VirtualBox

source: vbox/trunk/src/VBox/Devices/Graphics/DevVGA-SVGA.cpp@ 63839

Last change on this file since 63839 was 63690, checked in by vboxsync, 8 years ago

PCI,Devices: Changed range size in FNPCIIOREGIONMAP from uint32_t to RTGCPHYS.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 189.2 KB
Line 
1/* $Id: DevVGA-SVGA.cpp 63690 2016-09-02 12:15:07Z vboxsync $ */
2/** @file
3 * VMWare SVGA device.
4 *
5 * Logging levels guidelines for this and related files:
6 * - Log() for normal bits.
7 * - LogFlow() for more info.
8 * - Log2 for hex dump of cursor data.
9 * - Log3 for hex dump of shader code.
10 * - Log4 for hex dumps of 3D data.
11 */
12
13/*
14 * Copyright (C) 2013-2016 Oracle Corporation
15 *
16 * This file is part of VirtualBox Open Source Edition (OSE), as
17 * available from http://www.virtualbox.org. This file is free software;
18 * you can redistribute it and/or modify it under the terms of the GNU
19 * General Public License (GPL) as published by the Free Software
20 * Foundation, in version 2 as it comes in the "COPYING" file of the
21 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
22 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
23 */
24
25
26/*********************************************************************************************************************************
27* Header Files *
28*********************************************************************************************************************************/
29#define LOG_GROUP LOG_GROUP_DEV_VMSVGA
30#define VMSVGA_USE_EMT_HALT_CODE
31#include <VBox/vmm/pdmdev.h>
32#include <VBox/version.h>
33#include <VBox/err.h>
34#include <VBox/log.h>
35#include <VBox/vmm/pgm.h>
36#ifdef VMSVGA_USE_EMT_HALT_CODE
37# include <VBox/vmm/vmapi.h>
38# include <VBox/vmm/vmcpuset.h>
39#endif
40#include <VBox/sup.h>
41
42#include <iprt/assert.h>
43#include <iprt/semaphore.h>
44#include <iprt/uuid.h>
45#ifdef IN_RING3
46# include <iprt/ctype.h>
47# include <iprt/mem.h>
48#endif
49
50#include <VBox/VMMDev.h>
51#include <VBox/VBoxVideo.h>
52#include <VBox/bioslogo.h>
53
54/* should go BEFORE any other DevVGA include to make all DevVGA.h config defines be visible */
55#include "DevVGA.h"
56
57#ifdef DEBUG
58/* Enable to log FIFO register accesses. */
59//# define DEBUG_FIFO_ACCESS
60/* Enable to log GMR page accesses. */
61//# define DEBUG_GMR_ACCESS
62#endif
63
64#include "DevVGA-SVGA.h"
65#include "vmsvga/svga_reg.h"
66#include "vmsvga/svga_escape.h"
67#include "vmsvga/svga_overlay.h"
68#include "vmsvga/svga3d_reg.h"
69#include "vmsvga/svga3d_caps.h"
70#ifdef VBOX_WITH_VMSVGA3D
71# include "DevVGA-SVGA3d.h"
72# ifdef RT_OS_DARWIN
73# include "DevVGA-SVGA3d-cocoa.h"
74# endif
75#endif
76
77
78/*********************************************************************************************************************************
79* Defined Constants And Macros *
80*********************************************************************************************************************************/
81/**
82 * Macro for checking if a fixed FIFO register is valid according to the
83 * current FIFO configuration.
84 *
85 * @returns true / false.
86 * @param a_iIndex The fifo register index (like SVGA_FIFO_CAPABILITIES).
87 * @param a_offFifoMin A valid SVGA_FIFO_MIN value.
88 */
89#define VMSVGA_IS_VALID_FIFO_REG(a_iIndex, a_offFifoMin) ( ((a_iIndex) + 1) * sizeof(uint32_t) <= (a_offFifoMin) )
90
91
92/*********************************************************************************************************************************
93* Structures and Typedefs *
94*********************************************************************************************************************************/
95/**
96 * 64-bit GMR descriptor.
97 */
98typedef struct
99{
100 RTGCPHYS GCPhys;
101 uint64_t numPages;
102} VMSVGAGMRDESCRIPTOR, *PVMSVGAGMRDESCRIPTOR;
103
104/**
105 * GMR slot
106 */
107typedef struct
108{
109 uint32_t cMaxPages;
110 uint32_t cbTotal;
111 uint32_t numDescriptors;
112 PVMSVGAGMRDESCRIPTOR paDesc;
113} GMR, *PGMR;
114
115#ifdef IN_RING3
116/**
117 * Internal SVGA ring-3 only state.
118 */
119typedef struct VMSVGAR3STATE
120{
121 GMR aGMR[VMSVGA_MAX_GMR_IDS];
122 struct
123 {
124 SVGAGuestPtr ptr;
125 uint32_t bytesPerLine;
126 SVGAGMRImageFormat format;
127 } GMRFB;
128 struct
129 {
130 bool fActive;
131 uint32_t xHotspot;
132 uint32_t yHotspot;
133 uint32_t width;
134 uint32_t height;
135 uint32_t cbData;
136 void *pData;
137 } Cursor;
138 SVGAColorBGRX colorAnnotation;
139
140# ifdef VMSVGA_USE_EMT_HALT_CODE
141 /** Number of EMTs in BusyDelayedEmts (quicker than scanning the set). */
142 uint32_t volatile cBusyDelayedEmts;
143 /** Set of EMTs that are */
144 VMCPUSET BusyDelayedEmts;
145# else
146 /** Number of EMTs waiting on hBusyDelayedEmts. */
147 uint32_t volatile cBusyDelayedEmts;
148 /** Semaphore that EMTs wait on when reading SVGA_REG_BUSY and the FIFO is
149 * busy (ugly). */
150 RTSEMEVENTMULTI hBusyDelayedEmts;
151# endif
152 /** Tracks how much time we waste reading SVGA_REG_BUSY with a busy FIFO. */
153 STAMPROFILE StatBusyDelayEmts;
154
155 STAMPROFILE StatR3CmdPresent;
156 STAMPROFILE StatR3CmdDrawPrimitive;
157 STAMPROFILE StatR3CmdSurfaceDMA;
158
159 STAMCOUNTER StatFifoCommands;
160 STAMCOUNTER StatFifoErrors;
161 STAMCOUNTER StatFifoUnkCmds;
162 STAMCOUNTER StatFifoTodoTimeout;
163 STAMCOUNTER StatFifoTodoWoken;
164 STAMPROFILE StatFifoStalls;
165
166} VMSVGAR3STATE, *PVMSVGAR3STATE;
167#endif /* IN_RING3 */
168
169
170/*********************************************************************************************************************************
171* Internal Functions *
172*********************************************************************************************************************************/
173#ifdef IN_RING3
174# ifdef DEBUG_FIFO_ACCESS
175static FNPGMPHYSHANDLER vmsvgaR3FIFOAccessHandler;
176# endif
177# ifdef DEBUG_GMR_ACCESS
178static FNPGMPHYSHANDLER vmsvgaR3GMRAccessHandler;
179# endif
180#endif
181
182
183/*********************************************************************************************************************************
184* Global Variables *
185*********************************************************************************************************************************/
186#ifdef IN_RING3
187
188/**
189 * SSM descriptor table for the VMSVGAGMRDESCRIPTOR structure.
190 */
191static SSMFIELD const g_aVMSVGAGMRDESCRIPTORFields[] =
192{
193 SSMFIELD_ENTRY_GCPHYS( VMSVGAGMRDESCRIPTOR, GCPhys),
194 SSMFIELD_ENTRY( VMSVGAGMRDESCRIPTOR, numPages),
195 SSMFIELD_ENTRY_TERM()
196};
197
198/**
199 * SSM descriptor table for the GMR structure.
200 */
201static SSMFIELD const g_aGMRFields[] =
202{
203 SSMFIELD_ENTRY( GMR, cMaxPages),
204 SSMFIELD_ENTRY( GMR, cbTotal),
205 SSMFIELD_ENTRY( GMR, numDescriptors),
206 SSMFIELD_ENTRY_IGN_HCPTR( GMR, paDesc),
207 SSMFIELD_ENTRY_TERM()
208};
209
210/**
211 * SSM descriptor table for the VMSVGAR3STATE structure.
212 */
213static SSMFIELD const g_aVMSVGAR3STATEFields[] =
214{
215 SSMFIELD_ENTRY_IGNORE( VMSVGAR3STATE, aGMR),
216 SSMFIELD_ENTRY( VMSVGAR3STATE, GMRFB),
217 SSMFIELD_ENTRY( VMSVGAR3STATE, Cursor.fActive),
218 SSMFIELD_ENTRY( VMSVGAR3STATE, Cursor.xHotspot),
219 SSMFIELD_ENTRY( VMSVGAR3STATE, Cursor.yHotspot),
220 SSMFIELD_ENTRY( VMSVGAR3STATE, Cursor.width),
221 SSMFIELD_ENTRY( VMSVGAR3STATE, Cursor.height),
222 SSMFIELD_ENTRY( VMSVGAR3STATE, Cursor.cbData),
223 SSMFIELD_ENTRY_IGN_HCPTR( VMSVGAR3STATE, Cursor.pData),
224 SSMFIELD_ENTRY( VMSVGAR3STATE, colorAnnotation),
225 SSMFIELD_ENTRY_IGNORE( VMSVGAR3STATE, cBusyDelayedEmts),
226#ifdef VMSVGA_USE_EMT_HALT_CODE
227 SSMFIELD_ENTRY_IGNORE( VMSVGAR3STATE, BusyDelayedEmts),
228#else
229 SSMFIELD_ENTRY_IGNORE( VMSVGAR3STATE, hBusyDelayedEmts),
230#endif
231 SSMFIELD_ENTRY_IGNORE( VMSVGAR3STATE, StatBusyDelayEmts),
232 SSMFIELD_ENTRY_IGNORE( VMSVGAR3STATE, StatR3CmdPresent),
233 SSMFIELD_ENTRY_IGNORE( VMSVGAR3STATE, StatR3CmdDrawPrimitive),
234 SSMFIELD_ENTRY_IGNORE( VMSVGAR3STATE, StatR3CmdSurfaceDMA),
235 SSMFIELD_ENTRY_IGNORE( VMSVGAR3STATE, StatFifoCommands),
236 SSMFIELD_ENTRY_IGNORE( VMSVGAR3STATE, StatFifoErrors),
237 SSMFIELD_ENTRY_IGNORE( VMSVGAR3STATE, StatFifoUnkCmds),
238 SSMFIELD_ENTRY_IGNORE( VMSVGAR3STATE, StatFifoTodoTimeout),
239 SSMFIELD_ENTRY_IGNORE( VMSVGAR3STATE, StatFifoTodoWoken),
240 SSMFIELD_ENTRY_IGNORE( VMSVGAR3STATE, StatFifoStalls),
241 SSMFIELD_ENTRY_TERM()
242};
243
244/**
245 * SSM descriptor table for the VGAState.svga structure.
246 */
247static SSMFIELD const g_aVGAStateSVGAFields[] =
248{
249 SSMFIELD_ENTRY_IGNORE( VMSVGAState, u64HostWindowId),
250 SSMFIELD_ENTRY_IGN_HCPTR( VMSVGAState, pFIFOR3),
251 SSMFIELD_ENTRY_IGN_HCPTR( VMSVGAState, pFIFOR0),
252 SSMFIELD_ENTRY_IGN_HCPTR( VMSVGAState, pSvgaR3State),
253 SSMFIELD_ENTRY_IGN_HCPTR( VMSVGAState, p3dState),
254 SSMFIELD_ENTRY_IGN_HCPTR( VMSVGAState, pFrameBufferBackup),
255 SSMFIELD_ENTRY_IGN_HCPTR( VMSVGAState, pvFIFOExtCmdParam),
256 SSMFIELD_ENTRY_IGN_GCPHYS( VMSVGAState, GCPhysFIFO),
257 SSMFIELD_ENTRY_IGNORE( VMSVGAState, cbFIFO),
258 SSMFIELD_ENTRY( VMSVGAState, u32SVGAId),
259 SSMFIELD_ENTRY( VMSVGAState, fEnabled),
260 SSMFIELD_ENTRY( VMSVGAState, fConfigured),
261 SSMFIELD_ENTRY( VMSVGAState, fBusy),
262 SSMFIELD_ENTRY( VMSVGAState, fTraces),
263 SSMFIELD_ENTRY( VMSVGAState, u32GuestId),
264 SSMFIELD_ENTRY( VMSVGAState, cScratchRegion),
265 SSMFIELD_ENTRY( VMSVGAState, au32ScratchRegion),
266 SSMFIELD_ENTRY( VMSVGAState, u32IrqStatus),
267 SSMFIELD_ENTRY( VMSVGAState, u32IrqMask),
268 SSMFIELD_ENTRY( VMSVGAState, u32PitchLock),
269 SSMFIELD_ENTRY( VMSVGAState, u32CurrentGMRId),
270 SSMFIELD_ENTRY( VMSVGAState, u32RegCaps),
271 SSMFIELD_ENTRY_IGNORE( VMSVGAState, BasePort),
272 SSMFIELD_ENTRY( VMSVGAState, u32IndexReg),
273 SSMFIELD_ENTRY_IGNORE( VMSVGAState, pSupDrvSession),
274 SSMFIELD_ENTRY_IGNORE( VMSVGAState, FIFORequestSem),
275 SSMFIELD_ENTRY_IGNORE( VMSVGAState, FIFOExtCmdSem),
276 SSMFIELD_ENTRY_IGN_HCPTR( VMSVGAState, pFIFOIOThread),
277 SSMFIELD_ENTRY( VMSVGAState, uWidth),
278 SSMFIELD_ENTRY( VMSVGAState, uHeight),
279 SSMFIELD_ENTRY( VMSVGAState, uBpp),
280 SSMFIELD_ENTRY( VMSVGAState, cbScanline),
281 SSMFIELD_ENTRY( VMSVGAState, u32MaxWidth),
282 SSMFIELD_ENTRY( VMSVGAState, u32MaxHeight),
283 SSMFIELD_ENTRY( VMSVGAState, u32ActionFlags),
284 SSMFIELD_ENTRY( VMSVGAState, f3DEnabled),
285 SSMFIELD_ENTRY( VMSVGAState, fVRAMTracking),
286 SSMFIELD_ENTRY_IGNORE( VMSVGAState, u8FIFOExtCommand),
287 SSMFIELD_ENTRY_IGNORE( VMSVGAState, fFifoExtCommandWakeup),
288 SSMFIELD_ENTRY_TERM()
289};
290
291static void vmsvgaSetTraces(PVGASTATE pThis, bool fTraces);
292
293#endif /* IN_RING3 */
294
295#ifdef LOG_ENABLED
296
297/**
298 * Index register string name lookup
299 *
300 * @returns Index register string or "UNKNOWN"
301 * @param pThis VMSVGA State
302 */
303static const char *vmsvgaIndexToString(PVGASTATE pThis)
304{
305 switch (pThis->svga.u32IndexReg)
306 {
307 case SVGA_REG_ID:
308 return "SVGA_REG_ID";
309 case SVGA_REG_ENABLE:
310 return "SVGA_REG_ENABLE";
311 case SVGA_REG_WIDTH:
312 return "SVGA_REG_WIDTH";
313 case SVGA_REG_HEIGHT:
314 return "SVGA_REG_HEIGHT";
315 case SVGA_REG_MAX_WIDTH:
316 return "SVGA_REG_MAX_WIDTH";
317 case SVGA_REG_MAX_HEIGHT:
318 return "SVGA_REG_MAX_HEIGHT";
319 case SVGA_REG_DEPTH:
320 return "SVGA_REG_DEPTH";
321 case SVGA_REG_BITS_PER_PIXEL: /* Current bpp in the guest */
322 return "SVGA_REG_BITS_PER_PIXEL";
323 case SVGA_REG_HOST_BITS_PER_PIXEL: /* (Deprecated) */
324 return "SVGA_REG_HOST_BITS_PER_PIXEL";
325 case SVGA_REG_PSEUDOCOLOR:
326 return "SVGA_REG_PSEUDOCOLOR";
327 case SVGA_REG_RED_MASK:
328 return "SVGA_REG_RED_MASK";
329 case SVGA_REG_GREEN_MASK:
330 return "SVGA_REG_GREEN_MASK";
331 case SVGA_REG_BLUE_MASK:
332 return "SVGA_REG_BLUE_MASK";
333 case SVGA_REG_BYTES_PER_LINE:
334 return "SVGA_REG_BYTES_PER_LINE";
335 case SVGA_REG_VRAM_SIZE: /* VRAM size */
336 return "SVGA_REG_VRAM_SIZE";
337 case SVGA_REG_FB_START: /* Frame buffer physical address. */
338 return "SVGA_REG_FB_START";
339 case SVGA_REG_FB_OFFSET: /* Offset of the frame buffer in VRAM */
340 return "SVGA_REG_FB_OFFSET";
341 case SVGA_REG_FB_SIZE: /* Frame buffer size */
342 return "SVGA_REG_FB_SIZE";
343 case SVGA_REG_CAPABILITIES:
344 return "SVGA_REG_CAPABILITIES";
345 case SVGA_REG_MEM_START: /* FIFO start */
346 return "SVGA_REG_MEM_START";
347 case SVGA_REG_MEM_SIZE: /* FIFO size */
348 return "SVGA_REG_MEM_SIZE";
349 case SVGA_REG_CONFIG_DONE: /* Set when memory area configured */
350 return "SVGA_REG_CONFIG_DONE";
351 case SVGA_REG_SYNC: /* See "FIFO Synchronization Registers" */
352 return "SVGA_REG_SYNC";
353 case SVGA_REG_BUSY: /* See "FIFO Synchronization Registers" */
354 return "SVGA_REG_BUSY";
355 case SVGA_REG_GUEST_ID: /* Set guest OS identifier */
356 return "SVGA_REG_GUEST_ID";
357 case SVGA_REG_SCRATCH_SIZE: /* Number of scratch registers */
358 return "SVGA_REG_SCRATCH_SIZE";
359 case SVGA_REG_MEM_REGS: /* Number of FIFO registers */
360 return "SVGA_REG_MEM_REGS";
361 case SVGA_REG_PITCHLOCK: /* Fixed pitch for all modes */
362 return "SVGA_REG_PITCHLOCK";
363 case SVGA_REG_IRQMASK: /* Interrupt mask */
364 return "SVGA_REG_IRQMASK";
365 case SVGA_REG_GMR_ID:
366 return "SVGA_REG_GMR_ID";
367 case SVGA_REG_GMR_DESCRIPTOR:
368 return "SVGA_REG_GMR_DESCRIPTOR";
369 case SVGA_REG_GMR_MAX_IDS:
370 return "SVGA_REG_GMR_MAX_IDS";
371 case SVGA_REG_GMR_MAX_DESCRIPTOR_LENGTH:
372 return "SVGA_REG_GMR_MAX_DESCRIPTOR_LENGTH";
373 case SVGA_REG_TRACES: /* Enable trace-based updates even when FIFO is on */
374 return "SVGA_REG_TRACES";
375 case SVGA_REG_GMRS_MAX_PAGES: /* Maximum number of 4KB pages for all GMRs */
376 return "SVGA_REG_GMRS_MAX_PAGES";
377 case SVGA_REG_MEMORY_SIZE: /* Total dedicated device memory excluding FIFO */
378 return "SVGA_REG_MEMORY_SIZE";
379 case SVGA_REG_TOP: /* Must be 1 more than the last register */
380 return "SVGA_REG_TOP";
381 case SVGA_PALETTE_BASE: /* Base of SVGA color map */
382 return "SVGA_PALETTE_BASE";
383 case SVGA_REG_CURSOR_ID:
384 return "SVGA_REG_CURSOR_ID";
385 case SVGA_REG_CURSOR_X:
386 return "SVGA_REG_CURSOR_X";
387 case SVGA_REG_CURSOR_Y:
388 return "SVGA_REG_CURSOR_Y";
389 case SVGA_REG_CURSOR_ON:
390 return "SVGA_REG_CURSOR_ON";
391 case SVGA_REG_NUM_GUEST_DISPLAYS:/* Number of guest displays in X/Y direction */
392 return "SVGA_REG_NUM_GUEST_DISPLAYS";
393 case SVGA_REG_DISPLAY_ID: /* Display ID for the following display attributes */
394 return "SVGA_REG_DISPLAY_ID";
395 case SVGA_REG_DISPLAY_IS_PRIMARY:/* Whether this is a primary display */
396 return "SVGA_REG_DISPLAY_IS_PRIMARY";
397 case SVGA_REG_DISPLAY_POSITION_X:/* The display position x */
398 return "SVGA_REG_DISPLAY_POSITION_X";
399 case SVGA_REG_DISPLAY_POSITION_Y:/* The display position y */
400 return "SVGA_REG_DISPLAY_POSITION_Y";
401 case SVGA_REG_DISPLAY_WIDTH: /* The display's width */
402 return "SVGA_REG_DISPLAY_WIDTH";
403 case SVGA_REG_DISPLAY_HEIGHT: /* The display's height */
404 return "SVGA_REG_DISPLAY_HEIGHT";
405 case SVGA_REG_NUM_DISPLAYS: /* (Deprecated) */
406 return "SVGA_REG_NUM_DISPLAYS";
407
408 default:
409 if (pThis->svga.u32IndexReg - (uint32_t)SVGA_SCRATCH_BASE < pThis->svga.cScratchRegion)
410 return "SVGA_SCRATCH_BASE reg";
411 if (pThis->svga.u32IndexReg - (uint32_t)SVGA_PALETTE_BASE < (uint32_t)SVGA_NUM_PALETTE_REGS)
412 return "SVGA_PALETTE_BASE reg";
413 return "UNKNOWN";
414 }
415}
416
417#ifdef IN_RING3
418/**
419 * FIFO command name lookup
420 *
421 * @returns FIFO command string or "UNKNOWN"
422 * @param u32Cmd FIFO command
423 */
424static const char *vmsvgaFIFOCmdToString(uint32_t u32Cmd)
425{
426 switch (u32Cmd)
427 {
428 case SVGA_CMD_INVALID_CMD:
429 return "SVGA_CMD_INVALID_CMD";
430 case SVGA_CMD_UPDATE:
431 return "SVGA_CMD_UPDATE";
432 case SVGA_CMD_RECT_COPY:
433 return "SVGA_CMD_RECT_COPY";
434 case SVGA_CMD_DEFINE_CURSOR:
435 return "SVGA_CMD_DEFINE_CURSOR";
436 case SVGA_CMD_DEFINE_ALPHA_CURSOR:
437 return "SVGA_CMD_DEFINE_ALPHA_CURSOR";
438 case SVGA_CMD_UPDATE_VERBOSE:
439 return "SVGA_CMD_UPDATE_VERBOSE";
440 case SVGA_CMD_FRONT_ROP_FILL:
441 return "SVGA_CMD_FRONT_ROP_FILL";
442 case SVGA_CMD_FENCE:
443 return "SVGA_CMD_FENCE";
444 case SVGA_CMD_ESCAPE:
445 return "SVGA_CMD_ESCAPE";
446 case SVGA_CMD_DEFINE_SCREEN:
447 return "SVGA_CMD_DEFINE_SCREEN";
448 case SVGA_CMD_DESTROY_SCREEN:
449 return "SVGA_CMD_DESTROY_SCREEN";
450 case SVGA_CMD_DEFINE_GMRFB:
451 return "SVGA_CMD_DEFINE_GMRFB";
452 case SVGA_CMD_BLIT_GMRFB_TO_SCREEN:
453 return "SVGA_CMD_BLIT_GMRFB_TO_SCREEN";
454 case SVGA_CMD_BLIT_SCREEN_TO_GMRFB:
455 return "SVGA_CMD_BLIT_SCREEN_TO_GMRFB";
456 case SVGA_CMD_ANNOTATION_FILL:
457 return "SVGA_CMD_ANNOTATION_FILL";
458 case SVGA_CMD_ANNOTATION_COPY:
459 return "SVGA_CMD_ANNOTATION_COPY";
460 case SVGA_CMD_DEFINE_GMR2:
461 return "SVGA_CMD_DEFINE_GMR2";
462 case SVGA_CMD_REMAP_GMR2:
463 return "SVGA_CMD_REMAP_GMR2";
464 case SVGA_3D_CMD_SURFACE_DEFINE:
465 return "SVGA_3D_CMD_SURFACE_DEFINE";
466 case SVGA_3D_CMD_SURFACE_DESTROY:
467 return "SVGA_3D_CMD_SURFACE_DESTROY";
468 case SVGA_3D_CMD_SURFACE_COPY:
469 return "SVGA_3D_CMD_SURFACE_COPY";
470 case SVGA_3D_CMD_SURFACE_STRETCHBLT:
471 return "SVGA_3D_CMD_SURFACE_STRETCHBLT";
472 case SVGA_3D_CMD_SURFACE_DMA:
473 return "SVGA_3D_CMD_SURFACE_DMA";
474 case SVGA_3D_CMD_CONTEXT_DEFINE:
475 return "SVGA_3D_CMD_CONTEXT_DEFINE";
476 case SVGA_3D_CMD_CONTEXT_DESTROY:
477 return "SVGA_3D_CMD_CONTEXT_DESTROY";
478 case SVGA_3D_CMD_SETTRANSFORM:
479 return "SVGA_3D_CMD_SETTRANSFORM";
480 case SVGA_3D_CMD_SETZRANGE:
481 return "SVGA_3D_CMD_SETZRANGE";
482 case SVGA_3D_CMD_SETRENDERSTATE:
483 return "SVGA_3D_CMD_SETRENDERSTATE";
484 case SVGA_3D_CMD_SETRENDERTARGET:
485 return "SVGA_3D_CMD_SETRENDERTARGET";
486 case SVGA_3D_CMD_SETTEXTURESTATE:
487 return "SVGA_3D_CMD_SETTEXTURESTATE";
488 case SVGA_3D_CMD_SETMATERIAL:
489 return "SVGA_3D_CMD_SETMATERIAL";
490 case SVGA_3D_CMD_SETLIGHTDATA:
491 return "SVGA_3D_CMD_SETLIGHTDATA";
492 case SVGA_3D_CMD_SETLIGHTENABLED:
493 return "SVGA_3D_CMD_SETLIGHTENABLED";
494 case SVGA_3D_CMD_SETVIEWPORT:
495 return "SVGA_3D_CMD_SETVIEWPORT";
496 case SVGA_3D_CMD_SETCLIPPLANE:
497 return "SVGA_3D_CMD_SETCLIPPLANE";
498 case SVGA_3D_CMD_CLEAR:
499 return "SVGA_3D_CMD_CLEAR";
500 case SVGA_3D_CMD_PRESENT:
501 return "SVGA_3D_CMD_PRESENT";
502 case SVGA_3D_CMD_SHADER_DEFINE:
503 return "SVGA_3D_CMD_SHADER_DEFINE";
504 case SVGA_3D_CMD_SHADER_DESTROY:
505 return "SVGA_3D_CMD_SHADER_DESTROY";
506 case SVGA_3D_CMD_SET_SHADER:
507 return "SVGA_3D_CMD_SET_SHADER";
508 case SVGA_3D_CMD_SET_SHADER_CONST:
509 return "SVGA_3D_CMD_SET_SHADER_CONST";
510 case SVGA_3D_CMD_DRAW_PRIMITIVES:
511 return "SVGA_3D_CMD_DRAW_PRIMITIVES";
512 case SVGA_3D_CMD_SETSCISSORRECT:
513 return "SVGA_3D_CMD_SETSCISSORRECT";
514 case SVGA_3D_CMD_BEGIN_QUERY:
515 return "SVGA_3D_CMD_BEGIN_QUERY";
516 case SVGA_3D_CMD_END_QUERY:
517 return "SVGA_3D_CMD_END_QUERY";
518 case SVGA_3D_CMD_WAIT_FOR_QUERY:
519 return "SVGA_3D_CMD_WAIT_FOR_QUERY";
520 case SVGA_3D_CMD_PRESENT_READBACK:
521 return "SVGA_3D_CMD_PRESENT_READBACK";
522 case SVGA_3D_CMD_BLIT_SURFACE_TO_SCREEN:
523 return "SVGA_3D_CMD_BLIT_SURFACE_TO_SCREEN";
524 case SVGA_3D_CMD_SURFACE_DEFINE_V2:
525 return "SVGA_3D_CMD_SURFACE_DEFINE_V2";
526 case SVGA_3D_CMD_GENERATE_MIPMAPS:
527 return "SVGA_3D_CMD_GENERATE_MIPMAPS";
528 case SVGA_3D_CMD_ACTIVATE_SURFACE:
529 return "SVGA_3D_CMD_ACTIVATE_SURFACE";
530 case SVGA_3D_CMD_DEACTIVATE_SURFACE:
531 return "SVGA_3D_CMD_DEACTIVATE_SURFACE";
532 default:
533 return "UNKNOWN";
534 }
535}
536# endif /* IN_RING3 */
537
538#endif /* LOG_ENABLED */
539
540#ifdef IN_RING3
541/**
542 * @interface_method_impl{PDMIDISPLAYPORT,pfnSetViewport}
543 */
544DECLCALLBACK(void) vmsvgaPortSetViewport(PPDMIDISPLAYPORT pInterface, uint32_t uScreenId, uint32_t x, uint32_t y, uint32_t cx, uint32_t cy)
545{
546 PVGASTATE pThis = RT_FROM_MEMBER(pInterface, VGASTATE, IPort);
547
548 Log(("vmsvgaPortSetViewPort: screen %d (%d,%d)(%d,%d)\n", uScreenId, x, y, cx, cy));
549 VMSVGAVIEWPORT const OldViewport = pThis->svga.viewport;
550
551 if (x < pThis->svga.uWidth)
552 {
553 pThis->svga.viewport.x = x;
554 pThis->svga.viewport.cx = RT_MIN(cx, pThis->svga.uWidth - x);
555 pThis->svga.viewport.xRight = x + pThis->svga.viewport.cx;
556 }
557 else
558 {
559 pThis->svga.viewport.x = pThis->svga.uWidth;
560 pThis->svga.viewport.cx = 0;
561 pThis->svga.viewport.xRight = pThis->svga.uWidth;
562 }
563 if (y < pThis->svga.uHeight)
564 {
565 pThis->svga.viewport.y = y;
566 pThis->svga.viewport.cy = RT_MIN(cy, pThis->svga.uHeight - y);
567 pThis->svga.viewport.yLowWC = pThis->svga.uHeight - y - pThis->svga.viewport.cy;
568 pThis->svga.viewport.yHighWC = pThis->svga.uHeight - y;
569 }
570 else
571 {
572 pThis->svga.viewport.y = pThis->svga.uHeight;
573 pThis->svga.viewport.cy = 0;
574 pThis->svga.viewport.yLowWC = 0;
575 pThis->svga.viewport.yHighWC = 0;
576 }
577
578# ifdef VBOX_WITH_VMSVGA3D
579 /*
580 * Now inform the 3D backend.
581 */
582 if (pThis->svga.f3DEnabled)
583 vmsvga3dUpdateHostScreenViewport(pThis, uScreenId, &OldViewport);
584# else
585 RT_NOREF(uScreenId, OldViewport);
586# endif
587}
588#endif /* IN_RING3 */
589
590/**
591 * Read port register
592 *
593 * @returns VBox status code.
594 * @param pThis VMSVGA State
595 * @param pu32 Where to store the read value
596 */
597PDMBOTHCBDECL(int) vmsvgaReadPort(PVGASTATE pThis, uint32_t *pu32)
598{
599 int rc = VINF_SUCCESS;
600
601 *pu32 = 0;
602 switch (pThis->svga.u32IndexReg)
603 {
604 case SVGA_REG_ID:
605 *pu32 = pThis->svga.u32SVGAId;
606 break;
607
608 case SVGA_REG_ENABLE:
609 *pu32 = pThis->svga.fEnabled;
610 break;
611
612 case SVGA_REG_WIDTH:
613 {
614 if ( pThis->svga.fEnabled
615 && pThis->svga.uWidth != VMSVGA_VAL_UNINITIALIZED)
616 {
617 *pu32 = pThis->svga.uWidth;
618 }
619 else
620 {
621#ifndef IN_RING3
622 rc = VINF_IOM_R3_IOPORT_READ;
623#else
624 *pu32 = pThis->pDrv->cx;
625#endif
626 }
627 break;
628 }
629
630 case SVGA_REG_HEIGHT:
631 {
632 if ( pThis->svga.fEnabled
633 && pThis->svga.uHeight != VMSVGA_VAL_UNINITIALIZED)
634 {
635 *pu32 = pThis->svga.uHeight;
636 }
637 else
638 {
639#ifndef IN_RING3
640 rc = VINF_IOM_R3_IOPORT_READ;
641#else
642 *pu32 = pThis->pDrv->cy;
643#endif
644 }
645 break;
646 }
647
648 case SVGA_REG_MAX_WIDTH:
649 *pu32 = pThis->svga.u32MaxWidth;
650 break;
651
652 case SVGA_REG_MAX_HEIGHT:
653 *pu32 = pThis->svga.u32MaxHeight;
654 break;
655
656 case SVGA_REG_DEPTH:
657 /* This returns the color depth of the current mode. */
658 switch (pThis->svga.uBpp)
659 {
660 case 15:
661 case 16:
662 case 24:
663 *pu32 = pThis->svga.uBpp;
664 break;
665
666 default:
667 case 32:
668 *pu32 = 24; /* The upper 8 bits are either alpha bits or not used. */
669 break;
670 }
671 break;
672
673 case SVGA_REG_HOST_BITS_PER_PIXEL: /* (Deprecated) */
674 if ( pThis->svga.fEnabled
675 && pThis->svga.uBpp != VMSVGA_VAL_UNINITIALIZED)
676 {
677 *pu32 = pThis->svga.uBpp;
678 }
679 else
680 {
681#ifndef IN_RING3
682 rc = VINF_IOM_R3_IOPORT_READ;
683#else
684 *pu32 = pThis->pDrv->cBits;
685#endif
686 }
687 break;
688
689 case SVGA_REG_BITS_PER_PIXEL: /* Current bpp in the guest */
690 if ( pThis->svga.fEnabled
691 && pThis->svga.uBpp != VMSVGA_VAL_UNINITIALIZED)
692 {
693 *pu32 = (pThis->svga.uBpp + 7) & ~7;
694 }
695 else
696 {
697#ifndef IN_RING3
698 rc = VINF_IOM_R3_IOPORT_READ;
699#else
700 *pu32 = (pThis->pDrv->cBits + 7) & ~7;
701#endif
702 }
703 break;
704
705 case SVGA_REG_PSEUDOCOLOR:
706 *pu32 = 0;
707 break;
708
709 case SVGA_REG_RED_MASK:
710 case SVGA_REG_GREEN_MASK:
711 case SVGA_REG_BLUE_MASK:
712 {
713 uint32_t uBpp;
714
715 if ( pThis->svga.fEnabled
716 && pThis->svga.uBpp != VMSVGA_VAL_UNINITIALIZED)
717 {
718 uBpp = pThis->svga.uBpp;
719 }
720 else
721 {
722#ifndef IN_RING3
723 rc = VINF_IOM_R3_IOPORT_READ;
724 break;
725#else
726 uBpp = pThis->pDrv->cBits;
727#endif
728 }
729 uint32_t u32RedMask, u32GreenMask, u32BlueMask;
730 switch (uBpp)
731 {
732 case 8:
733 u32RedMask = 0x07;
734 u32GreenMask = 0x38;
735 u32BlueMask = 0xc0;
736 break;
737
738 case 15:
739 u32RedMask = 0x0000001f;
740 u32GreenMask = 0x000003e0;
741 u32BlueMask = 0x00007c00;
742 break;
743
744 case 16:
745 u32RedMask = 0x0000001f;
746 u32GreenMask = 0x000007e0;
747 u32BlueMask = 0x0000f800;
748 break;
749
750 case 24:
751 case 32:
752 default:
753 u32RedMask = 0x00ff0000;
754 u32GreenMask = 0x0000ff00;
755 u32BlueMask = 0x000000ff;
756 break;
757 }
758 switch (pThis->svga.u32IndexReg)
759 {
760 case SVGA_REG_RED_MASK:
761 *pu32 = u32RedMask;
762 break;
763
764 case SVGA_REG_GREEN_MASK:
765 *pu32 = u32GreenMask;
766 break;
767
768 case SVGA_REG_BLUE_MASK:
769 *pu32 = u32BlueMask;
770 break;
771 }
772 break;
773 }
774
775 case SVGA_REG_BYTES_PER_LINE:
776 {
777 if ( pThis->svga.fEnabled
778 && pThis->svga.cbScanline)
779 {
780 *pu32 = pThis->svga.cbScanline;
781 }
782 else
783 {
784#ifndef IN_RING3
785 rc = VINF_IOM_R3_IOPORT_READ;
786#else
787 *pu32 = pThis->pDrv->cbScanline;
788#endif
789 }
790 break;
791 }
792
793 case SVGA_REG_VRAM_SIZE: /* VRAM size */
794 *pu32 = pThis->vram_size;
795 break;
796
797 case SVGA_REG_FB_START: /* Frame buffer physical address. */
798 Assert(pThis->GCPhysVRAM <= 0xffffffff);
799 *pu32 = pThis->GCPhysVRAM;
800 break;
801
802 case SVGA_REG_FB_OFFSET: /* Offset of the frame buffer in VRAM */
803 /* Always zero in our case. */
804 *pu32 = 0;
805 break;
806
807 case SVGA_REG_FB_SIZE: /* Frame buffer size */
808 {
809#ifndef IN_RING3
810 rc = VINF_IOM_R3_IOPORT_READ;
811#else
812 /* VMWare testcases want at least 4 MB in case the hardware is disabled. */
813 if ( pThis->svga.fEnabled
814 && pThis->svga.uHeight != VMSVGA_VAL_UNINITIALIZED)
815 {
816 /* Hardware enabled; return real framebuffer size .*/
817 *pu32 = (uint32_t)pThis->svga.uHeight * pThis->svga.cbScanline;
818 }
819 else
820 *pu32 = RT_MAX(0x100000, (uint32_t)pThis->pDrv->cy * pThis->pDrv->cbScanline);
821
822 *pu32 = RT_MIN(pThis->vram_size, *pu32);
823 Log(("h=%d w=%d bpp=%d\n", pThis->pDrv->cy, pThis->pDrv->cx, pThis->pDrv->cBits));
824#endif
825 break;
826 }
827
828 case SVGA_REG_CAPABILITIES:
829 *pu32 = pThis->svga.u32RegCaps;
830 break;
831
832 case SVGA_REG_MEM_START: /* FIFO start */
833 Assert(pThis->svga.GCPhysFIFO <= 0xffffffff);
834 *pu32 = pThis->svga.GCPhysFIFO;
835 break;
836
837 case SVGA_REG_MEM_SIZE: /* FIFO size */
838 *pu32 = pThis->svga.cbFIFO;
839 break;
840
841 case SVGA_REG_CONFIG_DONE: /* Set when memory area configured */
842 *pu32 = pThis->svga.fConfigured;
843 break;
844
845 case SVGA_REG_SYNC: /* See "FIFO Synchronization Registers" */
846 *pu32 = 0;
847 break;
848
849 case SVGA_REG_BUSY: /* See "FIFO Synchronization Registers" */
850 if (pThis->svga.fBusy)
851 {
852#ifndef IN_RING3
853 /* Go to ring-3 and halt the CPU. */
854 rc = VINF_IOM_R3_IOPORT_READ;
855 break;
856#else
857# if defined(VMSVGA_USE_EMT_HALT_CODE)
858 /* The guest is basically doing a HLT via the device here, but with
859 a special wake up condition on FIFO completion. */
860 PVMSVGAR3STATE pSVGAState = pThis->svga.pSvgaR3State;
861 STAM_REL_PROFILE_START(&pSVGAState->StatBusyDelayEmts, EmtDelay);
862 PVM pVM = PDMDevHlpGetVM(pThis->pDevInsR3);
863 VMCPUID idCpu = PDMDevHlpGetCurrentCpuId(pThis->pDevInsR3);
864 VMCPUSET_ATOMIC_ADD(&pSVGAState->BusyDelayedEmts, idCpu);
865 ASMAtomicIncU32(&pSVGAState->cBusyDelayedEmts);
866 if (pThis->svga.fBusy)
867 rc = VMR3WaitForDeviceReady(pVM, idCpu);
868 ASMAtomicDecU32(&pSVGAState->cBusyDelayedEmts);
869 VMCPUSET_ATOMIC_DEL(&pSVGAState->BusyDelayedEmts, idCpu);
870# else
871
872 /* Delay the EMT a bit so the FIFO and others can get some work done.
873 This used to be a crude 50 ms sleep. The current code tries to be
874 more efficient, but the consept is still very crude. */
875 PVMSVGAR3STATE pSVGAState = pThis->svga.pSvgaR3State;
876 STAM_REL_PROFILE_START(&pSVGAState->StatBusyDelayEmts, EmtDelay);
877 RTThreadYield();
878 if (pThis->svga.fBusy)
879 {
880 uint32_t cRefs = ASMAtomicIncU32(&pSVGAState->cBusyDelayedEmts);
881
882 if (pThis->svga.fBusy && cRefs == 1)
883 RTSemEventMultiReset(pSVGAState->hBusyDelayedEmts);
884 if (pThis->svga.fBusy)
885 {
886 /** @todo If this code is going to stay, we need to call into the halt/wait
887 * code in VMEmt.cpp here, otherwise all kind of EMT interaction will
888 * suffer when the guest is polling on a busy FIFO. */
889 uint64_t cNsMaxWait = TMVirtualSyncGetNsToDeadline(PDMDevHlpGetVM(pThis->pDevInsR3));
890 if (cNsMaxWait >= RT_NS_100US)
891 RTSemEventMultiWaitEx(pSVGAState->hBusyDelayedEmts,
892 RTSEMWAIT_FLAGS_NANOSECS | RTSEMWAIT_FLAGS_RELATIVE | RTSEMWAIT_FLAGS_NORESUME,
893 RT_MIN(cNsMaxWait, RT_NS_10MS));
894 }
895
896 ASMAtomicDecU32(&pSVGAState->cBusyDelayedEmts);
897 }
898 STAM_REL_PROFILE_STOP(&pSVGAState->StatBusyDelayEmts, EmtDelay);
899# endif
900 *pu32 = pThis->svga.fBusy != 0;
901#endif
902 }
903 else
904 *pu32 = false;
905 break;
906
907 case SVGA_REG_GUEST_ID: /* Set guest OS identifier */
908 *pu32 = pThis->svga.u32GuestId;
909 break;
910
911 case SVGA_REG_SCRATCH_SIZE: /* Number of scratch registers */
912 *pu32 = pThis->svga.cScratchRegion;
913 break;
914
915 case SVGA_REG_MEM_REGS: /* Number of FIFO registers */
916 *pu32 = SVGA_FIFO_NUM_REGS;
917 break;
918
919 case SVGA_REG_PITCHLOCK: /* Fixed pitch for all modes */
920 *pu32 = pThis->svga.u32PitchLock;
921 break;
922
923 case SVGA_REG_IRQMASK: /* Interrupt mask */
924 *pu32 = pThis->svga.u32IrqMask;
925 break;
926
927 /* See "Guest memory regions" below. */
928 case SVGA_REG_GMR_ID:
929 *pu32 = pThis->svga.u32CurrentGMRId;
930 break;
931
932 case SVGA_REG_GMR_DESCRIPTOR:
933 /* Write only */
934 *pu32 = 0;
935 break;
936
937 case SVGA_REG_GMR_MAX_IDS:
938 *pu32 = VMSVGA_MAX_GMR_IDS;
939 break;
940
941 case SVGA_REG_GMR_MAX_DESCRIPTOR_LENGTH:
942 *pu32 = VMSVGA_MAX_GMR_PAGES;
943 break;
944
945 case SVGA_REG_TRACES: /* Enable trace-based updates even when FIFO is on */
946 *pu32 = pThis->svga.fTraces;
947 break;
948
949 case SVGA_REG_GMRS_MAX_PAGES: /* Maximum number of 4KB pages for all GMRs */
950 *pu32 = VMSVGA_MAX_GMR_PAGES;
951 break;
952
953 case SVGA_REG_MEMORY_SIZE: /* Total dedicated device memory excluding FIFO */
954 *pu32 = VMSVGA_SURFACE_SIZE;
955 break;
956
957 case SVGA_REG_TOP: /* Must be 1 more than the last register */
958 break;
959
960 case SVGA_PALETTE_BASE: /* Base of SVGA color map */
961 break;
962 /* Next 768 (== 256*3) registers exist for colormap */
963
964 /* Mouse cursor support. */
965 case SVGA_REG_CURSOR_ID:
966 case SVGA_REG_CURSOR_X:
967 case SVGA_REG_CURSOR_Y:
968 case SVGA_REG_CURSOR_ON:
969 break;
970
971 /* Legacy multi-monitor support */
972 case SVGA_REG_NUM_GUEST_DISPLAYS:/* Number of guest displays in X/Y direction */
973 *pu32 = 1;
974 break;
975
976 case SVGA_REG_DISPLAY_ID: /* Display ID for the following display attributes */
977 case SVGA_REG_DISPLAY_IS_PRIMARY:/* Whether this is a primary display */
978 case SVGA_REG_DISPLAY_POSITION_X:/* The display position x */
979 case SVGA_REG_DISPLAY_POSITION_Y:/* The display position y */
980 *pu32 = 0;
981 break;
982
983 case SVGA_REG_DISPLAY_WIDTH: /* The display's width */
984 *pu32 = pThis->svga.uWidth;
985 break;
986
987 case SVGA_REG_DISPLAY_HEIGHT: /* The display's height */
988 *pu32 = pThis->svga.uHeight;
989 break;
990
991 case SVGA_REG_NUM_DISPLAYS: /* (Deprecated) */
992 *pu32 = 1; /* Must return something sensible here otherwise the Linux driver will take a legacy code path without 3d support. */
993 break;
994
995 default:
996 if ( pThis->svga.u32IndexReg >= SVGA_SCRATCH_BASE
997 && pThis->svga.u32IndexReg < SVGA_SCRATCH_BASE + pThis->svga.cScratchRegion)
998 {
999 *pu32 = pThis->svga.au32ScratchRegion[pThis->svga.u32IndexReg - SVGA_SCRATCH_BASE];
1000 }
1001 break;
1002 }
1003 Log(("vmsvgaReadPort index=%s (%d) val=%#x rc=%x\n", vmsvgaIndexToString(pThis), pThis->svga.u32IndexReg, *pu32, rc));
1004 return rc;
1005}
1006
1007#ifdef IN_RING3
1008/**
1009 * Apply the current resolution settings to change the video mode.
1010 *
1011 * @returns VBox status code.
1012 * @param pThis VMSVGA State
1013 */
1014int vmsvgaChangeMode(PVGASTATE pThis)
1015{
1016 int rc;
1017
1018 if ( pThis->svga.uWidth == VMSVGA_VAL_UNINITIALIZED
1019 || pThis->svga.uHeight == VMSVGA_VAL_UNINITIALIZED
1020 || pThis->svga.uBpp == VMSVGA_VAL_UNINITIALIZED)
1021 {
1022 /* Mode change in progress; wait for all values to be set. */
1023 Log(("vmsvgaChangeMode: BOGUS sEnable LFB mode and resize to (%d,%d) bpp=%d\n", pThis->svga.uWidth, pThis->svga.uHeight, pThis->svga.uBpp));
1024 return VINF_SUCCESS;
1025 }
1026
1027 if ( pThis->svga.uWidth == 0
1028 || pThis->svga.uHeight == 0
1029 || pThis->svga.uBpp == 0)
1030 {
1031 /* Invalid mode change - BB does this early in the boot up. */
1032 Log(("vmsvgaChangeMode: BOGUS sEnable LFB mode and resize to (%d,%d) bpp=%d\n", pThis->svga.uWidth, pThis->svga.uHeight, pThis->svga.uBpp));
1033 return VINF_SUCCESS;
1034 }
1035
1036 if ( pThis->last_bpp == (unsigned)pThis->svga.uBpp
1037 && pThis->last_scr_width == (unsigned)pThis->svga.uWidth
1038 && pThis->last_scr_height == (unsigned)pThis->svga.uHeight
1039 && pThis->last_width == (unsigned)pThis->svga.uWidth
1040 && pThis->last_height == (unsigned)pThis->svga.uHeight
1041 )
1042 {
1043 /* Nothing to do. */
1044 Log(("vmsvgaChangeMode: nothing changed; ignore\n"));
1045 return VINF_SUCCESS;
1046 }
1047
1048 Log(("vmsvgaChangeMode: sEnable LFB mode and resize to (%d,%d) bpp=%d\n", pThis->svga.uWidth, pThis->svga.uHeight, pThis->svga.uBpp));
1049 pThis->svga.cbScanline = ((pThis->svga.uWidth * pThis->svga.uBpp + 7) & ~7) / 8;
1050
1051 pThis->pDrv->pfnLFBModeChange(pThis->pDrv, true);
1052 rc = pThis->pDrv->pfnResize(pThis->pDrv, pThis->svga.uBpp, pThis->CTX_SUFF(vram_ptr), pThis->svga.cbScanline, pThis->svga.uWidth, pThis->svga.uHeight);
1053 AssertRC(rc);
1054 AssertReturn(rc == VINF_SUCCESS || rc == VINF_VGA_RESIZE_IN_PROGRESS, rc);
1055
1056 /* last stuff */
1057 pThis->last_bpp = pThis->svga.uBpp;
1058 pThis->last_scr_width = pThis->svga.uWidth;
1059 pThis->last_scr_height = pThis->svga.uHeight;
1060 pThis->last_width = pThis->svga.uWidth;
1061 pThis->last_height = pThis->svga.uHeight;
1062
1063 ASMAtomicOrU32(&pThis->svga.u32ActionFlags, VMSVGA_ACTION_CHANGEMODE);
1064
1065 /* vmsvgaPortSetViewPort not called after state load; set sensible defaults. */
1066 if ( pThis->svga.viewport.cx == 0
1067 && pThis->svga.viewport.cy == 0)
1068 {
1069 pThis->svga.viewport.cx = pThis->svga.uWidth;
1070 pThis->svga.viewport.xRight = pThis->svga.uWidth;
1071 pThis->svga.viewport.cy = pThis->svga.uHeight;
1072 pThis->svga.viewport.yHighWC = pThis->svga.uHeight;
1073 pThis->svga.viewport.yLowWC = 0;
1074 }
1075 return VINF_SUCCESS;
1076}
1077#endif /* IN_RING3 */
1078
1079#if defined(IN_RING0) || defined(IN_RING3)
1080/**
1081 * Safely updates the SVGA_FIFO_BUSY register (in shared memory).
1082 *
1083 * @param pThis The VMSVGA state.
1084 * @param fState The busy state.
1085 */
1086DECLINLINE(void) vmsvgaSafeFifoBusyRegUpdate(PVGASTATE pThis, bool fState)
1087{
1088 ASMAtomicWriteU32(&pThis->svga.CTX_SUFF(pFIFO)[SVGA_FIFO_BUSY], fState);
1089
1090 if (RT_UNLIKELY(fState != (pThis->svga.fBusy != 0)))
1091 {
1092 /* Race / unfortunately scheduling. Highly unlikly. */
1093 uint32_t cLoops = 64;
1094 do
1095 {
1096 ASMNopPause();
1097 fState = (pThis->svga.fBusy != 0);
1098 ASMAtomicWriteU32(&pThis->svga.CTX_SUFF(pFIFO)[SVGA_FIFO_BUSY], fState != 0);
1099 } while (cLoops-- > 0 && fState != (pThis->svga.fBusy != 0));
1100 }
1101}
1102#endif
1103
1104/**
1105 * Write port register
1106 *
1107 * @returns VBox status code.
1108 * @param pThis VMSVGA State
1109 * @param u32 Value to write
1110 */
1111PDMBOTHCBDECL(int) vmsvgaWritePort(PVGASTATE pThis, uint32_t u32)
1112{
1113#if defined(IN_RING3) && defined(VBOX_WITH_VMSVGA3D)
1114 PVMSVGAR3STATE pSVGAState = pThis->svga.pSvgaR3State;
1115#endif
1116 int rc = VINF_SUCCESS;
1117
1118 Log(("vmsvgaWritePort index=%s (%d) val=%#x\n", vmsvgaIndexToString(pThis), pThis->svga.u32IndexReg, u32));
1119 switch (pThis->svga.u32IndexReg)
1120 {
1121 case SVGA_REG_ID:
1122 if ( u32 == SVGA_ID_0
1123 || u32 == SVGA_ID_1
1124 || u32 == SVGA_ID_2)
1125 pThis->svga.u32SVGAId = u32;
1126 break;
1127
1128 case SVGA_REG_ENABLE:
1129 if ( pThis->svga.fEnabled == u32
1130 && pThis->last_bpp == (unsigned)pThis->svga.uBpp
1131 && pThis->last_scr_width == (unsigned)pThis->svga.uWidth
1132 && pThis->last_scr_height == (unsigned)pThis->svga.uHeight
1133 && pThis->last_width == (unsigned)pThis->svga.uWidth
1134 && pThis->last_height == (unsigned)pThis->svga.uHeight
1135 )
1136 /* Nothing to do. */
1137 break;
1138
1139#ifdef IN_RING3
1140 if ( u32 == 1
1141 && pThis->svga.fEnabled == false)
1142 {
1143 /* Make a backup copy of the first 32k in order to save font data etc. */
1144 memcpy(pThis->svga.pFrameBufferBackup, pThis->vram_ptrR3, VMSVGA_FRAMEBUFFER_BACKUP_SIZE);
1145 }
1146
1147 pThis->svga.fEnabled = u32;
1148 if (pThis->svga.fEnabled)
1149 {
1150 if ( pThis->svga.uWidth == VMSVGA_VAL_UNINITIALIZED
1151 && pThis->svga.uHeight == VMSVGA_VAL_UNINITIALIZED
1152 && pThis->svga.uBpp == VMSVGA_VAL_UNINITIALIZED)
1153 {
1154 /* Keep the current mode. */
1155 pThis->svga.uWidth = pThis->pDrv->cx;
1156 pThis->svga.uHeight = pThis->pDrv->cy;
1157 pThis->svga.uBpp = (pThis->pDrv->cBits + 7) & ~7;
1158 }
1159
1160 if ( pThis->svga.uWidth != VMSVGA_VAL_UNINITIALIZED
1161 && pThis->svga.uHeight != VMSVGA_VAL_UNINITIALIZED
1162 && pThis->svga.uBpp != VMSVGA_VAL_UNINITIALIZED)
1163 {
1164 rc = vmsvgaChangeMode(pThis);
1165 AssertRCReturn(rc, rc);
1166 }
1167# ifdef LOG_ENABLED
1168 Log(("configured=%d busy=%d\n", pThis->svga.fConfigured, pThis->svga.pFIFOR3[SVGA_FIFO_BUSY]));
1169 uint32_t *pFIFO = pThis->svga.pFIFOR3;
1170 Log(("next %x stop %x\n", pFIFO[SVGA_FIFO_NEXT_CMD], pFIFO[SVGA_FIFO_STOP]));
1171# endif
1172
1173 /* Disable or enable dirty page tracking according to the current fTraces value. */
1174 vmsvgaSetTraces(pThis, !!pThis->svga.fTraces);
1175 }
1176 else
1177 {
1178 /* Restore the text mode backup. */
1179 memcpy(pThis->vram_ptrR3, pThis->svga.pFrameBufferBackup, VMSVGA_FRAMEBUFFER_BACKUP_SIZE);
1180
1181/* pThis->svga.uHeight = -1;
1182 pThis->svga.uWidth = -1;
1183 pThis->svga.uBpp = -1;
1184 pThis->svga.cbScanline = 0; */
1185 pThis->pDrv->pfnLFBModeChange(pThis->pDrv, false);
1186
1187 /* Enable dirty page tracking again when going into legacy mode. */
1188 vmsvgaSetTraces(pThis, true);
1189 }
1190#else
1191 rc = VINF_IOM_R3_IOPORT_WRITE;
1192#endif
1193 break;
1194
1195 case SVGA_REG_WIDTH:
1196 if (pThis->svga.uWidth != u32)
1197 {
1198 if (pThis->svga.fEnabled)
1199 {
1200#ifdef IN_RING3
1201 pThis->svga.uWidth = u32;
1202 rc = vmsvgaChangeMode(pThis);
1203 AssertRCReturn(rc, rc);
1204#else
1205 rc = VINF_IOM_R3_IOPORT_WRITE;
1206#endif
1207 }
1208 else
1209 pThis->svga.uWidth = u32;
1210 }
1211 /* else: nop */
1212 break;
1213
1214 case SVGA_REG_HEIGHT:
1215 if (pThis->svga.uHeight != u32)
1216 {
1217 if (pThis->svga.fEnabled)
1218 {
1219#ifdef IN_RING3
1220 pThis->svga.uHeight = u32;
1221 rc = vmsvgaChangeMode(pThis);
1222 AssertRCReturn(rc, rc);
1223#else
1224 rc = VINF_IOM_R3_IOPORT_WRITE;
1225#endif
1226 }
1227 else
1228 pThis->svga.uHeight = u32;
1229 }
1230 /* else: nop */
1231 break;
1232
1233 case SVGA_REG_DEPTH:
1234 /** @todo read-only?? */
1235 break;
1236
1237 case SVGA_REG_BITS_PER_PIXEL: /* Current bpp in the guest */
1238 if (pThis->svga.uBpp != u32)
1239 {
1240 if (pThis->svga.fEnabled)
1241 {
1242#ifdef IN_RING3
1243 pThis->svga.uBpp = u32;
1244 rc = vmsvgaChangeMode(pThis);
1245 AssertRCReturn(rc, rc);
1246#else
1247 rc = VINF_IOM_R3_IOPORT_WRITE;
1248#endif
1249 }
1250 else
1251 pThis->svga.uBpp = u32;
1252 }
1253 /* else: nop */
1254 break;
1255
1256 case SVGA_REG_PSEUDOCOLOR:
1257 break;
1258
1259 case SVGA_REG_CONFIG_DONE: /* Set when memory area configured */
1260#ifdef IN_RING3
1261 pThis->svga.fConfigured = u32;
1262 /* Disabling the FIFO enables tracing (dirty page detection) by default. */
1263 if (!pThis->svga.fConfigured)
1264 {
1265 pThis->svga.fTraces = true;
1266 }
1267 vmsvgaSetTraces(pThis, !!pThis->svga.fTraces);
1268#else
1269 rc = VINF_IOM_R3_IOPORT_WRITE;
1270#endif
1271 break;
1272
1273 case SVGA_REG_SYNC: /* See "FIFO Synchronization Registers" */
1274 if ( pThis->svga.fEnabled
1275 && pThis->svga.fConfigured)
1276 {
1277#if defined(IN_RING3) || defined(IN_RING0)
1278 Log(("SVGA_REG_SYNC: SVGA_FIFO_BUSY=%d\n", pThis->svga.CTX_SUFF(pFIFO)[SVGA_FIFO_BUSY]));
1279 ASMAtomicWriteU32(&pThis->svga.fBusy, VMSVGA_BUSY_F_EMT_FORCE | VMSVGA_BUSY_F_FIFO);
1280 if (VMSVGA_IS_VALID_FIFO_REG(SVGA_FIFO_BUSY, pThis->svga.CTX_SUFF(pFIFO)[SVGA_FIFO_MIN]))
1281 vmsvgaSafeFifoBusyRegUpdate(pThis, true);
1282
1283 /* Kick the FIFO thread to start processing commands again. */
1284 SUPSemEventSignal(pThis->svga.pSupDrvSession, pThis->svga.FIFORequestSem);
1285#else
1286 rc = VINF_IOM_R3_IOPORT_WRITE;
1287#endif
1288 }
1289 /* else nothing to do. */
1290 else
1291 Log(("Sync ignored enabled=%d configured=%d\n", pThis->svga.fEnabled, pThis->svga.fConfigured));
1292
1293 break;
1294
1295 case SVGA_REG_BUSY: /* See "FIFO Synchronization Registers" (read-only) */
1296 break;
1297
1298 case SVGA_REG_GUEST_ID: /* Set guest OS identifier */
1299 pThis->svga.u32GuestId = u32;
1300 break;
1301
1302 case SVGA_REG_PITCHLOCK: /* Fixed pitch for all modes */
1303 pThis->svga.u32PitchLock = u32;
1304 break;
1305
1306 case SVGA_REG_IRQMASK: /* Interrupt mask */
1307 pThis->svga.u32IrqMask = u32;
1308
1309 /* Irq pending after the above change? */
1310 if (pThis->svga.u32IrqStatus & u32)
1311 {
1312 Log(("SVGA_REG_IRQMASK: Trigger interrupt with status %x\n", pThis->svga.u32IrqStatus));
1313 PDMDevHlpPCISetIrqNoWait(pThis->CTX_SUFF(pDevIns), 0, 1);
1314 }
1315 else
1316 PDMDevHlpPCISetIrqNoWait(pThis->CTX_SUFF(pDevIns), 0, 0);
1317 break;
1318
1319 /* Mouse cursor support */
1320 case SVGA_REG_CURSOR_ID:
1321 case SVGA_REG_CURSOR_X:
1322 case SVGA_REG_CURSOR_Y:
1323 case SVGA_REG_CURSOR_ON:
1324 break;
1325
1326 /* Legacy multi-monitor support */
1327 case SVGA_REG_NUM_GUEST_DISPLAYS:/* Number of guest displays in X/Y direction */
1328 break;
1329 case SVGA_REG_DISPLAY_ID: /* Display ID for the following display attributes */
1330 break;
1331 case SVGA_REG_DISPLAY_IS_PRIMARY:/* Whether this is a primary display */
1332 break;
1333 case SVGA_REG_DISPLAY_POSITION_X:/* The display position x */
1334 break;
1335 case SVGA_REG_DISPLAY_POSITION_Y:/* The display position y */
1336 break;
1337 case SVGA_REG_DISPLAY_WIDTH: /* The display's width */
1338 break;
1339 case SVGA_REG_DISPLAY_HEIGHT: /* The display's height */
1340 break;
1341#ifdef VBOX_WITH_VMSVGA3D
1342 /* See "Guest memory regions" below. */
1343 case SVGA_REG_GMR_ID:
1344 pThis->svga.u32CurrentGMRId = u32;
1345 break;
1346
1347 case SVGA_REG_GMR_DESCRIPTOR:
1348# ifndef IN_RING3
1349 rc = VINF_IOM_R3_IOPORT_WRITE;
1350 break;
1351# else /* IN_RING3 */
1352 {
1353 SVGAGuestMemDescriptor desc;
1354 RTGCPHYS GCPhys = (RTGCPHYS)u32 << PAGE_SHIFT;
1355 RTGCPHYS GCPhysBase = GCPhys;
1356 uint32_t idGMR = pThis->svga.u32CurrentGMRId;
1357 uint32_t cDescriptorsAllocated = 16;
1358 uint32_t iDescriptor = 0;
1359
1360 /* Validate current GMR id. */
1361 AssertBreak(idGMR < VMSVGA_MAX_GMR_IDS);
1362
1363 /* Free the old GMR if present. */
1364 vmsvgaGMRFree(pThis, idGMR);
1365
1366 /* Just undefine the GMR? */
1367 if (GCPhys == 0)
1368 break;
1369
1370 pSVGAState->aGMR[idGMR].paDesc = (PVMSVGAGMRDESCRIPTOR)RTMemAllocZ(cDescriptorsAllocated * sizeof(VMSVGAGMRDESCRIPTOR));
1371 AssertReturn(pSVGAState->aGMR[idGMR].paDesc, VERR_NO_MEMORY);
1372
1373 /* Never cross a page boundary automatically. */
1374 while (PHYS_PAGE_ADDRESS(GCPhys) == PHYS_PAGE_ADDRESS(GCPhysBase))
1375 {
1376 /* Read descriptor. */
1377 rc = PDMDevHlpPhysRead(pThis->CTX_SUFF(pDevIns), GCPhys, &desc, sizeof(desc));
1378 AssertRCBreak(rc);
1379
1380 if ( desc.ppn == 0
1381 && desc.numPages == 0)
1382 break; /* terminator */
1383
1384 if ( desc.ppn != 0
1385 && desc.numPages == 0)
1386 {
1387 /* Pointer to the next physical page of descriptors. */
1388 GCPhys = GCPhysBase = (RTGCPHYS)desc.ppn << PAGE_SHIFT;
1389 }
1390 else
1391 {
1392 if (iDescriptor == cDescriptorsAllocated)
1393 {
1394 cDescriptorsAllocated += 16;
1395 pSVGAState->aGMR[idGMR].paDesc = (PVMSVGAGMRDESCRIPTOR)RTMemRealloc(pSVGAState->aGMR[idGMR].paDesc, cDescriptorsAllocated * sizeof(VMSVGAGMRDESCRIPTOR));
1396 AssertReturn(pSVGAState->aGMR[idGMR].paDesc, VERR_NO_MEMORY);
1397 }
1398
1399 pSVGAState->aGMR[idGMR].paDesc[iDescriptor].GCPhys = (RTGCPHYS)desc.ppn << PAGE_SHIFT;
1400 pSVGAState->aGMR[idGMR].paDesc[iDescriptor++].numPages = desc.numPages;
1401 pSVGAState->aGMR[idGMR].cbTotal += desc.numPages * PAGE_SIZE;
1402
1403 /* Continue with the next descriptor. */
1404 GCPhys += sizeof(desc);
1405 }
1406 }
1407 pSVGAState->aGMR[idGMR].numDescriptors = iDescriptor;
1408 Log(("Defined new gmr %x numDescriptors=%d cbTotal=%x\n", idGMR, iDescriptor, pSVGAState->aGMR[idGMR].cbTotal));
1409
1410 if (!pSVGAState->aGMR[idGMR].numDescriptors)
1411 {
1412 AssertFailed();
1413 RTMemFree(pSVGAState->aGMR[idGMR].paDesc);
1414 pSVGAState->aGMR[idGMR].paDesc = NULL;
1415 }
1416 AssertRC(rc);
1417 break;
1418 }
1419# endif /* IN_RING3 */
1420#endif // VBOX_WITH_VMSVGA3D
1421
1422 case SVGA_REG_TRACES: /* Enable trace-based updates even when FIFO is on */
1423 if (pThis->svga.fTraces == u32)
1424 break; /* nothing to do */
1425
1426#ifdef IN_RING3
1427 vmsvgaSetTraces(pThis, !!u32);
1428#else
1429 rc = VINF_IOM_R3_IOPORT_WRITE;
1430#endif
1431 break;
1432
1433 case SVGA_REG_TOP: /* Must be 1 more than the last register */
1434 break;
1435
1436 case SVGA_PALETTE_BASE: /* Base of SVGA color map */
1437 break;
1438 /* Next 768 (== 256*3) registers exist for colormap */
1439
1440 case SVGA_REG_NUM_DISPLAYS: /* (Deprecated) */
1441 Log(("Write to deprecated register %x - val %x ignored\n", pThis->svga.u32IndexReg, u32));
1442 break;
1443
1444 case SVGA_REG_FB_START:
1445 case SVGA_REG_MEM_START:
1446 case SVGA_REG_HOST_BITS_PER_PIXEL:
1447 case SVGA_REG_MAX_WIDTH:
1448 case SVGA_REG_MAX_HEIGHT:
1449 case SVGA_REG_VRAM_SIZE:
1450 case SVGA_REG_FB_SIZE:
1451 case SVGA_REG_CAPABILITIES:
1452 case SVGA_REG_MEM_SIZE:
1453 case SVGA_REG_SCRATCH_SIZE: /* Number of scratch registers */
1454 case SVGA_REG_MEM_REGS: /* Number of FIFO registers */
1455 case SVGA_REG_BYTES_PER_LINE:
1456 case SVGA_REG_FB_OFFSET:
1457 case SVGA_REG_RED_MASK:
1458 case SVGA_REG_GREEN_MASK:
1459 case SVGA_REG_BLUE_MASK:
1460 case SVGA_REG_GMRS_MAX_PAGES: /* Maximum number of 4KB pages for all GMRs */
1461 case SVGA_REG_MEMORY_SIZE: /* Total dedicated device memory excluding FIFO */
1462 case SVGA_REG_GMR_MAX_IDS:
1463 case SVGA_REG_GMR_MAX_DESCRIPTOR_LENGTH:
1464 /* Read only - ignore. */
1465 Log(("Write to R/O register %x - val %x ignored\n", pThis->svga.u32IndexReg, u32));
1466 break;
1467
1468 default:
1469 if ( pThis->svga.u32IndexReg >= SVGA_SCRATCH_BASE
1470 && pThis->svga.u32IndexReg < SVGA_SCRATCH_BASE + pThis->svga.cScratchRegion)
1471 {
1472 pThis->svga.au32ScratchRegion[pThis->svga.u32IndexReg - SVGA_SCRATCH_BASE] = u32;
1473 }
1474 break;
1475 }
1476 return rc;
1477}
1478
1479/**
1480 * Port I/O Handler for IN operations.
1481 *
1482 * @returns VINF_SUCCESS or VINF_EM_*.
1483 * @returns VERR_IOM_IOPORT_UNUSED if the port is really unused and a ~0 value should be returned.
1484 *
1485 * @param pDevIns The device instance.
1486 * @param pvUser User argument.
1487 * @param uPort Port number used for the IN operation.
1488 * @param pu32 Where to store the result. This is always a 32-bit
1489 * variable regardless of what @a cb might say.
1490 * @param cb Number of bytes read.
1491 */
1492PDMBOTHCBDECL(int) vmsvgaIORead(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t *pu32, unsigned cb)
1493{
1494 PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
1495 RT_NOREF_PV(pvUser);
1496
1497 /* Ignore non-dword accesses. */
1498 if (cb != 4)
1499 {
1500 Log(("Ignoring non-dword read at %x cb=%d\n", Port, cb));
1501 *pu32 = UINT32_MAX;
1502 return VINF_SUCCESS;
1503 }
1504
1505 switch (Port - pThis->svga.BasePort)
1506 {
1507 case SVGA_INDEX_PORT:
1508 *pu32 = pThis->svga.u32IndexReg;
1509 break;
1510
1511 case SVGA_VALUE_PORT:
1512 return vmsvgaReadPort(pThis, pu32);
1513
1514 case SVGA_BIOS_PORT:
1515 Log(("Ignoring BIOS port read\n"));
1516 *pu32 = 0;
1517 break;
1518
1519 case SVGA_IRQSTATUS_PORT:
1520 LogFlow(("vmsvgaIORead: SVGA_IRQSTATUS_PORT %x\n", pThis->svga.u32IrqStatus));
1521 *pu32 = pThis->svga.u32IrqStatus;
1522 break;
1523 }
1524
1525 return VINF_SUCCESS;
1526}
1527
1528/**
1529 * Port I/O Handler for OUT operations.
1530 *
1531 * @returns VINF_SUCCESS or VINF_EM_*.
1532 *
1533 * @param pDevIns The device instance.
1534 * @param pvUser User argument.
1535 * @param uPort Port number used for the OUT operation.
1536 * @param u32 The value to output.
1537 * @param cb The value size in bytes.
1538 */
1539PDMBOTHCBDECL(int) vmsvgaIOWrite(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
1540{
1541 PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
1542 RT_NOREF_PV(pvUser);
1543
1544 /* Ignore non-dword accesses. */
1545 if (cb != 4)
1546 {
1547 Log(("Ignoring non-dword write at %x val=%x cb=%d\n", Port, u32, cb));
1548 return VINF_SUCCESS;
1549 }
1550
1551 switch (Port - pThis->svga.BasePort)
1552 {
1553 case SVGA_INDEX_PORT:
1554 pThis->svga.u32IndexReg = u32;
1555 break;
1556
1557 case SVGA_VALUE_PORT:
1558 return vmsvgaWritePort(pThis, u32);
1559
1560 case SVGA_BIOS_PORT:
1561 Log(("Ignoring BIOS port write (val=%x)\n", u32));
1562 break;
1563
1564 case SVGA_IRQSTATUS_PORT:
1565 Log(("vmsvgaIOWrite SVGA_IRQSTATUS_PORT %x: status %x -> %x\n", u32, pThis->svga.u32IrqStatus, pThis->svga.u32IrqStatus & ~u32));
1566 ASMAtomicAndU32(&pThis->svga.u32IrqStatus, ~u32);
1567 /* Clear the irq in case all events have been cleared. */
1568 if (!(pThis->svga.u32IrqStatus & pThis->svga.u32IrqMask))
1569 {
1570 Log(("vmsvgaIOWrite SVGA_IRQSTATUS_PORT: clearing IRQ\n"));
1571 PDMDevHlpPCISetIrqNoWait(pDevIns, 0, 0);
1572 }
1573 break;
1574 }
1575 return VINF_SUCCESS;
1576}
1577
1578#ifdef DEBUG_FIFO_ACCESS
1579
1580# ifdef IN_RING3
1581/**
1582 * Handle LFB access.
1583 * @returns VBox status code.
1584 * @param pVM VM handle.
1585 * @param pThis VGA device instance data.
1586 * @param GCPhys The access physical address.
1587 * @param fWriteAccess Read or write access
1588 */
1589static int vmsvgaFIFOAccess(PVM pVM, PVGASTATE pThis, RTGCPHYS GCPhys, bool fWriteAccess)
1590{
1591 RTGCPHYS GCPhysOffset = GCPhys - pThis->svga.GCPhysFIFO;
1592 uint32_t *pFIFO = pThis->svga.pFIFOR3;
1593
1594 switch (GCPhysOffset >> 2)
1595 {
1596 case SVGA_FIFO_MIN:
1597 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_MIN = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1598 break;
1599 case SVGA_FIFO_MAX:
1600 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_MAX = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1601 break;
1602 case SVGA_FIFO_NEXT_CMD:
1603 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_NEXT_CMD = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1604 break;
1605 case SVGA_FIFO_STOP:
1606 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_STOP = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1607 break;
1608 case SVGA_FIFO_CAPABILITIES:
1609 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_CAPABILITIES = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1610 break;
1611 case SVGA_FIFO_FLAGS:
1612 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_FLAGS = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1613 break;
1614 case SVGA_FIFO_FENCE:
1615 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_FENCE = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1616 break;
1617 case SVGA_FIFO_3D_HWVERSION:
1618 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_HWVERSION = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1619 break;
1620 case SVGA_FIFO_PITCHLOCK:
1621 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_PITCHLOCK = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1622 break;
1623 case SVGA_FIFO_CURSOR_ON:
1624 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_CURSOR_ON = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1625 break;
1626 case SVGA_FIFO_CURSOR_X:
1627 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_CURSOR_X = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1628 break;
1629 case SVGA_FIFO_CURSOR_Y:
1630 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_CURSOR_Y = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1631 break;
1632 case SVGA_FIFO_CURSOR_COUNT:
1633 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_CURSOR_COUNT = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1634 break;
1635 case SVGA_FIFO_CURSOR_LAST_UPDATED:
1636 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_CURSOR_LAST_UPDATED = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1637 break;
1638 case SVGA_FIFO_RESERVED:
1639 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_RESERVED = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1640 break;
1641 case SVGA_FIFO_CURSOR_SCREEN_ID:
1642 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_CURSOR_SCREEN_ID = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1643 break;
1644 case SVGA_FIFO_DEAD:
1645 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_DEAD = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1646 break;
1647 case SVGA_FIFO_3D_HWVERSION_REVISED:
1648 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_HWVERSION_REVISED = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1649 break;
1650 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_3D:
1651 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_3D = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1652 break;
1653 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_MAX_LIGHTS:
1654 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_MAX_LIGHTS = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1655 break;
1656 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_MAX_TEXTURES:
1657 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_MAX_TEXTURES = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1658 break;
1659 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_MAX_CLIP_PLANES:
1660 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_MAX_CLIP_PLANES = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1661 break;
1662 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_VERTEX_SHADER_VERSION:
1663 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_VERTEX_SHADER_VERSION = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1664 break;
1665 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_VERTEX_SHADER:
1666 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_VERTEX_SHADER = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1667 break;
1668 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_FRAGMENT_SHADER_VERSION:
1669 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_FRAGMENT_SHADER_VERSION = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1670 break;
1671 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_FRAGMENT_SHADER:
1672 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_FRAGMENT_SHADER = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1673 break;
1674 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_MAX_RENDER_TARGETS:
1675 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_MAX_RENDER_TARGETS = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1676 break;
1677 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_S23E8_TEXTURES:
1678 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_S23E8_TEXTURES = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1679 break;
1680 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_S10E5_TEXTURES:
1681 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_S10E5_TEXTURES = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1682 break;
1683 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_MAX_FIXED_VERTEXBLEND:
1684 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_MAX_FIXED_VERTEXBLEND = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1685 break;
1686 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_D16_BUFFER_FORMAT:
1687 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_D16_BUFFER_FORMAT = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1688 break;
1689 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_D24S8_BUFFER_FORMAT:
1690 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_D24S8_BUFFER_FORMAT = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1691 break;
1692 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_D24X8_BUFFER_FORMAT:
1693 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_D24X8_BUFFER_FORMAT = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1694 break;
1695 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_QUERY_TYPES:
1696 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_QUERY_TYPES = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1697 break;
1698 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_TEXTURE_GRADIENT_SAMPLING:
1699 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_TEXTURE_GRADIENT_SAMPLING = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1700 break;
1701 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_MAX_POINT_SIZE:
1702 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_MAX_POINT_SIZE = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1703 break;
1704 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_MAX_SHADER_TEXTURES:
1705 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_MAX_SHADER_TEXTURES = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1706 break;
1707 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_MAX_TEXTURE_WIDTH:
1708 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_MAX_TEXTURE_WIDTH = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1709 break;
1710 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_MAX_TEXTURE_HEIGHT:
1711 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_MAX_TEXTURE_HEIGHT = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1712 break;
1713 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_MAX_VOLUME_EXTENT:
1714 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_MAX_VOLUME_EXTENT = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1715 break;
1716 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_MAX_TEXTURE_REPEAT:
1717 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_MAX_TEXTURE_REPEAT = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1718 break;
1719 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_MAX_TEXTURE_ASPECT_RATIO:
1720 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_MAX_TEXTURE_ASPECT_RATIO = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1721 break;
1722 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_MAX_TEXTURE_ANISOTROPY:
1723 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_MAX_TEXTURE_ANISOTROPY = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1724 break;
1725 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_MAX_PRIMITIVE_COUNT:
1726 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_MAX_PRIMITIVE_COUNT = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1727 break;
1728 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_MAX_VERTEX_INDEX:
1729 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_MAX_VERTEX_INDEX = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1730 break;
1731 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_MAX_VERTEX_SHADER_INSTRUCTIONS:
1732 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_MAX_VERTEX_SHADER_INSTRUCTIONS = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1733 break;
1734 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_MAX_FRAGMENT_SHADER_INSTRUCTIONS:
1735 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_MAX_FRAGMENT_SHADER_INSTRUCTIONS = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1736 break;
1737 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_MAX_VERTEX_SHADER_TEMPS:
1738 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_MAX_VERTEX_SHADER_TEMPS = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1739 break;
1740 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_MAX_FRAGMENT_SHADER_TEMPS:
1741 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_MAX_FRAGMENT_SHADER_TEMPS = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1742 break;
1743 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_TEXTURE_OPS:
1744 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_TEXTURE_OPS = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1745 break;
1746 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_SURFACEFMT_X8R8G8B8:
1747 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_SURFACEFMT_X8R8G8B8 = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1748 break;
1749 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_SURFACEFMT_A8R8G8B8:
1750 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_SURFACEFMT_A8R8G8B8 = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1751 break;
1752 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_SURFACEFMT_A2R10G10B10:
1753 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_SURFACEFMT_A2R10G10B10 = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1754 break;
1755 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_SURFACEFMT_X1R5G5B5:
1756 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_SURFACEFMT_X1R5G5B5 = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1757 break;
1758 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_SURFACEFMT_A1R5G5B5:
1759 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_SURFACEFMT_A1R5G5B5 = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1760 break;
1761 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_SURFACEFMT_A4R4G4B4:
1762 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_SURFACEFMT_A4R4G4B4 = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1763 break;
1764 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_SURFACEFMT_R5G6B5:
1765 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_SURFACEFMT_R5G6B5 = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1766 break;
1767 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_SURFACEFMT_LUMINANCE16:
1768 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_SURFACEFMT_LUMINANCE16 = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1769 break;
1770 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_SURFACEFMT_LUMINANCE8_ALPHA8:
1771 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_SURFACEFMT_LUMINANCE8_ALPHA8 = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1772 break;
1773 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_SURFACEFMT_ALPHA8:
1774 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_SURFACEFMT_ALPHA8 = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1775 break;
1776 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_SURFACEFMT_LUMINANCE8:
1777 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_SURFACEFMT_LUMINANCE8 = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1778 break;
1779 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_SURFACEFMT_Z_D16:
1780 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_SURFACEFMT_Z_D16 = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1781 break;
1782 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_SURFACEFMT_Z_D24S8:
1783 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_SURFACEFMT_Z_D24S8 = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1784 break;
1785 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_SURFACEFMT_Z_D24X8:
1786 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_SURFACEFMT_Z_D24X8 = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1787 break;
1788 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_SURFACEFMT_DXT1:
1789 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_SURFACEFMT_DXT1 = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1790 break;
1791 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_SURFACEFMT_DXT2:
1792 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_SURFACEFMT_DXT2 = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1793 break;
1794 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_SURFACEFMT_DXT3:
1795 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_SURFACEFMT_DXT3 = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1796 break;
1797 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_SURFACEFMT_DXT4:
1798 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_SURFACEFMT_DXT4 = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1799 break;
1800 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_SURFACEFMT_DXT5:
1801 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_SURFACEFMT_DXT5 = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1802 break;
1803 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_SURFACEFMT_BUMPX8L8V8U8:
1804 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_SURFACEFMT_BUMPX8L8V8U8 = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1805 break;
1806 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_SURFACEFMT_A2W10V10U10:
1807 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_SURFACEFMT_A2W10V10U10 = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1808 break;
1809 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_SURFACEFMT_BUMPU8V8:
1810 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_SURFACEFMT_BUMPU8V8 = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1811 break;
1812 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_SURFACEFMT_Q8W8V8U8:
1813 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_SURFACEFMT_Q8W8V8U8 = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1814 break;
1815 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_SURFACEFMT_CxV8U8:
1816 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_SURFACEFMT_CxV8U8 = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1817 break;
1818 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_SURFACEFMT_R_S10E5:
1819 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_SURFACEFMT_R_S10E5 = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1820 break;
1821 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_SURFACEFMT_R_S23E8:
1822 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_SURFACEFMT_R_S23E8 = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1823 break;
1824 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_SURFACEFMT_RG_S10E5:
1825 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_SURFACEFMT_RG_S10E5 = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1826 break;
1827 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_SURFACEFMT_RG_S23E8:
1828 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_SURFACEFMT_RG_S23E8 = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1829 break;
1830 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_SURFACEFMT_ARGB_S10E5:
1831 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_SURFACEFMT_ARGB_S10E5 = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1832 break;
1833 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_SURFACEFMT_ARGB_S23E8:
1834 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_SURFACEFMT_ARGB_S23E8 = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1835 break;
1836 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_MAX_VERTEX_SHADER_TEXTURES:
1837 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_MAX_VERTEX_SHADER_TEXTURES = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1838 break;
1839 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_MAX_SIMULTANEOUS_RENDER_TARGETS:
1840 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_MAX_SIMULTANEOUS_RENDER_TARGETS = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1841 break;
1842 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_SURFACEFMT_V16U16:
1843 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_SURFACEFMT_V16U16 = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1844 break;
1845 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_SURFACEFMT_G16R16:
1846 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_SURFACEFMT_G16R16 = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1847 break;
1848 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_SURFACEFMT_A16B16G16R16:
1849 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_SURFACEFMT_A16B16G16R16 = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1850 break;
1851 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_SURFACEFMT_UYVY:
1852 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_SURFACEFMT_UYVY = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1853 break;
1854 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_SURFACEFMT_YUY2:
1855 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_SURFACEFMT_YUY2 = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1856 break;
1857 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_MULTISAMPLE_NONMASKABLESAMPLES:
1858 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_MULTISAMPLE_NONMASKABLESAMPLES = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1859 break;
1860 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_MULTISAMPLE_MASKABLESAMPLES:
1861 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_MULTISAMPLE_MASKABLESAMPLES = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1862 break;
1863 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_ALPHATOCOVERAGE:
1864 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_ALPHATOCOVERAGE = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1865 break;
1866 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_SUPERSAMPLE:
1867 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_SUPERSAMPLE = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1868 break;
1869 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_AUTOGENMIPMAPS:
1870 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_AUTOGENMIPMAPS = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1871 break;
1872 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_SURFACEFMT_NV12:
1873 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_SURFACEFMT_NV12 = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1874 break;
1875 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_SURFACEFMT_AYUV:
1876 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_SURFACEFMT_AYUV = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1877 break;
1878 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_MAX_CONTEXT_IDS:
1879 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_MAX_CONTEXT_IDS = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1880 break;
1881 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_MAX_SURFACE_IDS:
1882 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_MAX_SURFACE_IDS = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1883 break;
1884 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_SURFACEFMT_Z_DF16:
1885 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_SURFACEFMT_Z_DF16 = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1886 break;
1887 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_SURFACEFMT_Z_DF24:
1888 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_SURFACEFMT_Z_DF24 = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1889 break;
1890 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_SURFACEFMT_Z_D24S8_INT:
1891 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_SURFACEFMT_Z_D24S8_INT = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1892 break;
1893 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_SURFACEFMT_BC4_UNORM:
1894 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_SURFACEFMT_BC4_UNORM = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1895 break;
1896 case SVGA_FIFO_3D_CAPS + SVGA3D_DEVCAP_SURFACEFMT_BC5_UNORM:
1897 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS SVGA3D_DEVCAP_SURFACEFMT_BC5_UNORM = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1898 break;
1899 case SVGA_FIFO_3D_CAPS_LAST:
1900 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_3D_CAPS_LAST = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1901 break;
1902 case SVGA_FIFO_GUEST_3D_HWVERSION:
1903 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_GUEST_3D_HWVERSION = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1904 break;
1905 case SVGA_FIFO_FENCE_GOAL:
1906 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_FENCE_GOAL = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1907 break;
1908 case SVGA_FIFO_BUSY:
1909 Log(("vmsvgaFIFOAccess [0x%x]: %s SVGA_FIFO_BUSY = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", pFIFO[GCPhysOffset >> 2]));
1910 break;
1911 default:
1912 Log(("vmsvgaFIFOAccess [0x%x]: %s access at offset %x = %x\n", GCPhysOffset >> 2, (fWriteAccess) ? "WRITE" : "READ", GCPhysOffset, pFIFO[GCPhysOffset >> 2]));
1913 break;
1914 }
1915
1916 return VINF_EM_RAW_EMULATE_INSTR;
1917}
1918
1919/**
1920 * HC access handler for the FIFO.
1921 *
1922 * @returns VINF_SUCCESS if the handler have carried out the operation.
1923 * @returns VINF_PGM_HANDLER_DO_DEFAULT if the caller should carry out the access operation.
1924 * @param pVM VM Handle.
1925 * @param pVCpu The cross context CPU structure for the calling EMT.
1926 * @param GCPhys The physical address the guest is writing to.
1927 * @param pvPhys The HC mapping of that address.
1928 * @param pvBuf What the guest is reading/writing.
1929 * @param cbBuf How much it's reading/writing.
1930 * @param enmAccessType The access type.
1931 * @param enmOrigin Who is making the access.
1932 * @param pvUser User argument.
1933 */
1934static DECLCALLBACK(VBOXSTRICTRC)
1935vmsvgaR3FIFOAccessHandler(PVM pVM, PVMCPU pVCpu RTGCPHYS GCPhys, void *pvPhys, void *pvBuf, size_t cbBuf,
1936 PGMACCESSTYPE enmAccessType, PGMACCESSORIGIN enmOrigin, void *pvUser)
1937{
1938 PVGASTATE pThis = (PVGASTATE)pvUser;
1939 int rc;
1940 Assert(pThis);
1941 Assert(GCPhys >= pThis->GCPhysVRAM);
1942 NOREF(pVCpu); NOREF(pvPhys); NOREF(pvBuf); NOREF(cbBuf); NOREF(enmOrigin);
1943
1944 rc = vmsvgaFIFOAccess(pVM, pThis, GCPhys, enmAccessType == PGMACCESSTYPE_WRITE);
1945 if (RT_SUCCESS(rc))
1946 return VINF_PGM_HANDLER_DO_DEFAULT;
1947 AssertMsg(rc <= VINF_SUCCESS, ("rc=%Rrc\n", rc));
1948 return rc;
1949}
1950
1951# endif /* IN_RING3 */
1952#endif /* DEBUG_FIFO_ACCESS */
1953
1954#ifdef DEBUG_GMR_ACCESS
1955/**
1956 * HC access handler for the FIFO.
1957 *
1958 * @returns VINF_SUCCESS if the handler have carried out the operation.
1959 * @returns VINF_PGM_HANDLER_DO_DEFAULT if the caller should carry out the access operation.
1960 * @param pVM VM Handle.
1961 * @param pVCpu The cross context CPU structure for the calling EMT.
1962 * @param GCPhys The physical address the guest is writing to.
1963 * @param pvPhys The HC mapping of that address.
1964 * @param pvBuf What the guest is reading/writing.
1965 * @param cbBuf How much it's reading/writing.
1966 * @param enmAccessType The access type.
1967 * @param enmOrigin Who is making the access.
1968 * @param pvUser User argument.
1969 */
1970static DECLCALLBACK(VBOXSTRICTRC)
1971vmsvgaR3GMRAccessHandler(PVM pVM, PVMCPU pVCpu, RTGCPHYS GCPhys, void *pvPhys, void *pvBuf, size_t cbBuf,
1972 PGMACCESSTYPE enmAccessType, PGMACCESSORIGIN enmOrigin, void *pvUser)
1973{
1974 PVGASTATE pThis = (PVGASTATE)pvUser;
1975 Assert(pThis);
1976 PVMSVGAR3STATE pSVGAState = pThis->svga.pSvgaR3State;
1977 NOREF(pVCpu); NOREF(pvPhys); NOREF(pvBuf); NOREF(cbBuf); NOREF(enmOrigin);
1978
1979 Log(("vmsvgaR3GMRAccessHandler: GMR access to page %RGp\n", GCPhys));
1980
1981 for (uint32_t i = 0; i < RT_ELEMENTS(pSVGAState->aGMR); i++)
1982 {
1983 PGMR pGMR = &pSVGAState->aGMR[i];
1984
1985 if (pGMR->numDescriptors)
1986 {
1987 for (uint32_t j = 0; j < pGMR->numDescriptors; j++)
1988 {
1989 if ( GCPhys >= pGMR->paDesc[j].GCPhys
1990 && GCPhys < pGMR->paDesc[j].GCPhys + pGMR->paDesc[j].numPages * PAGE_SIZE)
1991 {
1992 /*
1993 * Turn off the write handler for this particular page and make it R/W.
1994 * Then return telling the caller to restart the guest instruction.
1995 */
1996 int rc = PGMHandlerPhysicalPageTempOff(pVM, pGMR->paDesc[j].GCPhys, GCPhys);
1997 goto end;
1998 }
1999 }
2000 }
2001 }
2002end:
2003 return VINF_PGM_HANDLER_DO_DEFAULT;
2004}
2005
2006# ifdef IN_RING3
2007
2008/* Callback handler for VMR3ReqCallWait */
2009static DECLCALLBACK(int) vmsvgaRegisterGMR(PPDMDEVINS pDevIns, uint32_t gmrId)
2010{
2011 PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
2012 PVMSVGAR3STATE pSVGAState = pThis->svga.pSvgaR3State;
2013 PGMR pGMR = &pSVGAState->aGMR[gmrId];
2014 int rc;
2015
2016 for (uint32_t i = 0; i < pGMR->numDescriptors; i++)
2017 {
2018 rc = PGMHandlerPhysicalRegister(PDMDevHlpGetVM(pThis->pDevInsR3),
2019 pGMR->paDesc[i].GCPhys, pGMR->paDesc[i].GCPhys + pGMR->paDesc[i].numPages * PAGE_SIZE - 1,
2020 pThis->svga.hGmrAccessHandlerType, pThis, NIL_RTR0PTR, NIL_RTRCPTR, "VMSVGA GMR");
2021 AssertRC(rc);
2022 }
2023 return VINF_SUCCESS;
2024}
2025
2026/* Callback handler for VMR3ReqCallWait */
2027static DECLCALLBACK(int) vmsvgaDeregisterGMR(PPDMDEVINS pDevIns, uint32_t gmrId)
2028{
2029 PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
2030 PVMSVGAR3STATE pSVGAState = pThis->svga.pSvgaR3State;
2031 PGMR pGMR = &pSVGAState->aGMR[gmrId];
2032
2033 for (uint32_t i = 0; i < pGMR->numDescriptors; i++)
2034 {
2035 int rc = PGMHandlerPhysicalDeregister(PDMDevHlpGetVM(pThis->pDevInsR3), pGMR->paDesc[i].GCPhys);
2036 AssertRC(rc);
2037 }
2038 return VINF_SUCCESS;
2039}
2040
2041/* Callback handler for VMR3ReqCallWait */
2042static DECLCALLBACK(int) vmsvgaResetGMRHandlers(PVGASTATE pThis)
2043{
2044 PVMSVGAR3STATE pSVGAState = pThis->svga.pSvgaR3State;
2045
2046 for (uint32_t i = 0; i < RT_ELEMENTS(pSVGAState->aGMR); i++)
2047 {
2048 PGMR pGMR = &pSVGAState->aGMR[i];
2049
2050 if (pGMR->numDescriptors)
2051 {
2052 for (uint32_t j = 0; j < pGMR->numDescriptors; j++)
2053 {
2054 int rc = PGMHandlerPhysicalReset(PDMDevHlpGetVM(pThis->pDevInsR3), pGMR->paDesc[j].GCPhys);
2055 AssertRC(rc);
2056 }
2057 }
2058 }
2059 return VINF_SUCCESS;
2060}
2061
2062# endif /* IN_RING3 */
2063#endif /* DEBUG_GMR_ACCESS */
2064
2065/* -=-=-=-=-=- Ring 3 -=-=-=-=-=- */
2066
2067#ifdef IN_RING3
2068
2069/**
2070 * Worker for vmsvgaR3FifoThread that handles an external command.
2071 *
2072 * @param pThis VGA device instance data.
2073 */
2074static void vmsvgaR3FifoHandleExtCmd(PVGASTATE pThis)
2075{
2076 uint8_t uExtCmd = pThis->svga.u8FIFOExtCommand;
2077 switch (pThis->svga.u8FIFOExtCommand)
2078 {
2079 case VMSVGA_FIFO_EXTCMD_RESET:
2080 Log(("vmsvgaFIFOLoop: reset the fifo thread.\n"));
2081 Assert(pThis->svga.pvFIFOExtCmdParam == NULL);
2082# ifdef VBOX_WITH_VMSVGA3D
2083 if (pThis->svga.f3DEnabled)
2084 {
2085 /* The 3d subsystem must be reset from the fifo thread. */
2086 vmsvga3dReset(pThis);
2087 }
2088# endif
2089 break;
2090
2091 case VMSVGA_FIFO_EXTCMD_TERMINATE:
2092 Log(("vmsvgaFIFOLoop: terminate the fifo thread.\n"));
2093 Assert(pThis->svga.pvFIFOExtCmdParam == NULL);
2094# ifdef VBOX_WITH_VMSVGA3D
2095 if (pThis->svga.f3DEnabled)
2096 {
2097 /* The 3d subsystem must be shut down from the fifo thread. */
2098 vmsvga3dTerminate(pThis);
2099 }
2100# endif
2101 break;
2102
2103 case VMSVGA_FIFO_EXTCMD_SAVESTATE:
2104 {
2105 Log(("vmsvgaFIFOLoop: VMSVGA_FIFO_EXTCMD_SAVESTATE.\n"));
2106# ifdef VBOX_WITH_VMSVGA3D
2107 PSSMHANDLE pSSM = (PSSMHANDLE)pThis->svga.pvFIFOExtCmdParam;
2108 AssertLogRelMsgBreak(RT_VALID_PTR(pSSM), ("pSSM=%p\n", pSSM));
2109 vmsvga3dSaveExec(pThis, pSSM);
2110# endif
2111 break;
2112 }
2113
2114 case VMSVGA_FIFO_EXTCMD_LOADSTATE:
2115 {
2116 Log(("vmsvgaFIFOLoop: VMSVGA_FIFO_EXTCMD_LOADSTATE.\n"));
2117# ifdef VBOX_WITH_VMSVGA3D
2118 PVMSVGA_STATE_LOAD pLoadState = (PVMSVGA_STATE_LOAD)pThis->svga.pvFIFOExtCmdParam;
2119 AssertLogRelMsgBreak(RT_VALID_PTR(pLoadState), ("pLoadState=%p\n", pLoadState));
2120 vmsvga3dLoadExec(pThis, pLoadState->pSSM, pLoadState->uVersion, pLoadState->uPass);
2121# endif
2122 break;
2123 }
2124
2125 case VMSVGA_FIFO_EXTCMD_UPDATE_SURFACE_HEAP_BUFFERS:
2126 {
2127# ifdef VBOX_WITH_VMSVGA3D
2128 uint32_t sid = (uint32_t)(uintptr_t)pThis->svga.pvFIFOExtCmdParam;
2129 Log(("vmsvgaFIFOLoop: VMSVGA_FIFO_EXTCMD_UPDATE_SURFACE_HEAP_BUFFERS sid=%#x\n", sid));
2130 vmsvga3dUpdateHeapBuffersForSurfaces(pThis, sid);
2131# endif
2132 break;
2133 }
2134
2135
2136 default:
2137 AssertLogRelMsgFailed(("uExtCmd=%#x pvFIFOExtCmdParam=%p\n", uExtCmd, pThis->svga.pvFIFOExtCmdParam));
2138 break;
2139 }
2140
2141 /*
2142 * Signal the end of the external command.
2143 */
2144 pThis->svga.pvFIFOExtCmdParam = NULL;
2145 pThis->svga.u8FIFOExtCommand = VMSVGA_FIFO_EXTCMD_NONE;
2146 ASMMemoryFence(); /* paranoia^2 */
2147 int rc = RTSemEventSignal(pThis->svga.FIFOExtCmdSem);
2148 AssertLogRelRC(rc);
2149}
2150
2151/**
2152 * Worker for vmsvgaR3Destruct, vmsvgaR3Reset, vmsvgaR3Save and vmsvgaR3Load for
2153 * doing a job on the FIFO thread (even when it's officially suspended).
2154 *
2155 * @returns VBox status code (fully asserted).
2156 * @param pThis VGA device instance data.
2157 * @param uExtCmd The command to execute on the FIFO thread.
2158 * @param pvParam Pointer to command parameters.
2159 * @param cMsWait The time to wait for the command, given in
2160 * milliseconds.
2161 */
2162static int vmsvgaR3RunExtCmdOnFifoThread(PVGASTATE pThis, uint8_t uExtCmd, void *pvParam, RTMSINTERVAL cMsWait)
2163{
2164 Assert(cMsWait >= RT_MS_1SEC * 5);
2165 AssertLogRelMsg(pThis->svga.u8FIFOExtCommand == VMSVGA_FIFO_EXTCMD_NONE,
2166 ("old=%d new=%d\n", pThis->svga.u8FIFOExtCommand, uExtCmd));
2167
2168 int rc;
2169 PPDMTHREAD pThread = pThis->svga.pFIFOIOThread;
2170 PDMTHREADSTATE enmState = pThread->enmState;
2171 if (enmState == PDMTHREADSTATE_SUSPENDED)
2172 {
2173 /*
2174 * The thread is suspended, we have to temporarily wake it up so it can
2175 * perform the task.
2176 * (We ASSUME not racing code here, both wrt thread state and ext commands.)
2177 */
2178 Log(("vmsvgaR3RunExtCmdOnFifoThread: uExtCmd=%d enmState=SUSPENDED\n", uExtCmd));
2179 /* Post the request. */
2180 pThis->svga.fFifoExtCommandWakeup = true;
2181 pThis->svga.pvFIFOExtCmdParam = pvParam;
2182 pThis->svga.u8FIFOExtCommand = uExtCmd;
2183 ASMMemoryFence(); /* paranoia^3 */
2184
2185 /* Resume the thread. */
2186 rc = PDMR3ThreadResume(pThread);
2187 AssertLogRelRC(rc);
2188 if (RT_SUCCESS(rc))
2189 {
2190 /* Wait. Take care in case the semaphore was already posted (same as below). */
2191 rc = RTSemEventWait(pThis->svga.FIFOExtCmdSem, cMsWait);
2192 if ( rc == VINF_SUCCESS
2193 && pThis->svga.u8FIFOExtCommand == uExtCmd)
2194 rc = RTSemEventWait(pThis->svga.FIFOExtCmdSem, cMsWait);
2195 AssertLogRelMsg(pThis->svga.u8FIFOExtCommand != uExtCmd || RT_FAILURE_NP(rc),
2196 ("%#x %Rrc\n", pThis->svga.u8FIFOExtCommand, rc));
2197
2198 /* suspend the thread */
2199 pThis->svga.fFifoExtCommandWakeup = false;
2200 int rc2 = PDMR3ThreadSuspend(pThread);
2201 AssertLogRelRC(rc2);
2202 if (RT_FAILURE(rc2) && RT_SUCCESS(rc))
2203 rc = rc2;
2204 }
2205 pThis->svga.fFifoExtCommandWakeup = false;
2206 pThis->svga.pvFIFOExtCmdParam = NULL;
2207 }
2208 else if (enmState == PDMTHREADSTATE_RUNNING)
2209 {
2210 /*
2211 * The thread is running, should only happen during reset and vmsvga3dsfc.
2212 * We ASSUME not racing code here, both wrt thread state and ext commands.
2213 */
2214 Log(("vmsvgaR3RunExtCmdOnFifoThread: uExtCmd=%d enmState=RUNNING\n", uExtCmd));
2215 Assert(uExtCmd == VMSVGA_FIFO_EXTCMD_RESET || uExtCmd == VMSVGA_FIFO_EXTCMD_UPDATE_SURFACE_HEAP_BUFFERS);
2216
2217 /* Post the request. */
2218 pThis->svga.pvFIFOExtCmdParam = pvParam;
2219 pThis->svga.u8FIFOExtCommand = uExtCmd;
2220 ASMMemoryFence(); /* paranoia^2 */
2221 rc = SUPSemEventSignal(pThis->svga.pSupDrvSession, pThis->svga.FIFORequestSem);
2222 AssertLogRelRC(rc);
2223
2224 /* Wait. Take care in case the semaphore was already posted (same as above). */
2225 rc = RTSemEventWait(pThis->svga.FIFOExtCmdSem, cMsWait);
2226 if ( rc == VINF_SUCCESS
2227 && pThis->svga.u8FIFOExtCommand == uExtCmd)
2228 rc = RTSemEventWait(pThis->svga.FIFOExtCmdSem, cMsWait); /* it was already posted, retry the wait. */
2229 AssertLogRelMsg(pThis->svga.u8FIFOExtCommand != uExtCmd || RT_FAILURE_NP(rc),
2230 ("%#x %Rrc\n", pThis->svga.u8FIFOExtCommand, rc));
2231
2232 pThis->svga.pvFIFOExtCmdParam = NULL;
2233 }
2234 else
2235 {
2236 /*
2237 * Something is wrong with the thread!
2238 */
2239 AssertLogRelMsgFailed(("uExtCmd=%d enmState=%d\n", uExtCmd, enmState));
2240 rc = VERR_INVALID_STATE;
2241 }
2242 return rc;
2243}
2244
2245
2246/**
2247 * Marks the FIFO non-busy, notifying any waiting EMTs.
2248 *
2249 * @param pThis The VGA state.
2250 * @param pSVGAState Pointer to the ring-3 only SVGA state data.
2251 * @param offFifoMin The start byte offset of the command FIFO.
2252 */
2253static void vmsvgaFifoSetNotBusy(PVGASTATE pThis, PVMSVGAR3STATE pSVGAState, uint32_t offFifoMin)
2254{
2255 ASMAtomicAndU32(&pThis->svga.fBusy, ~VMSVGA_BUSY_F_FIFO);
2256 if (VMSVGA_IS_VALID_FIFO_REG(SVGA_FIFO_BUSY, offFifoMin))
2257 vmsvgaSafeFifoBusyRegUpdate(pThis, pThis->svga.fBusy != 0);
2258
2259 /* Wake up any waiting EMTs. */
2260 if (pSVGAState->cBusyDelayedEmts > 0)
2261 {
2262#ifdef VMSVGA_USE_EMT_HALT_CODE
2263 PVM pVM = PDMDevHlpGetVM(pThis->pDevInsR3);
2264 VMCPUID idCpu = VMCpuSetFindLastPresentInternal(&pSVGAState->BusyDelayedEmts);
2265 if (idCpu != NIL_VMCPUID)
2266 {
2267 VMR3NotifyCpuDeviceReady(pVM, idCpu);
2268 while (idCpu-- > 0)
2269 if (VMCPUSET_IS_PRESENT(&pSVGAState->BusyDelayedEmts, idCpu))
2270 VMR3NotifyCpuDeviceReady(pVM, idCpu);
2271 }
2272#else
2273 int rc2 = RTSemEventMultiSignal(pSVGAState->hBusyDelayedEmts);
2274 AssertRC(rc2);
2275#endif
2276 }
2277}
2278
2279/**
2280 * Reads (more) payload into the command buffer.
2281 *
2282 * @returns pbBounceBuf on success
2283 * @retval (void *)1 if the thread was requested to stop.
2284 * @retval NULL on FIFO error.
2285 *
2286 * @param cbPayloadReq The number of bytes of payload requested.
2287 * @param pFIFO The FIFO.
2288 * @param offCurrentCmd The FIFO byte offset of the current command.
2289 * @param offFifoMin The start byte offset of the command FIFO.
2290 * @param offFifoMax The end byte offset of the command FIFO.
2291 * @param pbBounceBuf The bounch buffer. Same size as the entire FIFO, so
2292 * always sufficient size.
2293 * @param pcbAlreadyRead How much payload we've already read into the bounce
2294 * buffer. (We will NEVER re-read anything.)
2295 * @param pThread The calling PDM thread handle.
2296 * @param pThis The VGA state.
2297 * @param pSVGAState Pointer to the ring-3 only SVGA state data. For
2298 * statistics collection.
2299 */
2300static void *vmsvgaFIFOGetCmdPayload(uint32_t cbPayloadReq, uint32_t volatile *pFIFO,
2301 uint32_t offCurrentCmd, uint32_t offFifoMin, uint32_t offFifoMax,
2302 uint8_t *pbBounceBuf, uint32_t *pcbAlreadyRead,
2303 PPDMTHREAD pThread, PVGASTATE pThis, PVMSVGAR3STATE pSVGAState)
2304{
2305 Assert(pbBounceBuf);
2306 Assert(pcbAlreadyRead);
2307 Assert(offFifoMin < offFifoMax);
2308 Assert(offCurrentCmd >= offFifoMin && offCurrentCmd < offFifoMax);
2309 Assert(offFifoMax <= VMSVGA_FIFO_SIZE);
2310
2311 /*
2312 * Check if the requested payload size has already been satisfied .
2313 * .
2314 * When called to read more, the caller is responsible for making sure the .
2315 * new command size (cbRequsted) never is smaller than what has already .
2316 * been read.
2317 */
2318 uint32_t cbAlreadyRead = *pcbAlreadyRead;
2319 if (cbPayloadReq <= cbAlreadyRead)
2320 {
2321 AssertLogRelReturn(cbPayloadReq == cbAlreadyRead, NULL);
2322 return pbBounceBuf;
2323 }
2324
2325 /*
2326 * Commands bigger than the fifo buffer are invalid.
2327 */
2328 uint32_t const cbFifoCmd = offFifoMax - offFifoMin;
2329 AssertMsgReturnStmt(cbPayloadReq <= cbFifoCmd, ("cbPayloadReq=%#x cbFifoCmd=%#x\n", cbPayloadReq, cbFifoCmd),
2330 STAM_REL_COUNTER_INC(&pSVGAState->StatFifoErrors),
2331 NULL);
2332
2333 /*
2334 * Move offCurrentCmd past the command dword.
2335 */
2336 offCurrentCmd += sizeof(uint32_t);
2337 if (offCurrentCmd >= offFifoMax)
2338 offCurrentCmd = offFifoMin;
2339
2340 /*
2341 * Do we have sufficient payload data available already?
2342 */
2343 uint32_t cbAfter, cbBefore;
2344 uint32_t offNextCmd = pFIFO[SVGA_FIFO_NEXT_CMD];
2345 if (offNextCmd > offCurrentCmd)
2346 {
2347 if (RT_LIKELY(offNextCmd < offFifoMax))
2348 cbAfter = offNextCmd - offCurrentCmd;
2349 else
2350 {
2351 STAM_REL_COUNTER_INC(&pSVGAState->StatFifoErrors);
2352 LogRelMax(16, ("vmsvgaFIFOGetCmdPayload: Invalid offNextCmd=%#x (offFifoMin=%#x offFifoMax=%#x)\n",
2353 offNextCmd, offFifoMin, offFifoMax));
2354 cbAfter = offFifoMax - offCurrentCmd;
2355 }
2356 cbBefore = 0;
2357 }
2358 else
2359 {
2360 cbAfter = offFifoMax - offCurrentCmd;
2361 if (offNextCmd >= offFifoMin)
2362 cbBefore = offNextCmd - offFifoMin;
2363 else
2364 {
2365 STAM_REL_COUNTER_INC(&pSVGAState->StatFifoErrors);
2366 LogRelMax(16, ("vmsvgaFIFOGetCmdPayload: Invalid offNextCmd=%#x (offFifoMin=%#x offFifoMax=%#x)\n",
2367 offNextCmd, offFifoMin, offFifoMax));
2368 cbBefore = 0;
2369 }
2370 }
2371 if (cbAfter + cbBefore < cbPayloadReq)
2372 {
2373 /*
2374 * Insufficient, must wait for it to arrive.
2375 */
2376/** @todo Should clear the busy flag here to maybe encourage the guest to wake us up. */
2377 STAM_REL_PROFILE_START(&pSVGAState->StatFifoStalls, Stall);
2378 for (uint32_t i = 0;; i++)
2379 {
2380 if (pThread->enmState != PDMTHREADSTATE_RUNNING)
2381 {
2382 STAM_REL_PROFILE_STOP(&pSVGAState->StatFifoStalls, Stall);
2383 return (void *)(uintptr_t)1;
2384 }
2385 Log(("Guest still copying (%x vs %x) current %x next %x stop %x loop %u; sleep a bit\n",
2386 cbPayloadReq, cbAfter + cbBefore, offCurrentCmd, offNextCmd, pFIFO[SVGA_FIFO_STOP], i));
2387
2388 SUPSemEventWaitNoResume(pThis->svga.pSupDrvSession, pThis->svga.FIFORequestSem, i < 16 ? 1 : 2);
2389
2390 offNextCmd = pFIFO[SVGA_FIFO_NEXT_CMD];
2391 if (offNextCmd > offCurrentCmd)
2392 {
2393 cbAfter = RT_MIN(offNextCmd, offFifoMax) - offCurrentCmd;
2394 cbBefore = 0;
2395 }
2396 else
2397 {
2398 cbAfter = offFifoMax - offCurrentCmd;
2399 cbBefore = RT_MAX(offNextCmd, offFifoMin) - offFifoMin;
2400 }
2401
2402 if (cbAfter + cbBefore >= cbPayloadReq)
2403 break;
2404 }
2405 STAM_REL_PROFILE_STOP(&pSVGAState->StatFifoStalls, Stall);
2406 }
2407
2408 /*
2409 * Copy out the memory and update what pcbAlreadyRead points to.
2410 */
2411 if (cbAfter >= cbPayloadReq)
2412 memcpy(pbBounceBuf + cbAlreadyRead,
2413 (uint8_t *)pFIFO + offCurrentCmd + cbAlreadyRead,
2414 cbPayloadReq - cbAlreadyRead);
2415 else
2416 {
2417 LogFlow(("Split data buffer at %x (%u-%u)\n", offCurrentCmd, cbAfter, cbBefore));
2418 if (cbAlreadyRead < cbAfter)
2419 {
2420 memcpy(pbBounceBuf + cbAlreadyRead,
2421 (uint8_t *)pFIFO + offCurrentCmd + cbAlreadyRead,
2422 cbAfter - cbAlreadyRead);
2423 cbAlreadyRead = cbAfter;
2424 }
2425 memcpy(pbBounceBuf + cbAlreadyRead,
2426 (uint8_t *)pFIFO + offFifoMin + cbAlreadyRead - cbAfter,
2427 cbPayloadReq - cbAlreadyRead);
2428 }
2429 *pcbAlreadyRead = cbPayloadReq;
2430 return pbBounceBuf;
2431}
2432
2433/* The async FIFO handling thread. */
2434static DECLCALLBACK(int) vmsvgaFIFOLoop(PPDMDEVINS pDevIns, PPDMTHREAD pThread)
2435{
2436 PVGASTATE pThis = (PVGASTATE)pThread->pvUser;
2437 PVMSVGAR3STATE pSVGAState = pThis->svga.pSvgaR3State;
2438 int rc;
2439
2440 if (pThread->enmState == PDMTHREADSTATE_INITIALIZING)
2441 return VINF_SUCCESS;
2442
2443 /*
2444 * Special mode where we only execute an external command and the go back
2445 * to being suspended. Currently, all ext cmds ends up here, with the reset
2446 * one also being eligble for runtime execution further down as well.
2447 */
2448 if (pThis->svga.fFifoExtCommandWakeup)
2449 {
2450 vmsvgaR3FifoHandleExtCmd(pThis);
2451 while (pThread->enmState == PDMTHREADSTATE_RUNNING)
2452 if (pThis->svga.u8FIFOExtCommand == VMSVGA_FIFO_EXTCMD_NONE)
2453 SUPSemEventWaitNoResume(pThis->svga.pSupDrvSession, pThis->svga.FIFORequestSem, RT_MS_1MIN);
2454 else
2455 vmsvgaR3FifoHandleExtCmd(pThis);
2456 return VINF_SUCCESS;
2457 }
2458
2459
2460 /*
2461 * Signal the semaphore to make sure we don't wait for 250ms after a
2462 * suspend & resume scenario (see vmsvgaFIFOGetCmdPayload).
2463 */
2464 SUPSemEventSignal(pThis->svga.pSupDrvSession, pThis->svga.FIFORequestSem);
2465
2466 /*
2467 * Allocate a bounce buffer for command we get from the FIFO.
2468 * (All code must return via the end of the function to free this buffer.)
2469 */
2470 uint8_t *pbBounceBuf = (uint8_t *)RTMemAllocZ(VMSVGA_FIFO_SIZE);
2471 AssertReturn(pbBounceBuf, VERR_NO_MEMORY);
2472
2473 /*
2474 * Polling/sleep interval config.
2475 *
2476 * We wait for an a short interval if the guest has recently given us work
2477 * to do, but the interval increases the longer we're kept idle. With the
2478 * current parameters we'll be at a 64ms poll interval after 1 idle second,
2479 * at 90ms after 2 seconds, and reach the max 250ms interval after about
2480 * 16 seconds.
2481 */
2482 RTMSINTERVAL const cMsMinSleep = 16;
2483 RTMSINTERVAL const cMsIncSleep = 2;
2484 RTMSINTERVAL const cMsMaxSleep = 250;
2485 RTMSINTERVAL cMsSleep = cMsMaxSleep;
2486
2487 /*
2488 * The FIFO loop.
2489 */
2490 LogFlow(("vmsvgaFIFOLoop: started loop\n"));
2491 bool fBadOrDisabledFifo = false;
2492 uint32_t volatile * const pFIFO = pThis->svga.pFIFOR3;
2493 while (pThread->enmState == PDMTHREADSTATE_RUNNING)
2494 {
2495# if defined(RT_OS_DARWIN) && defined(VBOX_WITH_VMSVGA3D)
2496 /*
2497 * Should service the run loop every so often.
2498 */
2499 if (pThis->svga.f3DEnabled)
2500 vmsvga3dCocoaServiceRunLoop();
2501# endif
2502
2503 /*
2504 * Unless there's already work pending, go to sleep for a short while.
2505 * (See polling/sleep interval config above.)
2506 */
2507 if ( fBadOrDisabledFifo
2508 || pFIFO[SVGA_FIFO_NEXT_CMD] == pFIFO[SVGA_FIFO_STOP])
2509 {
2510 rc = SUPSemEventWaitNoResume(pThis->svga.pSupDrvSession, pThis->svga.FIFORequestSem, cMsSleep);
2511 AssertBreak(RT_SUCCESS(rc) || rc == VERR_TIMEOUT || rc == VERR_INTERRUPTED);
2512 if (pThread->enmState != PDMTHREADSTATE_RUNNING)
2513 {
2514 LogFlow(("vmsvgaFIFOLoop: thread state %x\n", pThread->enmState));
2515 break;
2516 }
2517 }
2518 else
2519 rc = VINF_SUCCESS;
2520 fBadOrDisabledFifo = false;
2521 if (rc == VERR_TIMEOUT)
2522 {
2523 if (pFIFO[SVGA_FIFO_NEXT_CMD] == pFIFO[SVGA_FIFO_STOP])
2524 {
2525 cMsSleep = RT_MIN(cMsSleep + cMsIncSleep, cMsMaxSleep);
2526 continue;
2527 }
2528 STAM_REL_COUNTER_INC(&pSVGAState->StatFifoTodoTimeout);
2529
2530 Log(("vmsvgaFIFOLoop: timeout\n"));
2531 }
2532 else if (pFIFO[SVGA_FIFO_NEXT_CMD] != pFIFO[SVGA_FIFO_STOP])
2533 STAM_REL_COUNTER_INC(&pSVGAState->StatFifoTodoWoken);
2534 cMsSleep = cMsMinSleep;
2535
2536 Log(("vmsvgaFIFOLoop: enabled=%d configured=%d busy=%d\n", pThis->svga.fEnabled, pThis->svga.fConfigured, pThis->svga.pFIFOR3[SVGA_FIFO_BUSY]));
2537 Log(("vmsvgaFIFOLoop: min %x max %x\n", pFIFO[SVGA_FIFO_MIN], pFIFO[SVGA_FIFO_MAX]));
2538 Log(("vmsvgaFIFOLoop: next %x stop %x\n", pFIFO[SVGA_FIFO_NEXT_CMD], pFIFO[SVGA_FIFO_STOP]));
2539
2540 /*
2541 * Handle external commands (currently only reset).
2542 */
2543 if (pThis->svga.u8FIFOExtCommand != VMSVGA_FIFO_EXTCMD_NONE)
2544 {
2545 vmsvgaR3FifoHandleExtCmd(pThis);
2546 continue;
2547 }
2548
2549 /*
2550 * The device must be enabled and configured.
2551 */
2552 if ( !pThis->svga.fEnabled
2553 || !pThis->svga.fConfigured)
2554 {
2555 vmsvgaFifoSetNotBusy(pThis, pSVGAState, pFIFO[SVGA_FIFO_MIN]);
2556 fBadOrDisabledFifo = true;
2557 continue;
2558 }
2559
2560 /*
2561 * Get and check the min/max values. We ASSUME that they will remain
2562 * unchanged while we process requests. A further ASSUMPTION is that
2563 * the guest won't mess with SVGA_FIFO_NEXT_CMD while we're busy, so
2564 * we don't read it back while in the loop.
2565 */
2566 uint32_t const offFifoMin = pFIFO[SVGA_FIFO_MIN];
2567 uint32_t const offFifoMax = pFIFO[SVGA_FIFO_MAX];
2568 uint32_t offCurrentCmd = pFIFO[SVGA_FIFO_STOP];
2569 if (RT_UNLIKELY( !VMSVGA_IS_VALID_FIFO_REG(SVGA_FIFO_STOP, offFifoMin)
2570 || offFifoMax <= offFifoMin
2571 || offFifoMax > VMSVGA_FIFO_SIZE
2572 || (offFifoMax & 3) != 0
2573 || (offFifoMin & 3) != 0
2574 || offCurrentCmd < offFifoMin
2575 || offCurrentCmd > offFifoMax))
2576 {
2577 STAM_REL_COUNTER_INC(&pSVGAState->StatFifoErrors);
2578 LogRelMax(8, ("vmsvgaFIFOLoop: Bad fifo: min=%#x stop=%#x max=%#x\n", offFifoMin, offCurrentCmd, offFifoMax));
2579 vmsvgaFifoSetNotBusy(pThis, pSVGAState, offFifoMin);
2580 fBadOrDisabledFifo = true;
2581 continue;
2582 }
2583 if (RT_UNLIKELY(offCurrentCmd & 3))
2584 {
2585 STAM_REL_COUNTER_INC(&pSVGAState->StatFifoErrors);
2586 LogRelMax(8, ("vmsvgaFIFOLoop: Misaligned offCurrentCmd=%#x?\n", offCurrentCmd));
2587 offCurrentCmd = ~UINT32_C(3);
2588 }
2589
2590/** @def VMSVGAFIFO_GET_CMD_BUFFER_BREAK
2591 * Macro for shortening calls to vmsvgaFIFOGetCmdPayload.
2592 *
2593 * Will break out of the switch on failure.
2594 * Will restart and quit the loop if the thread was requested to stop.
2595 *
2596 * @param a_PtrVar Request variable pointer.
2597 * @param a_Type Request typedef (not pointer) for casting.
2598 * @param a_cbPayloadReq How much payload to fetch.
2599 * @remarks Accesses a bunch of variables in the current scope!
2600 */
2601# define VMSVGAFIFO_GET_CMD_BUFFER_BREAK(a_PtrVar, a_Type, a_cbPayloadReq) \
2602 if (1) { \
2603 (a_PtrVar) = (a_Type *)vmsvgaFIFOGetCmdPayload((a_cbPayloadReq), pFIFO, offCurrentCmd, offFifoMin, offFifoMax, \
2604 pbBounceBuf, &cbPayload, pThread, pThis, pSVGAState); \
2605 if (RT_UNLIKELY((uintptr_t)(a_PtrVar) < 2)) { if ((uintptr_t)(a_PtrVar) == 1) continue; break; } \
2606 } else do {} while (0)
2607/** @def VMSVGAFIFO_GET_MORE_CMD_BUFFER_BREAK
2608 * Macro for shortening calls to vmsvgaFIFOGetCmdPayload for refetching the
2609 * buffer after figuring out the actual command size.
2610 *
2611 * Will break out of the switch on failure.
2612 *
2613 * @param a_PtrVar Request variable pointer.
2614 * @param a_Type Request typedef (not pointer) for casting.
2615 * @param a_cbPayloadReq How much payload to fetch.
2616 * @remarks Accesses a bunch of variables in the current scope!
2617 */
2618# define VMSVGAFIFO_GET_MORE_CMD_BUFFER_BREAK(a_PtrVar, a_Type, a_cbPayloadReq) \
2619 if (1) { \
2620 VMSVGAFIFO_GET_CMD_BUFFER_BREAK(a_PtrVar, a_Type, a_cbPayloadReq); \
2621 } else do {} while (0)
2622
2623 /*
2624 * Mark the FIFO as busy.
2625 */
2626 ASMAtomicWriteU32(&pThis->svga.fBusy, VMSVGA_BUSY_F_FIFO);
2627 if (VMSVGA_IS_VALID_FIFO_REG(SVGA_FIFO_BUSY, offFifoMin))
2628 ASMAtomicWriteU32(&pFIFO[SVGA_FIFO_BUSY], true);
2629
2630 /*
2631 * Execute all queued FIFO commands.
2632 * Quit if pending external command or changes in the thread state.
2633 */
2634 bool fDone = false;
2635 while ( !(fDone = (pFIFO[SVGA_FIFO_NEXT_CMD] == offCurrentCmd))
2636 && pThread->enmState == PDMTHREADSTATE_RUNNING)
2637 {
2638 uint32_t cbPayload = 0;
2639 uint32_t u32IrqStatus = 0;
2640
2641 Assert(offCurrentCmd < offFifoMax && offCurrentCmd >= offFifoMin);
2642
2643 /* First check any pending actions. */
2644 if (ASMBitTestAndClear(&pThis->svga.u32ActionFlags, VMSVGA_ACTION_CHANGEMODE_BIT))
2645# ifdef VBOX_WITH_VMSVGA3D
2646 vmsvga3dChangeMode(pThis);
2647# else
2648 {/*nothing*/}
2649# endif
2650 /* Check for pending external commands (reset). */
2651 if (pThis->svga.u8FIFOExtCommand != VMSVGA_FIFO_EXTCMD_NONE)
2652 break;
2653
2654 /*
2655 * Process the command.
2656 */
2657 SVGAFifoCmdId const enmCmdId = (SVGAFifoCmdId)pFIFO[offCurrentCmd / sizeof(uint32_t)];
2658 LogFlow(("vmsvgaFIFOLoop: FIFO command (iCmd=0x%x) %s 0x%x\n",
2659 offCurrentCmd / sizeof(uint32_t), vmsvgaFIFOCmdToString(enmCmdId), enmCmdId));
2660 switch (enmCmdId)
2661 {
2662 case SVGA_CMD_INVALID_CMD:
2663 /* Nothing to do. */
2664 break;
2665
2666 case SVGA_CMD_FENCE:
2667 {
2668 SVGAFifoCmdFence *pCmdFence;
2669 VMSVGAFIFO_GET_CMD_BUFFER_BREAK(pCmdFence, SVGAFifoCmdFence, sizeof(*pCmdFence));
2670 if (VMSVGA_IS_VALID_FIFO_REG(SVGA_FIFO_FENCE, offFifoMin))
2671 {
2672 Log(("vmsvgaFIFOLoop: SVGA_CMD_FENCE %x\n", pCmdFence->fence));
2673 pFIFO[SVGA_FIFO_FENCE] = pCmdFence->fence;
2674
2675 if (pThis->svga.u32IrqMask & SVGA_IRQFLAG_ANY_FENCE)
2676 {
2677 Log(("vmsvgaFIFOLoop: any fence irq\n"));
2678 u32IrqStatus |= SVGA_IRQFLAG_ANY_FENCE;
2679 }
2680 else
2681 if ( VMSVGA_IS_VALID_FIFO_REG(SVGA_FIFO_FENCE_GOAL, offFifoMin)
2682 && (pThis->svga.u32IrqMask & SVGA_IRQFLAG_FENCE_GOAL)
2683 && pFIFO[SVGA_FIFO_FENCE_GOAL] == pCmdFence->fence)
2684 {
2685 Log(("vmsvgaFIFOLoop: fence goal reached irq (fence=%x)\n", pCmdFence->fence));
2686 u32IrqStatus |= SVGA_IRQFLAG_FENCE_GOAL;
2687 }
2688 }
2689 else
2690 Log(("SVGA_CMD_FENCE is bogus when offFifoMin is %#x!\n", offFifoMin));
2691 break;
2692 }
2693 case SVGA_CMD_UPDATE:
2694 case SVGA_CMD_UPDATE_VERBOSE:
2695 {
2696 SVGAFifoCmdUpdate *pUpdate;
2697 VMSVGAFIFO_GET_CMD_BUFFER_BREAK(pUpdate, SVGAFifoCmdUpdate, sizeof(*pUpdate));
2698 Log(("vmsvgaFIFOLoop: UPDATE (%d,%d)(%d,%d)\n", pUpdate->x, pUpdate->y, pUpdate->width, pUpdate->height));
2699 vgaR3UpdateDisplay(pThis, pUpdate->x, pUpdate->y, pUpdate->width, pUpdate->height);
2700 break;
2701 }
2702
2703 case SVGA_CMD_DEFINE_CURSOR:
2704 {
2705 /* Followed by bitmap data. */
2706 SVGAFifoCmdDefineCursor *pCursor;
2707 VMSVGAFIFO_GET_CMD_BUFFER_BREAK(pCursor, SVGAFifoCmdDefineCursor, sizeof(*pCursor));
2708 AssertFailed(); /** @todo implement when necessary. */
2709 break;
2710 }
2711
2712 case SVGA_CMD_DEFINE_ALPHA_CURSOR:
2713 {
2714 /* Followed by bitmap data. */
2715 uint32_t cbCursorShape, cbAndMask;
2716 uint8_t *pCursorCopy;
2717 uint32_t cbCmd;
2718
2719 SVGAFifoCmdDefineAlphaCursor *pCursor;
2720 VMSVGAFIFO_GET_CMD_BUFFER_BREAK(pCursor, SVGAFifoCmdDefineAlphaCursor, sizeof(*pCursor));
2721
2722 Log(("vmsvgaFIFOLoop: ALPHA_CURSOR id=%d size (%d,%d) hotspot (%d,%d)\n", pCursor->id, pCursor->width, pCursor->height, pCursor->hotspotX, pCursor->hotspotY));
2723
2724 /* Check against a reasonable upper limit to prevent integer overflows in the sanity checks below. */
2725 AssertBreak(pCursor->height < 2048 && pCursor->width < 2048);
2726
2727 /* Refetch the bitmap data as well. */
2728 cbCmd = sizeof(SVGAFifoCmdDefineAlphaCursor) + pCursor->width * pCursor->height * sizeof(uint32_t) /* 32-bit BRGA format */;
2729 VMSVGAFIFO_GET_MORE_CMD_BUFFER_BREAK(pCursor, SVGAFifoCmdDefineAlphaCursor, cbCmd);
2730 /** @todo Would be more efficient to copy the data straight into pCursorCopy (memcpy below). */
2731
2732 /* The mouse pointer interface always expects an AND mask followed by the color data (XOR mask). */
2733 cbAndMask = (pCursor->width + 7) / 8 * pCursor->height; /* size of the AND mask */
2734 cbAndMask = ((cbAndMask + 3) & ~3); /* + gap for alignment */
2735 cbCursorShape = cbAndMask + pCursor->width * sizeof(uint32_t) * pCursor->height; /* + size of the XOR mask (32-bit BRGA format) */
2736
2737 pCursorCopy = (uint8_t *)RTMemAlloc(cbCursorShape);
2738 AssertBreak(pCursorCopy);
2739
2740 Log2(("Cursor data:\n%.*Rhxd\n", pCursor->width * pCursor->height * sizeof(uint32_t), pCursor+1));
2741
2742 /* Transparency is defined by the alpha bytes, so make the whole bitmap visible. */
2743 memset(pCursorCopy, 0xff, cbAndMask);
2744 /* Colour data */
2745 memcpy(pCursorCopy + cbAndMask, (pCursor + 1), pCursor->width * pCursor->height * sizeof(uint32_t));
2746
2747 rc = pThis->pDrv->pfnVBVAMousePointerShape (pThis->pDrv,
2748 true,
2749 true,
2750 pCursor->hotspotX,
2751 pCursor->hotspotY,
2752 pCursor->width,
2753 pCursor->height,
2754 pCursorCopy);
2755 AssertRC(rc);
2756
2757 if (pSVGAState->Cursor.fActive)
2758 RTMemFree(pSVGAState->Cursor.pData);
2759
2760 pSVGAState->Cursor.fActive = true;
2761 pSVGAState->Cursor.xHotspot = pCursor->hotspotX;
2762 pSVGAState->Cursor.yHotspot = pCursor->hotspotY;
2763 pSVGAState->Cursor.width = pCursor->width;
2764 pSVGAState->Cursor.height = pCursor->height;
2765 pSVGAState->Cursor.cbData = cbCursorShape;
2766 pSVGAState->Cursor.pData = pCursorCopy;
2767 break;
2768 }
2769
2770 case SVGA_CMD_ESCAPE:
2771 {
2772 /* Followed by nsize bytes of data. */
2773 SVGAFifoCmdEscape *pEscape;
2774 VMSVGAFIFO_GET_CMD_BUFFER_BREAK(pEscape, SVGAFifoCmdEscape, sizeof(*pEscape));
2775
2776 /* Refetch the command buffer with the variable data; undo size increase (ugly) */
2777 AssertBreak(pEscape->size < VMSVGA_FIFO_SIZE);
2778 uint32_t cbCmd = sizeof(SVGAFifoCmdEscape) + pEscape->size;
2779 VMSVGAFIFO_GET_MORE_CMD_BUFFER_BREAK(pEscape, SVGAFifoCmdEscape, cbCmd);
2780
2781 if (pEscape->nsid == SVGA_ESCAPE_NSID_VMWARE)
2782 {
2783 AssertBreak(pEscape->size >= sizeof(uint32_t));
2784 uint32_t cmd = *(uint32_t *)(pEscape + 1);
2785 Log(("vmsvgaFIFOLoop: ESCAPE (%x %x) VMWARE cmd=%x\n", pEscape->nsid, pEscape->size, cmd));
2786
2787 switch (cmd)
2788 {
2789 case SVGA_ESCAPE_VMWARE_VIDEO_SET_REGS:
2790 {
2791 SVGAEscapeVideoSetRegs *pVideoCmd = (SVGAEscapeVideoSetRegs *)(pEscape + 1);
2792 AssertBreak(pEscape->size >= sizeof(pVideoCmd->header));
2793 uint32_t cRegs = (pEscape->size - sizeof(pVideoCmd->header)) / sizeof(pVideoCmd->items[0]);
2794
2795 Log(("SVGA_ESCAPE_VMWARE_VIDEO_SET_REGS: stream %x\n", pVideoCmd->header.streamId));
2796 for (uint32_t iReg = 0; iReg < cRegs; iReg++)
2797 Log(("SVGA_ESCAPE_VMWARE_VIDEO_SET_REGS: reg %x val %x\n", pVideoCmd->items[iReg].registerId, pVideoCmd->items[iReg].value));
2798
2799 RT_NOREF_PV(pVideoCmd);
2800 break;
2801
2802 }
2803
2804 case SVGA_ESCAPE_VMWARE_VIDEO_FLUSH:
2805 {
2806 SVGAEscapeVideoFlush *pVideoCmd = (SVGAEscapeVideoFlush *)(pEscape + 1);
2807 AssertBreak(pEscape->size >= sizeof(*pVideoCmd));
2808 Log(("SVGA_ESCAPE_VMWARE_VIDEO_FLUSH: stream %x\n", pVideoCmd->streamId));
2809 RT_NOREF_PV(pVideoCmd);
2810 break;
2811 }
2812 }
2813 }
2814 else
2815 Log(("vmsvgaFIFOLoop: ESCAPE %x %x\n", pEscape->nsid, pEscape->size));
2816
2817 break;
2818 }
2819# ifdef VBOX_WITH_VMSVGA3D
2820 case SVGA_CMD_DEFINE_GMR2:
2821 {
2822 SVGAFifoCmdDefineGMR2 *pCmd;
2823 VMSVGAFIFO_GET_CMD_BUFFER_BREAK(pCmd, SVGAFifoCmdDefineGMR2, sizeof(*pCmd));
2824 Log(("vmsvgaFIFOLoop: SVGA_CMD_DEFINE_GMR2 id=%x %x pages\n", pCmd->gmrId, pCmd->numPages));
2825
2826 /* Validate current GMR id. */
2827 AssertBreak(pCmd->gmrId < VMSVGA_MAX_GMR_IDS);
2828 AssertBreak(pCmd->numPages <= VMSVGA_MAX_GMR_PAGES);
2829
2830 if (!pCmd->numPages)
2831 {
2832 vmsvgaGMRFree(pThis, pCmd->gmrId);
2833 }
2834 else
2835 {
2836 PGMR pGMR = &pSVGAState->aGMR[pCmd->gmrId];
2837 pGMR->cMaxPages = pCmd->numPages;
2838 }
2839 /* everything done in remap */
2840 break;
2841 }
2842
2843 case SVGA_CMD_REMAP_GMR2:
2844 {
2845 /* Followed by page descriptors or guest ptr. */
2846 SVGAFifoCmdRemapGMR2 *pCmd;
2847 VMSVGAFIFO_GET_CMD_BUFFER_BREAK(pCmd, SVGAFifoCmdRemapGMR2, sizeof(*pCmd));
2848 uint32_t cbPageDesc = (pCmd->flags & SVGA_REMAP_GMR2_PPN64) ? sizeof(uint64_t) : sizeof(uint32_t);
2849 uint32_t cbCmd;
2850 uint64_t *paNewPage64 = NULL;
2851
2852 Log(("vmsvgaFIFOLoop: SVGA_CMD_REMAP_GMR2 id=%x flags=%x offset=%x npages=%x\n", pCmd->gmrId, pCmd->flags, pCmd->offsetPages, pCmd->numPages));
2853 AssertBreak(pCmd->gmrId < VMSVGA_MAX_GMR_IDS);
2854
2855 /* Calculate the size of what comes after next and fetch it. */
2856 cbCmd = sizeof(SVGAFifoCmdRemapGMR2);
2857 if (pCmd->flags & SVGA_REMAP_GMR2_VIA_GMR)
2858 cbCmd += sizeof(SVGAGuestPtr);
2859 else
2860 if (pCmd->flags & SVGA_REMAP_GMR2_SINGLE_PPN)
2861 {
2862 cbCmd += cbPageDesc;
2863 pCmd->numPages = 1;
2864 }
2865 else
2866 {
2867 AssertBreak(pCmd->numPages <= VMSVGA_FIFO_SIZE);
2868 cbCmd += cbPageDesc * pCmd->numPages;
2869 }
2870 VMSVGAFIFO_GET_MORE_CMD_BUFFER_BREAK(pCmd, SVGAFifoCmdRemapGMR2, cbCmd);
2871
2872 /* Validate current GMR id. */
2873 AssertBreak(pCmd->gmrId < VMSVGA_MAX_GMR_IDS);
2874 PGMR pGMR = &pSVGAState->aGMR[pCmd->gmrId];
2875 AssertBreak(pCmd->offsetPages + pCmd->numPages <= pGMR->cMaxPages);
2876 AssertBreak(!pCmd->offsetPages || pGMR->paDesc); /** @todo */
2877
2878 /* Save the old page descriptors as an array of page addresses (>> PAGE_SHIFT) */
2879 if (pGMR->paDesc)
2880 {
2881 uint32_t idxPage = 0;
2882 paNewPage64 = (uint64_t *)RTMemAllocZ(pGMR->cMaxPages * sizeof(uint64_t));
2883 AssertBreak(paNewPage64);
2884
2885 for (uint32_t i = 0; i < pGMR->numDescriptors; i++)
2886 {
2887 for (uint32_t j = 0; j < pGMR->paDesc[i].numPages; j++)
2888 {
2889 paNewPage64[idxPage++] = (pGMR->paDesc[i].GCPhys + j * PAGE_SIZE) >> PAGE_SHIFT;
2890 }
2891 }
2892 AssertBreak(idxPage == pGMR->cbTotal >> PAGE_SHIFT);
2893 }
2894
2895 /* Free the old GMR if present. */
2896 if (pGMR->paDesc)
2897 RTMemFree(pGMR->paDesc);
2898
2899 /* Allocate the maximum amount possible (everything non-continuous) */
2900 pGMR->paDesc = (PVMSVGAGMRDESCRIPTOR)RTMemAllocZ(pGMR->cMaxPages * sizeof(VMSVGAGMRDESCRIPTOR));
2901 AssertBreak(pGMR->paDesc);
2902
2903 if (pCmd->flags & SVGA_REMAP_GMR2_VIA_GMR)
2904 {
2905 /** @todo */
2906 AssertFailed();
2907 }
2908 else
2909 {
2910 uint32_t *pPage32 = (uint32_t *)(pCmd + 1);
2911 uint64_t *pPage64 = (uint64_t *)(pCmd + 1);
2912 uint32_t iDescriptor = 0;
2913 RTGCPHYS GCPhys;
2914 bool fGCPhys64 = !!(pCmd->flags & SVGA_REMAP_GMR2_PPN64);
2915
2916 if (paNewPage64)
2917 {
2918 /* Overwrite the old page array with the new page values. */
2919 for (uint32_t i = pCmd->offsetPages; i < pCmd->offsetPages + pCmd->numPages; i++)
2920 {
2921 if (pCmd->flags & SVGA_REMAP_GMR2_PPN64)
2922 paNewPage64[i] = pPage64[i - pCmd->offsetPages];
2923 else
2924 paNewPage64[i] = pPage32[i - pCmd->offsetPages];
2925 }
2926 /* Use the updated page array instead of the command data. */
2927 fGCPhys64 = true;
2928 pPage64 = paNewPage64;
2929 pCmd->numPages = pGMR->cbTotal >> PAGE_SHIFT;
2930 }
2931
2932 if (fGCPhys64)
2933 GCPhys = (pPage64[0] << PAGE_SHIFT) & 0x00000FFFFFFFFFFFULL; /* seeing rubbish in the top bits with certain linux guests*/
2934 else
2935 GCPhys = (RTGCPHYS)pPage32[0] << PAGE_SHIFT;
2936
2937 pGMR->paDesc[0].GCPhys = GCPhys;
2938 pGMR->paDesc[0].numPages = 1;
2939 pGMR->cbTotal = PAGE_SIZE;
2940
2941 for (uint32_t i = 1; i < pCmd->numPages; i++)
2942 {
2943 if (pCmd->flags & SVGA_REMAP_GMR2_PPN64)
2944 GCPhys = (pPage64[i] << PAGE_SHIFT) & 0x00000FFFFFFFFFFFULL; /* seeing rubbish in the top bits with certain linux guests*/
2945 else
2946 GCPhys = (RTGCPHYS)pPage32[i] << PAGE_SHIFT;
2947
2948 /* Continuous physical memory? */
2949 if (GCPhys == pGMR->paDesc[iDescriptor].GCPhys + pGMR->paDesc[iDescriptor].numPages * PAGE_SIZE)
2950 {
2951 Assert(pGMR->paDesc[iDescriptor].numPages);
2952 pGMR->paDesc[iDescriptor].numPages++;
2953 LogFlow(("Page %x GCPhys=%RGp successor\n", i, GCPhys));
2954 }
2955 else
2956 {
2957 iDescriptor++;
2958 pGMR->paDesc[iDescriptor].GCPhys = GCPhys;
2959 pGMR->paDesc[iDescriptor].numPages = 1;
2960 LogFlow(("Page %x GCPhys=%RGp\n", i, pGMR->paDesc[iDescriptor].GCPhys));
2961 }
2962
2963 pGMR->cbTotal += PAGE_SIZE;
2964 }
2965 LogFlow(("Nr of descriptors %x\n", iDescriptor + 1));
2966 pGMR->numDescriptors = iDescriptor + 1;
2967 }
2968
2969 if (paNewPage64)
2970 RTMemFree(paNewPage64);
2971
2972# ifdef DEBUG_GMR_ACCESS
2973 VMR3ReqCallWait(PDMDevHlpGetVM(pThis->pDevInsR3), VMCPUID_ANY, (PFNRT)vmsvgaRegisterGMR, 2, pThis->pDevInsR3, pCmd->gmrId);
2974# endif
2975 break;
2976 }
2977# endif // VBOX_WITH_VMSVGA3D
2978 case SVGA_CMD_DEFINE_SCREEN:
2979 {
2980 /* Note! The size of this command is specified by the guest and depends on capabilities. */
2981 Assert(!(pThis->svga.pFIFOR3[SVGA_FIFO_CAPABILITIES] & SVGA_FIFO_CAP_SCREEN_OBJECT));
2982 SVGAFifoCmdDefineScreen *pCmd;
2983 VMSVGAFIFO_GET_CMD_BUFFER_BREAK(pCmd, SVGAFifoCmdDefineScreen, sizeof(pCmd->screen.structSize));
2984 RT_BZERO(&pCmd->screen.id, sizeof(*pCmd) - RT_OFFSETOF(SVGAFifoCmdDefineScreen, screen.structSize));
2985 VMSVGAFIFO_GET_MORE_CMD_BUFFER_BREAK(pCmd, SVGAFifoCmdDefineScreen, RT_MAX(sizeof(pCmd->screen.structSize), pCmd->screen.structSize));
2986
2987 Log(("vmsvgaFIFOLoop: SVGA_CMD_DEFINE_SCREEN id=%x flags=%x size=(%d,%d) root=(%d,%d)\n", pCmd->screen.id, pCmd->screen.flags, pCmd->screen.size.width, pCmd->screen.size.height, pCmd->screen.root.x, pCmd->screen.root.y));
2988 if (pCmd->screen.flags & SVGA_SCREEN_HAS_ROOT)
2989 Log(("vmsvgaFIFOLoop: SVGA_CMD_DEFINE_SCREEN flags SVGA_SCREEN_HAS_ROOT\n"));
2990 if (pCmd->screen.flags & SVGA_SCREEN_IS_PRIMARY)
2991 Log(("vmsvgaFIFOLoop: SVGA_CMD_DEFINE_SCREEN flags SVGA_SCREEN_IS_PRIMARY\n"));
2992 if (pCmd->screen.flags & SVGA_SCREEN_FULLSCREEN_HINT)
2993 Log(("vmsvgaFIFOLoop: SVGA_CMD_DEFINE_SCREEN flags SVGA_SCREEN_FULLSCREEN_HINT\n"));
2994 if (pCmd->screen.flags & SVGA_SCREEN_DEACTIVATE )
2995 Log(("vmsvgaFIFOLoop: SVGA_CMD_DEFINE_SCREEN flags SVGA_SCREEN_DEACTIVATE \n"));
2996 if (pCmd->screen.flags & SVGA_SCREEN_BLANKING)
2997 Log(("vmsvgaFIFOLoop: SVGA_CMD_DEFINE_SCREEN flags SVGA_SCREEN_BLANKING\n"));
2998
2999 /** @todo multi monitor support and screen object capabilities. */
3000 pThis->svga.uWidth = pCmd->screen.size.width;
3001 pThis->svga.uHeight = pCmd->screen.size.height;
3002 vmsvgaChangeMode(pThis);
3003 break;
3004 }
3005
3006 case SVGA_CMD_DESTROY_SCREEN:
3007 {
3008 SVGAFifoCmdDestroyScreen *pCmd;
3009 VMSVGAFIFO_GET_CMD_BUFFER_BREAK(pCmd, SVGAFifoCmdDestroyScreen, sizeof(*pCmd));
3010
3011 Log(("vmsvgaFIFOLoop: SVGA_CMD_DESTROY_SCREEN id=%x\n", pCmd->screenId));
3012 break;
3013 }
3014# ifdef VBOX_WITH_VMSVGA3D
3015 case SVGA_CMD_DEFINE_GMRFB:
3016 {
3017 SVGAFifoCmdDefineGMRFB *pCmd;
3018 VMSVGAFIFO_GET_CMD_BUFFER_BREAK(pCmd, SVGAFifoCmdDefineGMRFB, sizeof(*pCmd));
3019
3020 Log(("vmsvgaFIFOLoop: SVGA_CMD_DEFINE_GMRFB gmr=%x offset=%x bytesPerLine=%x bpp=%d color depth=%d\n", pCmd->ptr.gmrId, pCmd->ptr.offset, pCmd->bytesPerLine, pCmd->format.s.bitsPerPixel, pCmd->format.s.colorDepth));
3021 pSVGAState->GMRFB.ptr = pCmd->ptr;
3022 pSVGAState->GMRFB.bytesPerLine = pCmd->bytesPerLine;
3023 pSVGAState->GMRFB.format = pCmd->format;
3024 break;
3025 }
3026
3027 case SVGA_CMD_BLIT_GMRFB_TO_SCREEN:
3028 {
3029 uint32_t width, height;
3030 SVGAFifoCmdBlitGMRFBToScreen *pCmd;
3031 VMSVGAFIFO_GET_CMD_BUFFER_BREAK(pCmd, SVGAFifoCmdBlitGMRFBToScreen, sizeof(*pCmd));
3032
3033 Log(("vmsvgaFIFOLoop: SVGA_CMD_BLIT_GMRFB_TO_SCREEN src=(%d,%d) dest id=%d (%d,%d)(%d,%d)\n", pCmd->srcOrigin.x, pCmd->srcOrigin.y, pCmd->destScreenId, pCmd->destRect.left, pCmd->destRect.top, pCmd->destRect.right, pCmd->destRect.bottom));
3034
3035 /** @todo Support GMRFB.format.s.bitsPerPixel != pThis->svga.uBpp */
3036 AssertBreak(pSVGAState->GMRFB.format.s.bitsPerPixel == pThis->svga.uBpp);
3037 AssertBreak(pCmd->destScreenId == 0);
3038
3039 if (pCmd->destRect.left < 0)
3040 pCmd->destRect.left = 0;
3041 if (pCmd->destRect.top < 0)
3042 pCmd->destRect.top = 0;
3043 if (pCmd->destRect.right < 0)
3044 pCmd->destRect.right = 0;
3045 if (pCmd->destRect.bottom < 0)
3046 pCmd->destRect.bottom = 0;
3047
3048 width = pCmd->destRect.right - pCmd->destRect.left;
3049 height = pCmd->destRect.bottom - pCmd->destRect.top;
3050
3051 if ( width == 0
3052 || height == 0)
3053 break; /* Nothing to do. */
3054
3055 /* Clip to screen dimensions. */
3056 if (width > pThis->svga.uWidth)
3057 width = pThis->svga.uWidth;
3058 if (height > pThis->svga.uHeight)
3059 height = pThis->svga.uHeight;
3060
3061 unsigned offsetSource = (pCmd->srcOrigin.x * pSVGAState->GMRFB.format.s.bitsPerPixel) / 8 + pSVGAState->GMRFB.bytesPerLine * pCmd->srcOrigin.y;
3062 unsigned offsetDest = (pCmd->destRect.left * RT_ALIGN(pThis->svga.uBpp, 8)) / 8 + pThis->svga.cbScanline * pCmd->destRect.top;
3063 unsigned cbCopyWidth = (width * RT_ALIGN(pThis->svga.uBpp, 8)) / 8;
3064
3065 AssertBreak(offsetDest < pThis->vram_size);
3066
3067 rc = vmsvgaGMRTransfer(pThis, SVGA3D_WRITE_HOST_VRAM, pThis->CTX_SUFF(vram_ptr) + offsetDest, pThis->svga.cbScanline, pSVGAState->GMRFB.ptr, offsetSource, pSVGAState->GMRFB.bytesPerLine, cbCopyWidth, height);
3068 AssertRC(rc);
3069 vgaR3UpdateDisplay(pThis, pCmd->destRect.left, pCmd->destRect.top, pCmd->destRect.right - pCmd->destRect.left, pCmd->destRect.bottom - pCmd->destRect.top);
3070 break;
3071 }
3072
3073 case SVGA_CMD_BLIT_SCREEN_TO_GMRFB:
3074 {
3075 SVGAFifoCmdBlitScreenToGMRFB *pCmd;
3076 VMSVGAFIFO_GET_CMD_BUFFER_BREAK(pCmd, SVGAFifoCmdBlitScreenToGMRFB, sizeof(*pCmd));
3077
3078 /* Note! This can fetch 3d render results as well!! */
3079 Log(("vmsvgaFIFOLoop: SVGA_CMD_BLIT_SCREEN_TO_GMRFB dest=(%d,%d) src id=%d (%d,%d)(%d,%d)\n", pCmd->destOrigin.x, pCmd->destOrigin.y, pCmd->srcScreenId, pCmd->srcRect.left, pCmd->srcRect.top, pCmd->srcRect.right, pCmd->srcRect.bottom));
3080 AssertFailed();
3081 break;
3082 }
3083# endif // VBOX_WITH_VMSVGA3D
3084 case SVGA_CMD_ANNOTATION_FILL:
3085 {
3086 SVGAFifoCmdAnnotationFill *pCmd;
3087 VMSVGAFIFO_GET_CMD_BUFFER_BREAK(pCmd, SVGAFifoCmdAnnotationFill, sizeof(*pCmd));
3088
3089 Log(("vmsvgaFIFOLoop: SVGA_CMD_ANNOTATION_FILL red=%x green=%x blue=%x\n", pCmd->color.s.r, pCmd->color.s.g, pCmd->color.s.b));
3090 pSVGAState->colorAnnotation = pCmd->color;
3091 break;
3092 }
3093
3094 case SVGA_CMD_ANNOTATION_COPY:
3095 {
3096 SVGAFifoCmdAnnotationCopy *pCmd;
3097 VMSVGAFIFO_GET_CMD_BUFFER_BREAK(pCmd, SVGAFifoCmdAnnotationCopy, sizeof(*pCmd));
3098
3099 Log(("vmsvgaFIFOLoop: SVGA_CMD_ANNOTATION_COPY\n"));
3100 AssertFailed();
3101 break;
3102 }
3103
3104 /** @todo SVGA_CMD_RECT_COPY - see with ubuntu */
3105
3106 default:
3107# ifdef VBOX_WITH_VMSVGA3D
3108 if ( (int)enmCmdId >= SVGA_3D_CMD_BASE
3109 && (int)enmCmdId < SVGA_3D_CMD_MAX)
3110 {
3111 /* All 3d commands start with a common header, which defines the size of the command. */
3112 SVGA3dCmdHeader *pHdr;
3113 VMSVGAFIFO_GET_CMD_BUFFER_BREAK(pHdr, SVGA3dCmdHeader, sizeof(*pHdr));
3114 AssertBreak(pHdr->size < VMSVGA_FIFO_SIZE);
3115 uint32_t cbCmd = sizeof(SVGA3dCmdHeader) + pHdr->size;
3116 VMSVGAFIFO_GET_MORE_CMD_BUFFER_BREAK(pHdr, SVGA3dCmdHeader, cbCmd);
3117
3118/**
3119 * Check that the 3D command has at least a_cbMin of payload bytes after the
3120 * header. Will break out of the switch if it doesn't.
3121 */
3122# define VMSVGAFIFO_CHECK_3D_CMD_MIN_SIZE_BREAK(a_cbMin) \
3123 AssertMsgBreak((a_cbMin) <= pHdr->size, ("size=%#x a_cbMin=%#zx\n", pHdr->size, (size_t)(a_cbMin)))
3124 switch ((int)enmCmdId)
3125 {
3126 case SVGA_3D_CMD_SURFACE_DEFINE:
3127 {
3128 uint32_t cMipLevels;
3129 SVGA3dCmdDefineSurface *pCmd = (SVGA3dCmdDefineSurface *)(pHdr + 1);
3130 VMSVGAFIFO_CHECK_3D_CMD_MIN_SIZE_BREAK(sizeof(*pCmd));
3131
3132 cMipLevels = (pHdr->size - sizeof(*pCmd)) / sizeof(SVGA3dSize);
3133 rc = vmsvga3dSurfaceDefine(pThis, pCmd->sid, (uint32_t)pCmd->surfaceFlags, pCmd->format, pCmd->face, 0,
3134 SVGA3D_TEX_FILTER_NONE, cMipLevels, (SVGA3dSize *)(pCmd + 1));
3135# ifdef DEBUG_GMR_ACCESS
3136 VMR3ReqCallWait(PDMDevHlpGetVM(pThis->pDevInsR3), VMCPUID_ANY, (PFNRT)vmsvgaResetGMRHandlers, 1, pThis);
3137# endif
3138 break;
3139 }
3140
3141 case SVGA_3D_CMD_SURFACE_DEFINE_V2:
3142 {
3143 uint32_t cMipLevels;
3144 SVGA3dCmdDefineSurface_v2 *pCmd = (SVGA3dCmdDefineSurface_v2 *)(pHdr + 1);
3145 VMSVGAFIFO_CHECK_3D_CMD_MIN_SIZE_BREAK(sizeof(*pCmd));
3146
3147 cMipLevels = (pHdr->size - sizeof(*pCmd)) / sizeof(SVGA3dSize);
3148 rc = vmsvga3dSurfaceDefine(pThis, pCmd->sid, pCmd->surfaceFlags, pCmd->format, pCmd->face,
3149 pCmd->multisampleCount, pCmd->autogenFilter,
3150 cMipLevels, (SVGA3dSize *)(pCmd + 1));
3151 break;
3152 }
3153
3154 case SVGA_3D_CMD_SURFACE_DESTROY:
3155 {
3156 SVGA3dCmdDestroySurface *pCmd = (SVGA3dCmdDestroySurface *)(pHdr + 1);
3157 VMSVGAFIFO_CHECK_3D_CMD_MIN_SIZE_BREAK(sizeof(*pCmd));
3158 rc = vmsvga3dSurfaceDestroy(pThis, pCmd->sid);
3159 break;
3160 }
3161
3162 case SVGA_3D_CMD_SURFACE_COPY:
3163 {
3164 uint32_t cCopyBoxes;
3165 SVGA3dCmdSurfaceCopy *pCmd = (SVGA3dCmdSurfaceCopy *)(pHdr + 1);
3166 VMSVGAFIFO_CHECK_3D_CMD_MIN_SIZE_BREAK(sizeof(*pCmd));
3167
3168 cCopyBoxes = (pHdr->size - sizeof(pCmd)) / sizeof(SVGA3dCopyBox);
3169 rc = vmsvga3dSurfaceCopy(pThis, pCmd->dest, pCmd->src, cCopyBoxes, (SVGA3dCopyBox *)(pCmd + 1));
3170 break;
3171 }
3172
3173 case SVGA_3D_CMD_SURFACE_STRETCHBLT:
3174 {
3175 SVGA3dCmdSurfaceStretchBlt *pCmd = (SVGA3dCmdSurfaceStretchBlt *)(pHdr + 1);
3176 VMSVGAFIFO_CHECK_3D_CMD_MIN_SIZE_BREAK(sizeof(*pCmd));
3177
3178 rc = vmsvga3dSurfaceStretchBlt(pThis, &pCmd->dest, &pCmd->boxDest, &pCmd->src, &pCmd->boxSrc, pCmd->mode);
3179 break;
3180 }
3181
3182 case SVGA_3D_CMD_SURFACE_DMA:
3183 {
3184 uint32_t cCopyBoxes;
3185 SVGA3dCmdSurfaceDMA *pCmd = (SVGA3dCmdSurfaceDMA *)(pHdr + 1);
3186 VMSVGAFIFO_CHECK_3D_CMD_MIN_SIZE_BREAK(sizeof(*pCmd));
3187
3188 cCopyBoxes = (pHdr->size - sizeof(*pCmd)) / sizeof(SVGA3dCopyBox);
3189 STAM_PROFILE_START(&pSVGAState->StatR3CmdSurfaceDMA, a);
3190 rc = vmsvga3dSurfaceDMA(pThis, pCmd->guest, pCmd->host, pCmd->transfer, cCopyBoxes, (SVGA3dCopyBox *)(pCmd + 1));
3191 STAM_PROFILE_STOP(&pSVGAState->StatR3CmdSurfaceDMA, a);
3192 break;
3193 }
3194
3195 case SVGA_3D_CMD_BLIT_SURFACE_TO_SCREEN:
3196 {
3197 uint32_t cRects;
3198 SVGA3dCmdBlitSurfaceToScreen *pCmd = (SVGA3dCmdBlitSurfaceToScreen *)(pHdr + 1);
3199 VMSVGAFIFO_CHECK_3D_CMD_MIN_SIZE_BREAK(sizeof(*pCmd));
3200
3201 cRects = (pHdr->size - sizeof(*pCmd)) / sizeof(SVGASignedRect);
3202 rc = vmsvga3dSurfaceBlitToScreen(pThis, pCmd->destScreenId, pCmd->destRect, pCmd->srcImage, pCmd->srcRect, cRects, (SVGASignedRect *)(pCmd + 1));
3203 break;
3204 }
3205
3206 case SVGA_3D_CMD_CONTEXT_DEFINE:
3207 {
3208 SVGA3dCmdDefineContext *pCmd = (SVGA3dCmdDefineContext *)(pHdr + 1);
3209 VMSVGAFIFO_CHECK_3D_CMD_MIN_SIZE_BREAK(sizeof(*pCmd));
3210
3211 rc = vmsvga3dContextDefine(pThis, pCmd->cid);
3212 break;
3213 }
3214
3215 case SVGA_3D_CMD_CONTEXT_DESTROY:
3216 {
3217 SVGA3dCmdDestroyContext *pCmd = (SVGA3dCmdDestroyContext *)(pHdr + 1);
3218 VMSVGAFIFO_CHECK_3D_CMD_MIN_SIZE_BREAK(sizeof(*pCmd));
3219
3220 rc = vmsvga3dContextDestroy(pThis, pCmd->cid);
3221 break;
3222 }
3223
3224 case SVGA_3D_CMD_SETTRANSFORM:
3225 {
3226 SVGA3dCmdSetTransform *pCmd = (SVGA3dCmdSetTransform *)(pHdr + 1);
3227 VMSVGAFIFO_CHECK_3D_CMD_MIN_SIZE_BREAK(sizeof(*pCmd));
3228
3229 rc = vmsvga3dSetTransform(pThis, pCmd->cid, pCmd->type, pCmd->matrix);
3230 break;
3231 }
3232
3233 case SVGA_3D_CMD_SETZRANGE:
3234 {
3235 SVGA3dCmdSetZRange *pCmd = (SVGA3dCmdSetZRange *)(pHdr + 1);
3236 VMSVGAFIFO_CHECK_3D_CMD_MIN_SIZE_BREAK(sizeof(*pCmd));
3237
3238 rc = vmsvga3dSetZRange(pThis, pCmd->cid, pCmd->zRange);
3239 break;
3240 }
3241
3242 case SVGA_3D_CMD_SETRENDERSTATE:
3243 {
3244 uint32_t cRenderStates;
3245 SVGA3dCmdSetRenderState *pCmd = (SVGA3dCmdSetRenderState *)(pHdr + 1);
3246 VMSVGAFIFO_CHECK_3D_CMD_MIN_SIZE_BREAK(sizeof(*pCmd));
3247
3248 cRenderStates = (pHdr->size - sizeof(*pCmd)) / sizeof(SVGA3dRenderState);
3249 rc = vmsvga3dSetRenderState(pThis, pCmd->cid, cRenderStates, (SVGA3dRenderState *)(pCmd + 1));
3250 break;
3251 }
3252
3253 case SVGA_3D_CMD_SETRENDERTARGET:
3254 {
3255 SVGA3dCmdSetRenderTarget *pCmd = (SVGA3dCmdSetRenderTarget *)(pHdr + 1);
3256 VMSVGAFIFO_CHECK_3D_CMD_MIN_SIZE_BREAK(sizeof(*pCmd));
3257
3258 rc = vmsvga3dSetRenderTarget(pThis, pCmd->cid, pCmd->type, pCmd->target);
3259 break;
3260 }
3261
3262 case SVGA_3D_CMD_SETTEXTURESTATE:
3263 {
3264 uint32_t cTextureStates;
3265 SVGA3dCmdSetTextureState *pCmd = (SVGA3dCmdSetTextureState *)(pHdr + 1);
3266 VMSVGAFIFO_CHECK_3D_CMD_MIN_SIZE_BREAK(sizeof(*pCmd));
3267
3268 cTextureStates = (pHdr->size - sizeof(*pCmd)) / sizeof(SVGA3dTextureState);
3269 rc = vmsvga3dSetTextureState(pThis, pCmd->cid, cTextureStates, (SVGA3dTextureState *)(pCmd + 1));
3270 break;
3271 }
3272
3273 case SVGA_3D_CMD_SETMATERIAL:
3274 {
3275 SVGA3dCmdSetMaterial *pCmd = (SVGA3dCmdSetMaterial *)(pHdr + 1);
3276 VMSVGAFIFO_CHECK_3D_CMD_MIN_SIZE_BREAK(sizeof(*pCmd));
3277
3278 rc = vmsvga3dSetMaterial(pThis, pCmd->cid, pCmd->face, &pCmd->material);
3279 break;
3280 }
3281
3282 case SVGA_3D_CMD_SETLIGHTDATA:
3283 {
3284 SVGA3dCmdSetLightData *pCmd = (SVGA3dCmdSetLightData *)(pHdr + 1);
3285 VMSVGAFIFO_CHECK_3D_CMD_MIN_SIZE_BREAK(sizeof(*pCmd));
3286
3287 rc = vmsvga3dSetLightData(pThis, pCmd->cid, pCmd->index, &pCmd->data);
3288 break;
3289 }
3290
3291 case SVGA_3D_CMD_SETLIGHTENABLED:
3292 {
3293 SVGA3dCmdSetLightEnabled *pCmd = (SVGA3dCmdSetLightEnabled *)(pHdr + 1);
3294 VMSVGAFIFO_CHECK_3D_CMD_MIN_SIZE_BREAK(sizeof(*pCmd));
3295
3296 rc = vmsvga3dSetLightEnabled(pThis, pCmd->cid, pCmd->index, pCmd->enabled);
3297 break;
3298 }
3299
3300 case SVGA_3D_CMD_SETVIEWPORT:
3301 {
3302 SVGA3dCmdSetViewport *pCmd = (SVGA3dCmdSetViewport *)(pHdr + 1);
3303 VMSVGAFIFO_CHECK_3D_CMD_MIN_SIZE_BREAK(sizeof(*pCmd));
3304
3305 rc = vmsvga3dSetViewPort(pThis, pCmd->cid, &pCmd->rect);
3306 break;
3307 }
3308
3309 case SVGA_3D_CMD_SETCLIPPLANE:
3310 {
3311 SVGA3dCmdSetClipPlane *pCmd = (SVGA3dCmdSetClipPlane *)(pHdr + 1);
3312 VMSVGAFIFO_CHECK_3D_CMD_MIN_SIZE_BREAK(sizeof(*pCmd));
3313
3314 rc = vmsvga3dSetClipPlane(pThis, pCmd->cid, pCmd->index, pCmd->plane);
3315 break;
3316 }
3317
3318 case SVGA_3D_CMD_CLEAR:
3319 {
3320 SVGA3dCmdClear *pCmd = (SVGA3dCmdClear *)(pHdr + 1);
3321 VMSVGAFIFO_CHECK_3D_CMD_MIN_SIZE_BREAK(sizeof(*pCmd));
3322 uint32_t cRects;
3323
3324 cRects = (pHdr->size - sizeof(*pCmd)) / sizeof(SVGA3dRect);
3325 rc = vmsvga3dCommandClear(pThis, pCmd->cid, pCmd->clearFlag, pCmd->color, pCmd->depth, pCmd->stencil, cRects, (SVGA3dRect *)(pCmd + 1));
3326 break;
3327 }
3328
3329 case SVGA_3D_CMD_PRESENT:
3330 case SVGA_3D_CMD_PRESENT_READBACK: /** @todo SVGA_3D_CMD_PRESENT_READBACK isn't quite the same as present... */
3331 {
3332 SVGA3dCmdPresent *pCmd = (SVGA3dCmdPresent *)(pHdr + 1);
3333 VMSVGAFIFO_CHECK_3D_CMD_MIN_SIZE_BREAK(sizeof(*pCmd));
3334 uint32_t cRects;
3335
3336 cRects = (pHdr->size - sizeof(*pCmd)) / sizeof(SVGA3dCopyRect);
3337
3338 STAM_PROFILE_START(&pSVGAState->StatR3CmdPresent, a);
3339 rc = vmsvga3dCommandPresent(pThis, pCmd->sid, cRects, (SVGA3dCopyRect *)(pCmd + 1));
3340 STAM_PROFILE_STOP(&pSVGAState->StatR3CmdPresent, a);
3341 break;
3342 }
3343
3344 case SVGA_3D_CMD_SHADER_DEFINE:
3345 {
3346 SVGA3dCmdDefineShader *pCmd = (SVGA3dCmdDefineShader *)(pHdr + 1);
3347 VMSVGAFIFO_CHECK_3D_CMD_MIN_SIZE_BREAK(sizeof(*pCmd));
3348 uint32_t cbData;
3349
3350 cbData = (pHdr->size - sizeof(*pCmd));
3351 rc = vmsvga3dShaderDefine(pThis, pCmd->cid, pCmd->shid, pCmd->type, cbData, (uint32_t *)(pCmd + 1));
3352 break;
3353 }
3354
3355 case SVGA_3D_CMD_SHADER_DESTROY:
3356 {
3357 SVGA3dCmdDestroyShader *pCmd = (SVGA3dCmdDestroyShader *)(pHdr + 1);
3358 VMSVGAFIFO_CHECK_3D_CMD_MIN_SIZE_BREAK(sizeof(*pCmd));
3359
3360 rc = vmsvga3dShaderDestroy(pThis, pCmd->cid, pCmd->shid, pCmd->type);
3361 break;
3362 }
3363
3364 case SVGA_3D_CMD_SET_SHADER:
3365 {
3366 SVGA3dCmdSetShader *pCmd = (SVGA3dCmdSetShader *)(pHdr + 1);
3367 VMSVGAFIFO_CHECK_3D_CMD_MIN_SIZE_BREAK(sizeof(*pCmd));
3368
3369 rc = vmsvga3dShaderSet(pThis, NULL, pCmd->cid, pCmd->type, pCmd->shid);
3370 break;
3371 }
3372
3373 case SVGA_3D_CMD_SET_SHADER_CONST:
3374 {
3375 SVGA3dCmdSetShaderConst *pCmd = (SVGA3dCmdSetShaderConst *)(pHdr + 1);
3376 VMSVGAFIFO_CHECK_3D_CMD_MIN_SIZE_BREAK(sizeof(*pCmd));
3377
3378 uint32_t cRegisters = (pHdr->size - sizeof(*pCmd)) / sizeof(pCmd->values) + 1;
3379 rc = vmsvga3dShaderSetConst(pThis, pCmd->cid, pCmd->reg, pCmd->type, pCmd->ctype, cRegisters, pCmd->values);
3380 break;
3381 }
3382
3383 case SVGA_3D_CMD_DRAW_PRIMITIVES:
3384 {
3385 SVGA3dCmdDrawPrimitives *pCmd = (SVGA3dCmdDrawPrimitives *)(pHdr + 1);
3386 VMSVGAFIFO_CHECK_3D_CMD_MIN_SIZE_BREAK(sizeof(*pCmd));
3387 uint32_t cVertexDivisor;
3388
3389 cVertexDivisor = (pHdr->size - sizeof(*pCmd) - sizeof(SVGA3dVertexDecl) * pCmd->numVertexDecls - sizeof(SVGA3dPrimitiveRange) * pCmd->numRanges);
3390 Assert(pCmd->numRanges <= SVGA3D_MAX_DRAW_PRIMITIVE_RANGES);
3391 Assert(pCmd->numVertexDecls <= SVGA3D_MAX_VERTEX_ARRAYS);
3392 Assert(!cVertexDivisor || cVertexDivisor == pCmd->numVertexDecls);
3393
3394 SVGA3dVertexDecl *pVertexDecl = (SVGA3dVertexDecl *)(pCmd + 1);
3395 SVGA3dPrimitiveRange *pNumRange = (SVGA3dPrimitiveRange *) (&pVertexDecl[pCmd->numVertexDecls]);
3396 SVGA3dVertexDivisor *pVertexDivisor = (cVertexDivisor) ? (SVGA3dVertexDivisor *)(&pNumRange[pCmd->numRanges]) : NULL;
3397
3398 STAM_PROFILE_START(&pSVGAState->StatR3CmdDrawPrimitive, a);
3399 rc = vmsvga3dDrawPrimitives(pThis, pCmd->cid, pCmd->numVertexDecls, pVertexDecl, pCmd->numRanges, pNumRange, cVertexDivisor, pVertexDivisor);
3400 STAM_PROFILE_STOP(&pSVGAState->StatR3CmdDrawPrimitive, a);
3401 break;
3402 }
3403
3404 case SVGA_3D_CMD_SETSCISSORRECT:
3405 {
3406 SVGA3dCmdSetScissorRect *pCmd = (SVGA3dCmdSetScissorRect *)(pHdr + 1);
3407 VMSVGAFIFO_CHECK_3D_CMD_MIN_SIZE_BREAK(sizeof(*pCmd));
3408
3409 rc = vmsvga3dSetScissorRect(pThis, pCmd->cid, &pCmd->rect);
3410 break;
3411 }
3412
3413 case SVGA_3D_CMD_BEGIN_QUERY:
3414 {
3415 SVGA3dCmdBeginQuery *pCmd = (SVGA3dCmdBeginQuery *)(pHdr + 1);
3416 VMSVGAFIFO_CHECK_3D_CMD_MIN_SIZE_BREAK(sizeof(*pCmd));
3417
3418 rc = vmsvga3dQueryBegin(pThis, pCmd->cid, pCmd->type);
3419 break;
3420 }
3421
3422 case SVGA_3D_CMD_END_QUERY:
3423 {
3424 SVGA3dCmdEndQuery *pCmd = (SVGA3dCmdEndQuery *)(pHdr + 1);
3425 VMSVGAFIFO_CHECK_3D_CMD_MIN_SIZE_BREAK(sizeof(*pCmd));
3426
3427 rc = vmsvga3dQueryEnd(pThis, pCmd->cid, pCmd->type, pCmd->guestResult);
3428 break;
3429 }
3430
3431 case SVGA_3D_CMD_WAIT_FOR_QUERY:
3432 {
3433 SVGA3dCmdWaitForQuery *pCmd = (SVGA3dCmdWaitForQuery *)(pHdr + 1);
3434 VMSVGAFIFO_CHECK_3D_CMD_MIN_SIZE_BREAK(sizeof(*pCmd));
3435
3436 rc = vmsvga3dQueryWait(pThis, pCmd->cid, pCmd->type, pCmd->guestResult);
3437 break;
3438 }
3439
3440 case SVGA_3D_CMD_GENERATE_MIPMAPS:
3441 {
3442 SVGA3dCmdGenerateMipmaps *pCmd = (SVGA3dCmdGenerateMipmaps *)(pHdr + 1);
3443 VMSVGAFIFO_CHECK_3D_CMD_MIN_SIZE_BREAK(sizeof(*pCmd));
3444
3445 rc = vmsvga3dGenerateMipmaps(pThis, pCmd->sid, pCmd->filter);
3446 break;
3447 }
3448
3449 case SVGA_3D_CMD_ACTIVATE_SURFACE:
3450 case SVGA_3D_CMD_DEACTIVATE_SURFACE:
3451 /* context id + surface id? */
3452 break;
3453
3454 default:
3455 STAM_REL_COUNTER_INC(&pSVGAState->StatFifoUnkCmds);
3456 AssertFailed();
3457 break;
3458 }
3459 }
3460 else
3461# endif // VBOX_WITH_VMSVGA3D
3462 {
3463 STAM_REL_COUNTER_INC(&pSVGAState->StatFifoUnkCmds);
3464 AssertFailed();
3465 }
3466 }
3467
3468 /* Go to the next slot */
3469 Assert(cbPayload + sizeof(uint32_t) <= offFifoMax - offFifoMin);
3470 offCurrentCmd += RT_ALIGN_32(cbPayload + sizeof(uint32_t), sizeof(uint32_t));
3471 if (offCurrentCmd >= offFifoMax)
3472 {
3473 offCurrentCmd -= offFifoMax - offFifoMin;
3474 Assert(offCurrentCmd >= offFifoMin);
3475 Assert(offCurrentCmd < offFifoMax);
3476 }
3477 ASMAtomicWriteU32(&pFIFO[SVGA_FIFO_STOP], offCurrentCmd);
3478 STAM_REL_COUNTER_INC(&pSVGAState->StatFifoCommands);
3479
3480 /*
3481 * Raise IRQ if required. Must enter the critical section here
3482 * before making final decisions here, otherwise cubebench and
3483 * others may end up waiting forever.
3484 */
3485 if ( u32IrqStatus
3486 || (pThis->svga.u32IrqMask & SVGA_IRQFLAG_FIFO_PROGRESS))
3487 {
3488 PDMCritSectEnter(&pThis->CritSect, VERR_IGNORED);
3489
3490 /* FIFO progress might trigger an interrupt. */
3491 if (pThis->svga.u32IrqMask & SVGA_IRQFLAG_FIFO_PROGRESS)
3492 {
3493 Log(("vmsvgaFIFOLoop: fifo progress irq\n"));
3494 u32IrqStatus |= SVGA_IRQFLAG_FIFO_PROGRESS;
3495 }
3496
3497 /* Unmasked IRQ pending? */
3498 if (pThis->svga.u32IrqMask & u32IrqStatus)
3499 {
3500 Log(("vmsvgaFIFOLoop: Trigger interrupt with status %x\n", u32IrqStatus));
3501 ASMAtomicOrU32(&pThis->svga.u32IrqStatus, u32IrqStatus);
3502 PDMDevHlpPCISetIrq(pDevIns, 0, 1);
3503 }
3504
3505 PDMCritSectLeave(&pThis->CritSect);
3506 }
3507 }
3508
3509 /* If really done, clear the busy flag. */
3510 if (fDone)
3511 {
3512 Log(("vmsvgaFIFOLoop: emptied the FIFO next=%x stop=%x\n", pFIFO[SVGA_FIFO_NEXT_CMD], offCurrentCmd));
3513 vmsvgaFifoSetNotBusy(pThis, pSVGAState, offFifoMin);
3514 }
3515 }
3516
3517 /*
3518 * Free the bounce buffer. (There are no returns above!)
3519 */
3520 RTMemFree(pbBounceBuf);
3521
3522 return VINF_SUCCESS;
3523}
3524
3525/**
3526 * Free the specified GMR
3527 *
3528 * @param pThis VGA device instance data.
3529 * @param idGMR GMR id
3530 */
3531void vmsvgaGMRFree(PVGASTATE pThis, uint32_t idGMR)
3532{
3533 PVMSVGAR3STATE pSVGAState = pThis->svga.pSvgaR3State;
3534
3535 /* Free the old descriptor if present. */
3536 if (pSVGAState->aGMR[idGMR].numDescriptors)
3537 {
3538 PGMR pGMR = &pSVGAState->aGMR[idGMR];
3539# ifdef DEBUG_GMR_ACCESS
3540 VMR3ReqCallWait(PDMDevHlpGetVM(pThis->pDevInsR3), VMCPUID_ANY, (PFNRT)vmsvgaDeregisterGMR, 2, pThis->pDevInsR3, idGMR);
3541# endif
3542
3543 Assert(pGMR->paDesc);
3544 RTMemFree(pGMR->paDesc);
3545 pGMR->paDesc = NULL;
3546 pGMR->numDescriptors = 0;
3547 pGMR->cbTotal = 0;
3548 pGMR->cMaxPages = 0;
3549 }
3550 Assert(!pSVGAState->aGMR[idGMR].cbTotal);
3551}
3552
3553/**
3554 * Copy from a GMR to host memory or vice versa
3555 *
3556 * @returns VBox status code.
3557 * @param pThis VGA device instance data.
3558 * @param enmTransferType Transfer type (read/write)
3559 * @param pbDst Host destination pointer
3560 * @param cbDestPitch Destination buffer pitch
3561 * @param src GMR description
3562 * @param offSrc Source buffer offset
3563 * @param cbSrcPitch Source buffer pitch
3564 * @param cbWidth Source width in bytes
3565 * @param cHeight Source height
3566 */
3567int vmsvgaGMRTransfer(PVGASTATE pThis, const SVGA3dTransferType enmTransferType, uint8_t *pbDst, int32_t cbDestPitch,
3568 SVGAGuestPtr src, uint32_t offSrc, int32_t cbSrcPitch, uint32_t cbWidth, uint32_t cHeight)
3569{
3570 PVMSVGAR3STATE pSVGAState = pThis->svga.pSvgaR3State;
3571 PGMR pGMR;
3572 int rc;
3573 PVMSVGAGMRDESCRIPTOR pDesc;
3574 unsigned offDesc = 0;
3575
3576 Log(("vmsvgaGMRTransfer: gmr=%x offset=%x pitch=%d cbWidth=%d cHeight=%d; src offset=%d src pitch=%d\n",
3577 src.gmrId, src.offset, cbDestPitch, cbWidth, cHeight, offSrc, cbSrcPitch));
3578 Assert(cbWidth && cHeight);
3579
3580 /* Shortcut for the framebuffer. */
3581 if (src.gmrId == SVGA_GMR_FRAMEBUFFER)
3582 {
3583 offSrc += src.offset;
3584 AssertMsgReturn(src.offset < pThis->vram_size,
3585 ("src.offset=%#x offSrc=%#x cbSrcPitch=%#x cHeight=%#x cbWidth=%#x vram_size=%#x\n",
3586 src.offset, offSrc, cbSrcPitch, cHeight, cbWidth, pThis->vram_size),
3587 VERR_INVALID_PARAMETER);
3588 AssertMsgReturn(offSrc + cbSrcPitch * (cHeight - 1) + cbWidth <= pThis->vram_size,
3589 ("src.offset=%#x offSrc=%#x cbSrcPitch=%#x cHeight=%#x cbWidth=%#x vram_size=%#x\n",
3590 src.offset, offSrc, cbSrcPitch, cHeight, cbWidth, pThis->vram_size),
3591 VERR_INVALID_PARAMETER);
3592
3593 uint8_t *pSrc = pThis->CTX_SUFF(vram_ptr) + offSrc;
3594
3595 if (enmTransferType == SVGA3D_READ_HOST_VRAM)
3596 {
3597 /* switch src & dest */
3598 uint8_t *pTemp = pbDst;
3599 int32_t cbTempPitch = cbDestPitch;
3600
3601 pbDst = pSrc;
3602 pSrc = pTemp;
3603
3604 cbDestPitch = cbSrcPitch;
3605 cbSrcPitch = cbTempPitch;
3606 }
3607
3608 if ( pThis->svga.cbScanline == (uint32_t)cbDestPitch
3609 && cbWidth == (uint32_t)cbDestPitch
3610 && cbSrcPitch == cbDestPitch)
3611 {
3612 memcpy(pbDst, pSrc, cbWidth * cHeight);
3613 }
3614 else
3615 {
3616 for(uint32_t i = 0; i < cHeight; i++)
3617 {
3618 memcpy(pbDst, pSrc, cbWidth);
3619
3620 pbDst += cbDestPitch;
3621 pSrc += cbSrcPitch;
3622 }
3623 }
3624 return VINF_SUCCESS;
3625 }
3626
3627 AssertReturn(src.gmrId < VMSVGA_MAX_GMR_IDS, VERR_INVALID_PARAMETER);
3628 pGMR = &pSVGAState->aGMR[src.gmrId];
3629 pDesc = pGMR->paDesc;
3630
3631 offSrc += src.offset;
3632 AssertMsgReturn(src.offset < pGMR->cbTotal,
3633 ("src.gmrId=%#x src.offset=%#x offSrc=%#x cbSrcPitch=%#x cHeight=%#x cbWidth=%#x cbTotal=%#x\n",
3634 src.gmrId, src.offset, offSrc, cbSrcPitch, cHeight, cbWidth, pGMR->cbTotal),
3635 VERR_INVALID_PARAMETER);
3636 AssertMsgReturn(offSrc + cbSrcPitch * (cHeight - 1) + cbWidth <= pGMR->cbTotal,
3637 ("src.gmrId=%#x src.offset=%#x offSrc=%#x cbSrcPitch=%#x cHeight=%#x cbWidth=%#x cbTotal=%#x\n",
3638 src.gmrId, src.offset, offSrc, cbSrcPitch, cHeight, cbWidth, pGMR->cbTotal),
3639 VERR_INVALID_PARAMETER);
3640
3641 for (uint32_t i = 0; i < cHeight; i++)
3642 {
3643 uint32_t cbCurrentWidth = cbWidth;
3644 uint32_t offCurrent = offSrc;
3645 uint8_t *pCurrentDest = pbDst;
3646
3647 /* Find the right descriptor */
3648 while (offDesc + pDesc->numPages * PAGE_SIZE <= offCurrent)
3649 {
3650 offDesc += pDesc->numPages * PAGE_SIZE;
3651 AssertReturn(offDesc < pGMR->cbTotal, VERR_INTERNAL_ERROR); /* overflow protection */
3652 pDesc++;
3653 }
3654
3655 while (cbCurrentWidth)
3656 {
3657 uint32_t cbToCopy;
3658
3659 if (offCurrent + cbCurrentWidth <= offDesc + pDesc->numPages * PAGE_SIZE)
3660 {
3661 cbToCopy = cbCurrentWidth;
3662 }
3663 else
3664 {
3665 cbToCopy = (offDesc + pDesc->numPages * PAGE_SIZE - offCurrent);
3666 AssertReturn(cbToCopy <= cbCurrentWidth, VERR_INVALID_PARAMETER);
3667 }
3668
3669 LogFlow(("vmsvgaGMRTransfer: %s phys=%RGp\n", (enmTransferType == SVGA3D_WRITE_HOST_VRAM) ? "READ" : "WRITE", pDesc->GCPhys + offCurrent - offDesc));
3670
3671 if (enmTransferType == SVGA3D_WRITE_HOST_VRAM)
3672 rc = PDMDevHlpPhysRead(pThis->CTX_SUFF(pDevIns), pDesc->GCPhys + offCurrent - offDesc, pCurrentDest, cbToCopy);
3673 else
3674 rc = PDMDevHlpPhysWrite(pThis->CTX_SUFF(pDevIns), pDesc->GCPhys + offCurrent - offDesc, pCurrentDest, cbToCopy);
3675 AssertRCBreak(rc);
3676
3677 cbCurrentWidth -= cbToCopy;
3678 offCurrent += cbToCopy;
3679 pCurrentDest += cbToCopy;
3680
3681 /* Go to the next descriptor if there's anything left. */
3682 if (cbCurrentWidth)
3683 {
3684 offDesc += pDesc->numPages * PAGE_SIZE;
3685 pDesc++;
3686 }
3687 }
3688
3689 offSrc += cbSrcPitch;
3690 pbDst += cbDestPitch;
3691 }
3692
3693 return VINF_SUCCESS;
3694}
3695
3696/**
3697 * Unblock the FIFO I/O thread so it can respond to a state change.
3698 *
3699 * @returns VBox status code.
3700 * @param pDevIns The VGA device instance.
3701 * @param pThread The send thread.
3702 */
3703static DECLCALLBACK(int) vmsvgaFIFOLoopWakeUp(PPDMDEVINS pDevIns, PPDMTHREAD pThread)
3704{
3705 RT_NOREF(pDevIns);
3706 PVGASTATE pThis = (PVGASTATE)pThread->pvUser;
3707 Log(("vmsvgaFIFOLoopWakeUp\n"));
3708 return SUPSemEventSignal(pThis->svga.pSupDrvSession, pThis->svga.FIFORequestSem);
3709}
3710
3711/**
3712 * Enables or disables dirty page tracking for the framebuffer
3713 *
3714 * @param pThis VGA device instance data.
3715 * @param fTraces Enable/disable traces
3716 */
3717static void vmsvgaSetTraces(PVGASTATE pThis, bool fTraces)
3718{
3719 if ( (!pThis->svga.fConfigured || !pThis->svga.fEnabled)
3720 && !fTraces)
3721 {
3722 //Assert(pThis->svga.fTraces);
3723 Log(("vmsvgaSetTraces: *not* allowed to disable dirty page tracking when the device is in legacy mode.\n"));
3724 return;
3725 }
3726
3727 pThis->svga.fTraces = fTraces;
3728 if (pThis->svga.fTraces)
3729 {
3730 unsigned cbFrameBuffer = pThis->vram_size;
3731
3732 Log(("vmsvgaSetTraces: enable dirty page handling for the frame buffer only (%x bytes)\n", 0));
3733 if (pThis->svga.uHeight != VMSVGA_VAL_UNINITIALIZED)
3734 {
3735#ifndef DEBUG_bird /* BB-10.3.1 triggers this as it initializes everything to zero. Better just ignore it. */
3736 Assert(pThis->svga.cbScanline);
3737#endif
3738 /* Hardware enabled; return real framebuffer size .*/
3739 cbFrameBuffer = (uint32_t)pThis->svga.uHeight * pThis->svga.cbScanline;
3740 cbFrameBuffer = RT_ALIGN(cbFrameBuffer, PAGE_SIZE);
3741 }
3742
3743 if (!pThis->svga.fVRAMTracking)
3744 {
3745 Log(("vmsvgaSetTraces: enable frame buffer dirty page tracking. (%x bytes; vram %x)\n", cbFrameBuffer, pThis->vram_size));
3746 vgaR3RegisterVRAMHandler(pThis, cbFrameBuffer);
3747 pThis->svga.fVRAMTracking = true;
3748 }
3749 }
3750 else
3751 {
3752 if (pThis->svga.fVRAMTracking)
3753 {
3754 Log(("vmsvgaSetTraces: disable frame buffer dirty page tracking\n"));
3755 vgaR3UnregisterVRAMHandler(pThis);
3756 pThis->svga.fVRAMTracking = false;
3757 }
3758 }
3759}
3760
3761/**
3762 * Callback function for mapping a PCI I/O region.
3763 *
3764 * @return VBox status code.
3765 * @param pPciDev Pointer to PCI device.
3766 * Use pPciDev->pDevIns to get the device instance.
3767 * @param iRegion The region number.
3768 * @param GCPhysAddress Physical address of the region.
3769 * If iType is PCI_ADDRESS_SPACE_IO, this is an
3770 * I/O port, else it's a physical address.
3771 * This address is *NOT* relative
3772 * to pci_mem_base like earlier!
3773 * @param enmType One of the PCI_ADDRESS_SPACE_* values.
3774 */
3775DECLCALLBACK(int) vmsvgaR3IORegionMap(PPCIDEVICE pPciDev, int iRegion, RTGCPHYS GCPhysAddress, RTGCPHYS cb,
3776 PCIADDRESSSPACE enmType)
3777{
3778 int rc;
3779 PPDMDEVINS pDevIns = pPciDev->pDevIns;
3780 PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
3781
3782 Log(("vgasvgaR3IORegionMap: iRegion=%d GCPhysAddress=%RGp cb=%RGp enmType=%d\n", iRegion, GCPhysAddress, cb, enmType));
3783 if (enmType == PCI_ADDRESS_SPACE_IO)
3784 {
3785 AssertReturn(iRegion == 0, VERR_INTERNAL_ERROR);
3786 rc = PDMDevHlpIOPortRegister(pDevIns, (RTIOPORT)GCPhysAddress, cb, 0,
3787 vmsvgaIOWrite, vmsvgaIORead, NULL /* OutStr */, NULL /* InStr */, "VMSVGA");
3788 if (RT_FAILURE(rc))
3789 return rc;
3790 if (pThis->fR0Enabled)
3791 {
3792 rc = PDMDevHlpIOPortRegisterR0(pDevIns, (RTIOPORT)GCPhysAddress, cb, 0,
3793 "vmsvgaIOWrite", "vmsvgaIORead", NULL, NULL, "VMSVGA");
3794 if (RT_FAILURE(rc))
3795 return rc;
3796 }
3797 if (pThis->fGCEnabled)
3798 {
3799 rc = PDMDevHlpIOPortRegisterRC(pDevIns, (RTIOPORT)GCPhysAddress, cb, 0,
3800 "vmsvgaIOWrite", "vmsvgaIORead", NULL, NULL, "VMSVGA");
3801 if (RT_FAILURE(rc))
3802 return rc;
3803 }
3804
3805 pThis->svga.BasePort = GCPhysAddress;
3806 Log(("vmsvgaR3IORegionMap: base port = %x\n", pThis->svga.BasePort));
3807 }
3808 else
3809 {
3810 AssertReturn(iRegion == 2 && enmType == PCI_ADDRESS_SPACE_MEM, VERR_INTERNAL_ERROR);
3811 if (GCPhysAddress != NIL_RTGCPHYS)
3812 {
3813 /*
3814 * Mapping the FIFO RAM.
3815 */
3816 rc = PDMDevHlpMMIO2Map(pDevIns, iRegion, GCPhysAddress);
3817 AssertRC(rc);
3818
3819# ifdef DEBUG_FIFO_ACCESS
3820 if (RT_SUCCESS(rc))
3821 {
3822 rc = PGMHandlerPhysicalRegister(PDMDevHlpGetVM(pDevIns), GCPhysAddress, GCPhysAddress + (VMSVGA_FIFO_SIZE - 1),
3823 pThis->svga.hFifoAccessHandlerType, pThis, NIL_RTR0PTR, NIL_RTRCPTR,
3824 "VMSVGA FIFO");
3825 AssertRC(rc);
3826 }
3827# endif
3828 if (RT_SUCCESS(rc))
3829 {
3830 pThis->svga.GCPhysFIFO = GCPhysAddress;
3831 Log(("vmsvgaR3IORegionMap: FIFO address = %RGp\n", GCPhysAddress));
3832 }
3833 }
3834 else
3835 {
3836 Assert(pThis->svga.GCPhysFIFO);
3837# ifdef DEBUG_FIFO_ACCESS
3838 rc = PGMHandlerPhysicalDeregister(PDMDevHlpGetVM(pDevIns), pThis->svga.GCPhysFIFO);
3839 AssertRC(rc);
3840# endif
3841 pThis->svga.GCPhysFIFO = 0;
3842 }
3843
3844 }
3845 return VINF_SUCCESS;
3846}
3847
3848# ifdef VBOX_WITH_VMSVGA3D
3849
3850/**
3851 * Used by vmsvga3dInfoSurfaceWorker to make the FIFO thread to save one or all
3852 * surfaces to VMSVGA3DMIPMAPLEVEL::pSurfaceData heap buffers.
3853 *
3854 * @param pThis The VGA device instance data.
3855 * @param sid Either UINT32_MAX or the ID of a specific
3856 * surface. If UINT32_MAX is used, all surfaces
3857 * are processed.
3858 */
3859void vmsvga3dSurfaceUpdateHeapBuffersOnFifoThread(PVGASTATE pThis, uint32_t sid)
3860{
3861 vmsvgaR3RunExtCmdOnFifoThread(pThis, VMSVGA_FIFO_EXTCMD_UPDATE_SURFACE_HEAP_BUFFERS, (void *)(uintptr_t)sid,
3862 sid == UINT32_MAX ? 10 * RT_MS_1SEC : RT_MS_1MIN);
3863}
3864
3865
3866/**
3867 * @callback_method_impl{FNDBGFHANDLERDEV, "vmsvga3dsfc"}
3868 */
3869DECLCALLBACK(void) vmsvgaR3Info3dSurface(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs)
3870{
3871 /* There might be a specific context ID at the start of the
3872 arguments, if not show all contexts. */
3873 uint32_t cid = UINT32_MAX;
3874 if (pszArgs)
3875 pszArgs = RTStrStripL(pszArgs);
3876 if (pszArgs && RT_C_IS_DIGIT(*pszArgs))
3877 cid = RTStrToUInt32(pszArgs);
3878
3879 /* Verbose or terse display, we default to verbose. */
3880 bool fVerbose = true;
3881 if (RTStrIStr(pszArgs, "terse"))
3882 fVerbose = false;
3883
3884 /* The size of the ascii art (x direction, y is 3/4 of x). */
3885 uint32_t cxAscii = 80;
3886 if (RTStrIStr(pszArgs, "gigantic"))
3887 cxAscii = 300;
3888 else if (RTStrIStr(pszArgs, "huge"))
3889 cxAscii = 180;
3890 else if (RTStrIStr(pszArgs, "big"))
3891 cxAscii = 132;
3892 else if (RTStrIStr(pszArgs, "normal"))
3893 cxAscii = 80;
3894 else if (RTStrIStr(pszArgs, "medium"))
3895 cxAscii = 64;
3896 else if (RTStrIStr(pszArgs, "small"))
3897 cxAscii = 48;
3898 else if (RTStrIStr(pszArgs, "tiny"))
3899 cxAscii = 24;
3900
3901 /* Y invert the image when producing the ASCII art. */
3902 bool fInvY = false;
3903 if (RTStrIStr(pszArgs, "invy"))
3904 fInvY = true;
3905
3906 vmsvga3dInfoSurfaceWorker(PDMINS_2_DATA(pDevIns, PVGASTATE), pHlp, cid, fVerbose, cxAscii, fInvY);
3907}
3908
3909
3910/**
3911 * @callback_method_impl{FNDBGFHANDLERDEV, "vmsvga3dctx"}
3912 */
3913DECLCALLBACK(void) vmsvgaR3Info3dContext(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs)
3914{
3915 /* There might be a specific surface ID at the start of the
3916 arguments, if not show all contexts. */
3917 uint32_t sid = UINT32_MAX;
3918 if (pszArgs)
3919 pszArgs = RTStrStripL(pszArgs);
3920 if (pszArgs && RT_C_IS_DIGIT(*pszArgs))
3921 sid = RTStrToUInt32(pszArgs);
3922
3923 /* Verbose or terse display, we default to verbose. */
3924 bool fVerbose = true;
3925 if (RTStrIStr(pszArgs, "terse"))
3926 fVerbose = false;
3927
3928 vmsvga3dInfoContextWorker(PDMINS_2_DATA(pDevIns, PVGASTATE), pHlp, sid, fVerbose);
3929}
3930
3931# endif /* VBOX_WITH_VMSVGA3D */
3932
3933/**
3934 * @callback_method_impl{FNDBGFHANDLERDEV, "vmsvga"}
3935 */
3936static DECLCALLBACK(void) vmsvgaR3Info(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs)
3937{
3938 RT_NOREF(pszArgs);
3939 PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
3940 PVMSVGAR3STATE pSVGAState = pThis->svga.pSvgaR3State;
3941
3942 pHlp->pfnPrintf(pHlp, "Extension enabled: %RTbool\n", pThis->svga.fEnabled);
3943 pHlp->pfnPrintf(pHlp, "Configured: %RTbool\n", pThis->svga.fConfigured);
3944 pHlp->pfnPrintf(pHlp, "Base I/O port: %#x\n", pThis->svga.BasePort);
3945 pHlp->pfnPrintf(pHlp, "FIFO address: %RGp\n", pThis->svga.GCPhysFIFO);
3946 pHlp->pfnPrintf(pHlp, "FIFO size: %u (%#x)\n", pThis->svga.cbFIFO, pThis->svga.cbFIFO);
3947 pHlp->pfnPrintf(pHlp, "FIFO external cmd: %#x\n", pThis->svga.u8FIFOExtCommand);
3948 pHlp->pfnPrintf(pHlp, "FIFO extcmd wakeup: %u\n", pThis->svga.fFifoExtCommandWakeup);
3949 pHlp->pfnPrintf(pHlp, "Busy: %#x\n", pThis->svga.fBusy);
3950 pHlp->pfnPrintf(pHlp, "Traces: %RTbool (effective: %RTbool)\n", pThis->svga.fTraces, pThis->svga.fVRAMTracking);
3951 pHlp->pfnPrintf(pHlp, "Guest ID: %#x (%d)\n", pThis->svga.u32GuestId, pThis->svga.u32GuestId);
3952 pHlp->pfnPrintf(pHlp, "IRQ status: %#x\n", pThis->svga.u32IrqStatus);
3953 pHlp->pfnPrintf(pHlp, "IRQ mask: %#x\n", pThis->svga.u32IrqMask);
3954 pHlp->pfnPrintf(pHlp, "Pitch lock: %#x\n", pThis->svga.u32PitchLock);
3955 pHlp->pfnPrintf(pHlp, "Current GMR ID: %#x\n", pThis->svga.u32CurrentGMRId);
3956 pHlp->pfnPrintf(pHlp, "Capabilites reg: %#x\n", pThis->svga.u32RegCaps);
3957 pHlp->pfnPrintf(pHlp, "Index reg: %#x\n", pThis->svga.u32IndexReg);
3958 pHlp->pfnPrintf(pHlp, "Action flags: %#x\n", pThis->svga.u32ActionFlags);
3959 pHlp->pfnPrintf(pHlp, "Max display size: %ux%u\n", pThis->svga.u32MaxWidth, pThis->svga.u32MaxHeight);
3960 pHlp->pfnPrintf(pHlp, "Display size: %ux%u %ubpp\n", pThis->svga.uWidth, pThis->svga.uHeight, pThis->svga.uBpp);
3961 pHlp->pfnPrintf(pHlp, "Scanline: %u (%#x)\n", pThis->svga.cbScanline, pThis->svga.cbScanline);
3962 pHlp->pfnPrintf(pHlp, "Viewport position: %ux%u\n", pThis->svga.viewport.x, pThis->svga.viewport.y);
3963 pHlp->pfnPrintf(pHlp, "Viewport size: %ux%u\n", pThis->svga.viewport.cx, pThis->svga.viewport.cy);
3964
3965 pHlp->pfnPrintf(pHlp, "Cursor active: %RTbool\n", pSVGAState->Cursor.fActive);
3966 pHlp->pfnPrintf(pHlp, "Cursor hotspot: %ux%u\n", pSVGAState->Cursor.xHotspot, pSVGAState->Cursor.yHotspot);
3967 pHlp->pfnPrintf(pHlp, "Cursor size: %ux%u\n", pSVGAState->Cursor.width, pSVGAState->Cursor.height);
3968 pHlp->pfnPrintf(pHlp, "Cursor byte size: %u (%#x)\n", pSVGAState->Cursor.cbData, pSVGAState->Cursor.cbData);
3969
3970# ifdef VBOX_WITH_VMSVGA3D
3971 pHlp->pfnPrintf(pHlp, "3D enabled: %RTbool\n", pThis->svga.f3DEnabled);
3972 pHlp->pfnPrintf(pHlp, "Host windows ID: %#RX64\n", pThis->svga.u64HostWindowId);
3973 if (pThis->svga.u64HostWindowId != 0)
3974 vmsvga3dInfoHostWindow(pHlp, pThis->svga.u64HostWindowId);
3975# endif
3976}
3977
3978
3979/**
3980 * @copydoc FNSSMDEVLOADEXEC
3981 */
3982int vmsvgaLoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
3983{
3984 RT_NOREF(uVersion, uPass);
3985 PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
3986 PVMSVGAR3STATE pSVGAState = pThis->svga.pSvgaR3State;
3987 int rc;
3988
3989 /* Load our part of the VGAState */
3990 rc = SSMR3GetStructEx(pSSM, &pThis->svga, sizeof(pThis->svga), 0, g_aVGAStateSVGAFields, NULL);
3991 AssertRCReturn(rc, rc);
3992
3993 /* Load the framebuffer backup. */
3994 rc = SSMR3GetMem(pSSM, pThis->svga.pFrameBufferBackup, VMSVGA_FRAMEBUFFER_BACKUP_SIZE);
3995 AssertRCReturn(rc, rc);
3996
3997 /* Load the VMSVGA state. */
3998 rc = SSMR3GetStructEx(pSSM, pSVGAState, sizeof(*pSVGAState), 0, g_aVMSVGAR3STATEFields, NULL);
3999 AssertRCReturn(rc, rc);
4000
4001 /* Load the active cursor bitmaps. */
4002 if (pSVGAState->Cursor.fActive)
4003 {
4004 pSVGAState->Cursor.pData = RTMemAlloc(pSVGAState->Cursor.cbData);
4005 AssertReturn(pSVGAState->Cursor.pData, VERR_NO_MEMORY);
4006
4007 rc = SSMR3GetMem(pSSM, pSVGAState->Cursor.pData, pSVGAState->Cursor.cbData);
4008 AssertRCReturn(rc, rc);
4009 }
4010
4011 /* Load the GMR state */
4012 for (uint32_t i = 0; i < RT_ELEMENTS(pSVGAState->aGMR); i++)
4013 {
4014 PGMR pGMR = &pSVGAState->aGMR[i];
4015
4016 rc = SSMR3GetStructEx(pSSM, pGMR, sizeof(*pGMR), 0, g_aGMRFields, NULL);
4017 AssertRCReturn(rc, rc);
4018
4019 if (pGMR->numDescriptors)
4020 {
4021 /* Allocate the maximum amount possible (everything non-continuous) */
4022 Assert(pGMR->cMaxPages || pGMR->cbTotal);
4023 pGMR->paDesc = (PVMSVGAGMRDESCRIPTOR)RTMemAllocZ((pGMR->cMaxPages) ? pGMR->cMaxPages : (pGMR->cbTotal >> PAGE_SHIFT) * sizeof(VMSVGAGMRDESCRIPTOR));
4024 AssertReturn(pGMR->paDesc, VERR_NO_MEMORY);
4025
4026 for (uint32_t j = 0; j < pGMR->numDescriptors; j++)
4027 {
4028 rc = SSMR3GetStructEx(pSSM, &pGMR->paDesc[j], sizeof(pGMR->paDesc[j]), 0, g_aVMSVGAGMRDESCRIPTORFields, NULL);
4029 AssertRCReturn(rc, rc);
4030 }
4031 }
4032 }
4033
4034# ifdef VBOX_WITH_VMSVGA3D
4035 if (pThis->svga.f3DEnabled)
4036 {
4037# ifdef RT_OS_DARWIN /** @todo r=bird: this is normally done on the EMT, so for DARWIN we do that when loading saved state too now. See DevVGA-SVGA3d-shared.h. */
4038 vmsvga3dPowerOn(pThis);
4039# endif
4040
4041 VMSVGA_STATE_LOAD LoadState;
4042 LoadState.pSSM = pSSM;
4043 LoadState.uVersion = uVersion;
4044 LoadState.uPass = uPass;
4045 rc = vmsvgaR3RunExtCmdOnFifoThread(pThis, VMSVGA_FIFO_EXTCMD_LOADSTATE, &LoadState, RT_INDEFINITE_WAIT);
4046 AssertLogRelRCReturn(rc, rc);
4047 }
4048# endif
4049
4050 return VINF_SUCCESS;
4051}
4052
4053/**
4054 * Reinit the video mode after the state has been loaded.
4055 */
4056int vmsvgaLoadDone(PPDMDEVINS pDevIns)
4057{
4058 PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
4059 PVMSVGAR3STATE pSVGAState = pThis->svga.pSvgaR3State;
4060
4061 pThis->last_bpp = VMSVGA_VAL_UNINITIALIZED; /* force mode reset */
4062 vmsvgaChangeMode(pThis);
4063
4064 /* Set the active cursor. */
4065 if (pSVGAState->Cursor.fActive)
4066 {
4067 int rc;
4068
4069 rc = pThis->pDrv->pfnVBVAMousePointerShape(pThis->pDrv,
4070 true,
4071 true,
4072 pSVGAState->Cursor.xHotspot,
4073 pSVGAState->Cursor.yHotspot,
4074 pSVGAState->Cursor.width,
4075 pSVGAState->Cursor.height,
4076 pSVGAState->Cursor.pData);
4077 AssertRC(rc);
4078 }
4079 return VINF_SUCCESS;
4080}
4081
4082/**
4083 * @copydoc FNSSMDEVSAVEEXEC
4084 */
4085int vmsvgaSaveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
4086{
4087 PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
4088 PVMSVGAR3STATE pSVGAState = pThis->svga.pSvgaR3State;
4089 int rc;
4090
4091 /* Save our part of the VGAState */
4092 rc = SSMR3PutStructEx(pSSM, &pThis->svga, sizeof(pThis->svga), 0, g_aVGAStateSVGAFields, NULL);
4093 AssertLogRelRCReturn(rc, rc);
4094
4095 /* Save the framebuffer backup. */
4096 rc = SSMR3PutMem(pSSM, pThis->svga.pFrameBufferBackup, VMSVGA_FRAMEBUFFER_BACKUP_SIZE);
4097 AssertLogRelRCReturn(rc, rc);
4098
4099 /* Save the VMSVGA state. */
4100 rc = SSMR3PutStructEx(pSSM, pSVGAState, sizeof(*pSVGAState), 0, g_aVMSVGAR3STATEFields, NULL);
4101 AssertLogRelRCReturn(rc, rc);
4102
4103 /* Save the active cursor bitmaps. */
4104 if (pSVGAState->Cursor.fActive)
4105 {
4106 rc = SSMR3PutMem(pSSM, pSVGAState->Cursor.pData, pSVGAState->Cursor.cbData);
4107 AssertLogRelRCReturn(rc, rc);
4108 }
4109
4110 /* Save the GMR state */
4111 for (uint32_t i = 0; i < RT_ELEMENTS(pSVGAState->aGMR); i++)
4112 {
4113 rc = SSMR3PutStructEx(pSSM, &pSVGAState->aGMR[i], sizeof(pSVGAState->aGMR[i]), 0, g_aGMRFields, NULL);
4114 AssertLogRelRCReturn(rc, rc);
4115
4116 for (uint32_t j = 0; j < pSVGAState->aGMR[i].numDescriptors; j++)
4117 {
4118 rc = SSMR3PutStructEx(pSSM, &pSVGAState->aGMR[i].paDesc[j], sizeof(pSVGAState->aGMR[i].paDesc[j]), 0, g_aVMSVGAGMRDESCRIPTORFields, NULL);
4119 AssertLogRelRCReturn(rc, rc);
4120 }
4121 }
4122
4123# ifdef VBOX_WITH_VMSVGA3D
4124 /*
4125 * Must save the 3d state in the FIFO thread.
4126 */
4127 if (pThis->svga.f3DEnabled)
4128 {
4129 rc = vmsvgaR3RunExtCmdOnFifoThread(pThis, VMSVGA_FIFO_EXTCMD_SAVESTATE, pSSM, RT_INDEFINITE_WAIT);
4130 AssertLogRelRCReturn(rc, rc);
4131 }
4132# endif
4133 return VINF_SUCCESS;
4134}
4135
4136/**
4137 * Resets the SVGA hardware state
4138 *
4139 * @returns VBox status code.
4140 * @param pDevIns The device instance.
4141 */
4142int vmsvgaReset(PPDMDEVINS pDevIns)
4143{
4144 PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
4145 PVMSVGAR3STATE pSVGAState = pThis->svga.pSvgaR3State;
4146
4147 /* Reset before init? */
4148 if (!pSVGAState)
4149 return VINF_SUCCESS;
4150
4151 Log(("vmsvgaReset\n"));
4152
4153
4154 /* Reset the FIFO processing as well as the 3d state (if we have one). */
4155 pThis->svga.pFIFOR3[SVGA_FIFO_NEXT_CMD] = pThis->svga.pFIFOR3[SVGA_FIFO_STOP] = 0; /** @todo should probably let the FIFO thread do this ... */
4156 int rc = vmsvgaR3RunExtCmdOnFifoThread(pThis, VMSVGA_FIFO_EXTCMD_RESET, NULL /*pvParam*/, 10000 /*ms*/);
4157
4158 /* Reset other stuff. */
4159 pThis->svga.cScratchRegion = VMSVGA_SCRATCH_SIZE;
4160 RT_ZERO(pThis->svga.au32ScratchRegion);
4161 RT_ZERO(*pThis->svga.pSvgaR3State);
4162 RT_BZERO(pThis->svga.pFrameBufferBackup, VMSVGA_FRAMEBUFFER_BACKUP_SIZE);
4163
4164 /* Register caps. */
4165 pThis->svga.u32RegCaps = SVGA_CAP_GMR | SVGA_CAP_GMR2 | SVGA_CAP_CURSOR | SVGA_CAP_CURSOR_BYPASS_2 | SVGA_CAP_EXTENDED_FIFO | SVGA_CAP_IRQMASK | SVGA_CAP_PITCHLOCK | SVGA_CAP_TRACES | SVGA_CAP_SCREEN_OBJECT_2 | SVGA_CAP_ALPHA_CURSOR;
4166# ifdef VBOX_WITH_VMSVGA3D
4167 pThis->svga.u32RegCaps |= SVGA_CAP_3D;
4168# endif
4169
4170 /* Setup FIFO capabilities. */
4171 pThis->svga.pFIFOR3[SVGA_FIFO_CAPABILITIES] = SVGA_FIFO_CAP_FENCE | SVGA_FIFO_CAP_CURSOR_BYPASS_3 | SVGA_FIFO_CAP_GMR2 | SVGA_FIFO_CAP_3D_HWVERSION_REVISED | SVGA_FIFO_CAP_SCREEN_OBJECT_2;
4172
4173 /* Valid with SVGA_FIFO_CAP_SCREEN_OBJECT_2 */
4174 pThis->svga.pFIFOR3[SVGA_FIFO_CURSOR_SCREEN_ID] = SVGA_ID_INVALID;
4175
4176 /* VRAM tracking is enabled by default during bootup. */
4177 pThis->svga.fVRAMTracking = true;
4178 pThis->svga.fEnabled = false;
4179
4180 /* Invalidate current settings. */
4181 pThis->svga.uWidth = VMSVGA_VAL_UNINITIALIZED;
4182 pThis->svga.uHeight = VMSVGA_VAL_UNINITIALIZED;
4183 pThis->svga.uBpp = VMSVGA_VAL_UNINITIALIZED;
4184 pThis->svga.cbScanline = 0;
4185
4186 return rc;
4187}
4188
4189/**
4190 * Cleans up the SVGA hardware state
4191 *
4192 * @returns VBox status code.
4193 * @param pDevIns The device instance.
4194 */
4195int vmsvgaDestruct(PPDMDEVINS pDevIns)
4196{
4197 PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
4198
4199 /*
4200 * Ask the FIFO thread to terminate the 3d state and then terminate it.
4201 */
4202 if (pThis->svga.pFIFOIOThread)
4203 {
4204 int rc = vmsvgaR3RunExtCmdOnFifoThread(pThis, VMSVGA_FIFO_EXTCMD_TERMINATE, NULL /*pvParam*/, 30000 /*ms*/);
4205 AssertLogRelRC(rc);
4206
4207 rc = PDMR3ThreadDestroy(pThis->svga.pFIFOIOThread, NULL);
4208 AssertLogRelRC(rc);
4209 pThis->svga.pFIFOIOThread = NULL;
4210 }
4211
4212 /*
4213 * Destroy the special SVGA state.
4214 */
4215 PVMSVGAR3STATE pSVGAState = pThis->svga.pSvgaR3State;
4216 if (pSVGAState)
4217 {
4218# ifndef VMSVGA_USE_EMT_HALT_CODE
4219 if (pSVGAState->hBusyDelayedEmts != NIL_RTSEMEVENTMULTI)
4220 {
4221 RTSemEventMultiDestroy(pSVGAState->hBusyDelayedEmts);
4222 pSVGAState->hBusyDelayedEmts = NIL_RTSEMEVENT;
4223 }
4224# endif
4225 if (pSVGAState->Cursor.fActive)
4226 RTMemFree(pSVGAState->Cursor.pData);
4227
4228 for (unsigned i = 0; i < RT_ELEMENTS(pSVGAState->aGMR); i++)
4229 if (pSVGAState->aGMR[i].paDesc)
4230 RTMemFree(pSVGAState->aGMR[i].paDesc);
4231
4232 RTMemFree(pSVGAState);
4233 pThis->svga.pSvgaR3State = NULL;
4234 }
4235
4236 /*
4237 * Free our resources residing in the VGA state.
4238 */
4239 if (pThis->svga.pFrameBufferBackup)
4240 RTMemFree(pThis->svga.pFrameBufferBackup);
4241 if (pThis->svga.FIFOExtCmdSem != NIL_RTSEMEVENT)
4242 {
4243 RTSemEventDestroy(pThis->svga.FIFOExtCmdSem);
4244 pThis->svga.FIFOExtCmdSem = NIL_RTSEMEVENT;
4245 }
4246 if (pThis->svga.FIFORequestSem != NIL_SUPSEMEVENT)
4247 {
4248 SUPSemEventClose(pThis->svga.pSupDrvSession, pThis->svga.FIFORequestSem);
4249 pThis->svga.FIFORequestSem = NIL_SUPSEMEVENT;
4250 }
4251
4252 return VINF_SUCCESS;
4253}
4254
4255/**
4256 * Initialize the SVGA hardware state
4257 *
4258 * @returns VBox status code.
4259 * @param pDevIns The device instance.
4260 */
4261int vmsvgaInit(PPDMDEVINS pDevIns)
4262{
4263 PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
4264 PVMSVGAR3STATE pSVGAState;
4265 PVM pVM = PDMDevHlpGetVM(pDevIns);
4266 int rc;
4267
4268 pThis->svga.cScratchRegion = VMSVGA_SCRATCH_SIZE;
4269 memset(pThis->svga.au32ScratchRegion, 0, sizeof(pThis->svga.au32ScratchRegion));
4270
4271 pThis->svga.pSvgaR3State = (PVMSVGAR3STATE)RTMemAllocZ(sizeof(VMSVGAR3STATE));
4272 AssertReturn(pThis->svga.pSvgaR3State, VERR_NO_MEMORY);
4273 pSVGAState = pThis->svga.pSvgaR3State;
4274
4275 /* Necessary for creating a backup of the text mode frame buffer when switching into svga mode. */
4276 pThis->svga.pFrameBufferBackup = RTMemAllocZ(VMSVGA_FRAMEBUFFER_BACKUP_SIZE);
4277 AssertReturn(pThis->svga.pFrameBufferBackup, VERR_NO_MEMORY);
4278
4279 /* Create event semaphore. */
4280 pThis->svga.pSupDrvSession = PDMDevHlpGetSupDrvSession(pDevIns);
4281
4282 rc = SUPSemEventCreate(pThis->svga.pSupDrvSession, &pThis->svga.FIFORequestSem);
4283 if (RT_FAILURE(rc))
4284 {
4285 Log(("%s: Failed to create event semaphore for FIFO handling.\n", __FUNCTION__));
4286 return rc;
4287 }
4288
4289 /* Create event semaphore. */
4290 rc = RTSemEventCreate(&pThis->svga.FIFOExtCmdSem);
4291 if (RT_FAILURE(rc))
4292 {
4293 Log(("%s: Failed to create event semaphore for external fifo cmd handling.\n", __FUNCTION__));
4294 return rc;
4295 }
4296
4297# ifndef VMSVGA_USE_EMT_HALT_CODE
4298 /* Create semaphore for delaying EMTs wait for the FIFO to stop being busy. */
4299 rc = RTSemEventMultiCreate(&pSVGAState->hBusyDelayedEmts);
4300 AssertRCReturn(rc, rc);
4301# endif
4302
4303 /* Register caps. */
4304 pThis->svga.u32RegCaps = SVGA_CAP_GMR | SVGA_CAP_GMR2 | SVGA_CAP_CURSOR | SVGA_CAP_CURSOR_BYPASS_2 | SVGA_CAP_EXTENDED_FIFO | SVGA_CAP_IRQMASK | SVGA_CAP_PITCHLOCK | SVGA_CAP_TRACES | SVGA_CAP_SCREEN_OBJECT_2 | SVGA_CAP_ALPHA_CURSOR;
4305# ifdef VBOX_WITH_VMSVGA3D
4306 pThis->svga.u32RegCaps |= SVGA_CAP_3D;
4307# endif
4308
4309 /* Setup FIFO capabilities. */
4310 pThis->svga.pFIFOR3[SVGA_FIFO_CAPABILITIES] = SVGA_FIFO_CAP_FENCE | SVGA_FIFO_CAP_CURSOR_BYPASS_3 | SVGA_FIFO_CAP_GMR2 | SVGA_FIFO_CAP_3D_HWVERSION_REVISED | SVGA_FIFO_CAP_SCREEN_OBJECT_2;
4311
4312 /* Valid with SVGA_FIFO_CAP_SCREEN_OBJECT_2 */
4313 pThis->svga.pFIFOR3[SVGA_FIFO_CURSOR_SCREEN_ID] = SVGA_ID_INVALID;
4314
4315 pThis->svga.pFIFOR3[SVGA_FIFO_3D_HWVERSION] = pThis->svga.pFIFOR3[SVGA_FIFO_3D_HWVERSION_REVISED] = 0; /* no 3d available. */
4316# ifdef VBOX_WITH_VMSVGA3D
4317 if (pThis->svga.f3DEnabled)
4318 {
4319 rc = vmsvga3dInit(pThis);
4320 if (RT_FAILURE(rc))
4321 {
4322 LogRel(("VMSVGA3d: 3D support disabled! (vmsvga3dInit -> %Rrc)\n", rc));
4323 pThis->svga.f3DEnabled = false;
4324 }
4325 }
4326# endif
4327 /* VRAM tracking is enabled by default during bootup. */
4328 pThis->svga.fVRAMTracking = true;
4329
4330 /* Invalidate current settings. */
4331 pThis->svga.uWidth = VMSVGA_VAL_UNINITIALIZED;
4332 pThis->svga.uHeight = VMSVGA_VAL_UNINITIALIZED;
4333 pThis->svga.uBpp = VMSVGA_VAL_UNINITIALIZED;
4334 pThis->svga.cbScanline = 0;
4335
4336 pThis->svga.u32MaxWidth = VBE_DISPI_MAX_YRES;
4337 pThis->svga.u32MaxHeight = VBE_DISPI_MAX_XRES;
4338 while (pThis->svga.u32MaxWidth * pThis->svga.u32MaxHeight * 4 /* 32 bpp */ > pThis->vram_size)
4339 {
4340 pThis->svga.u32MaxWidth -= 256;
4341 pThis->svga.u32MaxHeight -= 256;
4342 }
4343 Log(("VMSVGA: Maximum size (%d,%d)\n", pThis->svga.u32MaxWidth, pThis->svga.u32MaxHeight));
4344
4345# ifdef DEBUG_GMR_ACCESS
4346 /* Register the GMR access handler type. */
4347 rc = PGMR3HandlerPhysicalTypeRegister(PDMDevHlpGetVM(pThis->pDevInsR3), PGMPHYSHANDLERKIND_WRITE,
4348 vmsvgaR3GMRAccessHandler,
4349 NULL, NULL, NULL,
4350 NULL, NULL, NULL,
4351 "VMSVGA GMR", &pThis->svga.hGmrAccessHandlerType);
4352 AssertRCReturn(rc, rc);
4353# endif
4354# ifdef DEBUG_FIFO_ACCESS
4355 rc = PGMR3HandlerPhysicalTypeRegister(PDMDevHlpGetVM(pThis->pDevInsR3), PGMPHYSHANDLERKIND_ALL,
4356 vmsvgaR3FIFOAccessHandler,
4357 NULL, NULL, NULL,
4358 NULL, NULL, NULL,
4359 "VMSVGA FIFO", &pThis->svga.hFifoAccessHandlerType);
4360 AssertRCReturn(rc, rc);
4361#endif
4362
4363 /* Create the async IO thread. */
4364 rc = PDMDevHlpThreadCreate(pDevIns, &pThis->svga.pFIFOIOThread, pThis, vmsvgaFIFOLoop, vmsvgaFIFOLoopWakeUp, 0,
4365 RTTHREADTYPE_IO, "VMSVGA FIFO");
4366 if (RT_FAILURE(rc))
4367 {
4368 AssertMsgFailed(("%s: Async IO Thread creation for FIFO handling failed rc=%d\n", __FUNCTION__, rc));
4369 return rc;
4370 }
4371
4372 /*
4373 * Statistics.
4374 */
4375 STAM_REG(pVM, &pSVGAState->StatR3CmdPresent, STAMTYPE_PROFILE, "/Devices/VMSVGA/3d/Cmd/Present", STAMUNIT_TICKS_PER_CALL, "Profiling of Present.");
4376 STAM_REG(pVM, &pSVGAState->StatR3CmdDrawPrimitive, STAMTYPE_PROFILE, "/Devices/VMSVGA/3d/Cmd/DrawPrimitive", STAMUNIT_TICKS_PER_CALL, "Profiling of DrawPrimitive.");
4377 STAM_REG(pVM, &pSVGAState->StatR3CmdSurfaceDMA, STAMTYPE_PROFILE, "/Devices/VMSVGA/3d/Cmd/SurfaceDMA", STAMUNIT_TICKS_PER_CALL, "Profiling of SurfaceDMA.");
4378 STAM_REL_REG(pVM, &pSVGAState->StatBusyDelayEmts, STAMTYPE_PROFILE, "/Devices/VMSVGA/EmtDelayOnBusyFifo", STAMUNIT_TICKS_PER_CALL, "Time we've delayed EMTs because of busy FIFO thread.");
4379 STAM_REL_REG(pVM, &pSVGAState->StatFifoCommands, STAMTYPE_COUNTER, "/Devices/VMSVGA/FifoCommands", STAMUNIT_OCCURENCES, "FIFO command counter.");
4380 STAM_REL_REG(pVM, &pSVGAState->StatFifoErrors, STAMTYPE_COUNTER, "/Devices/VMSVGA/FifoErrors", STAMUNIT_OCCURENCES, "FIFO error counter.");
4381 STAM_REL_REG(pVM, &pSVGAState->StatFifoUnkCmds, STAMTYPE_COUNTER, "/Devices/VMSVGA/FifoUnknownCommands", STAMUNIT_OCCURENCES, "FIFO unknown command counter.");
4382 STAM_REL_REG(pVM, &pSVGAState->StatFifoTodoTimeout, STAMTYPE_COUNTER, "/Devices/VMSVGA/FifoTodoTimeout", STAMUNIT_OCCURENCES, "Number of times we discovered pending work after a wait timeout.");
4383 STAM_REL_REG(pVM, &pSVGAState->StatFifoTodoWoken, STAMTYPE_COUNTER, "/Devices/VMSVGA/FifoTodoWoken", STAMUNIT_OCCURENCES, "Number of times we discovered pending work after being woken up.");
4384 STAM_REL_REG(pVM, &pSVGAState->StatFifoStalls, STAMTYPE_PROFILE, "/Devices/VMSVGA/FifoStalls", STAMUNIT_TICKS_PER_CALL, "Profiling of FIFO stalls (waiting for guest to finish copying data).");
4385
4386 /*
4387 * Info handlers.
4388 */
4389 PDMDevHlpDBGFInfoRegister(pDevIns, "vmsvga", "Basic VMSVGA device state details", vmsvgaR3Info);
4390# ifdef VBOX_WITH_VMSVGA3D
4391 PDMDevHlpDBGFInfoRegister(pDevIns, "vmsvga3dctx", "VMSVGA 3d context details. Accepts 'terse'.", vmsvgaR3Info3dContext);
4392 PDMDevHlpDBGFInfoRegister(pDevIns, "vmsvga3dsfc",
4393 "VMSVGA 3d surface details. "
4394 "Accepts 'terse', 'invy', and one of 'tiny', 'medium', 'normal', 'big', 'huge', or 'gigantic'.",
4395 vmsvgaR3Info3dSurface);
4396# endif
4397
4398 return VINF_SUCCESS;
4399}
4400
4401# ifdef VBOX_WITH_VMSVGA3D
4402/** Names for the vmsvga 3d capabilities, prefixed with format type hint char. */
4403static const char * const g_apszVmSvgaDevCapNames[] =
4404{
4405 "x3D", /* = 0 */
4406 "xMAX_LIGHTS",
4407 "xMAX_TEXTURES",
4408 "xMAX_CLIP_PLANES",
4409 "xVERTEX_SHADER_VERSION",
4410 "xVERTEX_SHADER",
4411 "xFRAGMENT_SHADER_VERSION",
4412 "xFRAGMENT_SHADER",
4413 "xMAX_RENDER_TARGETS",
4414 "xS23E8_TEXTURES",
4415 "xS10E5_TEXTURES",
4416 "xMAX_FIXED_VERTEXBLEND",
4417 "xD16_BUFFER_FORMAT",
4418 "xD24S8_BUFFER_FORMAT",
4419 "xD24X8_BUFFER_FORMAT",
4420 "xQUERY_TYPES",
4421 "xTEXTURE_GRADIENT_SAMPLING",
4422 "rMAX_POINT_SIZE",
4423 "xMAX_SHADER_TEXTURES",
4424 "xMAX_TEXTURE_WIDTH",
4425 "xMAX_TEXTURE_HEIGHT",
4426 "xMAX_VOLUME_EXTENT",
4427 "xMAX_TEXTURE_REPEAT",
4428 "xMAX_TEXTURE_ASPECT_RATIO",
4429 "xMAX_TEXTURE_ANISOTROPY",
4430 "xMAX_PRIMITIVE_COUNT",
4431 "xMAX_VERTEX_INDEX",
4432 "xMAX_VERTEX_SHADER_INSTRUCTIONS",
4433 "xMAX_FRAGMENT_SHADER_INSTRUCTIONS",
4434 "xMAX_VERTEX_SHADER_TEMPS",
4435 "xMAX_FRAGMENT_SHADER_TEMPS",
4436 "xTEXTURE_OPS",
4437 "xSURFACEFMT_X8R8G8B8",
4438 "xSURFACEFMT_A8R8G8B8",
4439 "xSURFACEFMT_A2R10G10B10",
4440 "xSURFACEFMT_X1R5G5B5",
4441 "xSURFACEFMT_A1R5G5B5",
4442 "xSURFACEFMT_A4R4G4B4",
4443 "xSURFACEFMT_R5G6B5",
4444 "xSURFACEFMT_LUMINANCE16",
4445 "xSURFACEFMT_LUMINANCE8_ALPHA8",
4446 "xSURFACEFMT_ALPHA8",
4447 "xSURFACEFMT_LUMINANCE8",
4448 "xSURFACEFMT_Z_D16",
4449 "xSURFACEFMT_Z_D24S8",
4450 "xSURFACEFMT_Z_D24X8",
4451 "xSURFACEFMT_DXT1",
4452 "xSURFACEFMT_DXT2",
4453 "xSURFACEFMT_DXT3",
4454 "xSURFACEFMT_DXT4",
4455 "xSURFACEFMT_DXT5",
4456 "xSURFACEFMT_BUMPX8L8V8U8",
4457 "xSURFACEFMT_A2W10V10U10",
4458 "xSURFACEFMT_BUMPU8V8",
4459 "xSURFACEFMT_Q8W8V8U8",
4460 "xSURFACEFMT_CxV8U8",
4461 "xSURFACEFMT_R_S10E5",
4462 "xSURFACEFMT_R_S23E8",
4463 "xSURFACEFMT_RG_S10E5",
4464 "xSURFACEFMT_RG_S23E8",
4465 "xSURFACEFMT_ARGB_S10E5",
4466 "xSURFACEFMT_ARGB_S23E8",
4467 "xMISSING62",
4468 "xMAX_VERTEX_SHADER_TEXTURES",
4469 "xMAX_SIMULTANEOUS_RENDER_TARGETS",
4470 "xSURFACEFMT_V16U16",
4471 "xSURFACEFMT_G16R16",
4472 "xSURFACEFMT_A16B16G16R16",
4473 "xSURFACEFMT_UYVY",
4474 "xSURFACEFMT_YUY2",
4475 "xMULTISAMPLE_NONMASKABLESAMPLES",
4476 "xMULTISAMPLE_MASKABLESAMPLES",
4477 "xALPHATOCOVERAGE",
4478 "xSUPERSAMPLE",
4479 "xAUTOGENMIPMAPS",
4480 "xSURFACEFMT_NV12",
4481 "xSURFACEFMT_AYUV",
4482 "xMAX_CONTEXT_IDS",
4483 "xMAX_SURFACE_IDS",
4484 "xSURFACEFMT_Z_DF16",
4485 "xSURFACEFMT_Z_DF24",
4486 "xSURFACEFMT_Z_D24S8_INT",
4487 "xSURFACEFMT_BC4_UNORM",
4488 "xSURFACEFMT_BC5_UNORM", /* 83 */
4489};
4490# endif
4491
4492
4493/**
4494 * Power On notification.
4495 *
4496 * @returns VBox status code.
4497 * @param pDevIns The device instance data.
4498 *
4499 * @remarks Caller enters the device critical section.
4500 */
4501DECLCALLBACK(void) vmsvgaR3PowerOn(PPDMDEVINS pDevIns)
4502{
4503# ifdef VBOX_WITH_VMSVGA3D
4504 PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
4505 if (pThis->svga.f3DEnabled)
4506 {
4507 int rc = vmsvga3dPowerOn(pThis);
4508
4509 if (RT_SUCCESS(rc))
4510 {
4511 bool fSavedBuffering = RTLogRelSetBuffering(true);
4512 SVGA3dCapsRecord *pCaps;
4513 SVGA3dCapPair *pData;
4514 uint32_t idxCap = 0;
4515
4516 /* 3d hardware version; latest and greatest */
4517 pThis->svga.pFIFOR3[SVGA_FIFO_3D_HWVERSION_REVISED] = SVGA3D_HWVERSION_CURRENT;
4518 pThis->svga.pFIFOR3[SVGA_FIFO_3D_HWVERSION] = SVGA3D_HWVERSION_CURRENT;
4519
4520 pCaps = (SVGA3dCapsRecord *)&pThis->svga.pFIFOR3[SVGA_FIFO_3D_CAPS];
4521 pCaps->header.type = SVGA3DCAPS_RECORD_DEVCAPS;
4522 pData = (SVGA3dCapPair *)&pCaps->data;
4523
4524 /* Fill out all 3d capabilities. */
4525 for (unsigned i = 0; i < SVGA3D_DEVCAP_MAX; i++)
4526 {
4527 uint32_t val = 0;
4528
4529 rc = vmsvga3dQueryCaps(pThis, i, &val);
4530 if (RT_SUCCESS(rc))
4531 {
4532 pData[idxCap][0] = i;
4533 pData[idxCap][1] = val;
4534 idxCap++;
4535 if (g_apszVmSvgaDevCapNames[i][0] == 'x')
4536 LogRel(("VMSVGA3d: cap[%u]=%#010x {%s}\n", i, val, &g_apszVmSvgaDevCapNames[i][1]));
4537 else
4538 LogRel(("VMSVGA3d: cap[%u]=%d.%04u {%s}\n", i, (int)*(float *)&val, (unsigned)(*(float *)&val * 10000) % 10000,
4539 &g_apszVmSvgaDevCapNames[i][1]));
4540 }
4541 else
4542 LogRel(("VMSVGA3d: cap[%u]=failed rc=%Rrc! {%s}\n", i, rc, &g_apszVmSvgaDevCapNames[i][1]));
4543 }
4544 pCaps->header.length = (sizeof(pCaps->header) + idxCap * sizeof(SVGA3dCapPair)) / sizeof(uint32_t);
4545 pCaps = (SVGA3dCapsRecord *)((uint32_t *)pCaps + pCaps->header.length);
4546
4547 /* Mark end of record array. */
4548 pCaps->header.length = 0;
4549
4550 RTLogRelSetBuffering(fSavedBuffering);
4551 }
4552 }
4553# else /* !VBOX_WITH_VMSVGA3D */
4554 RT_NOREF(pDevIns);
4555# endif /* !VBOX_WITH_VMSVGA3D */
4556}
4557
4558#endif /* IN_RING3 */
4559
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette