HGSMIBase.cpp@ 59240

Last change on this file since 59240 was 59240, checked in by vboxsync, 9 years ago
bugref:8087: Additions/x11: support non-root X server: add host flags location reporting to the kernel graphics driver in preparation for adding IRQ handling. Among other things, the host uses the flags, which it places at the location reported/requested by the guest in video RAM, to tell the guest what event the IRQ was sent in response to.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 24.8 KB

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

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

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

Download in other formats: