DevVGA_VBVA.cpp@ 53813

Last change on this file since 53813 was 53813, checked in by vboxsync, 10 years ago
Devices/Graphics: do not re-set the guest VBVA capabilities when VBVA is enabled.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 86.4 KB

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

Note: See TracBrowser for help on using the repository browser.

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

Download in other formats: