VirtualBox

source: vbox/trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoVdma.cpp@ 34345

Last change on this file since 34345 was 34345, checked in by vboxsync, 14 years ago

wddm/3d: propper hide host window on swapchain destruction
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 59.9 KB
Line 
1/*
2 * Copyright (C) 2010 Oracle Corporation
3 *
4 * This file is part of VirtualBox Open Source Edition (OSE), as
5 * available from http://www.virtualbox.org. This file is free software;
6 * you can redistribute it and/or modify it under the terms of the GNU
7 * General Public License (GPL) as published by the Free Software
8 * Foundation, in version 2 as it comes in the "COPYING" file of the
9 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
10 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
11 */
12
13#include "../VBoxVideo-win.h"
14#include "../Helper.h"
15
16#include <VBox/VBoxGuestLib.h>
17#include <VBox/VBoxVideo.h>
18#include "VBoxVideoVdma.h"
19#include "../VBoxVideo.h"
20
21#include <iprt/asm.h>
22
23NTSTATUS vboxVdmaPipeConstruct(PVBOXVDMAPIPE pPipe)
24{
25 KeInitializeSpinLock(&pPipe->SinchLock);
26 KeInitializeEvent(&pPipe->Event, SynchronizationEvent, FALSE);
27 InitializeListHead(&pPipe->CmdListHead);
28 pPipe->enmState = VBOXVDMAPIPE_STATE_CREATED;
29 pPipe->bNeedNotify = true;
30 return STATUS_SUCCESS;
31}
32
33NTSTATUS vboxVdmaPipeSvrOpen(PVBOXVDMAPIPE pPipe)
34{
35 NTSTATUS Status = STATUS_SUCCESS;
36 KIRQL OldIrql;
37 KeAcquireSpinLock(&pPipe->SinchLock, &OldIrql);
38 Assert(pPipe->enmState == VBOXVDMAPIPE_STATE_CREATED);
39 switch (pPipe->enmState)
40 {
41 case VBOXVDMAPIPE_STATE_CREATED:
42 pPipe->enmState = VBOXVDMAPIPE_STATE_OPENNED;
43 pPipe->bNeedNotify = false;
44 break;
45 case VBOXVDMAPIPE_STATE_OPENNED:
46 pPipe->bNeedNotify = false;
47 break;
48 default:
49 AssertBreakpoint();
50 Status = STATUS_INVALID_PIPE_STATE;
51 break;
52 }
53
54 KeReleaseSpinLock(&pPipe->SinchLock, OldIrql);
55 return Status;
56}
57
58NTSTATUS vboxVdmaPipeSvrClose(PVBOXVDMAPIPE pPipe)
59{
60 NTSTATUS Status = STATUS_SUCCESS;
61 KIRQL OldIrql;
62 KeAcquireSpinLock(&pPipe->SinchLock, &OldIrql);
63 Assert(pPipe->enmState == VBOXVDMAPIPE_STATE_CLOSED
64 || pPipe->enmState == VBOXVDMAPIPE_STATE_CLOSING);
65 switch (pPipe->enmState)
66 {
67 case VBOXVDMAPIPE_STATE_CLOSING:
68 pPipe->enmState = VBOXVDMAPIPE_STATE_CLOSED;
69 break;
70 case VBOXVDMAPIPE_STATE_CLOSED:
71 break;
72 default:
73 AssertBreakpoint();
74 Status = STATUS_INVALID_PIPE_STATE;
75 break;
76 }
77
78 KeReleaseSpinLock(&pPipe->SinchLock, OldIrql);
79 return Status;
80}
81
82NTSTATUS vboxVdmaPipeCltClose(PVBOXVDMAPIPE pPipe)
83{
84 NTSTATUS Status = STATUS_SUCCESS;
85 KIRQL OldIrql;
86 KeAcquireSpinLock(&pPipe->SinchLock, &OldIrql);
87 bool bNeedNotify = false;
88 Assert(pPipe->enmState == VBOXVDMAPIPE_STATE_OPENNED
89 || pPipe->enmState == VBOXVDMAPIPE_STATE_CREATED
90 || pPipe->enmState == VBOXVDMAPIPE_STATE_CLOSED);
91 switch (pPipe->enmState)
92 {
93 case VBOXVDMAPIPE_STATE_OPENNED:
94 pPipe->enmState = VBOXVDMAPIPE_STATE_CLOSING;
95 bNeedNotify = pPipe->bNeedNotify;
96 pPipe->bNeedNotify = false;
97 break;
98 case VBOXVDMAPIPE_STATE_CREATED:
99 pPipe->enmState = VBOXVDMAPIPE_STATE_CLOSED;
100 pPipe->bNeedNotify = false;
101 break;
102 case VBOXVDMAPIPE_STATE_CLOSED:
103 break;
104 default:
105 AssertBreakpoint();
106 Status = STATUS_INVALID_PIPE_STATE;
107 break;
108 }
109
110 KeReleaseSpinLock(&pPipe->SinchLock, OldIrql);
111
112 if (bNeedNotify)
113 {
114 KeSetEvent(&pPipe->Event, 0, FALSE);
115 }
116 return Status;
117}
118
119NTSTATUS vboxVdmaPipeDestruct(PVBOXVDMAPIPE pPipe)
120{
121 Assert(pPipe->enmState == VBOXVDMAPIPE_STATE_CLOSED
122 || pPipe->enmState == VBOXVDMAPIPE_STATE_CREATED);
123 /* ensure the pipe is closed */
124 NTSTATUS Status = vboxVdmaPipeCltClose(pPipe);
125 Assert(Status == STATUS_SUCCESS);
126
127 Assert(pPipe->enmState == VBOXVDMAPIPE_STATE_CLOSED);
128
129 return Status;
130}
131
132NTSTATUS vboxVdmaPipeSvrCmdGetList(PVBOXVDMAPIPE pPipe, PLIST_ENTRY pDetachHead)
133{
134 PLIST_ENTRY pEntry = NULL;
135 KIRQL OldIrql;
136 NTSTATUS Status = STATUS_SUCCESS;
137 VBOXVDMAPIPE_STATE enmState = VBOXVDMAPIPE_STATE_CLOSED;
138 do
139 {
140 bool bListEmpty = true;
141 KeAcquireSpinLock(&pPipe->SinchLock, &OldIrql);
142 Assert(pPipe->enmState == VBOXVDMAPIPE_STATE_OPENNED
143 || pPipe->enmState == VBOXVDMAPIPE_STATE_CLOSING);
144 Assert(pPipe->enmState >= VBOXVDMAPIPE_STATE_OPENNED);
145 enmState = pPipe->enmState;
146 if (enmState >= VBOXVDMAPIPE_STATE_OPENNED)
147 {
148 vboxVideoLeDetach(&pPipe->CmdListHead, pDetachHead);
149 bListEmpty = !!(IsListEmpty(pDetachHead));
150 pPipe->bNeedNotify = bListEmpty;
151 }
152 else
153 {
154 KeReleaseSpinLock(&pPipe->SinchLock, OldIrql);
155 Status = STATUS_INVALID_PIPE_STATE;
156 break;
157 }
158
159 KeReleaseSpinLock(&pPipe->SinchLock, OldIrql);
160
161 if (!bListEmpty)
162 {
163 Assert(Status == STATUS_SUCCESS);
164 break;
165 }
166
167 if (enmState == VBOXVDMAPIPE_STATE_OPENNED)
168 {
169 Status = KeWaitForSingleObject(&pPipe->Event, Executive, KernelMode, FALSE, NULL /* PLARGE_INTEGER Timeout */);
170 Assert(Status == STATUS_SUCCESS);
171 if (Status != STATUS_SUCCESS)
172 break;
173 }
174 else
175 {
176 Assert(enmState == VBOXVDMAPIPE_STATE_CLOSING);
177 Status = STATUS_PIPE_CLOSING;
178 break;
179 }
180 } while (1);
181
182 return Status;
183}
184
185NTSTATUS vboxVdmaPipeCltCmdPut(PVBOXVDMAPIPE pPipe, PVBOXVDMAPIPE_CMD_HDR pCmd)
186{
187 NTSTATUS Status = STATUS_SUCCESS;
188 KIRQL OldIrql;
189 bool bNeedNotify = false;
190
191 KeAcquireSpinLock(&pPipe->SinchLock, &OldIrql);
192
193 Assert(pPipe->enmState == VBOXVDMAPIPE_STATE_OPENNED);
194 if (pPipe->enmState == VBOXVDMAPIPE_STATE_OPENNED)
195 {
196 bNeedNotify = pPipe->bNeedNotify;
197 InsertHeadList(&pPipe->CmdListHead, &pCmd->ListEntry);
198 pPipe->bNeedNotify = false;
199 }
200 else
201 Status = STATUS_INVALID_PIPE_STATE;
202
203 KeReleaseSpinLock(&pPipe->SinchLock, OldIrql);
204
205 if (bNeedNotify)
206 {
207 KeSetEvent(&pPipe->Event, 0, FALSE);
208 }
209
210 return Status;
211}
212
213PVBOXVDMAPIPE_CMD_DR vboxVdmaGgCmdCreate(PVBOXVDMAGG pVdma, VBOXVDMAPIPE_CMD_TYPE enmType, uint32_t cbCmd)
214{
215 PVBOXVDMAPIPE_CMD_DR pHdr = (PVBOXVDMAPIPE_CMD_DR)vboxWddmMemAllocZero(cbCmd);
216 Assert(pHdr);
217 if (pHdr)
218 {
219 pHdr->enmType = enmType;
220 return pHdr;
221 }
222 return NULL;
223}
224
225void vboxVdmaGgCmdDestroy(PVBOXVDMAPIPE_CMD_DR pDr)
226{
227 vboxWddmMemFree(pDr);
228}
229
230DECLCALLBACK(VOID) vboxVdmaGgDdiCmdDestroy(PDEVICE_EXTENSION pDevExt, PVBOXVDMADDI_CMD pCmd, PVOID pvContext)
231{
232 vboxVdmaGgCmdDestroy((PVBOXVDMAPIPE_CMD_DR)pvContext);
233}
234
235/**
236 * helper function used for system thread creation
237 */
238static NTSTATUS vboxVdmaGgThreadCreate(PKTHREAD * ppThread, PKSTART_ROUTINE pStartRoutine, PVOID pStartContext)
239{
240 NTSTATUS fStatus;
241 HANDLE hThread;
242 OBJECT_ATTRIBUTES fObjectAttributes;
243
244 Assert(KeGetCurrentIrql() == PASSIVE_LEVEL);
245
246 InitializeObjectAttributes(&fObjectAttributes, NULL, OBJ_KERNEL_HANDLE,
247 NULL, NULL);
248
249 fStatus = PsCreateSystemThread(&hThread, THREAD_ALL_ACCESS,
250 &fObjectAttributes, NULL, NULL,
251 (PKSTART_ROUTINE) pStartRoutine, pStartContext);
252 if (!NT_SUCCESS(fStatus))
253 return fStatus;
254
255 ObReferenceObjectByHandle(hThread, THREAD_ALL_ACCESS, NULL,
256 KernelMode, (PVOID*) ppThread, NULL);
257 ZwClose(hThread);
258 return STATUS_SUCCESS;
259}
260
261DECLINLINE(void) vboxVdmaDirtyRectsCalcIntersection(const RECT *pArea, const PVBOXWDDM_RECTS_INFO pRects, PVBOXWDDM_RECTS_INFO pResult)
262{
263 uint32_t cRects = 0;
264 for (uint32_t i = 0; i < pRects->cRects; ++i)
265 {
266 if (vboxWddmRectIntersection(pArea, &pRects->aRects[i], &pResult->aRects[cRects]))
267 {
268 ++cRects;
269 }
270 }
271
272 pResult->cRects = cRects;
273}
274
275DECLINLINE(bool) vboxVdmaDirtyRectsHasIntersections(const RECT *paRects1, uint32_t cRects1, const RECT *paRects2, uint32_t cRects2)
276{
277 RECT tmpRect;
278 for (uint32_t i = 0; i < cRects1; ++i)
279 {
280 const RECT * pRect1 = &paRects1[i];
281 for (uint32_t j = 0; j < cRects2; ++j)
282 {
283 const RECT * pRect2 = &paRects2[j];
284 if (vboxWddmRectIntersection(pRect1, pRect2, &tmpRect))
285 return true;
286 }
287 }
288 return false;
289}
290
291DECLINLINE(bool) vboxVdmaDirtyRectsIsCover(const RECT *paRects, uint32_t cRects, const RECT *paRectsCovered, uint32_t cRectsCovered)
292{
293 for (uint32_t i = 0; i < cRectsCovered; ++i)
294 {
295 const RECT * pRectCovered = &paRectsCovered[i];
296 uint32_t j = 0;
297 for (; j < cRects; ++j)
298 {
299 const RECT * pRect = &paRects[j];
300 if (vboxWddmRectIsCoveres(pRect, pRectCovered))
301 break;
302 }
303 if (j == cRects)
304 return false;
305 }
306 return true;
307}
308
309NTSTATUS vboxVdmaPostHideSwapchain(PVBOXWDDM_SWAPCHAIN pSwapchain)
310{
311 Assert(KeGetCurrentIrql() < DISPATCH_LEVEL);
312 uint32_t cbCmdInternal = VBOXVIDEOCM_CMD_RECTS_INTERNAL_SIZE4CRECTS(0);
313 PVBOXVIDEOCM_CMD_RECTS_INTERNAL pCmdInternal =
314 (PVBOXVIDEOCM_CMD_RECTS_INTERNAL)vboxVideoCmCmdCreate(&pSwapchain->pContext->CmContext, cbCmdInternal);
315 Assert(pCmdInternal);
316 if (pCmdInternal)
317 {
318 pCmdInternal->hSwapchainUm = pSwapchain->hSwapchainUm;
319 pCmdInternal->Cmd.fFlags.Value = 0;
320 pCmdInternal->Cmd.fFlags.bAddHiddenRects = 1;
321 pCmdInternal->Cmd.fFlags.bHide = 1;
322 pCmdInternal->Cmd.RectsInfo.cRects = 0;
323 vboxVideoCmCmdSubmit(pCmdInternal, VBOXVIDEOCM_SUBMITSIZE_DEFAULT);
324 return STATUS_SUCCESS;
325 }
326 return STATUS_NO_MEMORY;
327}
328
329/**
330 * @param pDevExt
331 */
332static NTSTATUS vboxVdmaGgDirtyRectsProcess(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_CONTEXT pContext, PVBOXWDDM_SWAPCHAIN pSwapchain, VBOXVDMAPIPE_RECTS *pContextRects)
333{
334 PVBOXWDDM_RECTS_INFO pRects = &pContextRects->UpdateRects;
335 NTSTATUS Status = STATUS_SUCCESS;
336 PVBOXVIDEOCM_CMD_RECTS_INTERNAL pCmdInternal = NULL;
337 uint32_t cbCmdInternal = VBOXVIDEOCM_CMD_RECTS_INTERNAL_SIZE4CRECTS(pRects->cRects);
338 Assert(KeGetCurrentIrql() < DISPATCH_LEVEL);
339 ExAcquireFastMutex(&pDevExt->ContextMutex);
340 for (PLIST_ENTRY pCur = pDevExt->SwapchainList3D.Flink; pCur != &pDevExt->SwapchainList3D; pCur = pCur->Flink)
341 {
342 if (pCur != &pSwapchain->DevExtListEntry)
343 {
344 PVBOXWDDM_SWAPCHAIN pCurSwapchain = VBOXWDDMENTRY_2_SWAPCHAIN(pCur);
345 if (!pCmdInternal)
346 {
347 pCmdInternal = (PVBOXVIDEOCM_CMD_RECTS_INTERNAL)vboxVideoCmCmdCreate(&pCurSwapchain->pContext->CmContext, cbCmdInternal);
348 Assert(pCmdInternal);
349 if (!pCmdInternal)
350 {
351 Status = STATUS_NO_MEMORY;
352 break;
353 }
354 }
355 else
356 {
357 pCmdInternal = (PVBOXVIDEOCM_CMD_RECTS_INTERNAL)vboxVideoCmCmdReinitForContext(pCmdInternal, &pCurSwapchain->pContext->CmContext);
358 }
359
360 vboxVdmaDirtyRectsCalcIntersection(&pCurSwapchain->ViewRect, pRects, &pCmdInternal->Cmd.RectsInfo);
361 if (pCmdInternal->Cmd.RectsInfo.cRects)
362 {
363 bool bSend = false;
364 pCmdInternal->Cmd.fFlags.Value = 0;
365 pCmdInternal->Cmd.fFlags.bAddHiddenRects = 1;
366 if (pCurSwapchain->pLastReportedRects)
367 {
368 if (pCurSwapchain->pLastReportedRects->Cmd.fFlags.bSetVisibleRects)
369 {
370 RECT *paPrevRects;
371 uint32_t cPrevRects;
372 if (pCurSwapchain->pLastReportedRects->Cmd.fFlags.bSetViewRect)
373 {
374 paPrevRects = &pCurSwapchain->pLastReportedRects->Cmd.RectsInfo.aRects[1];
375 cPrevRects = pCurSwapchain->pLastReportedRects->Cmd.RectsInfo.cRects - 1;
376 }
377 else
378 {
379 paPrevRects = &pCurSwapchain->pLastReportedRects->Cmd.RectsInfo.aRects[0];
380 cPrevRects = pCurSwapchain->pLastReportedRects->Cmd.RectsInfo.cRects;
381 }
382
383 if (vboxVdmaDirtyRectsHasIntersections(paPrevRects, cPrevRects,
384 pCmdInternal->Cmd.RectsInfo.aRects, pCmdInternal->Cmd.RectsInfo.cRects))
385 {
386 bSend = true;
387 }
388 }
389 else
390 {
391 Assert(pCurSwapchain->pLastReportedRects->Cmd.fFlags.bAddHiddenRects);
392 if (!vboxVdmaDirtyRectsIsCover(pCurSwapchain->pLastReportedRects->Cmd.RectsInfo.aRects,
393 pCurSwapchain->pLastReportedRects->Cmd.RectsInfo.cRects,
394 pCmdInternal->Cmd.RectsInfo.aRects, pCmdInternal->Cmd.RectsInfo.cRects))
395 {
396 bSend = true;
397 }
398 }
399 }
400 else
401 bSend = true;
402
403 if (bSend)
404 {
405 if (pCurSwapchain->pLastReportedRects)
406 vboxVideoCmCmdRelease(pCurSwapchain->pLastReportedRects);
407
408 pCmdInternal->hSwapchainUm = pCurSwapchain->hSwapchainUm;
409
410 vboxVideoCmCmdRetain(pCmdInternal);
411 pCurSwapchain->pLastReportedRects = pCmdInternal;
412 vboxVideoCmCmdSubmit(pCmdInternal, VBOXVIDEOCM_CMD_RECTS_INTERNAL_SIZE4CRECTS(pCmdInternal->Cmd.RectsInfo.cRects));
413 pCmdInternal = NULL;
414 }
415 }
416 }
417 else
418 {
419 RECT * pContextRect = &pContextRects->ContextRect;
420 bool bRectShanged = (pSwapchain->ViewRect.left != pContextRect->left
421 || pSwapchain->ViewRect.top != pContextRect->top
422 || pSwapchain->ViewRect.right != pContextRect->right
423 || pSwapchain->ViewRect.bottom != pContextRect->bottom);
424 PVBOXVIDEOCM_CMD_RECTS_INTERNAL pDrCmdInternal;
425
426 bool bSend = false;
427
428 if (bRectShanged)
429 {
430 uint32_t cbDrCmdInternal = VBOXVIDEOCM_CMD_RECTS_INTERNAL_SIZE4CRECTS(pRects->cRects + 1);
431 pDrCmdInternal = (PVBOXVIDEOCM_CMD_RECTS_INTERNAL)vboxVideoCmCmdCreate(&pContext->CmContext, cbDrCmdInternal);
432 Assert(pDrCmdInternal);
433 if (!pDrCmdInternal)
434 {
435 Status = STATUS_NO_MEMORY;
436 break;
437 }
438 pDrCmdInternal->Cmd.fFlags.Value = 0;
439 pDrCmdInternal->Cmd.RectsInfo.cRects = pRects->cRects + 1;
440 pDrCmdInternal->Cmd.fFlags.bSetViewRect = 1;
441 pDrCmdInternal->Cmd.RectsInfo.aRects[0] = *pContextRect;
442 pSwapchain->ViewRect = *pContextRect;
443 memcpy(&pDrCmdInternal->Cmd.RectsInfo.aRects[1], pRects->aRects, sizeof (RECT) * pRects->cRects);
444 bSend = true;
445 }
446 else
447 {
448 if (pCmdInternal)
449 {
450 pDrCmdInternal = (PVBOXVIDEOCM_CMD_RECTS_INTERNAL)vboxVideoCmCmdReinitForContext(pCmdInternal, &pContext->CmContext);
451 pCmdInternal = NULL;
452 }
453 else
454 {
455 pDrCmdInternal = (PVBOXVIDEOCM_CMD_RECTS_INTERNAL)vboxVideoCmCmdCreate(&pContext->CmContext, cbCmdInternal);
456 Assert(pDrCmdInternal);
457 if (!pDrCmdInternal)
458 {
459 Status = STATUS_NO_MEMORY;
460 break;
461 }
462 }
463 pDrCmdInternal->Cmd.fFlags.Value = 0;
464 pDrCmdInternal->Cmd.RectsInfo.cRects = pRects->cRects;
465 memcpy(&pDrCmdInternal->Cmd.RectsInfo.aRects[0], pRects->aRects, sizeof (RECT) * pRects->cRects);
466
467 if (pSwapchain->pLastReportedRects)
468 {
469 if (pSwapchain->pLastReportedRects->Cmd.fFlags.bSetVisibleRects)
470 {
471 RECT *paRects;
472 uint32_t cRects;
473 if (pSwapchain->pLastReportedRects->Cmd.fFlags.bSetViewRect)
474 {
475 paRects = &pSwapchain->pLastReportedRects->Cmd.RectsInfo.aRects[1];
476 cRects = pSwapchain->pLastReportedRects->Cmd.RectsInfo.cRects - 1;
477 }
478 else
479 {
480 paRects = &pSwapchain->pLastReportedRects->Cmd.RectsInfo.aRects[0];
481 cRects = pSwapchain->pLastReportedRects->Cmd.RectsInfo.cRects;
482 }
483 bSend = (pDrCmdInternal->Cmd.RectsInfo.cRects != cRects)
484 || memcmp(paRects, pDrCmdInternal->Cmd.RectsInfo.aRects, cRects * sizeof (RECT));
485 }
486 else
487 {
488 Assert(pSwapchain->pLastReportedRects->Cmd.fFlags.bAddHiddenRects);
489 bSend = true;
490 }
491 }
492 else
493 bSend = true;
494
495 }
496
497 Assert(pRects->cRects);
498 if (bSend)
499 {
500 if (pSwapchain->pLastReportedRects)
501 vboxVideoCmCmdRelease(pSwapchain->pLastReportedRects);
502
503 pDrCmdInternal->Cmd.fFlags.bSetVisibleRects = 1;
504 pDrCmdInternal->hSwapchainUm = pSwapchain->hSwapchainUm;
505
506 vboxVideoCmCmdRetain(pDrCmdInternal);
507 pSwapchain->pLastReportedRects = pDrCmdInternal;
508 vboxVideoCmCmdSubmit(pDrCmdInternal, VBOXVIDEOCM_SUBMITSIZE_DEFAULT);
509 }
510 else
511 {
512 if (!pCmdInternal)
513 pCmdInternal = pDrCmdInternal;
514 else
515 vboxVideoCmCmdRelease(pDrCmdInternal);
516 }
517 }
518 }
519 ExReleaseFastMutex(&pDevExt->ContextMutex);
520
521
522 if (pCmdInternal)
523 vboxVideoCmCmdRelease(pCmdInternal);
524
525 return Status;
526}
527
528static NTSTATUS vboxVdmaGgDmaColorFill(PVBOXVDMAPIPE_CMD_DMACMD_CLRFILL pCF)
529{
530 NTSTATUS Status = STATUS_UNSUCCESSFUL;
531 PVBOXWDDM_CONTEXT pContext = pCF->Hdr.DdiCmd.pContext;
532 PDEVICE_EXTENSION pDevExt = pContext->pDevice->pAdapter;
533 Assert (pDevExt->pvVisibleVram);
534 if (pDevExt->pvVisibleVram)
535 {
536 PVBOXWDDM_ALLOCATION pAlloc = pCF->ClrFill.Alloc.pAlloc;
537 Assert(pAlloc->offVram != VBOXVIDEOOFFSET_VOID);
538 if (pAlloc->offVram != VBOXVIDEOOFFSET_VOID)
539 {
540 RECT UnionRect = {0};
541 uint8_t *pvMem = pDevExt->pvVisibleVram + pAlloc->offVram;
542 UINT bpp = pAlloc->SurfDesc.bpp;
543 Assert(bpp);
544 Assert(((bpp * pAlloc->SurfDesc.width) >> 3) == pAlloc->SurfDesc.pitch);
545 switch (bpp)
546 {
547 case 32:
548 {
549 uint8_t bytestPP = bpp >> 3;
550 for (UINT i = 0; i < pCF->ClrFill.Rects.cRects; ++i)
551 {
552 RECT *pRect = &pCF->ClrFill.Rects.aRects[i];
553 for (LONG ir = pRect->top; ir < pRect->bottom; ++ir)
554 {
555 uint32_t * pvU32Mem = (uint32_t*)(pvMem + (ir * pAlloc->SurfDesc.pitch) + (pRect->left * bytestPP));
556 uint32_t cRaw = pRect->right - pRect->left;
557 Assert(pRect->left >= 0);
558 Assert(pRect->right <= (LONG)pAlloc->SurfDesc.width);
559 Assert(pRect->top >= 0);
560 Assert(pRect->bottom <= (LONG)pAlloc->SurfDesc.height);
561 for (UINT j = 0; j < cRaw; ++j)
562 {
563 *pvU32Mem = pCF->ClrFill.Color;
564 ++pvU32Mem;
565 }
566 }
567 vboxWddmRectUnited(&UnionRect, &UnionRect, pRect);
568 }
569 Status = STATUS_SUCCESS;
570 break;
571 }
572 case 16:
573 case 8:
574 default:
575 AssertBreakpoint();
576 break;
577 }
578
579 if (Status == STATUS_SUCCESS)
580 {
581 if (pAlloc->SurfDesc.VidPnSourceId != D3DDDI_ID_UNINITIALIZED
582 && pAlloc->bAssigned
583#if 0//def VBOXWDDM_RENDER_FROM_SHADOW
584 && pAlloc->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE
585#else
586 && pAlloc->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE
587#endif
588 )
589 {
590 if (!vboxWddmRectIsEmpty(&UnionRect))
591 {
592 PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[pCF->ClrFill.Alloc.pAlloc->SurfDesc.VidPnSourceId];
593 VBOXVBVA_OP_WITHLOCK(ReportDirtyRect, pDevExt, pSource, &UnionRect);
594 }
595 }
596 else
597 {
598 AssertBreakpoint();
599 }
600 }
601 }
602 }
603
604 return Status;
605}
606
607NTSTATUS vboxVdmaGgDmaBltPerform(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_ALLOCATION pSrcAlloc, RECT* pSrcRect,
608 PVBOXWDDM_ALLOCATION pDstAlloc, RECT* pDstRect)
609{
610 uint8_t* pvVramBase = pDevExt->pvVisibleVram;
611 /* we do not support color conversion */
612 Assert(pSrcAlloc->SurfDesc.format == pDstAlloc->SurfDesc.format);
613 /* we do not support stretching */
614 uint32_t srcWidth = pSrcRect->right - pSrcRect->left;
615 uint32_t srcHeight = pSrcRect->bottom - pSrcRect->top;
616 uint32_t dstWidth = pDstRect->right - pDstRect->left;
617 uint32_t dstHeight = pDstRect->bottom - pDstRect->top;
618 Assert(srcHeight == dstHeight);
619 Assert(dstWidth == srcWidth);
620 Assert(pDstAlloc->offVram != VBOXVIDEOOFFSET_VOID);
621 Assert(pSrcAlloc->offVram != VBOXVIDEOOFFSET_VOID);
622
623 if (pSrcAlloc->SurfDesc.format != pDstAlloc->SurfDesc.format)
624 return STATUS_INVALID_PARAMETER;
625 if (srcHeight != dstHeight)
626 return STATUS_INVALID_PARAMETER;
627 if (srcWidth != dstWidth)
628 return STATUS_INVALID_PARAMETER;
629 if (pDstAlloc->offVram == VBOXVIDEOOFFSET_VOID)
630 return STATUS_INVALID_PARAMETER;
631 if (pSrcAlloc->offVram == VBOXVIDEOOFFSET_VOID)
632 return STATUS_INVALID_PARAMETER;
633
634 uint8_t *pvDstSurf = pvVramBase + pDstAlloc->offVram;
635 uint8_t *pvSrcSurf = pvVramBase + pSrcAlloc->offVram;
636
637 if (pDstAlloc->SurfDesc.width == dstWidth
638 && pSrcAlloc->SurfDesc.width == srcWidth
639 && pSrcAlloc->SurfDesc.width == pDstAlloc->SurfDesc.width)
640 {
641 Assert(!pDstRect->left);
642 Assert(!pSrcRect->left);
643 uint32_t cbOff = pDstAlloc->SurfDesc.pitch * pDstRect->top;
644 uint32_t cbSize = pDstAlloc->SurfDesc.pitch * dstHeight;
645 memcpy(pvDstSurf + cbOff, pvSrcSurf + cbOff, cbSize);
646 }
647 else
648 {
649 uint32_t offDstLineStart = pDstRect->left * pDstAlloc->SurfDesc.bpp >> 3;
650 uint32_t offDstLineEnd = ((pDstRect->left * pDstAlloc->SurfDesc.bpp + 7) >> 3) + ((pDstAlloc->SurfDesc.bpp * dstWidth + 7) >> 3);
651 uint32_t cbDstLine = offDstLineEnd - offDstLineStart;
652 uint32_t offDstStart = pDstAlloc->SurfDesc.pitch * pDstRect->top + offDstLineStart;
653 Assert(cbDstLine <= pDstAlloc->SurfDesc.pitch);
654 uint32_t cbDstSkip = pDstAlloc->SurfDesc.pitch;
655 uint8_t * pvDstStart = pvDstSurf + offDstStart;
656
657 uint32_t offSrcLineStart = pSrcRect->left * pSrcAlloc->SurfDesc.bpp >> 3;
658 uint32_t offSrcLineEnd = ((pSrcRect->left * pSrcAlloc->SurfDesc.bpp + 7) >> 3) + ((pSrcAlloc->SurfDesc.bpp * srcWidth + 7) >> 3);
659 uint32_t cbSrcLine = offSrcLineEnd - offSrcLineStart;
660 uint32_t offSrcStart = pSrcAlloc->SurfDesc.pitch * pSrcRect->top + offSrcLineStart;
661 Assert(cbSrcLine <= pSrcAlloc->SurfDesc.pitch);
662 uint32_t cbSrcSkip = pSrcAlloc->SurfDesc.pitch;
663 const uint8_t * pvSrcStart = pvSrcSurf + offSrcStart;
664
665 Assert(cbDstLine == cbSrcLine);
666
667 for (uint32_t i = 0; ; ++i)
668 {
669 memcpy (pvDstStart, pvSrcStart, cbDstLine);
670 if (i == dstHeight)
671 break;
672 pvDstStart += cbDstSkip;
673 pvSrcStart += cbSrcSkip;
674 }
675 }
676 return STATUS_SUCCESS;
677}
678
679/*
680 * @return on success the number of bytes the command contained, otherwise - VERR_xxx error code
681 */
682static NTSTATUS vboxVdmaGgDmaBlt(PVBOXVDMAPIPE_CMD_DMACMD_BLT pBlt)
683{
684 /* we do not support stretching for now */
685 Assert(pBlt->Blt.SrcRect.right - pBlt->Blt.SrcRect.left == pBlt->Blt.DstRects.ContextRect.right - pBlt->Blt.DstRects.ContextRect.left);
686 Assert(pBlt->Blt.SrcRect.bottom - pBlt->Blt.SrcRect.top == pBlt->Blt.DstRects.ContextRect.bottom - pBlt->Blt.DstRects.ContextRect.top);
687 if (pBlt->Blt.SrcRect.right - pBlt->Blt.SrcRect.left != pBlt->Blt.DstRects.ContextRect.right - pBlt->Blt.DstRects.ContextRect.left)
688 return STATUS_INVALID_PARAMETER;
689 if (pBlt->Blt.SrcRect.bottom - pBlt->Blt.SrcRect.top != pBlt->Blt.DstRects.ContextRect.bottom - pBlt->Blt.DstRects.ContextRect.top)
690 return STATUS_INVALID_PARAMETER;
691 Assert(pBlt->Blt.DstRects.UpdateRects.cRects);
692
693 NTSTATUS Status = STATUS_SUCCESS;
694 PDEVICE_EXTENSION pDevExt = pBlt->Hdr.pDevExt;
695
696 if (pBlt->Blt.DstRects.UpdateRects.cRects)
697 {
698 for (uint32_t i = 0; i < pBlt->Blt.DstRects.UpdateRects.cRects; ++i)
699 {
700 RECT DstRect;
701 RECT SrcRect;
702 vboxWddmRectTranslated(&DstRect, &pBlt->Blt.DstRects.UpdateRects.aRects[i], pBlt->Blt.DstRects.ContextRect.left, pBlt->Blt.DstRects.ContextRect.top);
703 vboxWddmRectTranslated(&SrcRect, &pBlt->Blt.DstRects.UpdateRects.aRects[i], pBlt->Blt.SrcRect.left, pBlt->Blt.SrcRect.top);
704
705 Status = vboxVdmaGgDmaBltPerform(pDevExt, pBlt->Blt.SrcAlloc.pAlloc, &SrcRect,
706 pBlt->Blt.DstAlloc.pAlloc, &DstRect);
707 Assert(Status == STATUS_SUCCESS);
708 if (Status != STATUS_SUCCESS)
709 return Status;
710 }
711 }
712 else
713 {
714 Status = vboxVdmaGgDmaBltPerform(pDevExt, pBlt->Blt.SrcAlloc.pAlloc, &pBlt->Blt.SrcRect,
715 pBlt->Blt.DstAlloc.pAlloc, &pBlt->Blt.DstRects.ContextRect);
716 Assert(Status == STATUS_SUCCESS);
717 if (Status != STATUS_SUCCESS)
718 return Status;
719 }
720
721 return Status;
722}
723
724static VOID vboxWddmBltPipeRectsTranslate(VBOXVDMAPIPE_RECTS *pRects, int x, int y)
725{
726 vboxWddmRectTranslate(&pRects->ContextRect, x, y);
727
728 for (UINT i = 0; i < pRects->UpdateRects.cRects; ++i)
729 {
730 vboxWddmRectTranslate(&pRects->UpdateRects.aRects[i], x, y);
731 }
732}
733
734static NTSTATUS vboxVdmaGgDmaCmdProcess(VBOXVDMAPIPE_CMD_DMACMD *pDmaCmd)
735{
736 PDEVICE_EXTENSION pDevExt = pDmaCmd->pDevExt;
737 PVBOXWDDM_CONTEXT pContext = pDmaCmd->DdiCmd.pContext;
738 NTSTATUS Status = STATUS_SUCCESS;
739 DXGK_INTERRUPT_TYPE enmComplType = DXGK_INTERRUPT_DMA_COMPLETED;
740 switch (pDmaCmd->enmCmd)
741 {
742 case VBOXVDMACMD_TYPE_DMA_PRESENT_BLT:
743 {
744 PVBOXVDMAPIPE_CMD_DMACMD_BLT pBlt = (PVBOXVDMAPIPE_CMD_DMACMD_BLT)pDmaCmd;
745 PVBOXWDDM_ALLOCATION pDstAlloc = pBlt->Blt.DstAlloc.pAlloc;
746 PVBOXWDDM_ALLOCATION pSrcAlloc = pBlt->Blt.SrcAlloc.pAlloc;
747 BOOLEAN bComplete = TRUE;
748 switch (pDstAlloc->enmType)
749 {
750 case VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE:
751 case VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC:
752 {
753 if (pDstAlloc->bAssigned)
754 {
755 VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[pDstAlloc->SurfDesc.VidPnSourceId];
756 Assert(pSource->pPrimaryAllocation == pDstAlloc);
757 switch (pSrcAlloc->enmType)
758 {
759 case VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE:
760 {
761 Assert(pContext->enmType == VBOXWDDM_CONTEXT_TYPE_SYSTEM);
762
763 if (pBlt->Hdr.fFlags.b2DRelated || pBlt->Hdr.fFlags.b3DRelated)
764 {
765 POINT pos;
766 BOOLEAN bPosMoved = FALSE;
767 if (pBlt->Hdr.fFlags.b3DRelated)
768 {
769 pos = pSource->VScreenPos;
770 if (pos.x || pos.y)
771 {
772 vboxWddmBltPipeRectsTranslate(&pBlt->Blt.DstRects, pos.x, pos.y);
773 bPosMoved = TRUE;
774 }
775 Status = vboxVdmaGgDirtyRectsProcess(pDevExt, pContext, NULL, &pBlt->Blt.DstRects);
776 Assert(Status == STATUS_SUCCESS);
777 }
778
779
780 if (pBlt->Hdr.fFlags.b2DRelated)
781 {
782 if (bPosMoved)
783 {
784 vboxWddmBltPipeRectsTranslate(&pBlt->Blt.DstRects, -pos.x, -pos.y);
785 }
786
787 RECT OverlayUnionRect;
788 RECT UpdateRect;
789 UpdateRect = pBlt->Blt.DstRects.UpdateRects.aRects[0];
790 for (UINT i = 1; i < pBlt->Blt.DstRects.UpdateRects.cRects; ++i)
791 {
792 vboxWddmRectUnite(&UpdateRect, &pBlt->Blt.DstRects.UpdateRects.aRects[i]);
793 }
794 vboxVhwaHlpOverlayDstRectUnion(pDevExt, pDstAlloc->SurfDesc.VidPnSourceId, &OverlayUnionRect);
795 Assert(pBlt->Blt.DstRects.ContextRect.left == 0); /* <-| otherwise we would probably need to translate the UpdateRects to left;top first??*/
796 Assert(pBlt->Blt.DstRects.ContextRect.top == 0); /* <--| */
797 vboxVdmaDirtyRectsCalcIntersection(&OverlayUnionRect, &pBlt->Blt.DstRects.UpdateRects, &pBlt->Blt.DstRects.UpdateRects);
798 if (pBlt->Blt.DstRects.UpdateRects.cRects)
799 {
800 vboxVdmaGgDmaBlt(pBlt);
801 }
802 VBOXVBVA_OP_WITHLOCK(ReportDirtyRect, pDevExt, pSource, &UpdateRect);
803 }
804 }
805
806 break;
807 }
808 case VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC:
809 {
810 Assert(pContext->enmType == VBOXWDDM_CONTEXT_TYPE_CUSTOM_3D);
811 Assert(pSrcAlloc->fRcFlags.RenderTarget);
812 if (pSrcAlloc->fRcFlags.RenderTarget)
813 {
814 if (pBlt->Hdr.fFlags.b3DRelated)
815 {
816 PVBOXWDDM_SWAPCHAIN pSwapchain;
817 pSwapchain = vboxWddmSwapchainRetainByAlloc(pDevExt, pSrcAlloc);
818 if (pSwapchain)
819 {
820 Status = vboxVdmaGgDirtyRectsProcess(pDevExt, pContext, pSwapchain, &pBlt->Blt.DstRects);
821 Assert(Status == STATUS_SUCCESS);
822 vboxWddmSwapchainRelease(pSwapchain);
823 }
824 }
825 }
826 break;
827 }
828 default:
829 AssertBreakpoint();
830 break;
831 }
832 }
833 break;
834 }
835 default:
836 Assert(0);
837 }
838
839 break;
840 }
841 case VBOXVDMACMD_TYPE_DMA_PRESENT_FLIP:
842 {
843 PVBOXVDMAPIPE_CMD_DMACMD_FLIP pFlip = (PVBOXVDMAPIPE_CMD_DMACMD_FLIP)pDmaCmd;
844 Assert(pFlip->Hdr.fFlags.b3DRelated);
845 Assert(!pFlip->Hdr.fFlags.bDecVBVAUnlock);
846 Assert(!pFlip->Hdr.fFlags.b2DRelated);
847 PVBOXWDDM_ALLOCATION pAlloc = pFlip->Flip.Alloc.pAlloc;
848 VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[pAlloc->SurfDesc.VidPnSourceId];
849 if (pFlip->Hdr.fFlags.b3DRelated)
850 {
851 PVBOXWDDM_SWAPCHAIN pSwapchain;
852 pSwapchain = vboxWddmSwapchainRetainByAlloc(pDevExt, pAlloc);
853 if (pSwapchain)
854 {
855 POINT pos = pSource->VScreenPos;
856 VBOXVDMAPIPE_RECTS Rects;
857 Rects.ContextRect.left = pos.x;
858 Rects.ContextRect.top = pos.y;
859 Rects.ContextRect.right = pAlloc->SurfDesc.width + pos.x;
860 Rects.ContextRect.bottom = pAlloc->SurfDesc.height + pos.y;
861 Rects.UpdateRects.cRects = 1;
862 Rects.UpdateRects.aRects[0] = Rects.ContextRect;
863 Status = vboxVdmaGgDirtyRectsProcess(pDevExt, pContext, pSwapchain, &Rects);
864 Assert(Status == STATUS_SUCCESS);
865 vboxWddmSwapchainRelease(pSwapchain);
866 }
867 }
868
869 break;
870 }
871 case VBOXVDMACMD_TYPE_DMA_PRESENT_CLRFILL:
872 {
873 PVBOXVDMAPIPE_CMD_DMACMD_CLRFILL pCF = (PVBOXVDMAPIPE_CMD_DMACMD_CLRFILL)pDmaCmd;
874 Assert(pCF->Hdr.fFlags.b2DRelated);
875 Assert(pCF->Hdr.fFlags.bDecVBVAUnlock);
876 Assert(!pCF->Hdr.fFlags.b3DRelated);
877 Status = vboxVdmaGgDmaColorFill(pCF);
878 Assert(Status == STATUS_SUCCESS);
879 break;
880 }
881 default:
882 Assert(0);
883 break;
884 }
885
886 if (pDmaCmd->fFlags.bDecVBVAUnlock)
887 {
888 uint32_t cNew = ASMAtomicDecU32(&pDevExt->cUnlockedVBVADisabled);
889 Assert(cNew < UINT32_MAX/2);
890 }
891
892 Status = vboxVdmaDdiCmdCompleted(pDevExt, &pDevExt->DdiCmdQueue, &pDmaCmd->DdiCmd, enmComplType);
893 Assert(Status == STATUS_SUCCESS);
894
895 return Status;
896}
897
898static VOID vboxVdmaGgWorkerThread(PVOID pvUser)
899{
900 PVBOXVDMAGG pVdma = (PVBOXVDMAGG)pvUser;
901
902 NTSTATUS Status = vboxVdmaPipeSvrOpen(&pVdma->CmdPipe);
903 Assert(Status == STATUS_SUCCESS);
904 if (Status == STATUS_SUCCESS)
905 {
906 do
907 {
908 LIST_ENTRY CmdList;
909 Status = vboxVdmaPipeSvrCmdGetList(&pVdma->CmdPipe, &CmdList);
910 Assert(Status == STATUS_SUCCESS || Status == STATUS_PIPE_CLOSING);
911 if (Status == STATUS_SUCCESS)
912 {
913 for (PLIST_ENTRY pCur = CmdList.Blink; pCur != &CmdList;)
914 {
915 PVBOXVDMAPIPE_CMD_DR pDr = VBOXVDMAPIPE_CMD_DR_FROM_ENTRY(pCur);
916 RemoveEntryList(pCur);
917 pCur = CmdList.Blink;
918 switch (pDr->enmType)
919 {
920#if 0
921 case VBOXVDMAPIPE_CMD_TYPE_RECTSINFO:
922 {
923 PVBOXVDMAPIPE_CMD_RECTSINFO pRects = (PVBOXVDMAPIPE_CMD_RECTSINFO)pDr;
924 Status = vboxVdmaGgDirtyRectsProcess(pRects);
925 Assert(Status == STATUS_SUCCESS);
926 vboxVdmaGgCmdDestroy(pDr);
927 break;
928 }
929#endif
930 case VBOXVDMAPIPE_CMD_TYPE_DMACMD:
931 {
932 PVBOXVDMAPIPE_CMD_DMACMD pDmaCmd = (PVBOXVDMAPIPE_CMD_DMACMD)pDr;
933 Status = vboxVdmaGgDmaCmdProcess(pDmaCmd);
934 Assert(Status == STATUS_SUCCESS);
935 } break;
936 case VBOXVDMAPIPE_CMD_TYPE_RECTSINFO:
937 {
938 PVBOXVDMAPIPE_CMD_RECTSINFO pRects = (PVBOXVDMAPIPE_CMD_RECTSINFO)pDr;
939 Status = vboxVdmaGgDirtyRectsProcess(pRects->pDevExt, pRects->pContext, pRects->pSwapchain, &pRects->ContextsRects);
940 Assert(Status == STATUS_SUCCESS);
941 vboxVdmaGgCmdDestroy(pDr);
942 break;
943 }
944 default:
945 AssertBreakpoint();
946 }
947 }
948 }
949 else
950 break;
951 } while (1);
952 }
953
954 /* always try to close the pipe to make sure the client side is notified */
955 Status = vboxVdmaPipeSvrClose(&pVdma->CmdPipe);
956 Assert(Status == STATUS_SUCCESS);
957}
958
959NTSTATUS vboxVdmaGgConstruct(PVBOXVDMAGG pVdma)
960{
961 NTSTATUS Status = vboxVdmaPipeConstruct(&pVdma->CmdPipe);
962 Assert(Status == STATUS_SUCCESS);
963 if (Status == STATUS_SUCCESS)
964 {
965 Status = vboxVdmaGgThreadCreate(&pVdma->pThread, vboxVdmaGgWorkerThread, pVdma);
966 Assert(Status == STATUS_SUCCESS);
967 if (Status == STATUS_SUCCESS)
968 return STATUS_SUCCESS;
969
970 NTSTATUS tmpStatus = vboxVdmaPipeDestruct(&pVdma->CmdPipe);
971 Assert(tmpStatus == STATUS_SUCCESS);
972 }
973
974 /* we're here ONLY in case of an error */
975 Assert(Status != STATUS_SUCCESS);
976 return Status;
977}
978
979NTSTATUS vboxVdmaGgDestruct(PVBOXVDMAGG pVdma)
980{
981 /* this informs the server thread that it should complete all current commands and exit */
982 NTSTATUS Status = vboxVdmaPipeCltClose(&pVdma->CmdPipe);
983 Assert(Status == STATUS_SUCCESS);
984 if (Status == STATUS_SUCCESS)
985 {
986 Status = KeWaitForSingleObject(pVdma->pThread, Executive, KernelMode, FALSE, NULL /* PLARGE_INTEGER Timeout */);
987 Assert(Status == STATUS_SUCCESS);
988 if (Status == STATUS_SUCCESS)
989 {
990 Status = vboxVdmaPipeDestruct(&pVdma->CmdPipe);
991 Assert(Status == STATUS_SUCCESS);
992 }
993 }
994
995 return Status;
996}
997
998NTSTATUS vboxVdmaGgCmdSubmit(PVBOXVDMAGG pVdma, PVBOXVDMAPIPE_CMD_DR pCmd)
999{
1000 return vboxVdmaPipeCltCmdPut(&pVdma->CmdPipe, &pCmd->PipeHdr);
1001}
1002
1003/* end */
1004
1005#ifdef VBOX_WITH_VDMA
1006/*
1007 * This is currently used by VDMA. It is invisible for Vdma API clients since
1008 * Vdma transport may change if we choose to use another (e.g. more light-weight)
1009 * transport for DMA commands submission
1010 */
1011
1012#ifdef VBOXVDMA_WITH_VBVA
1013static int vboxWddmVdmaSubmitVbva(struct _DEVICE_EXTENSION* pDevExt, PVBOXVDMAINFO pInfo, HGSMIOFFSET offDr)
1014{
1015 int rc;
1016 if (vboxVbvaBufferBeginUpdate (pDevExt, &pDevExt->u.primary.Vbva))
1017 {
1018 rc = vboxVbvaReportCmdOffset(pDevExt, &pDevExt->u.primary.Vbva, offDr);
1019 vboxVbvaBufferEndUpdate (pDevExt, &pDevExt->u.primary.Vbva);
1020 }
1021 else
1022 {
1023 AssertBreakpoint();
1024 rc = VERR_INVALID_STATE;
1025 }
1026 return rc;
1027}
1028#define vboxWddmVdmaSubmit vboxWddmVdmaSubmitVbva
1029#else
1030static int vboxWddmVdmaSubmitHgsmi(struct _DEVICE_EXTENSION* pDevExt, PVBOXVDMAINFO pInfo, HGSMIOFFSET offDr)
1031{
1032 VBoxHGSMIGuestWrite(commonFromDeviceExt(pDevExt), offDr);
1033 return VINF_SUCCESS;
1034}
1035#define vboxWddmVdmaSubmit vboxWddmVdmaSubmitHgsmi
1036#endif
1037
1038static int vboxVdmaInformHost(PDEVICE_EXTENSION pDevExt, PVBOXVDMAINFO pInfo, VBOXVDMA_CTL_TYPE enmCtl)
1039{
1040 int rc = VINF_SUCCESS;
1041
1042 PVBOXVDMA_CTL pCmd = (PVBOXVDMA_CTL)VBoxSHGSMICommandAlloc(&commonFromDeviceExt(pDevExt)->hgsmiAdapterHeap, sizeof (VBOXVDMA_CTL), HGSMI_CH_VBVA, VBVA_VDMA_CTL);
1043 if (pCmd)
1044 {
1045 pCmd->enmCtl = enmCtl;
1046 pCmd->u32Offset = pInfo->CmdHeap.area.offBase;
1047 pCmd->i32Result = VERR_NOT_SUPPORTED;
1048
1049 const VBOXSHGSMIHEADER* pHdr = VBoxSHGSMICommandPrepSynch(&commonFromDeviceExt(pDevExt)->hgsmiAdapterHeap, pCmd);
1050 Assert(pHdr);
1051 if (pHdr)
1052 {
1053 do
1054 {
1055 HGSMIOFFSET offCmd = VBoxSHGSMICommandOffset(&commonFromDeviceExt(pDevExt)->hgsmiAdapterHeap, pHdr);
1056 Assert(offCmd != HGSMIOFFSET_VOID);
1057 if (offCmd != HGSMIOFFSET_VOID)
1058 {
1059 rc = vboxWddmVdmaSubmit(pDevExt, pInfo, offCmd);
1060 AssertRC(rc);
1061 if (RT_SUCCESS(rc))
1062 {
1063 rc = VBoxSHGSMICommandDoneSynch(&commonFromDeviceExt(pDevExt)->hgsmiAdapterHeap, pHdr);
1064 AssertRC(rc);
1065 if (RT_SUCCESS(rc))
1066 {
1067 rc = pCmd->i32Result;
1068 AssertRC(rc);
1069 }
1070 break;
1071 }
1072 }
1073 else
1074 rc = VERR_INVALID_PARAMETER;
1075 /* fail to submit, cancel it */
1076 VBoxSHGSMICommandCancelSynch(&commonFromDeviceExt(pDevExt)->hgsmiAdapterHeap, pHdr);
1077 } while (0);
1078 }
1079
1080 VBoxSHGSMICommandFree (&commonFromDeviceExt(pDevExt)->hgsmiAdapterHeap, pCmd);
1081 }
1082 else
1083 {
1084 drprintf((__FUNCTION__": HGSMIHeapAlloc failed\n"));
1085 rc = VERR_OUT_OF_RESOURCES;
1086 }
1087
1088 return rc;
1089}
1090#endif
1091
1092/* create a DMACommand buffer */
1093int vboxVdmaCreate(PDEVICE_EXTENSION pDevExt, VBOXVDMAINFO *pInfo
1094#ifdef VBOX_WITH_VDMA
1095 , ULONG offBuffer, ULONG cbBuffer
1096#endif
1097 )
1098{
1099 int rc;
1100 pInfo->fEnabled = FALSE;
1101
1102#ifdef VBOX_WITH_VDMA
1103 KeInitializeSpinLock(&pInfo->HeapLock);
1104 Assert((offBuffer & 0xfff) == 0);
1105 Assert((cbBuffer & 0xfff) == 0);
1106 Assert(offBuffer);
1107 Assert(cbBuffer);
1108
1109 if((offBuffer & 0xfff)
1110 || (cbBuffer & 0xfff)
1111 || !offBuffer
1112 || !cbBuffer)
1113 {
1114 drprintf((__FUNCTION__": invalid parameters: offBuffer(0x%x), cbBuffer(0x%x)", offBuffer, cbBuffer));
1115 return VERR_INVALID_PARAMETER;
1116 }
1117 PVOID pvBuffer;
1118
1119 rc = VBoxMapAdapterMemory (commonFromDeviceExt(pDevExt),
1120 &pvBuffer,
1121 offBuffer,
1122 cbBuffer);
1123 Assert(RT_SUCCESS(rc));
1124 if (RT_SUCCESS(rc))
1125 {
1126 /* Setup a HGSMI heap within the adapter information area. */
1127 rc = HGSMIHeapSetup (&pInfo->CmdHeap,
1128 pvBuffer,
1129 cbBuffer,
1130 offBuffer,
1131 false /*fOffsetBased*/);
1132 Assert(RT_SUCCESS(rc));
1133 if(RT_SUCCESS(rc))
1134#endif
1135 {
1136 NTSTATUS Status = vboxVdmaGgConstruct(&pInfo->DmaGg);
1137 Assert(Status == STATUS_SUCCESS);
1138 if (Status == STATUS_SUCCESS)
1139 return VINF_SUCCESS;
1140 rc = VERR_GENERAL_FAILURE;
1141 }
1142#ifdef VBOX_WITH_VDMA
1143 else
1144 drprintf((__FUNCTION__": HGSMIHeapSetup failed rc = 0x%x\n", rc));
1145
1146 VBoxUnmapAdapterMemory(commonFromDeviceExt(pDevExt), &pvBuffer);
1147 }
1148 else
1149 drprintf((__FUNCTION__": VBoxMapAdapterMemory failed rc = 0x%x\n", rc));
1150#endif
1151 return rc;
1152}
1153
1154int vboxVdmaDisable (PDEVICE_EXTENSION pDevExt, PVBOXVDMAINFO pInfo)
1155{
1156 dfprintf((__FUNCTION__"\n"));
1157
1158 Assert(pInfo->fEnabled);
1159 if (!pInfo->fEnabled)
1160 return VINF_ALREADY_INITIALIZED;
1161
1162 /* ensure nothing else is submitted */
1163 pInfo->fEnabled = FALSE;
1164#ifdef VBOX_WITH_VDMA
1165 int rc = vboxVdmaInformHost (pDevExt, pInfo, VBOXVDMA_CTL_TYPE_DISABLE);
1166 AssertRC(rc);
1167 return rc;
1168#else
1169 return VINF_SUCCESS;
1170#endif
1171}
1172
1173int vboxVdmaEnable (PDEVICE_EXTENSION pDevExt, PVBOXVDMAINFO pInfo)
1174{
1175 dfprintf((__FUNCTION__"\n"));
1176
1177 Assert(!pInfo->fEnabled);
1178 if (pInfo->fEnabled)
1179 return VINF_ALREADY_INITIALIZED;
1180#ifdef VBOX_WITH_VDMA
1181 int rc = vboxVdmaInformHost (pDevExt, pInfo, VBOXVDMA_CTL_TYPE_ENABLE);
1182 Assert(RT_SUCCESS(rc));
1183 if (RT_SUCCESS(rc))
1184 pInfo->fEnabled = TRUE;
1185
1186 return rc;
1187#else
1188 return VINF_SUCCESS;
1189#endif
1190}
1191
1192#ifdef VBOX_WITH_VDMA
1193int vboxVdmaFlush (PDEVICE_EXTENSION pDevExt, PVBOXVDMAINFO pInfo)
1194{
1195 dfprintf((__FUNCTION__"\n"));
1196
1197 Assert(pInfo->fEnabled);
1198 if (!pInfo->fEnabled)
1199 return VINF_ALREADY_INITIALIZED;
1200
1201 int rc = vboxVdmaInformHost (pDevExt, pInfo, VBOXVDMA_CTL_TYPE_FLUSH);
1202 Assert(RT_SUCCESS(rc));
1203
1204 return rc;
1205}
1206#endif
1207
1208int vboxVdmaDestroy (PDEVICE_EXTENSION pDevExt, PVBOXVDMAINFO pInfo)
1209{
1210 int rc = VINF_SUCCESS;
1211 NTSTATUS Status = vboxVdmaGgDestruct(&pInfo->DmaGg);
1212 Assert(Status == STATUS_SUCCESS);
1213 if (Status == STATUS_SUCCESS)
1214 {
1215 Assert(!pInfo->fEnabled);
1216 if (pInfo->fEnabled)
1217 rc = vboxVdmaDisable (pDevExt, pInfo);
1218#ifdef VBOX_WITH_VDMA
1219 VBoxUnmapAdapterMemory (commonFromDeviceExt(pDevExt), (void**)&pInfo->CmdHeap.area.pu8Base);
1220#endif
1221 }
1222 else
1223 rc = VERR_GENERAL_FAILURE;
1224 return rc;
1225}
1226
1227#ifdef VBOX_WITH_VDMA
1228void vboxVdmaCBufDrFree (PVBOXVDMAINFO pInfo, PVBOXVDMACBUF_DR pDr)
1229{
1230 KIRQL OldIrql;
1231 KeAcquireSpinLock(&pInfo->HeapLock, &OldIrql);
1232 VBoxSHGSMICommandFree (&pInfo->CmdHeap, pDr);
1233 KeReleaseSpinLock(&pInfo->HeapLock, OldIrql);
1234}
1235
1236PVBOXVDMACBUF_DR vboxVdmaCBufDrCreate (PVBOXVDMAINFO pInfo, uint32_t cbTrailingData)
1237{
1238 uint32_t cbDr = VBOXVDMACBUF_DR_SIZE(cbTrailingData);
1239 KIRQL OldIrql;
1240 KeAcquireSpinLock(&pInfo->HeapLock, &OldIrql);
1241 PVBOXVDMACBUF_DR pDr = (PVBOXVDMACBUF_DR)VBoxSHGSMICommandAlloc (&pInfo->CmdHeap, cbDr, HGSMI_CH_VBVA, VBVA_VDMA_CMD);
1242 KeReleaseSpinLock(&pInfo->HeapLock, OldIrql);
1243 Assert(pDr);
1244 if (pDr)
1245 memset (pDr, 0, cbDr);
1246 else
1247 drprintf((__FUNCTION__": VBoxSHGSMICommandAlloc returned NULL\n"));
1248
1249 return pDr;
1250}
1251
1252static DECLCALLBACK(void) vboxVdmaCBufDrCompletion(struct _HGSMIHEAP * pHeap, void *pvCmd, void *pvContext)
1253{
1254 PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION)pvContext;
1255 PVBOXVDMAINFO pInfo = &pDevExt->u.primary.Vdma;
1256
1257 vboxVdmaCBufDrFree (pInfo, (PVBOXVDMACBUF_DR)pvCmd);
1258}
1259
1260static DECLCALLBACK(void) vboxVdmaCBufDrCompletionIrq(struct _HGSMIHEAP * pHeap, void *pvCmd, void *pvContext,
1261 PFNVBOXSHGSMICMDCOMPLETION *ppfnCompletion, void **ppvCompletion)
1262{
1263 PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION)pvContext;
1264 PVBOXVDMAINFO pVdma = &pDevExt->u.primary.Vdma;
1265 PVBOXVDMACBUF_DR pDr = (PVBOXVDMACBUF_DR)pvCmd;
1266
1267 DXGK_INTERRUPT_TYPE enmComplType;
1268
1269 if (RT_SUCCESS(pDr->rc))
1270 {
1271 enmComplType = DXGK_INTERRUPT_DMA_COMPLETED;
1272 }
1273 else if (pDr->rc == VERR_INTERRUPTED)
1274 {
1275 Assert(0);
1276 enmComplType = DXGK_INTERRUPT_DMA_PREEMPTED;
1277 }
1278 else
1279 {
1280 Assert(0);
1281 enmComplType = DXGK_INTERRUPT_DMA_FAULTED;
1282 }
1283
1284 if (vboxVdmaDdiCmdCompletedIrq(pDevExt, &pDevExt->DdiCmdQueue, VBOXVDMADDI_CMD_FROM_BUF_DR(pDr), enmComplType))
1285 {
1286 pDevExt->bNotifyDxDpc = TRUE;
1287 }
1288
1289 /* inform SHGSMI we DO NOT want to be called at DPC later */
1290 *ppfnCompletion = NULL;
1291// *ppvCompletion = pvContext;
1292}
1293
1294int vboxVdmaCBufDrSubmit(PDEVICE_EXTENSION pDevExt, PVBOXVDMAINFO pInfo, PVBOXVDMACBUF_DR pDr)
1295{
1296 const VBOXSHGSMIHEADER* pHdr = VBoxSHGSMICommandPrepAsynchIrq (&pInfo->CmdHeap, pDr, vboxVdmaCBufDrCompletionIrq, pDevExt, VBOXSHGSMI_FLAG_GH_ASYNCH_FORCE);
1297 Assert(pHdr);
1298 int rc = VERR_GENERAL_FAILURE;
1299 if (pHdr)
1300 {
1301 do
1302 {
1303 HGSMIOFFSET offCmd = VBoxSHGSMICommandOffset(&pInfo->CmdHeap, pHdr);
1304 Assert(offCmd != HGSMIOFFSET_VOID);
1305 if (offCmd != HGSMIOFFSET_VOID)
1306 {
1307 rc = vboxWddmVdmaSubmit(pDevExt, pInfo, offCmd);
1308 AssertRC(rc);
1309 if (RT_SUCCESS(rc))
1310 {
1311 VBoxSHGSMICommandDoneAsynch(&pInfo->CmdHeap, pHdr);
1312 AssertRC(rc);
1313 break;
1314 }
1315 }
1316 else
1317 rc = VERR_INVALID_PARAMETER;
1318 /* fail to submit, cancel it */
1319 VBoxSHGSMICommandCancelAsynch(&pInfo->CmdHeap, pHdr);
1320 } while (0);
1321 }
1322 else
1323 rc = VERR_INVALID_PARAMETER;
1324 return rc;
1325}
1326
1327int vboxVdmaCBufDrSubmitSynch(PDEVICE_EXTENSION pDevExt, PVBOXVDMAINFO pInfo, PVBOXVDMACBUF_DR pDr)
1328{
1329 const VBOXSHGSMIHEADER* pHdr = VBoxSHGSMICommandPrepAsynch (&pInfo->CmdHeap, pDr, NULL, NULL, VBOXSHGSMI_FLAG_GH_SYNCH);
1330 Assert(pHdr);
1331 int rc = VERR_GENERAL_FAILURE;
1332 if (pHdr)
1333 {
1334 do
1335 {
1336 HGSMIOFFSET offCmd = VBoxSHGSMICommandOffset(&pInfo->CmdHeap, pHdr);
1337 Assert(offCmd != HGSMIOFFSET_VOID);
1338 if (offCmd != HGSMIOFFSET_VOID)
1339 {
1340 rc = vboxWddmVdmaSubmit(pDevExt, pInfo, offCmd);
1341 AssertRC(rc);
1342 if (RT_SUCCESS(rc))
1343 {
1344 VBoxSHGSMICommandDoneAsynch(&pInfo->CmdHeap, pHdr);
1345 AssertRC(rc);
1346 break;
1347 }
1348 }
1349 else
1350 rc = VERR_INVALID_PARAMETER;
1351 /* fail to submit, cancel it */
1352 VBoxSHGSMICommandCancelAsynch(&pInfo->CmdHeap, pHdr);
1353 } while (0);
1354 }
1355 else
1356 rc = VERR_INVALID_PARAMETER;
1357 return rc;
1358}
1359#endif
1360
1361
1362/* ddi dma command queue */
1363DECLINLINE(BOOLEAN) vboxVdmaDdiCmdCanComplete(PVBOXVDMADDI_CMD_QUEUE pQueue)
1364{
1365 return ASMAtomicUoReadU32(&pQueue->cQueuedCmds) == 0;
1366}
1367
1368DECLCALLBACK(VOID) vboxVdmaDdiCmdCompletionCbFree(PDEVICE_EXTENSION pDevExt, PVBOXVDMADDI_CMD pCmd, PVOID pvContext)
1369{
1370 vboxWddmMemFree(pCmd);
1371}
1372
1373static VOID vboxVdmaDdiCmdNotifyCompletedIrq(PDEVICE_EXTENSION pDevExt, PVBOXVDMADDI_CMD_QUEUE pQueue, PVBOXVDMADDI_CMD pCmd, DXGK_INTERRUPT_TYPE enmComplType)
1374{
1375 DXGKARGCB_NOTIFY_INTERRUPT_DATA notify;
1376 memset(&notify, 0, sizeof(DXGKARGCB_NOTIFY_INTERRUPT_DATA));
1377 switch (enmComplType)
1378 {
1379 case DXGK_INTERRUPT_DMA_COMPLETED:
1380 notify.InterruptType = DXGK_INTERRUPT_DMA_COMPLETED;
1381 notify.DmaCompleted.SubmissionFenceId = pCmd->u32FenceId;
1382// if (pCmd->pContext)
1383// {
1384// notify.DmaCompleted.NodeOrdinal = pCmd->pContext->NodeOrdinal;
1385// pCmd->pContext->uLastCompletedCmdFenceId = pCmd->u32FenceId;
1386// }
1387// else
1388 {
1389 pDevExt->u.primary.Vdma.uLastCompletedPagingBufferCmdFenceId = pCmd->u32FenceId;
1390 }
1391
1392 InsertTailList(&pQueue->DpcCmdQueue, &pCmd->QueueEntry);
1393
1394 break;
1395 case DXGK_INTERRUPT_DMA_PREEMPTED:
1396 Assert(0);
1397 notify.InterruptType = DXGK_INTERRUPT_DMA_PREEMPTED;
1398 notify.DmaPreempted.PreemptionFenceId = pCmd->u32FenceId;
1399// if (pCmd->pContext)
1400// {
1401// notify.DmaPreempted.LastCompletedFenceId = pCmd->pContext->uLastCompletedCmdFenceId;
1402// notify.DmaPreempted.NodeOrdinal = pCmd->pContext->NodeOrdinal;
1403// }
1404// else
1405 {
1406 notify.DmaPreempted.LastCompletedFenceId = pDevExt->u.primary.Vdma.uLastCompletedPagingBufferCmdFenceId;
1407 }
1408 break;
1409
1410 case DXGK_INTERRUPT_DMA_FAULTED:
1411 Assert(0);
1412 notify.InterruptType = DXGK_INTERRUPT_DMA_FAULTED;
1413 notify.DmaFaulted.FaultedFenceId = pCmd->u32FenceId;
1414 notify.DmaFaulted.Status = STATUS_UNSUCCESSFUL; /* @todo: better status ? */
1415 if (pCmd->pContext)
1416 {
1417 notify.DmaFaulted.NodeOrdinal = pCmd->pContext->NodeOrdinal;
1418 }
1419 break;
1420 default:
1421 Assert(0);
1422 break;
1423 }
1424
1425 pDevExt->u.primary.DxgkInterface.DxgkCbNotifyInterrupt(pDevExt->u.primary.DxgkInterface.DeviceHandle, &notify);
1426}
1427
1428DECLINLINE(VOID) vboxVdmaDdiCmdDequeueIrq(PVBOXVDMADDI_CMD_QUEUE pQueue, PVBOXVDMADDI_CMD pCmd)
1429{
1430 ASMAtomicDecU32(&pQueue->cQueuedCmds);
1431 RemoveEntryList(&pCmd->QueueEntry);
1432}
1433
1434DECLINLINE(VOID) vboxVdmaDdiCmdEnqueueIrq(PVBOXVDMADDI_CMD_QUEUE pQueue, PVBOXVDMADDI_CMD pCmd)
1435{
1436 ASMAtomicIncU32(&pQueue->cQueuedCmds);
1437 InsertTailList(&pQueue->CmdQueue, &pCmd->QueueEntry);
1438}
1439
1440VOID vboxVdmaDdiQueueInit(PDEVICE_EXTENSION pDevExt, PVBOXVDMADDI_CMD_QUEUE pQueue)
1441{
1442 pQueue->cQueuedCmds = 0;
1443 InitializeListHead(&pQueue->CmdQueue);
1444 InitializeListHead(&pQueue->DpcCmdQueue);
1445}
1446
1447BOOLEAN vboxVdmaDdiCmdCompletedIrq(PDEVICE_EXTENSION pDevExt, PVBOXVDMADDI_CMD_QUEUE pQueue, PVBOXVDMADDI_CMD pCmd, DXGK_INTERRUPT_TYPE enmComplType)
1448{
1449 if (VBOXVDMADDI_STATE_NOT_DX_CMD == pCmd->enmState)
1450 {
1451 InsertTailList(&pQueue->DpcCmdQueue, &pCmd->QueueEntry);
1452 return FALSE;
1453 }
1454
1455 BOOLEAN bQueued = pCmd->enmState > VBOXVDMADDI_STATE_NOT_QUEUED;
1456 BOOLEAN bComplete = FALSE;
1457 Assert(!bQueued || pQueue->cQueuedCmds);
1458 Assert(!bQueued || !IsListEmpty(&pQueue->CmdQueue));
1459 pCmd->enmState = VBOXVDMADDI_STATE_COMPLETED;
1460 if (bQueued)
1461 {
1462 if (pQueue->CmdQueue.Flink == &pCmd->QueueEntry)
1463 {
1464 vboxVdmaDdiCmdDequeueIrq(pQueue, pCmd);
1465 bComplete = TRUE;
1466 }
1467 }
1468 else if (IsListEmpty(&pQueue->CmdQueue))
1469 {
1470 bComplete = TRUE;
1471 }
1472 else
1473 {
1474 vboxVdmaDdiCmdEnqueueIrq(pQueue, pCmd);
1475 }
1476
1477 if (bComplete)
1478 {
1479 vboxVdmaDdiCmdNotifyCompletedIrq(pDevExt, pQueue, pCmd, enmComplType);
1480
1481 while (!IsListEmpty(&pQueue->CmdQueue))
1482 {
1483 pCmd = VBOXVDMADDI_CMD_FROM_ENTRY(pQueue->CmdQueue.Flink);
1484 if (pCmd->enmState == VBOXVDMADDI_STATE_COMPLETED)
1485 {
1486 vboxVdmaDdiCmdDequeueIrq(pQueue, pCmd);
1487 vboxVdmaDdiCmdNotifyCompletedIrq(pDevExt, pQueue, pCmd, pCmd->enmComplType);
1488 }
1489 else
1490 break;
1491 }
1492 }
1493 else
1494 {
1495 pCmd->enmState = VBOXVDMADDI_STATE_COMPLETED;
1496 pCmd->enmComplType = enmComplType;
1497 }
1498
1499 return bComplete;
1500}
1501
1502VOID vboxVdmaDdiCmdSubmittedIrq(PVBOXVDMADDI_CMD_QUEUE pQueue, PVBOXVDMADDI_CMD pCmd)
1503{
1504 BOOLEAN bQueued = pCmd->enmState >= VBOXVDMADDI_STATE_PENDING;
1505 Assert(pCmd->enmState < VBOXVDMADDI_STATE_SUBMITTED);
1506 pCmd->enmState = VBOXVDMADDI_STATE_SUBMITTED;
1507 if (!bQueued)
1508 vboxVdmaDdiCmdEnqueueIrq(pQueue, pCmd);
1509}
1510
1511typedef struct VBOXVDMADDI_CMD_COMPLETED_CB
1512{
1513 PDEVICE_EXTENSION pDevExt;
1514 PVBOXVDMADDI_CMD_QUEUE pQueue;
1515 PVBOXVDMADDI_CMD pCmd;
1516 DXGK_INTERRUPT_TYPE enmComplType;
1517} VBOXVDMADDI_CMD_COMPLETED_CB, *PVBOXVDMADDI_CMD_COMPLETED_CB;
1518
1519static BOOLEAN vboxVdmaDdiCmdCompletedCb(PVOID Context)
1520{
1521 PVBOXVDMADDI_CMD_COMPLETED_CB pdc = (PVBOXVDMADDI_CMD_COMPLETED_CB)Context;
1522 BOOLEAN bNeedDps = vboxVdmaDdiCmdCompletedIrq(pdc->pDevExt, pdc->pQueue, pdc->pCmd, pdc->enmComplType);
1523 pdc->pDevExt->bNotifyDxDpc |= bNeedDps;
1524
1525 return bNeedDps;
1526}
1527
1528NTSTATUS vboxVdmaDdiCmdCompleted(PDEVICE_EXTENSION pDevExt, PVBOXVDMADDI_CMD_QUEUE pQueue, PVBOXVDMADDI_CMD pCmd, DXGK_INTERRUPT_TYPE enmComplType)
1529{
1530 VBOXVDMADDI_CMD_COMPLETED_CB context;
1531 context.pDevExt = pDevExt;
1532 context.pQueue = pQueue;
1533 context.pCmd = pCmd;
1534 context.enmComplType = enmComplType;
1535 BOOLEAN bNeedDps;
1536 NTSTATUS Status = pDevExt->u.primary.DxgkInterface.DxgkCbSynchronizeExecution(
1537 pDevExt->u.primary.DxgkInterface.DeviceHandle,
1538 vboxVdmaDdiCmdCompletedCb,
1539 &context,
1540 0, /* IN ULONG MessageNumber */
1541 &bNeedDps);
1542 Assert(Status == STATUS_SUCCESS);
1543 if (Status == STATUS_SUCCESS && bNeedDps)
1544 {
1545 BOOLEAN bRc = pDevExt->u.primary.DxgkInterface.DxgkCbQueueDpc(pDevExt->u.primary.DxgkInterface.DeviceHandle);
1546 Assert(bRc);
1547 }
1548 return Status;
1549}
1550
1551typedef struct VBOXVDMADDI_CMD_SUBMITTED_CB
1552{
1553// PDEVICE_EXTENSION pDevExt;
1554 PVBOXVDMADDI_CMD_QUEUE pQueue;
1555 PVBOXVDMADDI_CMD pCmd;
1556} VBOXVDMADDI_CMD_SUBMITTED_CB, *PVBOXVDMADDI_CMD_SUBMITTED_CB;
1557
1558static BOOLEAN vboxVdmaDdiCmdSubmittedCb(PVOID Context)
1559{
1560 PVBOXVDMADDI_CMD_SUBMITTED_CB pdc = (PVBOXVDMADDI_CMD_SUBMITTED_CB)Context;
1561 vboxVdmaDdiCmdSubmittedIrq(pdc->pQueue, pdc->pCmd);
1562
1563 return FALSE;
1564}
1565
1566NTSTATUS vboxVdmaDdiCmdSubmitted(PDEVICE_EXTENSION pDevExt, PVBOXVDMADDI_CMD_QUEUE pQueue, PVBOXVDMADDI_CMD pCmd)
1567{
1568 VBOXVDMADDI_CMD_SUBMITTED_CB context;
1569 context.pQueue = pQueue;
1570 context.pCmd = pCmd;
1571 BOOLEAN bRc;
1572 NTSTATUS Status = pDevExt->u.primary.DxgkInterface.DxgkCbSynchronizeExecution(
1573 pDevExt->u.primary.DxgkInterface.DeviceHandle,
1574 vboxVdmaDdiCmdSubmittedCb,
1575 &context,
1576 0, /* IN ULONG MessageNumber */
1577 &bRc);
1578 Assert(Status == STATUS_SUCCESS);
1579 return Status;
1580}
1581
1582typedef struct VBOXVDMADDI_CMD_COMPLETE_CB
1583{
1584 PDEVICE_EXTENSION pDevExt;
1585 PVBOXWDDM_CONTEXT pContext;
1586 uint32_t u32FenceId;
1587} VBOXVDMADDI_CMD_COMPLETE_CB, *PVBOXVDMADDI_CMD_COMPLETE_CB;
1588
1589static BOOLEAN vboxVdmaDdiCmdFenceCompleteCb(PVOID Context)
1590{
1591 PVBOXVDMADDI_CMD_COMPLETE_CB pdc = (PVBOXVDMADDI_CMD_COMPLETE_CB)Context;
1592 PDEVICE_EXTENSION pDevExt = pdc->pDevExt;
1593 DXGKARGCB_NOTIFY_INTERRUPT_DATA notify;
1594 memset(&notify, 0, sizeof(DXGKARGCB_NOTIFY_INTERRUPT_DATA));
1595
1596 notify.InterruptType = DXGK_INTERRUPT_DMA_COMPLETED;
1597 notify.DmaCompleted.SubmissionFenceId = pdc->u32FenceId;
1598 notify.DmaCompleted.NodeOrdinal = pdc->pContext->NodeOrdinal;
1599 notify.DmaCompleted.EngineOrdinal = 0;
1600
1601 pDevExt->u.primary.DxgkInterface.DxgkCbNotifyInterrupt(pDevExt->u.primary.DxgkInterface.DeviceHandle, &notify);
1602
1603 pDevExt->bNotifyDxDpc = TRUE;
1604 BOOLEAN bDpcQueued = pDevExt->u.primary.DxgkInterface.DxgkCbQueueDpc(pDevExt->u.primary.DxgkInterface.DeviceHandle);
1605
1606 return bDpcQueued;
1607}
1608
1609static NTSTATUS vboxVdmaDdiCmdFenceNotifyComplete(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_CONTEXT pContext, uint32_t u32FenceId)
1610{
1611 VBOXVDMADDI_CMD_COMPLETE_CB context;
1612 context.pDevExt = pDevExt;
1613 context.pContext = pContext;
1614 context.u32FenceId = u32FenceId;
1615 BOOLEAN bRet;
1616 NTSTATUS Status = pDevExt->u.primary.DxgkInterface.DxgkCbSynchronizeExecution(
1617 pDevExt->u.primary.DxgkInterface.DeviceHandle,
1618 vboxVdmaDdiCmdFenceCompleteCb,
1619 &context,
1620 0, /* IN ULONG MessageNumber */
1621 &bRet);
1622 Assert(Status == STATUS_SUCCESS);
1623 return Status;
1624}
1625
1626NTSTATUS vboxVdmaDdiCmdFenceComplete(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_CONTEXT pContext, uint32_t u32FenceId, DXGK_INTERRUPT_TYPE enmComplType)
1627{
1628 if (vboxVdmaDdiCmdCanComplete(&pDevExt->DdiCmdQueue))
1629 return vboxVdmaDdiCmdFenceNotifyComplete(pDevExt, pContext, u32FenceId);
1630
1631 PVBOXVDMADDI_CMD pCmd = (PVBOXVDMADDI_CMD)vboxWddmMemAlloc(sizeof (VBOXVDMADDI_CMD));
1632 Assert(pCmd);
1633 if (pCmd)
1634 {
1635 vboxVdmaDdiCmdInit(pCmd, u32FenceId, pContext, vboxVdmaDdiCmdCompletionCbFree, NULL);
1636 NTSTATUS Status = vboxVdmaDdiCmdCompleted(pDevExt, &pDevExt->DdiCmdQueue, pCmd, enmComplType);
1637 Assert(Status == STATUS_SUCCESS);
1638 if (Status == STATUS_SUCCESS)
1639 return STATUS_SUCCESS;
1640 vboxWddmMemFree(pCmd);
1641 return Status;
1642 }
1643 return STATUS_NO_MEMORY;
1644}
1645
1646#ifdef VBOXWDDM_RENDER_FROM_SHADOW
1647NTSTATUS vboxVdmaHlpUpdatePrimary(PDEVICE_EXTENSION pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId, RECT* pRect)
1648{
1649 PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[VidPnSourceId];
1650 Assert(pSource->pPrimaryAllocation);
1651 Assert(pSource->pShadowAllocation);
1652 if (!pSource->pPrimaryAllocation)
1653 return STATUS_INVALID_PARAMETER;
1654 if (!pSource->pShadowAllocation)
1655 return STATUS_INVALID_PARAMETER;
1656
1657 Assert(pSource->pPrimaryAllocation->offVram != VBOXVIDEOOFFSET_VOID);
1658 Assert(pSource->pShadowAllocation->offVram != VBOXVIDEOOFFSET_VOID);
1659 if (pSource->pPrimaryAllocation->offVram == VBOXVIDEOOFFSET_VOID)
1660 return STATUS_INVALID_PARAMETER;
1661 if (pSource->pShadowAllocation->offVram == VBOXVIDEOOFFSET_VOID)
1662 return STATUS_INVALID_PARAMETER;
1663
1664 NTSTATUS Status = vboxVdmaGgDmaBltPerform(pDevExt, pSource->pShadowAllocation, pRect, pSource->pPrimaryAllocation, pRect);
1665 Assert(Status == STATUS_SUCCESS);
1666 return Status;
1667}
1668#endif
Note: See TracBrowser for help on using the repository browser.

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