DevVGA_VDMA.cpp@ 45305

Last change on this file since 45305 was 44528, checked in by vboxsync, 12 years ago
header (C) fixes
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 42.7 KB

Line
1	/** @file
2	* Video DMA (VDMA) support.
3	*/
4
5	/*
6	* Copyright (C) 2006-2012 Oracle Corporation
7	*
8	* This file is part of VirtualBox Open Source Edition (OSE), as
9	* available from http://www.virtualbox.org. This file is free software;
10	* you can redistribute it and/or modify it under the terms of the GNU
11	* General Public License (GPL) as published by the Free Software
12	* Foundation, in version 2 as it comes in the "COPYING" file of the
13	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
14	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
15	*/
16	//#include <VBox/VMMDev.h>
17	#include <VBox/vmm/pdmdev.h>
18	#include <VBox/VBoxVideo.h>
19	#include <iprt/semaphore.h>
20	#include <iprt/thread.h>
21	#include <iprt/mem.h>
22	#include <iprt/asm.h>
23
24	#include "DevVGA.h"
25	#include "HGSMI/SHGSMIHost.h"
26	#include "HGSMI/HGSMIHostHlp.h"
27
28	#ifdef VBOX_VDMA_WITH_WORKERTHREAD
29	typedef enum
30	{
31	VBOXVDMAPIPE_STATE_CLOSED = 0,
32	VBOXVDMAPIPE_STATE_CREATED = 1,
33	VBOXVDMAPIPE_STATE_OPENNED = 2,
34	VBOXVDMAPIPE_STATE_CLOSING = 3
35	} VBOXVDMAPIPE_STATE;
36
37	typedef struct VBOXVDMAPIPE
38	{
39	RTSEMEVENT hEvent;
40	/* critical section for accessing pipe properties */
41	RTCRITSECT hCritSect;
42	VBOXVDMAPIPE_STATE enmState;
43	/* true iff the other end needs Event notification */
44	bool bNeedNotify;
45	} VBOXVDMAPIPE, *PVBOXVDMAPIPE;
46
47	typedef enum
48	{
49	VBOXVDMAPIPE_CMD_TYPE_UNDEFINED = 0,
50	VBOXVDMAPIPE_CMD_TYPE_DMACMD = 1,
51	VBOXVDMAPIPE_CMD_TYPE_DMACTL = 2
52	} VBOXVDMAPIPE_CMD_TYPE;
53
54	typedef struct VBOXVDMAPIPE_CMD_BODY
55	{
56	VBOXVDMAPIPE_CMD_TYPE enmType;
57	union
58	{
59	PVBOXVDMACBUF_DR pDr;
60	PVBOXVDMA_CTL pCtl;
61	void *pvCmd;
62	} u;
63	}VBOXVDMAPIPE_CMD_BODY, *PVBOXVDMAPIPE_CMD_BODY;
64
65	typedef struct VBOXVDMAPIPE_CMD
66	{
67	HGSMILISTENTRY Entry;
68	VBOXVDMAPIPE_CMD_BODY Cmd;
69	} VBOXVDMAPIPE_CMD, *PVBOXVDMAPIPE_CMD;
70
71	#define VBOXVDMAPIPE_CMD_FROM_ENTRY(_pE) ( (PVBOXVDMAPIPE_CMD)((uint8_t *)(_pE) - RT_OFFSETOF(VBOXVDMAPIPE_CMD, Entry)) )
72
73	typedef struct VBOXVDMAPIPE_CMD_POOL
74	{
75	HGSMILIST List;
76	uint32_t cCmds;
77	VBOXVDMAPIPE_CMD aCmds[1];
78	} VBOXVDMAPIPE_CMD_POOL, *PVBOXVDMAPIPE_CMD_POOL;
79	#endif
80
81	typedef struct VBOXVDMAHOST
82	{
83	PHGSMIINSTANCE pHgsmi;
84	PVGASTATE pVGAState;
85	#ifdef VBOX_VDMA_WITH_WATCHDOG
86	PTMTIMERR3 WatchDogTimer;
87	#endif
88	#ifdef VBOX_VDMA_WITH_WORKERTHREAD
89	VBOXVDMAPIPE Pipe;
90	HGSMILIST PendingList;
91	RTTHREAD hWorkerThread;
92	VBOXVDMAPIPE_CMD_POOL CmdPool;
93	#endif
94	} VBOXVDMAHOST, *PVBOXVDMAHOST;
95
96
97	#ifdef VBOX_WITH_CRHGSMI
98
99	typedef DECLCALLBACK(void) FNVBOXVDMACRCTL_CALLBACK(PVGASTATE pVGAState, PVBOXVDMACMD_CHROMIUM_CTL pCmd, void* pvContext);
100	typedef FNVBOXVDMACRCTL_CALLBACK *PFNVBOXVDMACRCTL_CALLBACK;
101
102	typedef struct VBOXVDMACMD_CHROMIUM_CTL_PRIVATE
103	{
104	uint32_t cRefs;
105	int32_t rc;
106	PFNVBOXVDMACRCTL_CALLBACK pfnCompletion;
107	void *pvCompletion;
108	VBOXVDMACMD_CHROMIUM_CTL Cmd;
109	} VBOXVDMACMD_CHROMIUM_CTL_PRIVATE, *PVBOXVDMACMD_CHROMIUM_CTL_PRIVATE;
110
111	#define VBOXVDMACMD_CHROMIUM_CTL_PRIVATE_FROM_CTL(_p) ((PVBOXVDMACMD_CHROMIUM_CTL_PRIVATE)(((uint8_t*)(_p)) - RT_OFFSETOF(VBOXVDMACMD_CHROMIUM_CTL_PRIVATE, Cmd)))
112
113	static PVBOXVDMACMD_CHROMIUM_CTL vboxVDMACrCtlCreate(VBOXVDMACMD_CHROMIUM_CTL_TYPE enmCmd, uint32_t cbCmd)
114	{
115	PVBOXVDMACMD_CHROMIUM_CTL_PRIVATE pHdr = (PVBOXVDMACMD_CHROMIUM_CTL_PRIVATE)RTMemAllocZ(cbCmd + RT_OFFSETOF(VBOXVDMACMD_CHROMIUM_CTL_PRIVATE, Cmd));
116	Assert(pHdr);
117	if (pHdr)
118	{
119	pHdr->cRefs = 1;
120	pHdr->rc = VERR_NOT_IMPLEMENTED;
121	pHdr->Cmd.enmType = enmCmd;
122	pHdr->Cmd.cbCmd = cbCmd;
123	return &pHdr->Cmd;
124	}
125
126	return NULL;
127	}
128
129	DECLINLINE(void) vboxVDMACrCtlRelease (PVBOXVDMACMD_CHROMIUM_CTL pCmd)
130	{
131	PVBOXVDMACMD_CHROMIUM_CTL_PRIVATE pHdr = VBOXVDMACMD_CHROMIUM_CTL_PRIVATE_FROM_CTL(pCmd);
132	uint32_t cRefs = ASMAtomicDecU32(&pHdr->cRefs);
133	if(!cRefs)
134	{
135	RTMemFree(pHdr);
136	}
137	}
138
139	DECLINLINE(void) vboxVDMACrCtlRetain (PVBOXVDMACMD_CHROMIUM_CTL pCmd)
140	{
141	PVBOXVDMACMD_CHROMIUM_CTL_PRIVATE pHdr = VBOXVDMACMD_CHROMIUM_CTL_PRIVATE_FROM_CTL(pCmd);
142	ASMAtomicIncU32(&pHdr->cRefs);
143	}
144
145	DECLINLINE(int) vboxVDMACrCtlGetRc (PVBOXVDMACMD_CHROMIUM_CTL pCmd)
146	{
147	PVBOXVDMACMD_CHROMIUM_CTL_PRIVATE pHdr = VBOXVDMACMD_CHROMIUM_CTL_PRIVATE_FROM_CTL(pCmd);
148	return pHdr->rc;
149	}
150
151	static DECLCALLBACK(void) vboxVDMACrCtlCbSetEvent(PVGASTATE pVGAState, PVBOXVDMACMD_CHROMIUM_CTL pCmd, void* pvContext)
152	{
153	RTSemEventSignal((RTSEMEVENT)pvContext);
154	}
155
156	static DECLCALLBACK(void) vboxVDMACrCtlCbReleaseCmd(PVGASTATE pVGAState, PVBOXVDMACMD_CHROMIUM_CTL pCmd, void* pvContext)
157	{
158	vboxVDMACrCtlRelease(pCmd);
159	}
160
161
162	static int vboxVDMACrCtlPostAsync (PVGASTATE pVGAState, PVBOXVDMACMD_CHROMIUM_CTL pCmd, uint32_t cbCmd, PFNVBOXVDMACRCTL_CALLBACK pfnCompletion, void *pvCompletion)
163	{
164	if ( pVGAState->pDrv
165	&& pVGAState->pDrv->pfnCrHgsmiControlProcess)
166	{
167	PVBOXVDMACMD_CHROMIUM_CTL_PRIVATE pHdr = VBOXVDMACMD_CHROMIUM_CTL_PRIVATE_FROM_CTL(pCmd);
168	pHdr->pfnCompletion = pfnCompletion;
169	pHdr->pvCompletion = pvCompletion;
170	pVGAState->pDrv->pfnCrHgsmiControlProcess(pVGAState->pDrv, pCmd, cbCmd);
171	return VINF_SUCCESS;
172	}
173	#ifdef DEBUG_misha
174	Assert(0);
175	#endif
176	return VERR_NOT_SUPPORTED;
177	}
178
179	static int vboxVDMACrCtlPost(PVGASTATE pVGAState, PVBOXVDMACMD_CHROMIUM_CTL pCmd, uint32_t cbCmd)
180	{
181	RTSEMEVENT hComplEvent;
182	int rc = RTSemEventCreate(&hComplEvent);
183	AssertRC(rc);
184	if(RT_SUCCESS(rc))
185	{
186	rc = vboxVDMACrCtlPostAsync (pVGAState, pCmd, cbCmd, vboxVDMACrCtlCbSetEvent, (void*)hComplEvent);
187	#ifdef DEBUG_misha
188	AssertRC(rc);
189	#endif
190	if (RT_SUCCESS(rc))
191	{
192	rc = RTSemEventWaitNoResume(hComplEvent, RT_INDEFINITE_WAIT);
193	AssertRC(rc);
194	if(RT_SUCCESS(rc))
195	{
196	RTSemEventDestroy(hComplEvent);
197	}
198	}
199	else
200	{
201	/* the command is completed */
202	RTSemEventDestroy(hComplEvent);
203	}
204	}
205	return rc;
206	}
207
208	static int vboxVDMACrCtlHgsmiSetup(struct VBOXVDMAHOST *pVdma)
209	{
210	PVBOXVDMACMD_CHROMIUM_CTL_CRHGSMI_SETUP pCmd;
211	pCmd = (PVBOXVDMACMD_CHROMIUM_CTL_CRHGSMI_SETUP) vboxVDMACrCtlCreate (VBOXVDMACMD_CHROMIUM_CTL_TYPE_CRHGSMI_SETUP,
212	sizeof (*pCmd));
213	if (pCmd)
214	{
215	PVGASTATE pVGAState = pVdma->pVGAState;
216	pCmd->pvVRamBase = pVGAState->vram_ptrR3;
217	pCmd->cbVRam = pVGAState->vram_size;
218	int rc = vboxVDMACrCtlPost(pVGAState, &pCmd->Hdr, sizeof (*pCmd));
219	Assert(RT_SUCCESS(rc) \|\| rc == VERR_NOT_SUPPORTED);
220	if (RT_SUCCESS(rc))
221	{
222	rc = vboxVDMACrCtlGetRc(&pCmd->Hdr);
223	}
224	vboxVDMACrCtlRelease(&pCmd->Hdr);
225	return rc;
226	}
227	return VERR_NO_MEMORY;
228	}
229
230	static int vboxVDMACmdExecBpbTransfer(PVBOXVDMAHOST pVdma, const PVBOXVDMACMD_DMA_BPB_TRANSFER pTransfer, uint32_t cbBuffer);
231
232	/* check if this is external cmd to be passed to chromium backend */
233	static int vboxVDMACmdCheckCrCmd(struct VBOXVDMAHOST *pVdma, PVBOXVDMACBUF_DR pCmdDr, uint32_t cbCmdDr)
234	{
235	PVBOXVDMACMD pDmaCmd = NULL;
236	uint32_t cbDmaCmd = 0;
237	uint8_t * pvRam = pVdma->pVGAState->vram_ptrR3;
238	int rc = VINF_NOT_SUPPORTED;
239
240	cbDmaCmd = pCmdDr->cbBuf;
241
242	if (pCmdDr->fFlags & VBOXVDMACBUF_FLAG_BUF_FOLLOWS_DR)
243	{
244	if (cbCmdDr < sizeof (*pCmdDr) + VBOXVDMACMD_HEADER_SIZE())
245	{
246	AssertMsgFailed(("invalid buffer data!"));
247	return VERR_INVALID_PARAMETER;
248	}
249
250	if (cbDmaCmd < cbCmdDr - sizeof (*pCmdDr) - VBOXVDMACMD_HEADER_SIZE())
251	{
252	AssertMsgFailed(("invalid command buffer data!"));
253	return VERR_INVALID_PARAMETER;
254	}
255
256	pDmaCmd = VBOXVDMACBUF_DR_TAIL(pCmdDr, VBOXVDMACMD);
257	}
258	else if (pCmdDr->fFlags & VBOXVDMACBUF_FLAG_BUF_VRAM_OFFSET)
259	{
260	VBOXVIDEOOFFSET offBuf = pCmdDr->Location.offVramBuf;
261	if (offBuf + cbDmaCmd > pVdma->pVGAState->vram_size)
262	{
263	AssertMsgFailed(("invalid command buffer data from offset!"));
264	return VERR_INVALID_PARAMETER;
265	}
266	pDmaCmd = (VBOXVDMACMD*)(pvRam + offBuf);
267	}
268
269	if (pDmaCmd)
270	{
271	Assert(cbDmaCmd >= VBOXVDMACMD_HEADER_SIZE());
272	uint32_t cbBody = VBOXVDMACMD_BODY_SIZE(cbDmaCmd);
273
274	switch (pDmaCmd->enmType)
275	{
276	case VBOXVDMACMD_TYPE_CHROMIUM_CMD:
277	{
278	PVBOXVDMACMD_CHROMIUM_CMD pCrCmd = VBOXVDMACMD_BODY(pDmaCmd, VBOXVDMACMD_CHROMIUM_CMD);
279	if (cbBody < sizeof (*pCrCmd))
280	{
281	AssertMsgFailed(("invalid chromium command buffer size!"));
282	return VERR_INVALID_PARAMETER;
283	}
284	PVGASTATE pVGAState = pVdma->pVGAState;
285	rc = VINF_SUCCESS;
286	if (pVGAState->pDrv->pfnCrHgsmiCommandProcess)
287	{
288	VBoxSHGSMICommandMarkAsynchCompletion(pCmdDr);
289	pVGAState->pDrv->pfnCrHgsmiCommandProcess(pVGAState->pDrv, pCrCmd, cbBody);
290	break;
291	}
292	else
293	{
294	Assert(0);
295	}
296
297	int tmpRc = VBoxSHGSMICommandComplete (pVdma->pHgsmi, pCmdDr);
298	AssertRC(tmpRc);
299	break;
300	}
301	case VBOXVDMACMD_TYPE_DMA_BPB_TRANSFER:
302	{
303	PVBOXVDMACMD_DMA_BPB_TRANSFER pTransfer = VBOXVDMACMD_BODY(pDmaCmd, VBOXVDMACMD_DMA_BPB_TRANSFER);
304	if (cbBody < sizeof (*pTransfer))
305	{
306	AssertMsgFailed(("invalid bpb transfer buffer size!"));
307	return VERR_INVALID_PARAMETER;
308	}
309
310	rc = vboxVDMACmdExecBpbTransfer(pVdma, pTransfer, sizeof (*pTransfer));
311	AssertRC(rc);
312	if (RT_SUCCESS(rc))
313	{
314	pCmdDr->rc = VINF_SUCCESS;
315	rc = VBoxSHGSMICommandComplete (pVdma->pHgsmi, pCmdDr);
316	AssertRC(rc);
317	rc = VINF_SUCCESS;
318	}
319	break;
320	}
321	default:
322	break;
323	}
324	}
325	return rc;
326	}
327
328	int vboxVDMACrHgsmiCommandCompleteAsync(PPDMIDISPLAYVBVACALLBACKS pInterface, PVBOXVDMACMD_CHROMIUM_CMD pCmd, int rc)
329	{
330	PVGASTATE pVGAState = PPDMIDISPLAYVBVACALLBACKS_2_PVGASTATE(pInterface);
331	PHGSMIINSTANCE pIns = pVGAState->pHGSMI;
332	VBOXVDMACMD *pDmaHdr = VBOXVDMACMD_FROM_BODY(pCmd);
333	VBOXVDMACBUF_DR *pDr = VBOXVDMACBUF_DR_FROM_TAIL(pDmaHdr);
334	AssertRC(rc);
335	pDr->rc = rc;
336
337	Assert(pVGAState->fGuestCaps & VBVACAPS_COMPLETEGCMD_BY_IOREAD);
338	rc = VBoxSHGSMICommandComplete(pIns, pDr);
339	AssertRC(rc);
340	return rc;
341	}
342
343	int vboxVDMACrHgsmiControlCompleteAsync(PPDMIDISPLAYVBVACALLBACKS pInterface, PVBOXVDMACMD_CHROMIUM_CTL pCmd, int rc)
344	{
345	PVGASTATE pVGAState = PPDMIDISPLAYVBVACALLBACKS_2_PVGASTATE(pInterface);
346	PVBOXVDMACMD_CHROMIUM_CTL_PRIVATE pCmdPrivate = VBOXVDMACMD_CHROMIUM_CTL_PRIVATE_FROM_CTL(pCmd);
347	pCmdPrivate->rc = rc;
348	if (pCmdPrivate->pfnCompletion)
349	{
350	pCmdPrivate->pfnCompletion(pVGAState, pCmd, pCmdPrivate->pvCompletion);
351	}
352	return VINF_SUCCESS;
353	}
354
355	#endif
356
357	#ifdef VBOX_VDMA_WITH_WORKERTHREAD
358	/* to simplify things and to avoid extra backend if modifications we assume the VBOXVDMA_RECTL is the same as VBVACMDHDR */
359	AssertCompile(sizeof(VBOXVDMA_RECTL) == sizeof(VBVACMDHDR));
360	AssertCompile(RT_SIZEOFMEMB(VBOXVDMA_RECTL, left) == RT_SIZEOFMEMB(VBVACMDHDR, x));
361	AssertCompile(RT_SIZEOFMEMB(VBOXVDMA_RECTL, top) == RT_SIZEOFMEMB(VBVACMDHDR, y));
362	AssertCompile(RT_SIZEOFMEMB(VBOXVDMA_RECTL, width) == RT_SIZEOFMEMB(VBVACMDHDR, w));
363	AssertCompile(RT_SIZEOFMEMB(VBOXVDMA_RECTL, height) == RT_SIZEOFMEMB(VBVACMDHDR, h));
364	AssertCompile(RT_OFFSETOF(VBOXVDMA_RECTL, left) == RT_OFFSETOF(VBVACMDHDR, x));
365	AssertCompile(RT_OFFSETOF(VBOXVDMA_RECTL, top) == RT_OFFSETOF(VBVACMDHDR, y));
366	AssertCompile(RT_OFFSETOF(VBOXVDMA_RECTL, width) == RT_OFFSETOF(VBVACMDHDR, w));
367	AssertCompile(RT_OFFSETOF(VBOXVDMA_RECTL, height) == RT_OFFSETOF(VBVACMDHDR, h));
368
369	static int vboxVDMANotifyPrimaryUpdate (PVGASTATE pVGAState, unsigned uScreenId, const VBOXVDMA_RECTL * pRectl)
370	{
371	pVGAState->pDrv->pfnVBVAUpdateBegin (pVGAState->pDrv, uScreenId);
372
373	/* Updates the rectangle and sends the command to the VRDP server. */
374	pVGAState->pDrv->pfnVBVAUpdateProcess (pVGAState->pDrv, uScreenId,
375	(const PVBVACMDHDR)pRectl /* <- see above AssertCompile's and comments */,
376	sizeof (VBOXVDMA_RECTL));
377
378	pVGAState->pDrv->pfnVBVAUpdateEnd (pVGAState->pDrv, uScreenId, pRectl->left, pRectl->top,
379	pRectl->width, pRectl->height);
380
381	return VINF_SUCCESS;
382	}
383	#endif
384
385	static int vboxVDMACmdExecBltPerform(PVBOXVDMAHOST pVdma,
386	uint8_t pvDstSurf, const uint8_t pvSrcSurf,
387	const PVBOXVDMA_SURF_DESC pDstDesc, const PVBOXVDMA_SURF_DESC pSrcDesc,
388	const VBOXVDMA_RECTL * pDstRectl, const VBOXVDMA_RECTL * pSrcRectl)
389	{
390	/* we do not support color conversion */
391	Assert(pDstDesc->format == pSrcDesc->format);
392	/* we do not support stretching */
393	Assert(pDstRectl->height == pSrcRectl->height);
394	Assert(pDstRectl->width == pSrcRectl->width);
395	if (pDstDesc->format != pSrcDesc->format)
396	return VERR_INVALID_FUNCTION;
397	if (pDstDesc->width == pDstRectl->width
398	&& pSrcDesc->width == pSrcRectl->width
399	&& pSrcDesc->width == pDstDesc->width)
400	{
401	Assert(!pDstRectl->left);
402	Assert(!pSrcRectl->left);
403	uint32_t cbOff = pDstDesc->pitch * pDstRectl->top;
404	uint32_t cbSize = pDstDesc->pitch * pDstRectl->height;
405	memcpy(pvDstSurf + cbOff, pvSrcSurf + cbOff, cbSize);
406	}
407	else
408	{
409	uint32_t offDstLineStart = pDstRectl->left * pDstDesc->bpp >> 3;
410	uint32_t offDstLineEnd = ((pDstRectl->left * pDstDesc->bpp + 7) >> 3) + ((pDstDesc->bpp * pDstRectl->width + 7) >> 3);
411	uint32_t cbDstLine = offDstLineEnd - offDstLineStart;
412	uint32_t offDstStart = pDstDesc->pitch * pDstRectl->top + offDstLineStart;
413	Assert(cbDstLine <= pDstDesc->pitch);
414	uint32_t cbDstSkip = pDstDesc->pitch;
415	uint8_t * pvDstStart = pvDstSurf + offDstStart;
416
417	uint32_t offSrcLineStart = pSrcRectl->left * pSrcDesc->bpp >> 3;
418	uint32_t offSrcLineEnd = ((pSrcRectl->left * pSrcDesc->bpp + 7) >> 3) + ((pSrcDesc->bpp * pSrcRectl->width + 7) >> 3);
419	uint32_t cbSrcLine = offSrcLineEnd - offSrcLineStart;
420	uint32_t offSrcStart = pSrcDesc->pitch * pSrcRectl->top + offSrcLineStart;
421	Assert(cbSrcLine <= pSrcDesc->pitch);
422	uint32_t cbSrcSkip = pSrcDesc->pitch;
423	const uint8_t * pvSrcStart = pvSrcSurf + offSrcStart;
424
425	Assert(cbDstLine == cbSrcLine);
426
427	for (uint32_t i = 0; ; ++i)
428	{
429	memcpy (pvDstStart, pvSrcStart, cbDstLine);
430	if (i == pDstRectl->height)
431	break;
432	pvDstStart += cbDstSkip;
433	pvSrcStart += cbSrcSkip;
434	}
435	}
436	return VINF_SUCCESS;
437	}
438
439	static void vboxVDMARectlUnite(VBOXVDMA_RECTL * pRectl1, const VBOXVDMA_RECTL * pRectl2)
440	{
441	if (!pRectl1->width)
442	pRectl1 = pRectl2;
443	else
444	{
445	int16_t x21 = pRectl1->left + pRectl1->width;
446	int16_t x22 = pRectl2->left + pRectl2->width;
447	if (pRectl1->left > pRectl2->left)
448	{
449	pRectl1->left = pRectl2->left;
450	pRectl1->width = x21 < x22 ? x22 - pRectl1->left : x21 - pRectl1->left;
451	}
452	else if (x21 < x22)
453	pRectl1->width = x22 - pRectl1->left;
454
455	x21 = pRectl1->top + pRectl1->height;
456	x22 = pRectl2->top + pRectl2->height;
457	if (pRectl1->top > pRectl2->top)
458	{
459	pRectl1->top = pRectl2->top;
460	pRectl1->height = x21 < x22 ? x22 - pRectl1->top : x21 - pRectl1->top;
461	}
462	else if (x21 < x22)
463	pRectl1->height = x22 - pRectl1->top;
464	}
465	}
466
467	/*
468	* @return on success the number of bytes the command contained, otherwise - VERR_xxx error code
469	*/
470	static int vboxVDMACmdExecBlt(PVBOXVDMAHOST pVdma, const PVBOXVDMACMD_DMA_PRESENT_BLT pBlt, uint32_t cbBuffer)
471	{
472	const uint32_t cbBlt = VBOXVDMACMD_BODY_FIELD_OFFSET(uint32_t, VBOXVDMACMD_DMA_PRESENT_BLT, aDstSubRects[pBlt->cDstSubRects]);
473	Assert(cbBlt <= cbBuffer);
474	if (cbBuffer < cbBlt)
475	return VERR_INVALID_FUNCTION;
476
477	/* we do not support stretching for now */
478	Assert(pBlt->srcRectl.width == pBlt->dstRectl.width);
479	Assert(pBlt->srcRectl.height == pBlt->dstRectl.height);
480	if (pBlt->srcRectl.width != pBlt->dstRectl.width)
481	return VERR_INVALID_FUNCTION;
482	if (pBlt->srcRectl.height != pBlt->dstRectl.height)
483	return VERR_INVALID_FUNCTION;
484	Assert(pBlt->cDstSubRects);
485
486	uint8_t * pvRam = pVdma->pVGAState->vram_ptrR3;
487	VBOXVDMA_RECTL updateRectl = {0, 0, 0, 0};
488
489	if (pBlt->cDstSubRects)
490	{
491	VBOXVDMA_RECTL dstRectl, srcRectl;
492	const VBOXVDMA_RECTL pDstRectl, pSrcRectl;
493	for (uint32_t i = 0; i < pBlt->cDstSubRects; ++i)
494	{
495	pDstRectl = &pBlt->aDstSubRects[i];
496	if (pBlt->dstRectl.left \|\| pBlt->dstRectl.top)
497	{
498	dstRectl.left = pDstRectl->left + pBlt->dstRectl.left;
499	dstRectl.top = pDstRectl->top + pBlt->dstRectl.top;
500	dstRectl.width = pDstRectl->width;
501	dstRectl.height = pDstRectl->height;
502	pDstRectl = &dstRectl;
503	}
504
505	pSrcRectl = &pBlt->aDstSubRects[i];
506	if (pBlt->srcRectl.left \|\| pBlt->srcRectl.top)
507	{
508	srcRectl.left = pSrcRectl->left + pBlt->srcRectl.left;
509	srcRectl.top = pSrcRectl->top + pBlt->srcRectl.top;
510	srcRectl.width = pSrcRectl->width;
511	srcRectl.height = pSrcRectl->height;
512	pSrcRectl = &srcRectl;
513	}
514
515	int rc = vboxVDMACmdExecBltPerform(pVdma, pvRam + pBlt->offDst, pvRam + pBlt->offSrc,
516	&pBlt->dstDesc, &pBlt->srcDesc,
517	pDstRectl,
518	pSrcRectl);
519	AssertRC(rc);
520	if (!RT_SUCCESS(rc))
521	return rc;
522
523	vboxVDMARectlUnite(&updateRectl, pDstRectl);
524	}
525	}
526	else
527	{
528	int rc = vboxVDMACmdExecBltPerform(pVdma, pvRam + pBlt->offDst, pvRam + pBlt->offSrc,
529	&pBlt->dstDesc, &pBlt->srcDesc,
530	&pBlt->dstRectl,
531	&pBlt->srcRectl);
532	AssertRC(rc);
533	if (!RT_SUCCESS(rc))
534	return rc;
535
536	vboxVDMARectlUnite(&updateRectl, &pBlt->dstRectl);
537	}
538
539	#ifdef VBOX_VDMA_WITH_WORKERTHREAD
540	int iView = 0;
541	/* @todo: fixme: check if update is needed and get iView */
542	vboxVDMANotifyPrimaryUpdate (pVdma->pVGAState, iView, &updateRectl);
543	#endif
544
545	return cbBlt;
546	}
547
548	static int vboxVDMACmdExecBpbTransfer(PVBOXVDMAHOST pVdma, const PVBOXVDMACMD_DMA_BPB_TRANSFER pTransfer, uint32_t cbBuffer)
549	{
550	if (cbBuffer < sizeof (*pTransfer))
551	return VERR_INVALID_PARAMETER;
552
553	PVGASTATE pVGAState = pVdma->pVGAState;
554	uint8_t * pvRam = pVGAState->vram_ptrR3;
555	PGMPAGEMAPLOCK SrcLock;
556	PGMPAGEMAPLOCK DstLock;
557	PPDMDEVINS pDevIns = pVdma->pVGAState->pDevInsR3;
558	const void * pvSrc;
559	void * pvDst;
560	int rc = VINF_SUCCESS;
561	uint32_t cbTransfer = pTransfer->cbTransferSize;
562	uint32_t cbTransfered = 0;
563	bool bSrcLocked = false;
564	bool bDstLocked = false;
565	do
566	{
567	uint32_t cbSubTransfer = cbTransfer;
568	if (pTransfer->fFlags & VBOXVDMACMD_DMA_BPB_TRANSFER_F_SRC_VRAMOFFSET)
569	{
570	pvSrc = pvRam + pTransfer->Src.offVramBuf + cbTransfered;
571	}
572	else
573	{
574	RTGCPHYS phPage = pTransfer->Src.phBuf;
575	phPage += cbTransfered;
576	rc = PDMDevHlpPhysGCPhys2CCPtrReadOnly(pDevIns, phPage, 0, &pvSrc, &SrcLock);
577	AssertRC(rc);
578	if (RT_SUCCESS(rc))
579	{
580	bSrcLocked = true;
581	cbSubTransfer = RT_MIN(cbSubTransfer, 0x1000);
582	}
583	else
584	{
585	break;
586	}
587	}
588
589	if (pTransfer->fFlags & VBOXVDMACMD_DMA_BPB_TRANSFER_F_DST_VRAMOFFSET)
590	{
591	pvDst = pvRam + pTransfer->Dst.offVramBuf + cbTransfered;
592	}
593	else
594	{
595	RTGCPHYS phPage = pTransfer->Dst.phBuf;
596	phPage += cbTransfered;
597	rc = PDMDevHlpPhysGCPhys2CCPtr(pDevIns, phPage, 0, &pvDst, &DstLock);
598	AssertRC(rc);
599	if (RT_SUCCESS(rc))
600	{
601	bDstLocked = true;
602	cbSubTransfer = RT_MIN(cbSubTransfer, 0x1000);
603	}
604	else
605	{
606	break;
607	}
608	}
609
610	if (RT_SUCCESS(rc))
611	{
612	memcpy(pvDst, pvSrc, cbSubTransfer);
613	cbTransfer -= cbSubTransfer;
614	cbTransfered += cbSubTransfer;
615	}
616	else
617	{
618	cbTransfer = 0; /* to break */
619	}
620
621	if (bSrcLocked)
622	PDMDevHlpPhysReleasePageMappingLock(pDevIns, &SrcLock);
623	if (bDstLocked)
624	PDMDevHlpPhysReleasePageMappingLock(pDevIns, &DstLock);
625	} while (cbTransfer);
626
627	if (RT_SUCCESS(rc))
628	return sizeof (*pTransfer);
629	return rc;
630	}
631
632	static int vboxVDMACmdExec(PVBOXVDMAHOST pVdma, const uint8_t *pvBuffer, uint32_t cbBuffer)
633	{
634	do
635	{
636	Assert(pvBuffer);
637	Assert(cbBuffer >= VBOXVDMACMD_HEADER_SIZE());
638
639	if (!pvBuffer)
640	return VERR_INVALID_PARAMETER;
641	if (cbBuffer < VBOXVDMACMD_HEADER_SIZE())
642	return VERR_INVALID_PARAMETER;
643
644	PVBOXVDMACMD pCmd = (PVBOXVDMACMD)pvBuffer;
645	uint32_t cbCmd = 0;
646	switch (pCmd->enmType)
647	{
648	case VBOXVDMACMD_TYPE_CHROMIUM_CMD:
649	{
650	#ifdef VBOXWDDM_TEST_UHGSMI
651	static int count = 0;
652	static uint64_t start, end;
653	if (count==0)
654	{
655	start = RTTimeNanoTS();
656	}
657	++count;
658	if (count==100000)
659	{
660	end = RTTimeNanoTS();
661	float ems = (end-start)/1000000.f;
662	LogRel(("100000 calls took %i ms, %i cps\n", (int)ems, (int)(100000.f*1000.f/ems) ));
663	}
664	#endif
665	/* todo: post the buffer to chromium */
666	return VINF_SUCCESS;
667	}
668	case VBOXVDMACMD_TYPE_DMA_PRESENT_BLT:
669	{
670	const PVBOXVDMACMD_DMA_PRESENT_BLT pBlt = VBOXVDMACMD_BODY(pCmd, VBOXVDMACMD_DMA_PRESENT_BLT);
671	int cbBlt = vboxVDMACmdExecBlt(pVdma, pBlt, cbBuffer);
672	Assert(cbBlt >= 0);
673	Assert((uint32_t)cbBlt <= cbBuffer);
674	if (cbBlt >= 0)
675	{
676	if ((uint32_t)cbBlt == cbBuffer)
677	return VINF_SUCCESS;
678	else
679	{
680	cbBuffer -= (uint32_t)cbBlt;
681	pvBuffer -= cbBlt;
682	}
683	}
684	else
685	return cbBlt; /* error */
686	break;
687	}
688	case VBOXVDMACMD_TYPE_DMA_BPB_TRANSFER:
689	{
690	const PVBOXVDMACMD_DMA_BPB_TRANSFER pTransfer = VBOXVDMACMD_BODY(pCmd, VBOXVDMACMD_DMA_BPB_TRANSFER);
691	int cbTransfer = vboxVDMACmdExecBpbTransfer(pVdma, pTransfer, cbBuffer);
692	Assert(cbTransfer >= 0);
693	Assert((uint32_t)cbTransfer <= cbBuffer);
694	if (cbTransfer >= 0)
695	{
696	if ((uint32_t)cbTransfer == cbBuffer)
697	return VINF_SUCCESS;
698	else
699	{
700	cbBuffer -= (uint32_t)cbTransfer;
701	pvBuffer -= cbTransfer;
702	}
703	}
704	else
705	return cbTransfer; /* error */
706	break;
707	}
708	case VBOXVDMACMD_TYPE_DMA_NOP:
709	return VINF_SUCCESS;
710	case VBOXVDMACMD_TYPE_CHILD_STATUS_IRQ:
711	return VINF_SUCCESS;
712	default:
713	AssertBreakpoint();
714	return VERR_INVALID_FUNCTION;
715	}
716	} while (1);
717
718	/* we should not be here */
719	AssertBreakpoint();
720	return VERR_INVALID_STATE;
721	}
722
723	#ifdef VBOX_VDMA_WITH_WORKERTHREAD
724
725	int vboxVDMAPipeConstruct(PVBOXVDMAPIPE pPipe)
726	{
727	int rc = RTSemEventCreate(&pPipe->hEvent);
728	AssertRC(rc);
729	if (RT_SUCCESS(rc))
730	{
731	rc = RTCritSectInit(&pPipe->hCritSect);
732	AssertRC(rc);
733	if (RT_SUCCESS(rc))
734	{
735	pPipe->enmState = VBOXVDMAPIPE_STATE_CREATED;
736	pPipe->bNeedNotify = true;
737	return VINF_SUCCESS;
738	// RTCritSectDelete(pPipe->hCritSect);
739	}
740	RTSemEventDestroy(pPipe->hEvent);
741	}
742	return rc;
743	}
744
745	int vboxVDMAPipeOpenServer(PVBOXVDMAPIPE pPipe)
746	{
747	int rc = RTCritSectEnter(&pPipe->hCritSect);
748	AssertRC(rc);
749	if (RT_SUCCESS(rc))
750	{
751	Assert(pPipe->enmState == VBOXVDMAPIPE_STATE_CREATED);
752	switch (pPipe->enmState)
753	{
754	case VBOXVDMAPIPE_STATE_CREATED:
755	pPipe->enmState = VBOXVDMAPIPE_STATE_OPENNED;
756	pPipe->bNeedNotify = false;
757	rc = VINF_SUCCESS;
758	break;
759	case VBOXVDMAPIPE_STATE_OPENNED:
760	pPipe->bNeedNotify = false;
761	rc = VINF_ALREADY_INITIALIZED;
762	break;
763	default:
764	AssertBreakpoint();
765	rc = VERR_INVALID_STATE;
766	break;
767	}
768
769	RTCritSectLeave(&pPipe->hCritSect);
770	}
771	return rc;
772	}
773
774	int vboxVDMAPipeCloseServer(PVBOXVDMAPIPE pPipe)
775	{
776	int rc = RTCritSectEnter(&pPipe->hCritSect);
777	AssertRC(rc);
778	if (RT_SUCCESS(rc))
779	{
780	Assert(pPipe->enmState == VBOXVDMAPIPE_STATE_CLOSED
781	\|\| pPipe->enmState == VBOXVDMAPIPE_STATE_CLOSING);
782	switch (pPipe->enmState)
783	{
784	case VBOXVDMAPIPE_STATE_CLOSING:
785	pPipe->enmState = VBOXVDMAPIPE_STATE_CLOSED;
786	rc = VINF_SUCCESS;
787	break;
788	case VBOXVDMAPIPE_STATE_CLOSED:
789	rc = VINF_ALREADY_INITIALIZED;
790	break;
791	default:
792	AssertBreakpoint();
793	rc = VERR_INVALID_STATE;
794	break;
795	}
796
797	RTCritSectLeave(&pPipe->hCritSect);
798	}
799	return rc;
800	}
801
802	int vboxVDMAPipeCloseClient(PVBOXVDMAPIPE pPipe)
803	{
804	int rc = RTCritSectEnter(&pPipe->hCritSect);
805	AssertRC(rc);
806	if (RT_SUCCESS(rc))
807	{
808	bool bNeedNotify = false;
809	Assert(pPipe->enmState == VBOXVDMAPIPE_STATE_OPENNED
810	\|\| pPipe->enmState == VBOXVDMAPIPE_STATE_CREATED
811	\|\| pPipe->enmState == VBOXVDMAPIPE_STATE_CLOSED);
812	switch (pPipe->enmState)
813	{
814	case VBOXVDMAPIPE_STATE_OPENNED:
815	pPipe->enmState = VBOXVDMAPIPE_STATE_CLOSING;
816	bNeedNotify = pPipe->bNeedNotify;
817	pPipe->bNeedNotify = false;
818	break;
819	case VBOXVDMAPIPE_STATE_CREATED:
820	pPipe->enmState = VBOXVDMAPIPE_STATE_CLOSED;
821	pPipe->bNeedNotify = false;
822	break;
823	case VBOXVDMAPIPE_STATE_CLOSED:
824	rc = VINF_ALREADY_INITIALIZED;
825	break;
826	default:
827	AssertBreakpoint();
828	rc = VERR_INVALID_STATE;
829	break;
830	}
831
832	RTCritSectLeave(&pPipe->hCritSect);
833
834	if (bNeedNotify)
835	{
836	rc = RTSemEventSignal(pPipe->hEvent);
837	AssertRC(rc);
838	}
839	}
840	return rc;
841	}
842
843
844	typedef DECLCALLBACK(bool) FNHVBOXVDMARWCB(PVBOXVDMAPIPE pPipe, void *pvCallback);
845	typedef FNHVBOXVDMARWCB *PFNHVBOXVDMARWCB;
846
847	int vboxVDMAPipeModifyServer(PVBOXVDMAPIPE pPipe, PFNHVBOXVDMARWCB pfnCallback, void * pvCallback)
848	{
849	int rc = RTCritSectEnter(&pPipe->hCritSect);
850	AssertRC(rc);
851	if (RT_SUCCESS(rc))
852	{
853	do
854	{
855	Assert(pPipe->enmState == VBOXVDMAPIPE_STATE_OPENNED
856	\|\| pPipe->enmState == VBOXVDMAPIPE_STATE_CLOSING);
857
858	if (pPipe->enmState >= VBOXVDMAPIPE_STATE_OPENNED)
859	{
860	bool bProcessing = pfnCallback(pPipe, pvCallback);
861	pPipe->bNeedNotify = !bProcessing;
862	if (bProcessing)
863	{
864	RTCritSectLeave(&pPipe->hCritSect);
865	rc = VINF_SUCCESS;
866	break;
867	}
868	else if (pPipe->enmState == VBOXVDMAPIPE_STATE_CLOSING)
869	{
870	pPipe->enmState = VBOXVDMAPIPE_STATE_CLOSED;
871	RTCritSectLeave(&pPipe->hCritSect);
872	rc = VINF_EOF;
873	break;
874	}
875	}
876	else
877	{
878	AssertBreakpoint();
879	rc = VERR_INVALID_STATE;
880	RTCritSectLeave(&pPipe->hCritSect);
881	break;
882	}
883
884	RTCritSectLeave(&pPipe->hCritSect);
885
886	rc = RTSemEventWait(pPipe->hEvent, RT_INDEFINITE_WAIT);
887	AssertRC(rc);
888	if (!RT_SUCCESS(rc))
889	break;
890
891	rc = RTCritSectEnter(&pPipe->hCritSect);
892	AssertRC(rc);
893	if (!RT_SUCCESS(rc))
894	break;
895	} while (1);
896	}
897
898	return rc;
899	}
900
901	int vboxVDMAPipeModifyClient(PVBOXVDMAPIPE pPipe, PFNHVBOXVDMARWCB pfnCallback, void * pvCallback)
902	{
903	int rc = RTCritSectEnter(&pPipe->hCritSect);
904	AssertRC(rc);
905	if (RT_SUCCESS(rc))
906	{
907	bool bNeedNotify = false;
908	Assert(pPipe->enmState == VBOXVDMAPIPE_STATE_OPENNED);
909	if (pPipe->enmState == VBOXVDMAPIPE_STATE_OPENNED)
910	{
911	bool bModified = pfnCallback(pPipe, pvCallback);
912	if (bModified)
913	{
914	bNeedNotify = pPipe->bNeedNotify;
915	pPipe->bNeedNotify = false;
916	}
917	}
918	else
919	rc = VERR_INVALID_STATE;
920
921	RTCritSectLeave(&pPipe->hCritSect);
922
923	if (bNeedNotify)
924	{
925	rc = RTSemEventSignal(pPipe->hEvent);
926	AssertRC(rc);
927	}
928	}
929	return rc;
930	}
931
932	int vboxVDMAPipeDestruct(PVBOXVDMAPIPE pPipe)
933	{
934	Assert(pPipe->enmState == VBOXVDMAPIPE_STATE_CLOSED
935	\|\| pPipe->enmState == VBOXVDMAPIPE_STATE_CREATED);
936	/* ensure the pipe is closed */
937	vboxVDMAPipeCloseClient(pPipe);
938
939	Assert(pPipe->enmState == VBOXVDMAPIPE_STATE_CLOSED);
940
941	if (pPipe->enmState != VBOXVDMAPIPE_STATE_CLOSED)
942	return VERR_INVALID_STATE;
943
944	int rc = RTCritSectDelete(&pPipe->hCritSect);
945	AssertRC(rc);
946
947	rc = RTSemEventDestroy(pPipe->hEvent);
948	AssertRC(rc);
949
950	return VINF_SUCCESS;
951	}
952	#endif
953
954	static void vboxVDMACommandProcess(PVBOXVDMAHOST pVdma, PVBOXVDMACBUF_DR pCmd, uint32_t cbCmd)
955	{
956	PHGSMIINSTANCE pHgsmi = pVdma->pHgsmi;
957	const uint8_t * pvBuf;
958	PGMPAGEMAPLOCK Lock;
959	int rc;
960	bool bReleaseLocked = false;
961
962	do
963	{
964	PPDMDEVINS pDevIns = pVdma->pVGAState->pDevInsR3;
965
966	if (pCmd->fFlags & VBOXVDMACBUF_FLAG_BUF_FOLLOWS_DR)
967	pvBuf = VBOXVDMACBUF_DR_TAIL(pCmd, const uint8_t);
968	else if (pCmd->fFlags & VBOXVDMACBUF_FLAG_BUF_VRAM_OFFSET)
969	{
970	uint8_t * pvRam = pVdma->pVGAState->vram_ptrR3;
971	pvBuf = pvRam + pCmd->Location.offVramBuf;
972	}
973	else
974	{
975	RTGCPHYS phPage = pCmd->Location.phBuf & ~0xfffULL;
976	uint32_t offset = pCmd->Location.phBuf & 0xfff;
977	Assert(offset + pCmd->cbBuf <= 0x1000);
978	if (offset + pCmd->cbBuf > 0x1000)
979	{
980	/* @todo: more advanced mechanism of command buffer proc is actually needed */
981	rc = VERR_INVALID_PARAMETER;
982	break;
983	}
984
985	const void * pvPageBuf;
986	rc = PDMDevHlpPhysGCPhys2CCPtrReadOnly(pDevIns, phPage, 0, &pvPageBuf, &Lock);
987	AssertRC(rc);
988	if (!RT_SUCCESS(rc))
989	{
990	/* @todo: if (rc == VERR_PGM_PHYS_PAGE_RESERVED) -> fall back on using PGMPhysRead ?? */
991	break;
992	}
993
994	pvBuf = (const uint8_t *)pvPageBuf;
995	pvBuf += offset;
996
997	bReleaseLocked = true;
998	}
999
1000	rc = vboxVDMACmdExec(pVdma, pvBuf, pCmd->cbBuf);
1001	AssertRC(rc);
1002
1003	if (bReleaseLocked)
1004	PDMDevHlpPhysReleasePageMappingLock(pDevIns, &Lock);
1005	} while (0);
1006
1007	pCmd->rc = rc;
1008
1009	rc = VBoxSHGSMICommandComplete (pHgsmi, pCmd);
1010	AssertRC(rc);
1011	}
1012
1013	static void vboxVDMAControlProcess(PVBOXVDMAHOST pVdma, PVBOXVDMA_CTL pCmd)
1014	{
1015	PHGSMIINSTANCE pHgsmi = pVdma->pHgsmi;
1016	pCmd->i32Result = VINF_SUCCESS;
1017	int rc = VBoxSHGSMICommandComplete (pHgsmi, pCmd);
1018	AssertRC(rc);
1019	}
1020
1021	#ifdef VBOX_VDMA_WITH_WORKERTHREAD
1022	typedef struct
1023	{
1024	struct VBOXVDMAHOST *pVdma;
1025	VBOXVDMAPIPE_CMD_BODY Cmd;
1026	bool bHasCmd;
1027	} VBOXVDMACMD_PROCESS_CONTEXT, *PVBOXVDMACMD_PROCESS_CONTEXT;
1028
1029	static DECLCALLBACK(bool) vboxVDMACommandProcessCb(PVBOXVDMAPIPE pPipe, void *pvCallback)
1030	{
1031	PVBOXVDMACMD_PROCESS_CONTEXT pContext = (PVBOXVDMACMD_PROCESS_CONTEXT)pvCallback;
1032	struct VBOXVDMAHOST *pVdma = pContext->pVdma;
1033	HGSMILISTENTRY *pEntry = hgsmiListRemoveHead(&pVdma->PendingList);
1034	if (pEntry)
1035	{
1036	PVBOXVDMAPIPE_CMD pPipeCmd = VBOXVDMAPIPE_CMD_FROM_ENTRY(pEntry);
1037	Assert(pPipeCmd);
1038	pContext->Cmd = pPipeCmd->Cmd;
1039	hgsmiListPrepend(&pVdma->CmdPool.List, pEntry);
1040	pContext->bHasCmd = true;
1041	return true;
1042	}
1043
1044	pContext->bHasCmd = false;
1045	return false;
1046	}
1047
1048	static DECLCALLBACK(int) vboxVDMAWorkerThread(RTTHREAD ThreadSelf, void *pvUser)
1049	{
1050	PVBOXVDMAHOST pVdma = (PVBOXVDMAHOST)pvUser;
1051	PHGSMIINSTANCE pHgsmi = pVdma->pHgsmi;
1052	VBOXVDMACMD_PROCESS_CONTEXT Context;
1053	Context.pVdma = pVdma;
1054
1055	int rc = vboxVDMAPipeOpenServer(&pVdma->Pipe);
1056	AssertRC(rc);
1057	if (RT_SUCCESS(rc))
1058	{
1059	do
1060	{
1061	rc = vboxVDMAPipeModifyServer(&pVdma->Pipe, vboxVDMACommandProcessCb, &Context);
1062	AssertRC(rc);
1063	if (RT_SUCCESS(rc))
1064	{
1065	switch (Context.Cmd.enmType)
1066	{
1067	case VBOXVDMAPIPE_CMD_TYPE_DMACMD:
1068	{
1069	PVBOXVDMACBUF_DR pDr = Context.Cmd.u.pDr;
1070	vboxVDMACommandProcess(pVdma, pDr);
1071	break;
1072	}
1073	case VBOXVDMAPIPE_CMD_TYPE_DMACTL:
1074	{
1075	PVBOXVDMA_CTL pCtl = Context.Cmd.u.pCtl;
1076	vboxVDMAControlProcess(pVdma, pCtl);
1077	break;
1078	}
1079	default:
1080	AssertBreakpoint();
1081	break;
1082	}
1083
1084	if (rc == VINF_EOF)
1085	{
1086	rc = VINF_SUCCESS;
1087	break;
1088	}
1089	}
1090	else
1091	break;
1092	} while (1);
1093	}
1094
1095	/* always try to close the pipe to make sure the client side is notified */
1096	int tmpRc = vboxVDMAPipeCloseServer(&pVdma->Pipe);
1097	AssertRC(tmpRc);
1098	return rc;
1099	}
1100	#endif
1101
1102	#ifdef VBOX_VDMA_WITH_WATCHDOG
1103	static DECLCALLBACK(void) vboxVDMAWatchDogTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
1104	{
1105	VBOXVDMAHOST pVdma = (VBOXVDMAHOST )pvUser;
1106	PVGASTATE pVGAState = pVdma->pVGAState;
1107	VBVARaiseIrq(pVGAState, HGSMIHOSTFLAGS_WATCHDOG);
1108	}
1109
1110	static int vboxVDMAWatchDogCtl(struct VBOXVDMAHOST *pVdma, uint32_t cMillis)
1111	{
1112	PPDMDEVINS pDevIns = pVdma->pVGAState->pDevInsR3;
1113	if (cMillis)
1114	TMTimerSetMillies(pVdma->WatchDogTimer, cMillis);
1115	else
1116	TMTimerStop(pVdma->WatchDogTimer);
1117	return VINF_SUCCESS;
1118	}
1119	#endif
1120
1121	int vboxVDMAConstruct(PVGASTATE pVGAState, uint32_t cPipeElements)
1122	{
1123	int rc;
1124	#ifdef VBOX_VDMA_WITH_WORKERTHREAD
1125	PVBOXVDMAHOST pVdma = (PVBOXVDMAHOST)RTMemAllocZ(RT_OFFSETOF(VBOXVDMAHOST, CmdPool.aCmds[cPipeElements]));
1126	#else
1127	PVBOXVDMAHOST pVdma = (PVBOXVDMAHOST)RTMemAllocZ(sizeof(*pVdma));
1128	#endif
1129	Assert(pVdma);
1130	if (pVdma)
1131	{
1132	pVdma->pHgsmi = pVGAState->pHGSMI;
1133	pVdma->pVGAState = pVGAState;
1134
1135	#ifdef VBOX_VDMA_WITH_WATCHDOG
1136	rc = PDMDevHlpTMTimerCreate(pVGAState->pDevInsR3, TMCLOCK_REAL, vboxVDMAWatchDogTimer,
1137	pVdma, TMTIMER_FLAGS_NO_CRIT_SECT,
1138	"VDMA WatchDog Timer", &pVdma->WatchDogTimer);
1139	AssertRC(rc);
1140	#endif
1141	#ifdef VBOX_VDMA_WITH_WORKERTHREAD
1142	hgsmiListInit(&pVdma->PendingList);
1143	rc = vboxVDMAPipeConstruct(&pVdma->Pipe);
1144	AssertRC(rc);
1145	if (RT_SUCCESS(rc))
1146	{
1147	rc = RTThreadCreate(&pVdma->hWorkerThread, vboxVDMAWorkerThread, pVdma, 0, RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE, "VDMA");
1148	AssertRC(rc);
1149	if (RT_SUCCESS(rc))
1150	{
1151	hgsmiListInit(&pVdma->CmdPool.List);
1152	pVdma->CmdPool.cCmds = cPipeElements;
1153	for (uint32_t i = 0; i < cPipeElements; ++i)
1154	{
1155	hgsmiListAppend(&pVdma->CmdPool.List, &pVdma->CmdPool.aCmds[i].Entry);
1156	}
1157	# if 0 //def VBOX_WITH_CRHGSMI
1158	int tmpRc = vboxVDMACrCtlHgsmiSetup(pVdma);
1159	# endif
1160	#endif
1161	pVGAState->pVdma = pVdma;
1162	#ifdef VBOX_WITH_CRHGSMI
1163	int rcIgnored = vboxVDMACrCtlHgsmiSetup(pVdma); NOREF(rcIgnored); /** @todo is this ignoring intentional? */
1164	#endif
1165	return VINF_SUCCESS;
1166	#ifdef VBOX_VDMA_WITH_WORKERTHREAD
1167	}
1168
1169	int tmpRc = vboxVDMAPipeDestruct(&pVdma->Pipe);
1170	AssertRC(tmpRc);
1171	}
1172
1173	RTMemFree(pVdma);
1174	#endif
1175	}
1176	else
1177	rc = VERR_OUT_OF_RESOURCES;
1178
1179	return rc;
1180	}
1181
1182	int vboxVDMADestruct(struct VBOXVDMAHOST *pVdma)
1183	{
1184	#ifdef VBOX_VDMA_WITH_WORKERTHREAD
1185	/* @todo: implement*/
1186	AssertBreakpoint();
1187	#endif
1188	RTMemFree(pVdma);
1189	return VINF_SUCCESS;
1190	}
1191
1192	#ifdef VBOX_VDMA_WITH_WORKERTHREAD
1193	typedef struct
1194	{
1195	struct VBOXVDMAHOST *pVdma;
1196	VBOXVDMAPIPE_CMD_BODY Cmd;
1197	bool bQueued;
1198	} VBOXVDMACMD_SUBMIT_CONTEXT, *PVBOXVDMACMD_SUBMIT_CONTEXT;
1199
1200	DECLCALLBACK(bool) vboxVDMACommandSubmitCb(PVBOXVDMAPIPE pPipe, void *pvCallback)
1201	{
1202	PVBOXVDMACMD_SUBMIT_CONTEXT pContext = (PVBOXVDMACMD_SUBMIT_CONTEXT)pvCallback;
1203	struct VBOXVDMAHOST *pVdma = pContext->pVdma;
1204	HGSMILISTENTRY *pEntry = hgsmiListRemoveHead(&pVdma->CmdPool.List);
1205	Assert(pEntry);
1206	if (pEntry)
1207	{
1208	PVBOXVDMAPIPE_CMD pPipeCmd = VBOXVDMAPIPE_CMD_FROM_ENTRY(pEntry);
1209	pPipeCmd->Cmd = pContext->Cmd;
1210	VBoxSHGSMICommandMarkAsynchCompletion(pContext->Cmd.u.pvCmd);
1211	pContext->bQueued = true;
1212	hgsmiListAppend(&pVdma->PendingList, pEntry);
1213	return true;
1214	}
1215
1216	/* @todo: should we try to flush some commands here? */
1217	pContext->bQueued = false;
1218	return false;
1219	}
1220	#endif
1221
1222	int vboxVDMASaveStateExecPrep(struct VBOXVDMAHOST *pVdma, PSSMHANDLE pSSM)
1223	{
1224	#ifdef VBOX_WITH_CRHGSMI
1225	PVGASTATE pVGAState = pVdma->pVGAState;
1226	PVBOXVDMACMD_CHROMIUM_CTL pCmd = (PVBOXVDMACMD_CHROMIUM_CTL)vboxVDMACrCtlCreate(
1227	VBOXVDMACMD_CHROMIUM_CTL_TYPE_SAVESTATE_BEGIN, sizeof (*pCmd));
1228	Assert(pCmd);
1229	if (pCmd)
1230	{
1231	int rc = vboxVDMACrCtlPost(pVGAState, pCmd, sizeof (*pCmd));
1232	AssertRC(rc);
1233	if (RT_SUCCESS(rc))
1234	{
1235	rc = vboxVDMACrCtlGetRc(pCmd);
1236	}
1237	vboxVDMACrCtlRelease(pCmd);
1238	return rc;
1239	}
1240	return VERR_NO_MEMORY;
1241	#else
1242	return VINF_SUCCESS;
1243	#endif
1244	}
1245
1246	int vboxVDMASaveStateExecDone(struct VBOXVDMAHOST *pVdma, PSSMHANDLE pSSM)
1247	{
1248	#ifdef VBOX_WITH_CRHGSMI
1249	PVGASTATE pVGAState = pVdma->pVGAState;
1250	PVBOXVDMACMD_CHROMIUM_CTL pCmd = (PVBOXVDMACMD_CHROMIUM_CTL)vboxVDMACrCtlCreate(
1251	VBOXVDMACMD_CHROMIUM_CTL_TYPE_SAVESTATE_END, sizeof (*pCmd));
1252	Assert(pCmd);
1253	if (pCmd)
1254	{
1255	int rc = vboxVDMACrCtlPost(pVGAState, pCmd, sizeof (*pCmd));
1256	AssertRC(rc);
1257	if (RT_SUCCESS(rc))
1258	{
1259	rc = vboxVDMACrCtlGetRc(pCmd);
1260	}
1261	vboxVDMACrCtlRelease(pCmd);
1262	return rc;
1263	}
1264	return VERR_NO_MEMORY;
1265	#else
1266	return VINF_SUCCESS;
1267	#endif
1268	}
1269
1270	void vboxVDMAControl(struct VBOXVDMAHOST *pVdma, PVBOXVDMA_CTL pCmd, uint32_t cbCmd)
1271	{
1272	#if 1
1273	PHGSMIINSTANCE pIns = pVdma->pHgsmi;
1274
1275	switch (pCmd->enmCtl)
1276	{
1277	case VBOXVDMA_CTL_TYPE_ENABLE:
1278	pCmd->i32Result = VINF_SUCCESS;
1279	break;
1280	case VBOXVDMA_CTL_TYPE_DISABLE:
1281	pCmd->i32Result = VINF_SUCCESS;
1282	break;
1283	case VBOXVDMA_CTL_TYPE_FLUSH:
1284	pCmd->i32Result = VINF_SUCCESS;
1285	break;
1286	#ifdef VBOX_VDMA_WITH_WATCHDOG
1287	case VBOXVDMA_CTL_TYPE_WATCHDOG:
1288	pCmd->i32Result = vboxVDMAWatchDogCtl(pVdma, pCmd->u32Offset);
1289	break;
1290	#endif
1291	default:
1292	AssertBreakpoint();
1293	pCmd->i32Result = VERR_NOT_SUPPORTED;
1294	}
1295
1296	int rc = VBoxSHGSMICommandComplete (pIns, pCmd);
1297	AssertRC(rc);
1298	#else
1299	/* test asinch completion */
1300	VBOXVDMACMD_SUBMIT_CONTEXT Context;
1301	Context.pVdma = pVdma;
1302	Context.Cmd.enmType = VBOXVDMAPIPE_CMD_TYPE_DMACTL;
1303	Context.Cmd.u.pCtl = pCmd;
1304
1305	int rc = vboxVDMAPipeModifyClient(&pVdma->Pipe, vboxVDMACommandSubmitCb, &Context);
1306	AssertRC(rc);
1307	if (RT_SUCCESS(rc))
1308	{
1309	Assert(Context.bQueued);
1310	if (Context.bQueued)
1311	{
1312	/* success */
1313	return;
1314	}
1315	rc = VERR_OUT_OF_RESOURCES;
1316	}
1317
1318	/* failure */
1319	Assert(RT_FAILURE(rc));
1320	PHGSMIINSTANCE pIns = pVdma->pHgsmi;
1321	pCmd->i32Result = rc;
1322	int tmpRc = VBoxSHGSMICommandComplete (pIns, pCmd);
1323	AssertRC(tmpRc);
1324
1325	#endif
1326	}
1327
1328	void vboxVDMACommand(struct VBOXVDMAHOST *pVdma, PVBOXVDMACBUF_DR pCmd, uint32_t cbCmd)
1329	{
1330	int rc = VERR_NOT_IMPLEMENTED;
1331
1332	#ifdef VBOX_WITH_CRHGSMI
1333	/* chromium commands are processed by crhomium hgcm thread independently from our internal cmd processing pipeline
1334	* this is why we process them specially */
1335	rc = vboxVDMACmdCheckCrCmd(pVdma, pCmd, cbCmd);
1336	if (rc == VINF_SUCCESS)
1337	return;
1338
1339	if (RT_FAILURE(rc))
1340	{
1341	pCmd->rc = rc;
1342	rc = VBoxSHGSMICommandComplete (pVdma->pHgsmi, pCmd);
1343	AssertRC(rc);
1344	return;
1345	}
1346	#endif
1347
1348	#ifndef VBOX_VDMA_WITH_WORKERTHREAD
1349	vboxVDMACommandProcess(pVdma, pCmd, cbCmd);
1350	#else
1351
1352	# ifdef DEBUG_misha
1353	Assert(0);
1354	# endif
1355
1356	VBOXVDMACMD_SUBMIT_CONTEXT Context;
1357	Context.pVdma = pVdma;
1358	Context.Cmd.enmType = VBOXVDMAPIPE_CMD_TYPE_DMACMD;
1359	Context.Cmd.u.pDr = pCmd;
1360
1361	rc = vboxVDMAPipeModifyClient(&pVdma->Pipe, vboxVDMACommandSubmitCb, &Context);
1362	AssertRC(rc);
1363	if (RT_SUCCESS(rc))
1364	{
1365	Assert(Context.bQueued);
1366	if (Context.bQueued)
1367	{
1368	/* success */
1369	return;
1370	}
1371	rc = VERR_OUT_OF_RESOURCES;
1372	}
1373	/* failure */
1374	Assert(RT_FAILURE(rc));
1375	PHGSMIINSTANCE pIns = pVdma->pHgsmi;
1376	pCmd->rc = rc;
1377	int tmpRc = VBoxSHGSMICommandComplete (pIns, pCmd);
1378	AssertRC(tmpRc);
1379	#endif
1380	}

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

source: vbox/trunk/src/VBox/Devices/Graphics/DevVGA_VDMA.cpp@ 45305

Download in other formats: