VirtualBox

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

Last change on this file since 52849 was 52849, checked in by vboxsync, 10 years ago

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

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