HGSMIBase.cpp@ 65661

Last change on this file since 65661 was 65381, checked in by vboxsync, 8 years ago
bugref:8282: Additions/linux: submit DRM driver to the Linux kernel: move all graphics device-related header files to a separate sub-directory and add that to the include path where they are needed. The intention is too be able to remove the VBox/ include folder in the DRM driver package.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 25.1 KB

Line
1	/* $Id: HGSMIBase.cpp 65381 2017-01-20 09:23:53Z vboxsync $ */
2	/** @file
3	* VirtualBox Video driver, common code - HGSMI initialisation and helper
4	* functions.
5	*/
6
7	/*
8	* Copyright (C) 2006-2016 Oracle Corporation
9	*
10	* This file is part of VirtualBox Open Source Edition (OSE), as
11	* available from http://www.virtualbox.org. This file is free software;
12	* you can redistribute it and/or modify it under the terms of the GNU
13	* General Public License (GPL) as published by the Free Software
14	* Foundation, in version 2 as it comes in the "COPYING" file of the
15	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
16	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
17	*/
18
19	#include <VBoxVideoGuest.h>
20	#include <VBoxVideoVBE.h>
21
22	#include <iprt/asm.h>
23	#include <iprt/string.h>
24
25	/** Send completion notification to the host for the command located at offset
26	* @a offt into the host command buffer. */
27	static void HGSMINotifyHostCmdComplete(PHGSMIHOSTCOMMANDCONTEXT pCtx, HGSMIOFFSET offt)
28	{
29	VBoxVideoCmnPortWriteUlong(pCtx->port, offt);
30	}
31
32
33	/**
34	* Inform the host that a command has been handled.
35	*
36	* @param pCtx the context containing the heap to be used
37	* @param pvMem pointer into the heap as mapped in @a pCtx to the command to
38	* be completed
39	*/
40	DECLHIDDEN(void) VBoxHGSMIHostCmdComplete(PHGSMIHOSTCOMMANDCONTEXT pCtx,
41	void *pvMem)
42	{
43	HGSMIBUFFERHEADER *pHdr = HGSMIBufferHeaderFromData(pvMem);
44	HGSMIOFFSET offMem = HGSMIPointerToOffset(&pCtx->areaCtx, pHdr);
45	VBVOAssert(offMem != HGSMIOFFSET_VOID);
46	if(offMem != HGSMIOFFSET_VOID)
47	{
48	HGSMINotifyHostCmdComplete(pCtx, offMem);
49	}
50	}
51
52
53	/** Submit an incoming host command to the appropriate handler. */
54	static void hgsmiHostCmdProcess(PHGSMIHOSTCOMMANDCONTEXT pCtx,
55	HGSMIOFFSET offBuffer)
56	{
57	int rc = HGSMIBufferProcess(&pCtx->areaCtx, &pCtx->channels, offBuffer);
58	VBVOAssert(!RT_FAILURE(rc));
59	if(RT_FAILURE(rc))
60	{
61	/* failure means the command was not submitted to the handler for some reason
62	* it's our responsibility to notify its completion in this case */
63	HGSMINotifyHostCmdComplete(pCtx, offBuffer);
64	}
65	/* if the cmd succeeded it's responsibility of the callback to complete it */
66	}
67
68	/** Get the next command from the host. */
69	static HGSMIOFFSET hgsmiGetHostBuffer(PHGSMIHOSTCOMMANDCONTEXT pCtx)
70	{
71	return VBoxVideoCmnPortReadUlong(pCtx->port);
72	}
73
74
75	/** Get and handle the next command from the host. */
76	static void hgsmiHostCommandQueryProcess(PHGSMIHOSTCOMMANDCONTEXT pCtx)
77	{
78	HGSMIOFFSET offset = hgsmiGetHostBuffer(pCtx);
79	VBVOAssertReturnVoid(offset != HGSMIOFFSET_VOID);
80	hgsmiHostCmdProcess(pCtx, offset);
81	}
82
83
84	/** Drain the host command queue. */
85	DECLHIDDEN(void) VBoxHGSMIProcessHostQueue(PHGSMIHOSTCOMMANDCONTEXT pCtx)
86	{
87	while (pCtx->pfHostFlags->u32HostFlags & HGSMIHOSTFLAGS_COMMANDS_PENDING)
88	{
89	if (!ASMAtomicCmpXchgBool(&pCtx->fHostCmdProcessing, true, false))
90	return;
91	hgsmiHostCommandQueryProcess(pCtx);
92	ASMAtomicWriteBool(&pCtx->fHostCmdProcessing, false);
93	}
94	}
95
96
97	/** Detect whether HGSMI is supported by the host. */
98	DECLHIDDEN(bool) VBoxHGSMIIsSupported(void)
99	{
100	uint16_t DispiId;
101
102	VBoxVideoCmnPortWriteUshort(VBE_DISPI_IOPORT_INDEX, VBE_DISPI_INDEX_ID);
103	VBoxVideoCmnPortWriteUshort(VBE_DISPI_IOPORT_DATA, VBE_DISPI_ID_HGSMI);
104
105	DispiId = VBoxVideoCmnPortReadUshort(VBE_DISPI_IOPORT_DATA);
106
107	return (DispiId == VBE_DISPI_ID_HGSMI);
108	}
109
110
111	/**
112	* Allocate and initialise a command descriptor in the guest heap for a
113	* guest-to-host command.
114	*
115	* @returns pointer to the descriptor's command data buffer
116	* @param pCtx the context containing the heap to be used
117	* @param cbData the size of the command data to go into the descriptor
118	* @param u8Ch the HGSMI channel to be used, set to the descriptor
119	* @param u16Op the HGSMI command to be sent, set to the descriptor
120	*/
121	DECLHIDDEN(void *) VBoxHGSMIBufferAlloc(PHGSMIGUESTCOMMANDCONTEXT pCtx,
122	HGSMISIZE cbData,
123	uint8_t u8Ch,
124	uint16_t u16Op)
125	{
126	#ifdef VBOX_WDDM_MINIPORT
127	return VBoxSHGSMIHeapAlloc (&pCtx->heapCtx, cbData, u8Ch, u16Op);
128	#else
129	return HGSMIHeapAlloc (&pCtx->heapCtx, cbData, u8Ch, u16Op);
130	#endif
131	}
132
133
134	/**
135	* Free a descriptor allocated by @a VBoxHGSMIBufferAlloc.
136	*
137	* @param pCtx the context containing the heap used
138	* @param pvBuffer the pointer returned by @a VBoxHGSMIBufferAlloc
139	*/
140	DECLHIDDEN(void) VBoxHGSMIBufferFree(PHGSMIGUESTCOMMANDCONTEXT pCtx,
141	void *pvBuffer)
142	{
143	#ifdef VBOX_WDDM_MINIPORT
144	VBoxSHGSMIHeapFree (&pCtx->heapCtx, pvBuffer);
145	#else
146	HGSMIHeapFree (&pCtx->heapCtx, pvBuffer);
147	#endif
148	}
149
150
151	/**
152	* Submit a command descriptor allocated by @a VBoxHGSMIBufferAlloc.
153	*
154	* @param pCtx the context containing the heap used
155	* @param pvBuffer the pointer returned by @a VBoxHGSMIBufferAlloc
156	*/
157	DECLHIDDEN(int) VBoxHGSMIBufferSubmit(PHGSMIGUESTCOMMANDCONTEXT pCtx,
158	void *pvBuffer)
159	{
160	/* Initialize the buffer and get the offset for port IO. */
161	HGSMIOFFSET offBuffer = HGSMIHeapBufferOffset (HGSMIGUESTCMDHEAP_GET(&pCtx->heapCtx), pvBuffer);
162
163	VBVOAssert(offBuffer != HGSMIOFFSET_VOID);
164	if (offBuffer != HGSMIOFFSET_VOID)
165	{
166	/* Submit the buffer to the host. */
167	VBoxVideoCmnPortWriteUlong(pCtx->port, offBuffer);
168	/* Make the compiler aware that the host has changed memory. */
169	ASMCompilerBarrier();
170	return VINF_SUCCESS;
171	}
172
173	return VERR_INVALID_PARAMETER;
174	}
175
176
177	/** Inform the host of the location of the host flags in VRAM via an HGSMI
178	* command. */
179	static int vboxHGSMIReportFlagsLocation(PHGSMIGUESTCOMMANDCONTEXT pCtx,
180	HGSMIOFFSET offLocation)
181	{
182	HGSMIBUFFERLOCATION *p;
183	int rc = VINF_SUCCESS;
184
185	/* Allocate the IO buffer. */
186	p = (HGSMIBUFFERLOCATION *)VBoxHGSMIBufferAlloc(pCtx,
187	sizeof(HGSMIBUFFERLOCATION),
188	HGSMI_CH_HGSMI,
189	HGSMI_CC_HOST_FLAGS_LOCATION);
190	if (p)
191	{
192	/* Prepare data to be sent to the host. */
193	p->offLocation = offLocation;
194	p->cbLocation = sizeof(HGSMIHOSTFLAGS);
195	rc = VBoxHGSMIBufferSubmit(pCtx, p);
196	/* Free the IO buffer. */
197	VBoxHGSMIBufferFree(pCtx, p);
198	}
199	else
200	rc = VERR_NO_MEMORY;
201	return rc;
202	}
203
204
205	/**
206	* Inform the host of the location of the host flags in VRAM via an HGSMI
207	* command.
208	* @returns IPRT status value.
209	* @returns VERR_NOT_IMPLEMENTED if the host does not support the command.
210	* @returns VERR_NO_MEMORY if a heap allocation fails.
211	* @param pCtx the context of the guest heap to use.
212	* @param offLocation the offset chosen for the flags withing guest
213	* VRAM.
214	*/
215	DECLHIDDEN(int) VBoxHGSMIReportFlagsLocation(PHGSMIGUESTCOMMANDCONTEXT pCtx,
216	HGSMIOFFSET offLocation)
217	{
218	return vboxHGSMIReportFlagsLocation(pCtx, offLocation);
219	}
220
221
222	/** Notify the host of HGSMI-related guest capabilities via an HGSMI command.
223	*/
224	static int vboxHGSMISendCapsInfo(PHGSMIGUESTCOMMANDCONTEXT pCtx,
225	uint32_t fCaps)
226	{
227	VBVACAPS *pCaps;
228	int rc = VINF_SUCCESS;
229
230	/* Allocate the IO buffer. */
231	pCaps = (VBVACAPS *)VBoxHGSMIBufferAlloc(pCtx,
232	sizeof(VBVACAPS), HGSMI_CH_VBVA,
233	VBVA_INFO_CAPS);
234
235	if (pCaps)
236	{
237	/* Prepare data to be sent to the host. */
238	pCaps->rc = VERR_NOT_IMPLEMENTED;
239	pCaps->fCaps = fCaps;
240	rc = VBoxHGSMIBufferSubmit(pCtx, pCaps);
241	if (RT_SUCCESS(rc))
242	{
243	VBVOAssertRC(pCaps->rc);
244	rc = pCaps->rc;
245	}
246	/* Free the IO buffer. */
247	VBoxHGSMIBufferFree(pCtx, pCaps);
248	}
249	else
250	rc = VERR_NO_MEMORY;
251	return rc;
252	}
253
254
255	/**
256	* Notify the host of HGSMI-related guest capabilities via an HGSMI command.
257	* @returns IPRT status value.
258	* @returns VERR_NOT_IMPLEMENTED if the host does not support the command.
259	* @returns VERR_NO_MEMORY if a heap allocation fails.
260	* @param pCtx the context of the guest heap to use.
261	* @param fCaps the capabilities to report, see VBVACAPS.
262	*/
263	DECLHIDDEN(int) VBoxHGSMISendCapsInfo(PHGSMIGUESTCOMMANDCONTEXT pCtx,
264	uint32_t fCaps)
265	{
266	return vboxHGSMISendCapsInfo(pCtx, fCaps);
267	}
268
269
270	/** Tell the host about the location of the area of VRAM set aside for the host
271	* heap. */
272	static int vboxHGSMIReportHostArea(PHGSMIGUESTCOMMANDCONTEXT pCtx,
273	uint32_t u32AreaOffset, uint32_t u32AreaSize)
274	{
275	VBVAINFOHEAP *p;
276	int rc = VINF_SUCCESS;
277
278	/* Allocate the IO buffer. */
279	p = (VBVAINFOHEAP *)VBoxHGSMIBufferAlloc(pCtx,
280	sizeof (VBVAINFOHEAP), HGSMI_CH_VBVA,
281	VBVA_INFO_HEAP);
282	if (p)
283	{
284	/* Prepare data to be sent to the host. */
285	p->u32HeapOffset = u32AreaOffset;
286	p->u32HeapSize = u32AreaSize;
287	rc = VBoxHGSMIBufferSubmit(pCtx, p);
288	/* Free the IO buffer. */
289	VBoxHGSMIBufferFree(pCtx, p);
290	}
291	else
292	rc = VERR_NO_MEMORY;
293	return rc;
294	}
295
296
297	/**
298	* Get the information needed to map the basic communication structures in
299	* device memory into our address space. All pointer parameters are optional.
300	*
301	* @param cbVRAM how much video RAM is allocated to the device
302	* @param poffVRAMBaseMapping where to save the offset from the start of the
303	* device VRAM of the whole area to map
304	* @param pcbMapping where to save the mapping size
305	* @param poffGuestHeapMemory where to save the offset into the mapped area
306	* of the guest heap backing memory
307	* @param pcbGuestHeapMemory where to save the size of the guest heap
308	* backing memory
309	* @param poffHostFlags where to save the offset into the mapped area
310	* of the host flags
311	*/
312	DECLHIDDEN(void) VBoxHGSMIGetBaseMappingInfo(uint32_t cbVRAM,
313	uint32_t *poffVRAMBaseMapping,
314	uint32_t *pcbMapping,
315	uint32_t *poffGuestHeapMemory,
316	uint32_t *pcbGuestHeapMemory,
317	uint32_t *poffHostFlags)
318	{
319	VBVOAssertPtrNullReturnVoid(poffVRAMBaseMapping);
320	VBVOAssertPtrNullReturnVoid(pcbMapping);
321	VBVOAssertPtrNullReturnVoid(poffGuestHeapMemory);
322	VBVOAssertPtrNullReturnVoid(pcbGuestHeapMemory);
323	VBVOAssertPtrNullReturnVoid(poffHostFlags);
324	if (poffVRAMBaseMapping)
325	*poffVRAMBaseMapping = cbVRAM - VBVA_ADAPTER_INFORMATION_SIZE;
326	if (pcbMapping)
327	*pcbMapping = VBVA_ADAPTER_INFORMATION_SIZE;
328	if (poffGuestHeapMemory)
329	*poffGuestHeapMemory = 0;
330	if (pcbGuestHeapMemory)
331	*pcbGuestHeapMemory = VBVA_ADAPTER_INFORMATION_SIZE
332	- sizeof(HGSMIHOSTFLAGS);
333	if (poffHostFlags)
334	*poffHostFlags = VBVA_ADAPTER_INFORMATION_SIZE
335	- sizeof(HGSMIHOSTFLAGS);
336	}
337
338
339	/**
340	* Set up the HGSMI guest-to-host command context.
341	* @returns iprt status value
342	* @param pCtx the context to set up
343	* @param pvGuestHeapMemory a pointer to the mapped backing memory for
344	* the guest heap
345	* @param cbGuestHeapMemory the size of the backing memory area
346	* @param offVRAMGuestHeapMemory the offset of the memory pointed to by
347	* @a pvGuestHeapMemory within the video RAM
348	* @param pEnv HGSMI environment.
349	*/
350	DECLHIDDEN(int) VBoxHGSMISetupGuestContext(PHGSMIGUESTCOMMANDCONTEXT pCtx,
351	void *pvGuestHeapMemory,
352	uint32_t cbGuestHeapMemory,
353	uint32_t offVRAMGuestHeapMemory,
354	const HGSMIENV *pEnv)
355	{
356	/** @todo should we be using a fixed ISA port value here? */
357	pCtx->port = (RTIOPORT)VGA_PORT_HGSMI_GUEST;
358	#ifdef VBOX_WDDM_MINIPORT
359	return VBoxSHGSMIInit(&pCtx->heapCtx, pvGuestHeapMemory,
360	cbGuestHeapMemory, offVRAMGuestHeapMemory, pEnv);
361	#else
362	return HGSMIHeapSetup(&pCtx->heapCtx, pvGuestHeapMemory,
363	cbGuestHeapMemory, offVRAMGuestHeapMemory, pEnv);
364	#endif
365	}
366
367
368	/**
369	* Get the information needed to map the area used by the host to send back
370	* requests.
371	*
372	* @param pCtx the context containing the heap to use
373	* @param cbVRAM how much video RAM is allocated to the device
374	* @param offVRAMBaseMapping the offset of the basic communication structures
375	* into the guest's VRAM
376	* @param poffVRAMHostArea where to store the offset into VRAM of the host
377	* heap area
378	* @param pcbHostArea where to store the size of the host heap area
379	*/
380	DECLHIDDEN(void) VBoxHGSMIGetHostAreaMapping(PHGSMIGUESTCOMMANDCONTEXT pCtx,
381	uint32_t cbVRAM,
382	uint32_t offVRAMBaseMapping,
383	uint32_t *poffVRAMHostArea,
384	uint32_t *pcbHostArea)
385	{
386	uint32_t offVRAMHostArea = offVRAMBaseMapping, cbHostArea = 0;
387
388	VBVOAssertPtrReturnVoid(poffVRAMHostArea);
389	VBVOAssertPtrReturnVoid(pcbHostArea);
390	VBoxQueryConfHGSMI(pCtx, VBOX_VBVA_CONF32_HOST_HEAP_SIZE, &cbHostArea);
391	if (cbHostArea != 0)
392	{
393	uint32_t cbHostAreaMaxSize = cbVRAM / 4;
394	/** @todo what is the idea of this? */
395	if (cbHostAreaMaxSize >= VBVA_ADAPTER_INFORMATION_SIZE)
396	{
397	cbHostAreaMaxSize -= VBVA_ADAPTER_INFORMATION_SIZE;
398	}
399	if (cbHostArea > cbHostAreaMaxSize)
400	{
401	cbHostArea = cbHostAreaMaxSize;
402	}
403	/* Round up to 4096 bytes. */
404	cbHostArea = (cbHostArea + 0xFFF) & ~0xFFF;
405	offVRAMHostArea = offVRAMBaseMapping - cbHostArea;
406	}
407
408	*pcbHostArea = cbHostArea;
409	*poffVRAMHostArea = offVRAMHostArea;
410	// LogFunc(("offVRAMHostArea = 0x%08X, cbHostArea = 0x%08X\n",
411	// offVRAMHostArea, cbHostArea));
412	}
413
414
415	/**
416	* Initialise the host context structure.
417	*
418	* @param pCtx the context structure to initialise
419	* @param pvBaseMapping where the basic HGSMI structures are mapped at
420	* @param offHostFlags the offset of the host flags into the basic HGSMI
421	* structures
422	* @param pvHostAreaMapping where the area for the host heap is mapped at
423	* @param offVRAMHostArea offset of the host heap area into VRAM
424	* @param cbHostArea size in bytes of the host heap area
425	*/
426	DECLHIDDEN(void) VBoxHGSMISetupHostContext(PHGSMIHOSTCOMMANDCONTEXT pCtx,
427	void *pvBaseMapping,
428	uint32_t offHostFlags,
429	void *pvHostAreaMapping,
430	uint32_t offVRAMHostArea,
431	uint32_t cbHostArea)
432	{
433	uint8_t pu8HostFlags = ((uint8_t )pvBaseMapping) + offHostFlags;
434	pCtx->pfHostFlags = (HGSMIHOSTFLAGS *)pu8HostFlags;
435	/** @todo should we really be using a fixed ISA port value here? */
436	pCtx->port = (RTIOPORT)VGA_PORT_HGSMI_HOST;
437	HGSMIAreaInitialize(&pCtx->areaCtx, pvHostAreaMapping, cbHostArea,
438	offVRAMHostArea);
439	}
440
441
442	/**
443	* Tell the host about the ways it can use to communicate back to us via an
444	* HGSMI command
445	*
446	* @returns iprt status value
447	* @param pCtx the context containing the heap to use
448	* @param offVRAMFlagsLocation where we wish the host to place its flags
449	* relative to the start of the VRAM
450	* @param fCaps additions HGSMI capabilities the guest
451	* supports
452	* @param offVRAMHostArea offset into VRAM of the host heap area
453	* @param cbHostArea size in bytes of the host heap area
454	*/
455	DECLHIDDEN(int) VBoxHGSMISendHostCtxInfo(PHGSMIGUESTCOMMANDCONTEXT pCtx,
456	HGSMIOFFSET offVRAMFlagsLocation,
457	uint32_t fCaps,
458	uint32_t offVRAMHostArea,
459	uint32_t cbHostArea)
460	{
461	// Log(("VBoxVideo::vboxSetupAdapterInfo\n"));
462
463	/* setup the flags first to ensure they are initialized by the time the
464	* host heap is ready */
465	int rc = vboxHGSMIReportFlagsLocation(pCtx, offVRAMFlagsLocation);
466	VBVOAssertRC(rc);
467	if (RT_SUCCESS(rc) && fCaps)
468	{
469	/* Inform about caps */
470	rc = vboxHGSMISendCapsInfo(pCtx, fCaps);
471	VBVOAssertRC(rc);
472	}
473	if (RT_SUCCESS (rc))
474	{
475	/* Report the host heap location. */
476	rc = vboxHGSMIReportHostArea(pCtx, offVRAMHostArea, cbHostArea);
477	VBVOAssertRC(rc);
478	}
479	// Log(("VBoxVideo::vboxSetupAdapterInfo finished rc = %d\n", rc));
480	return rc;
481	}
482
483
484	/** Sanity test on first call. We do not worry about concurrency issues. */
485	static int testQueryConf(PHGSMIGUESTCOMMANDCONTEXT pCtx)
486	{
487	static bool cOnce = false;
488	uint32_t ulValue = 0;
489	int rc;
490
491	if (cOnce)
492	return VINF_SUCCESS;
493	cOnce = true;
494	rc = VBoxQueryConfHGSMI(pCtx, UINT32_MAX, &ulValue);
495	if (RT_SUCCESS(rc) && ulValue == UINT32_MAX)
496	return VINF_SUCCESS;
497	cOnce = false;
498	if (RT_FAILURE(rc))
499	return rc;
500	return VERR_INTERNAL_ERROR;
501	}
502
503
504	/**
505	* Query the host for an HGSMI configuration parameter via an HGSMI command.
506	* @returns iprt status value
507	* @param pCtx the context containing the heap used
508	* @param u32Index the index of the parameter to query,
509	* @see VBVACONF32::u32Index
510	* @param u32DefValue defaut value
511	* @param pulValue where to store the value of the parameter on success
512	*/
513	DECLHIDDEN(int) VBoxQueryConfHGSMIDef(PHGSMIGUESTCOMMANDCONTEXT pCtx,
514	uint32_t u32Index, uint32_t u32DefValue, uint32_t *pulValue)
515	{
516	int rc = VINF_SUCCESS;
517	VBVACONF32 *p;
518	// LogFunc(("u32Index = %d\n", u32Index));
519
520	rc = testQueryConf(pCtx);
521	if (RT_FAILURE(rc))
522	return rc;
523	/* Allocate the IO buffer. */
524	p = (VBVACONF32 *)VBoxHGSMIBufferAlloc(pCtx,
525	sizeof(VBVACONF32), HGSMI_CH_VBVA,
526	VBVA_QUERY_CONF32);
527	if (p)
528	{
529	/* Prepare data to be sent to the host. */
530	p->u32Index = u32Index;
531	p->u32Value = u32DefValue;
532	rc = VBoxHGSMIBufferSubmit(pCtx, p);
533	if (RT_SUCCESS(rc))
534	{
535	*pulValue = p->u32Value;
536	// LogFunc(("u32Value = %d\n", p->u32Value));
537	}
538	/* Free the IO buffer. */
539	VBoxHGSMIBufferFree(pCtx, p);
540	}
541	else
542	rc = VERR_NO_MEMORY;
543	// LogFunc(("rc = %d\n", rc));
544	return rc;
545	}
546
547	DECLHIDDEN(int) VBoxQueryConfHGSMI(PHGSMIGUESTCOMMANDCONTEXT pCtx,
548	uint32_t u32Index, uint32_t *pulValue)
549	{
550	return VBoxQueryConfHGSMIDef(pCtx, u32Index, UINT32_MAX, pulValue);
551	}
552
553	/**
554	* Pass the host a new mouse pointer shape via an HGSMI command.
555	*
556	* @returns success or failure
557	* @param pCtx the context containing the heap to be used
558	* @param fFlags cursor flags, @see VMMDevReqMousePointer::fFlags
559	* @param cHotX horizontal position of the hot spot
560	* @param cHotY vertical position of the hot spot
561	* @param cWidth width in pixels of the cursor
562	* @param cHeight height in pixels of the cursor
563	* @param pPixels pixel data, @see VMMDevReqMousePointer for the format
564	* @param cbLength size in bytes of the pixel data
565	*/
566	DECLHIDDEN(int) VBoxHGSMIUpdatePointerShape(PHGSMIGUESTCOMMANDCONTEXT pCtx,
567	uint32_t fFlags,
568	uint32_t cHotX,
569	uint32_t cHotY,
570	uint32_t cWidth,
571	uint32_t cHeight,
572	uint8_t *pPixels,
573	uint32_t cbLength)
574	{
575	VBVAMOUSEPOINTERSHAPE *p;
576	uint32_t cbData = 0;
577	int rc = VINF_SUCCESS;
578
579	if (fFlags & VBOX_MOUSE_POINTER_SHAPE)
580	{
581	/* Size of the pointer data: sizeof (AND mask) + sizeof (XOR_MASK) */
582	cbData = ((((cWidth + 7) / 8) * cHeight + 3) & ~3)
583	+ cWidth * 4 * cHeight;
584	/* If shape is supplied, then always create the pointer visible.
585	* See comments in 'vboxUpdatePointerShape'
586	*/
587	fFlags \|= VBOX_MOUSE_POINTER_VISIBLE;
588	}
589	// LogFlowFunc(("cbData %d, %dx%d\n", cbData, cWidth, cHeight));
590	if (cbData > cbLength)
591	{
592	// LogFunc(("calculated pointer data size is too big (%d bytes, limit %d)\n",
593	// cbData, cbLength));
594	return VERR_INVALID_PARAMETER;
595	}
596	/* Allocate the IO buffer. */
597	p = (VBVAMOUSEPOINTERSHAPE *)VBoxHGSMIBufferAlloc(pCtx,
598	sizeof(VBVAMOUSEPOINTERSHAPE)
599	+ cbData,
600	HGSMI_CH_VBVA,
601	VBVA_MOUSE_POINTER_SHAPE);
602	if (p)
603	{
604	/* Prepare data to be sent to the host. */
605	/* Will be updated by the host. */
606	p->i32Result = VINF_SUCCESS;
607	/* We have our custom flags in the field */
608	p->fu32Flags = fFlags;
609	p->u32HotX = cHotX;
610	p->u32HotY = cHotY;
611	p->u32Width = cWidth;
612	p->u32Height = cHeight;
613	if (p->fu32Flags & VBOX_MOUSE_POINTER_SHAPE)
614	/* Copy the actual pointer data. */
615	memcpy (p->au8Data, pPixels, cbData);
616	rc = VBoxHGSMIBufferSubmit(pCtx, p);
617	if (RT_SUCCESS(rc))
618	rc = p->i32Result;
619	/* Free the IO buffer. */
620	VBoxHGSMIBufferFree(pCtx, p);
621	}
622	else
623	rc = VERR_NO_MEMORY;
624	// LogFlowFunc(("rc %d\n", rc));
625	return rc;
626	}
627
628
629	/**
630	* Report the guest cursor position. The host may wish to use this information
631	* to re-position its own cursor (though this is currently unlikely). The
632	* current host cursor position is returned.
633	* @param pCtx The context containing the heap used.
634	* @param fReportPosition Are we reporting a position?
635	* @param x Guest cursor X position.
636	* @param y Guest cursor Y position.
637	* @param pxHost Host cursor X position is stored here. Optional.
638	* @param pyHost Host cursor Y position is stored here. Optional.
639	* @returns iprt status code.
640	* @returns VERR_NO_MEMORY HGSMI heap allocation failed.
641	*/
642	DECLHIDDEN(int) VBoxHGSMICursorPosition(PHGSMIGUESTCOMMANDCONTEXT pCtx, bool fReportPosition, uint32_t x, uint32_t y,
643	uint32_t pxHost, uint32_t pyHost)
644	{
645	int rc = VINF_SUCCESS;
646	VBVACURSORPOSITION *p;
647	// Log(("%s: x=%u, y=%u\n", __PRETTY_FUNCTION__, (unsigned)x, (unsigned)y));
648
649	/* Allocate the IO buffer. */
650	p = (VBVACURSORPOSITION *)VBoxHGSMIBufferAlloc(pCtx, sizeof(VBVACURSORPOSITION), HGSMI_CH_VBVA, VBVA_CURSOR_POSITION);
651	if (p)
652	{
653	/* Prepare data to be sent to the host. */
654	p->fReportPosition = fReportPosition ? 1 : 0;
655	p->x = x;
656	p->y = y;
657	rc = VBoxHGSMIBufferSubmit(pCtx, p);
658	if (RT_SUCCESS(rc))
659	{
660	if (pxHost)
661	*pxHost = p->x;
662	if (pyHost)
663	*pyHost = p->y;
664	// Log(("%s: return: x=%u, y=%u\n", __PRETTY_FUNCTION__, (unsigned)p->x, (unsigned)p->y));
665	}
666	/* Free the IO buffer. */
667	VBoxHGSMIBufferFree(pCtx, p);
668	}
669	else
670	rc = VERR_NO_MEMORY;
671	// LogFunc(("rc = %d\n", rc));
672	return rc;
673	}
674
675
676	/** @todo Mouse pointer position to be read from VMMDev memory, address of the memory region
677	* can be queried from VMMDev via an IOCTL. This VMMDev memory region will contain
678	* host information which is needed by the guest.
679	*
680	* Reading will not cause a switch to the host.
681	*
682	* Have to take into account:
683	* * synchronization: host must write to the memory only from EMT,
684	* large structures must be read under flag, which tells the host
685	* that the guest is currently reading the memory (OWNER flag?).
686	* * guest writes: may be allocate a page for the host info and make
687	* the page readonly for the guest.
688	* * the information should be available only for additions drivers.
689	* * VMMDev additions driver will inform the host which version of the info it expects,
690	* host must support all versions.
691	*
692	*/

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

source: vbox/trunk/src/VBox/Additions/common/VBoxVideo/HGSMIBase.cpp@ 65661

Download in other formats: