DevVGA_VBVA.cpp@ 71622

最後變更在這個檔案從71622是 71622,由 vboxsync 提交於 7 年前
DevVGA: Code cleanup in progress. bugref:9094
屬性 svn:eol-style 設為 `native` 屬性 svn:keywords 設為 `Author Date Id Revision`
檔案大小: 102.0 KB

行
1	/* $Id: DevVGA_VBVA.cpp 71622 2018-04-02 17:33:45Z vboxsync $ */
2	/** @file
3	* VirtualBox Video Acceleration (VBVA).
4	*/
5
6	/*
7	* Copyright (C) 2006-2017 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.alldomusa.eu.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18
19	/*********************************************************************************************************************************
20	* Header Files *
21	*********************************************************************************************************************************/
22	#define LOG_GROUP LOG_GROUP_DEV_VGA
23	#include <VBox/vmm/pdmifs.h>
24	#include <VBox/vmm/pdmdev.h>
25	#include <VBox/vmm/pgm.h>
26	#include <VBox/vmm/ssm.h>
27	#include <VBox/VMMDev.h>
28	#include <VBox/AssertGuest.h>
29	#include <VBoxVideo.h>
30	#include <iprt/alloc.h>
31	#include <iprt/assert.h>
32	#include <iprt/asm.h>
33	#include <iprt/string.h>
34	#include <iprt/param.h>
35	#ifdef VBOX_WITH_VIDEOHWACCEL
36	#include <iprt/semaphore.h>
37	#endif
38
39	#include "DevVGA.h"
40
41	/* A very detailed logging. */
42	#if 0 // def DEBUG_sunlover
43	#define LOGVBVABUFFER(a) LogFlow(a)
44	#else
45	#define LOGVBVABUFFER(a) do {} while (0)
46	#endif
47
48
49	/*********************************************************************************************************************************
50	* Structures and Typedefs *
51	*********************************************************************************************************************************/
52	typedef struct VBVAPARTIALRECORD
53	{
54	uint8_t *pu8;
55	uint32_t cb;
56	} VBVAPARTIALRECORD;
57
58	typedef struct VBVADATA
59	{
60	struct
61	{
62	VBVABUFFER RT_UNTRUSTED_VOLATILE_GUEST pVBVA; /< Pointer to the guest memory with the VBVABUFFER. /
63	uint8_t RT_UNTRUSTED_VOLATILE_GUEST pu8Data; /< For convenience, pointer to the guest ring buffer (VBVABUFFER::au8Data). /
64	} guest;
65	uint32_t u32VBVAOffset; /*< VBVABUFFER offset in the guest VRAM. /
66	VBVAPARTIALRECORD partialRecord; /*< Partial record temporary storage. /
67	uint32_t off32Data; /**< The offset where the data starts in the VBVABUFFER.
68	* The host code uses it instead of VBVABUFFER::off32Data. */
69	uint32_t indexRecordFirst; /*< Index of the first filled record in VBVABUFFER::aRecords. /
70	uint32_t cbPartialWriteThreshold; /*< Copy of VBVABUFFER::cbPartialWriteThreshold used by host code. /
71	uint32_t cbData; /*< Copy of VBVABUFFER::cbData used by host code. /
72	} VBVADATA;
73
74	typedef struct VBVAVIEW
75	{
76	VBVAINFOVIEW view;
77	VBVAINFOSCREEN screen;
78	VBVADATA vbva;
79	} VBVAVIEW;
80
81	typedef struct VBVAMOUSESHAPEINFO
82	{
83	bool fSet;
84	bool fVisible;
85	bool fAlpha;
86	uint32_t u32HotX;
87	uint32_t u32HotY;
88	uint32_t u32Width;
89	uint32_t u32Height;
90	uint32_t cbShape;
91	uint32_t cbAllocated;
92	uint8_t *pu8Shape;
93	} VBVAMOUSESHAPEINFO;
94
95	/** @todo saved state: save and restore VBVACONTEXT */
96	typedef struct VBVACONTEXT
97	{
98	uint32_t cViews;
99	VBVAVIEW aViews[VBOX_VIDEO_MAX_SCREENS];
100	VBVAMOUSESHAPEINFO mouseShapeInfo;
101	bool fPaused;
102	uint32_t xCursor;
103	uint32_t yCursor;
104	VBVAMODEHINT aModeHints[VBOX_VIDEO_MAX_SCREENS];
105	} VBVACONTEXT;
106
107
108	static void vbvaDataCleanup(VBVADATA *pVBVAData)
109	{
110	if (pVBVAData->guest.pVBVA)
111	{
112	pVBVAData->guest.pVBVA->hostFlags.u32HostEvents = 0;
113	pVBVAData->guest.pVBVA->hostFlags.u32SupportedOrders = 0;
114	}
115
116	RTMemFree(pVBVAData->partialRecord.pu8);
117
118	RT_ZERO(*pVBVAData);
119	pVBVAData->u32VBVAOffset = HGSMIOFFSET_VOID;
120	}
121
122	/** Copies @a cb bytes from the VBVA ring buffer to the @a pbDst.
123	* Used for partial records or for records which cross the ring boundary.
124	*/
125	static bool vbvaFetchBytes(VBVADATA pVBVAData, uint8_t pbDst, uint32_t cb)
126	{
127	if (cb >= pVBVAData->cbData)
128	{
129	AssertMsgFailed(("cb = 0x%08X, ring buffer size 0x%08X", cb, pVBVAData->cbData));
130	return false;
131	}
132
133	const uint8_t RT_UNTRUSTED_VOLATILE_GUEST *pbSrc = &pVBVAData->guest.pu8Data[pVBVAData->off32Data];
134	const uint32_t u32BytesTillBoundary = pVBVAData->cbData - pVBVAData->off32Data;
135	const int32_t i32Diff = cb - u32BytesTillBoundary;
136
137	if (i32Diff <= 0)
138	{
139	/* Chunk will not cross buffer boundary. */
140	RT_BCOPY_VOLATILE(pbDst, pbSrc, cb);
141	}
142	else
143	{
144	/* Chunk crosses buffer boundary. */
145	RT_BCOPY_VOLATILE(pbDst, pbSrc, u32BytesTillBoundary);
146	RT_BCOPY_VOLATILE(pbDst + u32BytesTillBoundary, &pVBVAData->guest.pu8Data[0], i32Diff);
147	}
148
149	/* Advance data offset and sync with guest. */
150	pVBVAData->off32Data = (pVBVAData->off32Data + cb) % pVBVAData->cbData;
151	pVBVAData->guest.pVBVA->off32Data = pVBVAData->off32Data;
152	return true;
153	}
154
155
156	static bool vbvaPartialRead(uint32_t cbRecord, VBVADATA *pVBVAData)
157	{
158	VBVAPARTIALRECORD *pPartialRecord = &pVBVAData->partialRecord;
159	uint8_t *pu8New;
160
161	LOGVBVABUFFER(("vbvaPartialRead: p = %p, cb = %d, cbRecord 0x%08X\n",
162	pPartialRecord->pu8, pPartialRecord->cb, cbRecord));
163
164	Assert(cbRecord > pPartialRecord->cb); /* Caller ensures this. */
165
166	const uint32_t cbChunk = cbRecord - pPartialRecord->cb;
167	if (cbChunk >= pVBVAData->cbData)
168	{
169	return false;
170	}
171
172	if (pPartialRecord->pu8)
173	{
174	Assert(pPartialRecord->cb);
175	pu8New = (uint8_t *)RTMemRealloc(pPartialRecord->pu8, cbRecord);
176	}
177	else
178	{
179	Assert(!pPartialRecord->cb);
180	pu8New = (uint8_t *)RTMemAlloc(cbRecord);
181	}
182
183	if (!pu8New)
184	{
185	/* Memory allocation failed, fail the function. */
186	Log(("vbvaPartialRead: failed to (re)alocate memory for partial record!!! cbRecord 0x%08X\n",
187	cbRecord));
188
189	return false;
190	}
191
192	/* Fetch data from the ring buffer. */
193	if (!vbvaFetchBytes(pVBVAData, pu8New + pPartialRecord->cb, cbChunk))
194	{
195	return false;
196	}
197
198	pPartialRecord->pu8 = pu8New;
199	pPartialRecord->cb = cbRecord;
200
201	return true;
202	}
203
204	/**
205	* For contiguous chunks just return the address in the buffer. For crossing
206	* boundary - allocate a buffer from heap.
207	*/
208	static bool vbvaFetchCmd(VBVADATA pVBVAData, VBVACMDHDR RT_UNTRUSTED_VOLATILE_GUEST ppHdr, uint32_t pcbCmd)
209	{
210	VBVAPARTIALRECORD *pPartialRecord = &pVBVAData->partialRecord;
211	uint32_t indexRecordFirst = pVBVAData->indexRecordFirst;
212	const uint32_t indexRecordFree = ASMAtomicReadU32(&pVBVAData->guest.pVBVA->indexRecordFree);
213
214	LOGVBVABUFFER(("first = %d, free = %d\n",
215	indexRecordFirst, indexRecordFree));
216
217	if (indexRecordFree >= RT_ELEMENTS(pVBVAData->guest.pVBVA->aRecords))
218	{
219	return false;
220	}
221
222	if (indexRecordFirst == indexRecordFree)
223	{
224	/* No records to process. Return without assigning output variables. */
225	return true;
226	}
227
228	uint32_t cbRecordCurrent = ASMAtomicReadU32(&pVBVAData->guest.pVBVA->aRecords[indexRecordFirst].cbRecord);
229
230	LOGVBVABUFFER(("cbRecord = 0x%08X, pPartialRecord->cb = 0x%08X\n", cbRecordCurrent, pPartialRecord->cb));
231
232	uint32_t cbRecord = cbRecordCurrent & ~VBVA_F_RECORD_PARTIAL;
233
234	if (cbRecord > VBVA_MAX_RECORD_SIZE)
235	{
236	return false;
237	}
238
239	if (pPartialRecord->cb)
240	{
241	/* There is a partial read in process. Continue with it. */
242	Assert (pPartialRecord->pu8);
243
244	LOGVBVABUFFER(("continue partial record cb = %d cbRecord 0x%08X, first = %d, free = %d\n",
245	pPartialRecord->cb, cbRecordCurrent, indexRecordFirst, indexRecordFree));
246
247	if (cbRecord > pPartialRecord->cb)
248	{
249	/* New data has been added to the record. */
250	if (!vbvaPartialRead(cbRecord, pVBVAData))
251	{
252	return false;
253	}
254	}
255
256	if (!(cbRecordCurrent & VBVA_F_RECORD_PARTIAL))
257	{
258	/* The record is completed by guest. Return it to the caller. */
259	ppHdr = (VBVACMDHDR )pPartialRecord->pu8;
260	*pcbCmd = pPartialRecord->cb;
261
262	pPartialRecord->pu8 = NULL;
263	pPartialRecord->cb = 0;
264
265	/* Advance the record index and sync with guest. */
266	pVBVAData->indexRecordFirst = (indexRecordFirst + 1) % RT_ELEMENTS(pVBVAData->guest.pVBVA->aRecords);
267	pVBVAData->guest.pVBVA->indexRecordFirst = pVBVAData->indexRecordFirst;
268
269	LOGVBVABUFFER(("partial done ok, data = %d, free = %d\n",
270	pVBVAData->off32Data, pVBVAData->guest.pVBVA->off32Free));
271	}
272
273	return true;
274	}
275
276	/* A new record need to be processed. */
277	if (cbRecordCurrent & VBVA_F_RECORD_PARTIAL)
278	{
279	/* Current record is being written by guest. '=' is important here,
280	* because the guest will do a FLUSH at this condition.
281	* This partial record is too large for the ring buffer and must
282	* be accumulated in an allocated buffer.
283	*/
284	if (cbRecord >= pVBVAData->cbData - pVBVAData->cbPartialWriteThreshold)
285	{
286	/* Partial read must be started. */
287	if (!vbvaPartialRead(cbRecord, pVBVAData))
288	{
289	return false;
290	}
291
292	LOGVBVABUFFER(("started partial record cb = 0x%08X cbRecord 0x%08X, first = %d, free = %d\n",
293	pPartialRecord->cb, cbRecordCurrent, indexRecordFirst, indexRecordFree));
294	}
295
296	return true;
297	}
298
299	/* Current record is complete. If it is not empty, process it. */
300	if (cbRecord >= pVBVAData->cbData)
301	{
302	return false;
303	}
304
305	if (cbRecord)
306	{
307	/* The size of largest contiguous chunk in the ring buffer. */
308	uint32_t u32BytesTillBoundary = pVBVAData->cbData - pVBVAData->off32Data;
309
310	/* The pointer to data in the ring buffer. */
311	uint8_t RT_UNTRUSTED_VOLATILE_GUEST *pbSrc = &pVBVAData->guest.pu8Data[pVBVAData->off32Data];
312
313	/* Fetch or point the data. */
314	if (u32BytesTillBoundary >= cbRecord)
315	{
316	/* The command does not cross buffer boundary. Return address in the buffer. */
317	ppHdr = (VBVACMDHDR RT_UNTRUSTED_VOLATILE_GUEST )pbSrc;
318
319	/* The data offset will be updated in vbvaReleaseCmd. */
320	}
321	else
322	{
323	/* The command crosses buffer boundary. Rare case, so not optimized. */
324	uint8_t pbDst = (uint8_t )RTMemAlloc(cbRecord);
325	if (!pbDst)
326	{
327	LogFlowFunc (("could not allocate %d bytes from heap!!!\n", cbRecord));
328	return false;
329	}
330
331	vbvaFetchBytes(pVBVAData, pbDst, cbRecord);
332
333	ppHdr = (VBVACMDHDR )pbDst;
334
335	LOGVBVABUFFER(("Allocated from heap %p\n", pbDst));
336	}
337	}
338
339	*pcbCmd = cbRecord;
340
341	/* Advance the record index and sync with guest. */
342	pVBVAData->indexRecordFirst = (indexRecordFirst + 1) % RT_ELEMENTS(pVBVAData->guest.pVBVA->aRecords);
343	pVBVAData->guest.pVBVA->indexRecordFirst = pVBVAData->indexRecordFirst;
344
345	LOGVBVABUFFER(("done ok, data = %d, free = %d\n",
346	pVBVAData->off32Data, pVBVAData->guest.pVBVA->off32Free));
347
348	return true;
349	}
350
351	static void vbvaReleaseCmd(VBVADATA pVBVAData, VBVACMDHDR RT_UNTRUSTED_VOLATILE_GUEST pHdr, uint32_t cbCmd)
352	{
353	VBVAPARTIALRECORD *pPartialRecord = &pVBVAData->partialRecord;
354	const uint8_t RT_UNTRUSTED_VOLATILE_GUEST *pbRingBuffer = pVBVAData->guest.pu8Data;
355
356	if ( (uintptr_t)pHdr >= (uintptr_t)pbRingBuffer
357	&& (uintptr_t)pHdr < (uintptr_t)&pbRingBuffer[pVBVAData->cbData])
358	{
359	/* The pointer is inside ring buffer. Must be continuous chunk. */
360	Assert(pVBVAData->cbData - (uint32_t)((uint8_t *)pHdr - pbRingBuffer) >= cbCmd);
361
362	/* Advance data offset and sync with guest. */
363	pVBVAData->off32Data = (pVBVAData->off32Data + cbCmd) % pVBVAData->cbData;
364	pVBVAData->guest.pVBVA->off32Data = pVBVAData->off32Data;
365
366	Assert(!pPartialRecord->pu8 && pPartialRecord->cb == 0);
367	}
368	else
369	{
370	/* The pointer is outside. It is then an allocated copy. */
371	LOGVBVABUFFER(("Free heap %p\n", pHdr));
372
373	if ((uint8_t *)pHdr == pPartialRecord->pu8)
374	{
375	pPartialRecord->pu8 = NULL;
376	pPartialRecord->cb = 0;
377	}
378	else
379	{
380	Assert(!pPartialRecord->pu8 && pPartialRecord->cb == 0);
381	}
382
383	RTMemFree((void *)pHdr);
384	}
385	}
386
387	static int vbvaFlushProcess(unsigned uScreenId, PVGASTATE pVGAState, VBVADATA *pVBVAData)
388	{
389	LOGVBVABUFFER(("uScreenId %d, indexRecordFirst = %d, indexRecordFree = %d, off32Data = %d, off32Free = %d\n",
390	uScreenId, pVBVAData->indexRecordFirst, pVBVAData->guest.pVBVA->indexRecordFree,
391	pVBVAData->off32Data, pVBVAData->guest.pVBVA->off32Free));
392	struct {
393	/* The rectangle that includes all dirty rectangles. */
394	int32_t xLeft;
395	int32_t xRight;
396	int32_t yTop;
397	int32_t yBottom;
398	} dirtyRect;
399	RT_ZERO(dirtyRect);
400
401	bool fUpdate = false; /* Whether there were any updates. */
402	bool fDirtyEmpty = true;
403
404	for (;;)
405	{
406	/* Fetch the command data. */
407	VBVACMDHDR RT_UNTRUSTED_VOLATILE_GUEST *pHdr = NULL;
408	uint32_t cbCmd = UINT32_MAX;
409	if (!vbvaFetchCmd(pVBVAData, &pHdr, &cbCmd))
410	{
411	LogFunc(("unable to fetch command. off32Data = %d, off32Free = %d!!!\n",
412	pVBVAData->off32Data, pVBVAData->guest.pVBVA->off32Free));
413	return VERR_NOT_SUPPORTED;
414	}
415
416	if (cbCmd == uint32_t(~0))
417	{
418	/* No more commands yet in the queue. */
419	break;
420	}
421
422	if (cbCmd < sizeof(VBVACMDHDR))
423	{
424	LogFunc(("short command. off32Data = %d, off32Free = %d, cbCmd %d!!!\n",
425	pVBVAData->off32Data, pVBVAData->guest.pVBVA->off32Free, cbCmd));
426
427	return VERR_NOT_SUPPORTED;
428	}
429
430	if (cbCmd != 0)
431	{
432	if (!fUpdate)
433	{
434	pVGAState->pDrv->pfnVBVAUpdateBegin(pVGAState->pDrv, uScreenId);
435	fUpdate = true;
436	}
437
438	/* Updates the rectangle and sends the command to the VRDP server. */
439	pVGAState->pDrv->pfnVBVAUpdateProcess(pVGAState->pDrv, uScreenId, pHdr, cbCmd);
440
441	int32_t xRight = pHdr->x + pHdr->w;
442	int32_t yBottom = pHdr->y + pHdr->h;
443
444	/* These are global coords, relative to the primary screen. */
445
446	LOGVBVABUFFER(("cbCmd = %d, x=%d, y=%d, w=%d, h=%d\n",
447	cbCmd, pHdr->x, pHdr->y, pHdr->w, pHdr->h));
448	LogRel3(("%s: update command cbCmd = %d, x=%d, y=%d, w=%d, h=%d\n",
449	__FUNCTION__, cbCmd, pHdr->x, pHdr->y, pHdr->w, pHdr->h));
450
451	/* Collect all rects into one. */
452	if (fDirtyEmpty)
453	{
454	/* This is the first rectangle to be added. */
455	dirtyRect.xLeft = pHdr->x;
456	dirtyRect.yTop = pHdr->y;
457	dirtyRect.xRight = xRight;
458	dirtyRect.yBottom = yBottom;
459	fDirtyEmpty = false;
460	}
461	else
462	{
463	/* Adjust region coordinates. */
464	if (dirtyRect.xLeft > pHdr->x)
465	{
466	dirtyRect.xLeft = pHdr->x;
467	}
468
469	if (dirtyRect.yTop > pHdr->y)
470	{
471	dirtyRect.yTop = pHdr->y;
472	}
473
474	if (dirtyRect.xRight < xRight)
475	{
476	dirtyRect.xRight = xRight;
477	}
478
479	if (dirtyRect.yBottom < yBottom)
480	{
481	dirtyRect.yBottom = yBottom;
482	}
483	}
484	}
485
486	vbvaReleaseCmd(pVBVAData, pHdr, cbCmd);
487	}
488
489	if (fUpdate)
490	{
491	if (dirtyRect.xRight - dirtyRect.xLeft)
492	{
493	LogRel3(("%s: sending update screen=%d, x=%d, y=%d, w=%d, h=%d\n",
494	__FUNCTION__, uScreenId, dirtyRect.xLeft,
495	dirtyRect.yTop, dirtyRect.xRight - dirtyRect.xLeft,
496	dirtyRect.yBottom - dirtyRect.yTop));
497	pVGAState->pDrv->pfnVBVAUpdateEnd(pVGAState->pDrv, uScreenId, dirtyRect.xLeft, dirtyRect.yTop,
498	dirtyRect.xRight - dirtyRect.xLeft, dirtyRect.yBottom - dirtyRect.yTop);
499	}
500	else
501	{
502	pVGAState->pDrv->pfnVBVAUpdateEnd(pVGAState->pDrv, uScreenId, 0, 0, 0, 0);
503	}
504	}
505
506	return VINF_SUCCESS;
507	}
508
509	static int vbvaFlush(PVGASTATE pVGAState, VBVACONTEXT *pCtx)
510	{
511	int rc = VINF_SUCCESS;
512
513	unsigned uScreenId;
514	for (uScreenId = 0; uScreenId < pCtx->cViews; uScreenId++)
515	{
516	VBVADATA *pVBVAData = &pCtx->aViews[uScreenId].vbva;
517	if (pVBVAData->guest.pVBVA)
518	{
519	rc = vbvaFlushProcess(uScreenId, pVGAState, pVBVAData);
520	if (RT_FAILURE(rc))
521	break;
522	}
523	}
524
525	if (RT_FAILURE(rc))
526	{
527	/* Turn off VBVA processing. */
528	LogRel(("VBVA: Disabling (%Rrc)\n", rc));
529	pVGAState->fGuestCaps = 0;
530	pVGAState->pDrv->pfnVBVAGuestCapabilityUpdate(pVGAState->pDrv, pVGAState->fGuestCaps);
531	for (uScreenId = 0; uScreenId < pCtx->cViews; uScreenId++)
532	{
533	VBVADATA *pVBVAData = &pCtx->aViews[uScreenId].vbva;
534	if (pVBVAData->guest.pVBVA)
535	{
536	vbvaDataCleanup(pVBVAData);
537	pVGAState->pDrv->pfnVBVADisable(pVGAState->pDrv, uScreenId);
538	}
539	}
540	}
541
542	return rc;
543	}
544
545	static int vbvaResize(PVGASTATE pVGAState, VBVAVIEW pView, const VBVAINFOSCREEN pNewScreen, bool fResetInputMapping)
546	{
547	/* Callers ensure that pNewScreen contains valid data. */
548
549	/* Apply these changes. */
550	pView->screen = *pNewScreen;
551
552	uint8_t *pu8VRAM = pVGAState->vram_ptrR3 + pView->view.u32ViewOffset;
553	return pVGAState->pDrv->pfnVBVAResize (pVGAState->pDrv, &pView->view, &pView->screen, pu8VRAM, fResetInputMapping);
554	}
555
556	static int vbvaEnable(unsigned uScreenId, PVGASTATE pVGAState, VBVACONTEXT *pCtx,
557	VBVABUFFER RT_UNTRUSTED_VOLATILE_GUEST *pVBVA, uint32_t u32Offset, bool fRestored)
558	{
559	/*
560	* Copy into non-volatile memory and validate its content.
561	*/
562	VBVABUFFER VbgaSafe;
563	RT_COPY_VOLATILE(VbgaSafe, *pVBVA);
564	RT_UNTRUSTED_NONVOLATILE_COPY_FENCE();
565
566	uint32_t const cbVBVABuffer = RT_UOFFSETOF(VBVABUFFER, au8Data) + VbgaSafe.cbData;
567	ASSERT_GUEST_RETURN( VbgaSafe.cbData <= UINT32_MAX - RT_UOFFSETOF(VBVABUFFER, au8Data)
568	&& cbVBVABuffer <= pVGAState->vram_size
569	&& u32Offset > pVGAState->vram_size - cbVBVABuffer,
570	VERR_INVALID_PARAMETER);
571	if (!fRestored)
572	{
573	ASSERT_GUEST_RETURN(VbgaSafe.off32Data == 0, VERR_INVALID_PARAMETER);
574	ASSERT_GUEST_RETURN(VbgaSafe.off32Free == 0, VERR_INVALID_PARAMETER);
575	ASSERT_GUEST_RETURN(VbgaSafe.indexRecordFirst == 0, VERR_INVALID_PARAMETER);
576	ASSERT_GUEST_RETURN(VbgaSafe.indexRecordFree == 0, VERR_INVALID_PARAMETER);
577	}
578	ASSERT_GUEST_RETURN( VbgaSafe.cbPartialWriteThreshold < VbgaSafe.cbData
579	&& VbgaSafe.cbPartialWriteThreshold != 0,
580	VERR_INVALID_PARAMETER);
581	RT_UNTRUSTED_VALIDATED_FENCE();
582
583	/*
584	* Okay, try do the job.
585	*/
586	int rc;
587	if (pVGAState->pDrv->pfnVBVAEnable)
588	{
589	pVBVA->hostFlags.u32HostEvents = 0;
590	pVBVA->hostFlags.u32SupportedOrders = 0;
591	rc = pVGAState->pDrv->pfnVBVAEnable(pVGAState->pDrv, uScreenId, &pVBVA->hostFlags, false);
592	if (RT_SUCCESS(rc))
593	{
594	/* pVBVA->hostFlags has been set up by pfnVBVAEnable. */
595	LogFlowFunc(("u32HostEvents=0x%08x u32SupportedOrders=0x%08x\n",
596	pVBVA->hostFlags.u32HostEvents, pVBVA->hostFlags.u32SupportedOrders));
597
598	VBVADATA *pVBVAData = &pCtx->aViews[uScreenId].vbva;
599	pVBVAData->guest.pVBVA = pVBVA;
600	pVBVAData->guest.pu8Data = &pVBVA->au8Data[0];
601	pVBVAData->u32VBVAOffset = u32Offset;
602	pVBVAData->off32Data = VbgaSafe.off32Data;
603	pVBVAData->indexRecordFirst = VbgaSafe.indexRecordFirst;
604	pVBVAData->cbPartialWriteThreshold = VbgaSafe.cbPartialWriteThreshold;
605	pVBVAData->cbData = VbgaSafe.cbData;
606
607	if (!fRestored)
608	{
609	/** @todo Actually this function must not touch the partialRecord structure at all,
610	* because initially it is a zero and when VBVA is disabled this should be set to zero.
611	* But I'm not sure that no code depends on zeroing partialRecord here.
612	* So for now (a quick fix for 4.1) just do not do this if the VM was restored,
613	* when partialRecord might be loaded already from the saved state.
614	*/
615	pVBVAData->partialRecord.pu8 = NULL;
616	pVBVAData->partialRecord.cb = 0;
617	}
618
619	/* VBVA is working so disable the pause. */
620	pCtx->fPaused = false;
621	}
622	}
623	else
624	rc = VERR_NOT_SUPPORTED;
625	return rc;
626	}
627
628	static int vbvaDisable (unsigned uScreenId, PVGASTATE pVGAState, VBVACONTEXT *pCtx)
629	{
630	/* Process any pending orders and empty the VBVA ring buffer. */
631	vbvaFlush (pVGAState, pCtx);
632
633	VBVADATA *pVBVAData = &pCtx->aViews[uScreenId].vbva;
634	vbvaDataCleanup(pVBVAData);
635
636	if (uScreenId == 0)
637	{
638	pVGAState->fGuestCaps = 0;
639	pVGAState->pDrv->pfnVBVAGuestCapabilityUpdate(pVGAState->pDrv, pVGAState->fGuestCaps);
640	}
641	pVGAState->pDrv->pfnVBVADisable(pVGAState->pDrv, uScreenId);
642	return VINF_SUCCESS;
643	}
644
645	bool VBVAIsEnabled(PVGASTATE pVGAState)
646	{
647	PHGSMIINSTANCE pHGSMI = pVGAState->pHGSMI;
648	if (pHGSMI)
649	{
650	VBVACONTEXT pCtx = (VBVACONTEXT )HGSMIContext(pHGSMI);
651	if (pCtx)
652	{
653	if (pCtx->cViews)
654	{
655	VBVAVIEW * pView = &pCtx->aViews[0];
656	if (pView->vbva.guest.pVBVA)
657	return true;
658	}
659	}
660	}
661	return false;
662	}
663
664	#ifdef DEBUG_sunlover
665	void dumpMouseShapeInfo(const VBVAMOUSESHAPEINFO *pMouseShapeInfo)
666	{
667	LogFlow(("fSet = %d, fVisible %d, fAlpha %d, @%d,%d %dx%d (%p, %d/%d)\n",
668	pMouseShapeInfo->fSet,
669	pMouseShapeInfo->fVisible,
670	pMouseShapeInfo->fAlpha,
671	pMouseShapeInfo->u32HotX,
672	pMouseShapeInfo->u32HotY,
673	pMouseShapeInfo->u32Width,
674	pMouseShapeInfo->u32Height,
675	pMouseShapeInfo->pu8Shape,
676	pMouseShapeInfo->cbShape,
677	pMouseShapeInfo->cbAllocated
678	));
679	}
680	#endif
681
682	static int vbvaUpdateMousePointerShape(PVGASTATE pVGAState, VBVAMOUSESHAPEINFO *pMouseShapeInfo, bool fShape)
683	{
684	LogFlowFunc(("pVGAState %p, pMouseShapeInfo %p, fShape %d\n",
685	pVGAState, pMouseShapeInfo, fShape));
686	#ifdef DEBUG_sunlover
687	dumpMouseShapeInfo(pMouseShapeInfo);
688	#endif
689
690	if (pVGAState->pDrv->pfnVBVAMousePointerShape == NULL)
691	{
692	return VERR_NOT_SUPPORTED;
693	}
694
695	int rc;
696	if (fShape && pMouseShapeInfo->pu8Shape != NULL)
697	{
698	rc = pVGAState->pDrv->pfnVBVAMousePointerShape (pVGAState->pDrv,
699	pMouseShapeInfo->fVisible,
700	pMouseShapeInfo->fAlpha,
701	pMouseShapeInfo->u32HotX,
702	pMouseShapeInfo->u32HotY,
703	pMouseShapeInfo->u32Width,
704	pMouseShapeInfo->u32Height,
705	pMouseShapeInfo->pu8Shape);
706	}
707	else
708	{
709	rc = pVGAState->pDrv->pfnVBVAMousePointerShape (pVGAState->pDrv,
710	pMouseShapeInfo->fVisible,
711	false,
712	0, 0,
713	0, 0,
714	NULL);
715	}
716
717	return rc;
718	}
719
720	static int vbvaMousePointerShape(PVGASTATE pVGAState, VBVACONTEXT *pCtx,
721	const VBVAMOUSEPOINTERSHAPE RT_UNTRUSTED_VOLATILE_GUEST *pShape, HGSMISIZE cbShape)
722	{
723	/*
724	* Make non-volatile copy of the shape header and validate it.
725	*/
726	VBVAMOUSEPOINTERSHAPE SafeShape;
727	RT_COPY_VOLATILE(SafeShape, *pShape);
728	RT_UNTRUSTED_NONVOLATILE_COPY_FENCE();
729
730	LogFlowFunc(("VBVA_MOUSE_POINTER_SHAPE: i32Result 0x%x, fu32Flags 0x%x, hot spot %d,%d, size %dx%d\n",
731	SafeShape.i32Result, SafeShape.fu32Flags, SafeShape.u32HotX, SafeShape.u32HotY, SafeShape.u32Width, SafeShape.u32Height));
732
733	const bool fVisible = RT_BOOL(SafeShape.fu32Flags & VBOX_MOUSE_POINTER_VISIBLE);
734	const bool fAlpha = RT_BOOL(SafeShape.fu32Flags & VBOX_MOUSE_POINTER_ALPHA);
735	const bool fShape = RT_BOOL(SafeShape.fu32Flags & VBOX_MOUSE_POINTER_SHAPE);
736
737	HGSMISIZE cbPointerData = 0;
738	if (fShape)
739	{
740	static const uint32_t s_cxMax = 2048; //used to be: 8192;
741	static const uint32_t s_cyMax = 2048; //used to be: 8192;
742	ASSERT_GUEST_MSG_RETURN( SafeShape.u32Width <= s_cxMax
743	\|\| SafeShape.u32Height <= s_cyMax,
744	("Too large: %ux%u, max %ux%x\n", SafeShape.u32Width, SafeShape.u32Height, s_cxMax, s_cyMax),
745	VERR_INVALID_PARAMETER);
746
747	cbPointerData = ((((SafeShape.u32Width + 7) / 8) * SafeShape.u32Height + 3) & ~3)
748	+ SafeShape.u32Width * 4 * SafeShape.u32Height;
749
750	ASSERT_GUEST_MSG_RETURN(cbPointerData <= cbShape - RT_UOFFSETOF(VBVAMOUSEPOINTERSHAPE, au8Data),
751	("Insufficent pointer data: Expected %#x, got %#x\n",
752	cbPointerData, cbShape - RT_UOFFSETOF(VBVAMOUSEPOINTERSHAPE, au8Data) ),
753	VERR_INVALID_PARAMETER);
754	}
755	RT_UNTRUSTED_VALIDATED_FENCE();
756
757	/*
758	* Do the job.
759	*/
760	/* Save mouse info it will be used to restore mouse pointer after restoring saved state. */
761	pCtx->mouseShapeInfo.fSet = true;
762	pCtx->mouseShapeInfo.fVisible = fVisible;
763	if (fShape)
764	{
765	/* Data related to shape. */
766	pCtx->mouseShapeInfo.u32HotX = SafeShape.u32HotX;
767	pCtx->mouseShapeInfo.u32HotY = SafeShape.u32HotY;
768	pCtx->mouseShapeInfo.u32Width = SafeShape.u32Width;
769	pCtx->mouseShapeInfo.u32Height = SafeShape.u32Height;
770	pCtx->mouseShapeInfo.fAlpha = fAlpha;
771
772	/* Reallocate memory buffer if necessary. */
773	if (cbPointerData > pCtx->mouseShapeInfo.cbAllocated)
774	{
775	RTMemFree (pCtx->mouseShapeInfo.pu8Shape);
776	pCtx->mouseShapeInfo.pu8Shape = NULL;
777	pCtx->mouseShapeInfo.cbShape = 0;
778
779	uint8_t pu8Shape = (uint8_t )RTMemAlloc (cbPointerData);
780	if (pu8Shape)
781	{
782	pCtx->mouseShapeInfo.pu8Shape = pu8Shape;
783	pCtx->mouseShapeInfo.cbAllocated = cbPointerData;
784	}
785	}
786
787	/* Copy shape bitmaps. */
788	if (pCtx->mouseShapeInfo.pu8Shape)
789	{
790	RT_BCOPY_VOLATILE(pCtx->mouseShapeInfo.pu8Shape, &pShape->au8Data[0], cbPointerData);
791	pCtx->mouseShapeInfo.cbShape = cbPointerData;
792	}
793	}
794
795	return vbvaUpdateMousePointerShape(pVGAState, &pCtx->mouseShapeInfo, fShape);
796	}
797
798	static uint32_t vbvaViewFromBufferPtr(PHGSMIINSTANCE pIns, const VBVACONTEXT *pCtx,
799	const void RT_UNTRUSTED_VOLATILE_GUEST *pvBuffer)
800	{
801	/* Check which view contains the buffer. */
802	HGSMIOFFSET offBuffer = HGSMIPointerToOffsetHost(pIns, pvBuffer);
803	if (offBuffer != HGSMIOFFSET_VOID)
804	{
805	unsigned uScreenId;
806	for (uScreenId = 0; uScreenId < pCtx->cViews; uScreenId++)
807	{
808	const VBVAINFOVIEW *pView = &pCtx->aViews[uScreenId].view;
809	if ((uint32_t)(offBuffer - pView->u32ViewOffset) < pView->u32ViewSize)
810	return pView->u32ViewIndex;
811	}
812	}
813	return UINT32_MAX;
814	}
815
816	#ifdef DEBUG_sunlover
817	static void dumpctx(const VBVACONTEXT *pCtx)
818	{
819	Log(("VBVACONTEXT dump: cViews %d\n", pCtx->cViews));
820
821	uint32_t iView;
822	for (iView = 0; iView < pCtx->cViews; iView++)
823	{
824	const VBVAVIEW *pView = &pCtx->aViews[iView];
825
826	Log((" view %d o 0x%x s 0x%x m 0x%x\n",
827	pView->view.u32ViewIndex,
828	pView->view.u32ViewOffset,
829	pView->view.u32ViewSize,
830	pView->view.u32MaxScreenSize));
831
832	Log((" screen %d @%d,%d s 0x%x l 0x%x %dx%d bpp %d f 0x%x\n",
833	pView->screen.u32ViewIndex,
834	pView->screen.i32OriginX,
835	pView->screen.i32OriginY,
836	pView->screen.u32StartOffset,
837	pView->screen.u32LineSize,
838	pView->screen.u32Width,
839	pView->screen.u32Height,
840	pView->screen.u16BitsPerPixel,
841	pView->screen.u16Flags));
842
843	Log((" VBVA o 0x%x p %p\n",
844	pView->vbva.u32VBVAOffset,
845	pView->vbva.guest.pVBVA));
846
847	Log((" PR cb 0x%x p %p\n",
848	pView->vbva.partialRecord.cb,
849	pView->vbva.partialRecord.pu8));
850	}
851
852	dumpMouseShapeInfo(&pCtx->mouseShapeInfo);
853	}
854	#endif /* DEBUG_sunlover */
855
856	#define VBOXVBVASAVEDSTATE_VHWAAVAILABLE_MAGIC 0x12345678
857	#define VBOXVBVASAVEDSTATE_VHWAUNAVAILABLE_MAGIC 0x9abcdef0
858
859	#ifdef VBOX_WITH_VIDEOHWACCEL
860	static void vbvaVHWAHHCommandReinit(VBOXVHWACMD* pHdr, VBOXVHWACMD_TYPE enmCmd, int32_t iDisplay)
861	{
862	memset(pHdr, 0, VBOXVHWACMD_HEADSIZE());
863	pHdr->cRefs = 1;
864	pHdr->iDisplay = iDisplay;
865	pHdr->rc = VERR_NOT_IMPLEMENTED;
866	pHdr->enmCmd = enmCmd;
867	pHdr->Flags = VBOXVHWACMD_FLAG_HH_CMD;
868	}
869
870	static VBOXVHWACMD *vbvaVHWAHHCommandCreate(VBOXVHWACMD_TYPE enmCmd, int32_t iDisplay, VBOXVHWACMD_LENGTH cbCmd)
871	{
872	VBOXVHWACMD pHdr = (VBOXVHWACMD )RTMemAllocZ(cbCmd + VBOXVHWACMD_HEADSIZE());
873	Assert(pHdr);
874	if (pHdr)
875	vbvaVHWAHHCommandReinit(pHdr, enmCmd, iDisplay);
876
877	return pHdr;
878	}
879
880	DECLINLINE(void) vbvaVHWAHHCommandRelease(VBOXVHWACMD *pCmd)
881	{
882	uint32_t cRefs = ASMAtomicDecU32(&pCmd->cRefs);
883	if (!cRefs)
884	RTMemFree(pCmd);
885	}
886
887	DECLINLINE(void) vbvaVHWAHHCommandRetain(VBOXVHWACMD *pCmd)
888	{
889	ASMAtomicIncU32(&pCmd->cRefs);
890	}
891
892	static void vbvaVHWACommandComplete(PVGASTATE pVGAState, VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCommand, bool fAsyncCommand)
893	{
894	if (fAsyncCommand)
895	{
896	Assert(pCommand->Flags & VBOXVHWACMD_FLAG_HG_ASYNCH);
897	vbvaVHWACommandCompleteAsync(&pVGAState->IVBVACallbacks, pCommand);
898	}
899	else
900	{
901	Log(("VGA Command <<< Sync rc %d %#p, %d\n", pCommand->rc, pCommand, pCommand->enmCmd));
902	pCommand->Flags &= ~VBOXVHWACMD_FLAG_HG_ASYNCH;
903	}
904
905	}
906
907	static void vbvaVHWACommandCompleteAllPending(PVGASTATE pVGAState, int rc)
908	{
909	if (!ASMAtomicUoReadU32(&pVGAState->pendingVhwaCommands.cPending))
910	return;
911
912	PDMCritSectEnter(&pVGAState->CritSect, VERR_SEM_BUSY);
913
914	VBOX_VHWA_PENDINGCMD pIter, pNext;
915	RTListForEachSafe(&pVGAState->pendingVhwaCommands.PendingList, pIter, pNext, VBOX_VHWA_PENDINGCMD, Node)
916	{
917	pIter->pCommand->rc = rc;
918	vbvaVHWACommandComplete(pVGAState, pIter->pCommand, true);
919
920	/* the command is submitted/processed, remove from the pend list */
921	RTListNodeRemove(&pIter->Node);
922	ASMAtomicDecU32(&pVGAState->pendingVhwaCommands.cPending);
923	RTMemFree(pIter);
924	}
925
926	PDMCritSectLeave(&pVGAState->CritSect);
927	}
928
929	static void vbvaVHWACommandClearAllPending(PVGASTATE pVGAState)
930	{
931	if (!ASMAtomicUoReadU32(&pVGAState->pendingVhwaCommands.cPending))
932	return;
933
934	PDMCritSectEnter(&pVGAState->CritSect, VERR_SEM_BUSY);
935
936	VBOX_VHWA_PENDINGCMD pIter, pNext;
937	RTListForEachSafe(&pVGAState->pendingVhwaCommands.PendingList, pIter, pNext, VBOX_VHWA_PENDINGCMD, Node)
938	{
939	RTListNodeRemove(&pIter->Node);
940	ASMAtomicDecU32(&pVGAState->pendingVhwaCommands.cPending);
941	RTMemFree(pIter);
942	}
943
944	PDMCritSectLeave(&pVGAState->CritSect);
945	}
946
947	static void vbvaVHWACommandPend(PVGASTATE pVGAState, VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCommand)
948	{
949	int rc = VERR_BUFFER_OVERFLOW;
950
951	if (ASMAtomicUoReadU32(&pVGAState->pendingVhwaCommands.cPending) < VBOX_VHWA_MAX_PENDING_COMMANDS)
952	{
953	VBOX_VHWA_PENDINGCMD pPend = (VBOX_VHWA_PENDINGCMD )RTMemAlloc(sizeof(*pPend));
954	if (pPend)
955	{
956	pCommand->Flags \|= VBOXVHWACMD_FLAG_HG_ASYNCH;
957	pPend->pCommand = pCommand;
958	PDMCritSectEnter(&pVGAState->CritSect, VERR_SEM_BUSY);
959	if (ASMAtomicUoReadU32(&pVGAState->pendingVhwaCommands.cPending) < VBOX_VHWA_MAX_PENDING_COMMANDS)
960	{
961	RTListAppend(&pVGAState->pendingVhwaCommands.PendingList, &pPend->Node);
962	ASMAtomicIncU32(&pVGAState->pendingVhwaCommands.cPending);
963	PDMCritSectLeave(&pVGAState->CritSect);
964	return;
965	}
966	PDMCritSectLeave(&pVGAState->CritSect);
967	LogRel(("VBVA: Pending command count has reached its threshold.. completing them all.."));
968	RTMemFree(pPend);
969	}
970	else
971	rc = VERR_NO_MEMORY;
972	}
973	else
974	LogRel(("VBVA: Pending command count has reached its threshold, completing them all.."));
975
976	vbvaVHWACommandCompleteAllPending(pVGAState, rc);
977
978	pCommand->rc = rc;
979
980	vbvaVHWACommandComplete(pVGAState, pCommand, false);
981	}
982
983	static bool vbvaVHWACommandCanPend(VBOXVHWACMD_TYPE enmCmd)
984	{
985	switch (enmCmd)
986	{
987	case VBOXVHWACMD_TYPE_HH_CONSTRUCT:
988	case VBOXVHWACMD_TYPE_HH_SAVESTATE_SAVEBEGIN:
989	case VBOXVHWACMD_TYPE_HH_SAVESTATE_SAVEEND:
990	case VBOXVHWACMD_TYPE_HH_SAVESTATE_SAVEPERFORM:
991	case VBOXVHWACMD_TYPE_HH_SAVESTATE_LOADPERFORM:
992	return false;
993	default:
994	return true;
995	}
996	}
997
998	static int vbvaVHWACommandSavePending(PVGASTATE pVGAState, PSSMHANDLE pSSM)
999	{
1000	int rc = SSMR3PutU32(pSSM, pVGAState->pendingVhwaCommands.cPending);
1001	AssertRCReturn(rc, rc);
1002
1003	VBOX_VHWA_PENDINGCMD *pIter;
1004	RTListForEach(&pVGAState->pendingVhwaCommands.PendingList, pIter, VBOX_VHWA_PENDINGCMD, Node)
1005	{
1006	rc = SSMR3PutU32(pSSM, (uint32_t)(((uint8_t)pIter->pCommand) - ((uint8_t)pVGAState->vram_ptrR3)));
1007	AssertRCReturn(rc, rc);
1008	}
1009	return rc;
1010	}
1011
1012	static int vbvaVHWACommandLoadPending(PVGASTATE pVGAState, PSSMHANDLE pSSM, uint32_t u32Version)
1013	{
1014	if (u32Version < VGA_SAVEDSTATE_VERSION_WITH_PENDVHWA)
1015	return VINF_SUCCESS;
1016
1017	uint32_t u32;
1018	int rc = SSMR3GetU32(pSSM, &u32);
1019	AssertRCReturn(rc, rc);
1020	for (uint32_t i = 0; i < u32; ++i)
1021	{
1022	uint32_t off32;
1023	rc = SSMR3GetU32(pSSM, &off32);
1024	AssertRCReturn(rc, rc);
1025	VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCommand
1026	= (VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST )((uint8_t volatile )pVGAState->vram_ptrR3 + off32);
1027	vbvaVHWACommandPend(pVGAState, pCommand);
1028	}
1029	return rc;
1030	}
1031
1032
1033	static bool vbvaVHWACommandSubmit(PVGASTATE pVGAState, VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCommand, bool fAsyncCommand)
1034	{
1035	VBOXVHWACMD_TYPE enmCmd = pCommand->enmCmd;
1036	ASMCompilerBarrier();
1037
1038	bool fPend = false;
1039	if (pVGAState->pDrv->pfnVHWACommandProcess)
1040	{
1041	Log(("VGA Command >>> %#p, %d\n", pCommand, enmCmd));
1042	int rc = pVGAState->pDrv->pfnVHWACommandProcess(pVGAState->pDrv, enmCmd, pCommand);
1043	if (rc == VINF_CALLBACK_RETURN)
1044	{
1045	Log(("VGA Command --- Going Async %#p, %d\n", pCommand, enmCmd));
1046	return true; /* command will be completed asynchronously, return right away */
1047	}
1048	if (rc == VERR_INVALID_STATE)
1049	{
1050	Log(("VGA Command --- Trying Pend %#p, %d\n", pCommand, enmCmd));
1051	fPend = vbvaVHWACommandCanPend(enmCmd);
1052	if (!fPend)
1053	{
1054	Log(("VGA Command --- Can NOT Pend %#p, %d\n", pCommand, enmCmd));
1055	pCommand->rc = rc;
1056	}
1057	else
1058	Log(("VGA Command --- Can Pend %#p, %d\n", pCommand, enmCmd));
1059	}
1060	else
1061	{
1062	Log(("VGA Command --- Going Complete Sync rc %d %#p, %d\n", rc, pCommand, enmCmd));
1063	pCommand->rc = rc;
1064	}
1065
1066	/* the command was completed, take a special care about it (seee below) */
1067	}
1068	else
1069	{
1070	AssertFailed();
1071	pCommand->rc = VERR_INVALID_STATE;
1072	}
1073
1074	if (fPend)
1075	return false;
1076
1077	vbvaVHWACommandComplete(pVGAState, pCommand, fAsyncCommand);
1078
1079	return true;
1080	}
1081
1082	static bool vbvaVHWACheckPendingCommands(PVGASTATE pVGAState)
1083	{
1084	if (!ASMAtomicUoReadU32(&pVGAState->pendingVhwaCommands.cPending))
1085	return true;
1086
1087	PDMCritSectEnter(&pVGAState->CritSect, VERR_SEM_BUSY);
1088
1089	VBOX_VHWA_PENDINGCMD pIter, pNext;
1090	RTListForEachSafe(&pVGAState->pendingVhwaCommands.PendingList, pIter, pNext, VBOX_VHWA_PENDINGCMD, Node)
1091	{
1092	if (!vbvaVHWACommandSubmit(pVGAState, pIter->pCommand, true))
1093	{
1094	PDMCritSectLeave(&pVGAState->CritSect);
1095	return false; /* the command should be pended still */
1096	}
1097
1098	/* the command is submitted/processed, remove from the pend list */
1099	RTListNodeRemove(&pIter->Node);
1100	ASMAtomicDecU32(&pVGAState->pendingVhwaCommands.cPending);
1101	RTMemFree(pIter);
1102	}
1103
1104	PDMCritSectLeave(&pVGAState->CritSect);
1105
1106	return true;
1107	}
1108
1109	void vbvaTimerCb(PVGASTATE pVGAState)
1110	{
1111	vbvaVHWACheckPendingCommands(pVGAState);
1112	}
1113	static void vbvaVHWAHandleCommand(PVGASTATE pVGAState, VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCmd)
1114	{
1115	if (vbvaVHWACheckPendingCommands(pVGAState))
1116	{
1117	if (vbvaVHWACommandSubmit(pVGAState, pCmd, false))
1118	return;
1119	}
1120
1121	vbvaVHWACommandPend(pVGAState, pCmd);
1122	}
1123
1124	static DECLCALLBACK(void) vbvaVHWAHHCommandSetEventCallback(void * pContext)
1125	{
1126	RTSemEventSignal((RTSEMEVENT)pContext);
1127	}
1128
1129	static int vbvaVHWAHHCommandPost(PVGASTATE pVGAState, VBOXVHWACMD* pCmd)
1130	{
1131	RTSEMEVENT hComplEvent;
1132	int rc = RTSemEventCreate(&hComplEvent);
1133	AssertRC(rc);
1134	if(RT_SUCCESS(rc))
1135	{
1136	/* ensure the cmd is not deleted until we process it */
1137	vbvaVHWAHHCommandRetain (pCmd);
1138	VBOXVHWA_HH_CALLBACK_SET(pCmd, vbvaVHWAHHCommandSetEventCallback, (void*)hComplEvent);
1139	vbvaVHWAHandleCommand(pVGAState, pCmd);
1140	if((ASMAtomicReadU32((volatile uint32_t *)&pCmd->Flags) & VBOXVHWACMD_FLAG_HG_ASYNCH) != 0)
1141	{
1142	rc = RTSemEventWaitNoResume(hComplEvent, RT_INDEFINITE_WAIT);
1143	}
1144	else
1145	{
1146	/* the command is completed */
1147	}
1148
1149	AssertRC(rc);
1150	if(RT_SUCCESS(rc))
1151	{
1152	RTSemEventDestroy(hComplEvent);
1153	}
1154	vbvaVHWAHHCommandRelease(pCmd);
1155	}
1156	return rc;
1157	}
1158
1159	int vbvaVHWAConstruct(PVGASTATE pVGAState)
1160	{
1161	pVGAState->pendingVhwaCommands.cPending = 0;
1162	RTListInit(&pVGAState->pendingVhwaCommands.PendingList);
1163
1164	VBOXVHWACMD *pCmd = vbvaVHWAHHCommandCreate(VBOXVHWACMD_TYPE_HH_CONSTRUCT, 0, sizeof(VBOXVHWACMD_HH_CONSTRUCT));
1165	Assert(pCmd);
1166	if(pCmd)
1167	{
1168	uint32_t iDisplay = 0;
1169	int rc = VINF_SUCCESS;
1170	VBOXVHWACMD_HH_CONSTRUCT *pBody = VBOXVHWACMD_BODY_HOST_HEAP(pCmd, VBOXVHWACMD_HH_CONSTRUCT);
1171
1172	do
1173	{
1174	memset(pBody, 0, sizeof(VBOXVHWACMD_HH_CONSTRUCT));
1175
1176	PPDMDEVINS pDevIns = pVGAState->pDevInsR3;
1177	PVM pVM = PDMDevHlpGetVM(pDevIns);
1178
1179	pBody->pVM = pVM;
1180	pBody->pvVRAM = pVGAState->vram_ptrR3;
1181	pBody->cbVRAM = pVGAState->vram_size;
1182
1183	rc = vbvaVHWAHHCommandPost(pVGAState, pCmd);
1184	ASMCompilerBarrier();
1185
1186	AssertRC(rc);
1187	if (RT_SUCCESS(rc))
1188	{
1189	rc = pCmd->rc;
1190	AssertMsg(RT_SUCCESS(rc) \|\| rc == VERR_NOT_IMPLEMENTED, ("%Rrc\n", rc));
1191	if(rc == VERR_NOT_IMPLEMENTED)
1192	{
1193	/** @todo set some flag in pVGAState indicating VHWA is not supported */
1194	/* VERR_NOT_IMPLEMENTED is not a failure, we just do not support it */
1195	rc = VINF_SUCCESS;
1196	}
1197
1198	if (!RT_SUCCESS(rc))
1199	break;
1200	}
1201	else
1202	break;
1203
1204	++iDisplay;
1205	if (iDisplay >= pVGAState->cMonitors)
1206	break;
1207	vbvaVHWAHHCommandReinit(pCmd, VBOXVHWACMD_TYPE_HH_CONSTRUCT, (int32_t)iDisplay);
1208	} while (true);
1209
1210	vbvaVHWAHHCommandRelease(pCmd);
1211
1212	return rc;
1213	}
1214	return VERR_OUT_OF_RESOURCES;
1215	}
1216
1217	int vbvaVHWAReset(PVGASTATE pVGAState)
1218	{
1219	vbvaVHWACommandClearAllPending(pVGAState);
1220
1221	/* ensure we have all pending cmds processed and h->g cmds disabled */
1222	VBOXVHWACMD *pCmd = vbvaVHWAHHCommandCreate(VBOXVHWACMD_TYPE_HH_RESET, 0, 0);
1223	Assert(pCmd);
1224	if(pCmd)
1225	{
1226	int rc = VINF_SUCCESS;
1227	uint32_t iDisplay = 0;
1228
1229	do
1230	{
1231	rc =vbvaVHWAHHCommandPost(pVGAState, pCmd);
1232	AssertRC(rc);
1233	if(RT_SUCCESS(rc))
1234	{
1235	rc = pCmd->rc;
1236	AssertMsg(RT_SUCCESS(rc) \|\| rc == VERR_NOT_IMPLEMENTED, ("%Rrc\n", rc));
1237	if (rc == VERR_NOT_IMPLEMENTED)
1238	rc = VINF_SUCCESS;
1239	}
1240
1241	if (!RT_SUCCESS(rc))
1242	break;
1243
1244	++iDisplay;
1245	if (iDisplay >= pVGAState->cMonitors)
1246	break;
1247	vbvaVHWAHHCommandReinit(pCmd, VBOXVHWACMD_TYPE_HH_RESET, (int32_t)iDisplay);
1248
1249	} while (true);
1250
1251	vbvaVHWAHHCommandRelease(pCmd);
1252
1253	return rc;
1254	}
1255	return VERR_OUT_OF_RESOURCES;
1256	}
1257
1258	typedef DECLCALLBACK(bool) FNVBOXVHWAHHCMDPRECB(PVGASTATE pVGAState, VBOXVHWACMD pCmd, uint32_t iDisplay, void pvContext);
1259	typedef FNVBOXVHWAHHCMDPRECB *PFNVBOXVHWAHHCMDPRECB;
1260
1261	typedef DECLCALLBACK(bool) FNVBOXVHWAHHCMDPOSTCB(PVGASTATE pVGAState, VBOXVHWACMD pCmd, uint32_t iDisplay, int rc, void pvContext);
1262	typedef FNVBOXVHWAHHCMDPOSTCB *PFNVBOXVHWAHHCMDPOSTCB;
1263
1264	int vbvaVHWAHHPost(PVGASTATE pVGAState, VBOXVHWACMD pCmd, PFNVBOXVHWAHHCMDPRECB pfnPre, PFNVBOXVHWAHHCMDPOSTCB pfnPost, void pvContext)
1265	{
1266	const VBOXVHWACMD_TYPE enmType = pCmd->enmCmd;
1267	int rc = VINF_SUCCESS;
1268	uint32_t iDisplay = 0;
1269
1270	do
1271	{
1272	if (!pfnPre \|\| pfnPre(pVGAState, pCmd, iDisplay, pvContext))
1273	{
1274	rc = vbvaVHWAHHCommandPost(pVGAState, pCmd);
1275	AssertRC(rc);
1276	if (pfnPost)
1277	{
1278	if (!pfnPost(pVGAState, pCmd, iDisplay, rc, pvContext))
1279	{
1280	rc = VINF_SUCCESS;
1281	break;
1282	}
1283	rc = VINF_SUCCESS;
1284	}
1285	else if(RT_SUCCESS(rc))
1286	{
1287	rc = pCmd->rc;
1288	AssertMsg(RT_SUCCESS(rc) \|\| rc == VERR_NOT_IMPLEMENTED, ("%Rrc\n", rc));
1289	if(rc == VERR_NOT_IMPLEMENTED)
1290	{
1291	rc = VINF_SUCCESS;
1292	}
1293	}
1294
1295	if (!RT_SUCCESS(rc))
1296	break;
1297	}
1298
1299	++iDisplay;
1300	if (iDisplay >= pVGAState->cMonitors)
1301	break;
1302	vbvaVHWAHHCommandReinit(pCmd, enmType, (int32_t)iDisplay);
1303	} while (true);
1304
1305	return rc;
1306	}
1307
1308	/** @todo call this also on reset? */
1309	int vbvaVHWAEnable (PVGASTATE pVGAState, bool bEnable)
1310	{
1311	const VBOXVHWACMD_TYPE enmType = bEnable ? VBOXVHWACMD_TYPE_HH_ENABLE : VBOXVHWACMD_TYPE_HH_DISABLE;
1312	VBOXVHWACMD *pCmd = vbvaVHWAHHCommandCreate(enmType, 0, 0);
1313	Assert(pCmd);
1314	if(pCmd)
1315	{
1316	int rc = vbvaVHWAHHPost (pVGAState, pCmd, NULL, NULL, NULL);
1317	vbvaVHWAHHCommandRelease(pCmd);
1318	return rc;
1319	}
1320	return VERR_OUT_OF_RESOURCES;
1321	}
1322
1323	int vboxVBVASaveStatePrep(PPDMDEVINS pDevIns)
1324	{
1325	/* ensure we have no pending commands */
1326	return vbvaVHWAEnable(PDMINS_2_DATA(pDevIns, PVGASTATE), false);
1327	}
1328
1329	int vboxVBVASaveStateDone(PPDMDEVINS pDevIns)
1330	{
1331	/* ensure we have no pending commands */
1332	return vbvaVHWAEnable(PDMINS_2_DATA(pDevIns, PVGASTATE), true);
1333	}
1334
1335	DECLCALLBACK(int) vbvaVHWACommandCompleteAsync(PPDMIDISPLAYVBVACALLBACKS pInterface, VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCmd)
1336	{
1337	int rc;
1338	Log(("VGA Command <<< Async rc %d %#p, %d\n", pCmd->rc, pCmd, pCmd->enmCmd));
1339
1340	if ((pCmd->Flags & VBOXVHWACMD_FLAG_HH_CMD) == 0)
1341	{
1342	PVGASTATE pVGAState = PPDMIDISPLAYVBVACALLBACKS_2_PVGASTATE(pInterface);
1343	PHGSMIINSTANCE pIns = pVGAState->pHGSMI;
1344
1345	Assert(pCmd->Flags & VBOXVHWACMD_FLAG_HG_ASYNCH);
1346	#ifdef VBOX_WITH_WDDM
1347	if (pVGAState->fGuestCaps & VBVACAPS_COMPLETEGCMD_BY_IOREAD)
1348	{
1349	rc = HGSMICompleteGuestCommand(pIns, pCmd, !!(pCmd->Flags & VBOXVHWACMD_FLAG_GH_ASYNCH_IRQ));
1350	AssertRC(rc);
1351	}
1352	else
1353	#endif
1354	{
1355	VBVAHOSTCMD RT_UNTRUSTED_VOLATILE_GUEST pHostCmd = NULL; / Shut up MSC. */
1356	if (pCmd->Flags & VBOXVHWACMD_FLAG_GH_ASYNCH_EVENT)
1357	{
1358	rc = HGSMIHostCommandAlloc(pIns,
1359	(void RT_UNTRUSTED_VOLATILE_GUEST **)&pHostCmd,
1360	VBVAHOSTCMD_SIZE(sizeof(VBVAHOSTCMDEVENT)),
1361	HGSMI_CH_VBVA,
1362	VBVAHG_EVENT);
1363	AssertRC(rc);
1364	if (RT_SUCCESS(rc))
1365	{
1366	memset((void *)pHostCmd, 0 , VBVAHOSTCMD_SIZE(sizeof(VBVAHOSTCMDEVENT)));
1367	pHostCmd->iDstID = pCmd->iDisplay;
1368	pHostCmd->customOpCode = 0;
1369	VBVAHOSTCMDEVENT RT_UNTRUSTED_VOLATILE_GUEST *pBody = VBVAHOSTCMD_BODY(pHostCmd, VBVAHOSTCMDEVENT);
1370	pBody->pEvent = pCmd->GuestVBVAReserved1;
1371	}
1372	}
1373	else
1374	{
1375	HGSMIOFFSET offCmd = HGSMIPointerToOffsetHost(pIns, pCmd);
1376	Assert(offCmd != HGSMIOFFSET_VOID);
1377	if (offCmd != HGSMIOFFSET_VOID)
1378	{
1379	rc = HGSMIHostCommandAlloc(pIns,
1380	(void RT_UNTRUSTED_VOLATILE_GUEST **)&pHostCmd,
1381	VBVAHOSTCMD_SIZE(sizeof(VBVAHOSTCMDVHWACMDCOMPLETE)),
1382	HGSMI_CH_VBVA,
1383	VBVAHG_DISPLAY_CUSTOM);
1384	AssertRC(rc);
1385	if (RT_SUCCESS(rc))
1386	{
1387	memset((void *)pHostCmd, 0 , VBVAHOSTCMD_SIZE(sizeof(VBVAHOSTCMDVHWACMDCOMPLETE)));
1388	pHostCmd->iDstID = pCmd->iDisplay;
1389	pHostCmd->customOpCode = VBVAHG_DCUSTOM_VHWA_CMDCOMPLETE;
1390	VBVAHOSTCMDVHWACMDCOMPLETE RT_UNTRUSTED_VOLATILE_GUEST *pBody
1391	= VBVAHOSTCMD_BODY(pHostCmd, VBVAHOSTCMDVHWACMDCOMPLETE);
1392	pBody->offCmd = offCmd;
1393	}
1394	}
1395	else
1396	rc = VERR_INVALID_PARAMETER;
1397	}
1398
1399	if (RT_SUCCESS(rc))
1400	{
1401	rc = HGSMIHostCommandSubmitAndFreeAsynch(pIns, pHostCmd, RT_BOOL(pCmd->Flags & VBOXVHWACMD_FLAG_GH_ASYNCH_IRQ));
1402	AssertRC(rc);
1403	if (RT_SUCCESS(rc))
1404	return rc;
1405
1406	HGSMIHostCommandFree (pIns, pHostCmd);
1407	}
1408	}
1409	}
1410	else
1411	{
1412	PFNVBOXVHWA_HH_CALLBACK pfn = VBOXVHWA_HH_CALLBACK_GET(pCmd);
1413	if (pfn)
1414	pfn(VBOXVHWA_HH_CALLBACK_GET_ARG(pCmd));
1415	rc = VINF_SUCCESS;
1416	}
1417	return rc;
1418	}
1419
1420	typedef struct VBOXVBVASAVEDSTATECBDATA
1421	{
1422	PSSMHANDLE pSSM;
1423	int rc;
1424	bool ab2DOn[VBOX_VIDEO_MAX_SCREENS];
1425	} VBOXVBVASAVEDSTATECBDATA, *PVBOXVBVASAVEDSTATECBDATA;
1426
1427	static DECLCALLBACK(bool) vboxVBVASaveStateBeginPostCb(PVGASTATE pVGAState, VBOXVHWACMD *pCmd, uint32_t iDisplay,
1428	int rc, void *pvContext)
1429	{
1430	RT_NOREF(pVGAState, pCmd);
1431	PVBOXVBVASAVEDSTATECBDATA pData = (PVBOXVBVASAVEDSTATECBDATA)pvContext;
1432	if (RT_FAILURE(pData->rc))
1433	return false;
1434	if (RT_FAILURE(rc))
1435	{
1436	pData->rc = rc;
1437	return false;
1438	}
1439
1440	Assert(iDisplay < RT_ELEMENTS(pData->ab2DOn));
1441	if (iDisplay >= RT_ELEMENTS(pData->ab2DOn))
1442	{
1443	pData->rc = VERR_INVALID_PARAMETER;
1444	return false;
1445	}
1446
1447	Assert(RT_SUCCESS(pCmd->rc) \|\| pCmd->rc == VERR_NOT_IMPLEMENTED);
1448	if (RT_SUCCESS(pCmd->rc))
1449	{
1450	pData->ab2DOn[iDisplay] = true;
1451	}
1452	else if (pCmd->rc != VERR_NOT_IMPLEMENTED)
1453	{
1454	pData->rc = pCmd->rc;
1455	return false;
1456	}
1457
1458	return true;
1459	}
1460
1461	static DECLCALLBACK(bool)
1462	vboxVBVASaveStatePerformPreCb(PVGASTATE pVGAState, VBOXVHWACMD pCmd, uint32_t iDisplay, void pvContext)
1463	{
1464	RT_NOREF(pVGAState, pCmd);
1465	PVBOXVBVASAVEDSTATECBDATA pData = (PVBOXVBVASAVEDSTATECBDATA)pvContext;
1466	if (RT_FAILURE(pData->rc))
1467	return false;
1468
1469	Assert(iDisplay < RT_ELEMENTS(pData->ab2DOn));
1470	if (iDisplay >= RT_ELEMENTS(pData->ab2DOn))
1471	{
1472	pData->rc = VERR_INVALID_PARAMETER;
1473	return false;
1474	}
1475
1476	int rc;
1477
1478	if (pData->ab2DOn[iDisplay])
1479	{
1480	rc = SSMR3PutU32 (pData->pSSM, VBOXVBVASAVEDSTATE_VHWAAVAILABLE_MAGIC); AssertRC(rc);
1481	if (RT_FAILURE(rc))
1482	{
1483	pData->rc = rc;
1484	return false;
1485	}
1486	return true;
1487	}
1488
1489	rc = SSMR3PutU32 (pData->pSSM, VBOXVBVASAVEDSTATE_VHWAUNAVAILABLE_MAGIC); AssertRC(rc);
1490	if (RT_FAILURE(rc))
1491	{
1492	pData->rc = rc;
1493	return false;
1494	}
1495
1496	return false;
1497	}
1498
1499	static DECLCALLBACK(bool) vboxVBVASaveStateEndPreCb(PVGASTATE pVGAState, VBOXVHWACMD pCmd, uint32_t iDisplay, void pvContext)
1500	{
1501	RT_NOREF(pVGAState, pCmd);
1502	PVBOXVBVASAVEDSTATECBDATA pData = (PVBOXVBVASAVEDSTATECBDATA)pvContext;
1503	Assert(iDisplay < RT_ELEMENTS(pData->ab2DOn));
1504	if (pData->ab2DOn[iDisplay])
1505	{
1506	return true;
1507	}
1508
1509	return false;
1510	}
1511
1512	static DECLCALLBACK(bool)
1513	vboxVBVALoadStatePerformPostCb(PVGASTATE pVGAState, VBOXVHWACMD pCmd, uint32_t iDisplay, int rc, void pvContext)
1514	{
1515	RT_NOREF(pVGAState, pCmd);
1516	PVBOXVBVASAVEDSTATECBDATA pData = (PVBOXVBVASAVEDSTATECBDATA)pvContext;
1517	if (RT_FAILURE(pData->rc))
1518	return false;
1519	if (RT_FAILURE(rc))
1520	{
1521	pData->rc = rc;
1522	return false;
1523	}
1524
1525	Assert(iDisplay < RT_ELEMENTS(pData->ab2DOn));
1526	if (iDisplay >= RT_ELEMENTS(pData->ab2DOn))
1527	{
1528	pData->rc = VERR_INVALID_PARAMETER;
1529	return false;
1530	}
1531
1532	Assert(RT_SUCCESS(pCmd->rc) \|\| pCmd->rc == VERR_NOT_IMPLEMENTED);
1533	if (pCmd->rc == VERR_NOT_IMPLEMENTED)
1534	{
1535	pData->rc = SSMR3SkipToEndOfUnit(pData->pSSM);
1536	AssertRC(pData->rc);
1537	return false;
1538	}
1539	if (RT_FAILURE(pCmd->rc))
1540	{
1541	pData->rc = pCmd->rc;
1542	return false;
1543	}
1544
1545	return true;
1546	}
1547
1548	static DECLCALLBACK(bool)
1549	vboxVBVALoadStatePerformPreCb(PVGASTATE pVGAState, VBOXVHWACMD pCmd, uint32_t iDisplay, void pvContext)
1550	{
1551	RT_NOREF(pVGAState, pCmd);
1552	PVBOXVBVASAVEDSTATECBDATA pData = (PVBOXVBVASAVEDSTATECBDATA)pvContext;
1553	if (RT_FAILURE(pData->rc))
1554	return false;
1555
1556	Assert(iDisplay < RT_ELEMENTS(pData->ab2DOn));
1557	if (iDisplay >= RT_ELEMENTS(pData->ab2DOn))
1558	{
1559	pData->rc = VERR_INVALID_PARAMETER;
1560	return false;
1561	}
1562
1563	int rc;
1564	uint32_t u32;
1565	rc = SSMR3GetU32(pData->pSSM, &u32); AssertRC(rc);
1566	if (RT_FAILURE(rc))
1567	{
1568	pData->rc = rc;
1569	return false;
1570	}
1571
1572	switch (u32)
1573	{
1574	case VBOXVBVASAVEDSTATE_VHWAAVAILABLE_MAGIC:
1575	pData->ab2DOn[iDisplay] = true;
1576	return true;
1577	case VBOXVBVASAVEDSTATE_VHWAUNAVAILABLE_MAGIC:
1578	pData->ab2DOn[iDisplay] = false;
1579	return false;
1580	default:
1581	pData->rc = VERR_INVALID_STATE;
1582	return false;
1583	}
1584	}
1585	#endif /* #ifdef VBOX_WITH_VIDEOHWACCEL */
1586
1587	int vboxVBVASaveDevStateExec (PVGASTATE pVGAState, PSSMHANDLE pSSM)
1588	{
1589	PHGSMIINSTANCE pIns = pVGAState->pHGSMI;
1590	int rc = HGSMIHostSaveStateExec (pIns, pSSM);
1591	if (RT_SUCCESS(rc))
1592	{
1593	VGA_SAVED_STATE_PUT_MARKER(pSSM, 2);
1594
1595	/* Save VBVACONTEXT. */
1596	VBVACONTEXT pCtx = (VBVACONTEXT )HGSMIContext (pIns);
1597
1598	if (!pCtx)
1599	{
1600	AssertFailed();
1601
1602	/* Still write a valid value to the SSM. */
1603	rc = SSMR3PutU32 (pSSM, 0);
1604	AssertRCReturn(rc, rc);
1605	}
1606	else
1607	{
1608	#ifdef DEBUG_sunlover
1609	dumpctx(pCtx);
1610	#endif
1611
1612	rc = SSMR3PutU32 (pSSM, pCtx->cViews);
1613	AssertRCReturn(rc, rc);
1614
1615	uint32_t iView;
1616	for (iView = 0; iView < pCtx->cViews; iView++)
1617	{
1618	VBVAVIEW *pView = &pCtx->aViews[iView];
1619
1620	rc = SSMR3PutU32 (pSSM, pView->view.u32ViewIndex);
1621	AssertRCReturn(rc, rc);
1622	rc = SSMR3PutU32 (pSSM, pView->view.u32ViewOffset);
1623	AssertRCReturn(rc, rc);
1624	rc = SSMR3PutU32 (pSSM, pView->view.u32ViewSize);
1625	AssertRCReturn(rc, rc);
1626	rc = SSMR3PutU32 (pSSM, pView->view.u32MaxScreenSize);
1627	AssertRCReturn(rc, rc);
1628
1629	rc = SSMR3PutU32 (pSSM, pView->screen.u32ViewIndex);
1630	AssertRCReturn(rc, rc);
1631	rc = SSMR3PutS32 (pSSM, pView->screen.i32OriginX);
1632	AssertRCReturn(rc, rc);
1633	rc = SSMR3PutS32 (pSSM, pView->screen.i32OriginY);
1634	AssertRCReturn(rc, rc);
1635	rc = SSMR3PutU32 (pSSM, pView->screen.u32StartOffset);
1636	AssertRCReturn(rc, rc);
1637	rc = SSMR3PutU32 (pSSM, pView->screen.u32LineSize);
1638	AssertRCReturn(rc, rc);
1639	rc = SSMR3PutU32 (pSSM, pView->screen.u32Width);
1640	AssertRCReturn(rc, rc);
1641	rc = SSMR3PutU32 (pSSM, pView->screen.u32Height);
1642	AssertRCReturn(rc, rc);
1643	rc = SSMR3PutU16 (pSSM, pView->screen.u16BitsPerPixel);
1644	AssertRCReturn(rc, rc);
1645	rc = SSMR3PutU16 (pSSM, pView->screen.u16Flags);
1646	AssertRCReturn(rc, rc);
1647
1648	rc = SSMR3PutU32 (pSSM, pView->vbva.guest.pVBVA? pView->vbva.u32VBVAOffset: HGSMIOFFSET_VOID);
1649	AssertRCReturn(rc, rc);
1650
1651	rc = SSMR3PutU32 (pSSM, pView->vbva.partialRecord.cb);
1652	AssertRCReturn(rc, rc);
1653
1654	if (pView->vbva.partialRecord.cb > 0)
1655	{
1656	rc = SSMR3PutMem (pSSM, pView->vbva.partialRecord.pu8, pView->vbva.partialRecord.cb);
1657	AssertRCReturn(rc, rc);
1658	}
1659	}
1660
1661	/* Save mouse pointer shape information. */
1662	rc = SSMR3PutBool (pSSM, pCtx->mouseShapeInfo.fSet);
1663	AssertRCReturn(rc, rc);
1664	rc = SSMR3PutBool (pSSM, pCtx->mouseShapeInfo.fVisible);
1665	AssertRCReturn(rc, rc);
1666	rc = SSMR3PutBool (pSSM, pCtx->mouseShapeInfo.fAlpha);
1667	AssertRCReturn(rc, rc);
1668	rc = SSMR3PutU32 (pSSM, pCtx->mouseShapeInfo.u32HotX);
1669	AssertRCReturn(rc, rc);
1670	rc = SSMR3PutU32 (pSSM, pCtx->mouseShapeInfo.u32HotY);
1671	AssertRCReturn(rc, rc);
1672	rc = SSMR3PutU32 (pSSM, pCtx->mouseShapeInfo.u32Width);
1673	AssertRCReturn(rc, rc);
1674	rc = SSMR3PutU32 (pSSM, pCtx->mouseShapeInfo.u32Height);
1675	AssertRCReturn(rc, rc);
1676	rc = SSMR3PutU32 (pSSM, pCtx->mouseShapeInfo.cbShape);
1677	AssertRCReturn(rc, rc);
1678	if (pCtx->mouseShapeInfo.cbShape)
1679	{
1680	rc = SSMR3PutMem (pSSM, pCtx->mouseShapeInfo.pu8Shape, pCtx->mouseShapeInfo.cbShape);
1681	AssertRCReturn(rc, rc);
1682	}
1683
1684	#ifdef VBOX_WITH_WDDM
1685	/* Size of some additional data. For future extensions. */
1686	rc = SSMR3PutU32 (pSSM, 4);
1687	AssertRCReturn(rc, rc);
1688	rc = SSMR3PutU32 (pSSM, pVGAState->fGuestCaps);
1689	AssertRCReturn(rc, rc);
1690	#else
1691	/* Size of some additional data. For future extensions. */
1692	rc = SSMR3PutU32 (pSSM, 0);
1693	AssertRCReturn(rc, rc);
1694	#endif
1695	rc = SSMR3PutU32 (pSSM, RT_ELEMENTS(pCtx->aModeHints));
1696	AssertRCReturn(rc, rc);
1697	rc = SSMR3PutU32 (pSSM, sizeof(VBVAMODEHINT));
1698	AssertRCReturn(rc, rc);
1699	for (unsigned i = 0; i < RT_ELEMENTS(pCtx->aModeHints); ++i)
1700	{
1701	rc = SSMR3PutMem (pSSM, &pCtx->aModeHints[i],
1702	sizeof(VBVAMODEHINT));
1703	AssertRCReturn(rc, rc);
1704	}
1705	}
1706	}
1707
1708	return rc;
1709	}
1710
1711	int vboxVBVASaveStateExec (PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
1712	{
1713	PVGASTATE pVGAState = PDMINS_2_DATA(pDevIns, PVGASTATE);
1714	int rc;
1715	#ifdef VBOX_WITH_VIDEOHWACCEL
1716	VBOXVBVASAVEDSTATECBDATA VhwaData = {0};
1717	VhwaData.pSSM = pSSM;
1718	uint32_t cbCmd = sizeof (VBOXVHWACMD_HH_SAVESTATE_SAVEPERFORM); /* maximum cmd size */
1719	VBOXVHWACMD *pCmd = vbvaVHWAHHCommandCreate(VBOXVHWACMD_TYPE_HH_SAVESTATE_SAVEBEGIN, 0, cbCmd);
1720	Assert(pCmd);
1721	if(pCmd)
1722	{
1723	vbvaVHWAHHPost (pVGAState, pCmd, NULL, vboxVBVASaveStateBeginPostCb, &VhwaData);
1724	rc = VhwaData.rc;
1725	AssertRC(rc);
1726	if (RT_SUCCESS(rc))
1727	{
1728	#endif
1729	rc = vboxVBVASaveDevStateExec (pVGAState, pSSM);
1730	AssertRC(rc);
1731	#ifdef VBOX_WITH_VIDEOHWACCEL
1732	if (RT_SUCCESS(rc))
1733	{
1734	vbvaVHWAHHCommandReinit(pCmd, VBOXVHWACMD_TYPE_HH_SAVESTATE_SAVEPERFORM, 0);
1735	VBOXVHWACMD_HH_SAVESTATE_SAVEPERFORM *pSave = VBOXVHWACMD_BODY_HOST_HEAP(pCmd, VBOXVHWACMD_HH_SAVESTATE_SAVEPERFORM);
1736	pSave->pSSM = pSSM;
1737	vbvaVHWAHHPost (pVGAState, pCmd, vboxVBVASaveStatePerformPreCb, NULL, &VhwaData);
1738	rc = VhwaData.rc;
1739	AssertRC(rc);
1740	if (RT_SUCCESS(rc))
1741	{
1742	rc = vbvaVHWACommandSavePending(pVGAState, pSSM);
1743	AssertRCReturn(rc, rc);
1744
1745	vbvaVHWAHHCommandReinit(pCmd, VBOXVHWACMD_TYPE_HH_SAVESTATE_SAVEEND, 0);
1746	vbvaVHWAHHPost (pVGAState, pCmd, vboxVBVASaveStateEndPreCb, NULL, &VhwaData);
1747	rc = VhwaData.rc;
1748	AssertRC(rc);
1749	}
1750	}
1751	}
1752
1753	vbvaVHWAHHCommandRelease(pCmd);
1754	}
1755	else
1756	rc = VERR_OUT_OF_RESOURCES;
1757	#else
1758	if (RT_SUCCESS(rc))
1759	{
1760	for (uint32_t i = 0; i < pVGAState->cMonitors; ++i)
1761	{
1762	rc = SSMR3PutU32 (pSSM, VBOXVBVASAVEDSTATE_VHWAUNAVAILABLE_MAGIC);
1763	AssertRCReturn(rc, rc);
1764	}
1765	}
1766
1767	/* no pending commands */
1768	SSMR3PutU32(pSSM, 0);
1769	#endif
1770	return rc;
1771	}
1772
1773	int vboxVBVALoadStateExec (PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion)
1774	{
1775	if (uVersion < VGA_SAVEDSTATE_VERSION_HGSMI)
1776	{
1777	/* Nothing was saved. */
1778	return VINF_SUCCESS;
1779	}
1780
1781	PVGASTATE pVGAState = PDMINS_2_DATA(pDevIns, PVGASTATE);
1782	PHGSMIINSTANCE pIns = pVGAState->pHGSMI;
1783	int rc = HGSMIHostLoadStateExec (pIns, pSSM, uVersion);
1784	if (RT_SUCCESS(rc))
1785	{
1786	VGA_SAVED_STATE_GET_MARKER_RETURN_ON_MISMATCH(pSSM, uVersion, 2);
1787
1788	/* Load VBVACONTEXT. */
1789	VBVACONTEXT pCtx = (VBVACONTEXT )HGSMIContext (pIns);
1790
1791	if (!pCtx)
1792	{
1793	/* This should not happen. */
1794	AssertFailed();
1795	rc = VERR_INVALID_PARAMETER;
1796	}
1797	else
1798	{
1799	uint32_t cViews = 0;
1800	rc = SSMR3GetU32 (pSSM, &cViews);
1801	AssertRCReturn(rc, rc);
1802
1803	uint32_t iView;
1804	for (iView = 0; iView < cViews; iView++)
1805	{
1806	VBVAVIEW *pView = &pCtx->aViews[iView];
1807
1808	rc = SSMR3GetU32 (pSSM, &pView->view.u32ViewIndex);
1809	AssertRCReturn(rc, rc);
1810	rc = SSMR3GetU32 (pSSM, &pView->view.u32ViewOffset);
1811	AssertRCReturn(rc, rc);
1812	rc = SSMR3GetU32 (pSSM, &pView->view.u32ViewSize);
1813	AssertRCReturn(rc, rc);
1814	rc = SSMR3GetU32 (pSSM, &pView->view.u32MaxScreenSize);
1815	AssertRCReturn(rc, rc);
1816
1817	rc = SSMR3GetU32 (pSSM, &pView->screen.u32ViewIndex);
1818	AssertRCReturn(rc, rc);
1819	rc = SSMR3GetS32 (pSSM, &pView->screen.i32OriginX);
1820	AssertRCReturn(rc, rc);
1821	rc = SSMR3GetS32 (pSSM, &pView->screen.i32OriginY);
1822	AssertRCReturn(rc, rc);
1823	rc = SSMR3GetU32 (pSSM, &pView->screen.u32StartOffset);
1824	AssertRCReturn(rc, rc);
1825	rc = SSMR3GetU32 (pSSM, &pView->screen.u32LineSize);
1826	AssertRCReturn(rc, rc);
1827	rc = SSMR3GetU32 (pSSM, &pView->screen.u32Width);
1828	AssertRCReturn(rc, rc);
1829	rc = SSMR3GetU32 (pSSM, &pView->screen.u32Height);
1830	AssertRCReturn(rc, rc);
1831	rc = SSMR3GetU16 (pSSM, &pView->screen.u16BitsPerPixel);
1832	AssertRCReturn(rc, rc);
1833	rc = SSMR3GetU16 (pSSM, &pView->screen.u16Flags);
1834	AssertRCReturn(rc, rc);
1835
1836	rc = SSMR3GetU32 (pSSM, &pView->vbva.u32VBVAOffset);
1837	AssertRCReturn(rc, rc);
1838
1839	rc = SSMR3GetU32 (pSSM, &pView->vbva.partialRecord.cb);
1840	AssertRCReturn(rc, rc);
1841
1842	if (pView->vbva.partialRecord.cb == 0)
1843	{
1844	pView->vbva.partialRecord.pu8 = NULL;
1845	}
1846	else
1847	{
1848	Assert(pView->vbva.partialRecord.pu8 == NULL); /* Should be it. */
1849
1850	uint8_t pu8 = (uint8_t )RTMemAlloc(pView->vbva.partialRecord.cb);
1851
1852	if (!pu8)
1853	{
1854	return VERR_NO_MEMORY;
1855	}
1856
1857	pView->vbva.partialRecord.pu8 = pu8;
1858
1859	rc = SSMR3GetMem (pSSM, pView->vbva.partialRecord.pu8, pView->vbva.partialRecord.cb);
1860	AssertRCReturn(rc, rc);
1861	}
1862
1863	if (pView->vbva.u32VBVAOffset == HGSMIOFFSET_VOID)
1864	{
1865	pView->vbva.guest.pVBVA = NULL;
1866	}
1867	else
1868	{
1869	pView->vbva.guest.pVBVA = (VBVABUFFER *)HGSMIOffsetToPointerHost(pIns, pView->vbva.u32VBVAOffset);
1870	}
1871	}
1872
1873	if (uVersion > VGA_SAVEDSTATE_VERSION_WITH_CONFIG)
1874	{
1875	/* Read mouse pointer shape information. */
1876	rc = SSMR3GetBool (pSSM, &pCtx->mouseShapeInfo.fSet);
1877	AssertRCReturn(rc, rc);
1878	rc = SSMR3GetBool (pSSM, &pCtx->mouseShapeInfo.fVisible);
1879	AssertRCReturn(rc, rc);
1880	rc = SSMR3GetBool (pSSM, &pCtx->mouseShapeInfo.fAlpha);
1881	AssertRCReturn(rc, rc);
1882	rc = SSMR3GetU32 (pSSM, &pCtx->mouseShapeInfo.u32HotX);
1883	AssertRCReturn(rc, rc);
1884	rc = SSMR3GetU32 (pSSM, &pCtx->mouseShapeInfo.u32HotY);
1885	AssertRCReturn(rc, rc);
1886	rc = SSMR3GetU32 (pSSM, &pCtx->mouseShapeInfo.u32Width);
1887	AssertRCReturn(rc, rc);
1888	rc = SSMR3GetU32 (pSSM, &pCtx->mouseShapeInfo.u32Height);
1889	AssertRCReturn(rc, rc);
1890	rc = SSMR3GetU32 (pSSM, &pCtx->mouseShapeInfo.cbShape);
1891	AssertRCReturn(rc, rc);
1892	if (pCtx->mouseShapeInfo.cbShape)
1893	{
1894	pCtx->mouseShapeInfo.pu8Shape = (uint8_t *)RTMemAlloc(pCtx->mouseShapeInfo.cbShape);
1895	if (pCtx->mouseShapeInfo.pu8Shape == NULL)
1896	{
1897	return VERR_NO_MEMORY;
1898	}
1899	pCtx->mouseShapeInfo.cbAllocated = pCtx->mouseShapeInfo.cbShape;
1900	rc = SSMR3GetMem (pSSM, pCtx->mouseShapeInfo.pu8Shape, pCtx->mouseShapeInfo.cbShape);
1901	AssertRCReturn(rc, rc);
1902	}
1903	else
1904	{
1905	pCtx->mouseShapeInfo.pu8Shape = NULL;
1906	}
1907
1908	/* Size of some additional data. For future extensions. */
1909	uint32_t cbExtra = 0;
1910	rc = SSMR3GetU32 (pSSM, &cbExtra);
1911	AssertRCReturn(rc, rc);
1912	#ifdef VBOX_WITH_WDDM
1913	if (cbExtra >= 4)
1914	{
1915	rc = SSMR3GetU32 (pSSM, &pVGAState->fGuestCaps);
1916	AssertRCReturn(rc, rc);
1917	pVGAState->pDrv->pfnVBVAGuestCapabilityUpdate(pVGAState->pDrv, pVGAState->fGuestCaps);
1918	cbExtra -= 4;
1919	}
1920	#endif
1921	if (cbExtra > 0)
1922	{
1923	rc = SSMR3Skip(pSSM, cbExtra);
1924	AssertRCReturn(rc, rc);
1925	}
1926
1927	if (uVersion >= VGA_SAVEDSTATE_VERSION_MODE_HINTS)
1928	{
1929	uint32_t cModeHints, cbModeHints;
1930	rc = SSMR3GetU32 (pSSM, &cModeHints);
1931	AssertRCReturn(rc, rc);
1932	rc = SSMR3GetU32 (pSSM, &cbModeHints);
1933	AssertRCReturn(rc, rc);
1934	memset(&pCtx->aModeHints, ~0, sizeof(pCtx->aModeHints));
1935	unsigned iHint;
1936	for (iHint = 0; iHint < cModeHints; ++iHint)
1937	{
1938	if ( cbModeHints <= sizeof(VBVAMODEHINT)
1939	&& iHint < RT_ELEMENTS(pCtx->aModeHints))
1940	rc = SSMR3GetMem(pSSM, &pCtx->aModeHints[iHint],
1941	cbModeHints);
1942	else
1943	rc = SSMR3Skip(pSSM, cbModeHints);
1944	AssertRCReturn(rc, rc);
1945	}
1946	}
1947	}
1948
1949	pCtx->cViews = iView;
1950	LogFlowFunc(("%d views loaded\n", pCtx->cViews));
1951
1952	if (uVersion > VGA_SAVEDSTATE_VERSION_WDDM)
1953	{
1954	bool fLoadCommands;
1955
1956	if (uVersion < VGA_SAVEDSTATE_VERSION_FIXED_PENDVHWA)
1957	{
1958	const char *pcszOsArch = SSMR3HandleHostOSAndArch(pSSM);
1959	Assert(pcszOsArch);
1960	fLoadCommands = !pcszOsArch \|\| RTStrNCmp(pcszOsArch, RT_STR_TUPLE("solaris"));
1961	}
1962	else
1963	fLoadCommands = true;
1964
1965	#ifdef VBOX_WITH_VIDEOHWACCEL
1966	uint32_t cbCmd = sizeof (VBOXVHWACMD_HH_SAVESTATE_LOADPERFORM); /* maximum cmd size */
1967	VBOXVHWACMD *pCmd = vbvaVHWAHHCommandCreate(VBOXVHWACMD_TYPE_HH_SAVESTATE_LOADPERFORM, 0, cbCmd);
1968	Assert(pCmd);
1969	if(pCmd)
1970	{
1971	VBOXVBVASAVEDSTATECBDATA VhwaData = {0};
1972	VhwaData.pSSM = pSSM;
1973	VBOXVHWACMD_HH_SAVESTATE_LOADPERFORM *pLoad = VBOXVHWACMD_BODY_HOST_HEAP(pCmd, VBOXVHWACMD_HH_SAVESTATE_LOADPERFORM);
1974	pLoad->pSSM = pSSM;
1975	vbvaVHWAHHPost (pVGAState, pCmd, vboxVBVALoadStatePerformPreCb, vboxVBVALoadStatePerformPostCb, &VhwaData);
1976	rc = VhwaData.rc;
1977	vbvaVHWAHHCommandRelease(pCmd);
1978	AssertRCReturn(rc, rc);
1979
1980	if (fLoadCommands)
1981	{
1982	rc = vbvaVHWACommandLoadPending(pVGAState, pSSM, uVersion);
1983	AssertRCReturn(rc, rc);
1984	}
1985	}
1986	else
1987	{
1988	rc = VERR_OUT_OF_RESOURCES;
1989	}
1990	#else
1991	uint32_t u32;
1992
1993	for (uint32_t i = 0; i < pVGAState->cMonitors; ++i)
1994	{
1995	rc = SSMR3GetU32(pSSM, &u32);
1996	AssertRCReturn(rc, rc);
1997
1998	if (u32 != VBOXVBVASAVEDSTATE_VHWAUNAVAILABLE_MAGIC)
1999	{
2000	LogRel(("VBVA: 2D data while 2D is not supported\n"));
2001	return VERR_NOT_SUPPORTED;
2002	}
2003	}
2004
2005	if (fLoadCommands)
2006	{
2007	rc = SSMR3GetU32(pSSM, &u32);
2008	AssertRCReturn(rc, rc);
2009
2010	if (u32)
2011	{
2012	LogRel(("VBVA: 2D pending command while 2D is not supported\n"));
2013	return VERR_NOT_SUPPORTED;
2014	}
2015	}
2016	#endif
2017	}
2018
2019	#ifdef DEBUG_sunlover
2020	dumpctx(pCtx);
2021	#endif
2022	}
2023	}
2024
2025	return rc;
2026	}
2027
2028	int vboxVBVALoadStateDone(PPDMDEVINS pDevIns)
2029	{
2030	PVGASTATE pVGAState = PDMINS_2_DATA(pDevIns, PVGASTATE);
2031	VBVACONTEXT pCtx = (VBVACONTEXT )HGSMIContext(pVGAState->pHGSMI);
2032	if (pCtx)
2033	{
2034	uint32_t iView;
2035	for (iView = 0; iView < pCtx->cViews; iView++)
2036	{
2037	VBVAVIEW *pView = &pCtx->aViews[iView];
2038	if (pView->vbva.guest.pVBVA)
2039	{
2040	#ifdef VBOX_WITH_CRHGSMI
2041	Assert(!vboxCmdVBVAIsEnabled(pVGAState));
2042	#endif
2043	int rc = vbvaEnable(iView, pVGAState, pCtx, pView->vbva.guest.pVBVA, pView->vbva.u32VBVAOffset, true /* fRestored */);
2044	if (RT_SUCCESS(rc))
2045	vbvaResize(pVGAState, pView, &pView->screen, false);
2046	else
2047	LogRel(("VBVA: can not restore: %Rrc\n", rc));
2048	}
2049	}
2050
2051	if (pCtx->mouseShapeInfo.fSet)
2052	vbvaUpdateMousePointerShape(pVGAState, &pCtx->mouseShapeInfo, true);
2053	}
2054
2055	return VINF_SUCCESS;
2056	}
2057
2058	void VBVARaiseIrq (PVGASTATE pVGAState, uint32_t fFlags)
2059	{
2060	PPDMDEVINS pDevIns = pVGAState->pDevInsR3;
2061
2062	PDMCritSectEnter(&pVGAState->CritSectIRQ, VERR_SEM_BUSY);
2063
2064	const uint32_t fu32CurrentGuestFlags = HGSMIGetHostGuestFlags(pVGAState->pHGSMI);
2065	if ((fu32CurrentGuestFlags & HGSMIHOSTFLAGS_IRQ) == 0)
2066	{
2067	/* No IRQ set yet. */
2068	Assert(pVGAState->fu32PendingGuestFlags == 0);
2069
2070	HGSMISetHostGuestFlags(pVGAState->pHGSMI, HGSMIHOSTFLAGS_IRQ \| fFlags);
2071
2072	/* If VM is not running, the IRQ will be set in VBVAOnResume. */
2073	const VMSTATE enmVMState = PDMDevHlpVMState(pDevIns);
2074	if ( enmVMState == VMSTATE_RUNNING
2075	\|\| enmVMState == VMSTATE_RUNNING_LS)
2076	PDMDevHlpPCISetIrqNoWait(pDevIns, 0, PDM_IRQ_LEVEL_HIGH);
2077	}
2078	else
2079	{
2080	/* IRQ already set, remember the new flags. */
2081	pVGAState->fu32PendingGuestFlags \|= HGSMIHOSTFLAGS_IRQ \| fFlags;
2082	}
2083
2084	PDMCritSectLeave(&pVGAState->CritSectIRQ);
2085	}
2086
2087	void VBVAOnResume(PVGASTATE pThis)
2088	{
2089	PPDMDEVINS pDevIns = pThis->pDevInsR3;
2090
2091	PDMCritSectEnter(&pThis->CritSectIRQ, VERR_SEM_BUSY);
2092
2093	if (HGSMIGetHostGuestFlags(pThis->pHGSMI) & HGSMIHOSTFLAGS_IRQ)
2094	PDMDevHlpPCISetIrqNoWait(pDevIns, 0, PDM_IRQ_LEVEL_HIGH);
2095
2096	PDMCritSectLeave(&pThis->CritSectIRQ);
2097	}
2098
2099	static int vbvaHandleQueryConf32(PVGASTATE pVGAState, VBVACONF32 RT_UNTRUSTED_VOLATILE_GUEST *pConf32)
2100	{
2101	uint32_t const idxQuery = pConf32->u32Index;
2102	RT_UNTRUSTED_NONVOLATILE_COPY_FENCE();
2103	LogFlowFunc(("VBVA_QUERY_CONF32: u32Index %d, u32Value 0x%x\n", idxQuery, pConf32->u32Value));
2104
2105	VBVACONTEXT pCtx = (VBVACONTEXT )HGSMIContext(pVGAState->pHGSMI);
2106	uint32_t uValue;
2107	if (idxQuery == VBOX_VBVA_CONF32_MONITOR_COUNT)
2108	uValue = pCtx->cViews;
2109	else if (idxQuery == VBOX_VBVA_CONF32_HOST_HEAP_SIZE)
2110	uValue = _64K; /** @todo a value calculated from the vram size */
2111	else if ( idxQuery == VBOX_VBVA_CONF32_MODE_HINT_REPORTING
2112	\|\| idxQuery == VBOX_VBVA_CONF32_GUEST_CURSOR_REPORTING)
2113	uValue = VINF_SUCCESS;
2114	else if (idxQuery == VBOX_VBVA_CONF32_CURSOR_CAPABILITIES)
2115	uValue = pVGAState->fHostCursorCapabilities;
2116	else if (idxQuery == VBOX_VBVA_CONF32_SCREEN_FLAGS)
2117	uValue = VBVA_SCREEN_F_ACTIVE
2118	\| VBVA_SCREEN_F_DISABLED
2119	\| VBVA_SCREEN_F_BLANK
2120	\| VBVA_SCREEN_F_BLANK2;
2121	else if (idxQuery == VBOX_VBVA_CONF32_MAX_RECORD_SIZE)
2122	uValue = VBVA_MAX_RECORD_SIZE;
2123	else
2124	ASSERT_GUEST_MSG_FAILED_RETURN(("Invalid index %#x\n", idxQuery), VERR_INVALID_PARAMETER);
2125
2126	pConf32->u32Value = uValue;
2127	return VINF_SUCCESS;
2128	}
2129
2130	static int vbvaHandleSetConf32(VBVACONF32 RT_UNTRUSTED_VOLATILE_GUEST *pConf32)
2131	{
2132	uint32_t const idxQuery = pConf32->u32Index;
2133	uint32_t const uValue = pConf32->u32Value;
2134	RT_UNTRUSTED_NONVOLATILE_COPY_FENCE();
2135	LogFlowFunc(("VBVA_SET_CONF32: u32Index %d, u32Value 0x%x\n", idxQuery, uValue));
2136
2137	if (idxQuery == VBOX_VBVA_CONF32_MONITOR_COUNT)
2138	{ /* do nothing. this is a const. */ }
2139	else if (idxQuery == VBOX_VBVA_CONF32_HOST_HEAP_SIZE)
2140	{ /* do nothing. this is a const. */ }
2141	else
2142	ASSERT_GUEST_MSG_FAILED_RETURN(("Invalid index %#x (value=%u)\n", idxQuery, uValue), VERR_INVALID_PARAMETER);
2143
2144	RT_NOREF_PV(uValue);
2145	return VINF_SUCCESS;
2146	}
2147
2148	static int vbvaHandleInfoHeap(PVGASTATE pVGAState, const VBVAINFOHEAP RT_UNTRUSTED_VOLATILE_GUEST *pInfoHeap)
2149	{
2150	uint32_t const offHeap = pInfoHeap->u32HeapOffset;
2151	uint32_t const cbHeap = pInfoHeap->u32HeapSize;
2152	RT_UNTRUSTED_NONVOLATILE_COPY_FENCE();
2153	LogFlowFunc(("VBVA_INFO_HEAP: offset 0x%x, size 0x%x\n", offHeap, cbHeap));
2154
2155	return HGSMIHostHeapSetup(pVGAState->pHGSMI, offHeap, cbHeap);
2156	}
2157
2158	int VBVAInfoView(PVGASTATE pVGAState, const VBVAINFOVIEW RT_UNTRUSTED_VOLATILE_GUEST *pView)
2159	{
2160	VBVAINFOVIEW view;
2161	RT_COPY_VOLATILE(view, *pView);
2162	RT_UNTRUSTED_NONVOLATILE_COPY_FENCE();
2163
2164	LogFlowFunc(("VBVA_INFO_VIEW: u32ViewIndex %d, u32ViewOffset 0x%x, u32ViewSize 0x%x, u32MaxScreenSize 0x%x\n",
2165	view.u32ViewIndex, view.u32ViewOffset, view.u32ViewSize, view.u32MaxScreenSize));
2166
2167	VBVACONTEXT pCtx = (VBVACONTEXT )HGSMIContext(pVGAState->pHGSMI);
2168	ASSERT_GUEST_LOGREL_MSG_RETURN( view.u32ViewIndex < pCtx->cViews
2169	&& view.u32ViewOffset <= pVGAState->vram_size
2170	&& view.u32ViewSize <= pVGAState->vram_size
2171	&& view.u32ViewOffset <= pVGAState->vram_size - view.u32ViewSize
2172	&& view.u32MaxScreenSize <= view.u32ViewSize,
2173	("index %d(%d), offset 0x%x, size 0x%x, max 0x%x, vram size 0x%x\n",
2174	view.u32ViewIndex, pCtx->cViews, view.u32ViewOffset, view.u32ViewSize,
2175	view.u32MaxScreenSize, pVGAState->vram_size),
2176	VERR_INVALID_PARAMETER);
2177	RT_UNTRUSTED_VALIDATED_FENCE();
2178
2179	pCtx->aViews[view.u32ViewIndex].view = view;
2180	return VINF_SUCCESS;
2181	}
2182
2183	int VBVAInfoScreen(PVGASTATE pVGAState, const VBVAINFOSCREEN RT_UNTRUSTED_VOLATILE_GUEST *pScreen)
2184	{
2185	/*
2186	* Copy input into non-volatile buffer.
2187	*/
2188	VBVAINFOSCREEN screen;
2189	RT_COPY_VOLATILE(screen, *pScreen);
2190	RT_UNTRUSTED_NONVOLATILE_COPY_FENCE();
2191	LogRel(("VBVA: InfoScreen: [%d] @%d,%d %dx%d, line 0x%x, BPP %d, flags 0x%x\n",
2192	screen.u32ViewIndex, screen.i32OriginX, screen.i32OriginY,
2193	screen.u32Width, screen.u32Height,
2194	screen.u32LineSize, screen.u16BitsPerPixel, screen.u16Flags));
2195
2196	/*
2197	* Validate input.
2198	*/
2199	/* Allow screen.u16BitsPerPixel == 0 because legacy guest code used it for screen blanking. */
2200	VBVACONTEXT pCtx = (VBVACONTEXT )HGSMIContext(pVGAState->pHGSMI);
2201	ASSERT_GUEST_LOGREL_MSG_RETURN(screen.u32ViewIndex < pCtx->cViews,
2202	("Screen index %#x is out of bound (cViews=%#x)\n", screen.u32ViewIndex, pCtx->cViews),
2203	VERR_INVALID_PARAMETER);
2204	ASSERT_GUEST_LOGREL_MSG_RETURN( screen.u16BitsPerPixel <= 32
2205	&& screen.u32Width <= UINT16_MAX
2206	&& screen.u32Height <= UINT16_MAX
2207	&& screen.u32LineSize <= UINT16_MAX * UINT32_C(4),
2208	("One or more values out of range: u16BitsPerPixel=%#x u32Width=%#x u32Height=%#x u32LineSize=%#x\n",
2209	screen.u16BitsPerPixel, screen.u32Width, screen.u32Height, screen.u32LineSize),
2210	VERR_INVALID_PARAMETER);
2211	RT_UNTRUSTED_VALIDATED_FENCE();
2212
2213	const VBVAINFOVIEW *pView = &pCtx->aViews[screen.u32ViewIndex].view;
2214	const uint32_t cbPerPixel = (screen.u16BitsPerPixel + 7) / 8;
2215	ASSERT_GUEST_LOGREL_MSG_RETURN(screen.u32Width <= screen.u32LineSize / (cbPerPixel ? cbPerPixel : 1),
2216	("u32Width=%#x u32LineSize=%3x cbPerPixel=%#x\n",
2217	screen.u32Width, screen.u32LineSize, cbPerPixel),
2218	VERR_INVALID_PARAMETER);
2219
2220	const uint64_t u64ScreenSize = (uint64_t)screen.u32LineSize * screen.u32Height;
2221
2222	ASSERT_GUEST_LOGREL_MSG_RETURN( screen.u32StartOffset <= pView->u32ViewSize
2223	&& u64ScreenSize <= pView->u32MaxScreenSize
2224	&& screen.u32StartOffset <= pView->u32ViewSize - (uint32_t)u64ScreenSize,
2225	("u32StartOffset=%#x u32ViewSize=%#x u64ScreenSize=%#RX64 u32MaxScreenSize=%#x\n",
2226	screen.u32StartOffset, pView->u32ViewSize, u64ScreenSize, pView->u32MaxScreenSize),
2227	VERR_INVALID_PARAMETER);
2228	RT_UNTRUSTED_VALIDATED_FENCE();
2229
2230	/*
2231	* Do the job.
2232	*/
2233	vbvaResize(pVGAState, &pCtx->aViews[screen.u32ViewIndex], &screen, true);
2234	return VINF_SUCCESS;
2235	}
2236
2237	int VBVAGetInfoViewAndScreen(PVGASTATE pVGAState, uint32_t u32ViewIndex, VBVAINFOVIEW pView, VBVAINFOSCREEN pScreen)
2238	{
2239	if (u32ViewIndex >= pVGAState->cMonitors)
2240	return VERR_INVALID_PARAMETER;
2241
2242	PHGSMIINSTANCE pIns = pVGAState->pHGSMI;
2243	VBVACONTEXT pCtx = (VBVACONTEXT )HGSMIContext (pIns);
2244
2245	if (pView)
2246	*pView = pCtx->aViews[u32ViewIndex].view;
2247
2248	if (pScreen)
2249	*pScreen = pCtx->aViews[u32ViewIndex].screen;
2250
2251	return VINF_SUCCESS;
2252	}
2253
2254	static int vbvaHandleEnable(PVGASTATE pVGAState, uint32_t fEnableFlags, uint32_t offEnable, uint32_t idScreen)
2255	{
2256	LogFlowFunc(("VBVA_ENABLE[%u]: fEnableFlags=0x%x offEnable=%#x\n", idScreen, fEnableFlags, offEnable));
2257	PHGSMIINSTANCE pIns = pVGAState->pHGSMI;
2258	VBVACONTEXT pCtx = (VBVACONTEXT )HGSMIContext(pIns);
2259
2260	/*
2261	* Validate input.
2262	*/
2263	ASSERT_GUEST_LOGREL_MSG_RETURN(idScreen < pCtx->cViews, ("idScreen=%#x cViews=%#x\n", idScreen, pCtx->cViews), VERR_INVALID_PARAMETER);
2264	ASSERT_GUEST_LOGREL_MSG_RETURN( (fEnableFlags & (VBVA_F_ENABLE \| VBVA_F_DISABLE)) == VBVA_F_ENABLE
2265	\|\| (fEnableFlags & (VBVA_F_ENABLE \| VBVA_F_DISABLE)) == VBVA_F_DISABLE,
2266	("fEnableFlags=%#x\n", fEnableFlags),
2267	VERR_INVALID_PARAMETER);
2268	if (fEnableFlags & VBVA_F_ENABLE)
2269	{
2270	ASSERT_GUEST_LOGREL_MSG_RETURN(offEnable < pVGAState->vram_size,
2271	("offEnable=%#x vram_size=%#x\n", offEnable, pVGAState->vram_size),
2272	VERR_INVALID_PARAMETER);
2273	if (fEnableFlags & VBVA_F_ABSOFFSET)
2274	/* Offset from VRAM start. */
2275	ASSERT_GUEST_LOGREL_MSG_RETURN( pVGAState->vram_size >= RT_UOFFSETOF(VBVABUFFER, au8Data)
2276	&& offEnable <= pVGAState->vram_size - RT_UOFFSETOF(VBVABUFFER, au8Data),
2277	("offEnable=%#x vram_size=%#x\n", offEnable, pVGAState->vram_size),
2278	VERR_INVALID_PARAMETER);
2279	else
2280	{
2281	/* Offset from the view start. We'd be using idScreen here to fence required. */
2282	RT_UNTRUSTED_VALIDATED_FENCE();
2283	const VBVAINFOVIEW *pView = &pCtx->aViews[idScreen].view;
2284	ASSERT_GUEST_LOGREL_MSG_RETURN( pVGAState->vram_size - offEnable >= pView->u32ViewOffset
2285	&& pView->u32ViewSize >= RT_UOFFSETOF(VBVABUFFER, au8Data)
2286	&& offEnable <= pView->u32ViewSize - RT_UOFFSETOF(VBVABUFFER, au8Data),
2287	("offEnable=%#x vram_size=%#x view: %#x LB %#x\n",
2288	offEnable, pVGAState->vram_size, pView->u32ViewOffset, pView->u32ViewSize),
2289	VERR_INVALID_PARAMETER);
2290	offEnable += pView->u32ViewOffset;
2291	}
2292	ASSERT_GUEST_LOGREL_MSG_RETURN(HGSMIIsOffsetValid(pIns, offEnable),
2293	("offEnable=%#x area %#x LB %#x\n",
2294	offEnable, HGSMIGetAreaOffset(pIns), HGSMIGetAreaSize(pIns)),
2295	VERR_INVALID_PARAMETER);
2296	}
2297	RT_UNTRUSTED_VALIDATED_FENCE();
2298
2299	/*
2300	* Execute.
2301	*/
2302	int rc = VINF_SUCCESS;
2303	if (fEnableFlags & VBVA_F_ENABLE)
2304	{
2305	VBVABUFFER RT_UNTRUSTED_VOLATILE_GUEST *pVBVA
2306	= (VBVABUFFER RT_UNTRUSTED_VOLATILE_GUEST *)HGSMIOffsetToPointerHost(pIns, offEnable);
2307	ASSERT_GUEST_LOGREL_RETURN(pVBVA, VERR_INVALID_PARAMETER); /* already check above, but let's be careful. */
2308
2309	/* Process any pending orders and empty the VBVA ring buffer. */
2310	vbvaFlush(pVGAState, pCtx);
2311
2312	rc = vbvaEnable(idScreen, pVGAState, pCtx, pVBVA, offEnable, false /* fRestored */);
2313	if (RT_FAILURE(rc))
2314	LogRelMax(8, ("VBVA: can not enable: %Rrc\n", rc));
2315	}
2316	else
2317	rc = vbvaDisable(idScreen, pVGAState, pCtx);
2318	return rc;
2319	}
2320
2321	static int vbvaHandleQueryModeHints(PVGASTATE pVGAState, VBVAQUERYMODEHINTS volatile *pQueryModeHints, HGSMISIZE cbBuffer)
2322	{
2323	PHGSMIINSTANCE pIns = pVGAState->pHGSMI;
2324	VBVACONTEXT pCtx = (VBVACONTEXT )HGSMIContext(pIns);
2325
2326	uint16_t const cHintsQueried = pQueryModeHints->cHintsQueried;
2327	uint16_t const cbHintStructureGuest = pQueryModeHints->cbHintStructureGuest;
2328	ASMCompilerBarrier();
2329
2330	LogRelFlowFunc(("VBVA: HandleQueryModeHints: cHintsQueried=%RU16, cbHintStructureGuest=%RU16\n",
2331	cHintsQueried, cbHintStructureGuest));
2332	if (cbBuffer < sizeof(VBVAQUERYMODEHINTS) + (uint32_t)cHintsQueried * cbHintStructureGuest)
2333	return VERR_INVALID_PARAMETER;
2334
2335	uint8_t pbHint = (uint8_t )(pQueryModeHints + 1);
2336	memset(pbHint, ~0, cbBuffer - sizeof(VBVAQUERYMODEHINTS));
2337
2338	for (unsigned iHint = 0; iHint < cHintsQueried && iHint < VBOX_VIDEO_MAX_SCREENS; ++iHint)
2339	{
2340	memcpy(pbHint, &pCtx->aModeHints[iHint], RT_MIN(cbHintStructureGuest, sizeof(VBVAMODEHINT)));
2341	pbHint += cbHintStructureGuest;
2342	Assert((uintptr_t)(pbHint - (uint8_t *)pQueryModeHints) <= cbBuffer);
2343	}
2344
2345	return VINF_SUCCESS;
2346	}
2347
2348	/*
2349	*
2350	* New VBVA uses a new interface id: #define VBE_DISPI_ID_VBOX_VIDEO 0xBE01
2351	*
2352	* VBVA uses two 32 bits IO ports to write VRAM offsets of shared memory blocks for commands.
2353	* Read Write
2354	* Host port 0x3b0 to process completed
2355	* Guest port 0x3d0 control value? to process
2356	*
2357	*/
2358
2359	static DECLCALLBACK(void) vbvaNotifyGuest (void *pvCallback)
2360	{
2361	#if defined(VBOX_WITH_HGSMI) && (defined(VBOX_WITH_VIDEOHWACCEL) \|\| defined(VBOX_WITH_VDMA) \|\| defined(VBOX_WITH_WDDM))
2362	PVGASTATE pVGAState = (PVGASTATE)pvCallback;
2363	VBVARaiseIrq (pVGAState, 0);
2364	#else
2365	NOREF(pvCallback);
2366	/* Do nothing. Later the VMMDev/VGA IRQ can be used for the notification. */
2367	#endif
2368	}
2369
2370	/**
2371	* The guest submitted a command buffer (hit VGA_PORT_HGSMI_GUEST).
2372	*
2373	* Verify the buffer size and invoke corresponding handler.
2374	*
2375	* @return VBox status code.
2376	* @param pvHandler The VBVA channel context.
2377	* @param u16ChannelInfo Command code.
2378	* @param pvBuffer HGSMI buffer with command data. Considered volatile!
2379	* @param cbBuffer Size of command data.
2380	*
2381	* @thread EMT
2382	*/
2383	static DECLCALLBACK(int) vbvaChannelHandler(void *pvHandler, uint16_t u16ChannelInfo,
2384	void RT_UNTRUSTED_VOLATILE_GUEST *pvBuffer, HGSMISIZE cbBuffer)
2385	{
2386	int rc = VINF_SUCCESS;
2387
2388	LogFlowFunc(("pvHandler %p, u16ChannelInfo %d, pvBuffer %p, cbBuffer %u\n", pvHandler, u16ChannelInfo, pvBuffer, cbBuffer));
2389
2390	PVGASTATE pVGAState = (PVGASTATE)pvHandler;
2391	PHGSMIINSTANCE pIns = pVGAState->pHGSMI;
2392	VBVACONTEXT pCtx = (VBVACONTEXT )HGSMIContext(pIns);
2393
2394	switch (u16ChannelInfo)
2395	{
2396	#ifdef VBOX_WITH_CRHGSMI
2397	case VBVA_CMDVBVA_SUBMIT:
2398	rc = vboxCmdVBVACmdSubmit(pVGAState);
2399	break;
2400
2401	case VBVA_CMDVBVA_FLUSH:
2402	rc = vboxCmdVBVACmdFlush(pVGAState);
2403	break;
2404
2405	case VBVA_CMDVBVA_CTL:
2406	if (cbBuffer >= VBoxSHGSMIBufferHeaderSize() + sizeof(VBOXCMDVBVA_CTL))
2407	{
2408	VBOXCMDVBVA_CTL RT_UNTRUSTED_VOLATILE_GUEST *pCtl
2409	= (VBOXCMDVBVA_CTL RT_UNTRUSTED_VOLATILE_GUEST )VBoxSHGSMIBufferData((VBOXSHGSMIHEADER RT_UNTRUSTED_VOLATILE_GUEST )pvBuffer);
2410	rc = vboxCmdVBVACmdCtl(pVGAState, pCtl, cbBuffer - VBoxSHGSMIBufferHeaderSize());
2411	}
2412	else
2413	rc = VERR_INVALID_PARAMETER;
2414	break;
2415	#endif /* VBOX_WITH_CRHGSMI */
2416
2417	#ifdef VBOX_WITH_VDMA
2418	case VBVA_VDMA_CMD:
2419	if (cbBuffer >= VBoxSHGSMIBufferHeaderSize() + sizeof(VBOXVDMACBUF_DR))
2420	{
2421	VBOXVDMACBUF_DR RT_UNTRUSTED_VOLATILE_GUEST *pCmd
2422	= (VBOXVDMACBUF_DR RT_UNTRUSTED_VOLATILE_GUEST )VBoxSHGSMIBufferData((VBOXSHGSMIHEADER RT_UNTRUSTED_VOLATILE_GUEST )pvBuffer);
2423	vboxVDMACommand(pVGAState->pVdma, pCmd, cbBuffer - VBoxSHGSMIBufferHeaderSize());
2424	rc = VINF_SUCCESS;
2425	}
2426	else
2427	rc = VERR_INVALID_PARAMETER;
2428	break;
2429
2430	case VBVA_VDMA_CTL:
2431	if (cbBuffer >= VBoxSHGSMIBufferHeaderSize() + sizeof(VBOXVDMA_CTL))
2432	{
2433	VBOXVDMA_CTL RT_UNTRUSTED_VOLATILE_GUEST *pCmd
2434	= (VBOXVDMA_CTL RT_UNTRUSTED_VOLATILE_GUEST )VBoxSHGSMIBufferData((VBOXSHGSMIHEADER RT_UNTRUSTED_VOLATILE_GUEST )pvBuffer);
2435	vboxVDMAControl(pVGAState->pVdma, pCmd, cbBuffer - VBoxSHGSMIBufferHeaderSize());
2436	}
2437	else
2438	rc = VERR_INVALID_PARAMETER;
2439	break;
2440	#endif /* VBOX_WITH_VDMA */
2441
2442	case VBVA_QUERY_CONF32:
2443	if (cbBuffer >= sizeof(VBVACONF32))
2444	rc = vbvaHandleQueryConf32(pVGAState, (VBVACONF32 RT_UNTRUSTED_VOLATILE_GUEST *)pvBuffer);
2445	else
2446	rc = VERR_INVALID_PARAMETER;
2447	break;
2448
2449	case VBVA_SET_CONF32:
2450	if (cbBuffer >= sizeof(VBVACONF32))
2451	rc = vbvaHandleSetConf32((VBVACONF32 RT_UNTRUSTED_VOLATILE_GUEST *)pvBuffer);
2452	else
2453	rc = VERR_INVALID_PARAMETER;
2454	break;
2455
2456	case VBVA_INFO_VIEW:
2457	/* Expect at least one VBVAINFOVIEW structure. */
2458	rc = VERR_INVALID_PARAMETER;
2459	if (cbBuffer >= sizeof(VBVAINFOVIEW))
2460	{
2461	#ifdef VBOX_WITH_CRHGSMI
2462	AssertMsgBreak(!vboxCmdVBVAIsEnabled(pVGAState), ("VBVA_INFO_VIEW is not acceptible for CmdVbva\n"));
2463	#endif
2464	/* Guest submits an array of VBVAINFOVIEW structures. */
2465	const VBVAINFOVIEW RT_UNTRUSTED_VOLATILE_GUEST pView = (VBVAINFOVIEW RT_UNTRUSTED_VOLATILE_GUEST )pvBuffer;
2466	for (;
2467	cbBuffer >= sizeof(VBVAINFOVIEW);
2468	++pView, cbBuffer -= sizeof(VBVAINFOVIEW))
2469	{
2470	rc = VBVAInfoView(pVGAState, pView);
2471	if (RT_FAILURE(rc))
2472	break;
2473	}
2474	}
2475	break;
2476
2477	case VBVA_INFO_HEAP:
2478	if (cbBuffer >= sizeof(VBVAINFOHEAP))
2479	rc = vbvaHandleInfoHeap(pVGAState, (VBVAINFOHEAP RT_UNTRUSTED_VOLATILE_GUEST *)pvBuffer);
2480	else
2481	rc = VERR_INVALID_PARAMETER;
2482	break;
2483
2484	case VBVA_FLUSH:
2485	if (cbBuffer >= sizeof(VBVAFLUSH))
2486	rc = vbvaFlush(pVGAState, pCtx);
2487	else
2488	rc = VERR_INVALID_PARAMETER;
2489	break;
2490
2491	case VBVA_INFO_SCREEN:
2492	rc = VERR_INVALID_PARAMETER;
2493	#ifdef VBOX_WITH_CRHGSMI
2494	AssertMsgBreak(!vboxCmdVBVAIsEnabled(pVGAState), ("VBVA_INFO_SCREEN is not acceptible for CmdVbva\n"));
2495	#endif
2496	if (cbBuffer >= sizeof(VBVAINFOSCREEN))
2497	rc = VBVAInfoScreen(pVGAState, (VBVAINFOSCREEN RT_UNTRUSTED_VOLATILE_GUEST *)pvBuffer);
2498	break;
2499
2500	case VBVA_ENABLE:
2501	rc = VERR_INVALID_PARAMETER;
2502	#ifdef VBOX_WITH_CRHGSMI
2503	AssertMsgBreak(!vboxCmdVBVAIsEnabled(pVGAState), ("VBVA_ENABLE is not acceptible for CmdVbva\n"));
2504	#endif /* VBOX_WITH_CRHGSMI */
2505	if (cbBuffer >= sizeof(VBVAENABLE))
2506	{
2507	VBVAENABLE RT_UNTRUSTED_VOLATILE_GUEST pVbvaEnable = (VBVAENABLE RT_UNTRUSTED_VOLATILE_GUEST )pvBuffer;
2508	uint32_t const fEnableFlags = pVbvaEnable->u32Flags;
2509	uint32_t const offEnable = pVbvaEnable->u32Offset;
2510	RT_UNTRUSTED_NONVOLATILE_COPY_FENCE();
2511
2512	uint32_t idScreen;
2513	if (fEnableFlags & VBVA_F_EXTENDED)
2514	{
2515	ASSERT_GUEST_STMT_BREAK(cbBuffer >= sizeof(VBVAENABLE_EX), rc = VERR_INVALID_PARAMETER);
2516	idScreen = ((VBVAENABLE_EX RT_UNTRUSTED_VOLATILE_GUEST *)pvBuffer)->u32ScreenId;
2517	RT_UNTRUSTED_NONVOLATILE_COPY_FENCE();
2518	}
2519	else
2520	idScreen = vbvaViewFromBufferPtr(pIns, pCtx, pvBuffer);
2521
2522	rc = vbvaHandleEnable(pVGAState, fEnableFlags, offEnable, idScreen);
2523	pVbvaEnable->i32Result = rc;
2524	}
2525	break;
2526
2527	case VBVA_MOUSE_POINTER_SHAPE:
2528	if (cbBuffer >= sizeof(VBVAMOUSEPOINTERSHAPE))
2529	{
2530	VBVAMOUSEPOINTERSHAPE RT_UNTRUSTED_VOLATILE_GUEST *pShape
2531	= (VBVAMOUSEPOINTERSHAPE RT_UNTRUSTED_VOLATILE_GUEST *)pvBuffer;
2532	rc = vbvaMousePointerShape(pVGAState, pCtx, pShape, cbBuffer);
2533	pShape->i32Result = rc;
2534	}
2535	else
2536	rc = VERR_INVALID_PARAMETER;
2537	break;
2538
2539
2540	#ifdef VBOX_WITH_VIDEOHWACCEL
2541	case VBVA_VHWA_CMD:
2542	if (cbBuffer >= VBOXVHWACMD_HEADSIZE())
2543	{
2544	vbvaVHWAHandleCommand(pVGAState, (VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *)pvBuffer);
2545	rc = VINF_SUCCESS;
2546	}
2547	else
2548	rc = VERR_INVALID_PARAMETER;
2549	break;
2550	#endif
2551
2552	#ifdef VBOX_WITH_WDDM
2553	case VBVA_INFO_CAPS:
2554	if (cbBuffer >= sizeof(VBVACAPS))
2555	{
2556	VBVACAPS RT_UNTRUSTED_VOLATILE_GUEST pCaps = (VBVACAPS RT_UNTRUSTED_VOLATILE_GUEST )pvBuffer;
2557	pVGAState->fGuestCaps = pCaps->fCaps;
2558	RT_UNTRUSTED_NONVOLATILE_COPY_FENCE();
2559
2560	pVGAState->pDrv->pfnVBVAGuestCapabilityUpdate(pVGAState->pDrv, pVGAState->fGuestCaps);
2561	pCaps->rc = rc = VINF_SUCCESS;
2562	}
2563	else
2564	rc = VERR_INVALID_PARAMETER;
2565	break;
2566	#endif
2567
2568	case VBVA_SCANLINE_CFG:
2569	if (cbBuffer >= sizeof(VBVASCANLINECFG))
2570	{
2571	VBVASCANLINECFG RT_UNTRUSTED_VOLATILE_GUEST pCfg = (VBVASCANLINECFG RT_UNTRUSTED_VOLATILE_GUEST )pvBuffer;
2572	pVGAState->fScanLineCfg = pCfg->fFlags;
2573	RT_UNTRUSTED_NONVOLATILE_COPY_FENCE();
2574
2575	pCfg->rc = rc = VINF_SUCCESS;
2576	}
2577	else
2578	rc = VERR_INVALID_PARAMETER;
2579	break;
2580
2581	case VBVA_QUERY_MODE_HINTS:
2582	if (cbBuffer >= sizeof(VBVAQUERYMODEHINTS))
2583	{
2584	VBVAQUERYMODEHINTS RT_UNTRUSTED_VOLATILE_GUEST *pQueryModeHints;
2585	pQueryModeHints = (VBVAQUERYMODEHINTS RT_UNTRUSTED_VOLATILE_GUEST *)pvBuffer;
2586	rc = vbvaHandleQueryModeHints(pVGAState, pQueryModeHints, cbBuffer);
2587	pQueryModeHints->rc = rc;
2588	}
2589	else
2590	rc = VERR_INVALID_PARAMETER;
2591	break;
2592
2593	case VBVA_REPORT_INPUT_MAPPING:
2594	if (cbBuffer >= sizeof(VBVAREPORTINPUTMAPPING))
2595	{
2596	VBVAREPORTINPUTMAPPING inputMapping;
2597	{
2598	VBVAREPORTINPUTMAPPING RT_UNTRUSTED_VOLATILE_GUEST *pInputMapping
2599	= (VBVAREPORTINPUTMAPPING RT_UNTRUSTED_VOLATILE_GUEST *)pvBuffer;
2600	inputMapping.x = pInputMapping->x;
2601	inputMapping.y = pInputMapping->y;
2602	inputMapping.cx = pInputMapping->cx;
2603	inputMapping.cy = pInputMapping->cy;
2604	}
2605	RT_UNTRUSTED_NONVOLATILE_COPY_FENCE();
2606
2607	LogRelFlowFunc(("VBVA: ChannelHandler: VBVA_REPORT_INPUT_MAPPING: x=%RI32, y=%RI32, cx=%RU32, cy=%RU32\n",
2608	inputMapping.x, inputMapping.y, inputMapping.cx, inputMapping.cy));
2609	pVGAState->pDrv->pfnVBVAInputMappingUpdate(pVGAState->pDrv,
2610	inputMapping.x, inputMapping.y,
2611	inputMapping.cx, inputMapping.cy);
2612	rc = VINF_SUCCESS;
2613	}
2614	else
2615	rc = VERR_INVALID_PARAMETER;
2616	break;
2617
2618	case VBVA_CURSOR_POSITION:
2619	if (cbBuffer >= sizeof(VBVACURSORPOSITION))
2620	{
2621	VBVACURSORPOSITION RT_UNTRUSTED_VOLATILE_GUEST pReport = (VBVACURSORPOSITION RT_UNTRUSTED_VOLATILE_GUEST )pvBuffer;
2622	VBVACURSORPOSITION Report;
2623	Report.fReportPosition = pReport->fReportPosition;
2624	Report.x = pReport->x;
2625	Report.y = pReport->y;
2626	RT_UNTRUSTED_NONVOLATILE_COPY_FENCE();
2627
2628	LogRelFlowFunc(("VBVA: ChannelHandler: VBVA_CURSOR_POSITION: fReportPosition=%RTbool, x=%RU32, y=%RU32\n",
2629	RT_BOOL(Report.fReportPosition), Report.x, Report.y));
2630
2631	pVGAState->pDrv->pfnVBVAReportCursorPosition(pVGAState->pDrv, RT_BOOL(Report.fReportPosition), Report.x, Report.y);
2632	pReport->x = pCtx->xCursor;
2633	pReport->y = pCtx->yCursor;
2634	rc = VINF_SUCCESS;
2635	}
2636	else
2637	rc = VERR_INVALID_PARAMETER;
2638	break;
2639
2640	default:
2641	Log(("Unsupported VBVA guest command %d (%#x)!!!\n", u16ChannelInfo, u16ChannelInfo));
2642	break;
2643	}
2644
2645	return rc;
2646	}
2647
2648	/* When VBVA is paused, then VGA device is allowed to work but
2649	* no HGSMI etc state is changed.
2650	*/
2651	void VBVAPause(PVGASTATE pVGAState, bool fPause)
2652	{
2653	if (!pVGAState \|\| !pVGAState->pHGSMI)
2654	{
2655	return;
2656	}
2657
2658	VBVACONTEXT pCtx = (VBVACONTEXT )HGSMIContext(pVGAState->pHGSMI);
2659
2660	if (pCtx)
2661	{
2662	pCtx->fPaused = fPause;
2663	}
2664	}
2665
2666	bool VBVAIsPaused(PVGASTATE pVGAState)
2667	{
2668	if (pVGAState && pVGAState->pHGSMI)
2669	{
2670	const VBVACONTEXT pCtx = (VBVACONTEXT )HGSMIContext(pVGAState->pHGSMI);
2671	if (pCtx && pCtx->cViews)
2672	{
2673	/* If VBVA is enabled at all. */
2674	const VBVAVIEW *pView = &pCtx->aViews[0];
2675	if (pView->vbva.guest.pVBVA)
2676	return pCtx->fPaused;
2677	}
2678	}
2679	/* VBVA is disabled. */
2680	return true;
2681	}
2682
2683	void VBVAOnVBEChanged(PVGASTATE pVGAState)
2684	{
2685	/* The guest does not depend on host handling the VBE registers. */
2686	if (pVGAState->fGuestCaps & VBVACAPS_USE_VBVA_ONLY)
2687	{
2688	return;
2689	}
2690
2691	VBVAPause(pVGAState, (pVGAState->vbe_regs[VBE_DISPI_INDEX_ENABLE] & VBE_DISPI_ENABLED) == 0);
2692	}
2693
2694	void VBVAReset (PVGASTATE pVGAState)
2695	{
2696	if (!pVGAState \|\| !pVGAState->pHGSMI)
2697	{
2698	return;
2699	}
2700
2701	VBVACONTEXT pCtx = (VBVACONTEXT )HGSMIContext (pVGAState->pHGSMI);
2702
2703	#ifdef VBOX_WITH_VIDEOHWACCEL
2704	vbvaVHWAReset (pVGAState);
2705	#endif
2706
2707	HGSMIReset(pVGAState->pHGSMI);
2708	/* Make sure the IRQ is reset. */
2709	PDMDevHlpPCISetIrq(pVGAState->pDevInsR3, 0, PDM_IRQ_LEVEL_LOW);
2710	pVGAState->fu32PendingGuestFlags = 0;
2711
2712	if (pCtx)
2713	{
2714	vbvaFlush (pVGAState, pCtx);
2715
2716	unsigned uScreenId;
2717
2718	for (uScreenId = 0; uScreenId < pCtx->cViews; uScreenId++)
2719	{
2720	vbvaDisable (uScreenId, pVGAState, pCtx);
2721	}
2722
2723	pCtx->mouseShapeInfo.fSet = false;
2724	RTMemFree(pCtx->mouseShapeInfo.pu8Shape);
2725	pCtx->mouseShapeInfo.pu8Shape = NULL;
2726	pCtx->mouseShapeInfo.cbAllocated = 0;
2727	pCtx->mouseShapeInfo.cbShape = 0;
2728	}
2729
2730	}
2731
2732	int VBVAUpdateDisplay (PVGASTATE pVGAState)
2733	{
2734	int rc = VERR_NOT_SUPPORTED; /* Assuming that the VGA device will have to do updates. */
2735
2736	VBVACONTEXT pCtx = (VBVACONTEXT )HGSMIContext (pVGAState->pHGSMI);
2737
2738	if (pCtx)
2739	{
2740	if (!pCtx->fPaused)
2741	{
2742	rc = vbvaFlush (pVGAState, pCtx);
2743
2744	if (RT_SUCCESS (rc))
2745	{
2746	if (!pCtx->aViews[0].vbva.guest.pVBVA)
2747	{
2748	/* VBVA is not enabled for the first view, so VGA device must do updates. */
2749	rc = VERR_NOT_SUPPORTED;
2750	}
2751	}
2752	}
2753	}
2754
2755	return rc;
2756	}
2757
2758	static int vbvaSendModeHintWorker(PVGASTATE pThis, uint32_t cx, uint32_t cy,
2759	uint32_t cBPP, uint32_t iDisplay, uint32_t dx,
2760	uint32_t dy, uint32_t fEnabled,
2761	uint32_t fNotifyGuest)
2762	{
2763	VBVACONTEXT pCtx = (VBVACONTEXT )HGSMIContext(pThis->pHGSMI);
2764	/** @note See Display::setVideoModeHint: "It is up to the guest to decide
2765	* whether the hint is valid. Therefore don't do any VRAM sanity checks
2766	* here! */
2767	if (iDisplay >= RT_MIN(pThis->cMonitors, RT_ELEMENTS(pCtx->aModeHints)))
2768	return VERR_OUT_OF_RANGE;
2769	pCtx->aModeHints[iDisplay].magic = VBVAMODEHINT_MAGIC;
2770	pCtx->aModeHints[iDisplay].cx = cx;
2771	pCtx->aModeHints[iDisplay].cy = cy;
2772	pCtx->aModeHints[iDisplay].cBPP = cBPP;
2773	pCtx->aModeHints[iDisplay].dx = dx;
2774	pCtx->aModeHints[iDisplay].dy = dy;
2775	pCtx->aModeHints[iDisplay].fEnabled = fEnabled;
2776	if (fNotifyGuest && pThis->fGuestCaps & VBVACAPS_IRQ && pThis->fGuestCaps & VBVACAPS_VIDEO_MODE_HINTS)
2777	VBVARaiseIrq(pThis, HGSMIHOSTFLAGS_HOTPLUG);
2778	return VINF_SUCCESS;
2779	}
2780
2781	/** Converts a display port interface pointer to a vga state pointer. */
2782	#define IDISPLAYPORT_2_VGASTATE(pInterface) ( (PVGASTATE)((uintptr_t)pInterface - RT_OFFSETOF(VGASTATE, IPort)) )
2783
2784	DECLCALLBACK(int) vbvaPortSendModeHint(PPDMIDISPLAYPORT pInterface, uint32_t cx,
2785	uint32_t cy, uint32_t cBPP,
2786	uint32_t iDisplay, uint32_t dx,
2787	uint32_t dy, uint32_t fEnabled,
2788	uint32_t fNotifyGuest)
2789	{
2790	PVGASTATE pThis;
2791	int rc;
2792
2793	pThis = IDISPLAYPORT_2_VGASTATE(pInterface);
2794	rc = PDMCritSectEnter(&pThis->CritSect, VERR_SEM_BUSY);
2795	AssertRC(rc);
2796	rc = vbvaSendModeHintWorker(pThis, cx, cy, cBPP, iDisplay, dx, dy, fEnabled,
2797	fNotifyGuest);
2798	PDMCritSectLeave(&pThis->CritSect);
2799	return rc;
2800	}
2801
2802	DECLCALLBACK(void) vbvaPortReportHostCursorCapabilities(PPDMIDISPLAYPORT pInterface, uint32_t fCapabilitiesAdded,
2803	uint32_t fCapabilitiesRemoved)
2804	{
2805	PVGASTATE pThis = IDISPLAYPORT_2_VGASTATE(pInterface);
2806	int rc = PDMCritSectEnter(&pThis->CritSect, VERR_SEM_BUSY);
2807	AssertRC(rc);
2808	pThis->fHostCursorCapabilities \|= fCapabilitiesAdded;
2809	pThis->fHostCursorCapabilities &= ~fCapabilitiesRemoved;
2810	if (pThis->fGuestCaps & VBVACAPS_IRQ && pThis->fGuestCaps & VBVACAPS_DISABLE_CURSOR_INTEGRATION)
2811	VBVARaiseIrq(pThis, HGSMIHOSTFLAGS_CURSOR_CAPABILITIES);
2812	PDMCritSectLeave(&pThis->CritSect);
2813	}
2814
2815	DECLCALLBACK(void) vbvaPortReportHostCursorPosition(PPDMIDISPLAYPORT pInterface, uint32_t x, uint32_t y)
2816	{
2817	PVGASTATE pThis = IDISPLAYPORT_2_VGASTATE(pInterface);
2818	VBVACONTEXT pCtx = (VBVACONTEXT )HGSMIContext(pThis->pHGSMI);
2819	int rc = PDMCritSectEnter(&pThis->CritSect, VERR_SEM_BUSY);
2820	AssertRC(rc);
2821	pCtx->xCursor = x;
2822	pCtx->yCursor = y;
2823	PDMCritSectLeave(&pThis->CritSect);
2824	}
2825
2826	int VBVAInit(PVGASTATE pVGAState)
2827	{
2828	PPDMDEVINS pDevIns = pVGAState->pDevInsR3;
2829
2830	PVM pVM = PDMDevHlpGetVM(pDevIns);
2831
2832	int rc = HGSMICreate(&pVGAState->pHGSMI,
2833	pVM,
2834	"VBVA",
2835	0,
2836	pVGAState->vram_ptrR3,
2837	pVGAState->vram_size,
2838	vbvaNotifyGuest,
2839	pVGAState,
2840	sizeof(VBVACONTEXT));
2841	if (RT_SUCCESS(rc))
2842	{
2843	rc = HGSMIHostChannelRegister(pVGAState->pHGSMI,
2844	HGSMI_CH_VBVA,
2845	vbvaChannelHandler,
2846	pVGAState);
2847	if (RT_SUCCESS(rc))
2848	{
2849	VBVACONTEXT pCtx = (VBVACONTEXT )HGSMIContext(pVGAState->pHGSMI);
2850	pCtx->cViews = pVGAState->cMonitors;
2851	pCtx->fPaused = true;
2852	memset(pCtx->aModeHints, ~0, sizeof(pCtx->aModeHints));
2853	pVGAState->fHostCursorCapabilities = 0;
2854	}
2855	}
2856
2857	return rc;
2858
2859	}
2860
2861	void VBVADestroy(PVGASTATE pVGAState)
2862	{
2863	PHGSMIINSTANCE pHgsmi = pVGAState->pHGSMI;
2864	if (pHgsmi)
2865	{
2866	VBVACONTEXT pCtx = (VBVACONTEXT )HGSMIContext(pHgsmi);
2867	pCtx->mouseShapeInfo.fSet = false;
2868	RTMemFree(pCtx->mouseShapeInfo.pu8Shape);
2869	pCtx->mouseShapeInfo.pu8Shape = NULL;
2870	pCtx->mouseShapeInfo.cbAllocated = 0;
2871	pCtx->mouseShapeInfo.cbShape = 0;
2872
2873	HGSMIDestroy(pHgsmi);
2874	pVGAState->pHGSMI = NULL;
2875	}
2876	}
2877

注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

source: vbox/trunk/src/VBox/Devices/Graphics/DevVGA_VBVA.cpp@ 71622

以其他格式下載: