pdmdev.h

Last change on this file was 106061, checked in by vboxsync, 2 months ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 407.6 KB

Line
1	/** @file
2	* PDM - Pluggable Device Manager, Devices.
3	*/
4
5	/*
6	* Copyright (C) 2006-2024 Oracle and/or its affiliates.
7	*
8	* This file is part of VirtualBox base platform packages, as
9	* available from https://www.virtualbox.org.
10	*
11	* This program is free software; you can redistribute it and/or
12	* modify it under the terms of the GNU General Public License
13	* as published by the Free Software Foundation, in version 3 of the
14	* License.
15	*
16	* This program is distributed in the hope that it will be useful, but
17	* WITHOUT ANY WARRANTY; without even the implied warranty of
18	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19	* General Public License for more details.
20	*
21	* You should have received a copy of the GNU General Public License
22	* along with this program; if not, see <https://www.gnu.org/licenses>.
23	*
24	* The contents of this file may alternatively be used under the terms
25	* of the Common Development and Distribution License Version 1.0
26	* (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
27	* in the VirtualBox distribution, in which case the provisions of the
28	* CDDL are applicable instead of those of the GPL.
29	*
30	* You may elect to license modified versions of this file under the
31	* terms and conditions of either the GPL or the CDDL or both.
32	*
33	* SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
34	*/
35
36	#ifndef VBOX_INCLUDED_vmm_pdmdev_h
37	#define VBOX_INCLUDED_vmm_pdmdev_h
38	#ifndef RT_WITHOUT_PRAGMA_ONCE
39	# pragma once
40	#endif
41
42	#include <VBox/vmm/pdmcritsect.h>
43	#include <VBox/vmm/pdmcritsectrw.h>
44	#include <VBox/vmm/pdmqueue.h>
45	#include <VBox/vmm/pdmtask.h>
46	#ifdef IN_RING3
47	# include <VBox/vmm/pdmthread.h>
48	#endif
49	#include <VBox/vmm/pdmifs.h>
50	#include <VBox/vmm/pdmins.h>
51	#include <VBox/vmm/pdmcommon.h>
52	#include <VBox/vmm/pdmpcidev.h>
53	#include <VBox/vmm/iom.h>
54	#include <VBox/vmm/mm.h>
55	#include <VBox/vmm/tm.h>
56	#include <VBox/vmm/ssm.h>
57	#include <VBox/vmm/cfgm.h>
58	#include <VBox/vmm/cpum.h>
59	#include <VBox/vmm/dbgf.h>
60	#include <VBox/vmm/pgm.h> /* PGMR3HandlerPhysicalTypeRegister() argument types. */
61	#include <VBox/vmm/gim.h>
62	#include <VBox/err.h> /* VINF_EM_DBG_STOP, also 120+ source files expecting this. */
63	#include <VBox/msi.h>
64	#include <iprt/stdarg.h>
65	#include <iprt/list.h>
66
67
68	RT_C_DECLS_BEGIN
69
70	/** @defgroup grp_pdm_device The PDM Devices API
71	* @ingroup grp_pdm
72	* @{
73	*/
74
75	/**
76	* Construct a device instance for a VM.
77	*
78	* @returns VBox status.
79	* @param pDevIns The device instance data. If the registration structure
80	* is needed, it can be accessed thru pDevIns->pReg.
81	* @param iInstance Instance number. Use this to figure out which registers
82	* and such to use. The instance number is also found in
83	* pDevIns->iInstance, but since it's likely to be
84	* frequently used PDM passes it as parameter.
85	* @param pCfg Configuration node handle for the driver. This is
86	* expected to be in high demand in the constructor and is
87	* therefore passed as an argument. When using it at other
88	* times, it can be found in pDevIns->pCfg.
89	*/
90	typedef DECLCALLBACKTYPE(int, FNPDMDEVCONSTRUCT,(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfg));
91	/** Pointer to a FNPDMDEVCONSTRUCT() function. */
92	typedef FNPDMDEVCONSTRUCT *PFNPDMDEVCONSTRUCT;
93
94	/**
95	* Destruct a device instance.
96	*
97	* Most VM resources are freed by the VM. This callback is provided so that any non-VM
98	* resources can be freed correctly.
99	*
100	* @returns VBox status.
101	* @param pDevIns The device instance data.
102	*
103	* @remarks The device critical section is not entered. The routine may delete
104	* the critical section, so the caller cannot exit it.
105	*/
106	typedef DECLCALLBACKTYPE(int, FNPDMDEVDESTRUCT,(PPDMDEVINS pDevIns));
107	/** Pointer to a FNPDMDEVDESTRUCT() function. */
108	typedef FNPDMDEVDESTRUCT *PFNPDMDEVDESTRUCT;
109
110	/**
111	* Device relocation callback.
112	*
113	* This is called when the instance data has been relocated in raw-mode context
114	* (RC). It is also called when the RC hypervisor selects changes. The device
115	* must fixup all necessary pointers and re-query all interfaces to other RC
116	* devices and drivers.
117	*
118	* Before the RC code is executed the first time, this function will be called
119	* with a 0 delta so RC pointer calculations can be one in one place.
120	*
121	* @param pDevIns Pointer to the device instance.
122	* @param offDelta The relocation delta relative to the old location.
123	*
124	* @remarks A relocation CANNOT fail.
125	*
126	* @remarks The device critical section is not entered. The relocations should
127	* not normally require any locking.
128	*/
129	typedef DECLCALLBACKTYPE(void, FNPDMDEVRELOCATE,(PPDMDEVINS pDevIns, RTGCINTPTR offDelta));
130	/** Pointer to a FNPDMDEVRELOCATE() function. */
131	typedef FNPDMDEVRELOCATE *PFNPDMDEVRELOCATE;
132
133	/**
134	* Power On notification.
135	*
136	* @param pDevIns The device instance data.
137	*
138	* @remarks Caller enters the device critical section.
139	*/
140	typedef DECLCALLBACKTYPE(void, FNPDMDEVPOWERON,(PPDMDEVINS pDevIns));
141	/** Pointer to a FNPDMDEVPOWERON() function. */
142	typedef FNPDMDEVPOWERON *PFNPDMDEVPOWERON;
143
144	/**
145	* Reset notification.
146	*
147	* @param pDevIns The device instance data.
148	*
149	* @remarks Caller enters the device critical section.
150	*/
151	typedef DECLCALLBACKTYPE(void, FNPDMDEVRESET,(PPDMDEVINS pDevIns));
152	/** Pointer to a FNPDMDEVRESET() function. */
153	typedef FNPDMDEVRESET *PFNPDMDEVRESET;
154
155	/**
156	* Soft reset notification.
157	*
158	* This is mainly for emulating the 286 style protected mode exits, in which
159	* most devices should remain in their current state.
160	*
161	* @param pDevIns The device instance data.
162	* @param fFlags PDMVMRESET_F_XXX (only bits relevant to soft resets).
163	*
164	* @remarks Caller enters the device critical section.
165	*/
166	typedef DECLCALLBACKTYPE(void, FNPDMDEVSOFTRESET,(PPDMDEVINS pDevIns, uint32_t fFlags));
167	/** Pointer to a FNPDMDEVSOFTRESET() function. */
168	typedef FNPDMDEVSOFTRESET *PFNPDMDEVSOFTRESET;
169
170	/** @name PDMVMRESET_F_XXX - VM reset flags.
171	* These flags are used both for FNPDMDEVSOFTRESET and for hardware signalling
172	* reset via PDMDevHlpVMReset.
173	* @{ */
174	/** Unknown reason. */
175	#define PDMVMRESET_F_UNKNOWN UINT32_C(0x00000000)
176	/** GIM triggered reset. */
177	#define PDMVMRESET_F_GIM UINT32_C(0x00000001)
178	/** The last source always causing hard resets. */
179	#define PDMVMRESET_F_LAST_ALWAYS_HARD PDMVMRESET_F_GIM
180	/** ACPI triggered reset. */
181	#define PDMVMRESET_F_ACPI UINT32_C(0x0000000c)
182	/** PS/2 system port A (92h) reset. */
183	#define PDMVMRESET_F_PORT_A UINT32_C(0x0000000d)
184	/** Keyboard reset. */
185	#define PDMVMRESET_F_KBD UINT32_C(0x0000000e)
186	/** Tripple fault. */
187	#define PDMVMRESET_F_TRIPLE_FAULT UINT32_C(0x0000000f)
188	/** Reset source mask. */
189	#define PDMVMRESET_F_SRC_MASK UINT32_C(0x0000000f)
190	/** @} */
191
192	/**
193	* Suspend notification.
194	*
195	* @param pDevIns The device instance data.
196	* @thread EMT(0)
197	*
198	* @remarks Caller enters the device critical section.
199	*/
200	typedef DECLCALLBACKTYPE(void, FNPDMDEVSUSPEND,(PPDMDEVINS pDevIns));
201	/** Pointer to a FNPDMDEVSUSPEND() function. */
202	typedef FNPDMDEVSUSPEND *PFNPDMDEVSUSPEND;
203
204	/**
205	* Resume notification.
206	*
207	* @param pDevIns The device instance data.
208	*
209	* @remarks Caller enters the device critical section.
210	*/
211	typedef DECLCALLBACKTYPE(void, FNPDMDEVRESUME,(PPDMDEVINS pDevIns));
212	/** Pointer to a FNPDMDEVRESUME() function. */
213	typedef FNPDMDEVRESUME *PFNPDMDEVRESUME;
214
215	/**
216	* Power Off notification.
217	*
218	* This is always called when VMR3PowerOff is called.
219	* There will be no callback when hot plugging devices.
220	*
221	* @param pDevIns The device instance data.
222	* @thread EMT(0)
223	*
224	* @remarks Caller enters the device critical section.
225	*/
226	typedef DECLCALLBACKTYPE(void, FNPDMDEVPOWEROFF,(PPDMDEVINS pDevIns));
227	/** Pointer to a FNPDMDEVPOWEROFF() function. */
228	typedef FNPDMDEVPOWEROFF *PFNPDMDEVPOWEROFF;
229
230	/**
231	* Attach command.
232	*
233	* This is called to let the device attach to a driver for a specified LUN
234	* at runtime. This is not called during VM construction, the device
235	* constructor has to attach to all the available drivers.
236	*
237	* This is like plugging in the keyboard or mouse after turning on the PC.
238	*
239	* @returns VBox status code.
240	* @param pDevIns The device instance.
241	* @param iLUN The logical unit which is being attached.
242	* @param fFlags Flags, combination of the PDM_TACH_FLAGS_* \#defines.
243	*
244	* @remarks Caller enters the device critical section.
245	*/
246	typedef DECLCALLBACKTYPE(int, FNPDMDEVATTACH,(PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags));
247	/** Pointer to a FNPDMDEVATTACH() function. */
248	typedef FNPDMDEVATTACH *PFNPDMDEVATTACH;
249
250	/**
251	* Detach notification.
252	*
253	* This is called when a driver is detaching itself from a LUN of the device.
254	* The device should adjust its state to reflect this.
255	*
256	* This is like unplugging the network cable to use it for the laptop or
257	* something while the PC is still running.
258	*
259	* @param pDevIns The device instance.
260	* @param iLUN The logical unit which is being detached.
261	* @param fFlags Flags, combination of the PDMDEVATT_FLAGS_* \#defines.
262	*
263	* @remarks Caller enters the device critical section.
264	*/
265	typedef DECLCALLBACKTYPE(void, FNPDMDEVDETACH,(PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags));
266	/** Pointer to a FNPDMDEVDETACH() function. */
267	typedef FNPDMDEVDETACH *PFNPDMDEVDETACH;
268
269	/**
270	* Query the base interface of a logical unit.
271	*
272	* @returns VBOX status code.
273	* @param pDevIns The device instance.
274	* @param iLUN The logicial unit to query.
275	* @param ppBase Where to store the pointer to the base interface of the LUN.
276	*
277	* @remarks The device critical section is not entered.
278	*/
279	typedef DECLCALLBACKTYPE(int, FNPDMDEVQUERYINTERFACE,(PPDMDEVINS pDevIns, unsigned iLUN, PPDMIBASE *ppBase));
280	/** Pointer to a FNPDMDEVQUERYINTERFACE() function. */
281	typedef FNPDMDEVQUERYINTERFACE *PFNPDMDEVQUERYINTERFACE;
282
283	/**
284	* Init complete notification (after ring-0 & RC init since 5.1).
285	*
286	* This can be done to do communication with other devices and other
287	* initialization which requires everything to be in place.
288	*
289	* @returns VBOX status code.
290	* @param pDevIns The device instance.
291	*
292	* @remarks Caller enters the device critical section.
293	*/
294	typedef DECLCALLBACKTYPE(int, FNPDMDEVINITCOMPLETE,(PPDMDEVINS pDevIns));
295	/** Pointer to a FNPDMDEVINITCOMPLETE() function. */
296	typedef FNPDMDEVINITCOMPLETE *PFNPDMDEVINITCOMPLETE;
297
298
299	/**
300	* The context of a pfnMemSetup call.
301	*/
302	typedef enum PDMDEVMEMSETUPCTX
303	{
304	/** Invalid zero value. */
305	PDMDEVMEMSETUPCTX_INVALID = 0,
306	/** After construction. */
307	PDMDEVMEMSETUPCTX_AFTER_CONSTRUCTION,
308	/** After reset. */
309	PDMDEVMEMSETUPCTX_AFTER_RESET,
310	/** Type size hack. */
311	PDMDEVMEMSETUPCTX_32BIT_HACK = 0x7fffffff
312	} PDMDEVMEMSETUPCTX;
313
314
315	/**
316	* PDM Device Registration Structure.
317	*
318	* This structure is used when registering a device from VBoxInitDevices() in HC
319	* Ring-3. PDM will continue use till the VM is terminated.
320	*
321	* @note The first part is the same in every context.
322	*/
323	typedef struct PDMDEVREGR3
324	{
325	/** Structure version. PDM_DEVREGR3_VERSION defines the current version. */
326	uint32_t u32Version;
327	/** Reserved, must be zero. */
328	uint32_t uReserved0;
329	/** Device name, must match the ring-3 one. */
330	char szName[32];
331	/** Flags, combination of the PDM_DEVREG_FLAGS_* \#defines. */
332	uint32_t fFlags;
333	/** Device class(es), combination of the PDM_DEVREG_CLASS_* \#defines. */
334	uint32_t fClass;
335	/** Maximum number of instances (per VM). */
336	uint32_t cMaxInstances;
337	/** The shared data structure version number. */
338	uint32_t uSharedVersion;
339	/** Size of the instance data. */
340	uint32_t cbInstanceShared;
341	/** Size of the ring-0 instance data. */
342	uint32_t cbInstanceCC;
343	/** Size of the raw-mode instance data. */
344	uint32_t cbInstanceRC;
345	/** Max number of PCI devices. */
346	uint16_t cMaxPciDevices;
347	/** Max number of MSI-X vectors in any of the PCI devices. */
348	uint16_t cMaxMsixVectors;
349	/** The description of the device. The UTF-8 string pointed to shall, like this structure,
350	* remain unchanged from registration till VM destruction. */
351	const char *pszDescription;
352
353	/** Name of the raw-mode context module (no path).
354	* Only evalutated if PDM_DEVREG_FLAGS_RC is set. */
355	const char *pszRCMod;
356	/** Name of the ring-0 module (no path).
357	* Only evalutated if PDM_DEVREG_FLAGS_R0 is set. */
358	const char *pszR0Mod;
359
360	/** Construct instance - required. */
361	PFNPDMDEVCONSTRUCT pfnConstruct;
362	/** Destruct instance - optional.
363	* Critical section NOT entered (will be destroyed). */
364	PFNPDMDEVDESTRUCT pfnDestruct;
365	/** Relocation command - optional.
366	* Critical section NOT entered. */
367	PFNPDMDEVRELOCATE pfnRelocate;
368	/**
369	* Memory setup callback.
370	*
371	* @param pDevIns The device instance data.
372	* @param enmCtx Indicates the context of the call.
373	* @remarks The critical section is entered prior to calling this method.
374	*/
375	DECLR3CALLBACKMEMBER(void, pfnMemSetup, (PPDMDEVINS pDevIns, PDMDEVMEMSETUPCTX enmCtx));
376	/** Power on notification - optional.
377	* Critical section is entered. */
378	PFNPDMDEVPOWERON pfnPowerOn;
379	/** Reset notification - optional.
380	* Critical section is entered. */
381	PFNPDMDEVRESET pfnReset;
382	/** Suspend notification - optional.
383	* Critical section is entered. */
384	PFNPDMDEVSUSPEND pfnSuspend;
385	/** Resume notification - optional.
386	* Critical section is entered. */
387	PFNPDMDEVRESUME pfnResume;
388	/** Attach command - optional.
389	* Critical section is entered. */
390	PFNPDMDEVATTACH pfnAttach;
391	/** Detach notification - optional.
392	* Critical section is entered. */
393	PFNPDMDEVDETACH pfnDetach;
394	/** Query a LUN base interface - optional.
395	* Critical section is NOT entered. */
396	PFNPDMDEVQUERYINTERFACE pfnQueryInterface;
397	/** Init complete notification - optional.
398	* Critical section is entered. */
399	PFNPDMDEVINITCOMPLETE pfnInitComplete;
400	/** Power off notification - optional.
401	* Critical section is entered. */
402	PFNPDMDEVPOWEROFF pfnPowerOff;
403	/** Software system reset notification - optional.
404	* Critical section is entered. */
405	PFNPDMDEVSOFTRESET pfnSoftReset;
406
407	/** @name Reserved for future extensions, must be zero.
408	* @{ */
409	DECLR3CALLBACKMEMBER(int, pfnReserved0, (PPDMDEVINS pDevIns));
410	DECLR3CALLBACKMEMBER(int, pfnReserved1, (PPDMDEVINS pDevIns));
411	DECLR3CALLBACKMEMBER(int, pfnReserved2, (PPDMDEVINS pDevIns));
412	DECLR3CALLBACKMEMBER(int, pfnReserved3, (PPDMDEVINS pDevIns));
413	DECLR3CALLBACKMEMBER(int, pfnReserved4, (PPDMDEVINS pDevIns));
414	DECLR3CALLBACKMEMBER(int, pfnReserved5, (PPDMDEVINS pDevIns));
415	DECLR3CALLBACKMEMBER(int, pfnReserved6, (PPDMDEVINS pDevIns));
416	DECLR3CALLBACKMEMBER(int, pfnReserved7, (PPDMDEVINS pDevIns));
417	/** @} */
418
419	/** Initialization safty marker. */
420	uint32_t u32VersionEnd;
421	} PDMDEVREGR3;
422	/** Pointer to a PDM Device Structure. */
423	typedef PDMDEVREGR3 *PPDMDEVREGR3;
424	/** Const pointer to a PDM Device Structure. */
425	typedef PDMDEVREGR3 const *PCPDMDEVREGR3;
426	/** Current DEVREGR3 version number. */
427	#define PDM_DEVREGR3_VERSION PDM_VERSION_MAKE(0xffff, 4, 0)
428
429
430	/** PDM Device Flags.
431	* @{ */
432	/** This flag is used to indicate that the device has a R0 component. */
433	#define PDM_DEVREG_FLAGS_R0 UINT32_C(0x00000001)
434	/** Requires the ring-0 component, ignore configuration values. */
435	#define PDM_DEVREG_FLAGS_REQUIRE_R0 UINT32_C(0x00000002)
436	/** Requires the ring-0 component, ignore configuration values. */
437	#define PDM_DEVREG_FLAGS_OPT_IN_R0 UINT32_C(0x00000004)
438
439	/** This flag is used to indicate that the device has a RC component. */
440	#define PDM_DEVREG_FLAGS_RC UINT32_C(0x00000010)
441	/** Requires the raw-mode component, ignore configuration values. */
442	#define PDM_DEVREG_FLAGS_REQUIRE_RC UINT32_C(0x00000020)
443	/** Requires the raw-mode component, ignore configuration values. */
444	#define PDM_DEVREG_FLAGS_OPT_IN_RC UINT32_C(0x00000040)
445
446	/** Convenience: PDM_DEVREG_FLAGS_R0 + PDM_DEVREG_FLAGS_RC */
447	#define PDM_DEVREG_FLAGS_RZ (PDM_DEVREG_FLAGS_R0 \| PDM_DEVREG_FLAGS_RC)
448
449	/** @def PDM_DEVREG_FLAGS_HOST_BITS_DEFAULT
450	* The bit count for the current host.
451	* @note Superfluous, but still around for hysterical raisins. */
452	#if HC_ARCH_BITS == 32
453	# define PDM_DEVREG_FLAGS_HOST_BITS_DEFAULT UINT32_C(0x00000100)
454	#elif HC_ARCH_BITS == 64
455	# define PDM_DEVREG_FLAGS_HOST_BITS_DEFAULT UINT32_C(0x00000200)
456	#else
457	# error Unsupported HC_ARCH_BITS value.
458	#endif
459	/** The host bit count mask. */
460	#define PDM_DEVREG_FLAGS_HOST_BITS_MASK UINT32_C(0x00000300)
461
462	/** The device support only 32-bit guests. */
463	#define PDM_DEVREG_FLAGS_GUEST_BITS_32 UINT32_C(0x00001000)
464	/** The device support only 64-bit guests. */
465	#define PDM_DEVREG_FLAGS_GUEST_BITS_64 UINT32_C(0x00002000)
466	/** The device support both 32-bit & 64-bit guests. */
467	#define PDM_DEVREG_FLAGS_GUEST_BITS_32_64 UINT32_C(0x00003000)
468	/** @def PDM_DEVREG_FLAGS_GUEST_BITS_DEFAULT
469	* The guest bit count for the current compilation. */
470	#if GC_ARCH_BITS == 32
471	# define PDM_DEVREG_FLAGS_GUEST_BITS_DEFAULT PDM_DEVREG_FLAGS_GUEST_BITS_32
472	#elif GC_ARCH_BITS == 64
473	# define PDM_DEVREG_FLAGS_GUEST_BITS_DEFAULT PDM_DEVREG_FLAGS_GUEST_BITS_32_64
474	#else
475	# error Unsupported GC_ARCH_BITS value.
476	#endif
477	/** The guest bit count mask. */
478	#define PDM_DEVREG_FLAGS_GUEST_BITS_MASK UINT32_C(0x00003000)
479
480	/** A convenience. */
481	#define PDM_DEVREG_FLAGS_DEFAULT_BITS (PDM_DEVREG_FLAGS_GUEST_BITS_DEFAULT \| PDM_DEVREG_FLAGS_HOST_BITS_DEFAULT)
482
483	/** Indicates that the device needs to be notified before the drivers when suspending. */
484	#define PDM_DEVREG_FLAGS_FIRST_SUSPEND_NOTIFICATION UINT32_C(0x00010000)
485	/** Indicates that the device needs to be notified before the drivers when powering off. */
486	#define PDM_DEVREG_FLAGS_FIRST_POWEROFF_NOTIFICATION UINT32_C(0x00020000)
487	/** Indicates that the device needs to be notified before the drivers when resetting. */
488	#define PDM_DEVREG_FLAGS_FIRST_RESET_NOTIFICATION UINT32_C(0x00040000)
489
490	/** This flag is used to indicate that the device has been converted to the
491	* new device style. */
492	#define PDM_DEVREG_FLAGS_NEW_STYLE UINT32_C(0x80000000)
493
494	/** @} */
495
496
497	/** PDM Device Classes.
498	* The order is important, lower bit earlier instantiation.
499	* @{ */
500	/** Architecture device. */
501	#define PDM_DEVREG_CLASS_ARCH RT_BIT(0)
502	/** Architecture BIOS device. */
503	#define PDM_DEVREG_CLASS_ARCH_BIOS RT_BIT(1)
504	/** PCI bus brigde. */
505	#define PDM_DEVREG_CLASS_BUS_PCI RT_BIT(2)
506	/** PCI built-in device (e.g. PCI root complex devices). */
507	#define PDM_DEVREG_CLASS_PCI_BUILTIN RT_BIT(3)
508	/** Input device (mouse, keyboard, joystick, HID, ...). */
509	#define PDM_DEVREG_CLASS_INPUT RT_BIT(4)
510	/** Interrupt controller (PIC). */
511	#define PDM_DEVREG_CLASS_PIC RT_BIT(5)
512	/** Interval controoler (PIT). */
513	#define PDM_DEVREG_CLASS_PIT RT_BIT(6)
514	/** RTC/CMOS. */
515	#define PDM_DEVREG_CLASS_RTC RT_BIT(7)
516	/** DMA controller. */
517	#define PDM_DEVREG_CLASS_DMA RT_BIT(8)
518	/** VMM Device. */
519	#define PDM_DEVREG_CLASS_VMM_DEV RT_BIT(9)
520	/** Graphics device, like VGA. */
521	#define PDM_DEVREG_CLASS_GRAPHICS RT_BIT(10)
522	/** Storage controller device. */
523	#define PDM_DEVREG_CLASS_STORAGE RT_BIT(11)
524	/** Network interface controller. */
525	#define PDM_DEVREG_CLASS_NETWORK RT_BIT(12)
526	/** Audio. */
527	#define PDM_DEVREG_CLASS_AUDIO RT_BIT(13)
528	/** USB HIC. */
529	#define PDM_DEVREG_CLASS_BUS_USB RT_BIT(14)
530	/** ACPI. */
531	#define PDM_DEVREG_CLASS_ACPI RT_BIT(15)
532	/** Serial controller device. */
533	#define PDM_DEVREG_CLASS_SERIAL RT_BIT(16)
534	/** Parallel controller device */
535	#define PDM_DEVREG_CLASS_PARALLEL RT_BIT(17)
536	/** Host PCI pass-through device */
537	#define PDM_DEVREG_CLASS_HOST_DEV RT_BIT(18)
538	/** GPIO device */
539	#define PDM_DEVREG_CLASS_GPIO RT_BIT(19)
540	/** Misc devices (always last). */
541	#define PDM_DEVREG_CLASS_MISC RT_BIT(31)
542	/** @} */
543
544
545	/**
546	* PDM Device Registration Structure, ring-0.
547	*
548	* This structure is used when registering a device from VBoxInitDevices() in HC
549	* Ring-0. PDM will continue use till the VM is terminated.
550	*/
551	typedef struct PDMDEVREGR0
552	{
553	/** Structure version. PDM_DEVREGR0_VERSION defines the current version. */
554	uint32_t u32Version;
555	/** Reserved, must be zero. */
556	uint32_t uReserved0;
557	/** Device name, must match the ring-3 one. */
558	char szName[32];
559	/** Flags, combination of the PDM_DEVREG_FLAGS_* \#defines. */
560	uint32_t fFlags;
561	/** Device class(es), combination of the PDM_DEVREG_CLASS_* \#defines. */
562	uint32_t fClass;
563	/** Maximum number of instances (per VM). */
564	uint32_t cMaxInstances;
565	/** The shared data structure version number. */
566	uint32_t uSharedVersion;
567	/** Size of the instance data. */
568	uint32_t cbInstanceShared;
569	/** Size of the ring-0 instance data. */
570	uint32_t cbInstanceCC;
571	/** Size of the raw-mode instance data. */
572	uint32_t cbInstanceRC;
573	/** Max number of PCI devices. */
574	uint16_t cMaxPciDevices;
575	/** Max number of MSI-X vectors in any of the PCI devices. */
576	uint16_t cMaxMsixVectors;
577	/** The description of the device. The UTF-8 string pointed to shall, like this structure,
578	* remain unchanged from registration till VM destruction. */
579	const char *pszDescription;
580
581	/**
582	* Early construction callback (optional).
583	*
584	* This is called right after the device instance structure has been allocated
585	* and before the ring-3 constructor gets called.
586	*
587	* @returns VBox status code.
588	* @param pDevIns The device instance data.
589	* @note The destructure is always called, regardless of the return status.
590	*/
591	DECLR0CALLBACKMEMBER(int, pfnEarlyConstruct, (PPDMDEVINS pDevIns));
592
593	/**
594	* Regular construction callback (optional).
595	*
596	* This is called after (or during) the ring-3 constructor.
597	*
598	* @returns VBox status code.
599	* @param pDevIns The device instance data.
600	* @note The destructure is always called, regardless of the return status.
601	*/
602	DECLR0CALLBACKMEMBER(int, pfnConstruct, (PPDMDEVINS pDevIns));
603
604	/**
605	* Destructor (optional).
606	*
607	* This is called after the ring-3 destruction. This is not called if ring-3
608	* fails to trigger it (e.g. process is killed or crashes).
609	*
610	* @param pDevIns The device instance data.
611	*/
612	DECLR0CALLBACKMEMBER(void, pfnDestruct, (PPDMDEVINS pDevIns));
613
614	/**
615	* Final destructor (optional).
616	*
617	* This is called right before the memory is freed, which happens when the
618	* VM/GVM object is destroyed. This is always called.
619	*
620	* @param pDevIns The device instance data.
621	*/
622	DECLR0CALLBACKMEMBER(void, pfnFinalDestruct, (PPDMDEVINS pDevIns));
623
624	/**
625	* Generic request handler (optional).
626	*
627	* @param pDevIns The device instance data.
628	* @param uReq Device specific request.
629	* @param uArg Request argument.
630	*/
631	DECLR0CALLBACKMEMBER(int, pfnRequest, (PPDMDEVINS pDevIns, uint32_t uReq, uint64_t uArg));
632
633	/** @name Reserved for future extensions, must be zero.
634	* @{ */
635	DECLR0CALLBACKMEMBER(int, pfnReserved0, (PPDMDEVINS pDevIns));
636	DECLR0CALLBACKMEMBER(int, pfnReserved1, (PPDMDEVINS pDevIns));
637	DECLR0CALLBACKMEMBER(int, pfnReserved2, (PPDMDEVINS pDevIns));
638	DECLR0CALLBACKMEMBER(int, pfnReserved3, (PPDMDEVINS pDevIns));
639	DECLR0CALLBACKMEMBER(int, pfnReserved4, (PPDMDEVINS pDevIns));
640	DECLR0CALLBACKMEMBER(int, pfnReserved5, (PPDMDEVINS pDevIns));
641	DECLR0CALLBACKMEMBER(int, pfnReserved6, (PPDMDEVINS pDevIns));
642	DECLR0CALLBACKMEMBER(int, pfnReserved7, (PPDMDEVINS pDevIns));
643	/** @} */
644
645	/** Initialization safty marker. */
646	uint32_t u32VersionEnd;
647	} PDMDEVREGR0;
648	/** Pointer to a ring-0 PDM device registration structure. */
649	typedef PDMDEVREGR0 *PPDMDEVREGR0;
650	/** Pointer to a const ring-0 PDM device registration structure. */
651	typedef PDMDEVREGR0 const *PCPDMDEVREGR0;
652	/** Current DEVREGR0 version number. */
653	#define PDM_DEVREGR0_VERSION PDM_VERSION_MAKE(0xff80, 1, 0)
654
655
656	/**
657	* PDM Device Registration Structure, raw-mode
658	*
659	* At the moment, this structure is mostly here to match the other two contexts.
660	*/
661	typedef struct PDMDEVREGRC
662	{
663	/** Structure version. PDM_DEVREGRC_VERSION defines the current version. */
664	uint32_t u32Version;
665	/** Reserved, must be zero. */
666	uint32_t uReserved0;
667	/** Device name, must match the ring-3 one. */
668	char szName[32];
669	/** Flags, combination of the PDM_DEVREG_FLAGS_* \#defines. */
670	uint32_t fFlags;
671	/** Device class(es), combination of the PDM_DEVREG_CLASS_* \#defines. */
672	uint32_t fClass;
673	/** Maximum number of instances (per VM). */
674	uint32_t cMaxInstances;
675	/** The shared data structure version number. */
676	uint32_t uSharedVersion;
677	/** Size of the instance data. */
678	uint32_t cbInstanceShared;
679	/** Size of the ring-0 instance data. */
680	uint32_t cbInstanceCC;
681	/** Size of the raw-mode instance data. */
682	uint32_t cbInstanceRC;
683	/** Max number of PCI devices. */
684	uint16_t cMaxPciDevices;
685	/** Max number of MSI-X vectors in any of the PCI devices. */
686	uint16_t cMaxMsixVectors;
687	/** The description of the device. The UTF-8 string pointed to shall, like this structure,
688	* remain unchanged from registration till VM destruction. */
689	const char *pszDescription;
690
691	/**
692	* Constructor callback.
693	*
694	* This is called much later than both the ring-0 and ring-3 constructors, since
695	* raw-mode v2 require a working VMM to run actual code.
696	*
697	* @returns VBox status code.
698	* @param pDevIns The device instance data.
699	* @note The destructure is always called, regardless of the return status.
700	*/
701	DECLRGCALLBACKMEMBER(int, pfnConstruct, (PPDMDEVINS pDevIns));
702
703	/** @name Reserved for future extensions, must be zero.
704	* @{ */
705	DECLRCCALLBACKMEMBER(int, pfnReserved0, (PPDMDEVINS pDevIns));
706	DECLRCCALLBACKMEMBER(int, pfnReserved1, (PPDMDEVINS pDevIns));
707	DECLRCCALLBACKMEMBER(int, pfnReserved2, (PPDMDEVINS pDevIns));
708	DECLRCCALLBACKMEMBER(int, pfnReserved3, (PPDMDEVINS pDevIns));
709	DECLRCCALLBACKMEMBER(int, pfnReserved4, (PPDMDEVINS pDevIns));
710	DECLRCCALLBACKMEMBER(int, pfnReserved5, (PPDMDEVINS pDevIns));
711	DECLRCCALLBACKMEMBER(int, pfnReserved6, (PPDMDEVINS pDevIns));
712	DECLRCCALLBACKMEMBER(int, pfnReserved7, (PPDMDEVINS pDevIns));
713	/** @} */
714
715	/** Initialization safty marker. */
716	uint32_t u32VersionEnd;
717	} PDMDEVREGRC;
718	/** Pointer to a raw-mode PDM device registration structure. */
719	typedef PDMDEVREGRC *PPDMDEVREGRC;
720	/** Pointer to a const raw-mode PDM device registration structure. */
721	typedef PDMDEVREGRC const *PCPDMDEVREGRC;
722	/** Current DEVREGRC version number. */
723	#define PDM_DEVREGRC_VERSION PDM_VERSION_MAKE(0xff81, 1, 0)
724
725
726
727	/** @def PDM_DEVREG_VERSION
728	* Current DEVREG version number. */
729	/** @typedef PDMDEVREGR3
730	* A current context PDM device registration structure. */
731	/** @typedef PPDMDEVREGR3
732	* Pointer to a current context PDM device registration structure. */
733	/** @typedef PCPDMDEVREGR3
734	* Pointer to a const current context PDM device registration structure. */
735	#if defined(IN_RING3) \|\| defined(DOXYGEN_RUNNING)
736	# define PDM_DEVREG_VERSION PDM_DEVREGR3_VERSION
737	typedef PDMDEVREGR3 PDMDEVREG;
738	typedef PPDMDEVREGR3 PPDMDEVREG;
739	typedef PCPDMDEVREGR3 PCPDMDEVREG;
740	#elif defined(IN_RING0)
741	# define PDM_DEVREG_VERSION PDM_DEVREGR0_VERSION
742	typedef PDMDEVREGR0 PDMDEVREG;
743	typedef PPDMDEVREGR0 PPDMDEVREG;
744	typedef PCPDMDEVREGR0 PCPDMDEVREG;
745	#elif defined(IN_RC)
746	# define PDM_DEVREG_VERSION PDM_DEVREGRC_VERSION
747	typedef PDMDEVREGRC PDMDEVREG;
748	typedef PPDMDEVREGRC PPDMDEVREG;
749	typedef PCPDMDEVREGRC PCPDMDEVREG;
750	#else
751	# error "Not IN_RING3, IN_RING0 or IN_RC"
752	#endif
753
754
755	/**
756	* Device registrations for ring-0 modules.
757	*
758	* This structure is used directly and must therefore reside in persistent
759	* memory (i.e. the data section).
760	*/
761	typedef struct PDMDEVMODREGR0
762	{
763	/** The structure version (PDM_DEVMODREGR0_VERSION). */
764	uint32_t u32Version;
765	/** Number of devices in the array papDevRegs points to. */
766	uint32_t cDevRegs;
767	/** Pointer to device registration structures. */
768	PCPDMDEVREGR0 *papDevRegs;
769	/** The ring-0 module handle - PDM internal, fingers off. */
770	void *hMod;
771	/** List entry - PDM internal, fingers off. */
772	RTLISTNODE ListEntry;
773	} PDMDEVMODREGR0;
774	/** Pointer to device registriations for a ring-0 module. */
775	typedef PDMDEVMODREGR0 *PPDMDEVMODREGR0;
776	/** Current PDMDEVMODREGR0 version number. */
777	#define PDM_DEVMODREGR0_VERSION PDM_VERSION_MAKE(0xff85, 1, 0)
778
779
780	/** @name IRQ Level for use with the *SetIrq APIs.
781	* @{
782	*/
783	/** Assert the IRQ (can assume value 1). */
784	#define PDM_IRQ_LEVEL_HIGH RT_BIT(0)
785	/** Deassert the IRQ (can assume value 0). */
786	#define PDM_IRQ_LEVEL_LOW 0
787	/** flip-flop - deassert and then assert the IRQ again immediately (PIC) /
788	* automatically deasserts it after delivery to the APIC (IOAPIC).
789	* @note Only suitable for edge trigger interrupts. */
790	#define PDM_IRQ_LEVEL_FLIP_FLOP (RT_BIT(1) \| PDM_IRQ_LEVEL_HIGH)
791	/** @} */
792
793	/**
794	* Registration record for MSI/MSI-X emulation.
795	*/
796	typedef struct PDMMSIREG
797	{
798	/** Number of MSI interrupt vectors, 0 if MSI not supported */
799	uint16_t cMsiVectors;
800	/** Offset of MSI capability */
801	uint8_t iMsiCapOffset;
802	/** Offset of next capability to MSI */
803	uint8_t iMsiNextOffset;
804	/** If we support 64-bit MSI addressing */
805	bool fMsi64bit;
806	/** If we do not support per-vector masking */
807	bool fMsiNoMasking;
808
809	/** Number of MSI-X interrupt vectors, 0 if MSI-X not supported */
810	uint16_t cMsixVectors;
811	/** Offset of MSI-X capability */
812	uint8_t iMsixCapOffset;
813	/** Offset of next capability to MSI-X */
814	uint8_t iMsixNextOffset;
815	/** Value of PCI BAR (base addresss register) assigned by device for MSI-X page access */
816	uint8_t iMsixBar;
817	} PDMMSIREG;
818	typedef PDMMSIREG *PPDMMSIREG;
819
820	/**
821	* PCI Bus registration structure.
822	* All the callbacks, except the PCIBIOS hack, are working on PCI devices.
823	*/
824	typedef struct PDMPCIBUSREGR3
825	{
826	/** Structure version number. PDM_PCIBUSREGR3_VERSION defines the current version. */
827	uint32_t u32Version;
828
829	/**
830	* Registers the device with the default PCI bus.
831	*
832	* @returns VBox status code.
833	* @param pDevIns Device instance of the PCI Bus.
834	* @param pPciDev The PCI device structure.
835	* @param fFlags Reserved for future use, PDMPCIDEVREG_F_MBZ.
836	* @param uPciDevNo PDMPCIDEVREG_DEV_NO_FIRST_UNUSED, or a specific
837	* device number (0-31).
838	* @param uPciFunNo PDMPCIDEVREG_FUN_NO_FIRST_UNUSED, or a specific
839	* function number (0-7).
840	* @param pszName Device name (static but not unique).
841	*
842	* @remarks Caller enters the PDM critical section.
843	*/
844	DECLR3CALLBACKMEMBER(int, pfnRegisterR3,(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t fFlags,
845	uint8_t uPciDevNo, uint8_t uPciFunNo, const char *pszName));
846
847	/**
848	* Initialize MSI or MSI-X emulation support in a PCI device.
849	*
850	* This cannot handle all corner cases of the MSI/MSI-X spec, but for the
851	* vast majority of device emulation it covers everything necessary. It's
852	* fully automatic, taking care of all BAR and config space requirements,
853	* and interrupt delivery is done using PDMDevHlpPCISetIrq and friends.
854	* When MSI/MSI-X is enabled then the iIrq parameter is redefined to take
855	* the vector number (otherwise it has the usual INTA-D meaning for PCI).
856	*
857	* A device not using this can still offer MSI/MSI-X. In this case it's
858	* completely up to the device (in the MSI-X case) to create/register the
859	* necessary MMIO BAR, handle all config space/BAR updating and take care
860	* of delivering the interrupts appropriately.
861	*
862	* @returns VBox status code.
863	* @param pDevIns Device instance of the PCI Bus.
864	* @param pPciDev The PCI device structure.
865	* @param pMsiReg MSI emulation registration structure
866	* @remarks Caller enters the PDM critical section.
867	*/
868	DECLR3CALLBACKMEMBER(int, pfnRegisterMsiR3,(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, PPDMMSIREG pMsiReg));
869
870	/**
871	* Registers a I/O region (memory mapped or I/O ports) for a PCI device.
872	*
873	* @returns VBox status code.
874	* @param pDevIns Device instance of the PCI Bus.
875	* @param pPciDev The PCI device structure.
876	* @param iRegion The region number.
877	* @param cbRegion Size of the region.
878	* @param enmType PCI_ADDRESS_SPACE_MEM, PCI_ADDRESS_SPACE_IO or
879	* PCI_ADDRESS_SPACE_MEM_PREFETCH, optionally with
880	* PCI_ADDRESS_SPACE_BAR64 or'ed in.
881	* @param fFlags PDMPCIDEV_IORGN_F_XXX.
882	* @param hHandle An I/O port, MMIO or MMIO2 handle according to
883	* @a fFlags, UINT64_MAX if no handle is passed
884	* (old style).
885	* @param pfnMapUnmap Callback for doing the mapping. Optional if a handle
886	* is given.
887	* @remarks Caller enters the PDM critical section.
888	*/
889	DECLR3CALLBACKMEMBER(int, pfnIORegionRegisterR3,(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t iRegion,
890	RTGCPHYS cbRegion, PCIADDRESSSPACE enmType, uint32_t fFlags,
891	uint64_t hHandle, PFNPCIIOREGIONMAP pfnMapUnmap));
892
893	/**
894	* Register PCI configuration space read/write intercept callbacks.
895	*
896	* @param pDevIns Device instance of the PCI Bus.
897	* @param pPciDev The PCI device structure.
898	* @param pfnRead Pointer to the user defined PCI config read function.
899	* @param pfnWrite Pointer to the user defined PCI config write function.
900	* to call default PCI config write function. Can be NULL.
901	* @remarks Caller enters the PDM critical section.
902	* @thread EMT
903	*/
904	DECLR3CALLBACKMEMBER(void, pfnInterceptConfigAccesses,(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev,
905	PFNPCICONFIGREAD pfnRead, PFNPCICONFIGWRITE pfnWrite));
906
907	/**
908	* Perform a PCI configuration space write, bypassing interception.
909	*
910	* This is for devices that make use of PDMDevHlpPCIInterceptConfigAccesses().
911	*
912	* @returns Strict VBox status code (mainly DBGFSTOP).
913	* @param pDevIns Device instance of the PCI Bus.
914	* @param pPciDev The PCI device which config space is being read.
915	* @param uAddress The config space address.
916	* @param cb The size of the read: 1, 2 or 4 bytes.
917	* @param u32Value The value to write.
918	* @note The caller (PDM) does not enter the PDM critsect, but it is possible
919	* that the (root) bus will have done that already.
920	*/
921	DECLR3CALLBACKMEMBER(VBOXSTRICTRC, pfnConfigWrite,(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev,
922	uint32_t uAddress, unsigned cb, uint32_t u32Value));
923
924	/**
925	* Perform a PCI configuration space read, bypassing interception.
926	*
927	* This is for devices that make use of PDMDevHlpPCIInterceptConfigAccesses().
928	*
929	* @returns Strict VBox status code (mainly DBGFSTOP).
930	* @param pDevIns Device instance of the PCI Bus.
931	* @param pPciDev The PCI device which config space is being read.
932	* @param uAddress The config space address.
933	* @param cb The size of the read: 1, 2 or 4 bytes.
934	* @param pu32Value Where to return the value.
935	* @note The caller (PDM) does not enter the PDM critsect, but it is possible
936	* that the (root) bus will have done that already.
937	*/
938	DECLR3CALLBACKMEMBER(VBOXSTRICTRC, pfnConfigRead,(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev,
939	uint32_t uAddress, unsigned cb, uint32_t *pu32Value));
940
941	/**
942	* Set the IRQ for a PCI device.
943	*
944	* @param pDevIns Device instance of the PCI Bus.
945	* @param pPciDev The PCI device structure.
946	* @param iIrq IRQ number to set.
947	* @param iLevel IRQ level. See the PDM_IRQ_LEVEL_* \#defines.
948	* @param uTagSrc The IRQ tag and source (for tracing).
949	* @remarks Caller enters the PDM critical section.
950	*/
951	DECLR3CALLBACKMEMBER(void, pfnSetIrqR3,(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, int iIrq, int iLevel, uint32_t uTagSrc));
952
953	/** Marks the end of the structure with PDM_PCIBUSREGR3_VERSION. */
954	uint32_t u32EndVersion;
955	} PDMPCIBUSREGR3;
956	/** Pointer to a PCI bus registration structure. */
957	typedef PDMPCIBUSREGR3 *PPDMPCIBUSREGR3;
958	/** Current PDMPCIBUSREGR3 version number. */
959	#define PDM_PCIBUSREGR3_VERSION PDM_VERSION_MAKE(0xff86, 2, 0)
960
961	/**
962	* PCI Bus registration structure for ring-0.
963	*/
964	typedef struct PDMPCIBUSREGR0
965	{
966	/** Structure version number. PDM_PCIBUSREGR0_VERSION defines the current version. */
967	uint32_t u32Version;
968	/** The PCI bus number (from ring-3 registration). */
969	uint32_t iBus;
970	/**
971	* Set the IRQ for a PCI device.
972	*
973	* @param pDevIns Device instance of the PCI Bus.
974	* @param pPciDev The PCI device structure.
975	* @param iIrq IRQ number to set.
976	* @param iLevel IRQ level. See the PDM_IRQ_LEVEL_* \#defines.
977	* @param uTagSrc The IRQ tag and source (for tracing).
978	* @remarks Caller enters the PDM critical section.
979	*/
980	DECLR0CALLBACKMEMBER(void, pfnSetIrq,(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, int iIrq, int iLevel, uint32_t uTagSrc));
981	/** Marks the end of the structure with PDM_PCIBUSREGR0_VERSION. */
982	uint32_t u32EndVersion;
983	} PDMPCIBUSREGR0;
984	/** Pointer to a PCI bus ring-0 registration structure. */
985	typedef PDMPCIBUSREGR0 *PPDMPCIBUSREGR0;
986	/** Current PDMPCIBUSREGR0 version number. */
987	#define PDM_PCIBUSREGR0_VERSION PDM_VERSION_MAKE(0xff87, 1, 0)
988
989	/**
990	* PCI Bus registration structure for raw-mode.
991	*/
992	typedef struct PDMPCIBUSREGRC
993	{
994	/** Structure version number. PDM_PCIBUSREGRC_VERSION defines the current version. */
995	uint32_t u32Version;
996	/** The PCI bus number (from ring-3 registration). */
997	uint32_t iBus;
998	/**
999	* Set the IRQ for a PCI device.
1000	*
1001	* @param pDevIns Device instance of the PCI Bus.
1002	* @param pPciDev The PCI device structure.
1003	* @param iIrq IRQ number to set.
1004	* @param iLevel IRQ level. See the PDM_IRQ_LEVEL_* \#defines.
1005	* @param uTagSrc The IRQ tag and source (for tracing).
1006	* @remarks Caller enters the PDM critical section.
1007	*/
1008	DECLRCCALLBACKMEMBER(void, pfnSetIrq,(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, int iIrq, int iLevel, uint32_t uTagSrc));
1009	/** Marks the end of the structure with PDM_PCIBUSREGRC_VERSION. */
1010	uint32_t u32EndVersion;
1011	} PDMPCIBUSREGRC;
1012	/** Pointer to a PCI bus raw-mode registration structure. */
1013	typedef PDMPCIBUSREGRC *PPDMPCIBUSREGRC;
1014	/** Current PDMPCIBUSREGRC version number. */
1015	#define PDM_PCIBUSREGRC_VERSION PDM_VERSION_MAKE(0xff88, 1, 0)
1016
1017	/** PCI bus registration structure for the current context. */
1018	typedef CTX_SUFF(PDMPCIBUSREG) PDMPCIBUSREGCC;
1019	/** Pointer to a PCI bus registration structure for the current context. */
1020	typedef CTX_SUFF(PPDMPCIBUSREG) PPDMPCIBUSREGCC;
1021	/** PCI bus registration structure version for the current context. */
1022	#define PDM_PCIBUSREGCC_VERSION CTX_MID(PDM_PCIBUSREG,_VERSION)
1023
1024
1025	/**
1026	* PCI Bus RC helpers.
1027	*/
1028	typedef struct PDMPCIHLPRC
1029	{
1030	/** Structure version. PDM_PCIHLPRC_VERSION defines the current version. */
1031	uint32_t u32Version;
1032
1033	/**
1034	* Set an ISA IRQ.
1035	*
1036	* @param pDevIns PCI device instance.
1037	* @param iIrq IRQ number to set.
1038	* @param iLevel IRQ level. See the PDM_IRQ_LEVEL_* \#defines.
1039	* @param uTagSrc The IRQ tag and source (for tracing).
1040	* @thread EMT only.
1041	*/
1042	DECLRCCALLBACKMEMBER(void, pfnIsaSetIrq,(PPDMDEVINS pDevIns, int iIrq, int iLevel, uint32_t uTagSrc));
1043
1044	/**
1045	* Set an I/O-APIC IRQ.
1046	*
1047	* @param pDevIns PCI device instance.
1048	* @param uBusDevFn The bus:device:function of the device initiating the
1049	* IRQ. Pass NIL_PCIBDF when it's not a PCI device or
1050	* interrupt.
1051	* @param iIrq IRQ number to set.
1052	* @param iLevel IRQ level. See the PDM_IRQ_LEVEL_* \#defines.
1053	* @param uTagSrc The IRQ tag and source (for tracing).
1054	* @thread EMT only.
1055	*/
1056	DECLRCCALLBACKMEMBER(void, pfnIoApicSetIrq,(PPDMDEVINS pDevIns, PCIBDF uBusDevFn, int iIrq, int iLevel, uint32_t uTagSrc));
1057
1058	/**
1059	* Send an MSI.
1060	*
1061	* @param pDevIns PCI device instance.
1062	* @param uBusDevFn The bus:device:function of the device initiating the
1063	* MSI. Cannot be NIL_PCIBDF.
1064	* @param pMsi The MSI to send.
1065	* @param uTagSrc The IRQ tag and source (for tracing).
1066	* @thread EMT only.
1067	*/
1068	DECLRCCALLBACKMEMBER(void, pfnIoApicSendMsi,(PPDMDEVINS pDevIns, PCIBDF uBusDevFn, PCMSIMSG pMsi, uint32_t uTagSrc));
1069
1070
1071	/**
1072	* Acquires the PDM lock.
1073	*
1074	* @returns VINF_SUCCESS on success.
1075	* @returns rc if we failed to acquire the lock.
1076	* @param pDevIns The PCI device instance.
1077	* @param rc What to return if we fail to acquire the lock.
1078	*
1079	* @sa PDMCritSectEnter
1080	*/
1081	DECLRCCALLBACKMEMBER(int, pfnLock,(PPDMDEVINS pDevIns, int rc));
1082
1083	/**
1084	* Releases the PDM lock.
1085	*
1086	* @param pDevIns The PCI device instance.
1087	*/
1088	DECLRCCALLBACKMEMBER(void, pfnUnlock,(PPDMDEVINS pDevIns));
1089
1090	/**
1091	* Gets a bus by it's PDM ordinal (typically the parent bus).
1092	*
1093	* @returns Pointer to the device instance of the bus.
1094	* @param pDevIns The PCI bus device instance.
1095	* @param idxPdmBus The PDM ordinal value of the bus to get.
1096	*/
1097	DECLRCCALLBACKMEMBER(PPDMDEVINS, pfnGetBusByNo,(PPDMDEVINS pDevIns, uint32_t idxPdmBus));
1098
1099	/** Just a safety precaution. */
1100	uint32_t u32TheEnd;
1101	} PDMPCIHLPRC;
1102	/** Pointer to PCI helpers. */
1103	typedef RCPTRTYPE(PDMPCIHLPRC *) PPDMPCIHLPRC;
1104	/** Pointer to const PCI helpers. */
1105	typedef RCPTRTYPE(const PDMPCIHLPRC *) PCPDMPCIHLPRC;
1106
1107	/** Current PDMPCIHLPRC version number. */
1108	#define PDM_PCIHLPRC_VERSION PDM_VERSION_MAKE(0xfffd, 4, 0)
1109
1110
1111	/**
1112	* PCI Bus R0 helpers.
1113	*/
1114	typedef struct PDMPCIHLPR0
1115	{
1116	/** Structure version. PDM_PCIHLPR0_VERSION defines the current version. */
1117	uint32_t u32Version;
1118
1119	/**
1120	* Set an ISA IRQ.
1121	*
1122	* @param pDevIns PCI device instance.
1123	* @param iIrq IRQ number to set.
1124	* @param iLevel IRQ level. See the PDM_IRQ_LEVEL_* \#defines.
1125	* @param uTagSrc The IRQ tag and source (for tracing).
1126	* @thread EMT only.
1127	*/
1128	DECLR0CALLBACKMEMBER(void, pfnIsaSetIrq,(PPDMDEVINS pDevIns, int iIrq, int iLevel, uint32_t uTagSrc));
1129
1130	/**
1131	* Set an I/O-APIC IRQ.
1132	*
1133	* @param pDevIns PCI device instance.
1134	* @param uBusDevFn The bus:device:function of the device initiating the
1135	* IRQ. Pass NIL_PCIBDF when it's not a PCI device or
1136	* interrupt.
1137	* @param iIrq IRQ number to set.
1138	* @param iLevel IRQ level. See the PDM_IRQ_LEVEL_* \#defines.
1139	* @param uTagSrc The IRQ tag and source (for tracing).
1140	* @thread EMT only.
1141	*/
1142	DECLR0CALLBACKMEMBER(void, pfnIoApicSetIrq,(PPDMDEVINS pDevIns, PCIBDF uBusDevFn, int iIrq, int iLevel, uint32_t uTagSrc));
1143
1144	/**
1145	* Send an MSI.
1146	*
1147	* @param pDevIns PCI device instance.
1148	* @param uBusDevFn The bus:device:function of the device initiating the
1149	* MSI. Cannot be NIL_PCIBDF.
1150	* @param pMsi The MSI to send.
1151	* @param uTagSrc The IRQ tag and source (for tracing).
1152	* @thread EMT only.
1153	*/
1154	DECLR0CALLBACKMEMBER(void, pfnIoApicSendMsi,(PPDMDEVINS pDevIns, PCIBDF uBusDevFn, PCMSIMSG pMsi, uint32_t uTagSrc));
1155
1156	/**
1157	* Acquires the PDM lock.
1158	*
1159	* @returns VINF_SUCCESS on success.
1160	* @returns rc if we failed to acquire the lock.
1161	* @param pDevIns The PCI device instance.
1162	* @param rc What to return if we fail to acquire the lock.
1163	*
1164	* @sa PDMCritSectEnter
1165	*/
1166	DECLR0CALLBACKMEMBER(int, pfnLock,(PPDMDEVINS pDevIns, int rc));
1167
1168	/**
1169	* Releases the PDM lock.
1170	*
1171	* @param pDevIns The PCI device instance.
1172	*/
1173	DECLR0CALLBACKMEMBER(void, pfnUnlock,(PPDMDEVINS pDevIns));
1174
1175	/**
1176	* Gets a bus by it's PDM ordinal (typically the parent bus).
1177	*
1178	* @returns Pointer to the device instance of the bus.
1179	* @param pDevIns The PCI bus device instance.
1180	* @param idxPdmBus The PDM ordinal value of the bus to get.
1181	*/
1182	DECLR0CALLBACKMEMBER(PPDMDEVINS, pfnGetBusByNo,(PPDMDEVINS pDevIns, uint32_t idxPdmBus));
1183
1184	/** Just a safety precaution. */
1185	uint32_t u32TheEnd;
1186	} PDMPCIHLPR0;
1187	/** Pointer to PCI helpers. */
1188	typedef R0PTRTYPE(PDMPCIHLPR0 *) PPDMPCIHLPR0;
1189	/** Pointer to const PCI helpers. */
1190	typedef R0PTRTYPE(const PDMPCIHLPR0 *) PCPDMPCIHLPR0;
1191
1192	/** Current PDMPCIHLPR0 version number. */
1193	#define PDM_PCIHLPR0_VERSION PDM_VERSION_MAKE(0xfffc, 6, 0)
1194
1195	/**
1196	* PCI device helpers.
1197	*/
1198	typedef struct PDMPCIHLPR3
1199	{
1200	/** Structure version. PDM_PCIHLPR3_VERSION defines the current version. */
1201	uint32_t u32Version;
1202
1203	/**
1204	* Set an ISA IRQ.
1205	*
1206	* @param pDevIns The PCI device instance.
1207	* @param iIrq IRQ number to set.
1208	* @param iLevel IRQ level. See the PDM_IRQ_LEVEL_* \#defines.
1209	* @param uTagSrc The IRQ tag and source (for tracing).
1210	*/
1211	DECLR3CALLBACKMEMBER(void, pfnIsaSetIrq,(PPDMDEVINS pDevIns, int iIrq, int iLevel, uint32_t uTagSrc));
1212
1213	/**
1214	* Set an I/O-APIC IRQ.
1215	*
1216	* @param pDevIns The PCI device instance.
1217	* @param uBusDevFn The bus:device:function of the device initiating the
1218	* IRQ. Pass NIL_PCIBDF when it's not a PCI device or
1219	* interrupt.
1220	* @param iIrq IRQ number to set.
1221	* @param iLevel IRQ level. See the PDM_IRQ_LEVEL_* \#defines.
1222	* @param uTagSrc The IRQ tag and source (for tracing).
1223	*/
1224	DECLR3CALLBACKMEMBER(void, pfnIoApicSetIrq,(PPDMDEVINS pDevIns, PCIBDF uBusDevFn, int iIrq, int iLevel, uint32_t uTagSrc));
1225
1226	/**
1227	* Send an MSI.
1228	*
1229	* @param pDevIns PCI device instance.
1230	* @param uBusDevFn The bus:device:function of the device initiating the
1231	* MSI. Cannot be NIL_PCIBDF.
1232	* @param pMsi The MSI to send.
1233	* @param uTagSrc The IRQ tag and source (for tracing).
1234	*/
1235	DECLR3CALLBACKMEMBER(void, pfnIoApicSendMsi,(PPDMDEVINS pDevIns, PCIBDF uBusDevFn, PCMSIMSG pMsi, uint32_t uTagSrc));
1236
1237	/**
1238	* Acquires the PDM lock.
1239	*
1240	* @returns VINF_SUCCESS on success.
1241	* @returns Fatal error on failure.
1242	* @param pDevIns The PCI device instance.
1243	* @param rc Dummy for making the interface identical to the RC and R0 versions.
1244	*
1245	* @sa PDMCritSectEnter
1246	*/
1247	DECLR3CALLBACKMEMBER(int, pfnLock,(PPDMDEVINS pDevIns, int rc));
1248
1249	/**
1250	* Releases the PDM lock.
1251	*
1252	* @param pDevIns The PCI device instance.
1253	*/
1254	DECLR3CALLBACKMEMBER(void, pfnUnlock,(PPDMDEVINS pDevIns));
1255
1256	/**
1257	* Gets a bus by it's PDM ordinal (typically the parent bus).
1258	*
1259	* @returns Pointer to the device instance of the bus.
1260	* @param pDevIns The PCI bus device instance.
1261	* @param idxPdmBus The PDM ordinal value of the bus to get.
1262	*/
1263	DECLR3CALLBACKMEMBER(PPDMDEVINS, pfnGetBusByNo,(PPDMDEVINS pDevIns, uint32_t idxPdmBus));
1264
1265	/** Just a safety precaution. */
1266	uint32_t u32TheEnd;
1267	} PDMPCIHLPR3;
1268	/** Pointer to PCI helpers. */
1269	typedef R3PTRTYPE(PDMPCIHLPR3 *) PPDMPCIHLPR3;
1270	/** Pointer to const PCI helpers. */
1271	typedef R3PTRTYPE(const PDMPCIHLPR3 *) PCPDMPCIHLPR3;
1272
1273	/** Current PDMPCIHLPR3 version number. */
1274	#define PDM_PCIHLPR3_VERSION PDM_VERSION_MAKE(0xfffb, 5, 0)
1275
1276
1277	/** @name PDMIOMMU_MEM_F_XXX - IOMMU memory access transaction flags.
1278	* These flags are used for memory access transactions via the IOMMU interface.
1279	* @{ */
1280	/** Memory read. */
1281	#define PDMIOMMU_MEM_F_READ RT_BIT_32(0)
1282	/** Memory write. */
1283	#define PDMIOMMU_MEM_F_WRITE RT_BIT_32(1)
1284	/** Valid flag mask. */
1285	#define PDMIOMMU_MEM_F_VALID_MASK (PDMIOMMU_MEM_F_READ \| PDMIOMMU_MEM_F_WRITE)
1286	/** @} */
1287
1288	/**
1289	* IOMMU registration structure for ring-0.
1290	*/
1291	typedef struct PDMIOMMUREGR0
1292	{
1293	/** Structure version number. PDM_IOMMUREG_VERSION defines the current
1294	* version. */
1295	uint32_t u32Version;
1296	/** Index into the PDM IOMMU array (PDM::aIommus) from ring-3. */
1297	uint32_t idxIommu;
1298
1299	/**
1300	* Translates the physical address for a memory transaction through the IOMMU.
1301	*
1302	* @returns VBox status code.
1303	* @param pDevIns The IOMMU device instance.
1304	* @param idDevice The device identifier (bus, device, function).
1305	* @param uIova The I/O virtual address being accessed.
1306	* @param cbIova The size of the access.
1307	* @param fFlags Access flags, see PDMIOMMU_MEM_F_XXX.
1308	* @param pGCPhysSpa Where to store the translated system physical address.
1309	* @param pcbContiguous Where to store the number of contiguous bytes translated
1310	* and permission-checked.
1311	*
1312	* @thread Any.
1313	*/
1314	DECLR0CALLBACKMEMBER(int, pfnMemAccess,(PPDMDEVINS pDevIns, uint16_t idDevice, uint64_t uIova, size_t cbIova,
1315	uint32_t fFlags, PRTGCPHYS pGCPhysSpa, size_t *pcbContiguous));
1316
1317	/**
1318	* Translates in bulk physical page addresses for memory transactions through the
1319	* IOMMU.
1320	*
1321	* @returns VBox status code.
1322	* @param pDevIns The IOMMU device instance.
1323	* @param idDevice The device identifier (bus, device, function).
1324	* @param cIovas The number of I/O virtual addresses being accessed.
1325	* @param pauIovas The I/O virtual addresses being accessed.
1326	* @param fFlags Access flags, see PDMIOMMU_MEM_F_XXX.
1327	* @param paGCPhysSpa Where to store the translated system physical page
1328	* addresses.
1329	*
1330	* @thread Any.
1331	*/
1332	DECLR0CALLBACKMEMBER(int, pfnMemBulkAccess,(PPDMDEVINS pDevIns, uint16_t idDevice, size_t cIovas, uint64_t const *pauIovas,
1333	uint32_t fFlags, PRTGCPHYS paGCPhysSpa));
1334
1335	/**
1336	* Performs an interrupt remap request through the IOMMU.
1337	*
1338	* @returns VBox status code.
1339	* @param pDevIns The IOMMU device instance.
1340	* @param idDevice The device identifier (bus, device, function).
1341	* @param pMsiIn The source MSI.
1342	* @param pMsiOut Where to store the remapped MSI.
1343	*
1344	* @thread Any.
1345	*/
1346	DECLR0CALLBACKMEMBER(int, pfnMsiRemap,(PPDMDEVINS pDevIns, uint16_t idDevice, PCMSIMSG pMsiIn, PMSIMSG pMsiOut));
1347
1348	/** Just a safety precaution. */
1349	uint32_t u32TheEnd;
1350	} PDMIOMMUREGR0;
1351	/** Pointer to a IOMMU registration structure. */
1352	typedef PDMIOMMUREGR0 *PPDMIOMMUREGR0;
1353
1354	/** Current PDMIOMMUREG version number. */
1355	#define PDM_IOMMUREGR0_VERSION PDM_VERSION_MAKE(0xff10, 3, 0)
1356
1357
1358	/**
1359	* IOMMU registration structure for raw-mode.
1360	*/
1361	typedef struct PDMIOMMUREGRC
1362	{
1363	/** Structure version number. PDM_IOMMUREG_VERSION defines the current
1364	* version. */
1365	uint32_t u32Version;
1366	/** Index into the PDM IOMMU array (PDM::aIommus) from ring-3. */
1367	uint32_t idxIommu;
1368
1369	/**
1370	* Translates the physical address for a memory transaction through the IOMMU.
1371	*
1372	* @returns VBox status code.
1373	* @param pDevIns The IOMMU device instance.
1374	* @param idDevice The device identifier (bus, device, function).
1375	* @param uIova The I/O virtual address being accessed.
1376	* @param cbIova The size of the access.
1377	* @param fFlags Access flags, see PDMIOMMU_MEM_F_XXX.
1378	* @param pGCPhysSpa Where to store the translated system physical address.
1379	* @param pcbContiguous Where to store the number of contiguous bytes translated
1380	* and permission-checked.
1381	*
1382	* @thread Any.
1383	*/
1384	DECLRCCALLBACKMEMBER(int, pfnMemAccess,(PPDMDEVINS pDevIns, uint16_t idDevice, uint64_t uIova, size_t cbIova,
1385	uint32_t fFlags, PRTGCPHYS pGCPhysSpa, size_t *pcbContiguous));
1386
1387	/**
1388	* Translates in bulk physical page addresses for memory transactions through the
1389	* IOMMU.
1390	*
1391	* @returns VBox status code.
1392	* @param pDevIns The IOMMU device instance.
1393	* @param idDevice The device identifier (bus, device, function).
1394	* @param cIovas The number of I/O virtual addresses being accessed.
1395	* @param pauIovas The I/O virtual addresses being accessed.
1396	* @param fFlags Access flags, see PDMIOMMU_MEM_F_XXX.
1397	* @param paGCPhysSpa Where to store the translated system physical page
1398	* addresses.
1399	*
1400	* @thread Any.
1401	*/
1402	DECLRCCALLBACKMEMBER(int, pfnMemBulkAccess,(PPDMDEVINS pDevIns, uint16_t idDevice, size_t cIovas, uint64_t const *pauIovas,
1403	uint32_t fFlags, PRTGCPHYS paGCPhysSpa));
1404
1405	/**
1406	* Performs an interrupt remap request through the IOMMU.
1407	*
1408	* @returns VBox status code.
1409	* @param pDevIns The IOMMU device instance.
1410	* @param idDevice The device identifier (bus, device, function).
1411	* @param pMsiIn The source MSI.
1412	* @param pMsiOut Where to store the remapped MSI.
1413	*
1414	* @thread Any.
1415	*/
1416	DECLRCCALLBACKMEMBER(int, pfnMsiRemap,(PPDMDEVINS pDevIns, uint16_t idDevice, PCMSIMSG pMsiIn, PMSIMSG pMsiOut));
1417
1418	/** Just a safety precaution. */
1419	uint32_t u32TheEnd;
1420	} PDMIOMMUREGRC;
1421	/** Pointer to a IOMMU registration structure. */
1422	typedef PDMIOMMUREGRC *PPDMIOMMUREGRC;
1423
1424	/** Current PDMIOMMUREG version number. */
1425	#define PDM_IOMMUREGRC_VERSION PDM_VERSION_MAKE(0xff11, 3, 0)
1426
1427
1428	/**
1429	* IOMMU registration structure for ring-3.
1430	*/
1431	typedef struct PDMIOMMUREGR3
1432	{
1433	/** Structure version number. PDM_IOMMUREG_VERSION defines the current
1434	* version. */
1435	uint32_t u32Version;
1436	/** Padding. */
1437	uint32_t uPadding0;
1438
1439	/**
1440	* Translates the physical address for a memory transaction through the IOMMU.
1441	*
1442	* @returns VBox status code.
1443	* @param pDevIns The IOMMU device instance.
1444	* @param idDevice The device identifier (bus, device, function).
1445	* @param uIova The I/O virtual address being accessed.
1446	* @param cbIova The size of the access.
1447	* @param fFlags Access flags, see PDMIOMMU_MEM_F_XXX.
1448	* @param pGCPhysSpa Where to store the translated system physical address.
1449	* @param pcbContiguous Where to store the number of contiguous bytes translated
1450	* and permission-checked.
1451	*
1452	* @thread Any.
1453	*/
1454	DECLR3CALLBACKMEMBER(int, pfnMemAccess,(PPDMDEVINS pDevIns, uint16_t idDevice, uint64_t uIova, size_t cbIova,
1455	uint32_t fFlags, PRTGCPHYS pGCPhysSpa, size_t *pcbContiguous));
1456
1457	/**
1458	* Translates in bulk physical page addresses for memory transactions through the
1459	* IOMMU.
1460	*
1461	* @returns VBox status code.
1462	* @param pDevIns The IOMMU device instance.
1463	* @param idDevice The device identifier (bus, device, function).
1464	* @param cIovas The number of I/O virtual addresses being accessed.
1465	* @param pauIovas The I/O virtual addresses being accessed.
1466	* @param fFlags Access flags, see PDMIOMMU_MEM_F_XXX.
1467	* @param paGCPhysSpa Where to store the translated system physical page
1468	* addresses.
1469	*
1470	* @thread Any.
1471	*/
1472	DECLR3CALLBACKMEMBER(int, pfnMemBulkAccess,(PPDMDEVINS pDevIns, uint16_t idDevice, size_t cIovas, uint64_t const *pauIovas,
1473	uint32_t fFlags, PRTGCPHYS paGCPhysSpa));
1474
1475	/**
1476	* Performs an interrupt remap request through the IOMMU.
1477	*
1478	* @returns VBox status code.
1479	* @param pDevIns The IOMMU device instance.
1480	* @param idDevice The device identifier (bus, device, function).
1481	* @param pMsiIn The source MSI.
1482	* @param pMsiOut Where to store the remapped MSI.
1483	*
1484	* @thread Any.
1485	*/
1486	DECLR3CALLBACKMEMBER(int, pfnMsiRemap,(PPDMDEVINS pDevIns, uint16_t idDevice, PCMSIMSG pMsiIn, PMSIMSG pMsiOut));
1487
1488	/** Just a safety precaution. */
1489	uint32_t u32TheEnd;
1490	} PDMIOMMUREGR3;
1491	/** Pointer to a IOMMU registration structure. */
1492	typedef PDMIOMMUREGR3 *PPDMIOMMUREGR3;
1493
1494	/** Current PDMIOMMUREG version number. */
1495	#define PDM_IOMMUREGR3_VERSION PDM_VERSION_MAKE(0xff12, 3, 0)
1496
1497	/** IOMMU registration structure for the current context. */
1498	typedef CTX_SUFF(PDMIOMMUREG) PDMIOMMUREGCC;
1499	/** Pointer to an IOMMU registration structure for the current context. */
1500	typedef CTX_SUFF(PPDMIOMMUREG) PPDMIOMMUREGCC;
1501	/** IOMMU registration structure version for the current context. */
1502	#define PDM_IOMMUREGCC_VERSION CTX_MID(PDM_IOMMUREG,_VERSION)
1503
1504
1505	/**
1506	* IOMMU helpers for ring-0.
1507	*/
1508	typedef struct PDMIOMMUHLPR0
1509	{
1510	/** Structure version. PDM_IOMMUHLP_VERSION defines the current version. */
1511	uint32_t u32Version;
1512
1513	/**
1514	* Acquires the PDM lock.
1515	*
1516	* @returns VINF_SUCCESS on success.
1517	* @returns rc if we failed to acquire the lock.
1518	* @param pDevIns The PCI device instance.
1519	* @param rc What to return if we fail to acquire the lock.
1520	*
1521	* @sa PDMCritSectEnter
1522	*/
1523	DECLR0CALLBACKMEMBER(int, pfnLock,(PPDMDEVINS pDevIns, int rc));
1524
1525	/**
1526	* Releases the PDM lock.
1527	*
1528	* @param pDevIns The PCI device instance.
1529	*/
1530	DECLR0CALLBACKMEMBER(void, pfnUnlock,(PPDMDEVINS pDevIns));
1531
1532	/**
1533	* Check whether the calling thread owns the PDM lock.
1534	*
1535	* @returns @c true if the PDM lock is owned, @c false otherwise.
1536	* @param pDevIns The PCI device instance.
1537	*/
1538	DECLR0CALLBACKMEMBER(bool, pfnLockIsOwner,(PPDMDEVINS pDevIns));
1539
1540	/**
1541	* Send an MSI (when generated by the IOMMU device itself).
1542	*
1543	* @param pDevIns PCI device instance.
1544	* @param pMsi The MSI to send.
1545	* @param uTagSrc The IRQ tag and source (for tracing).
1546	*/
1547	DECLR0CALLBACKMEMBER(void, pfnSendMsi,(PPDMDEVINS pDevIns, PCMSIMSG pMsi, uint32_t uTagSrc));
1548
1549	/** Just a safety precaution. */
1550	uint32_t u32TheEnd;
1551	} PDMIOMMUHLPR0;
1552	/** Pointer to IOMMU helpers for ring-0. */
1553	typedef PDMIOMMUHLPR0 *PPDMIOMMUHLPR0;
1554	/** Pointer to const IOMMU helpers for ring-0. */
1555	typedef const PDMIOMMUHLPR0 *PCPDMIOMMUHLPR0;
1556
1557	/** Current PDMIOMMUHLPR0 version number. */
1558	#define PDM_IOMMUHLPR0_VERSION PDM_VERSION_MAKE(0xff13, 5, 0)
1559
1560
1561	/**
1562	* IOMMU helpers for raw-mode.
1563	*/
1564	typedef struct PDMIOMMUHLPRC
1565	{
1566	/** Structure version. PDM_IOMMUHLP_VERSION defines the current version. */
1567	uint32_t u32Version;
1568
1569	/**
1570	* Acquires the PDM lock.
1571	*
1572	* @returns VINF_SUCCESS on success.
1573	* @returns rc if we failed to acquire the lock.
1574	* @param pDevIns The PCI device instance.
1575	* @param rc What to return if we fail to acquire the lock.
1576	*
1577	* @sa PDMCritSectEnter
1578	*/
1579	DECLRCCALLBACKMEMBER(int, pfnLock,(PPDMDEVINS pDevIns, int rc));
1580
1581	/**
1582	* Releases the PDM lock.
1583	*
1584	* @param pDevIns The PCI device instance.
1585	*/
1586	DECLRCCALLBACKMEMBER(void, pfnUnlock,(PPDMDEVINS pDevIns));
1587
1588	/**
1589	* Check whether the threads owns the PDM lock.
1590	*
1591	* @returns @c true if the PDM lock is owned, @c false otherwise.
1592	* @param pDevIns The PCI device instance.
1593	*/
1594	DECLRCCALLBACKMEMBER(bool, pfnLockIsOwner,(PPDMDEVINS pDevIns));
1595
1596	/**
1597	* Send an MSI (when generated by the IOMMU device itself).
1598	*
1599	* @param pDevIns PCI device instance.
1600	* @param pMsi The MSI to send.
1601	* @param uTagSrc The IRQ tag and source (for tracing).
1602	*/
1603	DECLRCCALLBACKMEMBER(void, pfnSendMsi,(PPDMDEVINS pDevIns, PCMSIMSG pMsi, uint32_t uTagSrc));
1604
1605	/** Just a safety precaution. */
1606	uint32_t u32TheEnd;
1607	} PDMIOMMUHLPRC;
1608	/** Pointer to IOMMU helpers for raw-mode. */
1609	typedef PDMIOMMUHLPRC *PPDMIOMMUHLPRC;
1610	/** Pointer to const IOMMU helpers for raw-mode. */
1611	typedef const PDMIOMMUHLPRC *PCPDMIOMMUHLPRC;
1612
1613	/** Current PDMIOMMUHLPRC version number. */
1614	#define PDM_IOMMUHLPRC_VERSION PDM_VERSION_MAKE(0xff14, 5, 0)
1615
1616
1617	/**
1618	* IOMMU helpers for ring-3.
1619	*/
1620	typedef struct PDMIOMMUHLPR3
1621	{
1622	/** Structure version. PDM_IOMMUHLP_VERSION defines the current version. */
1623	uint32_t u32Version;
1624
1625	/**
1626	* Acquires the PDM lock.
1627	*
1628	* @returns VINF_SUCCESS on success.
1629	* @returns rc if we failed to acquire the lock.
1630	* @param pDevIns The PCI device instance.
1631	* @param rc What to return if we fail to acquire the lock.
1632	*
1633	* @sa PDMCritSectEnter
1634	*/
1635	DECLR3CALLBACKMEMBER(int, pfnLock,(PPDMDEVINS pDevIns, int rc));
1636
1637	/**
1638	* Releases the PDM lock.
1639	*
1640	* @param pDevIns The PCI device instance.
1641	*/
1642	DECLR3CALLBACKMEMBER(void, pfnUnlock,(PPDMDEVINS pDevIns));
1643
1644	/**
1645	* Check whether the threads owns the PDM lock.
1646	*
1647	* @returns @c true if the PDM lock is owned, @c false otherwise.
1648	* @param pDevIns The PCI device instance.
1649	*/
1650	DECLR3CALLBACKMEMBER(bool, pfnLockIsOwner,(PPDMDEVINS pDevIns));
1651
1652	/**
1653	* Send an MSI (when generated by the IOMMU device itself).
1654	*
1655	* @param pDevIns PCI device instance.
1656	* @param pMsi The MSI to send.
1657	* @param uTagSrc The IRQ tag and source (for tracing).
1658	*/
1659	DECLR3CALLBACKMEMBER(void, pfnSendMsi,(PPDMDEVINS pDevIns, PCMSIMSG pMsi, uint32_t uTagSrc));
1660
1661	/** Just a safety precaution. */
1662	uint32_t u32TheEnd;
1663	} PDMIOMMUHLPR3;
1664	/** Pointer to IOMMU helpers for raw-mode. */
1665	typedef PDMIOMMUHLPR3 *PPDMIOMMUHLPR3;
1666	/** Pointer to const IOMMU helpers for raw-mode. */
1667	typedef const PDMIOMMUHLPR3 *PCPDMIOMMUHLPR3;
1668
1669	/** Current PDMIOMMUHLPR3 version number. */
1670	#define PDM_IOMMUHLPR3_VERSION PDM_VERSION_MAKE(0xff15, 5, 0)
1671
1672
1673	/**
1674	* Programmable Interrupt Controller registration structure (all contexts).
1675	*/
1676	typedef struct PDMPICREG
1677	{
1678	/** Structure version number. PDM_PICREG_VERSION defines the current version. */
1679	uint32_t u32Version;
1680
1681	/**
1682	* Set the an IRQ.
1683	*
1684	* @param pDevIns Device instance of the PIC.
1685	* @param iIrq IRQ number to set.
1686	* @param iLevel IRQ level. See the PDM_IRQ_LEVEL_* \#defines.
1687	* @param uTagSrc The IRQ tag and source (for tracing).
1688	* @remarks Caller enters the PDM critical section.
1689	*/
1690	DECLCALLBACKMEMBER(void, pfnSetIrq,(PPDMDEVINS pDevIns, int iIrq, int iLevel, uint32_t uTagSrc));
1691
1692	/**
1693	* Get a pending interrupt.
1694	*
1695	* @returns Pending interrupt number.
1696	* @param pDevIns Device instance of the PIC.
1697	* @param puTagSrc Where to return the IRQ tag and source.
1698	* @remarks Caller enters the PDM critical section.
1699	*/
1700	DECLCALLBACKMEMBER(int, pfnGetInterrupt,(PPDMDEVINS pDevIns, uint32_t *puTagSrc));
1701
1702	/** Just a safety precaution. */
1703	uint32_t u32TheEnd;
1704	} PDMPICREG;
1705	/** Pointer to a PIC registration structure. */
1706	typedef PDMPICREG *PPDMPICREG;
1707
1708	/** Current PDMPICREG version number. */
1709	#define PDM_PICREG_VERSION PDM_VERSION_MAKE(0xfffa, 3, 0)
1710
1711	/**
1712	* PIC helpers, same in all contexts.
1713	*/
1714	typedef struct PDMPICHLP
1715	{
1716	/** Structure version. PDM_PICHLP_VERSION defines the current version. */
1717	uint32_t u32Version;
1718
1719	/**
1720	* Set the interrupt force action flag.
1721	*
1722	* @param pDevIns Device instance of the PIC.
1723	*/
1724	DECLCALLBACKMEMBER(void, pfnSetInterruptFF,(PPDMDEVINS pDevIns));
1725
1726	/**
1727	* Clear the interrupt force action flag.
1728	*
1729	* @param pDevIns Device instance of the PIC.
1730	*/
1731	DECLCALLBACKMEMBER(void, pfnClearInterruptFF,(PPDMDEVINS pDevIns));
1732
1733	/**
1734	* Acquires the PDM lock.
1735	*
1736	* @returns VINF_SUCCESS on success.
1737	* @returns rc if we failed to acquire the lock.
1738	* @param pDevIns The PIC device instance.
1739	* @param rc What to return if we fail to acquire the lock.
1740	*
1741	* @sa PDMCritSectEnter
1742	*/
1743	DECLCALLBACKMEMBER(int, pfnLock,(PPDMDEVINS pDevIns, int rc));
1744
1745	/**
1746	* Releases the PDM lock.
1747	*
1748	* @param pDevIns The PIC device instance.
1749	*/
1750	DECLCALLBACKMEMBER(void, pfnUnlock,(PPDMDEVINS pDevIns));
1751
1752	/** Just a safety precaution. */
1753	uint32_t u32TheEnd;
1754	} PDMPICHLP;
1755	/** Pointer to PIC helpers. */
1756	typedef PDMPICHLP *PPDMPICHLP;
1757	/** Pointer to const PIC helpers. */
1758	typedef const PDMPICHLP *PCPDMPICHLP;
1759
1760	/** Current PDMPICHLP version number. */
1761	#define PDM_PICHLP_VERSION PDM_VERSION_MAKE(0xfff9, 3, 0)
1762
1763
1764	/**
1765	* Firmware registration structure.
1766	*/
1767	typedef struct PDMFWREG
1768	{
1769	/** Struct version+magic number (PDM_FWREG_VERSION). */
1770	uint32_t u32Version;
1771
1772	/**
1773	* Checks whether this is a hard or soft reset.
1774	*
1775	* The current definition of soft reset is what the PC BIOS does when CMOS[0xF]
1776	* is 5, 9 or 0xA.
1777	*
1778	* @returns true if hard reset, false if soft.
1779	* @param pDevIns Device instance of the firmware.
1780	* @param fFlags PDMRESET_F_XXX passed to the PDMDevHlpVMReset API.
1781	*/
1782	DECLR3CALLBACKMEMBER(bool, pfnIsHardReset,(PPDMDEVINS pDevIns, uint32_t fFlags));
1783
1784	/** Just a safety precaution. */
1785	uint32_t u32TheEnd;
1786	} PDMFWREG;
1787	/** Pointer to a FW registration structure. */
1788	typedef PDMFWREG *PPDMFWREG;
1789	/** Pointer to a const FW registration structure. */
1790	typedef PDMFWREG const *PCPDMFWREG;
1791
1792	/** Current PDMFWREG version number. */
1793	#define PDM_FWREG_VERSION PDM_VERSION_MAKE(0xffdd, 1, 0)
1794
1795	/**
1796	* Firmware R3 helpers.
1797	*/
1798	typedef struct PDMFWHLPR3
1799	{
1800	/** Structure version. PDM_FWHLP_VERSION defines the current version. */
1801	uint32_t u32Version;
1802
1803	/** Just a safety precaution. */
1804	uint32_t u32TheEnd;
1805	} PDMFWHLPR3;
1806
1807	/** Pointer to FW R3 helpers. */
1808	typedef R3PTRTYPE(PDMFWHLPR3 *) PPDMFWHLPR3;
1809	/** Pointer to const FW R3 helpers. */
1810	typedef R3PTRTYPE(const PDMFWHLPR3 *) PCPDMFWHLPR3;
1811
1812	/** Current PDMFWHLPR3 version number. */
1813	#define PDM_FWHLPR3_VERSION PDM_VERSION_MAKE(0xffdb, 1, 0)
1814
1815
1816	/**
1817	* APIC mode argument for apicR3SetCpuIdFeatureLevel.
1818	*
1819	* Also used in saved-states, CFGM don't change existing values.
1820	*/
1821	typedef enum PDMAPICMODE
1822	{
1823	/** Invalid 0 entry. */
1824	PDMAPICMODE_INVALID = 0,
1825	/** No APIC. */
1826	PDMAPICMODE_NONE,
1827	/** Standard APIC (X86_CPUID_FEATURE_EDX_APIC). */
1828	PDMAPICMODE_APIC,
1829	/** Intel X2APIC (X86_CPUID_FEATURE_ECX_X2APIC). */
1830	PDMAPICMODE_X2APIC,
1831	/** The usual 32-bit paranoia. */
1832	PDMAPICMODE_32BIT_HACK = 0x7fffffff
1833	} PDMAPICMODE;
1834
1835	/**
1836	* APIC irq argument for pfnSetInterruptFF and pfnClearInterruptFF.
1837	*/
1838	typedef enum PDMAPICIRQ
1839	{
1840	/** Invalid 0 entry. */
1841	PDMAPICIRQ_INVALID = 0,
1842	/** Normal hardware interrupt. */
1843	PDMAPICIRQ_HARDWARE,
1844	/** NMI. */
1845	PDMAPICIRQ_NMI,
1846	/** SMI. */
1847	PDMAPICIRQ_SMI,
1848	/** ExtINT (HW interrupt via PIC). */
1849	PDMAPICIRQ_EXTINT,
1850	/** Interrupt arrived, needs to be updated to the IRR. */
1851	PDMAPICIRQ_UPDATE_PENDING,
1852	/** The usual 32-bit paranoia. */
1853	PDMAPICIRQ_32BIT_HACK = 0x7fffffff
1854	} PDMAPICIRQ;
1855
1856
1857	/**
1858	* I/O APIC registration structure (all contexts).
1859	*/
1860	typedef struct PDMIOAPICREG
1861	{
1862	/** Struct version+magic number (PDM_IOAPICREG_VERSION). */
1863	uint32_t u32Version;
1864
1865	/**
1866	* Set an IRQ.
1867	*
1868	* @param pDevIns Device instance of the I/O APIC.
1869	* @param uBusDevFn The bus:device:function of the device initiating the
1870	* IRQ. Can be NIL_PCIBDF.
1871	* @param iIrq IRQ number to set.
1872	* @param iLevel IRQ level. See the PDM_IRQ_LEVEL_* \#defines.
1873	* @param uTagSrc The IRQ tag and source (for tracing).
1874	*
1875	* @remarks Caller enters the PDM critical section
1876	* Actually, as per 2018-07-21 this isn't true (bird).
1877	*/
1878	DECLCALLBACKMEMBER(void, pfnSetIrq,(PPDMDEVINS pDevIns, PCIBDF uBusDevFn, int iIrq, int iLevel, uint32_t uTagSrc));
1879
1880	/**
1881	* Send a MSI.
1882	*
1883	* @param pDevIns Device instance of the I/O APIC.
1884	* @param uBusDevFn The bus:device:function of the device initiating the
1885	* MSI. Cannot be NIL_PCIBDF.
1886	* @param pMsi The MSI to send.
1887	* @param uTagSrc The IRQ tag and source (for tracing).
1888	*
1889	* @remarks Caller enters the PDM critical section
1890	* Actually, as per 2018-07-21 this isn't true (bird).
1891	*/
1892	DECLCALLBACKMEMBER(void, pfnSendMsi,(PPDMDEVINS pDevIns, PCIBDF uBusDevFn, PCMSIMSG pMsi, uint32_t uTagSrc));
1893
1894	/**
1895	* Set the EOI for an interrupt vector.
1896	*
1897	* @param pDevIns Device instance of the I/O APIC.
1898	* @param u8Vector The vector.
1899	*
1900	* @remarks Caller enters the PDM critical section
1901	* Actually, as per 2018-07-21 this isn't true (bird).
1902	*/
1903	DECLCALLBACKMEMBER(void, pfnSetEoi,(PPDMDEVINS pDevIns, uint8_t u8Vector));
1904
1905	/** Just a safety precaution. */
1906	uint32_t u32TheEnd;
1907	} PDMIOAPICREG;
1908	/** Pointer to an APIC registration structure. */
1909	typedef PDMIOAPICREG *PPDMIOAPICREG;
1910
1911	/** Current PDMAPICREG version number. */
1912	#define PDM_IOAPICREG_VERSION PDM_VERSION_MAKE(0xfff2, 8, 0)
1913
1914
1915	/**
1916	* IOAPIC helpers, same in all contexts.
1917	*/
1918	typedef struct PDMIOAPICHLP
1919	{
1920	/** Structure version. PDM_IOAPICHLP_VERSION defines the current version. */
1921	uint32_t u32Version;
1922
1923	/**
1924	* Private interface between the IOAPIC and APIC.
1925	*
1926	* @returns status code.
1927	* @param pDevIns Device instance of the IOAPIC.
1928	* @param u8Dest See APIC implementation.
1929	* @param u8DestMode See APIC implementation.
1930	* @param u8DeliveryMode See APIC implementation.
1931	* @param uVector See APIC implementation.
1932	* @param u8Polarity See APIC implementation.
1933	* @param u8TriggerMode See APIC implementation.
1934	* @param uTagSrc The IRQ tag and source (for tracing).
1935	*
1936	* @sa APICBusDeliver()
1937	*/
1938	DECLCALLBACKMEMBER(int, pfnApicBusDeliver,(PPDMDEVINS pDevIns, uint8_t u8Dest, uint8_t u8DestMode, uint8_t u8DeliveryMode,
1939	uint8_t uVector, uint8_t u8Polarity, uint8_t u8TriggerMode, uint32_t uTagSrc));
1940
1941	/**
1942	* Acquires the PDM lock.
1943	*
1944	* @returns VINF_SUCCESS on success.
1945	* @returns rc if we failed to acquire the lock.
1946	* @param pDevIns The IOAPIC device instance.
1947	* @param rc What to return if we fail to acquire the lock.
1948	*
1949	* @sa PDMCritSectEnter
1950	*/
1951	DECLCALLBACKMEMBER(int, pfnLock,(PPDMDEVINS pDevIns, int rc));
1952
1953	/**
1954	* Releases the PDM lock.
1955	*
1956	* @param pDevIns The IOAPIC device instance.
1957	*/
1958	DECLCALLBACKMEMBER(void, pfnUnlock,(PPDMDEVINS pDevIns));
1959
1960	/**
1961	* Checks if the calling thread owns the PDM lock.
1962	*
1963	* @param pDevIns The IOAPIC device instance.
1964	*/
1965	DECLCALLBACKMEMBER(bool, pfnLockIsOwner,(PPDMDEVINS pDevIns));
1966
1967	/**
1968	* Private interface between the IOAPIC and IOMMU.
1969	*
1970	* @returns status code.
1971	* @param pDevIns Device instance of the IOAPIC.
1972	* @param idDevice The device identifier (bus, device, function).
1973	* @param pMsiIn The source MSI.
1974	* @param pMsiOut Where to store the remapped MSI (only updated when
1975	* VINF_SUCCESS is returned).
1976	*/
1977	DECLCALLBACKMEMBER(int, pfnIommuMsiRemap,(PPDMDEVINS pDevIns, uint16_t idDevice, PCMSIMSG pMsiIn, PMSIMSG pMsiOut));
1978
1979	/** Just a safety precaution. */
1980	uint32_t u32TheEnd;
1981	} PDMIOAPICHLP;
1982	/** Pointer to IOAPIC helpers. */
1983	typedef PDMIOAPICHLP * PPDMIOAPICHLP;
1984	/** Pointer to const IOAPIC helpers. */
1985	typedef const PDMIOAPICHLP * PCPDMIOAPICHLP;
1986
1987	/** Current PDMIOAPICHLP version number. */
1988	#define PDM_IOAPICHLP_VERSION PDM_VERSION_MAKE(0xfff0, 3, 1)
1989
1990
1991	/**
1992	* HPET registration structure.
1993	*/
1994	typedef struct PDMHPETREG
1995	{
1996	/** Struct version+magic number (PDM_HPETREG_VERSION). */
1997	uint32_t u32Version;
1998	} PDMHPETREG;
1999	/** Pointer to an HPET registration structure. */
2000	typedef PDMHPETREG *PPDMHPETREG;
2001
2002	/** Current PDMHPETREG version number. */
2003	#define PDM_HPETREG_VERSION PDM_VERSION_MAKE(0xffe2, 1, 0)
2004
2005	/**
2006	* HPET RC helpers.
2007	*
2008	* @remarks Keep this around in case HPET will need PDM interaction in again RC
2009	* at some later point.
2010	*/
2011	typedef struct PDMHPETHLPRC
2012	{
2013	/** Structure version. PDM_HPETHLPRC_VERSION defines the current version. */
2014	uint32_t u32Version;
2015
2016	/** Just a safety precaution. */
2017	uint32_t u32TheEnd;
2018	} PDMHPETHLPRC;
2019
2020	/** Pointer to HPET RC helpers. */
2021	typedef RCPTRTYPE(PDMHPETHLPRC *) PPDMHPETHLPRC;
2022	/** Pointer to const HPET RC helpers. */
2023	typedef RCPTRTYPE(const PDMHPETHLPRC *) PCPDMHPETHLPRC;
2024
2025	/** Current PDMHPETHLPRC version number. */
2026	#define PDM_HPETHLPRC_VERSION PDM_VERSION_MAKE(0xffee, 2, 0)
2027
2028
2029	/**
2030	* HPET R0 helpers.
2031	*
2032	* @remarks Keep this around in case HPET will need PDM interaction in again R0
2033	* at some later point.
2034	*/
2035	typedef struct PDMHPETHLPR0
2036	{
2037	/** Structure version. PDM_HPETHLPR0_VERSION defines the current version. */
2038	uint32_t u32Version;
2039
2040	/** Just a safety precaution. */
2041	uint32_t u32TheEnd;
2042	} PDMHPETHLPR0;
2043
2044	/** Pointer to HPET R0 helpers. */
2045	typedef R0PTRTYPE(PDMHPETHLPR0 *) PPDMHPETHLPR0;
2046	/** Pointer to const HPET R0 helpers. */
2047	typedef R0PTRTYPE(const PDMHPETHLPR0 *) PCPDMHPETHLPR0;
2048
2049	/** Current PDMHPETHLPR0 version number. */
2050	#define PDM_HPETHLPR0_VERSION PDM_VERSION_MAKE(0xffed, 2, 0)
2051
2052	/**
2053	* HPET R3 helpers.
2054	*/
2055	typedef struct PDMHPETHLPR3
2056	{
2057	/** Structure version. PDM_HPETHLP_VERSION defines the current version. */
2058	uint32_t u32Version;
2059
2060	/**
2061	* Set legacy mode on PIT and RTC.
2062	*
2063	* @returns VINF_SUCCESS on success.
2064	* @returns rc if we failed to set legacy mode.
2065	* @param pDevIns Device instance of the HPET.
2066	* @param fActivated Whether legacy mode is activated or deactivated.
2067	*/
2068	DECLR3CALLBACKMEMBER(int, pfnSetLegacyMode,(PPDMDEVINS pDevIns, bool fActivated));
2069
2070
2071	/**
2072	* Set IRQ, bypassing ISA bus override rules.
2073	*
2074	* @returns VINF_SUCCESS on success.
2075	* @returns rc if we failed to set legacy mode.
2076	* @param pDevIns Device instance of the HPET.
2077	* @param iIrq IRQ number to set.
2078	* @param iLevel IRQ level. See the PDM_IRQ_LEVEL_* \#defines.
2079	*/
2080	DECLR3CALLBACKMEMBER(int, pfnSetIrq,(PPDMDEVINS pDevIns, int iIrq, int iLevel));
2081
2082	/** Just a safety precaution. */
2083	uint32_t u32TheEnd;
2084	} PDMHPETHLPR3;
2085
2086	/** Pointer to HPET R3 helpers. */
2087	typedef R3PTRTYPE(PDMHPETHLPR3 *) PPDMHPETHLPR3;
2088	/** Pointer to const HPET R3 helpers. */
2089	typedef R3PTRTYPE(const PDMHPETHLPR3 *) PCPDMHPETHLPR3;
2090
2091	/** Current PDMHPETHLPR3 version number. */
2092	#define PDM_HPETHLPR3_VERSION PDM_VERSION_MAKE(0xffec, 3, 0)
2093
2094
2095	/**
2096	* Raw PCI device registration structure.
2097	*/
2098	typedef struct PDMPCIRAWREG
2099	{
2100	/** Struct version+magic number (PDM_PCIRAWREG_VERSION). */
2101	uint32_t u32Version;
2102	/** Just a safety precaution. */
2103	uint32_t u32TheEnd;
2104	} PDMPCIRAWREG;
2105	/** Pointer to a raw PCI registration structure. */
2106	typedef PDMPCIRAWREG *PPDMPCIRAWREG;
2107
2108	/** Current PDMPCIRAWREG version number. */
2109	#define PDM_PCIRAWREG_VERSION PDM_VERSION_MAKE(0xffe1, 1, 0)
2110
2111	/**
2112	* Raw PCI device raw-mode context helpers.
2113	*/
2114	typedef struct PDMPCIRAWHLPRC
2115	{
2116	/** Structure version and magic number (PDM_PCIRAWHLPRC_VERSION). */
2117	uint32_t u32Version;
2118	/** Just a safety precaution. */
2119	uint32_t u32TheEnd;
2120	} PDMPCIRAWHLPRC;
2121	/** Pointer to a raw PCI deviec raw-mode context helper structure. */
2122	typedef RCPTRTYPE(PDMPCIRAWHLPRC *) PPDMPCIRAWHLPRC;
2123	/** Pointer to a const raw PCI deviec raw-mode context helper structure. */
2124	typedef RCPTRTYPE(const PDMPCIRAWHLPRC *) PCPDMPCIRAWHLPRC;
2125
2126	/** Current PDMPCIRAWHLPRC version number. */
2127	#define PDM_PCIRAWHLPRC_VERSION PDM_VERSION_MAKE(0xffe0, 1, 0)
2128
2129	/**
2130	* Raw PCI device ring-0 context helpers.
2131	*/
2132	typedef struct PDMPCIRAWHLPR0
2133	{
2134	/** Structure version and magic number (PDM_PCIRAWHLPR0_VERSION). */
2135	uint32_t u32Version;
2136	/** Just a safety precaution. */
2137	uint32_t u32TheEnd;
2138	} PDMPCIRAWHLPR0;
2139	/** Pointer to a raw PCI deviec ring-0 context helper structure. */
2140	typedef R0PTRTYPE(PDMPCIRAWHLPR0 *) PPDMPCIRAWHLPR0;
2141	/** Pointer to a const raw PCI deviec ring-0 context helper structure. */
2142	typedef R0PTRTYPE(const PDMPCIRAWHLPR0 *) PCPDMPCIRAWHLPR0;
2143
2144	/** Current PDMPCIRAWHLPR0 version number. */
2145	#define PDM_PCIRAWHLPR0_VERSION PDM_VERSION_MAKE(0xffdf, 1, 0)
2146
2147
2148	/**
2149	* Raw PCI device ring-3 context helpers.
2150	*/
2151	typedef struct PDMPCIRAWHLPR3
2152	{
2153	/** Undefined structure version and magic number. */
2154	uint32_t u32Version;
2155
2156	/**
2157	* Gets the address of the RC raw PCI device helpers.
2158	*
2159	* This should be called at both construction and relocation time to obtain
2160	* the correct address of the RC helpers.
2161	*
2162	* @returns RC pointer to the raw PCI device helpers.
2163	* @param pDevIns Device instance of the raw PCI device.
2164	*/
2165	DECLR3CALLBACKMEMBER(PCPDMPCIRAWHLPRC, pfnGetRCHelpers,(PPDMDEVINS pDevIns));
2166
2167	/**
2168	* Gets the address of the R0 raw PCI device helpers.
2169	*
2170	* This should be called at both construction and relocation time to obtain
2171	* the correct address of the R0 helpers.
2172	*
2173	* @returns R0 pointer to the raw PCI device helpers.
2174	* @param pDevIns Device instance of the raw PCI device.
2175	*/
2176	DECLR3CALLBACKMEMBER(PCPDMPCIRAWHLPR0, pfnGetR0Helpers,(PPDMDEVINS pDevIns));
2177
2178	/** Just a safety precaution. */
2179	uint32_t u32TheEnd;
2180	} PDMPCIRAWHLPR3;
2181	/** Pointer to raw PCI R3 helpers. */
2182	typedef R3PTRTYPE(PDMPCIRAWHLPR3 *) PPDMPCIRAWHLPR3;
2183	/** Pointer to const raw PCI R3 helpers. */
2184	typedef R3PTRTYPE(const PDMPCIRAWHLPR3 *) PCPDMPCIRAWHLPR3;
2185
2186	/** Current PDMPCIRAWHLPR3 version number. */
2187	#define PDM_PCIRAWHLPR3_VERSION PDM_VERSION_MAKE(0xffde, 1, 0)
2188
2189
2190	#ifdef IN_RING3
2191
2192	/**
2193	* DMA Transfer Handler.
2194	*
2195	* @returns Number of bytes transferred.
2196	* @param pDevIns The device instance that registered the handler.
2197	* @param pvUser User pointer.
2198	* @param uChannel Channel number.
2199	* @param off DMA position.
2200	* @param cb Block size.
2201	* @remarks The device lock is take before the callback (in fact, the locks of
2202	* DMA devices and the DMA controller itself are taken).
2203	*/
2204	typedef DECLCALLBACKTYPE(uint32_t, FNDMATRANSFERHANDLER,(PPDMDEVINS pDevIns, void *pvUser, unsigned uChannel,
2205	uint32_t off, uint32_t cb));
2206	/** Pointer to a FNDMATRANSFERHANDLER(). */
2207	typedef FNDMATRANSFERHANDLER *PFNDMATRANSFERHANDLER;
2208
2209	/**
2210	* DMA Controller registration structure.
2211	*/
2212	typedef struct PDMDMAREG
2213	{
2214	/** Structure version number. PDM_DMACREG_VERSION defines the current version. */
2215	uint32_t u32Version;
2216
2217	/**
2218	* Execute pending transfers.
2219	*
2220	* @returns A more work indiciator. I.e. 'true' if there is more to be done, and 'false' if all is done.
2221	* @param pDevIns Device instance of the DMAC.
2222	* @remarks No locks held, called on EMT(0) as a form of serialization.
2223	*/
2224	DECLR3CALLBACKMEMBER(bool, pfnRun,(PPDMDEVINS pDevIns));
2225
2226	/**
2227	* Register transfer function for DMA channel.
2228	*
2229	* @param pDevIns Device instance of the DMAC.
2230	* @param uChannel Channel number.
2231	* @param pDevInsHandler The device instance of the device making the
2232	* regstration (will be passed to the callback).
2233	* @param pfnTransferHandler Device specific transfer function.
2234	* @param pvUser User pointer to be passed to the callback.
2235	* @remarks No locks held, called on an EMT.
2236	*/
2237	DECLR3CALLBACKMEMBER(void, pfnRegister,(PPDMDEVINS pDevIns, unsigned uChannel, PPDMDEVINS pDevInsHandler,
2238	PFNDMATRANSFERHANDLER pfnTransferHandler, void *pvUser));
2239
2240	/**
2241	* Read memory
2242	*
2243	* @returns Number of bytes read.
2244	* @param pDevIns Device instance of the DMAC.
2245	* @param uChannel Channel number.
2246	* @param pvBuffer Pointer to target buffer.
2247	* @param off DMA position.
2248	* @param cbBlock Block size.
2249	* @remarks No locks held, called on an EMT.
2250	*/
2251	DECLR3CALLBACKMEMBER(uint32_t, pfnReadMemory,(PPDMDEVINS pDevIns, unsigned uChannel, void *pvBuffer, uint32_t off, uint32_t cbBlock));
2252
2253	/**
2254	* Write memory
2255	*
2256	* @returns Number of bytes written.
2257	* @param pDevIns Device instance of the DMAC.
2258	* @param uChannel Channel number.
2259	* @param pvBuffer Memory to write.
2260	* @param off DMA position.
2261	* @param cbBlock Block size.
2262	* @remarks No locks held, called on an EMT.
2263	*/
2264	DECLR3CALLBACKMEMBER(uint32_t, pfnWriteMemory,(PPDMDEVINS pDevIns, unsigned uChannel, const void *pvBuffer, uint32_t off, uint32_t cbBlock));
2265
2266	/**
2267	* Set the DREQ line.
2268	*
2269	* @param pDevIns Device instance of the DMAC.
2270	* @param uChannel Channel number.
2271	* @param uLevel Level of the line.
2272	* @remarks No locks held, called on an EMT.
2273	*/
2274	DECLR3CALLBACKMEMBER(void, pfnSetDREQ,(PPDMDEVINS pDevIns, unsigned uChannel, unsigned uLevel));
2275
2276	/**
2277	* Get channel mode
2278	*
2279	* @returns Channel mode.
2280	* @param pDevIns Device instance of the DMAC.
2281	* @param uChannel Channel number.
2282	* @remarks No locks held, called on an EMT.
2283	*/
2284	DECLR3CALLBACKMEMBER(uint8_t, pfnGetChannelMode,(PPDMDEVINS pDevIns, unsigned uChannel));
2285
2286	} PDMDMACREG;
2287	/** Pointer to a DMAC registration structure. */
2288	typedef PDMDMACREG *PPDMDMACREG;
2289
2290	/** Current PDMDMACREG version number. */
2291	#define PDM_DMACREG_VERSION PDM_VERSION_MAKE(0xffeb, 2, 0)
2292
2293
2294	/**
2295	* DMA Controller device helpers.
2296	*/
2297	typedef struct PDMDMACHLP
2298	{
2299	/** Structure version. PDM_DMACHLP_VERSION defines the current version. */
2300	uint32_t u32Version;
2301
2302	/* to-be-defined */
2303
2304	} PDMDMACHLP;
2305	/** Pointer to DMAC helpers. */
2306	typedef PDMDMACHLP *PPDMDMACHLP;
2307	/** Pointer to const DMAC helpers. */
2308	typedef const PDMDMACHLP *PCPDMDMACHLP;
2309
2310	/** Current PDMDMACHLP version number. */
2311	#define PDM_DMACHLP_VERSION PDM_VERSION_MAKE(0xffea, 1, 0)
2312
2313	#endif /* IN_RING3 */
2314
2315
2316
2317	/**
2318	* RTC registration structure.
2319	*/
2320	typedef struct PDMRTCREG
2321	{
2322	/** Structure version number. PDM_RTCREG_VERSION defines the current version. */
2323	uint32_t u32Version;
2324	uint32_t u32Alignment; /*< structure size alignment. /
2325
2326	/**
2327	* Write to a CMOS register and update the checksum if necessary.
2328	*
2329	* @returns VBox status code.
2330	* @param pDevIns Device instance of the RTC.
2331	* @param iReg The CMOS register index.
2332	* @param u8Value The CMOS register value.
2333	* @remarks Caller enters the device critical section.
2334	*/
2335	DECLR3CALLBACKMEMBER(int, pfnWrite,(PPDMDEVINS pDevIns, unsigned iReg, uint8_t u8Value));
2336
2337	/**
2338	* Read a CMOS register.
2339	*
2340	* @returns VBox status code.
2341	* @param pDevIns Device instance of the RTC.
2342	* @param iReg The CMOS register index.
2343	* @param pu8Value Where to store the CMOS register value.
2344	* @remarks Caller enters the device critical section.
2345	*/
2346	DECLR3CALLBACKMEMBER(int, pfnRead,(PPDMDEVINS pDevIns, unsigned iReg, uint8_t *pu8Value));
2347
2348	} PDMRTCREG;
2349	/** Pointer to a RTC registration structure. */
2350	typedef PDMRTCREG *PPDMRTCREG;
2351	/** Pointer to a const RTC registration structure. */
2352	typedef const PDMRTCREG *PCPDMRTCREG;
2353
2354	/** Current PDMRTCREG version number. */
2355	#define PDM_RTCREG_VERSION PDM_VERSION_MAKE(0xffe9, 2, 0)
2356
2357
2358	/**
2359	* RTC device helpers.
2360	*/
2361	typedef struct PDMRTCHLP
2362	{
2363	/** Structure version. PDM_RTCHLP_VERSION defines the current version. */
2364	uint32_t u32Version;
2365
2366	/* to-be-defined */
2367
2368	} PDMRTCHLP;
2369	/** Pointer to RTC helpers. */
2370	typedef PDMRTCHLP *PPDMRTCHLP;
2371	/** Pointer to const RTC helpers. */
2372	typedef const PDMRTCHLP *PCPDMRTCHLP;
2373
2374	/** Current PDMRTCHLP version number. */
2375	#define PDM_RTCHLP_VERSION PDM_VERSION_MAKE(0xffe8, 1, 0)
2376
2377
2378
2379	/** @name Flags for PCI I/O region registration
2380	* @{ */
2381	/** No handle is passed. */
2382	#define PDMPCIDEV_IORGN_F_NO_HANDLE UINT32_C(0x00000000)
2383	/** An I/O port handle is passed. */
2384	#define PDMPCIDEV_IORGN_F_IOPORT_HANDLE UINT32_C(0x00000001)
2385	/** An MMIO range handle is passed. */
2386	#define PDMPCIDEV_IORGN_F_MMIO_HANDLE UINT32_C(0x00000002)
2387	/** An MMIO2 handle is passed. */
2388	#define PDMPCIDEV_IORGN_F_MMIO2_HANDLE UINT32_C(0x00000003)
2389	/** Handle type mask. */
2390	#define PDMPCIDEV_IORGN_F_HANDLE_MASK UINT32_C(0x00000003)
2391	/** New-style (mostly wrt callbacks). */
2392	#define PDMPCIDEV_IORGN_F_NEW_STYLE UINT32_C(0x00000004)
2393	/** Mask of valid flags. */
2394	#define PDMPCIDEV_IORGN_F_VALID_MASK UINT32_C(0x00000007)
2395	/** @} */
2396
2397
2398	/** @name Flags for the guest physical read/write helpers
2399	* @{ */
2400	/** Default flag with no indication whether the data is processed by the device or just passed through. */
2401	#define PDM_DEVHLP_PHYS_RW_F_DEFAULT UINT32_C(0x00000000)
2402	/** The data is user data which is just passed through between the guest and the source or destination and not processed
2403	* by the device in any way. */
2404	#define PDM_DEVHLP_PHYS_RW_F_DATA_USER RT_BIT_32(0)
2405	/** The data is metadata and being processed by the device in some way. */
2406	#define PDM_DEVHLP_PHYS_RW_F_DATA_META RT_BIT_32(1)
2407	/** @} */
2408
2409
2410	#ifdef IN_RING3
2411
2412	/** @name Special values for PDMDEVHLPR3::pfnPCIRegister parameters.
2413	* @{ */
2414	/** Same device number (and bus) as the previous PCI device registered with the PDM device.
2415	* This is handy when registering multiple PCI device functions and the device
2416	* number is left up to the PCI bus. In order to facilitate one PDM device
2417	* instance for each PCI function, this searches earlier PDM device
2418	* instances as well. */
2419	# define PDMPCIDEVREG_DEV_NO_SAME_AS_PREV UINT8_C(0xfd)
2420	/** Use the first unused device number (all functions must be unused). */
2421	# define PDMPCIDEVREG_DEV_NO_FIRST_UNUSED UINT8_C(0xfe)
2422	/** Use the first unused device function. */
2423	# define PDMPCIDEVREG_FUN_NO_FIRST_UNUSED UINT8_C(0xff)
2424
2425	/** The device and function numbers are not mandatory, just suggestions. */
2426	# define PDMPCIDEVREG_F_NOT_MANDATORY_NO RT_BIT_32(0)
2427	/** Registering a PCI bridge device. */
2428	# define PDMPCIDEVREG_F_PCI_BRIDGE RT_BIT_32(1)
2429	/** Valid flag mask. */
2430	# define PDMPCIDEVREG_F_VALID_MASK UINT32_C(0x00000003)
2431	/** @} */
2432
2433	/** Current PDMDEVHLPR3 version number. */
2434	#define PDM_DEVHLPR3_VERSION PDM_VERSION_MAKE_PP(0xffe7, 66, 0)
2435
2436	/**
2437	* PDM Device API.
2438	*/
2439	typedef struct PDMDEVHLPR3
2440	{
2441	/** Structure version. PDM_DEVHLPR3_VERSION defines the current version. */
2442	uint32_t u32Version;
2443
2444	/** @name I/O ports
2445	* @{ */
2446	/**
2447	* Creates a range of I/O ports for a device.
2448	*
2449	* The I/O port range must be mapped in a separately call. Any ring-0 and
2450	* raw-mode context callback handlers needs to be set up in the respective
2451	* contexts.
2452	*
2453	* @returns VBox status.
2454	* @param pDevIns The device instance to register the ports with.
2455	* @param cPorts Number of ports to register.
2456	* @param fFlags IOM_IOPORT_F_XXX.
2457	* @param pPciDev The PCI device the range is associated with, if
2458	* applicable.
2459	* @param iPciRegion The PCI device region in the high 16-bit word and
2460	* sub-region in the low 16-bit word. UINT32_MAX if NA.
2461	* @param pfnOut Pointer to function which is gonna handle OUT
2462	* operations. Optional.
2463	* @param pfnIn Pointer to function which is gonna handle IN operations.
2464	* Optional.
2465	* @param pfnOutStr Pointer to function which is gonna handle string OUT
2466	* operations. Optional.
2467	* @param pfnInStr Pointer to function which is gonna handle string IN
2468	* operations. Optional.
2469	* @param pvUser User argument to pass to the callbacks.
2470	* @param pszDesc Pointer to description string. This must not be freed.
2471	* @param paExtDescs Extended per-port descriptions, optional. Partial range
2472	* coverage is allowed. This must not be freed.
2473	* @param phIoPorts Where to return the I/O port range handle.
2474	*
2475	* @remarks Caller enters the device critical section prior to invoking the
2476	* registered callback methods.
2477	*
2478	* @sa PDMDevHlpIoPortSetUpContext, PDMDevHlpIoPortMap,
2479	* PDMDevHlpIoPortUnmap.
2480	*/
2481	DECLR3CALLBACKMEMBER(int, pfnIoPortCreateEx,(PPDMDEVINS pDevIns, RTIOPORT cPorts, uint32_t fFlags, PPDMPCIDEV pPciDev,
2482	uint32_t iPciRegion, PFNIOMIOPORTNEWOUT pfnOut, PFNIOMIOPORTNEWIN pfnIn,
2483	PFNIOMIOPORTNEWOUTSTRING pfnOutStr, PFNIOMIOPORTNEWINSTRING pfnInStr, RTR3PTR pvUser,
2484	const char *pszDesc, PCIOMIOPORTDESC paExtDescs, PIOMIOPORTHANDLE phIoPorts));
2485
2486	/**
2487	* Maps an I/O port range.
2488	*
2489	* @returns VBox status.
2490	* @param pDevIns The device instance to register the ports with.
2491	* @param hIoPorts The I/O port range handle.
2492	* @param Port Where to map the range.
2493	* @sa PDMDevHlpIoPortUnmap, PDMDevHlpIoPortSetUpContext,
2494	* PDMDevHlpIoPortCreate, PDMDevHlpIoPortCreateEx.
2495	*/
2496	DECLR3CALLBACKMEMBER(int, pfnIoPortMap,(PPDMDEVINS pDevIns, IOMIOPORTHANDLE hIoPorts, RTIOPORT Port));
2497
2498	/**
2499	* Unmaps an I/O port range.
2500	*
2501	* @returns VBox status.
2502	* @param pDevIns The device instance to register the ports with.
2503	* @param hIoPorts The I/O port range handle.
2504	* @sa PDMDevHlpIoPortMap, PDMDevHlpIoPortSetUpContext,
2505	* PDMDevHlpIoPortCreate, PDMDevHlpIoPortCreateEx.
2506	*/
2507	DECLR3CALLBACKMEMBER(int, pfnIoPortUnmap,(PPDMDEVINS pDevIns, IOMIOPORTHANDLE hIoPorts));
2508
2509	/**
2510	* Gets the mapping address of the I/O port range @a hIoPorts.
2511	*
2512	* @returns Mapping address (0..65535) or UINT32_MAX if not mapped (or invalid
2513	* parameters).
2514	* @param pDevIns The device instance to register the ports with.
2515	* @param hIoPorts The I/O port range handle.
2516	*/
2517	DECLR3CALLBACKMEMBER(uint32_t, pfnIoPortGetMappingAddress,(PPDMDEVINS pDevIns, IOMIOPORTHANDLE hIoPorts));
2518
2519	/**
2520	* Reads from an I/O port register.
2521	*
2522	* @returns Strict VBox status code. Informational status codes other than the one documented
2523	* here are to be treated as internal failure. Use IOM_SUCCESS() to check for success.
2524	* @retval VINF_SUCCESS Success.
2525	* @retval VINF_EM_FIRST-VINF_EM_LAST Success with some exceptions (see IOM_SUCCESS()), the
2526	* status code must be passed on to EM.
2527	*
2528	* @param pDevIns The device instance to register the ports with.
2529	* @param Port The port to read from.
2530	* @param pu32Value Where to store the read value.
2531	* @param cbValue The size of the register to read in bytes. 1, 2 or 4 bytes.
2532	*
2533	* @thread EMT
2534	*
2535	* @note This is required for the ARM platform in order to emulate PIO accesses through a dedicated MMIO region.
2536	*/
2537	DECLR3CALLBACKMEMBER(VBOXSTRICTRC, pfnIoPortRead,(PPDMDEVINS pDevIns, RTIOPORT Port, uint32_t *pu32Value, size_t cbValue));
2538
2539	/**
2540	* Writes to an I/O port register.
2541	*
2542	* @returns Strict VBox status code. Informational status codes other than the one documented
2543	* here are to be treated as internal failure. Use IOM_SUCCESS() to check for success.
2544	* @retval VINF_SUCCESS Success.
2545	* @retval VINF_EM_FIRST-VINF_EM_LAST Success with some exceptions (see IOM_SUCCESS()), the
2546	* status code must be passed on to EM.
2547	*
2548	* @param pDevIns The device instance to register the ports with.
2549	* @param Port The port to write to.
2550	* @param u32Value The value to write.
2551	* @param cbValue The size of the register to write in bytes. 1, 2 or 4 bytes.
2552	*
2553	* @thread EMT
2554	*
2555	* @note This is required for the ARM platform in order to emulate PIO accesses through a dedicated MMIO region.
2556	*/
2557	DECLR3CALLBACKMEMBER(VBOXSTRICTRC, pfnIoPortWrite,(PPDMDEVINS pDevIns, RTIOPORT Port, uint32_t u32Value, size_t cbValue));
2558	/** @} */
2559
2560	/** @name MMIO
2561	* @{ */
2562	/**
2563	* Creates a memory mapped I/O (MMIO) region for a device.
2564	*
2565	* The MMIO region must be mapped in a separately call. Any ring-0 and
2566	* raw-mode context callback handlers needs to be set up in the respective
2567	* contexts.
2568	*
2569	* @returns VBox status.
2570	* @param pDevIns The device instance to register the ports with.
2571	* @param cbRegion The size of the region in bytes.
2572	* @param fFlags Flags, IOMMMIO_FLAGS_XXX.
2573	* @param pPciDev The PCI device the range is associated with, if
2574	* applicable.
2575	* @param iPciRegion The PCI device region in the high 16-bit word and
2576	* sub-region in the low 16-bit word. UINT32_MAX if NA.
2577	* @param pfnWrite Pointer to function which is gonna handle Write
2578	* operations.
2579	* @param pfnRead Pointer to function which is gonna handle Read
2580	* operations.
2581	* @param pfnFill Pointer to function which is gonna handle Fill/memset
2582	* operations. (optional)
2583	* @param pvUser User argument to pass to the callbacks.
2584	* @param pszDesc Pointer to description string. This must not be freed.
2585	* @param phRegion Where to return the MMIO region handle.
2586	*
2587	* @remarks Caller enters the device critical section prior to invoking the
2588	* registered callback methods.
2589	*
2590	* @sa PDMDevHlpMmioSetUpContext, PDMDevHlpMmioMap, PDMDevHlpMmioUnmap.
2591	*/
2592	DECLR3CALLBACKMEMBER(int, pfnMmioCreateEx,(PPDMDEVINS pDevIns, RTGCPHYS cbRegion,
2593	uint32_t fFlags, PPDMPCIDEV pPciDev, uint32_t iPciRegion,
2594	PFNIOMMMIONEWWRITE pfnWrite, PFNIOMMMIONEWREAD pfnRead, PFNIOMMMIONEWFILL pfnFill,
2595	void pvUser, const char pszDesc, PIOMMMIOHANDLE phRegion));
2596
2597	/**
2598	* Maps a memory mapped I/O (MMIO) region (into the guest physical address space).
2599	*
2600	* @returns VBox status.
2601	* @param pDevIns The device instance the region is associated with.
2602	* @param hRegion The MMIO region handle.
2603	* @param GCPhys Where to map the region.
2604	* @note An MMIO range may overlap with base memory if a lot of RAM is
2605	* configured for the VM, in which case we'll drop the base memory
2606	* pages. Presently we will make no attempt to preserve anything that
2607	* happens to be present in the base memory that is replaced, this is
2608	* technically incorrect but it's just not worth the effort to do
2609	* right, at least not at this point.
2610	* @sa PDMDevHlpMmioUnmap, PDMDevHlpMmioCreate, PDMDevHlpMmioCreateEx,
2611	* PDMDevHlpMmioSetUpContext
2612	*/
2613	DECLR3CALLBACKMEMBER(int, pfnMmioMap,(PPDMDEVINS pDevIns, IOMMMIOHANDLE hRegion, RTGCPHYS GCPhys));
2614
2615	/**
2616	* Unmaps a memory mapped I/O (MMIO) region.
2617	*
2618	* @returns VBox status.
2619	* @param pDevIns The device instance the region is associated with.
2620	* @param hRegion The MMIO region handle.
2621	* @sa PDMDevHlpMmioMap, PDMDevHlpMmioCreate, PDMDevHlpMmioCreateEx,
2622	* PDMDevHlpMmioSetUpContext
2623	*/
2624	DECLR3CALLBACKMEMBER(int, pfnMmioUnmap,(PPDMDEVINS pDevIns, IOMMMIOHANDLE hRegion));
2625
2626	/**
2627	* Reduces the length of a MMIO range.
2628	*
2629	* This is for implementations of PDMPCIDEV::pfnRegionLoadChangeHookR3 and will
2630	* only work during saved state restore. It will not call the PCI bus code, as
2631	* that is expected to restore the saved resource configuration.
2632	*
2633	* It just adjusts the mapping length of the region so that when pfnMmioMap is
2634	* called it will only map @a cbRegion bytes and not the value set during
2635	* registration.
2636	*
2637	* @return VBox status code.
2638	* @param pDevIns The device owning the range.
2639	* @param hRegion The MMIO region handle.
2640	* @param cbRegion The new size, must be smaller.
2641	*/
2642	DECLR3CALLBACKMEMBER(int, pfnMmioReduce,(PPDMDEVINS pDevIns, IOMMMIOHANDLE hRegion, RTGCPHYS cbRegion));
2643
2644	/**
2645	* Gets the mapping address of the MMIO region @a hRegion.
2646	*
2647	* @returns Mapping address, NIL_RTGCPHYS if not mapped (or invalid parameters).
2648	* @param pDevIns The device instance to register the ports with.
2649	* @param hRegion The MMIO region handle.
2650	*/
2651	DECLR3CALLBACKMEMBER(RTGCPHYS, pfnMmioGetMappingAddress,(PPDMDEVINS pDevIns, IOMMMIOHANDLE hRegion));
2652	/** @} */
2653
2654	/** @name MMIO2
2655	* @{ */
2656	/**
2657	* Creates a MMIO2 region.
2658	*
2659	* As mentioned elsewhere, MMIO2 is just RAM spelled differently. It's RAM
2660	* associated with a device. It is also non-shared memory with a permanent
2661	* ring-3 mapping and page backing (presently).
2662	*
2663	* @returns VBox status.
2664	* @param pDevIns The device instance.
2665	* @param pPciDev The PCI device the region is associated with, or
2666	* NULL if no PCI device association.
2667	* @param iPciRegion The region number. Use the PCI region number as
2668	* this must be known to the PCI bus device too. If
2669	* it's not associated with the PCI device, then
2670	* any number up to UINT8_MAX is fine.
2671	* @param cbRegion The size (in bytes) of the region.
2672	* @param fFlags PGMPHYS_MMIO2_FLAGS_XXX (see pgm.h).
2673	* @param pszDesc Pointer to description string. This must not be
2674	* freed.
2675	* @param ppvMapping Where to store the address of the ring-3 mapping
2676	* of the memory.
2677	* @param phRegion Where to return the MMIO2 region handle.
2678	*
2679	* @thread EMT(0)
2680	*/
2681	DECLR3CALLBACKMEMBER(int, pfnMmio2Create,(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t iPciRegion, RTGCPHYS cbRegion,
2682	uint32_t fFlags, const char pszDesc, void *ppvMapping, PPGMMMIO2HANDLE phRegion));
2683
2684	/**
2685	* Destroys a MMIO2 region, unmapping it and freeing the memory.
2686	*
2687	* Any physical access handlers registered for the region must be deregistered
2688	* before calling this function.
2689	*
2690	* @returns VBox status code.
2691	* @param pDevIns The device instance.
2692	* @param hRegion The MMIO2 region handle.
2693	* @thread EMT.
2694	*/
2695	DECLR3CALLBACKMEMBER(int, pfnMmio2Destroy,(PPDMDEVINS pDevIns, PGMMMIO2HANDLE hRegion));
2696
2697	/**
2698	* Maps a MMIO2 region (into the guest physical address space).
2699	*
2700	* @returns VBox status.
2701	* @param pDevIns The device instance the region is associated with.
2702	* @param hRegion The MMIO2 region handle.
2703	* @param GCPhys Where to map the region.
2704	* @note A MMIO2 region overlap with base memory if a lot of RAM is
2705	* configured for the VM, in which case we'll drop the base memory
2706	* pages. Presently we will make no attempt to preserve anything that
2707	* happens to be present in the base memory that is replaced, this is
2708	* technically incorrect but it's just not worth the effort to do
2709	* right, at least not at this point.
2710	* @sa PDMDevHlpMmio2Unmap, PDMDevHlpMmio2Create, PDMDevHlpMmio2SetUpContext
2711	*/
2712	DECLR3CALLBACKMEMBER(int, pfnMmio2Map,(PPDMDEVINS pDevIns, PGMMMIO2HANDLE hRegion, RTGCPHYS GCPhys));
2713
2714	/**
2715	* Unmaps a MMIO2 region.
2716	*
2717	* @returns VBox status.
2718	* @param pDevIns The device instance the region is associated with.
2719	* @param hRegion The MMIO2 region handle.
2720	* @sa PDMDevHlpMmio2Map, PDMDevHlpMmio2Create, PDMDevHlpMmio2SetUpContext
2721	*/
2722	DECLR3CALLBACKMEMBER(int, pfnMmio2Unmap,(PPDMDEVINS pDevIns, PGMMMIO2HANDLE hRegion));
2723
2724	/**
2725	* Reduces the length of a MMIO range.
2726	*
2727	* This is for implementations of PDMPCIDEV::pfnRegionLoadChangeHookR3 and will
2728	* only work during saved state restore. It will not call the PCI bus code, as
2729	* that is expected to restore the saved resource configuration.
2730	*
2731	* It just adjusts the mapping length of the region so that when pfnMmioMap is
2732	* called it will only map @a cbRegion bytes and not the value set during
2733	* registration.
2734	*
2735	* @return VBox status code.
2736	* @param pDevIns The device owning the range.
2737	* @param hRegion The MMIO2 region handle.
2738	* @param cbRegion The new size, must be smaller.
2739	*/
2740	DECLR3CALLBACKMEMBER(int, pfnMmio2Reduce,(PPDMDEVINS pDevIns, PGMMMIO2HANDLE hRegion, RTGCPHYS cbRegion));
2741
2742	/**
2743	* Gets the mapping address of the MMIO region @a hRegion.
2744	*
2745	* @returns Mapping address, NIL_RTGCPHYS if not mapped (or invalid parameters).
2746	* @param pDevIns The device instance to register the ports with.
2747	* @param hRegion The MMIO2 region handle.
2748	*/
2749	DECLR3CALLBACKMEMBER(RTGCPHYS, pfnMmio2GetMappingAddress,(PPDMDEVINS pDevIns, PGMMMIO2HANDLE hRegion));
2750
2751	/**
2752	* Queries and resets the dirty bitmap for an MMIO2 region.
2753	*
2754	* The MMIO2 region must have been created with the
2755	* PGMPHYS_MMIO2_FLAGS_TRACK_DIRTY_PAGES flag for this to work.
2756	*
2757	* @returns VBox status code.
2758	* @param pDevIns The device instance.
2759	* @param hRegion The MMIO2 region handle.
2760	* @param pvBitmap Where to return the bitmap. Must be 8-byte aligned.
2761	* Can be NULL if only resetting the tracking is desired.
2762	* @param cbBitmap The bitmap size. One bit per page in the region,
2763	* rounded up to 8-bytes. If pvBitmap is NULL this must
2764	* also be zero.
2765	*/
2766	DECLR3CALLBACKMEMBER(int, pfnMmio2QueryAndResetDirtyBitmap, (PPDMDEVINS pDevIns, PGMMMIO2HANDLE hRegion,
2767	void *pvBitmap, size_t cbBitmap));
2768
2769	/**
2770	* Controls the dirty page tracking for an MMIO2 region.
2771	*
2772	* The MMIO2 region must have been created with the
2773	* PGMPHYS_MMIO2_FLAGS_TRACK_DIRTY_PAGES flag for this to work.
2774	*
2775	* @returns VBox status code.
2776	* @param pDevIns The device instance.
2777	* @param hRegion The MMIO2 region handle.
2778	* @param fEnabled When set to @c true the dirty page tracking will be
2779	* enabled if currently disabled (bitmap is reset). When
2780	* set to @c false the dirty page tracking will be
2781	* disabled.
2782	*/
2783	DECLR3CALLBACKMEMBER(int, pfnMmio2ControlDirtyPageTracking, (PPDMDEVINS pDevIns, PGMMMIO2HANDLE hRegion, bool fEnabled));
2784
2785	/**
2786	* Changes the number of an MMIO2 or pre-registered MMIO region.
2787	*
2788	* This should only be used to deal with saved state problems, so there is no
2789	* convenience inline wrapper for this method.
2790	*
2791	* @returns VBox status code.
2792	* @param pDevIns The device instance.
2793	* @param hRegion The MMIO2 region handle.
2794	* @param iNewRegion The new region index.
2795	*
2796	* @sa @bugref{9359}
2797	*/
2798	DECLR3CALLBACKMEMBER(int, pfnMmio2ChangeRegionNo,(PPDMDEVINS pDevIns, PGMMMIO2HANDLE hRegion, uint32_t iNewRegion));
2799
2800	/**
2801	* Mapping an MMIO2 page in place of an MMIO page for direct access.
2802	*
2803	* This is a special optimization used by the VGA device. Call
2804	* PDMDevHlpMmioResetRegion() to undo the mapping.
2805	*
2806	* @returns VBox status code. This API may return VINF_SUCCESS even if no
2807	* remapping is made.
2808	* @retval VERR_SEM_BUSY in ring-0 if we cannot get the IOM lock.
2809	*
2810	* @param pDevIns The device instance @a hRegion and @a hMmio2 are
2811	* associated with.
2812	* @param hRegion The handle to the MMIO region.
2813	* @param offRegion The offset into @a hRegion of the page to be
2814	* remapped.
2815	* @param hMmio2 The MMIO2 handle.
2816	* @param offMmio2 Offset into @a hMmio2 of the page to be use for the
2817	* mapping.
2818	* @param fPageFlags Page flags to set. Must be (X86_PTE_RW \| X86_PTE_P)
2819	* for the time being.
2820	*/
2821	DECLR3CALLBACKMEMBER(int, pfnMmioMapMmio2Page,(PPDMDEVINS pDevIns, IOMMMIOHANDLE hRegion, RTGCPHYS offRegion,
2822	uint64_t hMmio2, RTGCPHYS offMmio2, uint64_t fPageFlags));
2823
2824	/**
2825	* Reset a previously modified MMIO region; restore the access flags.
2826	*
2827	* This undoes the effects of PDMDevHlpMmioMapMmio2Page() and is currently only
2828	* intended for some ancient VGA hack. However, it would be great to extend it
2829	* beyond VT-x and/or nested-paging.
2830	*
2831	* @returns VBox status code.
2832	*
2833	* @param pDevIns The device instance @a hRegion is associated with.
2834	* @param hRegion The handle to the MMIO region.
2835	*/
2836	DECLR3CALLBACKMEMBER(int, pfnMmioResetRegion, (PPDMDEVINS pDevIns, IOMMMIOHANDLE hRegion));
2837	/** @} */
2838
2839	/**
2840	* Register a ROM (BIOS) region.
2841	*
2842	* It goes without saying that this is read-only memory. The memory region must be
2843	* in unassigned memory. I.e. from the top of the address space or on the PC in
2844	* the 0xa0000-0xfffff range.
2845	*
2846	* @returns VBox status.
2847	* @param pDevIns The device instance owning the ROM region.
2848	* @param GCPhysStart First physical address in the range.
2849	* Must be page aligned!
2850	* @param cbRange The size of the range (in bytes).
2851	* Must be page aligned!
2852	* @param pvBinary Pointer to the binary data backing the ROM image.
2853	* @param cbBinary The size of the binary pointer. This must
2854	* be equal or smaller than @a cbRange.
2855	* @param fFlags PGMPHYS_ROM_FLAGS_XXX (see pgm.h).
2856	* @param pszDesc Pointer to description string. This must not be freed.
2857	*
2858	* @remark There is no way to remove the rom, automatically on device cleanup or
2859	* manually from the device yet. At present I doubt we need such features...
2860	*/
2861	DECLR3CALLBACKMEMBER(int, pfnROMRegister,(PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, uint32_t cbRange,
2862	const void pvBinary, uint32_t cbBinary, uint32_t fFlags, const char pszDesc));
2863
2864	/**
2865	* Changes the protection of shadowed ROM mapping.
2866	*
2867	* This is intented for use by the system BIOS, chipset or device in question to
2868	* change the protection of shadowed ROM code after init and on reset.
2869	*
2870	* @param pDevIns The device instance.
2871	* @param GCPhysStart Where the mapping starts.
2872	* @param cbRange The size of the mapping.
2873	* @param enmProt The new protection type.
2874	*/
2875	DECLR3CALLBACKMEMBER(int, pfnROMProtectShadow,(PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, uint32_t cbRange, PGMROMPROT enmProt));
2876
2877	/**
2878	* Register a save state data unit.
2879	*
2880	* @returns VBox status.
2881	* @param pDevIns The device instance.
2882	* @param uVersion Data layout version number.
2883	* @param cbGuess The approximate amount of data in the unit.
2884	* Only for progress indicators.
2885	* @param pszBefore Name of data unit which we should be put in
2886	* front of. Optional (NULL).
2887	*
2888	* @param pfnLivePrep Prepare live save callback, optional.
2889	* @param pfnLiveExec Execute live save callback, optional.
2890	* @param pfnLiveVote Vote live save callback, optional.
2891	*
2892	* @param pfnSavePrep Prepare save callback, optional.
2893	* @param pfnSaveExec Execute save callback, optional.
2894	* @param pfnSaveDone Done save callback, optional.
2895	*
2896	* @param pfnLoadPrep Prepare load callback, optional.
2897	* @param pfnLoadExec Execute load callback, optional.
2898	* @param pfnLoadDone Done load callback, optional.
2899	* @remarks Caller enters the device critical section prior to invoking the
2900	* registered callback methods.
2901	*/
2902	DECLR3CALLBACKMEMBER(int, pfnSSMRegister,(PPDMDEVINS pDevIns, uint32_t uVersion, size_t cbGuess, const char *pszBefore,
2903	PFNSSMDEVLIVEPREP pfnLivePrep, PFNSSMDEVLIVEEXEC pfnLiveExec, PFNSSMDEVLIVEVOTE pfnLiveVote,
2904	PFNSSMDEVSAVEPREP pfnSavePrep, PFNSSMDEVSAVEEXEC pfnSaveExec, PFNSSMDEVSAVEDONE pfnSaveDone,
2905	PFNSSMDEVLOADPREP pfnLoadPrep, PFNSSMDEVLOADEXEC pfnLoadExec, PFNSSMDEVLOADDONE pfnLoadDone));
2906
2907	/**
2908	* Register a save state data unit for backward compatibility.
2909	*
2910	* This is for migrating from an old device name to a new one or for merging
2911	* devices. It will only help loading old saved states.
2912	*
2913	* @returns VBox status.
2914	* @param pDevIns The device instance.
2915	* @param pszOldName The old unit name.
2916	* @param pfnLoadPrep Prepare load callback, optional.
2917	* @param pfnLoadExec Execute load callback, optional.
2918	* @param pfnLoadDone Done load callback, optional.
2919	* @remarks Caller enters the device critical section prior to invoking the
2920	* registered callback methods.
2921	*/
2922	DECLR3CALLBACKMEMBER(int, pfnSSMRegisterLegacy,(PPDMDEVINS pDevIns, const char *pszOldName, PFNSSMDEVLOADPREP pfnLoadPrep,
2923	PFNSSMDEVLOADEXEC pfnLoadExec, PFNSSMDEVLOADDONE pfnLoadDone));
2924
2925	/** @name Exported SSM Functions
2926	* @{ */
2927	DECLR3CALLBACKMEMBER(int, pfnSSMPutStruct,(PSSMHANDLE pSSM, const void *pvStruct, PCSSMFIELD paFields));
2928	DECLR3CALLBACKMEMBER(int, pfnSSMPutStructEx,(PSSMHANDLE pSSM, const void pvStruct, size_t cbStruct, uint32_t fFlags, PCSSMFIELD paFields, void pvUser));
2929	DECLR3CALLBACKMEMBER(int, pfnSSMPutBool,(PSSMHANDLE pSSM, bool fBool));
2930	DECLR3CALLBACKMEMBER(int, pfnSSMPutU8,(PSSMHANDLE pSSM, uint8_t u8));
2931	DECLR3CALLBACKMEMBER(int, pfnSSMPutS8,(PSSMHANDLE pSSM, int8_t i8));
2932	DECLR3CALLBACKMEMBER(int, pfnSSMPutU16,(PSSMHANDLE pSSM, uint16_t u16));
2933	DECLR3CALLBACKMEMBER(int, pfnSSMPutS16,(PSSMHANDLE pSSM, int16_t i16));
2934	DECLR3CALLBACKMEMBER(int, pfnSSMPutU32,(PSSMHANDLE pSSM, uint32_t u32));
2935	DECLR3CALLBACKMEMBER(int, pfnSSMPutS32,(PSSMHANDLE pSSM, int32_t i32));
2936	DECLR3CALLBACKMEMBER(int, pfnSSMPutU64,(PSSMHANDLE pSSM, uint64_t u64));
2937	DECLR3CALLBACKMEMBER(int, pfnSSMPutS64,(PSSMHANDLE pSSM, int64_t i64));
2938	DECLR3CALLBACKMEMBER(int, pfnSSMPutU128,(PSSMHANDLE pSSM, uint128_t u128));
2939	DECLR3CALLBACKMEMBER(int, pfnSSMPutS128,(PSSMHANDLE pSSM, int128_t i128));
2940	DECLR3CALLBACKMEMBER(int, pfnSSMPutUInt,(PSSMHANDLE pSSM, RTUINT u));
2941	DECLR3CALLBACKMEMBER(int, pfnSSMPutSInt,(PSSMHANDLE pSSM, RTINT i));
2942	DECLR3CALLBACKMEMBER(int, pfnSSMPutGCUInt,(PSSMHANDLE pSSM, RTGCUINT u));
2943	DECLR3CALLBACKMEMBER(int, pfnSSMPutGCUIntReg,(PSSMHANDLE pSSM, RTGCUINTREG u));
2944	DECLR3CALLBACKMEMBER(int, pfnSSMPutGCPhys32,(PSSMHANDLE pSSM, RTGCPHYS32 GCPhys));
2945	DECLR3CALLBACKMEMBER(int, pfnSSMPutGCPhys64,(PSSMHANDLE pSSM, RTGCPHYS64 GCPhys));
2946	DECLR3CALLBACKMEMBER(int, pfnSSMPutGCPhys,(PSSMHANDLE pSSM, RTGCPHYS GCPhys));
2947	DECLR3CALLBACKMEMBER(int, pfnSSMPutGCPtr,(PSSMHANDLE pSSM, RTGCPTR GCPtr));
2948	DECLR3CALLBACKMEMBER(int, pfnSSMPutGCUIntPtr,(PSSMHANDLE pSSM, RTGCUINTPTR GCPtr));
2949	DECLR3CALLBACKMEMBER(int, pfnSSMPutRCPtr,(PSSMHANDLE pSSM, RTRCPTR RCPtr));
2950	DECLR3CALLBACKMEMBER(int, pfnSSMPutIOPort,(PSSMHANDLE pSSM, RTIOPORT IOPort));
2951	DECLR3CALLBACKMEMBER(int, pfnSSMPutSel,(PSSMHANDLE pSSM, RTSEL Sel));
2952	DECLR3CALLBACKMEMBER(int, pfnSSMPutMem,(PSSMHANDLE pSSM, const void *pv, size_t cb));
2953	DECLR3CALLBACKMEMBER(int, pfnSSMPutStrZ,(PSSMHANDLE pSSM, const char *psz));
2954	DECLR3CALLBACKMEMBER(int, pfnSSMGetStruct,(PSSMHANDLE pSSM, void *pvStruct, PCSSMFIELD paFields));
2955	DECLR3CALLBACKMEMBER(int, pfnSSMGetStructEx,(PSSMHANDLE pSSM, void pvStruct, size_t cbStruct, uint32_t fFlags, PCSSMFIELD paFields, void pvUser));
2956	DECLR3CALLBACKMEMBER(int, pfnSSMGetBool,(PSSMHANDLE pSSM, bool *pfBool));
2957	DECLR3CALLBACKMEMBER(int, pfnSSMGetBoolV,(PSSMHANDLE pSSM, bool volatile *pfBool));
2958	DECLR3CALLBACKMEMBER(int, pfnSSMGetU8,(PSSMHANDLE pSSM, uint8_t *pu8));
2959	DECLR3CALLBACKMEMBER(int, pfnSSMGetU8V,(PSSMHANDLE pSSM, uint8_t volatile *pu8));
2960	DECLR3CALLBACKMEMBER(int, pfnSSMGetS8,(PSSMHANDLE pSSM, int8_t *pi8));
2961	DECLR3CALLBACKMEMBER(int, pfnSSMGetS8V,(PSSMHANDLE pSSM, int8_t volatile *pi8));
2962	DECLR3CALLBACKMEMBER(int, pfnSSMGetU16,(PSSMHANDLE pSSM, uint16_t *pu16));
2963	DECLR3CALLBACKMEMBER(int, pfnSSMGetU16V,(PSSMHANDLE pSSM, uint16_t volatile *pu16));
2964	DECLR3CALLBACKMEMBER(int, pfnSSMGetS16,(PSSMHANDLE pSSM, int16_t *pi16));
2965	DECLR3CALLBACKMEMBER(int, pfnSSMGetS16V,(PSSMHANDLE pSSM, int16_t volatile *pi16));
2966	DECLR3CALLBACKMEMBER(int, pfnSSMGetU32,(PSSMHANDLE pSSM, uint32_t *pu32));
2967	DECLR3CALLBACKMEMBER(int, pfnSSMGetU32V,(PSSMHANDLE pSSM, uint32_t volatile *pu32));
2968	DECLR3CALLBACKMEMBER(int, pfnSSMGetS32,(PSSMHANDLE pSSM, int32_t *pi32));
2969	DECLR3CALLBACKMEMBER(int, pfnSSMGetS32V,(PSSMHANDLE pSSM, int32_t volatile *pi32));
2970	DECLR3CALLBACKMEMBER(int, pfnSSMGetU64,(PSSMHANDLE pSSM, uint64_t *pu64));
2971	DECLR3CALLBACKMEMBER(int, pfnSSMGetU64V,(PSSMHANDLE pSSM, uint64_t volatile *pu64));
2972	DECLR3CALLBACKMEMBER(int, pfnSSMGetS64,(PSSMHANDLE pSSM, int64_t *pi64));
2973	DECLR3CALLBACKMEMBER(int, pfnSSMGetS64V,(PSSMHANDLE pSSM, int64_t volatile *pi64));
2974	DECLR3CALLBACKMEMBER(int, pfnSSMGetU128,(PSSMHANDLE pSSM, uint128_t *pu128));
2975	DECLR3CALLBACKMEMBER(int, pfnSSMGetU128V,(PSSMHANDLE pSSM, uint128_t volatile *pu128));
2976	DECLR3CALLBACKMEMBER(int, pfnSSMGetS128,(PSSMHANDLE pSSM, int128_t *pi128));
2977	DECLR3CALLBACKMEMBER(int, pfnSSMGetS128V,(PSSMHANDLE pSSM, int128_t volatile *pi128));
2978	DECLR3CALLBACKMEMBER(int, pfnSSMGetGCPhys32,(PSSMHANDLE pSSM, PRTGCPHYS32 pGCPhys));
2979	DECLR3CALLBACKMEMBER(int, pfnSSMGetGCPhys32V,(PSSMHANDLE pSSM, RTGCPHYS32 volatile *pGCPhys));
2980	DECLR3CALLBACKMEMBER(int, pfnSSMGetGCPhys64,(PSSMHANDLE pSSM, PRTGCPHYS64 pGCPhys));
2981	DECLR3CALLBACKMEMBER(int, pfnSSMGetGCPhys64V,(PSSMHANDLE pSSM, RTGCPHYS64 volatile *pGCPhys));
2982	DECLR3CALLBACKMEMBER(int, pfnSSMGetGCPhys,(PSSMHANDLE pSSM, PRTGCPHYS pGCPhys));
2983	DECLR3CALLBACKMEMBER(int, pfnSSMGetGCPhysV,(PSSMHANDLE pSSM, RTGCPHYS volatile *pGCPhys));
2984	DECLR3CALLBACKMEMBER(int, pfnSSMGetUInt,(PSSMHANDLE pSSM, PRTUINT pu));
2985	DECLR3CALLBACKMEMBER(int, pfnSSMGetSInt,(PSSMHANDLE pSSM, PRTINT pi));
2986	DECLR3CALLBACKMEMBER(int, pfnSSMGetGCUInt,(PSSMHANDLE pSSM, PRTGCUINT pu));
2987	DECLR3CALLBACKMEMBER(int, pfnSSMGetGCUIntReg,(PSSMHANDLE pSSM, PRTGCUINTREG pu));
2988	DECLR3CALLBACKMEMBER(int, pfnSSMGetGCPtr,(PSSMHANDLE pSSM, PRTGCPTR pGCPtr));
2989	DECLR3CALLBACKMEMBER(int, pfnSSMGetGCUIntPtr,(PSSMHANDLE pSSM, PRTGCUINTPTR pGCPtr));
2990	DECLR3CALLBACKMEMBER(int, pfnSSMGetRCPtr,(PSSMHANDLE pSSM, PRTRCPTR pRCPtr));
2991	DECLR3CALLBACKMEMBER(int, pfnSSMGetIOPort,(PSSMHANDLE pSSM, PRTIOPORT pIOPort));
2992	DECLR3CALLBACKMEMBER(int, pfnSSMGetSel,(PSSMHANDLE pSSM, PRTSEL pSel));
2993	DECLR3CALLBACKMEMBER(int, pfnSSMGetMem,(PSSMHANDLE pSSM, void *pv, size_t cb));
2994	DECLR3CALLBACKMEMBER(int, pfnSSMGetStrZ,(PSSMHANDLE pSSM, char *psz, size_t cbMax));
2995	DECLR3CALLBACKMEMBER(int, pfnSSMGetStrZEx,(PSSMHANDLE pSSM, char psz, size_t cbMax, size_t pcbStr));
2996	DECLR3CALLBACKMEMBER(int, pfnSSMSkip,(PSSMHANDLE pSSM, size_t cb));
2997	DECLR3CALLBACKMEMBER(int, pfnSSMSkipToEndOfUnit,(PSSMHANDLE pSSM));
2998	DECLR3CALLBACKMEMBER(int, pfnSSMSetLoadError,(PSSMHANDLE pSSM, int rc, RT_SRC_POS_DECL, const char *pszFormat, ...) RT_IPRT_FORMAT_ATTR(6, 7));
2999	DECLR3CALLBACKMEMBER(int, pfnSSMSetLoadErrorV,(PSSMHANDLE pSSM, int rc, RT_SRC_POS_DECL, const char *pszFormat, va_list va) RT_IPRT_FORMAT_ATTR(6, 0));
3000	DECLR3CALLBACKMEMBER(int, pfnSSMSetCfgError,(PSSMHANDLE pSSM, RT_SRC_POS_DECL, const char *pszFormat, ...) RT_IPRT_FORMAT_ATTR(5, 6));
3001	DECLR3CALLBACKMEMBER(int, pfnSSMSetCfgErrorV,(PSSMHANDLE pSSM, RT_SRC_POS_DECL, const char *pszFormat, va_list va) RT_IPRT_FORMAT_ATTR(5, 0));
3002	DECLR3CALLBACKMEMBER(int, pfnSSMHandleGetStatus,(PSSMHANDLE pSSM));
3003	DECLR3CALLBACKMEMBER(SSMAFTER, pfnSSMHandleGetAfter,(PSSMHANDLE pSSM));
3004	DECLR3CALLBACKMEMBER(bool, pfnSSMHandleIsLiveSave,(PSSMHANDLE pSSM));
3005	DECLR3CALLBACKMEMBER(uint32_t, pfnSSMHandleMaxDowntime,(PSSMHANDLE pSSM));
3006	DECLR3CALLBACKMEMBER(uint32_t, pfnSSMHandleHostBits,(PSSMHANDLE pSSM));
3007	DECLR3CALLBACKMEMBER(uint32_t, pfnSSMHandleRevision,(PSSMHANDLE pSSM));
3008	DECLR3CALLBACKMEMBER(uint32_t, pfnSSMHandleVersion,(PSSMHANDLE pSSM));
3009	DECLR3CALLBACKMEMBER(const char *, pfnSSMHandleHostOSAndArch,(PSSMHANDLE pSSM));
3010	/** @} */
3011
3012	/**
3013	* Creates a timer w/ a cross context handle.
3014	*
3015	* @returns VBox status.
3016	* @param pDevIns The device instance.
3017	* @param enmClock The clock to use on this timer.
3018	* @param pfnCallback Callback function.
3019	* @param pvUser User argument for the callback.
3020	* @param fFlags Flags, see TMTIMER_FLAGS_*.
3021	* @param pszDesc Pointer to description string which must stay around
3022	* until the timer is fully destroyed (i.e. a bit after TMTimerDestroy()).
3023	* @param phTimer Where to store the timer handle on success.
3024	* @remarks Caller enters the device critical section prior to invoking the
3025	* callback.
3026	*/
3027	DECLR3CALLBACKMEMBER(int, pfnTimerCreate,(PPDMDEVINS pDevIns, TMCLOCK enmClock, PFNTMTIMERDEV pfnCallback,
3028	void pvUser, uint32_t fFlags, const char pszDesc, PTMTIMERHANDLE phTimer));
3029
3030	/** @name Timer handle method wrappers
3031	* @{ */
3032	DECLR3CALLBACKMEMBER(uint64_t, pfnTimerFromMicro,(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cMicroSecs));
3033	DECLR3CALLBACKMEMBER(uint64_t, pfnTimerFromMilli,(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cMilliSecs));
3034	DECLR3CALLBACKMEMBER(uint64_t, pfnTimerFromNano,(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cNanoSecs));
3035	DECLR3CALLBACKMEMBER(uint64_t, pfnTimerGet,(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer));
3036	DECLR3CALLBACKMEMBER(uint64_t, pfnTimerGetFreq,(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer));
3037	DECLR3CALLBACKMEMBER(uint64_t, pfnTimerGetNano,(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer));
3038	DECLR3CALLBACKMEMBER(bool, pfnTimerIsActive,(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer));
3039	DECLR3CALLBACKMEMBER(bool, pfnTimerIsLockOwner,(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer));
3040	DECLR3CALLBACKMEMBER(VBOXSTRICTRC, pfnTimerLockClock,(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, int rcBusy));
3041	/** Takes the clock lock then enters the specified critical section. */
3042	DECLR3CALLBACKMEMBER(VBOXSTRICTRC, pfnTimerLockClock2,(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, PPDMCRITSECT pCritSect, int rcBusy));
3043	DECLR3CALLBACKMEMBER(int, pfnTimerSet,(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t uExpire));
3044	DECLR3CALLBACKMEMBER(int, pfnTimerSetFrequencyHint,(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint32_t uHz));
3045	DECLR3CALLBACKMEMBER(int, pfnTimerSetMicro,(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cMicrosToNext));
3046	DECLR3CALLBACKMEMBER(int, pfnTimerSetMillies,(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cMilliesToNext));
3047	DECLR3CALLBACKMEMBER(int, pfnTimerSetNano,(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cNanosToNext));
3048	DECLR3CALLBACKMEMBER(int, pfnTimerSetRelative,(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cTicksToNext, uint64_t *pu64Now));
3049	DECLR3CALLBACKMEMBER(int, pfnTimerStop,(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer));
3050	DECLR3CALLBACKMEMBER(void, pfnTimerUnlockClock,(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer));
3051	DECLR3CALLBACKMEMBER(void, pfnTimerUnlockClock2,(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, PPDMCRITSECT pCritSect));
3052	DECLR3CALLBACKMEMBER(int, pfnTimerSetCritSect,(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, PPDMCRITSECT pCritSect));
3053	DECLR3CALLBACKMEMBER(int, pfnTimerSave,(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, PSSMHANDLE pSSM));
3054	DECLR3CALLBACKMEMBER(int, pfnTimerLoad,(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, PSSMHANDLE pSSM));
3055	DECLR3CALLBACKMEMBER(int, pfnTimerDestroy,(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer));
3056	/** @sa TMR3TimerSkip */
3057	DECLR3CALLBACKMEMBER(int, pfnTimerSkipLoad,(PSSMHANDLE pSSM, bool *pfActive));
3058	/** @} */
3059
3060	/**
3061	* Get the real world UTC time adjusted for VM lag, user offset and warpdrive.
3062	*
3063	* @returns pTime.
3064	* @param pDevIns The device instance.
3065	* @param pTime Where to store the time.
3066	*/
3067	DECLR3CALLBACKMEMBER(PRTTIMESPEC, pfnTMUtcNow,(PPDMDEVINS pDevIns, PRTTIMESPEC pTime));
3068
3069	/** @name Exported CFGM Functions.
3070	* @{ */
3071	DECLR3CALLBACKMEMBER(bool, pfnCFGMExists,( PCFGMNODE pNode, const char *pszName));
3072	DECLR3CALLBACKMEMBER(int, pfnCFGMQueryType,( PCFGMNODE pNode, const char *pszName, PCFGMVALUETYPE penmType));
3073	DECLR3CALLBACKMEMBER(int, pfnCFGMQuerySize,( PCFGMNODE pNode, const char pszName, size_t pcb));
3074	DECLR3CALLBACKMEMBER(int, pfnCFGMQueryInteger,( PCFGMNODE pNode, const char pszName, uint64_t pu64));
3075	DECLR3CALLBACKMEMBER(int, pfnCFGMQueryIntegerDef,( PCFGMNODE pNode, const char pszName, uint64_t pu64, uint64_t u64Def));
3076	DECLR3CALLBACKMEMBER(int, pfnCFGMQueryString,( PCFGMNODE pNode, const char pszName, char pszString, size_t cchString));
3077	DECLR3CALLBACKMEMBER(int, pfnCFGMQueryStringDef,( PCFGMNODE pNode, const char pszName, char pszString, size_t cchString, const char *pszDef));
3078	DECLR3CALLBACKMEMBER(int, pfnCFGMQueryPassword,( PCFGMNODE pNode, const char pszName, char pszString, size_t cchString));
3079	DECLR3CALLBACKMEMBER(int, pfnCFGMQueryPasswordDef,( PCFGMNODE pNode, const char pszName, char pszString, size_t cchString, const char *pszDef));
3080	DECLR3CALLBACKMEMBER(int, pfnCFGMQueryBytes,( PCFGMNODE pNode, const char pszName, void pvData, size_t cbData));
3081	DECLR3CALLBACKMEMBER(int, pfnCFGMQueryU64,( PCFGMNODE pNode, const char pszName, uint64_t pu64));
3082	DECLR3CALLBACKMEMBER(int, pfnCFGMQueryU64Def,( PCFGMNODE pNode, const char pszName, uint64_t pu64, uint64_t u64Def));
3083	DECLR3CALLBACKMEMBER(int, pfnCFGMQueryS64,( PCFGMNODE pNode, const char pszName, int64_t pi64));
3084	DECLR3CALLBACKMEMBER(int, pfnCFGMQueryS64Def,( PCFGMNODE pNode, const char pszName, int64_t pi64, int64_t i64Def));
3085	DECLR3CALLBACKMEMBER(int, pfnCFGMQueryU32,( PCFGMNODE pNode, const char pszName, uint32_t pu32));
3086	DECLR3CALLBACKMEMBER(int, pfnCFGMQueryU32Def,( PCFGMNODE pNode, const char pszName, uint32_t pu32, uint32_t u32Def));
3087	DECLR3CALLBACKMEMBER(int, pfnCFGMQueryS32,( PCFGMNODE pNode, const char pszName, int32_t pi32));
3088	DECLR3CALLBACKMEMBER(int, pfnCFGMQueryS32Def,( PCFGMNODE pNode, const char pszName, int32_t pi32, int32_t i32Def));
3089	DECLR3CALLBACKMEMBER(int, pfnCFGMQueryU16,( PCFGMNODE pNode, const char pszName, uint16_t pu16));
3090	DECLR3CALLBACKMEMBER(int, pfnCFGMQueryU16Def,( PCFGMNODE pNode, const char pszName, uint16_t pu16, uint16_t u16Def));
3091	DECLR3CALLBACKMEMBER(int, pfnCFGMQueryS16,( PCFGMNODE pNode, const char pszName, int16_t pi16));
3092	DECLR3CALLBACKMEMBER(int, pfnCFGMQueryS16Def,( PCFGMNODE pNode, const char pszName, int16_t pi16, int16_t i16Def));
3093	DECLR3CALLBACKMEMBER(int, pfnCFGMQueryU8,( PCFGMNODE pNode, const char pszName, uint8_t pu8));
3094	DECLR3CALLBACKMEMBER(int, pfnCFGMQueryU8Def,( PCFGMNODE pNode, const char pszName, uint8_t pu8, uint8_t u8Def));
3095	DECLR3CALLBACKMEMBER(int, pfnCFGMQueryS8,( PCFGMNODE pNode, const char pszName, int8_t pi8));
3096	DECLR3CALLBACKMEMBER(int, pfnCFGMQueryS8Def,( PCFGMNODE pNode, const char pszName, int8_t pi8, int8_t i8Def));
3097	DECLR3CALLBACKMEMBER(int, pfnCFGMQueryBool,( PCFGMNODE pNode, const char pszName, bool pf));
3098	DECLR3CALLBACKMEMBER(int, pfnCFGMQueryBoolDef,( PCFGMNODE pNode, const char pszName, bool pf, bool fDef));
3099	DECLR3CALLBACKMEMBER(int, pfnCFGMQueryPort,( PCFGMNODE pNode, const char *pszName, PRTIOPORT pPort));
3100	DECLR3CALLBACKMEMBER(int, pfnCFGMQueryPortDef,( PCFGMNODE pNode, const char *pszName, PRTIOPORT pPort, RTIOPORT PortDef));
3101	DECLR3CALLBACKMEMBER(int, pfnCFGMQueryUInt,( PCFGMNODE pNode, const char pszName, unsigned int pu));
3102	DECLR3CALLBACKMEMBER(int, pfnCFGMQueryUIntDef,( PCFGMNODE pNode, const char pszName, unsigned int pu, unsigned int uDef));
3103	DECLR3CALLBACKMEMBER(int, pfnCFGMQuerySInt,( PCFGMNODE pNode, const char pszName, signed int pi));
3104	DECLR3CALLBACKMEMBER(int, pfnCFGMQuerySIntDef,( PCFGMNODE pNode, const char pszName, signed int pi, signed int iDef));
3105	DECLR3CALLBACKMEMBER(int, pfnCFGMQueryGCPtr,( PCFGMNODE pNode, const char *pszName, PRTGCPTR pGCPtr));
3106	DECLR3CALLBACKMEMBER(int, pfnCFGMQueryGCPtrDef,( PCFGMNODE pNode, const char *pszName, PRTGCPTR pGCPtr, RTGCPTR GCPtrDef));
3107	DECLR3CALLBACKMEMBER(int, pfnCFGMQueryGCPtrU,( PCFGMNODE pNode, const char *pszName, PRTGCUINTPTR pGCPtr));
3108	DECLR3CALLBACKMEMBER(int, pfnCFGMQueryGCPtrUDef,( PCFGMNODE pNode, const char *pszName, PRTGCUINTPTR pGCPtr, RTGCUINTPTR GCPtrDef));
3109	DECLR3CALLBACKMEMBER(int, pfnCFGMQueryGCPtrS,( PCFGMNODE pNode, const char *pszName, PRTGCINTPTR pGCPtr));
3110	DECLR3CALLBACKMEMBER(int, pfnCFGMQueryGCPtrSDef,( PCFGMNODE pNode, const char *pszName, PRTGCINTPTR pGCPtr, RTGCINTPTR GCPtrDef));
3111	DECLR3CALLBACKMEMBER(int, pfnCFGMQueryStringAlloc,( PCFGMNODE pNode, const char pszName, char *ppszString));
3112	DECLR3CALLBACKMEMBER(int, pfnCFGMQueryStringAllocDef,(PCFGMNODE pNode, const char pszName, char ppszString, const char pszDef));
3113	DECLR3CALLBACKMEMBER(PCFGMNODE, pfnCFGMGetParent,(PCFGMNODE pNode));
3114	DECLR3CALLBACKMEMBER(PCFGMNODE, pfnCFGMGetChild,(PCFGMNODE pNode, const char *pszPath));
3115	DECLR3CALLBACKMEMBER(PCFGMNODE, pfnCFGMGetChildF,(PCFGMNODE pNode, const char *pszPathFormat, ...) RT_IPRT_FORMAT_ATTR(2, 3));
3116	DECLR3CALLBACKMEMBER(PCFGMNODE, pfnCFGMGetChildFV,(PCFGMNODE pNode, const char *pszPathFormat, va_list Args) RT_IPRT_FORMAT_ATTR(3, 0));
3117	DECLR3CALLBACKMEMBER(PCFGMNODE, pfnCFGMGetFirstChild,(PCFGMNODE pNode));
3118	DECLR3CALLBACKMEMBER(PCFGMNODE, pfnCFGMGetNextChild,(PCFGMNODE pCur));
3119	DECLR3CALLBACKMEMBER(int, pfnCFGMGetName,(PCFGMNODE pCur, char *pszName, size_t cchName));
3120	DECLR3CALLBACKMEMBER(size_t, pfnCFGMGetNameLen,(PCFGMNODE pCur));
3121	DECLR3CALLBACKMEMBER(bool, pfnCFGMAreChildrenValid,(PCFGMNODE pNode, const char *pszzValid));
3122	DECLR3CALLBACKMEMBER(PCFGMLEAF, pfnCFGMGetFirstValue,(PCFGMNODE pCur));
3123	DECLR3CALLBACKMEMBER(PCFGMLEAF, pfnCFGMGetNextValue,(PCFGMLEAF pCur));
3124	DECLR3CALLBACKMEMBER(int, pfnCFGMGetValueName,(PCFGMLEAF pCur, char *pszName, size_t cchName));
3125	DECLR3CALLBACKMEMBER(size_t, pfnCFGMGetValueNameLen,(PCFGMLEAF pCur));
3126	DECLR3CALLBACKMEMBER(CFGMVALUETYPE, pfnCFGMGetValueType,(PCFGMLEAF pCur));
3127	DECLR3CALLBACKMEMBER(bool, pfnCFGMAreValuesValid,(PCFGMNODE pNode, const char *pszzValid));
3128	DECLR3CALLBACKMEMBER(int, pfnCFGMValidateConfig,(PCFGMNODE pNode, const char *pszNode,
3129	const char pszValidValues, const char pszValidNodes,
3130	const char *pszWho, uint32_t uInstance));
3131	/** @} */
3132
3133	/**
3134	* Read physical memory.
3135	*
3136	* @returns VINF_SUCCESS (for now).
3137	* @param pDevIns The device instance.
3138	* @param GCPhys Physical address start reading from.
3139	* @param pvBuf Where to put the read bits.
3140	* @param cbRead How many bytes to read.
3141	* @param fFlags Combination of PDM_DEVHLP_PHYS_RW_F_XXX.
3142	* @thread Any thread, but the call may involve the emulation thread.
3143	*/
3144	DECLR3CALLBACKMEMBER(int, pfnPhysRead,(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, void *pvBuf, size_t cbRead, uint32_t fFlags));
3145
3146	/**
3147	* Write to physical memory.
3148	*
3149	* @returns VINF_SUCCESS for now, and later maybe VERR_EM_MEMORY.
3150	* @param pDevIns The device instance.
3151	* @param GCPhys Physical address to write to.
3152	* @param pvBuf What to write.
3153	* @param cbWrite How many bytes to write.
3154	* @param fFlags Combination of PDM_DEVHLP_PHYS_RW_F_XXX.
3155	* @thread Any thread, but the call may involve the emulation thread.
3156	*/
3157	DECLR3CALLBACKMEMBER(int, pfnPhysWrite,(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, const void *pvBuf, size_t cbWrite, uint32_t fFlags));
3158
3159	/**
3160	* Requests the mapping of a guest page into ring-3.
3161	*
3162	* When you're done with the page, call pfnPhysReleasePageMappingLock() ASAP to
3163	* release it.
3164	*
3165	* This API will assume your intention is to write to the page, and will
3166	* therefore replace shared and zero pages. If you do not intend to modify the
3167	* page, use the pfnPhysGCPhys2CCPtrReadOnly() API.
3168	*
3169	* @returns VBox status code.
3170	* @retval VINF_SUCCESS on success.
3171	* @retval VERR_PGM_PHYS_PAGE_RESERVED it it's a valid page but has no physical
3172	* backing or if the page has any active access handlers. The caller
3173	* must fall back on using PGMR3PhysWriteExternal.
3174	* @retval VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS if it's not a valid physical address.
3175	*
3176	* @param pDevIns The device instance.
3177	* @param GCPhys The guest physical address of the page that
3178	* should be mapped.
3179	* @param fFlags Flags reserved for future use, MBZ.
3180	* @param ppv Where to store the address corresponding to
3181	* GCPhys.
3182	* @param pLock Where to store the lock information that
3183	* pfnPhysReleasePageMappingLock needs.
3184	*
3185	* @remark Avoid calling this API from within critical sections (other than the
3186	* PGM one) because of the deadlock risk when we have to delegating the
3187	* task to an EMT.
3188	* @thread Any.
3189	*/
3190	DECLR3CALLBACKMEMBER(int, pfnPhysGCPhys2CCPtr,(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, uint32_t fFlags, void **ppv,
3191	PPGMPAGEMAPLOCK pLock));
3192
3193	/**
3194	* Requests the mapping of a guest page into ring-3, external threads.
3195	*
3196	* When you're done with the page, call pfnPhysReleasePageMappingLock() ASAP to
3197	* release it.
3198	*
3199	* @returns VBox status code.
3200	* @retval VINF_SUCCESS on success.
3201	* @retval VERR_PGM_PHYS_PAGE_RESERVED it it's a valid page but has no physical
3202	* backing or if the page as an active ALL access handler. The caller
3203	* must fall back on using PGMPhysRead.
3204	* @retval VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS if it's not a valid physical address.
3205	*
3206	* @param pDevIns The device instance.
3207	* @param GCPhys The guest physical address of the page that
3208	* should be mapped.
3209	* @param fFlags Flags reserved for future use, MBZ.
3210	* @param ppv Where to store the address corresponding to
3211	* GCPhys.
3212	* @param pLock Where to store the lock information that
3213	* pfnPhysReleasePageMappingLock needs.
3214	*
3215	* @remark Avoid calling this API from within critical sections.
3216	* @thread Any.
3217	*/
3218	DECLR3CALLBACKMEMBER(int, pfnPhysGCPhys2CCPtrReadOnly,(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, uint32_t fFlags,
3219	void const **ppv, PPGMPAGEMAPLOCK pLock));
3220
3221	/**
3222	* Release the mapping of a guest page.
3223	*
3224	* This is the counter part of pfnPhysGCPhys2CCPtr and
3225	* pfnPhysGCPhys2CCPtrReadOnly.
3226	*
3227	* @param pDevIns The device instance.
3228	* @param pLock The lock structure initialized by the mapping
3229	* function.
3230	*/
3231	DECLR3CALLBACKMEMBER(void, pfnPhysReleasePageMappingLock,(PPDMDEVINS pDevIns, PPGMPAGEMAPLOCK pLock));
3232
3233	/**
3234	* Read guest physical memory by virtual address.
3235	*
3236	* @param pDevIns The device instance.
3237	* @param pvDst Where to put the read bits.
3238	* @param GCVirtSrc Guest virtual address to start reading from.
3239	* @param cb How many bytes to read.
3240	* @thread The emulation thread.
3241	*/
3242	DECLR3CALLBACKMEMBER(int, pfnPhysReadGCVirt,(PPDMDEVINS pDevIns, void *pvDst, RTGCPTR GCVirtSrc, size_t cb));
3243
3244	/**
3245	* Write to guest physical memory by virtual address.
3246	*
3247	* @param pDevIns The device instance.
3248	* @param GCVirtDst Guest virtual address to write to.
3249	* @param pvSrc What to write.
3250	* @param cb How many bytes to write.
3251	* @thread The emulation thread.
3252	*/
3253	DECLR3CALLBACKMEMBER(int, pfnPhysWriteGCVirt,(PPDMDEVINS pDevIns, RTGCPTR GCVirtDst, const void *pvSrc, size_t cb));
3254
3255	/**
3256	* Convert a guest virtual address to a guest physical address.
3257	*
3258	* @returns VBox status code.
3259	* @param pDevIns The device instance.
3260	* @param GCPtr Guest virtual address.
3261	* @param pGCPhys Where to store the GC physical address
3262	* corresponding to GCPtr.
3263	* @thread The emulation thread.
3264	* @remark Careful with page boundaries.
3265	*/
3266	DECLR3CALLBACKMEMBER(int, pfnPhysGCPtr2GCPhys, (PPDMDEVINS pDevIns, RTGCPTR GCPtr, PRTGCPHYS pGCPhys));
3267
3268	/**
3269	* Checks if a GC physical address is a normal page,
3270	* i.e. not ROM, MMIO or reserved.
3271	*
3272	* @returns true if normal.
3273	* @returns false if invalid, ROM, MMIO or reserved page.
3274	* @param pDevIns The device instance.
3275	* @param GCPhys The physical address to check.
3276	*/
3277	DECLR3CALLBACKMEMBER(bool, pfnPhysIsGCPhysNormal,(PPDMDEVINS pDevIns, RTGCPHYS GCPhys));
3278
3279	/**
3280	* Inflate or deflate a memory balloon
3281	*
3282	* @returns VBox status code.
3283	* @param pDevIns The device instance.
3284	* @param fInflate Inflate or deflate memory balloon
3285	* @param cPages Number of pages to free
3286	* @param paPhysPage Array of guest physical addresses
3287	*/
3288	DECLR3CALLBACKMEMBER(int, pfnPhysChangeMemBalloon,(PPDMDEVINS pDevIns, bool fInflate, unsigned cPages, RTGCPHYS *paPhysPage));
3289
3290	/**
3291	* Allocate memory which is associated with current VM instance
3292	* and automatically freed on it's destruction.
3293	*
3294	* @returns Pointer to allocated memory. The memory is NOT zero-ed.
3295	* @param pDevIns The device instance.
3296	* @param cb Number of bytes to allocate.
3297	*/
3298	DECLR3CALLBACKMEMBER(void *, pfnMMHeapAlloc,(PPDMDEVINS pDevIns, size_t cb));
3299
3300	/**
3301	* Allocate memory which is associated with current VM instance
3302	* and automatically freed on it's destruction. The memory is ZEROed.
3303	*
3304	* @returns Pointer to allocated memory. The memory is NOT zero-ed.
3305	* @param pDevIns The device instance.
3306	* @param cb Number of bytes to allocate.
3307	*/
3308	DECLR3CALLBACKMEMBER(void *, pfnMMHeapAllocZ,(PPDMDEVINS pDevIns, size_t cb));
3309
3310	/**
3311	* Allocating string printf.
3312	*
3313	* @returns Pointer to the string.
3314	* @param pDevIns The device instance.
3315	* @param enmTag The statistics tag.
3316	* @param pszFormat The format string.
3317	* @param va Format arguments.
3318	*/
3319	DECLR3CALLBACKMEMBER(char , pfnMMHeapAPrintfV,(PPDMDEVINS pDevIns, MMTAG enmTag, const char pszFormat, va_list va));
3320
3321	/**
3322	* Free memory allocated with pfnMMHeapAlloc() and pfnMMHeapAllocZ().
3323	*
3324	* @param pDevIns The device instance.
3325	* @param pv Pointer to the memory to free.
3326	*/
3327	DECLR3CALLBACKMEMBER(void, pfnMMHeapFree,(PPDMDEVINS pDevIns, void *pv));
3328
3329	/**
3330	* Returns the physical RAM size of the VM.
3331	*
3332	* @returns RAM size in bytes.
3333	* @param pDevIns The device instance.
3334	*/
3335	DECLR3CALLBACKMEMBER(uint64_t, pfnMMPhysGetRamSize,(PPDMDEVINS pDevIns));
3336
3337	/**
3338	* Returns the physical RAM size of the VM below the 4GB boundary.
3339	*
3340	* @returns RAM size in bytes.
3341	* @param pDevIns The device instance.
3342	*/
3343	DECLR3CALLBACKMEMBER(uint32_t, pfnMMPhysGetRamSizeBelow4GB,(PPDMDEVINS pDevIns));
3344
3345	/**
3346	* Returns the physical RAM size of the VM above the 4GB boundary.
3347	*
3348	* @returns RAM size in bytes.
3349	* @param pDevIns The device instance.
3350	*/
3351	DECLR3CALLBACKMEMBER(uint64_t, pfnMMPhysGetRamSizeAbove4GB,(PPDMDEVINS pDevIns));
3352
3353	/**
3354	* Gets the VM state.
3355	*
3356	* @returns VM state.
3357	* @param pDevIns The device instance.
3358	* @thread Any thread (just keep in mind that it's volatile info).
3359	*/
3360	DECLR3CALLBACKMEMBER(VMSTATE, pfnVMState, (PPDMDEVINS pDevIns));
3361
3362	/**
3363	* Checks if the VM was teleported and hasn't been fully resumed yet.
3364	*
3365	* @returns true / false.
3366	* @param pDevIns The device instance.
3367	* @thread Any thread.
3368	*/
3369	DECLR3CALLBACKMEMBER(bool, pfnVMTeleportedAndNotFullyResumedYet,(PPDMDEVINS pDevIns));
3370
3371	/**
3372	* Set the VM error message
3373	*
3374	* @returns rc.
3375	* @param pDevIns The device instance.
3376	* @param rc VBox status code.
3377	* @param SRC_POS Use RT_SRC_POS.
3378	* @param pszFormat Error message format string.
3379	* @param va Error message arguments.
3380	*/
3381	DECLR3CALLBACKMEMBER(int, pfnVMSetErrorV,(PPDMDEVINS pDevIns, int rc, RT_SRC_POS_DECL,
3382	const char *pszFormat, va_list va) RT_IPRT_FORMAT_ATTR(6, 0));
3383
3384	/**
3385	* Set the VM runtime error message
3386	*
3387	* @returns VBox status code.
3388	* @param pDevIns The device instance.
3389	* @param fFlags The action flags. See VMSETRTERR_FLAGS_*.
3390	* @param pszErrorId Error ID string.
3391	* @param pszFormat Error message format string.
3392	* @param va Error message arguments.
3393	*/
3394	DECLR3CALLBACKMEMBER(int, pfnVMSetRuntimeErrorV,(PPDMDEVINS pDevIns, uint32_t fFlags, const char *pszErrorId,
3395	const char *pszFormat, va_list va) RT_IPRT_FORMAT_ATTR(4, 0));
3396
3397	/**
3398	* Special interface for implementing a HLT-like port on a device.
3399	*
3400	* This can be called directly from device code, provide the device is trusted
3401	* to access the VMM directly. Since we may not have an accurate register set
3402	* and the caller certainly shouldn't (device code does not access CPU
3403	* registers), this function will return when interrupts are pending regardless
3404	* of the actual EFLAGS.IF state.
3405	*
3406	* @returns VBox error status (never informational statuses).
3407	* @param pDevIns The device instance.
3408	* @param idCpu The id of the calling EMT.
3409	*/
3410	DECLR3CALLBACKMEMBER(int, pfnVMWaitForDeviceReady,(PPDMDEVINS pDevIns, VMCPUID idCpu));
3411
3412	/**
3413	* Wakes up a CPU that has called PDMDEVHLPR3::pfnVMWaitForDeviceReady.
3414	*
3415	* @returns VBox error status (never informational statuses).
3416	* @param pDevIns The device instance.
3417	* @param idCpu The id of the calling EMT.
3418	*/
3419	DECLR3CALLBACKMEMBER(int, pfnVMNotifyCpuDeviceReady,(PPDMDEVINS pDevIns, VMCPUID idCpu));
3420
3421	/**
3422	* Convenience wrapper for VMR3ReqCallU.
3423	*
3424	* This assumes (1) you're calling a function that returns an VBox status code
3425	* and that you do not wish to wait for it to complete.
3426	*
3427	* @returns VBox status code returned by VMR3ReqCallVU.
3428	*
3429	* @param pDevIns The device instance.
3430	* @param idDstCpu The destination CPU(s). Either a specific CPU ID or
3431	* one of the following special values:
3432	* VMCPUID_ANY, VMCPUID_ANY_QUEUE, VMCPUID_ALL or VMCPUID_ALL_REVERSE.
3433	* @param pfnFunction Pointer to the function to call.
3434	* @param cArgs Number of arguments following in the ellipsis.
3435	* @param Args Argument vector.
3436	*
3437	* @remarks See remarks on VMR3ReqCallVU.
3438	*/
3439	DECLR3CALLBACKMEMBER(int, pfnVMReqCallNoWaitV,(PPDMDEVINS pDevIns, VMCPUID idDstCpu, PFNRT pfnFunction, unsigned cArgs,
3440	va_list Args)) RT_IPRT_CALLREQ_ATTR(3, 4, 0);
3441
3442	/**
3443	* Convenience wrapper for VMR3ReqCallU.
3444	*
3445	* This assumes (1) you're calling a function that returns void, (2) that you
3446	* wish to wait for ever for it to return, and (3) that it's priority request
3447	* that can be safely be handled during async suspend and power off.
3448	*
3449	* @returns VBox status code of VMR3ReqCallVU.
3450	*
3451	* @param pDevIns The device instance.
3452	* @param idDstCpu The destination CPU(s). Either a specific CPU ID or
3453	* one of the following special values:
3454	* VMCPUID_ANY, VMCPUID_ANY_QUEUE, VMCPUID_ALL or VMCPUID_ALL_REVERSE.
3455	* @param pfnFunction Pointer to the function to call.
3456	* @param cArgs Number of arguments following in the ellipsis.
3457	* @param Args Argument vector.
3458	*
3459	* @remarks See remarks on VMR3ReqCallVU.
3460	*/
3461	DECLR3CALLBACKMEMBER(int, pfnVMReqPriorityCallWaitV,(PPDMDEVINS pDevIns, VMCPUID idDstCpu, PFNRT pfnFunction, unsigned cArgs,
3462	va_list Args)) RT_IPRT_CALLREQ_ATTR(3, 4, 0);
3463
3464	/**
3465	* Stops the VM and enters the debugger to look at the guest state.
3466	*
3467	* Use the PDMDeviceDBGFStop() inline function with the RT_SRC_POS macro instead of
3468	* invoking this function directly.
3469	*
3470	* @returns VBox status code which must be passed up to the VMM.
3471	* @param pDevIns The device instance.
3472	* @param pszFile Filename of the assertion location.
3473	* @param iLine The linenumber of the assertion location.
3474	* @param pszFunction Function of the assertion location.
3475	* @param pszFormat Message. (optional)
3476	* @param args Message parameters.
3477	*/
3478	DECLR3CALLBACKMEMBER(int, pfnDBGFStopV,(PPDMDEVINS pDevIns, const char pszFile, unsigned iLine, const char pszFunction,
3479	const char *pszFormat, va_list args) RT_IPRT_FORMAT_ATTR(5, 0));
3480
3481	/**
3482	* Register a info handler with DBGF.
3483	*
3484	* @returns VBox status code.
3485	* @param pDevIns The device instance.
3486	* @param pszName The identifier of the info.
3487	* @param pszDesc The description of the info and any arguments
3488	* the handler may take.
3489	* @param pfnHandler The handler function to be called to display the
3490	* info.
3491	*/
3492	DECLR3CALLBACKMEMBER(int, pfnDBGFInfoRegister,(PPDMDEVINS pDevIns, const char pszName, const char pszDesc, PFNDBGFHANDLERDEV pfnHandler));
3493
3494	/**
3495	* Register a info handler with DBGF, argv style.
3496	*
3497	* @returns VBox status code.
3498	* @param pDevIns The device instance.
3499	* @param pszName The identifier of the info.
3500	* @param pszDesc The description of the info and any arguments
3501	* the handler may take.
3502	* @param pfnHandler The handler function to be called to display the
3503	* info.
3504	*/
3505	DECLR3CALLBACKMEMBER(int, pfnDBGFInfoRegisterArgv,(PPDMDEVINS pDevIns, const char pszName, const char pszDesc, PFNDBGFINFOARGVDEV pfnHandler));
3506
3507	/**
3508	* Registers a set of registers for a device.
3509	*
3510	* The @a pvUser argument of the getter and setter callbacks will be
3511	* @a pDevIns. The register names will be prefixed by the device name followed
3512	* immediately by the instance number.
3513	*
3514	* @returns VBox status code.
3515	* @param pDevIns The device instance.
3516	* @param paRegisters The register descriptors.
3517	*
3518	* @remarks The device critical section is NOT entered prior to working the
3519	* callbacks registered via this helper!
3520	*/
3521	DECLR3CALLBACKMEMBER(int, pfnDBGFRegRegister,(PPDMDEVINS pDevIns, PCDBGFREGDESC paRegisters));
3522
3523	/**
3524	* Gets the trace buffer handle.
3525	*
3526	* This is used by the macros found in VBox/vmm/dbgftrace.h and is not
3527	* really inteded for direct usage, thus no inline wrapper function.
3528	*
3529	* @returns Trace buffer handle or NIL_RTTRACEBUF.
3530	* @param pDevIns The device instance.
3531	*/
3532	DECLR3CALLBACKMEMBER(RTTRACEBUF, pfnDBGFTraceBuf,(PPDMDEVINS pDevIns));
3533
3534	/**
3535	* Report a bug check.
3536	*
3537	* @returns
3538	* @param pDevIns The device instance.
3539	* @param enmEvent The kind of BSOD event this is.
3540	* @param uBugCheck The bug check number.
3541	* @param uP1 The bug check parameter \#1.
3542	* @param uP2 The bug check parameter \#2.
3543	* @param uP3 The bug check parameter \#3.
3544	* @param uP4 The bug check parameter \#4.
3545	*
3546	* @thread EMT
3547	*/
3548	DECLR3CALLBACKMEMBER(VBOXSTRICTRC, pfnDBGFReportBugCheck,(PPDMDEVINS pDevIns, DBGFEVENTTYPE enmEvent, uint64_t uBugCheck,
3549	uint64_t uP1, uint64_t uP2, uint64_t uP3, uint64_t uP4));
3550
3551	/**
3552	* Write core dump of the guest.
3553	*
3554	* @returns VBox status code.
3555	* @param pDevIns The device instance.
3556	* @param pszFilename The name of the file to which the guest core
3557	* dump should be written.
3558	* @param fReplaceFile Whether to replace the file or not.
3559	*
3560	* @remarks The VM may need to be suspended before calling this function in
3561	* order to truly stop all device threads and drivers. This function
3562	* only synchronizes EMTs.
3563	*/
3564	DECLR3CALLBACKMEMBER(int, pfnDBGFCoreWrite,(PPDMDEVINS pDevIns, const char *pszFilename, bool fReplaceFile));
3565
3566	/**
3567	* Gets the logger info helper.
3568	* The returned info helper will unconditionally write all output to the log.
3569	*
3570	* @returns Pointer to the logger info helper.
3571	* @param pDevIns The device instance.
3572	*/
3573	DECLR3CALLBACKMEMBER(PCDBGFINFOHLP, pfnDBGFInfoLogHlp,(PPDMDEVINS pDevIns));
3574
3575	/**
3576	* Queries a 64-bit register value.
3577	*
3578	* @retval VINF_SUCCESS
3579	* @retval VERR_INVALID_VM_HANDLE
3580	* @retval VERR_INVALID_CPU_ID
3581	* @retval VERR_DBGF_REGISTER_NOT_FOUND
3582	* @retval VERR_DBGF_UNSUPPORTED_CAST
3583	* @retval VINF_DBGF_TRUNCATED_REGISTER
3584	* @retval VINF_DBGF_ZERO_EXTENDED_REGISTER
3585	*
3586	* @param pDevIns The device instance.
3587	* @param idDefCpu The default target CPU ID, VMCPUID_ANY if not
3588	* applicable. Can be OR'ed with
3589	* DBGFREG_HYPER_VMCPUID.
3590	* @param pszReg The register that's being queried. Except for
3591	* CPU registers, this must be on the form
3592	* "set.reg[.sub]".
3593	* @param pu64 Where to store the register value.
3594	*/
3595	DECLR3CALLBACKMEMBER(int, pfnDBGFRegNmQueryU64,(PPDMDEVINS pDevIns, VMCPUID idDefCpu, const char pszReg, uint64_t pu64));
3596
3597	/**
3598	* Format a set of registers.
3599	*
3600	* This is restricted to registers from one CPU, that specified by @a idCpu.
3601	*
3602	* @returns VBox status code.
3603	* @param pDevIns The device instance.
3604	* @param idCpu The CPU ID of any CPU registers that may be
3605	* printed, pass VMCPUID_ANY if not applicable.
3606	* @param pszBuf The output buffer.
3607	* @param cbBuf The size of the output buffer.
3608	* @param pszFormat The format string. Register names are given by
3609	* %VR{name}, they take no arguments.
3610	* @param va Other format arguments.
3611	*/
3612	DECLR3CALLBACKMEMBER(int, pfnDBGFRegPrintfV,(PPDMDEVINS pDevIns, VMCPUID idCpu, char *pszBuf, size_t cbBuf,
3613	const char *pszFormat, va_list va));
3614
3615	/**
3616	* Registers a statistics sample.
3617	*
3618	* @param pDevIns Device instance of the DMA.
3619	* @param pvSample Pointer to the sample.
3620	* @param enmType Sample type. This indicates what pvSample is
3621	* pointing at.
3622	* @param pszName Sample name, unix path style. If this does not
3623	* start with a '/', the default prefix will be
3624	* prepended, otherwise it will be used as-is.
3625	* @param enmUnit Sample unit.
3626	* @param pszDesc Sample description.
3627	*/
3628	DECLR3CALLBACKMEMBER(void, pfnSTAMRegister,(PPDMDEVINS pDevIns, void pvSample, STAMTYPE enmType, const char pszName, STAMUNIT enmUnit, const char *pszDesc));
3629
3630	/**
3631	* Same as pfnSTAMRegister except that the name is specified in a
3632	* RTStrPrintfV like fashion.
3633	*
3634	* @param pDevIns Device instance of the DMA.
3635	* @param pvSample Pointer to the sample.
3636	* @param enmType Sample type. This indicates what pvSample is
3637	* pointing at.
3638	* @param enmVisibility Visibility type specifying whether unused
3639	* statistics should be visible or not.
3640	* @param enmUnit Sample unit.
3641	* @param pszDesc Sample description.
3642	* @param pszName Sample name format string, unix path style. If
3643	* this does not start with a '/', the default
3644	* prefix will be prepended, otherwise it will be
3645	* used as-is.
3646	* @param args Arguments to the format string.
3647	*/
3648	DECLR3CALLBACKMEMBER(void, pfnSTAMRegisterV,(PPDMDEVINS pDevIns, void *pvSample, STAMTYPE enmType,
3649	STAMVISIBILITY enmVisibility, STAMUNIT enmUnit, const char *pszDesc,
3650	const char *pszName, va_list args) RT_IPRT_FORMAT_ATTR(7, 0));
3651
3652	/**
3653	* Registers a PCI device with the default PCI bus.
3654	*
3655	* If a PDM device has more than one PCI device, they must be registered in the
3656	* order of PDMDEVINSR3::apPciDevs.
3657	*
3658	* @returns VBox status code.
3659	* @param pDevIns The device instance.
3660	* @param pPciDev The PCI device structure.
3661	* This must be kept in the instance data.
3662	* The PCI configuration must be initialized before registration.
3663	* @param fFlags 0, PDMPCIDEVREG_F_PCI_BRIDGE or
3664	* PDMPCIDEVREG_F_NOT_MANDATORY_NO.
3665	* @param uPciDevNo PDMPCIDEVREG_DEV_NO_FIRST_UNUSED,
3666	* PDMPCIDEVREG_DEV_NO_SAME_AS_PREV, or a specific
3667	* device number (0-31). This will be ignored if
3668	* the CFGM configuration contains a PCIDeviceNo
3669	* value.
3670	* @param uPciFunNo PDMPCIDEVREG_FUN_NO_FIRST_UNUSED, or a specific
3671	* function number (0-7). This will be ignored if
3672	* the CFGM configuration contains a PCIFunctionNo
3673	* value.
3674	* @param pszName Device name, if NULL PDMDEVREG::szName is used.
3675	* The pointer is saved, so don't free or changed.
3676	* @note The PCI device configuration is now implicit from the apPciDevs
3677	* index, meaning that the zero'th entry is the primary one and
3678	* subsequent uses CFGM subkeys "PciDev1", "PciDev2" and so on.
3679	*/
3680	DECLR3CALLBACKMEMBER(int, pfnPCIRegister,(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t fFlags,
3681	uint8_t uPciDevNo, uint8_t uPciFunNo, const char *pszName));
3682
3683	/**
3684	* Initialize MSI or MSI-X emulation support for the given PCI device.
3685	*
3686	* @see PDMPCIBUSREG::pfnRegisterMsiR3 for details.
3687	*
3688	* @returns VBox status code.
3689	* @param pDevIns The device instance.
3690	* @param pPciDev The PCI device. NULL is an alias for the first
3691	* one registered.
3692	* @param pMsiReg MSI emulation registration structure.
3693	*/
3694	DECLR3CALLBACKMEMBER(int, pfnPCIRegisterMsi,(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, PPDMMSIREG pMsiReg));
3695
3696	/**
3697	* Registers a I/O region (memory mapped or I/O ports) for a PCI device.
3698	*
3699	* @returns VBox status code.
3700	* @param pDevIns The device instance.
3701	* @param pPciDev The PCI device structure. If NULL the default
3702	* PCI device for this device instance is used.
3703	* @param iRegion The region number.
3704	* @param cbRegion Size of the region.
3705	* @param enmType PCI_ADDRESS_SPACE_MEM, PCI_ADDRESS_SPACE_IO or PCI_ADDRESS_SPACE_MEM_PREFETCH.
3706	* @param fFlags PDMPCIDEV_IORGN_F_XXX.
3707	* @param hHandle An I/O port, MMIO or MMIO2 handle according to
3708	* @a fFlags, UINT64_MAX if no handle is passed
3709	* (old style).
3710	* @param pfnMapUnmap Callback for doing the mapping, optional when a
3711	* handle is specified. The callback will be
3712	* invoked holding only the PDM lock. The device
3713	* lock will _not_ be taken (due to lock order).
3714	*/
3715	DECLR3CALLBACKMEMBER(int, pfnPCIIORegionRegister,(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t iRegion,
3716	RTGCPHYS cbRegion, PCIADDRESSSPACE enmType, uint32_t fFlags,
3717	uint64_t hHandle, PFNPCIIOREGIONMAP pfnMapUnmap));
3718
3719	/**
3720	* Register PCI configuration space read/write callbacks.
3721	*
3722	* @returns VBox status code.
3723	* @param pDevIns The device instance.
3724	* @param pPciDev The PCI device structure. If NULL the default
3725	* PCI device for this device instance is used.
3726	* @param pfnRead Pointer to the user defined PCI config read function.
3727	* to call default PCI config read function. Can be NULL.
3728	* @param pfnWrite Pointer to the user defined PCI config write function.
3729	* @remarks The callbacks will be invoked holding the PDM lock. The device lock
3730	* is NOT take because that is very likely be a lock order violation.
3731	* @thread EMT(0)
3732	* @note Only callable during VM creation.
3733	* @sa PDMDevHlpPCIConfigRead, PDMDevHlpPCIConfigWrite
3734	*/
3735	DECLR3CALLBACKMEMBER(int, pfnPCIInterceptConfigAccesses,(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev,
3736	PFNPCICONFIGREAD pfnRead, PFNPCICONFIGWRITE pfnWrite));
3737
3738	/**
3739	* Perform a PCI configuration space write.
3740	*
3741	* This is for devices that make use of PDMDevHlpPCIInterceptConfigAccesses().
3742	*
3743	* @returns Strict VBox status code (mainly DBGFSTOP).
3744	* @param pDevIns The device instance.
3745	* @param pPciDev The PCI device which config space is being read.
3746	* @param uAddress The config space address.
3747	* @param cb The size of the read: 1, 2 or 4 bytes.
3748	* @param u32Value The value to write.
3749	*/
3750	DECLR3CALLBACKMEMBER(VBOXSTRICTRC, pfnPCIConfigWrite,(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev,
3751	uint32_t uAddress, unsigned cb, uint32_t u32Value));
3752
3753	/**
3754	* Perform a PCI configuration space read.
3755	*
3756	* This is for devices that make use of PDMDevHlpPCIInterceptConfigAccesses().
3757	*
3758	* @returns Strict VBox status code (mainly DBGFSTOP).
3759	* @param pDevIns The device instance.
3760	* @param pPciDev The PCI device which config space is being read.
3761	* @param uAddress The config space address.
3762	* @param cb The size of the read: 1, 2 or 4 bytes.
3763	* @param pu32Value Where to return the value.
3764	*/
3765	DECLR3CALLBACKMEMBER(VBOXSTRICTRC, pfnPCIConfigRead,(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev,
3766	uint32_t uAddress, unsigned cb, uint32_t *pu32Value));
3767
3768	/**
3769	* Bus master physical memory read.
3770	*
3771	* @returns VINF_SUCCESS or VERR_PGM_PCI_PHYS_READ_BM_DISABLED, later maybe
3772	* VERR_EM_MEMORY. The informational status shall NOT be propagated!
3773	* @param pDevIns The device instance.
3774	* @param pPciDev The PCI device structure. If NULL the default
3775	* PCI device for this device instance is used.
3776	* @param GCPhys Physical address start reading from.
3777	* @param pvBuf Where to put the read bits.
3778	* @param cbRead How many bytes to read.
3779	* @param fFlags Combination of PDM_DEVHLP_PHYS_RW_F_XXX.
3780	* @thread Any thread, but the call may involve the emulation thread.
3781	*/
3782	DECLR3CALLBACKMEMBER(int, pfnPCIPhysRead,(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, RTGCPHYS GCPhys, void *pvBuf, size_t cbRead, uint32_t fFlags));
3783
3784	/**
3785	* Bus master physical memory write.
3786	*
3787	* @returns VINF_SUCCESS or VERR_PGM_PCI_PHYS_WRITE_BM_DISABLED, later maybe
3788	* VERR_EM_MEMORY. The informational status shall NOT be propagated!
3789	* @param pDevIns The device instance.
3790	* @param pPciDev The PCI device structure. If NULL the default
3791	* PCI device for this device instance is used.
3792	* @param GCPhys Physical address to write to.
3793	* @param pvBuf What to write.
3794	* @param cbWrite How many bytes to write.
3795	* @param fFlags Combination of PDM_DEVHLP_PHYS_RW_F_XXX.
3796	* @thread Any thread, but the call may involve the emulation thread.
3797	*/
3798	DECLR3CALLBACKMEMBER(int, pfnPCIPhysWrite,(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, RTGCPHYS GCPhys, const void *pvBuf, size_t cbWrite, uint32_t fFlags));
3799
3800	/**
3801	* Requests the mapping of a guest page into ring-3 in preparation for a bus master
3802	* physical memory write operation.
3803	*
3804	* Refer pfnPhysGCPhys2CCPtr() for further details.
3805	*
3806	* @returns VBox status code.
3807	* @param pDevIns The device instance.
3808	* @param pPciDev The PCI device structure. If NULL the default
3809	* PCI device for this device instance is used.
3810	* @param GCPhys The guest physical address of the page that should be
3811	* mapped.
3812	* @param fFlags Flags reserved for future use, MBZ.
3813	* @param ppv Where to store the address corresponding to GCPhys.
3814	* @param pLock Where to store the lock information that
3815	* pfnPhysReleasePageMappingLock needs.
3816	*
3817	* @remarks Avoid calling this API from within critical sections (other than the PGM
3818	* one) because of the deadlock risk when we have to delegating the task to
3819	* an EMT.
3820	* @thread Any.
3821	*/
3822	DECLR3CALLBACKMEMBER(int, pfnPCIPhysGCPhys2CCPtr,(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, RTGCPHYS GCPhys, uint32_t fFlags,
3823	void **ppv, PPGMPAGEMAPLOCK pLock));
3824
3825	/**
3826	* Requests the mapping of a guest page into ring-3, external threads, in prepartion
3827	* for a bus master physical memory read operation.
3828	*
3829	* Refer pfnPhysGCPhys2CCPtrReadOnly() for further details.
3830	*
3831	* @returns VBox status code.
3832	* @param pDevIns The device instance.
3833	* @param pPciDev The PCI device structure. If NULL the default
3834	* PCI device for this device instance is used.
3835	* @param GCPhys The guest physical address of the page that
3836	* should be mapped.
3837	* @param fFlags Flags reserved for future use, MBZ.
3838	* @param ppv Where to store the address corresponding to
3839	* GCPhys.
3840	* @param pLock Where to store the lock information that
3841	* pfnPhysReleasePageMappingLock needs.
3842	*
3843	* @remarks Avoid calling this API from within critical sections.
3844	* @thread Any.
3845	*/
3846	DECLR3CALLBACKMEMBER(int, pfnPCIPhysGCPhys2CCPtrReadOnly,(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, RTGCPHYS GCPhys,
3847	uint32_t fFlags, void const **ppv, PPGMPAGEMAPLOCK pLock));
3848
3849	/**
3850	* Requests the mapping of multiple guest pages into ring-3 in prepartion for a bus
3851	* master physical memory write operation.
3852	*
3853	* When you're done with the pages, call pfnPhysBulkReleasePageMappingLocks()
3854	* ASAP to release them.
3855	*
3856	* Refer pfnPhysBulkGCPhys2CCPtr() for further details.
3857	*
3858	* @returns VBox status code.
3859	* @param pDevIns The device instance.
3860	* @param pPciDev The PCI device structure. If NULL the default
3861	* PCI device for this device instance is used.
3862	* @param cPages Number of pages to lock.
3863	* @param paGCPhysPages The guest physical address of the pages that
3864	* should be mapped (@a cPages entries).
3865	* @param fFlags Flags reserved for future use, MBZ.
3866	* @param papvPages Where to store the ring-3 mapping addresses
3867	* corresponding to @a paGCPhysPages.
3868	* @param paLocks Where to store the locking information that
3869	* pfnPhysBulkReleasePageMappingLock needs (@a cPages
3870	* in length).
3871	*/
3872	DECLR3CALLBACKMEMBER(int, pfnPCIPhysBulkGCPhys2CCPtr,(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t cPages,
3873	PCRTGCPHYS paGCPhysPages, uint32_t fFlags, void **papvPages,
3874	PPGMPAGEMAPLOCK paLocks));
3875
3876	/**
3877	* Requests the mapping of multiple guest pages into ring-3 in preparation for a bus
3878	* master physical memory read operation.
3879	*
3880	* When you're done with the pages, call pfnPhysBulkReleasePageMappingLocks()
3881	* ASAP to release them.
3882	*
3883	* Refer pfnPhysBulkGCPhys2CCPtrReadOnly() for further details.
3884	*
3885	* @returns VBox status code.
3886	* @param pDevIns The device instance.
3887	* @param pPciDev The PCI device structure. If NULL the default
3888	* PCI device for this device instance is used.
3889	* @param cPages Number of pages to lock.
3890	* @param paGCPhysPages The guest physical address of the pages that
3891	* should be mapped (@a cPages entries).
3892	* @param fFlags Flags reserved for future use, MBZ.
3893	* @param papvPages Where to store the ring-3 mapping addresses
3894	* corresponding to @a paGCPhysPages.
3895	* @param paLocks Where to store the lock information that
3896	* pfnPhysReleasePageMappingLock needs (@a cPages
3897	* in length).
3898	*/
3899	DECLR3CALLBACKMEMBER(int, pfnPCIPhysBulkGCPhys2CCPtrReadOnly,(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t cPages,
3900	PCRTGCPHYS paGCPhysPages, uint32_t fFlags,
3901	void const **papvPages, PPGMPAGEMAPLOCK paLocks));
3902
3903	/**
3904	* Sets the IRQ for the given PCI device.
3905	*
3906	* @param pDevIns The device instance.
3907	* @param pPciDev The PCI device structure. If NULL the default
3908	* PCI device for this device instance is used.
3909	* @param iIrq IRQ number to set.
3910	* @param iLevel IRQ level. See the PDM_IRQ_LEVEL_* \#defines.
3911	* @thread Any thread, but will involve the emulation thread.
3912	*/
3913	DECLR3CALLBACKMEMBER(void, pfnPCISetIrq,(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, int iIrq, int iLevel));
3914
3915	/**
3916	* Sets the IRQ for the given PCI device, but doesn't wait for EMT to process
3917	* the request when not called from EMT.
3918	*
3919	* @param pDevIns The device instance.
3920	* @param pPciDev The PCI device structure. If NULL the default
3921	* PCI device for this device instance is used.
3922	* @param iIrq IRQ number to set.
3923	* @param iLevel IRQ level.
3924	* @thread Any thread, but will involve the emulation thread.
3925	*/
3926	DECLR3CALLBACKMEMBER(void, pfnPCISetIrqNoWait,(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, int iIrq, int iLevel));
3927
3928	/**
3929	* Set ISA IRQ for a device.
3930	*
3931	* @param pDevIns The device instance.
3932	* @param iIrq IRQ number to set.
3933	* @param iLevel IRQ level. See the PDM_IRQ_LEVEL_* \#defines.
3934	* @thread Any thread, but will involve the emulation thread.
3935	*/
3936	DECLR3CALLBACKMEMBER(void, pfnISASetIrq,(PPDMDEVINS pDevIns, int iIrq, int iLevel));
3937
3938	/**
3939	* Set the ISA IRQ for a device, but don't wait for EMT to process
3940	* the request when not called from EMT.
3941	*
3942	* @param pDevIns The device instance.
3943	* @param iIrq IRQ number to set.
3944	* @param iLevel IRQ level. See the PDM_IRQ_LEVEL_* \#defines.
3945	* @thread Any thread, but will involve the emulation thread.
3946	*/
3947	DECLR3CALLBACKMEMBER(void, pfnISASetIrqNoWait,(PPDMDEVINS pDevIns, int iIrq, int iLevel));
3948
3949	/**
3950	* Attaches a driver (chain) to the device.
3951	*
3952	* The first call for a LUN this will serve as a registration of the LUN. The pBaseInterface and
3953	* the pszDesc string will be registered with that LUN and kept around for PDMR3QueryDeviceLun().
3954	*
3955	* @returns VBox status code.
3956	* @param pDevIns The device instance.
3957	* @param iLun The logical unit to attach.
3958	* @param pBaseInterface Pointer to the base interface for that LUN. (device side / down)
3959	* @param ppBaseInterface Where to store the pointer to the base interface. (driver side / up)
3960	* @param pszDesc Pointer to a string describing the LUN. This string must remain valid
3961	* for the live of the device instance.
3962	*/
3963	DECLR3CALLBACKMEMBER(int, pfnDriverAttach,(PPDMDEVINS pDevIns, uint32_t iLun, PPDMIBASE pBaseInterface,
3964	PPDMIBASE ppBaseInterface, const char pszDesc));
3965
3966	/**
3967	* Detaches an attached driver (chain) from the device again.
3968	*
3969	* @returns VBox status code.
3970	* @param pDevIns The device instance.
3971	* @param pDrvIns The driver instance to detach.
3972	* @param fFlags Flags, combination of the PDMDEVATT_FLAGS_* \#defines.
3973	*/
3974	DECLR3CALLBACKMEMBER(int, pfnDriverDetach,(PPDMDEVINS pDevIns, PPDMDRVINS pDrvIns, uint32_t fFlags));
3975
3976	/**
3977	* Reconfigures the driver chain for a LUN, detaching any driver currently
3978	* present there.
3979	*
3980	* Caller will have attach it, of course.
3981	*
3982	* @returns VBox status code.
3983	* @param pDevIns The device instance.
3984	* @param iLun The logical unit to reconfigure.
3985	* @param cDepth The depth of the driver chain. Determins the
3986	* size of @a papszDrivers and @a papConfigs.
3987	* @param papszDrivers The names of the drivers to configure in the
3988	* chain, first entry is the one immediately
3989	* below the device/LUN
3990	* @param papConfigs The configurations for each of the drivers
3991	* in @a papszDrivers array. NULL entries
3992	* corresponds to empty 'Config' nodes. This
3993	* function will take ownership of non-NULL
3994	* CFGM sub-trees and set the array member to
3995	* NULL, so the caller can do cleanups on
3996	* failure. This parameter is optional.
3997	* @param fFlags Reserved, MBZ.
3998	*/
3999	DECLR3CALLBACKMEMBER(int, pfnDriverReconfigure,(PPDMDEVINS pDevIns, uint32_t iLun, uint32_t cDepth,
4000	const char * const papszDrivers, PCFGMNODE papConfigs, uint32_t fFlags));
4001
4002	/** @name Exported PDM Queue Functions
4003	* @{ */
4004	/**
4005	* Create a queue.
4006	*
4007	* @returns VBox status code.
4008	* @param pDevIns The device instance.
4009	* @param cbItem The size of a queue item.
4010	* @param cItems The number of items in the queue.
4011	* @param cMilliesInterval The number of milliseconds between polling the queue.
4012	* If 0 then the emulation thread will be notified whenever an item arrives.
4013	* @param pfnCallback The consumer function.
4014	* @param fRZEnabled Set if the queue should work in RC and R0.
4015	* @param pszName The queue base name. The instance number will be
4016	* appended automatically.
4017	* @param phQueue Where to store the queue handle on success.
4018	* @thread EMT(0)
4019	* @remarks The device critical section will NOT be entered before calling the
4020	* callback. No locks will be held, but for now it's safe to assume
4021	* that only one EMT will do queue callbacks at any one time.
4022	*/
4023	DECLR3CALLBACKMEMBER(int, pfnQueueCreate,(PPDMDEVINS pDevIns, size_t cbItem, uint32_t cItems, uint32_t cMilliesInterval,
4024	PFNPDMQUEUEDEV pfnCallback, bool fRZEnabled, const char *pszName,
4025	PDMQUEUEHANDLE *phQueue));
4026
4027	DECLR3CALLBACKMEMBER(PPDMQUEUEITEMCORE, pfnQueueAlloc,(PPDMDEVINS pDevIns, PDMQUEUEHANDLE hQueue));
4028	DECLR3CALLBACKMEMBER(int, pfnQueueInsert,(PPDMDEVINS pDevIns, PDMQUEUEHANDLE hQueue, PPDMQUEUEITEMCORE pItem));
4029	DECLR3CALLBACKMEMBER(bool, pfnQueueFlushIfNecessary,(PPDMDEVINS pDevIns, PDMQUEUEHANDLE hQueue));
4030	/** @} */
4031
4032	/** @name PDM Task
4033	* @{ */
4034	/**
4035	* Create an asynchronous ring-3 task.
4036	*
4037	* @returns VBox status code.
4038	* @param pDevIns The device instance.
4039	* @param fFlags PDMTASK_F_XXX
4040	* @param pszName The function name or similar. Used for statistics,
4041	* so no slashes.
4042	* @param pfnCallback The task function.
4043	* @param pvUser User argument for the task function.
4044	* @param phTask Where to return the task handle.
4045	* @thread EMT(0)
4046	*/
4047	DECLR3CALLBACKMEMBER(int, pfnTaskCreate,(PPDMDEVINS pDevIns, uint32_t fFlags, const char *pszName,
4048	PFNPDMTASKDEV pfnCallback, void pvUser, PDMTASKHANDLE phTask));
4049	/**
4050	* Triggers the running the given task.
4051	*
4052	* @returns VBox status code.
4053	* @retval VINF_ALREADY_POSTED is the task is already pending.
4054	* @param pDevIns The device instance.
4055	* @param hTask The task to trigger.
4056	* @thread Any thread.
4057	*/
4058	DECLR3CALLBACKMEMBER(int, pfnTaskTrigger,(PPDMDEVINS pDevIns, PDMTASKHANDLE hTask));
4059	/** @} */
4060
4061	/** @name SUP Event Semaphore Wrappers (single release / auto reset)
4062	* These semaphores can be signalled from ring-0.
4063	* @{ */
4064	/** @sa SUPSemEventCreate */
4065	DECLR3CALLBACKMEMBER(int, pfnSUPSemEventCreate,(PPDMDEVINS pDevIns, PSUPSEMEVENT phEvent));
4066	/** @sa SUPSemEventClose */
4067	DECLR3CALLBACKMEMBER(int, pfnSUPSemEventClose,(PPDMDEVINS pDevIns, SUPSEMEVENT hEvent));
4068	/** @sa SUPSemEventSignal */
4069	DECLR3CALLBACKMEMBER(int, pfnSUPSemEventSignal,(PPDMDEVINS pDevIns, SUPSEMEVENT hEvent));
4070	/** @sa SUPSemEventWaitNoResume */
4071	DECLR3CALLBACKMEMBER(int, pfnSUPSemEventWaitNoResume,(PPDMDEVINS pDevIns, SUPSEMEVENT hEvent, uint32_t cMillies));
4072	/** @sa SUPSemEventWaitNsAbsIntr */
4073	DECLR3CALLBACKMEMBER(int, pfnSUPSemEventWaitNsAbsIntr,(PPDMDEVINS pDevIns, SUPSEMEVENT hEvent, uint64_t uNsTimeout));
4074	/** @sa SUPSemEventWaitNsRelIntr */
4075	DECLR3CALLBACKMEMBER(int, pfnSUPSemEventWaitNsRelIntr,(PPDMDEVINS pDevIns, SUPSEMEVENT hEvent, uint64_t cNsTimeout));
4076	/** @sa SUPSemEventGetResolution */
4077	DECLR3CALLBACKMEMBER(uint32_t, pfnSUPSemEventGetResolution,(PPDMDEVINS pDevIns));
4078	/** @} */
4079
4080	/** @name SUP Multi Event Semaphore Wrappers (multiple release / manual reset)
4081	* These semaphores can be signalled from ring-0.
4082	* @{ */
4083	/** @sa SUPSemEventMultiCreate */
4084	DECLR3CALLBACKMEMBER(int, pfnSUPSemEventMultiCreate,(PPDMDEVINS pDevIns, PSUPSEMEVENTMULTI phEventMulti));
4085	/** @sa SUPSemEventMultiClose */
4086	DECLR3CALLBACKMEMBER(int, pfnSUPSemEventMultiClose,(PPDMDEVINS pDevIns, SUPSEMEVENTMULTI hEventMulti));
4087	/** @sa SUPSemEventMultiSignal */
4088	DECLR3CALLBACKMEMBER(int, pfnSUPSemEventMultiSignal,(PPDMDEVINS pDevIns, SUPSEMEVENTMULTI hEventMulti));
4089	/** @sa SUPSemEventMultiReset */
4090	DECLR3CALLBACKMEMBER(int, pfnSUPSemEventMultiReset,(PPDMDEVINS pDevIns, SUPSEMEVENTMULTI hEventMulti));
4091	/** @sa SUPSemEventMultiWaitNoResume */
4092	DECLR3CALLBACKMEMBER(int, pfnSUPSemEventMultiWaitNoResume,(PPDMDEVINS pDevIns, SUPSEMEVENTMULTI hEventMulti, uint32_t cMillies));
4093	/** @sa SUPSemEventMultiWaitNsAbsIntr */
4094	DECLR3CALLBACKMEMBER(int, pfnSUPSemEventMultiWaitNsAbsIntr,(PPDMDEVINS pDevIns, SUPSEMEVENTMULTI hEventMulti, uint64_t uNsTimeout));
4095	/** @sa SUPSemEventMultiWaitNsRelIntr */
4096	DECLR3CALLBACKMEMBER(int, pfnSUPSemEventMultiWaitNsRelIntr,(PPDMDEVINS pDevIns, SUPSEMEVENTMULTI hEventMulti, uint64_t cNsTimeout));
4097	/** @sa SUPSemEventMultiGetResolution */
4098	DECLR3CALLBACKMEMBER(uint32_t, pfnSUPSemEventMultiGetResolution,(PPDMDEVINS pDevIns));
4099	/** @} */
4100
4101	/**
4102	* Initializes a PDM critical section.
4103	*
4104	* The PDM critical sections are derived from the IPRT critical sections, but
4105	* works in RC and R0 as well.
4106	*
4107	* @returns VBox status code.
4108	* @param pDevIns The device instance.
4109	* @param pCritSect Pointer to the critical section.
4110	* @param SRC_POS Use RT_SRC_POS.
4111	* @param pszNameFmt Format string for naming the critical section.
4112	* For statistics and lock validation.
4113	* @param va Arguments for the format string.
4114	*/
4115	DECLR3CALLBACKMEMBER(int, pfnCritSectInit,(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect, RT_SRC_POS_DECL,
4116	const char *pszNameFmt, va_list va) RT_IPRT_FORMAT_ATTR(6, 0));
4117
4118	/**
4119	* Gets the NOP critical section.
4120	*
4121	* @returns The ring-3 address of the NOP critical section.
4122	* @param pDevIns The device instance.
4123	*/
4124	DECLR3CALLBACKMEMBER(PPDMCRITSECT, pfnCritSectGetNop,(PPDMDEVINS pDevIns));
4125
4126	/**
4127	* Changes the device level critical section from the automatically created
4128	* default to one desired by the device constructor.
4129	*
4130	* For ring-0 and raw-mode capable devices, the call must be repeated in each of
4131	* the additional contexts.
4132	*
4133	* @returns VBox status code.
4134	* @param pDevIns The device instance.
4135	* @param pCritSect The critical section to use. NULL is not
4136	* valid, instead use the NOP critical
4137	* section.
4138	*/
4139	DECLR3CALLBACKMEMBER(int, pfnSetDeviceCritSect,(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect));
4140
4141	/** @name Exported PDM Critical Section Functions
4142	* @{ */
4143	DECLR3CALLBACKMEMBER(bool, pfnCritSectYield,(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect));
4144	DECLR3CALLBACKMEMBER(int, pfnCritSectEnter,(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect, int rcBusy));
4145	DECLR3CALLBACKMEMBER(int, pfnCritSectEnterDebug,(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect, int rcBusy, RTHCUINTPTR uId, RT_SRC_POS_DECL));
4146	DECLR3CALLBACKMEMBER(int, pfnCritSectTryEnter,(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect));
4147	DECLR3CALLBACKMEMBER(int, pfnCritSectTryEnterDebug,(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect, RTHCUINTPTR uId, RT_SRC_POS_DECL));
4148	DECLR3CALLBACKMEMBER(int, pfnCritSectLeave,(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect));
4149	DECLR3CALLBACKMEMBER(bool, pfnCritSectIsOwner,(PPDMDEVINS pDevIns, PCPDMCRITSECT pCritSect));
4150	DECLR3CALLBACKMEMBER(bool, pfnCritSectIsInitialized,(PPDMDEVINS pDevIns, PCPDMCRITSECT pCritSect));
4151	DECLR3CALLBACKMEMBER(bool, pfnCritSectHasWaiters,(PPDMDEVINS pDevIns, PCPDMCRITSECT pCritSect));
4152	DECLR3CALLBACKMEMBER(uint32_t, pfnCritSectGetRecursion,(PPDMDEVINS pDevIns, PCPDMCRITSECT pCritSect));
4153	DECLR3CALLBACKMEMBER(int, pfnCritSectScheduleExitEvent,(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect, SUPSEMEVENT hEventToSignal));
4154	DECLR3CALLBACKMEMBER(int, pfnCritSectDelete,(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect));
4155	/** @} */
4156
4157	/** @name Exported PDM Read/Write Critical Section Functions
4158	* @{ */
4159	DECLR3CALLBACKMEMBER(int, pfnCritSectRwInit,(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect, RT_SRC_POS_DECL,
4160	const char *pszNameFmt, va_list va) RT_IPRT_FORMAT_ATTR(6, 0));
4161	DECLR3CALLBACKMEMBER(int, pfnCritSectRwDelete,(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect));
4162
4163	DECLR3CALLBACKMEMBER(int, pfnCritSectRwEnterShared,(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect, int rcBusy));
4164	DECLR3CALLBACKMEMBER(int, pfnCritSectRwEnterSharedDebug,(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect, int rcBusy, RTHCUINTPTR uId, RT_SRC_POS_DECL));
4165	DECLR3CALLBACKMEMBER(int, pfnCritSectRwTryEnterShared,(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect));
4166	DECLR3CALLBACKMEMBER(int, pfnCritSectRwTryEnterSharedDebug,(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect, RTHCUINTPTR uId, RT_SRC_POS_DECL));
4167	DECLR3CALLBACKMEMBER(int, pfnCritSectRwLeaveShared,(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect));
4168
4169	DECLR3CALLBACKMEMBER(int, pfnCritSectRwEnterExcl,(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect, int rcBusy));
4170	DECLR3CALLBACKMEMBER(int, pfnCritSectRwEnterExclDebug,(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect, int rcBusy, RTHCUINTPTR uId, RT_SRC_POS_DECL));
4171	DECLR3CALLBACKMEMBER(int, pfnCritSectRwTryEnterExcl,(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect));
4172	DECLR3CALLBACKMEMBER(int, pfnCritSectRwTryEnterExclDebug,(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect, RTHCUINTPTR uId, RT_SRC_POS_DECL));
4173	DECLR3CALLBACKMEMBER(int, pfnCritSectRwLeaveExcl,(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect));
4174
4175	DECLR3CALLBACKMEMBER(bool, pfnCritSectRwIsWriteOwner,(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect));
4176	DECLR3CALLBACKMEMBER(bool, pfnCritSectRwIsReadOwner,(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect, bool fWannaHear));
4177	DECLR3CALLBACKMEMBER(uint32_t, pfnCritSectRwGetWriteRecursion,(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect));
4178	DECLR3CALLBACKMEMBER(uint32_t, pfnCritSectRwGetWriterReadRecursion,(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect));
4179	DECLR3CALLBACKMEMBER(uint32_t, pfnCritSectRwGetReadCount,(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect));
4180	DECLR3CALLBACKMEMBER(bool, pfnCritSectRwIsInitialized,(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect));
4181	/** @} */
4182
4183	/**
4184	* Creates a PDM thread.
4185	*
4186	* This differs from the RTThreadCreate() API in that PDM takes care of suspending,
4187	* resuming, and destroying the thread as the VM state changes.
4188	*
4189	* @returns VBox status code.
4190	* @param pDevIns The device instance.
4191	* @param ppThread Where to store the thread 'handle'.
4192	* @param pvUser The user argument to the thread function.
4193	* @param pfnThread The thread function.
4194	* @param pfnWakeup The wakup callback. This is called on the EMT
4195	* thread when a state change is pending.
4196	* @param cbStack See RTThreadCreate.
4197	* @param enmType See RTThreadCreate.
4198	* @param pszName See RTThreadCreate.
4199	* @remarks The device critical section will NOT be entered prior to invoking
4200	* the function pointers.
4201	*/
4202	DECLR3CALLBACKMEMBER(int, pfnThreadCreate,(PPDMDEVINS pDevIns, PPPDMTHREAD ppThread, void *pvUser, PFNPDMTHREADDEV pfnThread,
4203	PFNPDMTHREADWAKEUPDEV pfnWakeup, size_t cbStack, RTTHREADTYPE enmType, const char *pszName));
4204
4205	/** @name Exported PDM Thread Functions
4206	* @{ */
4207	DECLR3CALLBACKMEMBER(int, pfnThreadDestroy,(PPDMTHREAD pThread, int *pRcThread));
4208	DECLR3CALLBACKMEMBER(int, pfnThreadIAmSuspending,(PPDMTHREAD pThread));
4209	DECLR3CALLBACKMEMBER(int, pfnThreadIAmRunning,(PPDMTHREAD pThread));
4210	DECLR3CALLBACKMEMBER(int, pfnThreadSleep,(PPDMTHREAD pThread, RTMSINTERVAL cMillies));
4211	DECLR3CALLBACKMEMBER(int, pfnThreadSuspend,(PPDMTHREAD pThread));
4212	DECLR3CALLBACKMEMBER(int, pfnThreadResume,(PPDMTHREAD pThread));
4213	/** @} */
4214
4215	/**
4216	* Set up asynchronous handling of a suspend, reset or power off notification.
4217	*
4218	* This shall only be called when getting the notification. It must be called
4219	* for each one.
4220	*
4221	* @returns VBox status code.
4222	* @param pDevIns The device instance.
4223	* @param pfnAsyncNotify The callback.
4224	* @thread EMT(0)
4225	* @remarks The caller will enter the device critical section prior to invoking
4226	* the callback.
4227	*/
4228	DECLR3CALLBACKMEMBER(int, pfnSetAsyncNotification, (PPDMDEVINS pDevIns, PFNPDMDEVASYNCNOTIFY pfnAsyncNotify));
4229
4230	/**
4231	* Notify EMT(0) that the device has completed the asynchronous notification
4232	* handling.
4233	*
4234	* This can be called at any time, spurious calls will simply be ignored.
4235	*
4236	* @param pDevIns The device instance.
4237	* @thread Any
4238	*/
4239	DECLR3CALLBACKMEMBER(void, pfnAsyncNotificationCompleted, (PPDMDEVINS pDevIns));
4240
4241	/**
4242	* Register the RTC device.
4243	*
4244	* @returns VBox status code.
4245	* @param pDevIns The device instance.
4246	* @param pRtcReg Pointer to a RTC registration structure.
4247	* @param ppRtcHlp Where to store the pointer to the helper
4248	* functions.
4249	*/
4250	DECLR3CALLBACKMEMBER(int, pfnRTCRegister,(PPDMDEVINS pDevIns, PCPDMRTCREG pRtcReg, PCPDMRTCHLP *ppRtcHlp));
4251
4252	/**
4253	* Register a PCI Bus.
4254	*
4255	* @returns VBox status code, but the positive values 0..31 are used to indicate
4256	* bus number rather than informational status codes.
4257	* @param pDevIns The device instance.
4258	* @param pPciBusReg Pointer to PCI bus registration structure.
4259	* @param ppPciHlp Where to store the pointer to the PCI Bus
4260	* helpers.
4261	* @param piBus Where to return the PDM bus number. Optional.
4262	*/
4263	DECLR3CALLBACKMEMBER(int, pfnPCIBusRegister,(PPDMDEVINS pDevIns, PPDMPCIBUSREGR3 pPciBusReg,
4264	PCPDMPCIHLPR3 ppPciHlp, uint32_t piBus));
4265
4266	/**
4267	* Register the IOMMU device.
4268	*
4269	* @returns VBox status code.
4270	* @param pDevIns The device instance.
4271	* @param pIommuReg Pointer to a IOMMU registration structure.
4272	* @param ppIommuHlp Where to store the pointer to the ring-3 IOMMU
4273	* helpers.
4274	* @param pidxIommu Where to return the IOMMU index. Optional.
4275	*/
4276	DECLR3CALLBACKMEMBER(int, pfnIommuRegister,(PPDMDEVINS pDevIns, PPDMIOMMUREGR3 pIommuReg, PCPDMIOMMUHLPR3 *ppIommuHlp,
4277	uint32_t *pidxIommu));
4278
4279	/**
4280	* Register the PIC device.
4281	*
4282	* @returns VBox status code.
4283	* @param pDevIns The device instance.
4284	* @param pPicReg Pointer to a PIC registration structure.
4285	* @param ppPicHlp Where to store the pointer to the ring-3 PIC
4286	* helpers.
4287	* @sa PDMDevHlpPICSetUpContext
4288	*/
4289	DECLR3CALLBACKMEMBER(int, pfnPICRegister,(PPDMDEVINS pDevIns, PPDMPICREG pPicReg, PCPDMPICHLP *ppPicHlp));
4290
4291	/**
4292	* Register the APIC device.
4293	*
4294	* @returns VBox status code.
4295	* @param pDevIns The device instance.
4296	*/
4297	DECLR3CALLBACKMEMBER(int, pfnApicRegister,(PPDMDEVINS pDevIns));
4298
4299	/**
4300	* Register the I/O APIC device.
4301	*
4302	* @returns VBox status code.
4303	* @param pDevIns The device instance.
4304	* @param pIoApicReg Pointer to a I/O APIC registration structure.
4305	* @param ppIoApicHlp Where to store the pointer to the IOAPIC
4306	* helpers.
4307	*/
4308	DECLR3CALLBACKMEMBER(int, pfnIoApicRegister,(PPDMDEVINS pDevIns, PPDMIOAPICREG pIoApicReg, PCPDMIOAPICHLP *ppIoApicHlp));
4309
4310	/**
4311	* Register the HPET device.
4312	*
4313	* @returns VBox status code.
4314	* @param pDevIns The device instance.
4315	* @param pHpetReg Pointer to a HPET registration structure.
4316	* @param ppHpetHlpR3 Where to store the pointer to the HPET
4317	* helpers.
4318	*/
4319	DECLR3CALLBACKMEMBER(int, pfnHpetRegister,(PPDMDEVINS pDevIns, PPDMHPETREG pHpetReg, PCPDMHPETHLPR3 *ppHpetHlpR3));
4320
4321	/**
4322	* Register a raw PCI device.
4323	*
4324	* @returns VBox status code.
4325	* @param pDevIns The device instance.
4326	* @param pPciRawReg Pointer to a raw PCI registration structure.
4327	* @param ppPciRawHlpR3 Where to store the pointer to the raw PCI
4328	* device helpers.
4329	*/
4330	DECLR3CALLBACKMEMBER(int, pfnPciRawRegister,(PPDMDEVINS pDevIns, PPDMPCIRAWREG pPciRawReg, PCPDMPCIRAWHLPR3 *ppPciRawHlpR3));
4331
4332	/**
4333	* Register the DMA device.
4334	*
4335	* @returns VBox status code.
4336	* @param pDevIns The device instance.
4337	* @param pDmacReg Pointer to a DMAC registration structure.
4338	* @param ppDmacHlp Where to store the pointer to the DMA helpers.
4339	*/
4340	DECLR3CALLBACKMEMBER(int, pfnDMACRegister,(PPDMDEVINS pDevIns, PPDMDMACREG pDmacReg, PCPDMDMACHLP *ppDmacHlp));
4341
4342	/**
4343	* Register transfer function for DMA channel.
4344	*
4345	* @returns VBox status code.
4346	* @param pDevIns The device instance.
4347	* @param uChannel Channel number.
4348	* @param pfnTransferHandler Device specific transfer callback function.
4349	* @param pvUser User pointer to pass to the callback.
4350	* @thread EMT
4351	*/
4352	DECLR3CALLBACKMEMBER(int, pfnDMARegister,(PPDMDEVINS pDevIns, unsigned uChannel, PFNDMATRANSFERHANDLER pfnTransferHandler, void *pvUser));
4353
4354	/**
4355	* Read memory.
4356	*
4357	* @returns VBox status code.
4358	* @param pDevIns The device instance.
4359	* @param uChannel Channel number.
4360	* @param pvBuffer Pointer to target buffer.
4361	* @param off DMA position.
4362	* @param cbBlock Block size.
4363	* @param pcbRead Where to store the number of bytes which was
4364	* read. optional.
4365	* @thread EMT
4366	*/
4367	DECLR3CALLBACKMEMBER(int, pfnDMAReadMemory,(PPDMDEVINS pDevIns, unsigned uChannel, void pvBuffer, uint32_t off, uint32_t cbBlock, uint32_t pcbRead));
4368
4369	/**
4370	* Write memory.
4371	*
4372	* @returns VBox status code.
4373	* @param pDevIns The device instance.
4374	* @param uChannel Channel number.
4375	* @param pvBuffer Memory to write.
4376	* @param off DMA position.
4377	* @param cbBlock Block size.
4378	* @param pcbWritten Where to store the number of bytes which was
4379	* written. optional.
4380	* @thread EMT
4381	*/
4382	DECLR3CALLBACKMEMBER(int, pfnDMAWriteMemory,(PPDMDEVINS pDevIns, unsigned uChannel, const void pvBuffer, uint32_t off, uint32_t cbBlock, uint32_t pcbWritten));
4383
4384	/**
4385	* Set the DREQ line.
4386	*
4387	* @returns VBox status code.
4388	* @param pDevIns Device instance.
4389	* @param uChannel Channel number.
4390	* @param uLevel Level of the line.
4391	* @thread EMT
4392	*/
4393	DECLR3CALLBACKMEMBER(int, pfnDMASetDREQ,(PPDMDEVINS pDevIns, unsigned uChannel, unsigned uLevel));
4394
4395	/**
4396	* Get channel mode.
4397	*
4398	* @returns Channel mode. See specs.
4399	* @param pDevIns The device instance.
4400	* @param uChannel Channel number.
4401	* @thread EMT
4402	*/
4403	DECLR3CALLBACKMEMBER(uint8_t, pfnDMAGetChannelMode,(PPDMDEVINS pDevIns, unsigned uChannel));
4404
4405	/**
4406	* Schedule DMA execution.
4407	*
4408	* @param pDevIns The device instance.
4409	* @thread Any thread.
4410	*/
4411	DECLR3CALLBACKMEMBER(void, pfnDMASchedule,(PPDMDEVINS pDevIns));
4412
4413	/**
4414	* Write CMOS value and update the checksum(s).
4415	*
4416	* @returns VBox status code.
4417	* @param pDevIns The device instance.
4418	* @param iReg The CMOS register index.
4419	* @param u8Value The CMOS register value.
4420	* @thread EMT
4421	*/
4422	DECLR3CALLBACKMEMBER(int, pfnCMOSWrite,(PPDMDEVINS pDevIns, unsigned iReg, uint8_t u8Value));
4423
4424	/**
4425	* Read CMOS value.
4426	*
4427	* @returns VBox status code.
4428	* @param pDevIns The device instance.
4429	* @param iReg The CMOS register index.
4430	* @param pu8Value Where to store the CMOS register value.
4431	* @thread EMT
4432	*/
4433	DECLR3CALLBACKMEMBER(int, pfnCMOSRead,(PPDMDEVINS pDevIns, unsigned iReg, uint8_t *pu8Value));
4434
4435	/**
4436	* Assert that the current thread is the emulation thread.
4437	*
4438	* @returns True if correct.
4439	* @returns False if wrong.
4440	* @param pDevIns The device instance.
4441	* @param pszFile Filename of the assertion location.
4442	* @param iLine The linenumber of the assertion location.
4443	* @param pszFunction Function of the assertion location.
4444	*/
4445	DECLR3CALLBACKMEMBER(bool, pfnAssertEMT,(PPDMDEVINS pDevIns, const char pszFile, unsigned iLine, const char pszFunction));
4446
4447	/**
4448	* Assert that the current thread is NOT the emulation thread.
4449	*
4450	* @returns True if correct.
4451	* @returns False if wrong.
4452	* @param pDevIns The device instance.
4453	* @param pszFile Filename of the assertion location.
4454	* @param iLine The linenumber of the assertion location.
4455	* @param pszFunction Function of the assertion location.
4456	*/
4457	DECLR3CALLBACKMEMBER(bool, pfnAssertOther,(PPDMDEVINS pDevIns, const char pszFile, unsigned iLine, const char pszFunction));
4458
4459	/**
4460	* Resolves the symbol for a raw-mode context interface.
4461	*
4462	* @returns VBox status code.
4463	* @param pDevIns The device instance.
4464	* @param pvInterface The interface structure.
4465	* @param cbInterface The size of the interface structure.
4466	* @param pszSymPrefix What to prefix the symbols in the list with
4467	* before resolving them. This must start with
4468	* 'dev' and contain the driver name.
4469	* @param pszSymList List of symbols corresponding to the interface.
4470	* There is generally a there is generally a define
4471	* holding this list associated with the interface
4472	* definition (INTERFACE_SYM_LIST). For more
4473	* details see PDMR3LdrGetInterfaceSymbols.
4474	* @thread EMT
4475	*/
4476	DECLR3CALLBACKMEMBER(int, pfnLdrGetRCInterfaceSymbols,(PPDMDEVINS pDevIns, void *pvInterface, size_t cbInterface,
4477	const char pszSymPrefix, const char pszSymList));
4478
4479	/**
4480	* Resolves the symbol for a ring-0 context interface.
4481	*
4482	* @returns VBox status code.
4483	* @param pDevIns The device instance.
4484	* @param pvInterface The interface structure.
4485	* @param cbInterface The size of the interface structure.
4486	* @param pszSymPrefix What to prefix the symbols in the list with
4487	* before resolving them. This must start with
4488	* 'dev' and contain the driver name.
4489	* @param pszSymList List of symbols corresponding to the interface.
4490	* There is generally a there is generally a define
4491	* holding this list associated with the interface
4492	* definition (INTERFACE_SYM_LIST). For more
4493	* details see PDMR3LdrGetInterfaceSymbols.
4494	* @thread EMT
4495	*/
4496	DECLR3CALLBACKMEMBER(int, pfnLdrGetR0InterfaceSymbols,(PPDMDEVINS pDevIns, void *pvInterface, size_t cbInterface,
4497	const char pszSymPrefix, const char pszSymList));
4498
4499	/**
4500	* Calls the PDMDEVREGR0::pfnRequest callback (in ring-0 context).
4501	*
4502	* @returns VBox status code.
4503	* @retval VERR_INVALID_FUNCTION if the callback member is NULL.
4504	* @retval VERR_ACCESS_DENIED if the device isn't ring-0 capable.
4505	*
4506	* @param pDevIns The device instance.
4507	* @param uOperation The operation to perform.
4508	* @param u64Arg 64-bit integer argument.
4509	* @thread EMT
4510	*/
4511	DECLR3CALLBACKMEMBER(int, pfnCallR0,(PPDMDEVINS pDevIns, uint32_t uOperation, uint64_t u64Arg));
4512
4513	/**
4514	* Gets the reason for the most recent VM suspend.
4515	*
4516	* @returns The suspend reason. VMSUSPENDREASON_INVALID is returned if no
4517	* suspend has been made or if the pDevIns is invalid.
4518	* @param pDevIns The device instance.
4519	*/
4520	DECLR3CALLBACKMEMBER(VMSUSPENDREASON, pfnVMGetSuspendReason,(PPDMDEVINS pDevIns));
4521
4522	/**
4523	* Gets the reason for the most recent VM resume.
4524	*
4525	* @returns The resume reason. VMRESUMEREASON_INVALID is returned if no
4526	* resume has been made or if the pDevIns is invalid.
4527	* @param pDevIns The device instance.
4528	*/
4529	DECLR3CALLBACKMEMBER(VMRESUMEREASON, pfnVMGetResumeReason,(PPDMDEVINS pDevIns));
4530
4531	/**
4532	* Requests the mapping of multiple guest page into ring-3.
4533	*
4534	* When you're done with the pages, call pfnPhysBulkReleasePageMappingLocks()
4535	* ASAP to release them.
4536	*
4537	* This API will assume your intention is to write to the pages, and will
4538	* therefore replace shared and zero pages. If you do not intend to modify the
4539	* pages, use the pfnPhysBulkGCPhys2CCPtrReadOnly() API.
4540	*
4541	* @returns VBox status code.
4542	* @retval VINF_SUCCESS on success.
4543	* @retval VERR_PGM_PHYS_PAGE_RESERVED if any of the pages has no physical
4544	* backing or if any of the pages the page has any active access
4545	* handlers. The caller must fall back on using PGMR3PhysWriteExternal.
4546	* @retval VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS if @a paGCPhysPages contains
4547	* an invalid physical address.
4548	*
4549	* @param pDevIns The device instance.
4550	* @param cPages Number of pages to lock.
4551	* @param paGCPhysPages The guest physical address of the pages that
4552	* should be mapped (@a cPages entries).
4553	* @param fFlags Flags reserved for future use, MBZ.
4554	* @param papvPages Where to store the ring-3 mapping addresses
4555	* corresponding to @a paGCPhysPages.
4556	* @param paLocks Where to store the locking information that
4557	* pfnPhysBulkReleasePageMappingLock needs (@a cPages
4558	* in length).
4559	*
4560	* @remark Avoid calling this API from within critical sections (other than the
4561	* PGM one) because of the deadlock risk when we have to delegating the
4562	* task to an EMT.
4563	* @thread Any.
4564	* @since 6.0.6
4565	*/
4566	DECLR3CALLBACKMEMBER(int, pfnPhysBulkGCPhys2CCPtr,(PPDMDEVINS pDevIns, uint32_t cPages, PCRTGCPHYS paGCPhysPages,
4567	uint32_t fFlags, void **papvPages, PPGMPAGEMAPLOCK paLocks));
4568
4569	/**
4570	* Requests the mapping of multiple guest page into ring-3, for reading only.
4571	*
4572	* When you're done with the pages, call pfnPhysBulkReleasePageMappingLocks()
4573	* ASAP to release them.
4574	*
4575	* @returns VBox status code.
4576	* @retval VINF_SUCCESS on success.
4577	* @retval VERR_PGM_PHYS_PAGE_RESERVED if any of the pages has no physical
4578	* backing or if any of the pages the page has an active ALL access
4579	* handler. The caller must fall back on using PGMR3PhysWriteExternal.
4580	* @retval VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS if @a paGCPhysPages contains
4581	* an invalid physical address.
4582	*
4583	* @param pDevIns The device instance.
4584	* @param cPages Number of pages to lock.
4585	* @param paGCPhysPages The guest physical address of the pages that
4586	* should be mapped (@a cPages entries).
4587	* @param fFlags Flags reserved for future use, MBZ.
4588	* @param papvPages Where to store the ring-3 mapping addresses
4589	* corresponding to @a paGCPhysPages.
4590	* @param paLocks Where to store the lock information that
4591	* pfnPhysReleasePageMappingLock needs (@a cPages
4592	* in length).
4593	*
4594	* @remark Avoid calling this API from within critical sections.
4595	* @thread Any.
4596	* @since 6.0.6
4597	*/
4598	DECLR3CALLBACKMEMBER(int, pfnPhysBulkGCPhys2CCPtrReadOnly,(PPDMDEVINS pDevIns, uint32_t cPages, PCRTGCPHYS paGCPhysPages,
4599	uint32_t fFlags, void const **papvPages, PPGMPAGEMAPLOCK paLocks));
4600
4601	/**
4602	* Release the mappings of multiple guest pages.
4603	*
4604	* This is the counter part of pfnPhysBulkGCPhys2CCPtr and
4605	* pfnPhysBulkGCPhys2CCPtrReadOnly.
4606	*
4607	* @param pDevIns The device instance.
4608	* @param cPages Number of pages to unlock.
4609	* @param paLocks The lock structures initialized by the mapping
4610	* function (@a cPages in length).
4611	* @thread Any.
4612	* @since 6.0.6
4613	*/
4614	DECLR3CALLBACKMEMBER(void, pfnPhysBulkReleasePageMappingLocks,(PPDMDEVINS pDevIns, uint32_t cPages, PPGMPAGEMAPLOCK paLocks));
4615
4616	/**
4617	* Returns the architecture used for the guest.
4618	*
4619	* @returns CPU architecture enum.
4620	* @param pDevIns The device instance.
4621	*/
4622	DECLR3CALLBACKMEMBER(CPUMARCH, pfnCpuGetGuestArch,(PPDMDEVINS pDevIns));
4623
4624	/**
4625	* Returns the micro architecture used for the guest.
4626	*
4627	* @returns CPU micro architecture enum.
4628	* @param pDevIns The device instance.
4629	*/
4630	DECLR3CALLBACKMEMBER(CPUMMICROARCH, pfnCpuGetGuestMicroarch,(PPDMDEVINS pDevIns));
4631
4632	/**
4633	* Get the number of physical and linear address bits supported by the guest.
4634	*
4635	* @param pDevIns The device instance.
4636	* @param pcPhysAddrWidth Where to store the number of physical address bits
4637	* supported by the guest.
4638	* @param pcLinearAddrWidth Where to store the number of linear address bits
4639	* supported by the guest.
4640	*/
4641	DECLR3CALLBACKMEMBER(void, pfnCpuGetGuestAddrWidths,(PPDMDEVINS pDevIns, uint8_t *pcPhysAddrWidth,
4642	uint8_t *pcLinearAddrWidth));
4643
4644	/**
4645	* Gets the scalable bus frequency.
4646	*
4647	* The bus frequency is used as a base in several MSRs that gives the CPU and
4648	* other frequency ratios.
4649	*
4650	* @returns Scalable bus frequency in Hz. Will not return CPUM_SBUSFREQ_UNKNOWN.
4651	* @param pDevIns The device instance.
4652	*/
4653	DECLR3CALLBACKMEMBER(uint64_t, pfnCpuGetGuestScalableBusFrequency,(PPDMDEVINS pDevIns));
4654
4655	/** Space reserved for future members.
4656	* @{ */
4657	/**
4658	* Deregister zero or more samples given their name prefix.
4659	*
4660	* @returns VBox status code.
4661	* @param pDevIns The device instance.
4662	* @param pszPrefix The name prefix of the samples to remove. If this does
4663	* not start with a '/', the default prefix will be
4664	* prepended, otherwise it will be used as-is.
4665	*/
4666	DECLR3CALLBACKMEMBER(int, pfnSTAMDeregisterByPrefix,(PPDMDEVINS pDevIns, const char *pszPrefix));
4667	DECLR3CALLBACKMEMBER(void, pfnReserved2,(void));
4668	DECLR3CALLBACKMEMBER(void, pfnReserved3,(void));
4669	DECLR3CALLBACKMEMBER(void, pfnReserved4,(void));
4670	DECLR3CALLBACKMEMBER(void, pfnReserved5,(void));
4671	DECLR3CALLBACKMEMBER(void, pfnReserved6,(void));
4672	DECLR3CALLBACKMEMBER(void, pfnReserved7,(void));
4673	DECLR3CALLBACKMEMBER(void, pfnReserved8,(void));
4674	DECLR3CALLBACKMEMBER(void, pfnReserved9,(void));
4675	DECLR3CALLBACKMEMBER(void, pfnReserved10,(void));
4676	/** @} */
4677
4678
4679	/** API available to trusted devices only.
4680	*
4681	* These APIs are providing unrestricted access to the guest and the VM,
4682	* or they are interacting intimately with PDM.
4683	*
4684	* @{
4685	*/
4686
4687	/**
4688	* Gets the user mode VM handle. Restricted API.
4689	*
4690	* @returns User mode VM Handle.
4691	* @param pDevIns The device instance.
4692	*/
4693	DECLR3CALLBACKMEMBER(PUVM, pfnGetUVM,(PPDMDEVINS pDevIns));
4694
4695	/**
4696	* Gets the global VM handle. Restricted API.
4697	*
4698	* @returns VM Handle.
4699	* @param pDevIns The device instance.
4700	*/
4701	DECLR3CALLBACKMEMBER(PVMCC, pfnGetVM,(PPDMDEVINS pDevIns));
4702
4703	/**
4704	* Gets the VMCPU handle. Restricted API.
4705	*
4706	* @returns VMCPU Handle.
4707	* @param pDevIns The device instance.
4708	*/
4709	DECLR3CALLBACKMEMBER(PVMCPU, pfnGetVMCPU,(PPDMDEVINS pDevIns));
4710
4711	/**
4712	* The the VM CPU ID of the current thread (restricted API).
4713	*
4714	* @returns The VMCPUID of the calling thread, NIL_VMCPUID if not EMT.
4715	* @param pDevIns The device instance.
4716	*/
4717	DECLR3CALLBACKMEMBER(VMCPUID, pfnGetCurrentCpuId,(PPDMDEVINS pDevIns));
4718
4719	/**
4720	* Registers the VMM device heap or notifies about mapping/unmapping.
4721	*
4722	* This interface serves three purposes:
4723	*
4724	* -# Register the VMM device heap during device construction
4725	* for the HM to use.
4726	* -# Notify PDM/HM that it's mapped into guest address
4727	* space (i.e. usable).
4728	* -# Notify PDM/HM that it is being unmapped from the guest
4729	* address space (i.e. not usable).
4730	*
4731	* @returns VBox status code.
4732	* @param pDevIns The device instance.
4733	* @param GCPhys The physical address if mapped, NIL_RTGCPHYS if
4734	* not mapped.
4735	* @param pvHeap Ring 3 heap pointer.
4736	* @param cbHeap Size of the heap.
4737	* @thread EMT.
4738	*/
4739	DECLR3CALLBACKMEMBER(int, pfnRegisterVMMDevHeap,(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, RTR3PTR pvHeap, unsigned cbHeap));
4740
4741	/**
4742	* Registers the firmware (BIOS, EFI) device with PDM.
4743	*
4744	* The firmware provides a callback table and gets a special PDM helper table.
4745	* There can only be one firmware device for a VM.
4746	*
4747	* @returns VBox status code.
4748	* @param pDevIns The device instance.
4749	* @param pFwReg Firmware registration structure.
4750	* @param ppFwHlp Where to return the firmware helper structure.
4751	* @remarks Only valid during device construction.
4752	* @thread EMT(0)
4753	*/
4754	DECLR3CALLBACKMEMBER(int, pfnFirmwareRegister,(PPDMDEVINS pDevIns, PCPDMFWREG pFwReg, PCPDMFWHLPR3 *ppFwHlp));
4755
4756	/**
4757	* Resets the VM.
4758	*
4759	* @returns The appropriate VBox status code to pass around on reset.
4760	* @param pDevIns The device instance.
4761	* @param fFlags PDMVMRESET_F_XXX flags.
4762	* @thread The emulation thread.
4763	*/
4764	DECLR3CALLBACKMEMBER(int, pfnVMReset,(PPDMDEVINS pDevIns, uint32_t fFlags));
4765
4766	/**
4767	* Suspends the VM.
4768	*
4769	* @returns The appropriate VBox status code to pass around on suspend.
4770	* @param pDevIns The device instance.
4771	* @thread The emulation thread.
4772	*/
4773	DECLR3CALLBACKMEMBER(int, pfnVMSuspend,(PPDMDEVINS pDevIns));
4774
4775	/**
4776	* Suspends, saves and powers off the VM.
4777	*
4778	* @returns The appropriate VBox status code to pass around.
4779	* @param pDevIns The device instance.
4780	* @thread An emulation thread.
4781	*/
4782	DECLR3CALLBACKMEMBER(int, pfnVMSuspendSaveAndPowerOff,(PPDMDEVINS pDevIns));
4783
4784	/**
4785	* Power off the VM.
4786	*
4787	* @returns The appropriate VBox status code to pass around on power off.
4788	* @param pDevIns The device instance.
4789	* @thread The emulation thread.
4790	*/
4791	DECLR3CALLBACKMEMBER(int, pfnVMPowerOff,(PPDMDEVINS pDevIns));
4792
4793	/**
4794	* Checks if the Gate A20 is enabled or not.
4795	*
4796	* @returns true if A20 is enabled.
4797	* @returns false if A20 is disabled.
4798	* @param pDevIns The device instance.
4799	* @thread The emulation thread.
4800	*/
4801	DECLR3CALLBACKMEMBER(bool, pfnA20IsEnabled,(PPDMDEVINS pDevIns));
4802
4803	/**
4804	* Enables or disables the Gate A20.
4805	*
4806	* @param pDevIns The device instance.
4807	* @param fEnable Set this flag to enable the Gate A20; clear it
4808	* to disable.
4809	* @thread The emulation thread.
4810	*/
4811	DECLR3CALLBACKMEMBER(void, pfnA20Set,(PPDMDEVINS pDevIns, bool fEnable));
4812
4813	/**
4814	* Get the specified CPUID leaf for the virtual CPU associated with the calling
4815	* thread.
4816	*
4817	* @param pDevIns The device instance.
4818	* @param iLeaf The CPUID leaf to get.
4819	* @param pEax Where to store the EAX value.
4820	* @param pEbx Where to store the EBX value.
4821	* @param pEcx Where to store the ECX value.
4822	* @param pEdx Where to store the EDX value.
4823	* @thread EMT.
4824	*/
4825	DECLR3CALLBACKMEMBER(void, pfnGetCpuId,(PPDMDEVINS pDevIns, uint32_t iLeaf, uint32_t pEax, uint32_t pEbx, uint32_t pEcx, uint32_t pEdx));
4826
4827	/**
4828	* Gets the main execution engine for the VM.
4829	*
4830	* @returns VM_EXEC_ENGINE_XXX
4831	* @param pDevIns The device instance.
4832	*/
4833	DECLR3CALLBACKMEMBER(uint8_t, pfnGetMainExecutionEngine,(PPDMDEVINS pDevIns));
4834
4835	/**
4836	* Get the current virtual clock time in a VM. The clock frequency must be
4837	* queried separately.
4838	*
4839	* @returns Current clock time.
4840	* @param pDevIns The device instance.
4841	*/
4842	DECLR3CALLBACKMEMBER(uint64_t, pfnTMTimeVirtGet,(PPDMDEVINS pDevIns));
4843
4844	/**
4845	* Get the frequency of the virtual clock.
4846	*
4847	* @returns The clock frequency (not variable at run-time).
4848	* @param pDevIns The device instance.
4849	*/
4850	DECLR3CALLBACKMEMBER(uint64_t, pfnTMTimeVirtGetFreq,(PPDMDEVINS pDevIns));
4851
4852	/**
4853	* Get the current virtual clock time in a VM, in nanoseconds.
4854	*
4855	* @returns Current clock time (in ns).
4856	* @param pDevIns The device instance.
4857	*/
4858	DECLR3CALLBACKMEMBER(uint64_t, pfnTMTimeVirtGetNano,(PPDMDEVINS pDevIns));
4859
4860	/**
4861	* Get the timestamp frequency.
4862	*
4863	* @returns Number of ticks per second.
4864	* @param pDevIns The device instance.
4865	*/
4866	DECLR3CALLBACKMEMBER(uint64_t, pfnTMCpuTicksPerSecond,(PPDMDEVINS pDevIns));
4867
4868	/**
4869	* Gets the support driver session.
4870	*
4871	* This is intended for working with the semaphore API.
4872	*
4873	* @returns Support driver session handle.
4874	* @param pDevIns The device instance.
4875	*/
4876	DECLR3CALLBACKMEMBER(PSUPDRVSESSION, pfnGetSupDrvSession,(PPDMDEVINS pDevIns));
4877
4878	/**
4879	* Queries a generic object from the VMM user.
4880	*
4881	* @returns Pointer to the object if found, NULL if not.
4882	* @param pDevIns The device instance.
4883	* @param pUuid The UUID of what's being queried. The UUIDs and
4884	* the usage conventions are defined by the user.
4885	*
4886	* @note It is strictly forbidden to call this internally in VBox! This
4887	* interface is exclusively for hacks in externally developed devices.
4888	*/
4889	DECLR3CALLBACKMEMBER(void *, pfnQueryGenericUserObject,(PPDMDEVINS pDevIns, PCRTUUID pUuid));
4890
4891	/**
4892	* Register a physical page access handler type.
4893	*
4894	* @returns VBox status code.
4895	* @param pDevIns The device instance.
4896	* @param enmKind The kind of access handler.
4897	* @param pfnHandler Pointer to the ring-3 handler callback.
4898	* @param pszDesc The type description.
4899	* @param phType Where to return the type handle (cross context safe).
4900	* @sa PDMDevHlpPGMHandlerPhysicalTypeSetUpContext
4901	*/
4902	DECLR3CALLBACKMEMBER(int, pfnPGMHandlerPhysicalTypeRegister, (PPDMDEVINS pDevIns, PGMPHYSHANDLERKIND enmKind,
4903	PFNPGMPHYSHANDLER pfnHandler,
4904	const char *pszDesc, PPGMPHYSHANDLERTYPE phType));
4905
4906	/**
4907	* Register a access handler for a physical range.
4908	*
4909	* @returns VBox status code.
4910	* @retval VINF_SUCCESS when successfully installed.
4911	* @retval VINF_PGM_GCPHYS_ALIASED when the shadow PTs could be updated because
4912	* the guest page aliased or/and mapped by multiple PTs. A CR3 sync has been
4913	* flagged together with a pool clearing.
4914	* @retval VERR_PGM_HANDLER_PHYSICAL_CONFLICT if the range conflicts with an existing
4915	* one. A debug assertion is raised.
4916	*
4917	* @param pDevIns The device instance.
4918	* @param GCPhys Start physical address.
4919	* @param GCPhysLast Last physical address. (inclusive)
4920	* @param hType The handler type registration handle.
4921	* @param pszDesc Description of this handler. If NULL, the type
4922	* description will be used instead.
4923	* @note There is no @a uUser argument, because it will be set to the pDevIns
4924	* in the context the handler is called.
4925	*/
4926	DECLR3CALLBACKMEMBER(int, pfnPGMHandlerPhysicalRegister, (PPDMDEVINS pDevIns, RTGCPHYS GCPhys, RTGCPHYS GCPhysLast,
4927	PGMPHYSHANDLERTYPE hType, R3PTRTYPE(const char *) pszDesc));
4928
4929	/**
4930	* Deregister a physical page access handler.
4931	*
4932	* @returns VBox status code.
4933	* @param pDevIns The device instance.
4934	* @param GCPhys Start physical address.
4935	*/
4936	DECLR3CALLBACKMEMBER(int, pfnPGMHandlerPhysicalDeregister,(PPDMDEVINS pDevIns, RTGCPHYS GCPhys));
4937
4938	/**
4939	* Temporarily turns off the access monitoring of a page within a monitored
4940	* physical write/all page access handler region.
4941	*
4942	* Use this when no further \#PFs are required for that page. Be aware that
4943	* a page directory sync might reset the flags, and turn on access monitoring
4944	* for the page.
4945	*
4946	* The caller must do required page table modifications.
4947	*
4948	* @returns VBox status code.
4949	* @param pDevIns The device instance.
4950	* @param GCPhys The start address of the access handler. This
4951	* must be a fully page aligned range or we risk
4952	* messing up other handlers installed for the
4953	* start and end pages.
4954	* @param GCPhysPage The physical address of the page to turn off
4955	* access monitoring for.
4956	*/
4957	DECLR3CALLBACKMEMBER(int, pfnPGMHandlerPhysicalPageTempOff,(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, RTGCPHYS GCPhysPage));
4958
4959	/**
4960	* Resets any modifications to individual pages in a physical page access
4961	* handler region.
4962	*
4963	* This is used in pair with PGMHandlerPhysicalPageTempOff(),
4964	* PGMHandlerPhysicalPageAliasMmio2() or PGMHandlerPhysicalPageAliasHC().
4965	*
4966	* @returns VBox status code.
4967	* @param pDevIns The device instance.
4968	* @param GCPhys The start address of the handler regions, i.e. what you
4969	* passed to PGMR3HandlerPhysicalRegister(),
4970	* PGMHandlerPhysicalRegisterEx() or
4971	* PGMHandlerPhysicalModify().
4972	*/
4973	DECLR3CALLBACKMEMBER(int, pfnPGMHandlerPhysicalReset,(PPDMDEVINS pDevIns, RTGCPHYS GCPhys));
4974
4975	/**
4976	* Registers the guest memory range that can be used for patching.
4977	*
4978	* @returns VBox status code.
4979	* @param pDevIns The device instance.
4980	* @param GCPtrPatchMem Patch memory range.
4981	* @param cbPatchMem Size of the memory range.
4982	*/
4983	DECLR3CALLBACKMEMBER(int, pfnVMMRegisterPatchMemory, (PPDMDEVINS pDevIns, RTGCPTR GCPtrPatchMem, uint32_t cbPatchMem));
4984
4985	/**
4986	* Deregisters the guest memory range that can be used for patching.
4987	*
4988	* @returns VBox status code.
4989	* @param pDevIns The device instance.
4990	* @param GCPtrPatchMem Patch memory range.
4991	* @param cbPatchMem Size of the memory range.
4992	*/
4993	DECLR3CALLBACKMEMBER(int, pfnVMMDeregisterPatchMemory, (PPDMDEVINS pDevIns, RTGCPTR GCPtrPatchMem, uint32_t cbPatchMem));
4994
4995	/**
4996	* Registers a new shared module for the VM
4997	*
4998	* @returns VBox status code.
4999	* @param pDevIns The device instance.
5000	* @param enmGuestOS Guest OS type.
5001	* @param pszModuleName Module name.
5002	* @param pszVersion Module version.
5003	* @param GCBaseAddr Module base address.
5004	* @param cbModule Module size.
5005	* @param cRegions Number of shared region descriptors.
5006	* @param paRegions Shared region(s).
5007	*/
5008	DECLR3CALLBACKMEMBER(int, pfnSharedModuleRegister,(PPDMDEVINS pDevIns, VBOXOSFAMILY enmGuestOS, char pszModuleName, char pszVersion,
5009	RTGCPTR GCBaseAddr, uint32_t cbModule,
5010	uint32_t cRegions, VMMDEVSHAREDREGIONDESC const *paRegions));
5011
5012	/**
5013	* Unregisters a shared module for the VM
5014	*
5015	* @returns VBox status code.
5016	* @param pDevIns The device instance.
5017	* @param pszModuleName Module name.
5018	* @param pszVersion Module version.
5019	* @param GCBaseAddr Module base address.
5020	* @param cbModule Module size.
5021	*/
5022	DECLR3CALLBACKMEMBER(int, pfnSharedModuleUnregister,(PPDMDEVINS pDevIns, char pszModuleName, char pszVersion,
5023	RTGCPTR GCBaseAddr, uint32_t cbModule));
5024
5025	/**
5026	* Query the state of a page in a shared module
5027	*
5028	* @returns VBox status code.
5029	* @param pDevIns The device instance.
5030	* @param GCPtrPage Page address.
5031	* @param pfShared Shared status (out).
5032	* @param pfPageFlags Page flags (out).
5033	*/
5034	DECLR3CALLBACKMEMBER(int, pfnSharedModuleGetPageState, (PPDMDEVINS pDevIns, RTGCPTR GCPtrPage, bool pfShared, uint64_t pfPageFlags));
5035
5036	/**
5037	* Check all registered modules for changes.
5038	*
5039	* @returns VBox status code.
5040	* @param pDevIns The device instance.
5041	*/
5042	DECLR3CALLBACKMEMBER(int, pfnSharedModuleCheckAll,(PPDMDEVINS pDevIns));
5043
5044	/**
5045	* Query the interface of the top level driver on a LUN.
5046	*
5047	* @returns VBox status code.
5048	* @param pDevIns The device instance.
5049	* @param pszDevice Device name.
5050	* @param iInstance Device instance.
5051	* @param iLun The Logical Unit to obtain the interface of.
5052	* @param ppBase Where to store the base interface pointer.
5053	*
5054	* @remark We're not doing any locking ATM, so don't try call this at times when the
5055	* device chain is known to be updated.
5056	*/
5057	DECLR3CALLBACKMEMBER(int, pfnQueryLun,(PPDMDEVINS pDevIns, const char *pszDevice, unsigned iInstance, unsigned iLun, PPPDMIBASE ppBase));
5058
5059	/**
5060	* Registers the GIM device with VMM.
5061	*
5062	* @param pDevIns Pointer to the GIM device instance.
5063	* @param pDbg Pointer to the GIM device debug structure, can be
5064	* NULL.
5065	*/
5066	DECLR3CALLBACKMEMBER(void, pfnGIMDeviceRegister,(PPDMDEVINS pDevIns, PGIMDEBUG pDbg));
5067
5068	/**
5069	* Gets debug setup specified by the provider.
5070	*
5071	* @returns VBox status code.
5072	* @param pDevIns Pointer to the GIM device instance.
5073	* @param pDbgSetup Where to store the debug setup details.
5074	*/
5075	DECLR3CALLBACKMEMBER(int, pfnGIMGetDebugSetup,(PPDMDEVINS pDevIns, PGIMDEBUGSETUP pDbgSetup));
5076
5077	/**
5078	* Returns the array of MMIO2 regions that are expected to be registered and
5079	* later mapped into the guest-physical address space for the GIM provider
5080	* configured for the VM.
5081	*
5082	* @returns Pointer to an array of GIM MMIO2 regions, may return NULL.
5083	* @param pDevIns Pointer to the GIM device instance.
5084	* @param pcRegions Where to store the number of items in the array.
5085	*
5086	* @remarks The caller does not own and therefore must -NOT- try to free the
5087	* returned pointer.
5088	*/
5089	DECLR3CALLBACKMEMBER(PGIMMMIO2REGION, pfnGIMGetMmio2Regions,(PPDMDEVINS pDevIns, uint32_t *pcRegions));
5090
5091	/** @} */
5092
5093	/** Just a safety precaution. (PDM_DEVHLPR3_VERSION) */
5094	uint32_t u32TheEnd;
5095	} PDMDEVHLPR3;
5096	#endif /* !IN_RING3 \|\| DOXYGEN_RUNNING */
5097	/** Pointer to the R3 PDM Device API. */
5098	typedef R3PTRTYPE(struct PDMDEVHLPR3 *) PPDMDEVHLPR3;
5099	/** Pointer to the R3 PDM Device API, const variant. */
5100	typedef R3PTRTYPE(const struct PDMDEVHLPR3 *) PCPDMDEVHLPR3;
5101
5102
5103	/**
5104	* PDM Device API - RC Variant.
5105	*/
5106	typedef struct PDMDEVHLPRC
5107	{
5108	/** Structure version. PDM_DEVHLPRC_VERSION defines the current version. */
5109	uint32_t u32Version;
5110
5111	/**
5112	* Sets up raw-mode context callback handlers for an I/O port range.
5113	*
5114	* The range must have been registered in ring-3 first using
5115	* PDMDevHlpIoPortCreate() or PDMDevHlpIoPortCreateEx().
5116	*
5117	* @returns VBox status.
5118	* @param pDevIns The device instance to register the ports with.
5119	* @param hIoPorts The I/O port range handle.
5120	* @param pfnOut Pointer to function which is gonna handle OUT
5121	* operations. Optional.
5122	* @param pfnIn Pointer to function which is gonna handle IN operations.
5123	* Optional.
5124	* @param pfnOutStr Pointer to function which is gonna handle string OUT
5125	* operations. Optional.
5126	* @param pfnInStr Pointer to function which is gonna handle string IN
5127	* operations. Optional.
5128	* @param pvUser User argument to pass to the callbacks.
5129	*
5130	* @remarks Caller enters the device critical section prior to invoking the
5131	* registered callback methods.
5132	*
5133	* @sa PDMDevHlpIoPortCreate, PDMDevHlpIoPortCreateEx, PDMDevHlpIoPortMap,
5134	* PDMDevHlpIoPortUnmap.
5135	*/
5136	DECLRCCALLBACKMEMBER(int, pfnIoPortSetUpContextEx,(PPDMDEVINS pDevIns, IOMIOPORTHANDLE hIoPorts,
5137	PFNIOMIOPORTNEWOUT pfnOut, PFNIOMIOPORTNEWIN pfnIn,
5138	PFNIOMIOPORTNEWOUTSTRING pfnOutStr, PFNIOMIOPORTNEWINSTRING pfnInStr,
5139	void *pvUser));
5140
5141	/**
5142	* Sets up raw-mode context callback handlers for an MMIO region.
5143	*
5144	* The region must have been registered in ring-3 first using
5145	* PDMDevHlpMmioCreate() or PDMDevHlpMmioCreateEx().
5146	*
5147	* @returns VBox status.
5148	* @param pDevIns The device instance to register the ports with.
5149	* @param hRegion The MMIO region handle.
5150	* @param pfnWrite Pointer to function which is gonna handle Write
5151	* operations.
5152	* @param pfnRead Pointer to function which is gonna handle Read
5153	* operations.
5154	* @param pfnFill Pointer to function which is gonna handle Fill/memset
5155	* operations. (optional)
5156	* @param pvUser User argument to pass to the callbacks.
5157	*
5158	* @remarks Caller enters the device critical section prior to invoking the
5159	* registered callback methods.
5160	*
5161	* @sa PDMDevHlpMmioCreate, PDMDevHlpMmioCreateEx, PDMDevHlpMmioMap,
5162	* PDMDevHlpMmioUnmap.
5163	*/
5164	DECLRCCALLBACKMEMBER(int, pfnMmioSetUpContextEx,(PPDMDEVINS pDevIns, IOMMMIOHANDLE hRegion, PFNIOMMMIONEWWRITE pfnWrite,
5165	PFNIOMMMIONEWREAD pfnRead, PFNIOMMMIONEWFILL pfnFill, void *pvUser));
5166
5167	/**
5168	* Sets up a raw-mode mapping for an MMIO2 region.
5169	*
5170	* The region must have been created in ring-3 first using
5171	* PDMDevHlpMmio2Create().
5172	*
5173	* @returns VBox status.
5174	* @param pDevIns The device instance to register the ports with.
5175	* @param hRegion The MMIO2 region handle.
5176	* @param offSub Start of what to map into raw-mode. Must be page aligned.
5177	* @param cbSub Number of bytes to map into raw-mode. Must be page
5178	* aligned. Zero is an alias for everything.
5179	* @param ppvMapping Where to return the mapping corresponding to @a offSub.
5180	* @thread EMT(0)
5181	* @note Only available at VM creation time.
5182	*
5183	* @sa PDMDevHlpMmio2Create().
5184	*/
5185	DECLRCCALLBACKMEMBER(int, pfnMmio2SetUpContext,(PPDMDEVINS pDevIns, PGMMMIO2HANDLE hRegion,
5186	size_t offSub, size_t cbSub, void **ppvMapping));
5187
5188	/**
5189	* Bus master physical memory read from the given PCI device.
5190	*
5191	* @returns VINF_SUCCESS or VERR_PGM_PCI_PHYS_READ_BM_DISABLED, later maybe
5192	* VERR_EM_MEMORY. The informational status shall NOT be propagated!
5193	* @param pDevIns The device instance.
5194	* @param pPciDev The PCI device structure. If NULL the default
5195	* PCI device for this device instance is used.
5196	* @param GCPhys Physical address start reading from.
5197	* @param pvBuf Where to put the read bits.
5198	* @param cbRead How many bytes to read.
5199	* @param fFlags Combination of PDM_DEVHLP_PHYS_RW_F_XXX.
5200	* @thread Any thread, but the call may involve the emulation thread.
5201	*/
5202	DECLRCCALLBACKMEMBER(int, pfnPCIPhysRead,(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, RTGCPHYS GCPhys,
5203	void *pvBuf, size_t cbRead, uint32_t fFlags));
5204
5205	/**
5206	* Bus master physical memory write from the given PCI device.
5207	*
5208	* @returns VINF_SUCCESS or VERR_PGM_PCI_PHYS_WRITE_BM_DISABLED, later maybe
5209	* VERR_EM_MEMORY. The informational status shall NOT be propagated!
5210	* @param pDevIns The device instance.
5211	* @param pPciDev The PCI device structure. If NULL the default
5212	* PCI device for this device instance is used.
5213	* @param GCPhys Physical address to write to.
5214	* @param pvBuf What to write.
5215	* @param cbWrite How many bytes to write.
5216	* @param fFlags Combination of PDM_DEVHLP_PHYS_RW_F_XXX.
5217	* @thread Any thread, but the call may involve the emulation thread.
5218	*/
5219	DECLRCCALLBACKMEMBER(int, pfnPCIPhysWrite,(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, RTGCPHYS GCPhys,
5220	const void *pvBuf, size_t cbWrite, uint32_t fFlags));
5221
5222	/**
5223	* Set the IRQ for the given PCI device.
5224	*
5225	* @param pDevIns Device instance.
5226	* @param pPciDev The PCI device structure. If NULL the default
5227	* PCI device for this device instance is used.
5228	* @param iIrq IRQ number to set.
5229	* @param iLevel IRQ level. See the PDM_IRQ_LEVEL_* \#defines.
5230	* @thread Any thread, but will involve the emulation thread.
5231	*/
5232	DECLRCCALLBACKMEMBER(void, pfnPCISetIrq,(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, int iIrq, int iLevel));
5233
5234	/**
5235	* Set ISA IRQ for a device.
5236	*
5237	* @param pDevIns Device instance.
5238	* @param iIrq IRQ number to set.
5239	* @param iLevel IRQ level. See the PDM_IRQ_LEVEL_* \#defines.
5240	* @thread Any thread, but will involve the emulation thread.
5241	*/
5242	DECLRCCALLBACKMEMBER(void, pfnISASetIrq,(PPDMDEVINS pDevIns, int iIrq, int iLevel));
5243
5244	/**
5245	* Read physical memory.
5246	*
5247	* @returns VINF_SUCCESS (for now).
5248	* @param pDevIns Device instance.
5249	* @param GCPhys Physical address start reading from.
5250	* @param pvBuf Where to put the read bits.
5251	* @param cbRead How many bytes to read.
5252	* @param fFlags Combination of PDM_DEVHLP_PHYS_RW_F_XXX.
5253	*/
5254	DECLRCCALLBACKMEMBER(int, pfnPhysRead,(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, void *pvBuf, size_t cbRead, uint32_t fFlags));
5255
5256	/**
5257	* Write to physical memory.
5258	*
5259	* @returns VINF_SUCCESS for now, and later maybe VERR_EM_MEMORY.
5260	* @param pDevIns Device instance.
5261	* @param GCPhys Physical address to write to.
5262	* @param pvBuf What to write.
5263	* @param cbWrite How many bytes to write.
5264	* @param fFlags Combination of PDM_DEVHLP_PHYS_RW_F_XXX.
5265	*/
5266	DECLRCCALLBACKMEMBER(int, pfnPhysWrite,(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, const void *pvBuf, size_t cbWrite, uint32_t fFlags));
5267
5268	/**
5269	* Checks if the Gate A20 is enabled or not.
5270	*
5271	* @returns true if A20 is enabled.
5272	* @returns false if A20 is disabled.
5273	* @param pDevIns Device instance.
5274	* @thread The emulation thread.
5275	*/
5276	DECLRCCALLBACKMEMBER(bool, pfnA20IsEnabled,(PPDMDEVINS pDevIns));
5277
5278	/**
5279	* Gets the VM state.
5280	*
5281	* @returns VM state.
5282	* @param pDevIns The device instance.
5283	* @thread Any thread (just keep in mind that it's volatile info).
5284	*/
5285	DECLRCCALLBACKMEMBER(VMSTATE, pfnVMState, (PPDMDEVINS pDevIns));
5286
5287	/**
5288	* Gets the VM handle. Restricted API.
5289	*
5290	* @returns VM Handle.
5291	* @param pDevIns Device instance.
5292	*/
5293	DECLRCCALLBACKMEMBER(PVMCC, pfnGetVM,(PPDMDEVINS pDevIns));
5294
5295	/**
5296	* Gets the VMCPU handle. Restricted API.
5297	*
5298	* @returns VMCPU Handle.
5299	* @param pDevIns The device instance.
5300	*/
5301	DECLRCCALLBACKMEMBER(PVMCPUCC, pfnGetVMCPU,(PPDMDEVINS pDevIns));
5302
5303	/**
5304	* The the VM CPU ID of the current thread (restricted API).
5305	*
5306	* @returns The VMCPUID of the calling thread, NIL_VMCPUID if not EMT.
5307	* @param pDevIns The device instance.
5308	*/
5309	DECLRCCALLBACKMEMBER(VMCPUID, pfnGetCurrentCpuId,(PPDMDEVINS pDevIns));
5310
5311	/**
5312	* Gets the main execution engine for the VM.
5313	*
5314	* @returns VM_EXEC_ENGINE_XXX
5315	* @param pDevIns The device instance.
5316	*/
5317	DECLRCCALLBACKMEMBER(uint8_t, pfnGetMainExecutionEngine,(PPDMDEVINS pDevIns));
5318
5319	/**
5320	* Get the current virtual clock time in a VM. The clock frequency must be
5321	* queried separately.
5322	*
5323	* @returns Current clock time.
5324	* @param pDevIns The device instance.
5325	*/
5326	DECLRCCALLBACKMEMBER(uint64_t, pfnTMTimeVirtGet,(PPDMDEVINS pDevIns));
5327
5328	/**
5329	* Get the frequency of the virtual clock.
5330	*
5331	* @returns The clock frequency (not variable at run-time).
5332	* @param pDevIns The device instance.
5333	*/
5334	DECLRCCALLBACKMEMBER(uint64_t, pfnTMTimeVirtGetFreq,(PPDMDEVINS pDevIns));
5335
5336	/**
5337	* Get the current virtual clock time in a VM, in nanoseconds.
5338	*
5339	* @returns Current clock time (in ns).
5340	* @param pDevIns The device instance.
5341	*/
5342	DECLRCCALLBACKMEMBER(uint64_t, pfnTMTimeVirtGetNano,(PPDMDEVINS pDevIns));
5343
5344	/**
5345	* Gets the NOP critical section.
5346	*
5347	* @returns The ring-3 address of the NOP critical section.
5348	* @param pDevIns The device instance.
5349	*/
5350	DECLRCCALLBACKMEMBER(PPDMCRITSECT, pfnCritSectGetNop,(PPDMDEVINS pDevIns));
5351
5352	/**
5353	* Changes the device level critical section from the automatically created
5354	* default to one desired by the device constructor.
5355	*
5356	* Must first be done in ring-3.
5357	*
5358	* @returns VBox status code.
5359	* @param pDevIns The device instance.
5360	* @param pCritSect The critical section to use. NULL is not
5361	* valid, instead use the NOP critical
5362	* section.
5363	*/
5364	DECLRCCALLBACKMEMBER(int, pfnSetDeviceCritSect,(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect));
5365
5366	/** @name Exported PDM Critical Section Functions
5367	* @{ */
5368	DECLRCCALLBACKMEMBER(int, pfnCritSectEnter,(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect, int rcBusy));
5369	DECLRCCALLBACKMEMBER(int, pfnCritSectEnterDebug,(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect, int rcBusy, RTHCUINTPTR uId, RT_SRC_POS_DECL));
5370	DECLRCCALLBACKMEMBER(int, pfnCritSectTryEnter,(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect));
5371	DECLRCCALLBACKMEMBER(int, pfnCritSectTryEnterDebug,(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect, RTHCUINTPTR uId, RT_SRC_POS_DECL));
5372	DECLRCCALLBACKMEMBER(int, pfnCritSectLeave,(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect));
5373	DECLRCCALLBACKMEMBER(bool, pfnCritSectIsOwner,(PPDMDEVINS pDevIns, PCPDMCRITSECT pCritSect));
5374	DECLRCCALLBACKMEMBER(bool, pfnCritSectIsInitialized,(PPDMDEVINS pDevIns, PCPDMCRITSECT pCritSect));
5375	DECLRCCALLBACKMEMBER(bool, pfnCritSectHasWaiters,(PPDMDEVINS pDevIns, PCPDMCRITSECT pCritSect));
5376	DECLRCCALLBACKMEMBER(uint32_t, pfnCritSectGetRecursion,(PPDMDEVINS pDevIns, PCPDMCRITSECT pCritSect));
5377	/** @} */
5378
5379	/** @name Exported PDM Read/Write Critical Section Functions
5380	* @{ */
5381	DECLRCCALLBACKMEMBER(int, pfnCritSectRwEnterShared,(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect, int rcBusy));
5382	DECLRCCALLBACKMEMBER(int, pfnCritSectRwEnterSharedDebug,(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect, int rcBusy, RTHCUINTPTR uId, RT_SRC_POS_DECL));
5383	DECLRCCALLBACKMEMBER(int, pfnCritSectRwTryEnterShared,(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect));
5384	DECLRCCALLBACKMEMBER(int, pfnCritSectRwTryEnterSharedDebug,(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect, RTHCUINTPTR uId, RT_SRC_POS_DECL));
5385	DECLRCCALLBACKMEMBER(int, pfnCritSectRwLeaveShared,(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect));
5386
5387	DECLRCCALLBACKMEMBER(int, pfnCritSectRwEnterExcl,(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect, int rcBusy));
5388	DECLRCCALLBACKMEMBER(int, pfnCritSectRwEnterExclDebug,(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect, int rcBusy, RTHCUINTPTR uId, RT_SRC_POS_DECL));
5389	DECLRCCALLBACKMEMBER(int, pfnCritSectRwTryEnterExcl,(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect));
5390	DECLRCCALLBACKMEMBER(int, pfnCritSectRwTryEnterExclDebug,(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect, RTHCUINTPTR uId, RT_SRC_POS_DECL));
5391	DECLRCCALLBACKMEMBER(int, pfnCritSectRwLeaveExcl,(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect));
5392
5393	DECLRCCALLBACKMEMBER(bool, pfnCritSectRwIsWriteOwner,(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect));
5394	DECLRCCALLBACKMEMBER(bool, pfnCritSectRwIsReadOwner,(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect, bool fWannaHear));
5395	DECLRCCALLBACKMEMBER(uint32_t, pfnCritSectRwGetWriteRecursion,(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect));
5396	DECLRCCALLBACKMEMBER(uint32_t, pfnCritSectRwGetWriterReadRecursion,(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect));
5397	DECLRCCALLBACKMEMBER(uint32_t, pfnCritSectRwGetReadCount,(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect));
5398	DECLRCCALLBACKMEMBER(bool, pfnCritSectRwIsInitialized,(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect));
5399	/** @} */
5400
5401	/**
5402	* Gets the trace buffer handle.
5403	*
5404	* This is used by the macros found in VBox/vmm/dbgftrace.h and is not
5405	* really inteded for direct usage, thus no inline wrapper function.
5406	*
5407	* @returns Trace buffer handle or NIL_RTTRACEBUF.
5408	* @param pDevIns The device instance.
5409	*/
5410	DECLRCCALLBACKMEMBER(RTTRACEBUF, pfnDBGFTraceBuf,(PPDMDEVINS pDevIns));
5411
5412	/**
5413	* Sets up the PCI bus for the raw-mode context.
5414	*
5415	* This must be called after ring-3 has registered the PCI bus using
5416	* PDMDevHlpPCIBusRegister().
5417	*
5418	* @returns VBox status code.
5419	* @param pDevIns The device instance.
5420	* @param pPciBusReg The PCI bus registration information for raw-mode,
5421	* considered volatile.
5422	* @param ppPciHlp Where to return the raw-mode PCI bus helpers.
5423	*/
5424	DECLRCCALLBACKMEMBER(int, pfnPCIBusSetUpContext,(PPDMDEVINS pDevIns, PPDMPCIBUSREGRC pPciBusReg, PCPDMPCIHLPRC *ppPciHlp));
5425
5426	/**
5427	* Sets up the IOMMU for the raw-mode context.
5428	*
5429	* This must be called after ring-3 has registered the IOMMU using
5430	* PDMDevHlpIommuRegister().
5431	*
5432	* @returns VBox status code.
5433	* @param pDevIns The device instance.
5434	* @param pIommuReg The IOMMU registration information for raw-mode,
5435	* considered volatile.
5436	* @param ppIommuHlp Where to return the raw-mode IOMMU helpers.
5437	*/
5438	DECLRCCALLBACKMEMBER(int, pfnIommuSetUpContext,(PPDMDEVINS pDevIns, PPDMIOMMUREGRC pIommuReg, PCPDMIOMMUHLPRC *ppIommuHlp));
5439
5440	/**
5441	* Sets up the PIC for the ring-0 context.
5442	*
5443	* This must be called after ring-3 has registered the PIC using
5444	* PDMDevHlpPICRegister().
5445	*
5446	* @returns VBox status code.
5447	* @param pDevIns The device instance.
5448	* @param pPicReg The PIC registration information for ring-0,
5449	* considered volatile and copied.
5450	* @param ppPicHlp Where to return the ring-0 PIC helpers.
5451	*/
5452	DECLRCCALLBACKMEMBER(int, pfnPICSetUpContext,(PPDMDEVINS pDevIns, PPDMPICREG pPicReg, PCPDMPICHLP *ppPicHlp));
5453
5454	/**
5455	* Sets up the APIC for the raw-mode context.
5456	*
5457	* This must be called after ring-3 has registered the APIC using
5458	* PDMDevHlpApicRegister().
5459	*
5460	* @returns VBox status code.
5461	* @param pDevIns The device instance.
5462	*/
5463	DECLRCCALLBACKMEMBER(int, pfnApicSetUpContext,(PPDMDEVINS pDevIns));
5464
5465	/**
5466	* Sets up the IOAPIC for the ring-0 context.
5467	*
5468	* This must be called after ring-3 has registered the PIC using
5469	* PDMDevHlpIoApicRegister().
5470	*
5471	* @returns VBox status code.
5472	* @param pDevIns The device instance.
5473	* @param pIoApicReg The PIC registration information for ring-0,
5474	* considered volatile and copied.
5475	* @param ppIoApicHlp Where to return the ring-0 IOAPIC helpers.
5476	*/
5477	DECLRCCALLBACKMEMBER(int, pfnIoApicSetUpContext,(PPDMDEVINS pDevIns, PPDMIOAPICREG pIoApicReg, PCPDMIOAPICHLP *ppIoApicHlp));
5478
5479	/**
5480	* Sets up the HPET for the raw-mode context.
5481	*
5482	* This must be called after ring-3 has registered the PIC using
5483	* PDMDevHlpHpetRegister().
5484	*
5485	* @returns VBox status code.
5486	* @param pDevIns The device instance.
5487	* @param pHpetReg The PIC registration information for raw-mode,
5488	* considered volatile and copied.
5489	* @param ppHpetHlp Where to return the raw-mode HPET helpers.
5490	*/
5491	DECLRCCALLBACKMEMBER(int, pfnHpetSetUpContext,(PPDMDEVINS pDevIns, PPDMHPETREG pHpetReg, PCPDMHPETHLPRC *ppHpetHlp));
5492
5493	/** Space reserved for future members.
5494	* @{ */
5495	DECLRCCALLBACKMEMBER(void, pfnReserved1,(void));
5496	DECLRCCALLBACKMEMBER(void, pfnReserved2,(void));
5497	DECLRCCALLBACKMEMBER(void, pfnReserved3,(void));
5498	DECLRCCALLBACKMEMBER(void, pfnReserved4,(void));
5499	DECLRCCALLBACKMEMBER(void, pfnReserved5,(void));
5500	DECLRCCALLBACKMEMBER(void, pfnReserved6,(void));
5501	DECLRCCALLBACKMEMBER(void, pfnReserved7,(void));
5502	DECLRCCALLBACKMEMBER(void, pfnReserved8,(void));
5503	DECLRCCALLBACKMEMBER(void, pfnReserved9,(void));
5504	DECLRCCALLBACKMEMBER(void, pfnReserved10,(void));
5505	/** @} */
5506
5507	/** Just a safety precaution. */
5508	uint32_t u32TheEnd;
5509	} PDMDEVHLPRC;
5510	/** Pointer PDM Device RC API. */
5511	typedef RGPTRTYPE(struct PDMDEVHLPRC *) PPDMDEVHLPRC;
5512	/** Pointer PDM Device RC API. */
5513	typedef RGPTRTYPE(const struct PDMDEVHLPRC *) PCPDMDEVHLPRC;
5514
5515	/** Current PDMDEVHLP version number. */
5516	#define PDM_DEVHLPRC_VERSION PDM_VERSION_MAKE(0xffe6, 19, 0)
5517
5518
5519	/**
5520	* PDM Device API - R0 Variant.
5521	*/
5522	typedef struct PDMDEVHLPR0
5523	{
5524	/** Structure version. PDM_DEVHLPR0_VERSION defines the current version. */
5525	uint32_t u32Version;
5526
5527	/**
5528	* Sets up ring-0 callback handlers for an I/O port range.
5529	*
5530	* The range must have been created in ring-3 first using
5531	* PDMDevHlpIoPortCreate() or PDMDevHlpIoPortCreateEx().
5532	*
5533	* @returns VBox status.
5534	* @param pDevIns The device instance to register the ports with.
5535	* @param hIoPorts The I/O port range handle.
5536	* @param pfnOut Pointer to function which is gonna handle OUT
5537	* operations. Optional.
5538	* @param pfnIn Pointer to function which is gonna handle IN operations.
5539	* Optional.
5540	* @param pfnOutStr Pointer to function which is gonna handle string OUT
5541	* operations. Optional.
5542	* @param pfnInStr Pointer to function which is gonna handle string IN
5543	* operations. Optional.
5544	* @param pvUser User argument to pass to the callbacks.
5545	*
5546	* @remarks Caller enters the device critical section prior to invoking the
5547	* registered callback methods.
5548	*
5549	* @sa PDMDevHlpIoPortCreate(), PDMDevHlpIoPortCreateEx(),
5550	* PDMDevHlpIoPortMap(), PDMDevHlpIoPortUnmap().
5551	*/
5552	DECLR0CALLBACKMEMBER(int, pfnIoPortSetUpContextEx,(PPDMDEVINS pDevIns, IOMIOPORTHANDLE hIoPorts,
5553	PFNIOMIOPORTNEWOUT pfnOut, PFNIOMIOPORTNEWIN pfnIn,
5554	PFNIOMIOPORTNEWOUTSTRING pfnOutStr, PFNIOMIOPORTNEWINSTRING pfnInStr,
5555	void *pvUser));
5556
5557	/**
5558	* Sets up ring-0 callback handlers for an MMIO region.
5559	*
5560	* The region must have been created in ring-3 first using
5561	* PDMDevHlpMmioCreate(), PDMDevHlpMmioCreateEx(), PDMDevHlpMmioCreateAndMap(),
5562	* PDMDevHlpMmioCreateExAndMap() or PDMDevHlpPCIIORegionCreateMmio().
5563	*
5564	* @returns VBox status.
5565	* @param pDevIns The device instance to register the ports with.
5566	* @param hRegion The MMIO region handle.
5567	* @param pfnWrite Pointer to function which is gonna handle Write
5568	* operations.
5569	* @param pfnRead Pointer to function which is gonna handle Read
5570	* operations.
5571	* @param pfnFill Pointer to function which is gonna handle Fill/memset
5572	* operations. (optional)
5573	* @param pvUser User argument to pass to the callbacks.
5574	*
5575	* @remarks Caller enters the device critical section prior to invoking the
5576	* registered callback methods.
5577	*
5578	* @sa PDMDevHlpMmioCreate(), PDMDevHlpMmioCreateEx(), PDMDevHlpMmioMap(),
5579	* PDMDevHlpMmioUnmap().
5580	*/
5581	DECLR0CALLBACKMEMBER(int, pfnMmioSetUpContextEx,(PPDMDEVINS pDevIns, IOMMMIOHANDLE hRegion, PFNIOMMMIONEWWRITE pfnWrite,
5582	PFNIOMMMIONEWREAD pfnRead, PFNIOMMMIONEWFILL pfnFill, void *pvUser));
5583
5584	/**
5585	* Sets up a ring-0 mapping for an MMIO2 region.
5586	*
5587	* The region must have been created in ring-3 first using
5588	* PDMDevHlpMmio2Create().
5589	*
5590	* @returns VBox status.
5591	* @param pDevIns The device instance to register the ports with.
5592	* @param hRegion The MMIO2 region handle.
5593	* @param offSub Start of what to map into ring-0. Must be page aligned.
5594	* @param cbSub Number of bytes to map into ring-0. Must be page
5595	* aligned. Zero is an alias for everything.
5596	* @param ppvMapping Where to return the mapping corresponding to @a offSub.
5597	*
5598	* @thread EMT(0)
5599	* @note Only available at VM creation time.
5600	*
5601	* @sa PDMDevHlpMmio2Create().
5602	*/
5603	DECLR0CALLBACKMEMBER(int, pfnMmio2SetUpContext,(PPDMDEVINS pDevIns, PGMMMIO2HANDLE hRegion, size_t offSub, size_t cbSub,
5604	void **ppvMapping));
5605
5606	/**
5607	* Bus master physical memory read from the given PCI device.
5608	*
5609	* @returns VINF_SUCCESS or VERR_PDM_NOT_PCI_BUS_MASTER, later maybe
5610	* VERR_EM_MEMORY.
5611	* @param pDevIns The device instance.
5612	* @param pPciDev The PCI device structure. If NULL the default
5613	* PCI device for this device instance is used.
5614	* @param GCPhys Physical address start reading from.
5615	* @param pvBuf Where to put the read bits.
5616	* @param cbRead How many bytes to read.
5617	* @param fFlags Combination of PDM_DEVHLP_PHYS_RW_F_XXX.
5618	* @thread Any thread, but the call may involve the emulation thread.
5619	*/
5620	DECLR0CALLBACKMEMBER(int, pfnPCIPhysRead,(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, RTGCPHYS GCPhys,
5621	void *pvBuf, size_t cbRead, uint32_t fFlags));
5622
5623	/**
5624	* Bus master physical memory write from the given PCI device.
5625	*
5626	* @returns VINF_SUCCESS or VERR_PDM_NOT_PCI_BUS_MASTER, later maybe
5627	* VERR_EM_MEMORY.
5628	* @param pDevIns The device instance.
5629	* @param pPciDev The PCI device structure. If NULL the default
5630	* PCI device for this device instance is used.
5631	* @param GCPhys Physical address to write to.
5632	* @param pvBuf What to write.
5633	* @param cbWrite How many bytes to write.
5634	* @param fFlags Combination of PDM_DEVHLP_PHYS_RW_F_XXX.
5635	* @thread Any thread, but the call may involve the emulation thread.
5636	*/
5637	DECLR0CALLBACKMEMBER(int, pfnPCIPhysWrite,(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, RTGCPHYS GCPhys,
5638	const void *pvBuf, size_t cbWrite, uint32_t fFlags));
5639
5640	/**
5641	* Set the IRQ for the given PCI device.
5642	*
5643	* @param pDevIns Device instance.
5644	* @param pPciDev The PCI device structure. If NULL the default
5645	* PCI device for this device instance is used.
5646	* @param iIrq IRQ number to set.
5647	* @param iLevel IRQ level. See the PDM_IRQ_LEVEL_* \#defines.
5648	* @thread Any thread, but will involve the emulation thread.
5649	*/
5650	DECLR0CALLBACKMEMBER(void, pfnPCISetIrq,(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, int iIrq, int iLevel));
5651
5652	/**
5653	* Set ISA IRQ for a device.
5654	*
5655	* @param pDevIns Device instance.
5656	* @param iIrq IRQ number to set.
5657	* @param iLevel IRQ level. See the PDM_IRQ_LEVEL_* \#defines.
5658	* @thread Any thread, but will involve the emulation thread.
5659	*/
5660	DECLR0CALLBACKMEMBER(void, pfnISASetIrq,(PPDMDEVINS pDevIns, int iIrq, int iLevel));
5661
5662	/**
5663	* Read physical memory.
5664	*
5665	* @returns VINF_SUCCESS (for now).
5666	* @param pDevIns Device instance.
5667	* @param GCPhys Physical address start reading from.
5668	* @param pvBuf Where to put the read bits.
5669	* @param cbRead How many bytes to read.
5670	* @param fFlags Combination of PDM_DEVHLP_PHYS_RW_F_XXX.
5671	*/
5672	DECLR0CALLBACKMEMBER(int, pfnPhysRead,(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, void *pvBuf, size_t cbRead, uint32_t fFlags));
5673
5674	/**
5675	* Write to physical memory.
5676	*
5677	* @returns VINF_SUCCESS for now, and later maybe VERR_EM_MEMORY.
5678	* @param pDevIns Device instance.
5679	* @param GCPhys Physical address to write to.
5680	* @param pvBuf What to write.
5681	* @param cbWrite How many bytes to write.
5682	* @param fFlags Combination of PDM_DEVHLP_PHYS_RW_F_XXX.
5683	*/
5684	DECLR0CALLBACKMEMBER(int, pfnPhysWrite,(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, const void *pvBuf, size_t cbWrite, uint32_t fFlags));
5685
5686	/**
5687	* Checks if the Gate A20 is enabled or not.
5688	*
5689	* @returns true if A20 is enabled.
5690	* @returns false if A20 is disabled.
5691	* @param pDevIns Device instance.
5692	* @thread The emulation thread.
5693	*/
5694	DECLR0CALLBACKMEMBER(bool, pfnA20IsEnabled,(PPDMDEVINS pDevIns));
5695
5696	/**
5697	* Gets the VM state.
5698	*
5699	* @returns VM state.
5700	* @param pDevIns The device instance.
5701	* @thread Any thread (just keep in mind that it's volatile info).
5702	*/
5703	DECLR0CALLBACKMEMBER(VMSTATE, pfnVMState, (PPDMDEVINS pDevIns));
5704
5705	/**
5706	* Gets the VM handle. Restricted API.
5707	*
5708	* @returns VM Handle.
5709	* @param pDevIns Device instance.
5710	*/
5711	DECLR0CALLBACKMEMBER(PVMCC, pfnGetVM,(PPDMDEVINS pDevIns));
5712
5713	/**
5714	* Gets the VMCPU handle. Restricted API.
5715	*
5716	* @returns VMCPU Handle.
5717	* @param pDevIns The device instance.
5718	*/
5719	DECLR0CALLBACKMEMBER(PVMCPUCC, pfnGetVMCPU,(PPDMDEVINS pDevIns));
5720
5721	/**
5722	* The the VM CPU ID of the current thread (restricted API).
5723	*
5724	* @returns The VMCPUID of the calling thread, NIL_VMCPUID if not EMT.
5725	* @param pDevIns The device instance.
5726	*/
5727	DECLR0CALLBACKMEMBER(VMCPUID, pfnGetCurrentCpuId,(PPDMDEVINS pDevIns));
5728
5729	/**
5730	* Gets the main execution engine for the VM.
5731	*
5732	* @returns VM_EXEC_ENGINE_XXX
5733	* @param pDevIns The device instance.
5734	*/
5735	DECLR0CALLBACKMEMBER(uint8_t, pfnGetMainExecutionEngine,(PPDMDEVINS pDevIns));
5736
5737	/** @name Timer handle method wrappers
5738	* @{ */
5739	DECLR0CALLBACKMEMBER(uint64_t, pfnTimerFromMicro,(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cMicroSecs));
5740	DECLR0CALLBACKMEMBER(uint64_t, pfnTimerFromMilli,(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cMilliSecs));
5741	DECLR0CALLBACKMEMBER(uint64_t, pfnTimerFromNano,(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cNanoSecs));
5742	DECLR0CALLBACKMEMBER(uint64_t, pfnTimerGet,(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer));
5743	DECLR0CALLBACKMEMBER(uint64_t, pfnTimerGetFreq,(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer));
5744	DECLR0CALLBACKMEMBER(uint64_t, pfnTimerGetNano,(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer));
5745	DECLR0CALLBACKMEMBER(bool, pfnTimerIsActive,(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer));
5746	DECLR0CALLBACKMEMBER(bool, pfnTimerIsLockOwner,(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer));
5747	DECLR0CALLBACKMEMBER(VBOXSTRICTRC, pfnTimerLockClock,(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, int rcBusy));
5748	/** Takes the clock lock then enters the specified critical section. */
5749	DECLR0CALLBACKMEMBER(VBOXSTRICTRC, pfnTimerLockClock2,(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, PPDMCRITSECT pCritSect, int rcBusy));
5750	DECLR0CALLBACKMEMBER(int, pfnTimerSet,(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t uExpire));
5751	DECLR0CALLBACKMEMBER(int, pfnTimerSetFrequencyHint,(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint32_t uHz));
5752	DECLR0CALLBACKMEMBER(int, pfnTimerSetMicro,(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cMicrosToNext));
5753	DECLR0CALLBACKMEMBER(int, pfnTimerSetMillies,(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cMilliesToNext));
5754	DECLR0CALLBACKMEMBER(int, pfnTimerSetNano,(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cNanosToNext));
5755	DECLR0CALLBACKMEMBER(int, pfnTimerSetRelative,(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cTicksToNext, uint64_t *pu64Now));
5756	DECLR0CALLBACKMEMBER(int, pfnTimerStop,(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer));
5757	DECLR0CALLBACKMEMBER(void, pfnTimerUnlockClock,(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer));
5758	DECLR0CALLBACKMEMBER(void, pfnTimerUnlockClock2,(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, PPDMCRITSECT pCritSect));
5759	/** @} */
5760
5761	/**
5762	* Get the current virtual clock time in a VM. The clock frequency must be
5763	* queried separately.
5764	*
5765	* @returns Current clock time.
5766	* @param pDevIns The device instance.
5767	*/
5768	DECLR0CALLBACKMEMBER(uint64_t, pfnTMTimeVirtGet,(PPDMDEVINS pDevIns));
5769
5770	/**
5771	* Get the frequency of the virtual clock.
5772	*
5773	* @returns The clock frequency (not variable at run-time).
5774	* @param pDevIns The device instance.
5775	*/
5776	DECLR0CALLBACKMEMBER(uint64_t, pfnTMTimeVirtGetFreq,(PPDMDEVINS pDevIns));
5777
5778	/**
5779	* Get the current virtual clock time in a VM, in nanoseconds.
5780	*
5781	* @returns Current clock time (in ns).
5782	* @param pDevIns The device instance.
5783	*/
5784	DECLR0CALLBACKMEMBER(uint64_t, pfnTMTimeVirtGetNano,(PPDMDEVINS pDevIns));
5785
5786	/** @name Exported PDM Queue Functions
5787	* @{ */
5788	DECLR0CALLBACKMEMBER(PPDMQUEUEITEMCORE, pfnQueueAlloc,(PPDMDEVINS pDevIns, PDMQUEUEHANDLE hQueue));
5789	DECLR0CALLBACKMEMBER(int, pfnQueueInsert,(PPDMDEVINS pDevIns, PDMQUEUEHANDLE hQueue, PPDMQUEUEITEMCORE pItem));
5790	DECLR0CALLBACKMEMBER(bool, pfnQueueFlushIfNecessary,(PPDMDEVINS pDevIns, PDMQUEUEHANDLE hQueue));
5791	/** @} */
5792
5793	/** @name PDM Task
5794	* @{ */
5795	/**
5796	* Triggers the running the given task.
5797	*
5798	* @returns VBox status code.
5799	* @retval VINF_ALREADY_POSTED is the task is already pending.
5800	* @param pDevIns The device instance.
5801	* @param hTask The task to trigger.
5802	* @thread Any thread.
5803	*/
5804	DECLR0CALLBACKMEMBER(int, pfnTaskTrigger,(PPDMDEVINS pDevIns, PDMTASKHANDLE hTask));
5805	/** @} */
5806
5807	/** @name SUP Event Semaphore Wrappers (single release / auto reset)
5808	* These semaphores can be signalled from ring-0.
5809	* @{ */
5810	/** @sa SUPSemEventSignal */
5811	DECLR0CALLBACKMEMBER(int, pfnSUPSemEventSignal,(PPDMDEVINS pDevIns, SUPSEMEVENT hEvent));
5812	/** @sa SUPSemEventWaitNoResume */
5813	DECLR0CALLBACKMEMBER(int, pfnSUPSemEventWaitNoResume,(PPDMDEVINS pDevIns, SUPSEMEVENT hEvent, uint32_t cMillies));
5814	/** @sa SUPSemEventWaitNsAbsIntr */
5815	DECLR0CALLBACKMEMBER(int, pfnSUPSemEventWaitNsAbsIntr,(PPDMDEVINS pDevIns, SUPSEMEVENT hEvent, uint64_t uNsTimeout));
5816	/** @sa SUPSemEventWaitNsRelIntr */
5817	DECLR0CALLBACKMEMBER(int, pfnSUPSemEventWaitNsRelIntr,(PPDMDEVINS pDevIns, SUPSEMEVENT hEvent, uint64_t cNsTimeout));
5818	/** @sa SUPSemEventGetResolution */
5819	DECLR0CALLBACKMEMBER(uint32_t, pfnSUPSemEventGetResolution,(PPDMDEVINS pDevIns));
5820	/** @} */
5821
5822	/** @name SUP Multi Event Semaphore Wrappers (multiple release / manual reset)
5823	* These semaphores can be signalled from ring-0.
5824	* @{ */
5825	/** @sa SUPSemEventMultiSignal */
5826	DECLR0CALLBACKMEMBER(int, pfnSUPSemEventMultiSignal,(PPDMDEVINS pDevIns, SUPSEMEVENTMULTI hEventMulti));
5827	/** @sa SUPSemEventMultiReset */
5828	DECLR0CALLBACKMEMBER(int, pfnSUPSemEventMultiReset,(PPDMDEVINS pDevIns, SUPSEMEVENTMULTI hEventMulti));
5829	/** @sa SUPSemEventMultiWaitNoResume */
5830	DECLR0CALLBACKMEMBER(int, pfnSUPSemEventMultiWaitNoResume,(PPDMDEVINS pDevIns, SUPSEMEVENTMULTI hEventMulti, uint32_t cMillies));
5831	/** @sa SUPSemEventMultiWaitNsAbsIntr */
5832	DECLR0CALLBACKMEMBER(int, pfnSUPSemEventMultiWaitNsAbsIntr,(PPDMDEVINS pDevIns, SUPSEMEVENTMULTI hEventMulti, uint64_t uNsTimeout));
5833	/** @sa SUPSemEventMultiWaitNsRelIntr */
5834	DECLR0CALLBACKMEMBER(int, pfnSUPSemEventMultiWaitNsRelIntr,(PPDMDEVINS pDevIns, SUPSEMEVENTMULTI hEventMulti, uint64_t cNsTimeout));
5835	/** @sa SUPSemEventMultiGetResolution */
5836	DECLR0CALLBACKMEMBER(uint32_t, pfnSUPSemEventMultiGetResolution,(PPDMDEVINS pDevIns));
5837	/** @} */
5838
5839	/**
5840	* Gets the NOP critical section.
5841	*
5842	* @returns The ring-3 address of the NOP critical section.
5843	* @param pDevIns The device instance.
5844	*/
5845	DECLR0CALLBACKMEMBER(PPDMCRITSECT, pfnCritSectGetNop,(PPDMDEVINS pDevIns));
5846
5847	/**
5848	* Changes the device level critical section from the automatically created
5849	* default to one desired by the device constructor.
5850	*
5851	* Must first be done in ring-3.
5852	*
5853	* @returns VBox status code.
5854	* @param pDevIns The device instance.
5855	* @param pCritSect The critical section to use. NULL is not
5856	* valid, instead use the NOP critical
5857	* section.
5858	*/
5859	DECLR0CALLBACKMEMBER(int, pfnSetDeviceCritSect,(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect));
5860
5861	/** @name Exported PDM Critical Section Functions
5862	* @{ */
5863	DECLR0CALLBACKMEMBER(int, pfnCritSectEnter,(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect, int rcBusy));
5864	DECLR0CALLBACKMEMBER(int, pfnCritSectEnterDebug,(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect, int rcBusy, RTHCUINTPTR uId, RT_SRC_POS_DECL));
5865	DECLR0CALLBACKMEMBER(int, pfnCritSectTryEnter,(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect));
5866	DECLR0CALLBACKMEMBER(int, pfnCritSectTryEnterDebug,(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect, RTHCUINTPTR uId, RT_SRC_POS_DECL));
5867	DECLR0CALLBACKMEMBER(int, pfnCritSectLeave,(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect));
5868	DECLR0CALLBACKMEMBER(bool, pfnCritSectIsOwner,(PPDMDEVINS pDevIns, PCPDMCRITSECT pCritSect));
5869	DECLR0CALLBACKMEMBER(bool, pfnCritSectIsInitialized,(PPDMDEVINS pDevIns, PCPDMCRITSECT pCritSect));
5870	DECLR0CALLBACKMEMBER(bool, pfnCritSectHasWaiters,(PPDMDEVINS pDevIns, PCPDMCRITSECT pCritSect));
5871	DECLR0CALLBACKMEMBER(uint32_t, pfnCritSectGetRecursion,(PPDMDEVINS pDevIns, PCPDMCRITSECT pCritSect));
5872	DECLR0CALLBACKMEMBER(int, pfnCritSectScheduleExitEvent,(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect, SUPSEMEVENT hEventToSignal));
5873	/** @} */
5874
5875	/** @name Exported PDM Read/Write Critical Section Functions
5876	* @{ */
5877	DECLR0CALLBACKMEMBER(int, pfnCritSectRwEnterShared,(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect, int rcBusy));
5878	DECLR0CALLBACKMEMBER(int, pfnCritSectRwEnterSharedDebug,(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect, int rcBusy, RTHCUINTPTR uId, RT_SRC_POS_DECL));
5879	DECLR0CALLBACKMEMBER(int, pfnCritSectRwTryEnterShared,(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect));
5880	DECLR0CALLBACKMEMBER(int, pfnCritSectRwTryEnterSharedDebug,(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect, RTHCUINTPTR uId, RT_SRC_POS_DECL));
5881	DECLR0CALLBACKMEMBER(int, pfnCritSectRwLeaveShared,(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect));
5882
5883	DECLR0CALLBACKMEMBER(int, pfnCritSectRwEnterExcl,(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect, int rcBusy));
5884	DECLR0CALLBACKMEMBER(int, pfnCritSectRwEnterExclDebug,(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect, int rcBusy, RTHCUINTPTR uId, RT_SRC_POS_DECL));
5885	DECLR0CALLBACKMEMBER(int, pfnCritSectRwTryEnterExcl,(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect));
5886	DECLR0CALLBACKMEMBER(int, pfnCritSectRwTryEnterExclDebug,(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect, RTHCUINTPTR uId, RT_SRC_POS_DECL));
5887	DECLR0CALLBACKMEMBER(int, pfnCritSectRwLeaveExcl,(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect));
5888
5889	DECLR0CALLBACKMEMBER(bool, pfnCritSectRwIsWriteOwner,(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect));
5890	DECLR0CALLBACKMEMBER(bool, pfnCritSectRwIsReadOwner,(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect, bool fWannaHear));
5891	DECLR0CALLBACKMEMBER(uint32_t, pfnCritSectRwGetWriteRecursion,(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect));
5892	DECLR0CALLBACKMEMBER(uint32_t, pfnCritSectRwGetWriterReadRecursion,(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect));
5893	DECLR0CALLBACKMEMBER(uint32_t, pfnCritSectRwGetReadCount,(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect));
5894	DECLR0CALLBACKMEMBER(bool, pfnCritSectRwIsInitialized,(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect));
5895	/** @} */
5896
5897	/**
5898	* Gets the trace buffer handle.
5899	*
5900	* This is used by the macros found in VBox/vmm/dbgftrace.h and is not
5901	* really inteded for direct usage, thus no inline wrapper function.
5902	*
5903	* @returns Trace buffer handle or NIL_RTTRACEBUF.
5904	* @param pDevIns The device instance.
5905	*/
5906	DECLR0CALLBACKMEMBER(RTTRACEBUF, pfnDBGFTraceBuf,(PPDMDEVINS pDevIns));
5907
5908	/**
5909	* Sets up the PCI bus for the ring-0 context.
5910	*
5911	* This must be called after ring-3 has registered the PCI bus using
5912	* PDMDevHlpPCIBusRegister().
5913	*
5914	* @returns VBox status code.
5915	* @param pDevIns The device instance.
5916	* @param pPciBusReg The PCI bus registration information for ring-0,
5917	* considered volatile and copied.
5918	* @param ppPciHlp Where to return the ring-0 PCI bus helpers.
5919	*/
5920	DECLR0CALLBACKMEMBER(int, pfnPCIBusSetUpContext,(PPDMDEVINS pDevIns, PPDMPCIBUSREGR0 pPciBusReg, PCPDMPCIHLPR0 *ppPciHlp));
5921
5922	/**
5923	* Sets up the IOMMU for the ring-0 context.
5924	*
5925	* This must be called after ring-3 has registered the IOMMU using
5926	* PDMDevHlpIommuRegister().
5927	*
5928	* @returns VBox status code.
5929	* @param pDevIns The device instance.
5930	* @param pIommuReg The IOMMU registration information for ring-0,
5931	* considered volatile and copied.
5932	* @param ppIommuHlp Where to return the ring-0 IOMMU helpers.
5933	*/
5934	DECLR0CALLBACKMEMBER(int, pfnIommuSetUpContext,(PPDMDEVINS pDevIns, PPDMIOMMUREGR0 pIommuReg, PCPDMIOMMUHLPR0 *ppIommuHlp));
5935
5936	/**
5937	* Sets up the PIC for the ring-0 context.
5938	*
5939	* This must be called after ring-3 has registered the PIC using
5940	* PDMDevHlpPICRegister().
5941	*
5942	* @returns VBox status code.
5943	* @param pDevIns The device instance.
5944	* @param pPicReg The PIC registration information for ring-0,
5945	* considered volatile and copied.
5946	* @param ppPicHlp Where to return the ring-0 PIC helpers.
5947	*/
5948	DECLR0CALLBACKMEMBER(int, pfnPICSetUpContext,(PPDMDEVINS pDevIns, PPDMPICREG pPicReg, PCPDMPICHLP *ppPicHlp));
5949
5950	/**
5951	* Sets up the APIC for the ring-0 context.
5952	*
5953	* This must be called after ring-3 has registered the APIC using
5954	* PDMDevHlpApicRegister().
5955	*
5956	* @returns VBox status code.
5957	* @param pDevIns The device instance.
5958	*/
5959	DECLR0CALLBACKMEMBER(int, pfnApicSetUpContext,(PPDMDEVINS pDevIns));
5960
5961	/**
5962	* Sets up the IOAPIC for the ring-0 context.
5963	*
5964	* This must be called after ring-3 has registered the PIC using
5965	* PDMDevHlpIoApicRegister().
5966	*
5967	* @returns VBox status code.
5968	* @param pDevIns The device instance.
5969	* @param pIoApicReg The PIC registration information for ring-0,
5970	* considered volatile and copied.
5971	* @param ppIoApicHlp Where to return the ring-0 IOAPIC helpers.
5972	*/
5973	DECLR0CALLBACKMEMBER(int, pfnIoApicSetUpContext,(PPDMDEVINS pDevIns, PPDMIOAPICREG pIoApicReg, PCPDMIOAPICHLP *ppIoApicHlp));
5974
5975	/**
5976	* Sets up the HPET for the ring-0 context.
5977	*
5978	* This must be called after ring-3 has registered the PIC using
5979	* PDMDevHlpHpetRegister().
5980	*
5981	* @returns VBox status code.
5982	* @param pDevIns The device instance.
5983	* @param pHpetReg The PIC registration information for ring-0,
5984	* considered volatile and copied.
5985	* @param ppHpetHlp Where to return the ring-0 HPET helpers.
5986	*/
5987	DECLR0CALLBACKMEMBER(int, pfnHpetSetUpContext,(PPDMDEVINS pDevIns, PPDMHPETREG pHpetReg, PCPDMHPETHLPR0 *ppHpetHlp));
5988
5989	/**
5990	* Sets up a physical page access handler type for ring-0 callbacks.
5991	*
5992	* @returns VBox status code.
5993	* @param pDevIns The device instance.
5994	* @param enmKind The kind of access handler.
5995	* @param pfnHandler Pointer to the ring-0 handler callback. NULL if
5996	* the ring-3 handler should be called.
5997	* @param pfnPfHandler The name of the ring-0 \#PF handler, NULL if the
5998	* ring-3 handler should be called.
5999	* @param pszDesc The type description.
6000	* @param hType The type handle registered in ring-3 already.
6001	* @sa PDMDevHlpPGMHandlerPhysicalTypeRegister
6002	*/
6003	DECLR0CALLBACKMEMBER(int, pfnPGMHandlerPhysicalTypeSetUpContext, (PPDMDEVINS pDevIns, PGMPHYSHANDLERKIND enmKind,
6004	PFNPGMPHYSHANDLER pfnHandler,
6005	PFNPGMRZPHYSPFHANDLER pfnPfHandler,
6006	const char *pszDesc, PGMPHYSHANDLERTYPE hType));
6007
6008	/**
6009	* Temporarily turns off the access monitoring of a page within a monitored
6010	* physical write/all page access handler region.
6011	*
6012	* Use this when no further \#PFs are required for that page. Be aware that
6013	* a page directory sync might reset the flags, and turn on access monitoring
6014	* for the page.
6015	*
6016	* The caller must do required page table modifications.
6017	*
6018	* @returns VBox status code.
6019	* @param pDevIns The device instance.
6020	* @param GCPhys The start address of the access handler. This
6021	* must be a fully page aligned range or we risk
6022	* messing up other handlers installed for the
6023	* start and end pages.
6024	* @param GCPhysPage The physical address of the page to turn off
6025	* access monitoring for.
6026	*/
6027	DECLR0CALLBACKMEMBER(int, pfnPGMHandlerPhysicalPageTempOff,(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, RTGCPHYS GCPhysPage));
6028
6029	/**
6030	* Mapping an MMIO2 page in place of an MMIO page for direct access.
6031	*
6032	* This is a special optimization used by the VGA device. Call
6033	* PDMDevHlpMmioResetRegion() to undo the mapping.
6034	*
6035	* @returns VBox status code. This API may return VINF_SUCCESS even if no
6036	* remapping is made.
6037	* @retval VERR_SEM_BUSY in ring-0 if we cannot get the IOM lock.
6038	*
6039	* @param pDevIns The device instance @a hRegion and @a hMmio2 are
6040	* associated with.
6041	* @param hRegion The handle to the MMIO region.
6042	* @param offRegion The offset into @a hRegion of the page to be
6043	* remapped.
6044	* @param hMmio2 The MMIO2 handle.
6045	* @param offMmio2 Offset into @a hMmio2 of the page to be use for the
6046	* mapping.
6047	* @param fPageFlags Page flags to set. Must be (X86_PTE_RW \| X86_PTE_P)
6048	* for the time being.
6049	*/
6050	DECLR0CALLBACKMEMBER(int, pfnMmioMapMmio2Page,(PPDMDEVINS pDevIns, IOMMMIOHANDLE hRegion, RTGCPHYS offRegion,
6051	uint64_t hMmio2, RTGCPHYS offMmio2, uint64_t fPageFlags));
6052
6053	/**
6054	* Reset a previously modified MMIO region; restore the access flags.
6055	*
6056	* This undoes the effects of PDMDevHlpMmioMapMmio2Page() and is currently only
6057	* intended for some ancient VGA hack. However, it would be great to extend it
6058	* beyond VT-x and/or nested-paging.
6059	*
6060	* @returns VBox status code.
6061	*
6062	* @param pDevIns The device instance @a hRegion is associated with.
6063	* @param hRegion The handle to the MMIO region.
6064	*/
6065	DECLR0CALLBACKMEMBER(int, pfnMmioResetRegion, (PPDMDEVINS pDevIns, IOMMMIOHANDLE hRegion));
6066
6067	/**
6068	* Returns the array of MMIO2 regions that are expected to be registered and
6069	* later mapped into the guest-physical address space for the GIM provider
6070	* configured for the VM.
6071	*
6072	* @returns Pointer to an array of GIM MMIO2 regions, may return NULL.
6073	* @param pDevIns Pointer to the GIM device instance.
6074	* @param pcRegions Where to store the number of items in the array.
6075	*
6076	* @remarks The caller does not own and therefore must -NOT- try to free the
6077	* returned pointer.
6078	*/
6079	DECLR0CALLBACKMEMBER(PGIMMMIO2REGION, pfnGIMGetMmio2Regions,(PPDMDEVINS pDevIns, uint32_t *pcRegions));
6080
6081	/** Space reserved for future members.
6082	* @{ */
6083	DECLR0CALLBACKMEMBER(void, pfnReserved1,(void));
6084	DECLR0CALLBACKMEMBER(void, pfnReserved2,(void));
6085	DECLR0CALLBACKMEMBER(void, pfnReserved3,(void));
6086	DECLR0CALLBACKMEMBER(void, pfnReserved4,(void));
6087	DECLR0CALLBACKMEMBER(void, pfnReserved5,(void));
6088	DECLR0CALLBACKMEMBER(void, pfnReserved6,(void));
6089	DECLR0CALLBACKMEMBER(void, pfnReserved7,(void));
6090	DECLR0CALLBACKMEMBER(void, pfnReserved8,(void));
6091	DECLR0CALLBACKMEMBER(void, pfnReserved9,(void));
6092	DECLR0CALLBACKMEMBER(void, pfnReserved10,(void));
6093	/** @} */
6094
6095	/** Just a safety precaution. */
6096	uint32_t u32TheEnd;
6097	} PDMDEVHLPR0;
6098	/** Pointer PDM Device R0 API. */
6099	typedef R0PTRTYPE(struct PDMDEVHLPR0 *) PPDMDEVHLPR0;
6100	/** Pointer PDM Device GC API. */
6101	typedef R0PTRTYPE(const struct PDMDEVHLPR0 *) PCPDMDEVHLPR0;
6102
6103	/** Current PDMDEVHLP version number. */
6104	#define PDM_DEVHLPR0_VERSION PDM_VERSION_MAKE(0xffe5, 27, 0)
6105
6106
6107	/**
6108	* PDM Device Instance.
6109	*/
6110	typedef struct PDMDEVINSR3
6111	{
6112	/** Structure version. PDM_DEVINSR3_VERSION defines the current version. */
6113	uint32_t u32Version;
6114	/** Device instance number. */
6115	uint32_t iInstance;
6116	/** Size of the ring-3, raw-mode and shared bits. */
6117	uint32_t cbRing3;
6118	/** Set if ring-0 context is enabled. */
6119	bool fR0Enabled;
6120	/** Set if raw-mode context is enabled. */
6121	bool fRCEnabled;
6122	/** Alignment padding. */
6123	bool afReserved[2];
6124	/** Pointer the HC PDM Device API. */
6125	PCPDMDEVHLPR3 pHlpR3;
6126	/** Pointer to the shared device instance data. */
6127	RTR3PTR pvInstanceDataR3;
6128	/** Pointer to the device instance data for ring-3. */
6129	RTR3PTR pvInstanceDataForR3;
6130	/** The critical section for the device.
6131	*
6132	* TM and IOM will enter this critical section before calling into the device
6133	* code. PDM will when doing power on, power off, reset, suspend and resume
6134	* notifications. SSM will currently not, but this will be changed later on.
6135	*
6136	* The device gets a critical section automatically assigned to it before
6137	* the constructor is called. If the constructor wishes to use a different
6138	* critical section, it calls PDMDevHlpSetDeviceCritSect() to change it
6139	* very early on.
6140	*/
6141	R3PTRTYPE(PPDMCRITSECT) pCritSectRoR3;
6142	/** Pointer to device registration structure. */
6143	R3PTRTYPE(PCPDMDEVREG) pReg;
6144	/** Configuration handle. */
6145	R3PTRTYPE(PCFGMNODE) pCfg;
6146	/** The base interface of the device.
6147	*
6148	* The device constructor initializes this if it has any
6149	* device level interfaces to export. To obtain this interface
6150	* call PDMR3QueryDevice(). */
6151	PDMIBASE IBase;
6152
6153	/** Tracing indicator. */
6154	uint32_t fTracing;
6155	/** The tracing ID of this device. */
6156	uint32_t idTracing;
6157
6158	/** Ring-3 pointer to the raw-mode device instance. */
6159	R3PTRTYPE(struct PDMDEVINSRC *) pDevInsForRCR3;
6160	/** Raw-mode address of the raw-mode device instance. */
6161	RTRGPTR pDevInsForRC;
6162	/** Ring-3 pointer to the raw-mode instance data. */
6163	RTR3PTR pvInstanceDataForRCR3;
6164
6165	/** PCI device structure size. */
6166	uint32_t cbPciDev;
6167	/** Number of PCI devices in apPciDevs. */
6168	uint32_t cPciDevs;
6169	/** Pointer to the PCI devices for this device.
6170	* (Allocated after the shared instance data.)
6171	* @note If we want to extend this beyond 8 sub-functions/devices, those 1 or
6172	* two devices ever needing it can use cbPciDev and do the address
6173	* calculations that for entries 8+. */
6174	R3PTRTYPE(struct PDMPCIDEV *) apPciDevs[8];
6175
6176	/** Temporarily. */
6177	R0PTRTYPE(struct PDMDEVINSR0 *) pDevInsR0RemoveMe;
6178	/** Temporarily. */
6179	RTR0PTR pvInstanceDataR0;
6180	/** Temporarily. */
6181	RTRCPTR pvInstanceDataRC;
6182	/** Align the internal data more naturally. */
6183	uint32_t au32Padding[HC_ARCH_BITS == 32 ? 13 : 11];
6184
6185	/** Internal data. */
6186	union
6187	{
6188	#ifdef PDMDEVINSINT_DECLARED
6189	PDMDEVINSINTR3 s;
6190	#endif
6191	uint8_t padding[HC_ARCH_BITS == 32 ? 0x40 : 0x90];
6192	} Internal;
6193
6194	/** Device instance data for ring-3. The size of this area is defined
6195	* in the PDMDEVREG::cbInstanceR3 field. */
6196	char achInstanceData[8];
6197	} PDMDEVINSR3;
6198
6199	/** Current PDMDEVINSR3 version number. */
6200	#define PDM_DEVINSR3_VERSION PDM_VERSION_MAKE(0xff82, 4, 0)
6201
6202	/** Converts a pointer to the PDMDEVINSR3::IBase to a pointer to PDMDEVINS. */
6203	#define PDMIBASE_2_PDMDEV(pInterface) ( (PPDMDEVINS)((char *)(pInterface) - RT_UOFFSETOF(PDMDEVINS, IBase)) )
6204
6205
6206	/**
6207	* PDM ring-0 device instance.
6208	*/
6209	typedef struct PDMDEVINSR0
6210	{
6211	/** Structure version. PDM_DEVINSR0_VERSION defines the current version. */
6212	uint32_t u32Version;
6213	/** Device instance number. */
6214	uint32_t iInstance;
6215
6216	/** Pointer the HC PDM Device API. */
6217	PCPDMDEVHLPR0 pHlpR0;
6218	/** Pointer to the shared device instance data. */
6219	RTR0PTR pvInstanceDataR0;
6220	/** Pointer to the device instance data for ring-0. */
6221	RTR0PTR pvInstanceDataForR0;
6222	/** The critical section for the device.
6223	*
6224	* TM and IOM will enter this critical section before calling into the device
6225	* code. PDM will when doing power on, power off, reset, suspend and resume
6226	* notifications. SSM will currently not, but this will be changed later on.
6227	*
6228	* The device gets a critical section automatically assigned to it before
6229	* the constructor is called. If the constructor wishes to use a different
6230	* critical section, it calls PDMDevHlpSetDeviceCritSect() to change it
6231	* very early on.
6232	*/
6233	R0PTRTYPE(PPDMCRITSECT) pCritSectRoR0;
6234	/** Pointer to the ring-0 device registration structure. */
6235	R0PTRTYPE(PCPDMDEVREGR0) pReg;
6236	/** Ring-3 address of the ring-3 device instance. */
6237	R3PTRTYPE(struct PDMDEVINSR3 *) pDevInsForR3;
6238	/** Ring-0 pointer to the ring-3 device instance. */
6239	R0PTRTYPE(struct PDMDEVINSR3 *) pDevInsForR3R0;
6240	/** Ring-0 pointer to the ring-3 instance data. */
6241	RTR0PTR pvInstanceDataForR3R0;
6242	/** Raw-mode address of the raw-mode device instance. */
6243	RGPTRTYPE(struct PDMDEVINSRC *) pDevInsForRC;
6244	/** Ring-0 pointer to the raw-mode device instance. */
6245	R0PTRTYPE(struct PDMDEVINSRC *) pDevInsForRCR0;
6246	/** Ring-0 pointer to the raw-mode instance data. */
6247	RTR0PTR pvInstanceDataForRCR0;
6248
6249	/** PCI device structure size. */
6250	uint32_t cbPciDev;
6251	/** Number of PCI devices in apPciDevs. */
6252	uint32_t cPciDevs;
6253	/** Pointer to the PCI devices for this device.
6254	* (Allocated after the shared instance data.)
6255	* @note If we want to extend this beyond 8 sub-functions/devices, those 1 or
6256	* two devices ever needing it can use cbPciDev and do the address
6257	* calculations that for entries 8+. */
6258	R0PTRTYPE(struct PDMPCIDEV *) apPciDevs[8];
6259
6260	/** Align the internal data more naturally. */
6261	uint32_t au32Padding[HC_ARCH_BITS == 32 ? 3 : 2 + 4];
6262
6263	/** Internal data. */
6264	union
6265	{
6266	#ifdef PDMDEVINSINT_DECLARED
6267	PDMDEVINSINTR0 s;
6268	#endif
6269	uint8_t padding[HC_ARCH_BITS == 32 ? 0x40 : 0x80];
6270	} Internal;
6271
6272	/** Device instance data for ring-0. The size of this area is defined
6273	* in the PDMDEVREG::cbInstanceR0 field. */
6274	char achInstanceData[8];
6275	} PDMDEVINSR0;
6276
6277	/** Current PDMDEVINSR0 version number. */
6278	#define PDM_DEVINSR0_VERSION PDM_VERSION_MAKE(0xff83, 4, 0)
6279
6280
6281	/**
6282	* PDM raw-mode device instance.
6283	*/
6284	typedef struct PDMDEVINSRC
6285	{
6286	/** Structure version. PDM_DEVINSRC_VERSION defines the current version. */
6287	uint32_t u32Version;
6288	/** Device instance number. */
6289	uint32_t iInstance;
6290
6291	/** Pointer the HC PDM Device API. */
6292	PCPDMDEVHLPRC pHlpRC;
6293	/** Pointer to the shared device instance data. */
6294	RTRGPTR pvInstanceDataRC;
6295	/** Pointer to the device instance data for raw-mode. */
6296	RTRGPTR pvInstanceDataForRC;
6297	/** The critical section for the device.
6298	*
6299	* TM and IOM will enter this critical section before calling into the device
6300	* code. PDM will when doing power on, power off, reset, suspend and resume
6301	* notifications. SSM will currently not, but this will be changed later on.
6302	*
6303	* The device gets a critical section automatically assigned to it before
6304	* the constructor is called. If the constructor wishes to use a different
6305	* critical section, it calls PDMDevHlpSetDeviceCritSect() to change it
6306	* very early on.
6307	*/
6308	RGPTRTYPE(PPDMCRITSECT) pCritSectRoRC;
6309	/** Pointer to the raw-mode device registration structure. */
6310	RGPTRTYPE(PCPDMDEVREGRC) pReg;
6311
6312	/** PCI device structure size. */
6313	uint32_t cbPciDev;
6314	/** Number of PCI devices in apPciDevs. */
6315	uint32_t cPciDevs;
6316	/** Pointer to the PCI devices for this device.
6317	* (Allocated after the shared instance data.) */
6318	RGPTRTYPE(struct PDMPCIDEV *) apPciDevs[8];
6319
6320	/** Align the internal data more naturally. */
6321	uint32_t au32Padding[14];
6322
6323	/** Internal data. */
6324	union
6325	{
6326	#ifdef PDMDEVINSINT_DECLARED
6327	PDMDEVINSINTRC s;
6328	#endif
6329	uint8_t padding[0x10];
6330	} Internal;
6331
6332	/** Device instance data for ring-0. The size of this area is defined
6333	* in the PDMDEVREG::cbInstanceR0 field. */
6334	char achInstanceData[8];
6335	} PDMDEVINSRC;
6336
6337	/** Current PDMDEVINSR0 version number. */
6338	#define PDM_DEVINSRC_VERSION PDM_VERSION_MAKE(0xff84, 4, 0)
6339
6340
6341	/** @def PDM_DEVINS_VERSION
6342	* Current PDMDEVINS version number. */
6343	/** @typedef PDMDEVINS
6344	* The device instance structure for the current context. */
6345	#ifdef IN_RING3
6346	# define PDM_DEVINS_VERSION PDM_DEVINSR3_VERSION
6347	typedef PDMDEVINSR3 PDMDEVINS;
6348	#elif defined(IN_RING0)
6349	# define PDM_DEVINS_VERSION PDM_DEVINSR0_VERSION
6350	typedef PDMDEVINSR0 PDMDEVINS;
6351	#elif defined(IN_RC)
6352	# define PDM_DEVINS_VERSION PDM_DEVINSRC_VERSION
6353	typedef PDMDEVINSRC PDMDEVINS;
6354	#else
6355	# error "Missing context defines: IN_RING0, IN_RING3, IN_RC"
6356	#endif
6357
6358	/**
6359	* Get the pointer to an PCI device.
6360	* @note Returns NULL if @a a_idxPciDev is out of bounds.
6361	*/
6362	#define PDMDEV_GET_PPCIDEV(a_pDevIns, a_idxPciDev) \
6363	( (uintptr_t)(a_idxPciDev) < RT_ELEMENTS((a_pDevIns)->apPciDevs) ? (a_pDevIns)->apPciDevs[(uintptr_t)(a_idxPciDev)] \
6364	: PDMDEV_CALC_PPCIDEV(a_pDevIns, a_idxPciDev) )
6365
6366	/**
6367	* Calc the pointer to of a given PCI device.
6368	* @note Returns NULL if @a a_idxPciDev is out of bounds.
6369	*/
6370	#define PDMDEV_CALC_PPCIDEV(a_pDevIns, a_idxPciDev) \
6371	( (uintptr_t)(a_idxPciDev) < (a_pDevIns)->cPciDevs \
6372	? (PPDMPCIDEV)((uint8_t )((a_pDevIns)->apPciDevs[0]) + (a_pDevIns->cbPciDev) (uintptr_t)(a_idxPciDev)) \
6373	: (PPDMPCIDEV)NULL )
6374
6375
6376	/**
6377	* Checks the structure versions of the device instance and device helpers,
6378	* returning if they are incompatible.
6379	*
6380	* This is for use in the constructor.
6381	*
6382	* @param pDevIns The device instance pointer.
6383	*/
6384	#define PDMDEV_CHECK_VERSIONS_RETURN(pDevIns) \
6385	do \
6386	{ \
6387	PPDMDEVINS pDevInsTypeCheck = (pDevIns); NOREF(pDevInsTypeCheck); \
6388	AssertLogRelMsgReturn(PDM_VERSION_ARE_COMPATIBLE((pDevIns)->u32Version, PDM_DEVINS_VERSION), \
6389	("DevIns=%#x mine=%#x\n", (pDevIns)->u32Version, PDM_DEVINS_VERSION), \
6390	VERR_PDM_DEVINS_VERSION_MISMATCH); \
6391	AssertLogRelMsgReturn(PDM_VERSION_ARE_COMPATIBLE((pDevIns)->CTX_SUFF(pHlp)->u32Version, CTX_MID(PDM_DEVHLP,_VERSION)), \
6392	("DevHlp=%#x mine=%#x\n", (pDevIns)->CTX_SUFF(pHlp)->u32Version, CTX_MID(PDM_DEVHLP,_VERSION)), \
6393	VERR_PDM_DEVHLP_VERSION_MISMATCH); \
6394	} while (0)
6395
6396	/**
6397	* Quietly checks the structure versions of the device instance and device
6398	* helpers, returning if they are incompatible.
6399	*
6400	* This is for use in the destructor.
6401	*
6402	* @param pDevIns The device instance pointer.
6403	*/
6404	#define PDMDEV_CHECK_VERSIONS_RETURN_QUIET(pDevIns) \
6405	do \
6406	{ \
6407	PPDMDEVINS pDevInsTypeCheck = (pDevIns); NOREF(pDevInsTypeCheck); \
6408	if (RT_LIKELY(PDM_VERSION_ARE_COMPATIBLE((pDevIns)->u32Version, PDM_DEVINS_VERSION) )) \
6409	{ /* likely */ } else return VERR_PDM_DEVINS_VERSION_MISMATCH; \
6410	if (RT_LIKELY(PDM_VERSION_ARE_COMPATIBLE((pDevIns)->CTX_SUFF(pHlp)->u32Version, CTX_MID(PDM_DEVHLP,_VERSION)) )) \
6411	{ /* likely */ } else return VERR_PDM_DEVHLP_VERSION_MISMATCH; \
6412	} while (0)
6413
6414	/**
6415	* Wrapper around CFGMR3ValidateConfig for the root config for use in the
6416	* constructor - returns on failure.
6417	*
6418	* This should be invoked after having initialized the instance data
6419	* sufficiently for the correct operation of the destructor. The destructor is
6420	* always called!
6421	*
6422	* @param pDevIns Pointer to the PDM device instance.
6423	* @param pszValidValues Patterns describing the valid value names. See
6424	* RTStrSimplePatternMultiMatch for details on the
6425	* pattern syntax.
6426	* @param pszValidNodes Patterns describing the valid node (key) names.
6427	* Pass empty string if no valid nodes.
6428	*/
6429	#define PDMDEV_VALIDATE_CONFIG_RETURN(pDevIns, pszValidValues, pszValidNodes) \
6430	do \
6431	{ \
6432	int rcValCfg = pDevIns->pHlpR3->pfnCFGMValidateConfig((pDevIns)->pCfg, "/", pszValidValues, pszValidNodes, \
6433	(pDevIns)->pReg->szName, (pDevIns)->iInstance); \
6434	if (RT_SUCCESS(rcValCfg)) \
6435	{ /* likely */ } else return rcValCfg; \
6436	} while (0)
6437
6438	/** @def PDMDEV_ASSERT_EMT
6439	* Assert that the current thread is the emulation thread.
6440	*/
6441	#ifdef VBOX_STRICT
6442	# define PDMDEV_ASSERT_EMT(pDevIns) pDevIns->pHlpR3->pfnAssertEMT(pDevIns, __FILE__, __LINE__, __FUNCTION__)
6443	#else
6444	# define PDMDEV_ASSERT_EMT(pDevIns) do { } while (0)
6445	#endif
6446
6447	/** @def PDMDEV_ASSERT_OTHER
6448	* Assert that the current thread is NOT the emulation thread.
6449	*/
6450	#ifdef VBOX_STRICT
6451	# define PDMDEV_ASSERT_OTHER(pDevIns) pDevIns->pHlpR3->pfnAssertOther(pDevIns, __FILE__, __LINE__, __FUNCTION__)
6452	#else
6453	# define PDMDEV_ASSERT_OTHER(pDevIns) do { } while (0)
6454	#endif
6455
6456	/** @def PDMDEV_ASSERT_VMLOCK_OWNER
6457	* Assert that the current thread is owner of the VM lock.
6458	*/
6459	#ifdef VBOX_STRICT
6460	# define PDMDEV_ASSERT_VMLOCK_OWNER(pDevIns) pDevIns->pHlpR3->pfnAssertVMLock(pDevIns, __FILE__, __LINE__, __FUNCTION__)
6461	#else
6462	# define PDMDEV_ASSERT_VMLOCK_OWNER(pDevIns) do { } while (0)
6463	#endif
6464
6465	/** @def PDMDEV_SET_ERROR
6466	* Set the VM error. See PDMDevHlpVMSetError() for printf like message formatting.
6467	*/
6468	#define PDMDEV_SET_ERROR(pDevIns, rc, pszError) \
6469	PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS, "%s", pszError)
6470
6471	/** @def PDMDEV_SET_RUNTIME_ERROR
6472	* Set the VM runtime error. See PDMDevHlpVMSetRuntimeError() for printf like message formatting.
6473	*/
6474	#define PDMDEV_SET_RUNTIME_ERROR(pDevIns, fFlags, pszErrorId, pszError) \
6475	PDMDevHlpVMSetRuntimeError(pDevIns, fFlags, pszErrorId, "%s", pszError)
6476
6477	/** @def PDMDEVINS_2_RCPTR
6478	* Converts a PDM Device instance pointer to a RC PDM Device instance pointer.
6479	*/
6480	#ifdef IN_RC
6481	# define PDMDEVINS_2_RCPTR(pDevIns) (pDevIns)
6482	#else
6483	# define PDMDEVINS_2_RCPTR(pDevIns) ( (pDevIns)->pDevInsForRC )
6484	#endif
6485
6486	/** @def PDMDEVINS_2_R3PTR
6487	* Converts a PDM Device instance pointer to a R3 PDM Device instance pointer.
6488	*/
6489	#ifdef IN_RING3
6490	# define PDMDEVINS_2_R3PTR(pDevIns) (pDevIns)
6491	#else
6492	# define PDMDEVINS_2_R3PTR(pDevIns) ( (pDevIns)->pDevInsForR3 )
6493	#endif
6494
6495	/** @def PDMDEVINS_2_R0PTR
6496	* Converts a PDM Device instance pointer to a R0 PDM Device instance pointer.
6497	*/
6498	#ifdef IN_RING0
6499	# define PDMDEVINS_2_R0PTR(pDevIns) (pDevIns)
6500	#else
6501	# define PDMDEVINS_2_R0PTR(pDevIns) ( (pDevIns)->pDevInsR0RemoveMe )
6502	#endif
6503
6504	/** @def PDMDEVINS_DATA_2_R0_REMOVE_ME
6505	* Converts a PDM device instance data pointer to a ring-0 one.
6506	* @deprecated
6507	*/
6508	#ifdef IN_RING0
6509	# define PDMDEVINS_DATA_2_R0_REMOVE_ME(pDevIns, pvCC) (pvCC)
6510	#else
6511	# define PDMDEVINS_DATA_2_R0_REMOVE_ME(pDevIns, pvCC) ( (pDevIns)->pvInstanceDataR0 + (uintptr_t)(pvCC) - (uintptr_t)(pDevIns)->CTX_SUFF(pvInstanceData) )
6512	#endif
6513
6514
6515	/** @def PDMDEVINS_2_DATA
6516	* This is a safer edition of PDMINS_2_DATA that checks that the size of the
6517	* target type is same as PDMDEVREG::cbInstanceShared in strict builds.
6518	*
6519	* @note Do no use this macro in common code working on a core structure which
6520	* device specific code has expanded.
6521	*/
6522	#if defined(VBOX_STRICT) && defined(RT_COMPILER_SUPPORTS_LAMBDA)
6523	# define PDMDEVINS_2_DATA(a_pDevIns, a_PtrType) \
6524	([](PPDMDEVINS a_pLambdaDevIns) -> a_PtrType \
6525	{ \
6526	a_PtrType pLambdaRet = (a_PtrType)(a_pLambdaDevIns)->CTX_SUFF(pvInstanceData); \
6527	Assert(sizeof(*pLambdaRet) == a_pLambdaDevIns->pReg->cbInstanceShared); \
6528	return pLambdaRet; \
6529	}(a_pDevIns))
6530	#else
6531	# define PDMDEVINS_2_DATA(a_pDevIns, a_PtrType) ( (a_PtrType)(a_pDevIns)->CTX_SUFF(pvInstanceData) )
6532	#endif
6533
6534	/** @def PDMDEVINS_2_DATA_CC
6535	* This is a safer edition of PDMINS_2_DATA_CC that checks that the size of the
6536	* target type is same as PDMDEVREG::cbInstanceCC in strict builds.
6537	*
6538	* @note Do no use this macro in common code working on a core structure which
6539	* device specific code has expanded.
6540	*/
6541	#if defined(VBOX_STRICT) && defined(RT_COMPILER_SUPPORTS_LAMBDA)
6542	# define PDMDEVINS_2_DATA_CC(a_pDevIns, a_PtrType) \
6543	([](PPDMDEVINS a_pLambdaDevIns) -> a_PtrType \
6544	{ \
6545	a_PtrType pLambdaRet = (a_PtrType)&(a_pLambdaDevIns)->achInstanceData[0]; \
6546	Assert(sizeof(*pLambdaRet) == a_pLambdaDevIns->pReg->cbInstanceCC); \
6547	return pLambdaRet; \
6548	}(a_pDevIns))
6549	#else
6550	# define PDMDEVINS_2_DATA_CC(a_pDevIns, a_PtrType) ( (a_PtrType)(void *)&(a_pDevIns)->achInstanceData[0] )
6551	#endif
6552
6553
6554	#ifdef IN_RING3
6555
6556	/**
6557	* Combines PDMDevHlpIoPortCreate() & PDMDevHlpIoPortMap().
6558	*/
6559	DECLINLINE(int) PDMDevHlpIoPortCreateAndMap(PPDMDEVINS pDevIns, RTIOPORT Port, RTIOPORT cPorts, PFNIOMIOPORTNEWOUT pfnOut,
6560	PFNIOMIOPORTNEWIN pfnIn, const char *pszDesc, PCIOMIOPORTDESC paExtDescs,
6561	PIOMIOPORTHANDLE phIoPorts)
6562	{
6563	int rc = pDevIns->pHlpR3->pfnIoPortCreateEx(pDevIns, cPorts, 0, NULL, UINT32_MAX,
6564	pfnOut, pfnIn, NULL, NULL, NULL, pszDesc, paExtDescs, phIoPorts);
6565	if (RT_SUCCESS(rc))
6566	rc = pDevIns->pHlpR3->pfnIoPortMap(pDevIns, *phIoPorts, Port);
6567	return rc;
6568	}
6569
6570	/**
6571	* Combines PDMDevHlpIoPortCreate() & PDMDevHlpIoPortMap(), but with pvUser.
6572	*/
6573	DECLINLINE(int) PDMDevHlpIoPortCreateUAndMap(PPDMDEVINS pDevIns, RTIOPORT Port, RTIOPORT cPorts, PFNIOMIOPORTNEWOUT pfnOut,
6574	PFNIOMIOPORTNEWIN pfnIn, void *pvUser,
6575	const char *pszDesc, PCIOMIOPORTDESC paExtDescs, PIOMIOPORTHANDLE phIoPorts)
6576	{
6577	int rc = pDevIns->pHlpR3->pfnIoPortCreateEx(pDevIns, cPorts, 0, NULL, UINT32_MAX,
6578	pfnOut, pfnIn, NULL, NULL, pvUser, pszDesc, paExtDescs, phIoPorts);
6579	if (RT_SUCCESS(rc))
6580	rc = pDevIns->pHlpR3->pfnIoPortMap(pDevIns, *phIoPorts, Port);
6581	return rc;
6582	}
6583
6584	/**
6585	* Combines PDMDevHlpIoPortCreate() & PDMDevHlpIoPortMap(), but with flags.
6586	*/
6587	DECLINLINE(int) PDMDevHlpIoPortCreateFlagsAndMap(PPDMDEVINS pDevIns, RTIOPORT Port, RTIOPORT cPorts, uint32_t fFlags,
6588	PFNIOMIOPORTNEWOUT pfnOut, PFNIOMIOPORTNEWIN pfnIn,
6589	const char *pszDesc, PCIOMIOPORTDESC paExtDescs, PIOMIOPORTHANDLE phIoPorts)
6590	{
6591	int rc = pDevIns->pHlpR3->pfnIoPortCreateEx(pDevIns, cPorts, fFlags, NULL, UINT32_MAX,
6592	pfnOut, pfnIn, NULL, NULL, NULL, pszDesc, paExtDescs, phIoPorts);
6593	if (RT_SUCCESS(rc))
6594	rc = pDevIns->pHlpR3->pfnIoPortMap(pDevIns, *phIoPorts, Port);
6595	return rc;
6596	}
6597
6598	/**
6599	* Combines PDMDevHlpIoPortCreateEx() & PDMDevHlpIoPortMap().
6600	*/
6601	DECLINLINE(int) PDMDevHlpIoPortCreateExAndMap(PPDMDEVINS pDevIns, RTIOPORT Port, RTIOPORT cPorts, uint32_t fFlags,
6602	PFNIOMIOPORTNEWOUT pfnOut, PFNIOMIOPORTNEWIN pfnIn,
6603	PFNIOMIOPORTNEWOUTSTRING pfnOutStr, PFNIOMIOPORTNEWINSTRING pfnInStr, void *pvUser,
6604	const char *pszDesc, PCIOMIOPORTDESC paExtDescs, PIOMIOPORTHANDLE phIoPorts)
6605	{
6606	int rc = pDevIns->pHlpR3->pfnIoPortCreateEx(pDevIns, cPorts, fFlags, NULL, UINT32_MAX,
6607	pfnOut, pfnIn, pfnOutStr, pfnInStr, pvUser, pszDesc, paExtDescs, phIoPorts);
6608	if (RT_SUCCESS(rc))
6609	rc = pDevIns->pHlpR3->pfnIoPortMap(pDevIns, *phIoPorts, Port);
6610	return rc;
6611	}
6612
6613	/**
6614	* @sa PDMDevHlpIoPortCreateEx
6615	*/
6616	DECLINLINE(int) PDMDevHlpIoPortCreate(PPDMDEVINS pDevIns, RTIOPORT cPorts, PPDMPCIDEV pPciDev, uint32_t iPciRegion,
6617	PFNIOMIOPORTNEWOUT pfnOut, PFNIOMIOPORTNEWIN pfnIn, void pvUser, const char pszDesc,
6618	PCIOMIOPORTDESC paExtDescs, PIOMIOPORTHANDLE phIoPorts)
6619	{
6620	return pDevIns->pHlpR3->pfnIoPortCreateEx(pDevIns, cPorts, 0, pPciDev, iPciRegion,
6621	pfnOut, pfnIn, NULL, NULL, pvUser, pszDesc, paExtDescs, phIoPorts);
6622	}
6623
6624
6625	/**
6626	* @sa PDMDevHlpIoPortCreateEx
6627	*/
6628	DECLINLINE(int) PDMDevHlpIoPortCreateIsa(PPDMDEVINS pDevIns, RTIOPORT cPorts, PFNIOMIOPORTNEWOUT pfnOut,
6629	PFNIOMIOPORTNEWIN pfnIn, void pvUser, const char pszDesc,
6630	PCIOMIOPORTDESC paExtDescs, PIOMIOPORTHANDLE phIoPorts)
6631	{
6632	return pDevIns->pHlpR3->pfnIoPortCreateEx(pDevIns, cPorts, 0, NULL, UINT32_MAX,
6633	pfnOut, pfnIn, NULL, NULL, pvUser, pszDesc, paExtDescs, phIoPorts);
6634	}
6635
6636	/**
6637	* @copydoc PDMDEVHLPR3::pfnIoPortCreateEx
6638	*/
6639	DECLINLINE(int) PDMDevHlpIoPortCreateEx(PPDMDEVINS pDevIns, RTIOPORT cPorts, uint32_t fFlags, PPDMPCIDEV pPciDev,
6640	uint32_t iPciRegion, PFNIOMIOPORTNEWOUT pfnOut, PFNIOMIOPORTNEWIN pfnIn,
6641	PFNIOMIOPORTNEWOUTSTRING pfnOutStr, PFNIOMIOPORTNEWINSTRING pfnInStr, void *pvUser,
6642	const char *pszDesc, PCIOMIOPORTDESC paExtDescs, PIOMIOPORTHANDLE phIoPorts)
6643	{
6644	return pDevIns->pHlpR3->pfnIoPortCreateEx(pDevIns, cPorts, fFlags, pPciDev, iPciRegion,
6645	pfnOut, pfnIn, pfnOutStr, pfnInStr, pvUser, pszDesc, paExtDescs, phIoPorts);
6646	}
6647
6648	/**
6649	* @copydoc PDMDEVHLPR3::pfnIoPortMap
6650	*/
6651	DECLINLINE(int) PDMDevHlpIoPortMap(PPDMDEVINS pDevIns, IOMIOPORTHANDLE hIoPorts, RTIOPORT Port)
6652	{
6653	return pDevIns->pHlpR3->pfnIoPortMap(pDevIns, hIoPorts, Port);
6654	}
6655
6656	/**
6657	* @copydoc PDMDEVHLPR3::pfnIoPortUnmap
6658	*/
6659	DECLINLINE(int) PDMDevHlpIoPortUnmap(PPDMDEVINS pDevIns, IOMIOPORTHANDLE hIoPorts)
6660	{
6661	return pDevIns->pHlpR3->pfnIoPortUnmap(pDevIns, hIoPorts);
6662	}
6663
6664	/**
6665	* @copydoc PDMDEVHLPR3::pfnIoPortGetMappingAddress
6666	*/
6667	DECLINLINE(uint32_t) PDMDevHlpIoPortGetMappingAddress(PPDMDEVINS pDevIns, IOMIOPORTHANDLE hIoPorts)
6668	{
6669	return pDevIns->pHlpR3->pfnIoPortGetMappingAddress(pDevIns, hIoPorts);
6670	}
6671
6672	/**
6673	* @copydoc PDMDEVHLPR3::pfnIoPortRead
6674	*/
6675	DECLINLINE(VBOXSTRICTRC) PDMDevHlpIoPortRead(PPDMDEVINS pDevIns, RTIOPORT Port, uint32_t *pu32Value, size_t cbValue)
6676	{
6677	return pDevIns->pHlpR3->pfnIoPortRead(pDevIns, Port, pu32Value, cbValue);
6678	}
6679
6680	/**
6681	* @copydoc PDMDEVHLPR3::pfnIoPortWrite
6682	*/
6683	DECLINLINE(VBOXSTRICTRC) PDMDevHlpIoPortWrite(PPDMDEVINS pDevIns, RTIOPORT Port, uint32_t u32Value, size_t cbValue)
6684	{
6685	return pDevIns->pHlpR3->pfnIoPortWrite(pDevIns, Port, u32Value, cbValue);
6686	}
6687
6688
6689	#endif /* IN_RING3 */
6690	#if !defined(IN_RING3) \|\| defined(DOXYGEN_RUNNING)
6691
6692	/**
6693	* @sa PDMDevHlpIoPortSetUpContextEx
6694	*/
6695	DECLINLINE(int) PDMDevHlpIoPortSetUpContext(PPDMDEVINS pDevIns, IOMIOPORTHANDLE hIoPorts,
6696	PFNIOMIOPORTNEWOUT pfnOut, PFNIOMIOPORTNEWIN pfnIn, void *pvUser)
6697	{
6698	return pDevIns->CTX_SUFF(pHlp)->pfnIoPortSetUpContextEx(pDevIns, hIoPorts, pfnOut, pfnIn, NULL, NULL, pvUser);
6699	}
6700
6701	/**
6702	* @copydoc PDMDEVHLPR0::pfnIoPortSetUpContextEx
6703	*/
6704	DECLINLINE(int) PDMDevHlpIoPortSetUpContextEx(PPDMDEVINS pDevIns, IOMIOPORTHANDLE hIoPorts,
6705	PFNIOMIOPORTNEWOUT pfnOut, PFNIOMIOPORTNEWIN pfnIn,
6706	PFNIOMIOPORTNEWOUTSTRING pfnOutStr, PFNIOMIOPORTNEWINSTRING pfnInStr, void *pvUser)
6707	{
6708	return pDevIns->CTX_SUFF(pHlp)->pfnIoPortSetUpContextEx(pDevIns, hIoPorts, pfnOut, pfnIn, pfnOutStr, pfnInStr, pvUser);
6709	}
6710
6711	#endif /* !IN_RING3 \|\| DOXYGEN_RUNNING */
6712	#ifdef IN_RING3
6713
6714	/**
6715	* @sa PDMDevHlpMmioCreateEx
6716	*/
6717	DECLINLINE(int) PDMDevHlpMmioCreate(PPDMDEVINS pDevIns, RTGCPHYS cbRegion, PPDMPCIDEV pPciDev, uint32_t iPciRegion,
6718	PFNIOMMMIONEWWRITE pfnWrite, PFNIOMMMIONEWREAD pfnRead, void *pvUser,
6719	uint32_t fFlags, const char *pszDesc, PIOMMMIOHANDLE phRegion)
6720	{
6721	return pDevIns->pHlpR3->pfnMmioCreateEx(pDevIns, cbRegion, fFlags, pPciDev, iPciRegion,
6722	pfnWrite, pfnRead, NULL, pvUser, pszDesc, phRegion);
6723	}
6724
6725	/**
6726	* @copydoc PDMDEVHLPR3::pfnMmioCreateEx
6727	*/
6728	DECLINLINE(int) PDMDevHlpMmioCreateEx(PPDMDEVINS pDevIns, RTGCPHYS cbRegion,
6729	uint32_t fFlags, PPDMPCIDEV pPciDev, uint32_t iPciRegion,
6730	PFNIOMMMIONEWWRITE pfnWrite, PFNIOMMMIONEWREAD pfnRead, PFNIOMMMIONEWFILL pfnFill,
6731	void pvUser, const char pszDesc, PIOMMMIOHANDLE phRegion)
6732	{
6733	return pDevIns->pHlpR3->pfnMmioCreateEx(pDevIns, cbRegion, fFlags, pPciDev, iPciRegion,
6734	pfnWrite, pfnRead, pfnFill, pvUser, pszDesc, phRegion);
6735	}
6736
6737	/**
6738	* @sa PDMDevHlpMmioCreate and PDMDevHlpMmioMap
6739	*/
6740	DECLINLINE(int) PDMDevHlpMmioCreateAndMap(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, RTGCPHYS cbRegion,
6741	PFNIOMMMIONEWWRITE pfnWrite, PFNIOMMMIONEWREAD pfnRead,
6742	uint32_t fFlags, const char *pszDesc, PIOMMMIOHANDLE phRegion)
6743	{
6744	int rc = pDevIns->pHlpR3->pfnMmioCreateEx(pDevIns, cbRegion, fFlags, NULL /pPciDev/, UINT32_MAX /iPciRegion/,
6745	pfnWrite, pfnRead, NULL /pfnFill/, NULL /pvUser/, pszDesc, phRegion);
6746	if (RT_SUCCESS(rc))
6747	rc = pDevIns->pHlpR3->pfnMmioMap(pDevIns, *phRegion, GCPhys);
6748	return rc;
6749	}
6750
6751	/**
6752	* @sa PDMDevHlpMmioCreateEx and PDMDevHlpMmioMap
6753	*/
6754	DECLINLINE(int) PDMDevHlpMmioCreateExAndMap(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, RTGCPHYS cbRegion, uint32_t fFlags,
6755	PPDMPCIDEV pPciDev, uint32_t iPciRegion, PFNIOMMMIONEWWRITE pfnWrite,
6756	PFNIOMMMIONEWREAD pfnRead, PFNIOMMMIONEWFILL pfnFill, void *pvUser,
6757	const char *pszDesc, PIOMMMIOHANDLE phRegion)
6758	{
6759	int rc = pDevIns->pHlpR3->pfnMmioCreateEx(pDevIns, cbRegion, fFlags, pPciDev, iPciRegion,
6760	pfnWrite, pfnRead, pfnFill, pvUser, pszDesc, phRegion);
6761	if (RT_SUCCESS(rc))
6762	rc = pDevIns->pHlpR3->pfnMmioMap(pDevIns, *phRegion, GCPhys);
6763	return rc;
6764	}
6765
6766	/**
6767	* @copydoc PDMDEVHLPR3::pfnMmioMap
6768	*/
6769	DECLINLINE(int) PDMDevHlpMmioMap(PPDMDEVINS pDevIns, IOMMMIOHANDLE hRegion, RTGCPHYS GCPhys)
6770	{
6771	return pDevIns->pHlpR3->pfnMmioMap(pDevIns, hRegion, GCPhys);
6772	}
6773
6774	/**
6775	* @copydoc PDMDEVHLPR3::pfnMmioUnmap
6776	*/
6777	DECLINLINE(int) PDMDevHlpMmioUnmap(PPDMDEVINS pDevIns, IOMMMIOHANDLE hRegion)
6778	{
6779	return pDevIns->pHlpR3->pfnMmioUnmap(pDevIns, hRegion);
6780	}
6781
6782	/**
6783	* @copydoc PDMDEVHLPR3::pfnMmioReduce
6784	*/
6785	DECLINLINE(int) PDMDevHlpMmioReduce(PPDMDEVINS pDevIns, IOMMMIOHANDLE hRegion, RTGCPHYS cbRegion)
6786	{
6787	return pDevIns->pHlpR3->pfnMmioReduce(pDevIns, hRegion, cbRegion);
6788	}
6789
6790	/**
6791	* @copydoc PDMDEVHLPR3::pfnMmioGetMappingAddress
6792	*/
6793	DECLINLINE(RTGCPHYS) PDMDevHlpMmioGetMappingAddress(PPDMDEVINS pDevIns, IOMMMIOHANDLE hRegion)
6794	{
6795	return pDevIns->pHlpR3->pfnMmioGetMappingAddress(pDevIns, hRegion);
6796	}
6797
6798	#endif /* IN_RING3 */
6799	#if !defined(IN_RING3) \|\| defined(DOXYGEN_RUNNING)
6800
6801	/**
6802	* @sa PDMDevHlpMmioSetUpContextEx
6803	*/
6804	DECLINLINE(int) PDMDevHlpMmioSetUpContext(PPDMDEVINS pDevIns, IOMMMIOHANDLE hRegion,
6805	PFNIOMMMIONEWWRITE pfnWrite, PFNIOMMMIONEWREAD pfnRead, void *pvUser)
6806	{
6807	return pDevIns->CTX_SUFF(pHlp)->pfnMmioSetUpContextEx(pDevIns, hRegion, pfnWrite, pfnRead, NULL, pvUser);
6808	}
6809
6810	/**
6811	* @copydoc PDMDEVHLPR0::pfnMmioSetUpContextEx
6812	*/
6813	DECLINLINE(int) PDMDevHlpMmioSetUpContextEx(PPDMDEVINS pDevIns, IOMMMIOHANDLE hRegion, PFNIOMMMIONEWWRITE pfnWrite,
6814	PFNIOMMMIONEWREAD pfnRead, PFNIOMMMIONEWFILL pfnFill, void *pvUser)
6815	{
6816	return pDevIns->CTX_SUFF(pHlp)->pfnMmioSetUpContextEx(pDevIns, hRegion, pfnWrite, pfnRead, pfnFill, pvUser);
6817	}
6818
6819	#endif /* !IN_RING3 \|\| DOXYGEN_RUNNING */
6820	#ifdef IN_RING3
6821
6822	/**
6823	* @copydoc PDMDEVHLPR3::pfnMmio2Create
6824	*/
6825	DECLINLINE(int) PDMDevHlpMmio2Create(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t iPciRegion, RTGCPHYS cbRegion,
6826	uint32_t fFlags, const char pszDesc, void *ppvMapping, PPGMMMIO2HANDLE phRegion)
6827	{
6828	return pDevIns->pHlpR3->pfnMmio2Create(pDevIns, pPciDev, iPciRegion, cbRegion, fFlags, pszDesc, ppvMapping, phRegion);
6829	}
6830
6831	/**
6832	* @copydoc PDMDEVHLPR3::pfnMmio2Map
6833	*/
6834	DECLINLINE(int) PDMDevHlpMmio2Map(PPDMDEVINS pDevIns, PGMMMIO2HANDLE hRegion, RTGCPHYS GCPhys)
6835	{
6836	return pDevIns->pHlpR3->pfnMmio2Map(pDevIns, hRegion, GCPhys);
6837	}
6838
6839	/**
6840	* @copydoc PDMDEVHLPR3::pfnMmio2Unmap
6841	*/
6842	DECLINLINE(int) PDMDevHlpMmio2Unmap(PPDMDEVINS pDevIns, PGMMMIO2HANDLE hRegion)
6843	{
6844	return pDevIns->pHlpR3->pfnMmio2Unmap(pDevIns, hRegion);
6845	}
6846
6847	/**
6848	* @copydoc PDMDEVHLPR3::pfnMmio2Reduce
6849	*/
6850	DECLINLINE(int) PDMDevHlpMmio2Reduce(PPDMDEVINS pDevIns, PGMMMIO2HANDLE hRegion, RTGCPHYS cbRegion)
6851	{
6852	return pDevIns->pHlpR3->pfnMmio2Reduce(pDevIns, hRegion, cbRegion);
6853	}
6854
6855	/**
6856	* @copydoc PDMDEVHLPR3::pfnMmio2GetMappingAddress
6857	*/
6858	DECLINLINE(RTGCPHYS) PDMDevHlpMmio2GetMappingAddress(PPDMDEVINS pDevIns, PGMMMIO2HANDLE hRegion)
6859	{
6860	return pDevIns->pHlpR3->pfnMmio2GetMappingAddress(pDevIns, hRegion);
6861	}
6862
6863	/**
6864	* @copydoc PDMDEVHLPR3::pfnMmio2QueryAndResetDirtyBitmap
6865	*/
6866	DECLINLINE(int) PDMDevHlpMmio2QueryAndResetDirtyBitmap(PPDMDEVINS pDevIns, PGMMMIO2HANDLE hRegion,
6867	void *pvBitmap, size_t cbBitmap)
6868	{
6869	return pDevIns->pHlpR3->pfnMmio2QueryAndResetDirtyBitmap(pDevIns, hRegion, pvBitmap, cbBitmap);
6870	}
6871
6872	/**
6873	* Reset the dirty bitmap tracking for an MMIO2 region.
6874	*
6875	* The MMIO2 region must have been created with the
6876	* PGMPHYS_MMIO2_FLAGS_TRACK_DIRTY_PAGES flag for this to work.
6877	*
6878	* @returns VBox status code.
6879	* @param pDevIns The device instance.
6880	* @param hRegion The MMIO2 region handle.
6881	*/
6882	DECLINLINE(int) PDMDevHlpMmio2ResetDirtyBitmap(PPDMDEVINS pDevIns, PGMMMIO2HANDLE hRegion)
6883	{
6884	return pDevIns->pHlpR3->pfnMmio2QueryAndResetDirtyBitmap(pDevIns, hRegion, NULL, 0);
6885	}
6886
6887	/**
6888	* @copydoc PDMDEVHLPR3::pfnMmio2ControlDirtyPageTracking
6889	*/
6890	DECLINLINE(int) PDMDevHlpMmio2ControlDirtyPageTracking(PPDMDEVINS pDevIns, PGMMMIO2HANDLE hRegion, bool fEnabled)
6891	{
6892	return pDevIns->pHlpR3->pfnMmio2ControlDirtyPageTracking(pDevIns, hRegion, fEnabled);
6893	}
6894
6895	#endif /* IN_RING3 */
6896
6897	/**
6898	* @copydoc PDMDEVHLPR3::pfnMmioMapMmio2Page
6899	*/
6900	DECLINLINE(int) PDMDevHlpMmioMapMmio2Page(PPDMDEVINS pDevIns, IOMMMIOHANDLE hRegion, RTGCPHYS offRegion,
6901	uint64_t hMmio2, RTGCPHYS offMmio2, uint64_t fPageFlags)
6902	{
6903	return pDevIns->CTX_SUFF(pHlp)->pfnMmioMapMmio2Page(pDevIns, hRegion, offRegion, hMmio2, offMmio2, fPageFlags);
6904	}
6905
6906	/**
6907	* @copydoc PDMDEVHLPR3::pfnMmioResetRegion
6908	*/
6909	DECLINLINE(int) PDMDevHlpMmioResetRegion(PPDMDEVINS pDevIns, IOMMMIOHANDLE hRegion)
6910	{
6911	return pDevIns->CTX_SUFF(pHlp)->pfnMmioResetRegion(pDevIns, hRegion);
6912	}
6913
6914	#if !defined(IN_RING3) \|\| defined(DOXYGEN_RUNNING)
6915
6916	/**
6917	* @copydoc PDMDEVHLPR0::pfnMmio2SetUpContext
6918	*/
6919	DECLINLINE(int) PDMDevHlpMmio2SetUpContext(PPDMDEVINS pDevIns, PGMMMIO2HANDLE hRegion,
6920	size_t offSub, size_t cbSub, void **ppvMapping)
6921	{
6922	return pDevIns->CTX_SUFF(pHlp)->pfnMmio2SetUpContext(pDevIns, hRegion, offSub, cbSub, ppvMapping);
6923	}
6924
6925	#endif /* !IN_RING3 \|\| DOXYGEN_RUNNING */
6926	#ifdef IN_RING3
6927
6928	/**
6929	* @copydoc PDMDEVHLPR3::pfnROMRegister
6930	*/
6931	DECLINLINE(int) PDMDevHlpROMRegister(PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, uint32_t cbRange,
6932	const void pvBinary, uint32_t cbBinary, uint32_t fFlags, const char pszDesc)
6933	{
6934	return pDevIns->pHlpR3->pfnROMRegister(pDevIns, GCPhysStart, cbRange, pvBinary, cbBinary, fFlags, pszDesc);
6935	}
6936
6937	/**
6938	* @copydoc PDMDEVHLPR3::pfnROMProtectShadow
6939	*/
6940	DECLINLINE(int) PDMDevHlpROMProtectShadow(PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, uint32_t cbRange, PGMROMPROT enmProt)
6941	{
6942	return pDevIns->pHlpR3->pfnROMProtectShadow(pDevIns, GCPhysStart, cbRange, enmProt);
6943	}
6944
6945	/**
6946	* Register a save state data unit.
6947	*
6948	* @returns VBox status.
6949	* @param pDevIns The device instance.
6950	* @param uVersion Data layout version number.
6951	* @param cbGuess The approximate amount of data in the unit.
6952	* Only for progress indicators.
6953	* @param pfnSaveExec Execute save callback, optional.
6954	* @param pfnLoadExec Execute load callback, optional.
6955	*/
6956	DECLINLINE(int) PDMDevHlpSSMRegister(PPDMDEVINS pDevIns, uint32_t uVersion, size_t cbGuess,
6957	PFNSSMDEVSAVEEXEC pfnSaveExec, PFNSSMDEVLOADEXEC pfnLoadExec)
6958	{
6959	return pDevIns->pHlpR3->pfnSSMRegister(pDevIns, uVersion, cbGuess, NULL /pszBefore/,
6960	NULL /pfnLivePrep/, NULL /pfnLiveExec/, NULL /pfnLiveDone/,
6961	NULL /pfnSavePrep/, pfnSaveExec, NULL /pfnSaveDone/,
6962	NULL /pfnLoadPrep/, pfnLoadExec, NULL /pfnLoadDone/);
6963	}
6964
6965	/**
6966	* Register a save state data unit with a live save callback as well.
6967	*
6968	* @returns VBox status.
6969	* @param pDevIns The device instance.
6970	* @param uVersion Data layout version number.
6971	* @param cbGuess The approximate amount of data in the unit.
6972	* Only for progress indicators.
6973	* @param pfnLiveExec Execute live callback, optional.
6974	* @param pfnSaveExec Execute save callback, optional.
6975	* @param pfnLoadExec Execute load callback, optional.
6976	*/
6977	DECLINLINE(int) PDMDevHlpSSMRegister3(PPDMDEVINS pDevIns, uint32_t uVersion, size_t cbGuess,
6978	PFNSSMDEVLIVEEXEC pfnLiveExec, PFNSSMDEVSAVEEXEC pfnSaveExec, PFNSSMDEVLOADEXEC pfnLoadExec)
6979	{
6980	return pDevIns->pHlpR3->pfnSSMRegister(pDevIns, uVersion, cbGuess, NULL /pszBefore/,
6981	NULL /pfnLivePrep/, pfnLiveExec, NULL /pfnLiveDone/,
6982	NULL /pfnSavePrep/, pfnSaveExec, NULL /pfnSaveDone/,
6983	NULL /pfnLoadPrep/, pfnLoadExec, NULL /pfnLoadDone/);
6984	}
6985
6986	/**
6987	* @copydoc PDMDEVHLPR3::pfnSSMRegister
6988	*/
6989	DECLINLINE(int) PDMDevHlpSSMRegisterEx(PPDMDEVINS pDevIns, uint32_t uVersion, size_t cbGuess, const char *pszBefore,
6990	PFNSSMDEVLIVEPREP pfnLivePrep, PFNSSMDEVLIVEEXEC pfnLiveExec, PFNSSMDEVLIVEVOTE pfnLiveVote,
6991	PFNSSMDEVSAVEPREP pfnSavePrep, PFNSSMDEVSAVEEXEC pfnSaveExec, PFNSSMDEVSAVEDONE pfnSaveDone,
6992	PFNSSMDEVLOADPREP pfnLoadPrep, PFNSSMDEVLOADEXEC pfnLoadExec, PFNSSMDEVLOADDONE pfnLoadDone)
6993	{
6994	return pDevIns->pHlpR3->pfnSSMRegister(pDevIns, uVersion, cbGuess, pszBefore,
6995	pfnLivePrep, pfnLiveExec, pfnLiveVote,
6996	pfnSavePrep, pfnSaveExec, pfnSaveDone,
6997	pfnLoadPrep, pfnLoadExec, pfnLoadDone);
6998	}
6999
7000	/**
7001	* @copydoc PDMDEVHLPR3::pfnSSMRegisterLegacy
7002	*/
7003	DECLINLINE(int) PDMDevHlpSSMRegisterLegacy(PPDMDEVINS pDevIns, const char *pszOldName, PFNSSMDEVLOADPREP pfnLoadPrep,
7004	PFNSSMDEVLOADEXEC pfnLoadExec, PFNSSMDEVLOADDONE pfnLoadDone)
7005	{
7006	return pDevIns->pHlpR3->pfnSSMRegisterLegacy(pDevIns, pszOldName, pfnLoadPrep, pfnLoadExec, pfnLoadDone);
7007	}
7008
7009	/**
7010	* @copydoc PDMDEVHLPR3::pfnTimerCreate
7011	*/
7012	DECLINLINE(int) PDMDevHlpTimerCreate(PPDMDEVINS pDevIns, TMCLOCK enmClock, PFNTMTIMERDEV pfnCallback, void *pvUser,
7013	uint32_t fFlags, const char *pszDesc, PTMTIMERHANDLE phTimer)
7014	{
7015	return pDevIns->pHlpR3->pfnTimerCreate(pDevIns, enmClock, pfnCallback, pvUser, fFlags, pszDesc, phTimer);
7016	}
7017
7018	#endif /* IN_RING3 */
7019
7020	/**
7021	* @copydoc PDMDEVHLPR3::pfnTimerFromMicro
7022	*/
7023	DECLINLINE(uint64_t) PDMDevHlpTimerFromMicro(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cMicroSecs)
7024	{
7025	return pDevIns->CTX_SUFF(pHlp)->pfnTimerFromMicro(pDevIns, hTimer, cMicroSecs);
7026	}
7027
7028	/**
7029	* @copydoc PDMDEVHLPR3::pfnTimerFromMilli
7030	*/
7031	DECLINLINE(uint64_t) PDMDevHlpTimerFromMilli(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cMilliSecs)
7032	{
7033	return pDevIns->CTX_SUFF(pHlp)->pfnTimerFromMilli(pDevIns, hTimer, cMilliSecs);
7034	}
7035
7036	/**
7037	* @copydoc PDMDEVHLPR3::pfnTimerFromNano
7038	*/
7039	DECLINLINE(uint64_t) PDMDevHlpTimerFromNano(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cNanoSecs)
7040	{
7041	return pDevIns->CTX_SUFF(pHlp)->pfnTimerFromNano(pDevIns, hTimer, cNanoSecs);
7042	}
7043
7044	/**
7045	* @copydoc PDMDEVHLPR3::pfnTimerGet
7046	*/
7047	DECLINLINE(uint64_t) PDMDevHlpTimerGet(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
7048	{
7049	return pDevIns->CTX_SUFF(pHlp)->pfnTimerGet(pDevIns, hTimer);
7050	}
7051
7052	/**
7053	* @copydoc PDMDEVHLPR3::pfnTimerGetFreq
7054	*/
7055	DECLINLINE(uint64_t) PDMDevHlpTimerGetFreq(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
7056	{
7057	return pDevIns->CTX_SUFF(pHlp)->pfnTimerGetFreq(pDevIns, hTimer);
7058	}
7059
7060	/**
7061	* @copydoc PDMDEVHLPR3::pfnTimerGetNano
7062	*/
7063	DECLINLINE(uint64_t) PDMDevHlpTimerGetNano(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
7064	{
7065	return pDevIns->CTX_SUFF(pHlp)->pfnTimerGetNano(pDevIns, hTimer);
7066	}
7067
7068	/**
7069	* @copydoc PDMDEVHLPR3::pfnTimerIsActive
7070	*/
7071	DECLINLINE(bool) PDMDevHlpTimerIsActive(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
7072	{
7073	return pDevIns->CTX_SUFF(pHlp)->pfnTimerIsActive(pDevIns, hTimer);
7074	}
7075
7076	/**
7077	* @copydoc PDMDEVHLPR3::pfnTimerIsLockOwner
7078	*/
7079	DECLINLINE(bool) PDMDevHlpTimerIsLockOwner(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
7080	{
7081	return pDevIns->CTX_SUFF(pHlp)->pfnTimerIsLockOwner(pDevIns, hTimer);
7082	}
7083
7084	/**
7085	* @copydoc PDMDEVHLPR3::pfnTimerLockClock
7086	*/
7087	DECLINLINE(VBOXSTRICTRC) PDMDevHlpTimerLockClock(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, int rcBusy)
7088	{
7089	return pDevIns->CTX_SUFF(pHlp)->pfnTimerLockClock(pDevIns, hTimer, rcBusy);
7090	}
7091
7092	/**
7093	* @copydoc PDMDEVHLPR3::pfnTimerLockClock2
7094	*/
7095	DECLINLINE(VBOXSTRICTRC) PDMDevHlpTimerLockClock2(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, PPDMCRITSECT pCritSect, int rcBusy)
7096	{
7097	return pDevIns->CTX_SUFF(pHlp)->pfnTimerLockClock2(pDevIns, hTimer, pCritSect, rcBusy);
7098	}
7099
7100	/**
7101	* @copydoc PDMDEVHLPR3::pfnTimerSet
7102	*/
7103	DECLINLINE(int) PDMDevHlpTimerSet(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t uExpire)
7104	{
7105	return pDevIns->CTX_SUFF(pHlp)->pfnTimerSet(pDevIns, hTimer, uExpire);
7106	}
7107
7108	/**
7109	* @copydoc PDMDEVHLPR3::pfnTimerSetFrequencyHint
7110	*/
7111	DECLINLINE(int) PDMDevHlpTimerSetFrequencyHint(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint32_t uHz)
7112	{
7113	return pDevIns->CTX_SUFF(pHlp)->pfnTimerSetFrequencyHint(pDevIns, hTimer, uHz);
7114	}
7115
7116	/**
7117	* @copydoc PDMDEVHLPR3::pfnTimerSetMicro
7118	*/
7119	DECLINLINE(int) PDMDevHlpTimerSetMicro(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cMicrosToNext)
7120	{
7121	return pDevIns->CTX_SUFF(pHlp)->pfnTimerSetMicro(pDevIns, hTimer, cMicrosToNext);
7122	}
7123
7124	/**
7125	* @copydoc PDMDEVHLPR3::pfnTimerSetMillies
7126	*/
7127	DECLINLINE(int) PDMDevHlpTimerSetMillies(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cMilliesToNext)
7128	{
7129	return pDevIns->CTX_SUFF(pHlp)->pfnTimerSetMillies(pDevIns, hTimer, cMilliesToNext);
7130	}
7131
7132	/**
7133	* @copydoc PDMDEVHLPR3::pfnTimerSetNano
7134	*/
7135	DECLINLINE(int) PDMDevHlpTimerSetNano(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cNanosToNext)
7136	{
7137	return pDevIns->CTX_SUFF(pHlp)->pfnTimerSetNano(pDevIns, hTimer, cNanosToNext);
7138	}
7139
7140	/**
7141	* @copydoc PDMDEVHLPR3::pfnTimerSetRelative
7142	*/
7143	DECLINLINE(int) PDMDevHlpTimerSetRelative(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cTicksToNext, uint64_t *pu64Now)
7144	{
7145	return pDevIns->CTX_SUFF(pHlp)->pfnTimerSetRelative(pDevIns, hTimer, cTicksToNext, pu64Now);
7146	}
7147
7148	/**
7149	* @copydoc PDMDEVHLPR3::pfnTimerStop
7150	*/
7151	DECLINLINE(int) PDMDevHlpTimerStop(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
7152	{
7153	return pDevIns->CTX_SUFF(pHlp)->pfnTimerStop(pDevIns, hTimer);
7154	}
7155
7156	/**
7157	* @copydoc PDMDEVHLPR3::pfnTimerUnlockClock
7158	*/
7159	DECLINLINE(void) PDMDevHlpTimerUnlockClock(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
7160	{
7161	pDevIns->CTX_SUFF(pHlp)->pfnTimerUnlockClock(pDevIns, hTimer);
7162	}
7163
7164	/**
7165	* @copydoc PDMDEVHLPR3::pfnTimerUnlockClock2
7166	*/
7167	DECLINLINE(void) PDMDevHlpTimerUnlockClock2(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, PPDMCRITSECT pCritSect)
7168	{
7169	pDevIns->CTX_SUFF(pHlp)->pfnTimerUnlockClock2(pDevIns, hTimer, pCritSect);
7170	}
7171
7172	#ifdef IN_RING3
7173
7174	/**
7175	* @copydoc PDMDEVHLPR3::pfnTimerSetCritSect
7176	*/
7177	DECLINLINE(int) PDMDevHlpTimerSetCritSect(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, PPDMCRITSECT pCritSect)
7178	{
7179	return pDevIns->pHlpR3->pfnTimerSetCritSect(pDevIns, hTimer, pCritSect);
7180	}
7181
7182	/**
7183	* @copydoc PDMDEVHLPR3::pfnTimerSave
7184	*/
7185	DECLINLINE(int) PDMDevHlpTimerSave(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, PSSMHANDLE pSSM)
7186	{
7187	return pDevIns->pHlpR3->pfnTimerSave(pDevIns, hTimer, pSSM);
7188	}
7189
7190	/**
7191	* @copydoc PDMDEVHLPR3::pfnTimerLoad
7192	*/
7193	DECLINLINE(int) PDMDevHlpTimerLoad(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, PSSMHANDLE pSSM)
7194	{
7195	return pDevIns->pHlpR3->pfnTimerLoad(pDevIns, hTimer, pSSM);
7196	}
7197
7198	/**
7199	* @copydoc PDMDEVHLPR3::pfnTimerDestroy
7200	*/
7201	DECLINLINE(int) PDMDevHlpTimerDestroy(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
7202	{
7203	return pDevIns->pHlpR3->pfnTimerDestroy(pDevIns, hTimer);
7204	}
7205
7206	/**
7207	* @copydoc PDMDEVHLPR3::pfnTMUtcNow
7208	*/
7209	DECLINLINE(PRTTIMESPEC) PDMDevHlpTMUtcNow(PPDMDEVINS pDevIns, PRTTIMESPEC pTime)
7210	{
7211	return pDevIns->pHlpR3->pfnTMUtcNow(pDevIns, pTime);
7212	}
7213
7214	#endif
7215
7216	/**
7217	* Read physical memory - unknown data usage.
7218	*
7219	* @returns VINF_SUCCESS (for now).
7220	* @param pDevIns The device instance.
7221	* @param GCPhys Physical address start reading from.
7222	* @param pvBuf Where to put the read bits.
7223	* @param cbRead How many bytes to read.
7224	* @thread Any thread, but the call may involve the emulation thread.
7225	*/
7226	DECLINLINE(int) PDMDevHlpPhysRead(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, void *pvBuf, size_t cbRead)
7227	{
7228	return pDevIns->CTX_SUFF(pHlp)->pfnPhysRead(pDevIns, GCPhys, pvBuf, cbRead, PDM_DEVHLP_PHYS_RW_F_DEFAULT);
7229	}
7230
7231	/**
7232	* Write to physical memory - unknown data usage.
7233	*
7234	* @returns VINF_SUCCESS for now, and later maybe VERR_EM_MEMORY.
7235	* @param pDevIns The device instance.
7236	* @param GCPhys Physical address to write to.
7237	* @param pvBuf What to write.
7238	* @param cbWrite How many bytes to write.
7239	* @thread Any thread, but the call may involve the emulation thread.
7240	*/
7241	DECLINLINE(int) PDMDevHlpPhysWrite(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, const void *pvBuf, size_t cbWrite)
7242	{
7243	return pDevIns->CTX_SUFF(pHlp)->pfnPhysWrite(pDevIns, GCPhys, pvBuf, cbWrite, PDM_DEVHLP_PHYS_RW_F_DEFAULT);
7244	}
7245
7246	/**
7247	* Read physical memory - reads meta data processed by the device.
7248	*
7249	* @returns VINF_SUCCESS (for now).
7250	* @param pDevIns The device instance.
7251	* @param GCPhys Physical address start reading from.
7252	* @param pvBuf Where to put the read bits.
7253	* @param cbRead How many bytes to read.
7254	* @thread Any thread, but the call may involve the emulation thread.
7255	*/
7256	DECLINLINE(int) PDMDevHlpPhysReadMeta(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, void *pvBuf, size_t cbRead)
7257	{
7258	return pDevIns->CTX_SUFF(pHlp)->pfnPhysRead(pDevIns, GCPhys, pvBuf, cbRead, PDM_DEVHLP_PHYS_RW_F_DATA_META);
7259	}
7260
7261	/**
7262	* Write to physical memory - written data was created/altered by the device.
7263	*
7264	* @returns VINF_SUCCESS for now, and later maybe VERR_EM_MEMORY.
7265	* @param pDevIns The device instance.
7266	* @param GCPhys Physical address to write to.
7267	* @param pvBuf What to write.
7268	* @param cbWrite How many bytes to write.
7269	* @thread Any thread, but the call may involve the emulation thread.
7270	*/
7271	DECLINLINE(int) PDMDevHlpPhysWriteMeta(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, const void *pvBuf, size_t cbWrite)
7272	{
7273	return pDevIns->CTX_SUFF(pHlp)->pfnPhysWrite(pDevIns, GCPhys, pvBuf, cbWrite, PDM_DEVHLP_PHYS_RW_F_DATA_META);
7274	}
7275
7276	/**
7277	* Read physical memory - read data will not be touched by the device.
7278	*
7279	* @returns VINF_SUCCESS (for now).
7280	* @param pDevIns The device instance.
7281	* @param GCPhys Physical address start reading from.
7282	* @param pvBuf Where to put the read bits.
7283	* @param cbRead How many bytes to read.
7284	* @thread Any thread, but the call may involve the emulation thread.
7285	*/
7286	DECLINLINE(int) PDMDevHlpPhysReadUser(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, void *pvBuf, size_t cbRead)
7287	{
7288	return pDevIns->CTX_SUFF(pHlp)->pfnPhysRead(pDevIns, GCPhys, pvBuf, cbRead, PDM_DEVHLP_PHYS_RW_F_DATA_USER);
7289	}
7290
7291	/**
7292	* Write to physical memory - written data was not touched/created by the device.
7293	*
7294	* @returns VINF_SUCCESS for now, and later maybe VERR_EM_MEMORY.
7295	* @param pDevIns The device instance.
7296	* @param GCPhys Physical address to write to.
7297	* @param pvBuf What to write.
7298	* @param cbWrite How many bytes to write.
7299	* @thread Any thread, but the call may involve the emulation thread.
7300	*/
7301	DECLINLINE(int) PDMDevHlpPhysWriteUser(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, const void *pvBuf, size_t cbWrite)
7302	{
7303	return pDevIns->CTX_SUFF(pHlp)->pfnPhysWrite(pDevIns, GCPhys, pvBuf, cbWrite, PDM_DEVHLP_PHYS_RW_F_DATA_USER);
7304	}
7305
7306	#ifdef IN_RING3
7307
7308	/**
7309	* @copydoc PDMDEVHLPR3::pfnPhysGCPhys2CCPtr
7310	*/
7311	DECLINLINE(int) PDMDevHlpPhysGCPhys2CCPtr(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, uint32_t fFlags, void **ppv, PPGMPAGEMAPLOCK pLock)
7312	{
7313	return pDevIns->CTX_SUFF(pHlp)->pfnPhysGCPhys2CCPtr(pDevIns, GCPhys, fFlags, ppv, pLock);
7314	}
7315
7316	/**
7317	* @copydoc PDMDEVHLPR3::pfnPhysGCPhys2CCPtrReadOnly
7318	*/
7319	DECLINLINE(int) PDMDevHlpPhysGCPhys2CCPtrReadOnly(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, uint32_t fFlags, void const **ppv,
7320	PPGMPAGEMAPLOCK pLock)
7321	{
7322	return pDevIns->CTX_SUFF(pHlp)->pfnPhysGCPhys2CCPtrReadOnly(pDevIns, GCPhys, fFlags, ppv, pLock);
7323	}
7324
7325	/**
7326	* @copydoc PDMDEVHLPR3::pfnPhysReleasePageMappingLock
7327	*/
7328	DECLINLINE(void) PDMDevHlpPhysReleasePageMappingLock(PPDMDEVINS pDevIns, PPGMPAGEMAPLOCK pLock)
7329	{
7330	pDevIns->CTX_SUFF(pHlp)->pfnPhysReleasePageMappingLock(pDevIns, pLock);
7331	}
7332
7333	/**
7334	* @copydoc PDMDEVHLPR3::pfnPhysBulkGCPhys2CCPtr
7335	*/
7336	DECLINLINE(int) PDMDevHlpPhysBulkGCPhys2CCPtr(PPDMDEVINS pDevIns, uint32_t cPages, PCRTGCPHYS paGCPhysPages,
7337	uint32_t fFlags, void **papvPages, PPGMPAGEMAPLOCK paLocks)
7338	{
7339	return pDevIns->CTX_SUFF(pHlp)->pfnPhysBulkGCPhys2CCPtr(pDevIns, cPages, paGCPhysPages, fFlags, papvPages, paLocks);
7340	}
7341
7342	/**
7343	* @copydoc PDMDEVHLPR3::pfnPhysBulkGCPhys2CCPtrReadOnly
7344	*/
7345	DECLINLINE(int) PDMDevHlpPhysBulkGCPhys2CCPtrReadOnly(PPDMDEVINS pDevIns, uint32_t cPages, PCRTGCPHYS paGCPhysPages,
7346	uint32_t fFlags, void const **papvPages, PPGMPAGEMAPLOCK paLocks)
7347	{
7348	return pDevIns->CTX_SUFF(pHlp)->pfnPhysBulkGCPhys2CCPtrReadOnly(pDevIns, cPages, paGCPhysPages, fFlags, papvPages, paLocks);
7349	}
7350
7351	/**
7352	* @copydoc PDMDEVHLPR3::pfnPhysBulkReleasePageMappingLocks
7353	*/
7354	DECLINLINE(void) PDMDevHlpPhysBulkReleasePageMappingLocks(PPDMDEVINS pDevIns, uint32_t cPages, PPGMPAGEMAPLOCK paLocks)
7355	{
7356	pDevIns->CTX_SUFF(pHlp)->pfnPhysBulkReleasePageMappingLocks(pDevIns, cPages, paLocks);
7357	}
7358
7359	/**
7360	* @copydoc PDMDEVHLPR3::pfnPhysIsGCPhysNormal
7361	*/
7362	DECLINLINE(bool) PDMDevHlpPhysIsGCPhysNormal(PPDMDEVINS pDevIns, RTGCPHYS GCPhys)
7363	{
7364	return pDevIns->CTX_SUFF(pHlp)->pfnPhysIsGCPhysNormal(pDevIns, GCPhys);
7365	}
7366
7367	/**
7368	* @copydoc PDMDEVHLPR3::pfnPhysChangeMemBalloon
7369	*/
7370	DECLINLINE(int) PDMDevHlpPhysChangeMemBalloon(PPDMDEVINS pDevIns, bool fInflate, unsigned cPages, RTGCPHYS *paPhysPage)
7371	{
7372	return pDevIns->CTX_SUFF(pHlp)->pfnPhysChangeMemBalloon(pDevIns, fInflate, cPages, paPhysPage);
7373	}
7374
7375	/**
7376	* @copydoc PDMDEVHLPR3::pfnCpuGetGuestArch
7377	*/
7378	DECLINLINE(CPUMARCH) PDMDevHlpCpuGetGuestArch(PPDMDEVINS pDevIns)
7379	{
7380	return pDevIns->CTX_SUFF(pHlp)->pfnCpuGetGuestArch(pDevIns);
7381	}
7382
7383	/**
7384	* Returns a flag whether the current guest CPU architecture is x86.
7385	*
7386	* @returns Flag whether the current guest architecture is x86.
7387	* @param pDevIns The device instance.
7388	*/
7389	DECLINLINE(bool) PDMDevHlpCpuIsGuestArchX86(PPDMDEVINS pDevIns)
7390	{
7391	return pDevIns->CTX_SUFF(pHlp)->pfnCpuGetGuestArch(pDevIns) == kCpumArch_X86;
7392	}
7393
7394	/**
7395	* Returns a flag whether the current guest CPU architecture is ARM.
7396	*
7397	* @returns Flag whether the current guest architecture is ARM.
7398	* @param pDevIns The device instance.
7399	*/
7400	DECLINLINE(bool) PDMDevHlpCpuIsGuestArchArm(PPDMDEVINS pDevIns)
7401	{
7402	return pDevIns->CTX_SUFF(pHlp)->pfnCpuGetGuestArch(pDevIns) == kCpumArch_Arm;
7403	}
7404
7405	/**
7406	* @copydoc PDMDEVHLPR3::pfnCpuGetGuestMicroarch
7407	*/
7408	DECLINLINE(CPUMMICROARCH) PDMDevHlpCpuGetGuestMicroarch(PPDMDEVINS pDevIns)
7409	{
7410	return pDevIns->CTX_SUFF(pHlp)->pfnCpuGetGuestMicroarch(pDevIns);
7411	}
7412
7413	/**
7414	* @copydoc PDMDEVHLPR3::pfnCpuGetGuestScalableBusFrequency
7415	*/
7416	DECLINLINE(uint64_t) PDMDevHlpCpuGetGuestScalableBusFrequency(PPDMDEVINS pDevIns)
7417	{
7418	return pDevIns->CTX_SUFF(pHlp)->pfnCpuGetGuestScalableBusFrequency(pDevIns);
7419	}
7420
7421	/**
7422	* @copydoc PDMDEVHLPR3::pfnCpuGetGuestAddrWidths
7423	*/
7424	DECLINLINE(void) PDMDevHlpCpuGetGuestAddrWidths(PPDMDEVINS pDevIns, uint8_t pcPhysAddrWidth, uint8_t pcLinearAddrWidth)
7425	{
7426	pDevIns->CTX_SUFF(pHlp)->pfnCpuGetGuestAddrWidths(pDevIns, pcPhysAddrWidth, pcLinearAddrWidth);
7427	}
7428
7429	/**
7430	* @copydoc PDMDEVHLPR3::pfnPhysReadGCVirt
7431	*/
7432	DECLINLINE(int) PDMDevHlpPhysReadGCVirt(PPDMDEVINS pDevIns, void *pvDst, RTGCPTR GCVirtSrc, size_t cb)
7433	{
7434	return pDevIns->pHlpR3->pfnPhysReadGCVirt(pDevIns, pvDst, GCVirtSrc, cb);
7435	}
7436
7437	/**
7438	* @copydoc PDMDEVHLPR3::pfnPhysWriteGCVirt
7439	*/
7440	DECLINLINE(int) PDMDevHlpPhysWriteGCVirt(PPDMDEVINS pDevIns, RTGCPTR GCVirtDst, const void *pvSrc, size_t cb)
7441	{
7442	return pDevIns->pHlpR3->pfnPhysWriteGCVirt(pDevIns, GCVirtDst, pvSrc, cb);
7443	}
7444
7445	/**
7446	* @copydoc PDMDEVHLPR3::pfnPhysGCPtr2GCPhys
7447	*/
7448	DECLINLINE(int) PDMDevHlpPhysGCPtr2GCPhys(PPDMDEVINS pDevIns, RTGCPTR GCPtr, PRTGCPHYS pGCPhys)
7449	{
7450	return pDevIns->pHlpR3->pfnPhysGCPtr2GCPhys(pDevIns, GCPtr, pGCPhys);
7451	}
7452
7453	/**
7454	* @copydoc PDMDEVHLPR3::pfnMMHeapAlloc
7455	*/
7456	DECLINLINE(void *) PDMDevHlpMMHeapAlloc(PPDMDEVINS pDevIns, size_t cb)
7457	{
7458	return pDevIns->pHlpR3->pfnMMHeapAlloc(pDevIns, cb);
7459	}
7460
7461	/**
7462	* @copydoc PDMDEVHLPR3::pfnMMHeapAllocZ
7463	*/
7464	DECLINLINE(void *) PDMDevHlpMMHeapAllocZ(PPDMDEVINS pDevIns, size_t cb)
7465	{
7466	return pDevIns->pHlpR3->pfnMMHeapAllocZ(pDevIns, cb);
7467	}
7468
7469	/**
7470	* Allocating string printf.
7471	*
7472	* @returns Pointer to the string.
7473	* @param pDevIns The device instance.
7474	* @param enmTag The statistics tag.
7475	* @param pszFormat The format string.
7476	* @param ... Format arguments.
7477	*/
7478	DECLINLINE(char ) RT_IPRT_FORMAT_ATTR(2, 3) PDMDevHlpMMHeapAPrintf(PPDMDEVINS pDevIns, MMTAG enmTag, const char pszFormat, ...)
7479	{
7480	va_list va;
7481	va_start(va, pszFormat);
7482	char *psz = pDevIns->pHlpR3->pfnMMHeapAPrintfV(pDevIns, enmTag, pszFormat, va);
7483	va_end(va);
7484
7485	return psz;
7486	}
7487
7488	/**
7489	* @copydoc PDMDEVHLPR3::pfnMMHeapFree
7490	*/
7491	DECLINLINE(void) PDMDevHlpMMHeapFree(PPDMDEVINS pDevIns, void *pv)
7492	{
7493	pDevIns->pHlpR3->pfnMMHeapFree(pDevIns, pv);
7494	}
7495
7496	/**
7497	* @copydoc PDMDEVHLPR3::pfnMMPhysGetRamSize
7498	*/
7499	DECLINLINE(uint64_t) PDMDevHlpMMPhysGetRamSize(PPDMDEVINS pDevIns)
7500	{
7501	return pDevIns->pHlpR3->pfnMMPhysGetRamSize(pDevIns);
7502	}
7503
7504	/**
7505	* @copydoc PDMDEVHLPR3::pfnMMPhysGetRamSizeBelow4GB
7506	*/
7507	DECLINLINE(uint32_t) PDMDevHlpMMPhysGetRamSizeBelow4GB(PPDMDEVINS pDevIns)
7508	{
7509	return pDevIns->pHlpR3->pfnMMPhysGetRamSizeBelow4GB(pDevIns);
7510	}
7511
7512	/**
7513	* @copydoc PDMDEVHLPR3::pfnMMPhysGetRamSizeAbove4GB
7514	*/
7515	DECLINLINE(uint64_t) PDMDevHlpMMPhysGetRamSizeAbove4GB(PPDMDEVINS pDevIns)
7516	{
7517	return pDevIns->pHlpR3->pfnMMPhysGetRamSizeAbove4GB(pDevIns);
7518	}
7519	#endif /* IN_RING3 */
7520
7521	/**
7522	* @copydoc PDMDEVHLPR3::pfnVMState
7523	*/
7524	DECLINLINE(VMSTATE) PDMDevHlpVMState(PPDMDEVINS pDevIns)
7525	{
7526	return pDevIns->CTX_SUFF(pHlp)->pfnVMState(pDevIns);
7527	}
7528
7529	#ifdef IN_RING3
7530
7531	/**
7532	* @copydoc PDMDEVHLPR3::pfnVMTeleportedAndNotFullyResumedYet
7533	*/
7534	DECLINLINE(bool) PDMDevHlpVMTeleportedAndNotFullyResumedYet(PPDMDEVINS pDevIns)
7535	{
7536	return pDevIns->pHlpR3->pfnVMTeleportedAndNotFullyResumedYet(pDevIns);
7537	}
7538
7539	/**
7540	* Set the VM error message
7541	*
7542	* @returns rc.
7543	* @param pDevIns The device instance.
7544	* @param rc VBox status code.
7545	* @param SRC_POS Use RT_SRC_POS.
7546	* @param pszFormat Error message format string.
7547	* @param ... Error message arguments.
7548	* @sa VMSetError
7549	*/
7550	DECLINLINE(int) RT_IPRT_FORMAT_ATTR(6, 7) PDMDevHlpVMSetError(PPDMDEVINS pDevIns, const int rc, RT_SRC_POS_DECL,
7551	const char *pszFormat, ...)
7552	{
7553	va_list va;
7554	va_start(va, pszFormat);
7555	pDevIns->CTX_SUFF(pHlp)->pfnVMSetErrorV(pDevIns, rc, RT_SRC_POS_ARGS, pszFormat, va);
7556	va_end(va);
7557	return rc;
7558	}
7559
7560	/**
7561	* Set the VM runtime error message
7562	*
7563	* @returns VBox status code.
7564	* @param pDevIns The device instance.
7565	* @param fFlags The action flags. See VMSETRTERR_FLAGS_*.
7566	* @param pszErrorId Error ID string.
7567	* @param pszFormat Error message format string.
7568	* @param ... Error message arguments.
7569	* @sa VMSetRuntimeError
7570	*/
7571	DECLINLINE(int) RT_IPRT_FORMAT_ATTR(4, 5) PDMDevHlpVMSetRuntimeError(PPDMDEVINS pDevIns, uint32_t fFlags, const char *pszErrorId,
7572	const char *pszFormat, ...)
7573	{
7574	va_list va;
7575	int rc;
7576	va_start(va, pszFormat);
7577	rc = pDevIns->CTX_SUFF(pHlp)->pfnVMSetRuntimeErrorV(pDevIns, fFlags, pszErrorId, pszFormat, va);
7578	va_end(va);
7579	return rc;
7580	}
7581
7582	/**
7583	* @copydoc PDMDEVHLPR3::pfnVMWaitForDeviceReady
7584	*/
7585	DECLINLINE(int) PDMDevHlpVMWaitForDeviceReady(PPDMDEVINS pDevIns, VMCPUID idCpu)
7586	{
7587	return pDevIns->CTX_SUFF(pHlp)->pfnVMWaitForDeviceReady(pDevIns, idCpu);
7588	}
7589
7590	/**
7591	* @copydoc PDMDEVHLPR3::pfnVMNotifyCpuDeviceReady
7592	*/
7593	DECLINLINE(int) PDMDevHlpVMNotifyCpuDeviceReady(PPDMDEVINS pDevIns, VMCPUID idCpu)
7594	{
7595	return pDevIns->CTX_SUFF(pHlp)->pfnVMNotifyCpuDeviceReady(pDevIns, idCpu);
7596	}
7597
7598	/**
7599	* Convenience wrapper for VMR3ReqCallU.
7600	*
7601	* This assumes (1) you're calling a function that returns an VBox status code
7602	* and that you do not wish to wait for it to complete.
7603	*
7604	* @returns VBox status code returned by VMR3ReqCallVU.
7605	*
7606	* @param pDevIns The device instance.
7607	* @param idDstCpu The destination CPU(s). Either a specific CPU ID or
7608	* one of the following special values:
7609	* VMCPUID_ANY, VMCPUID_ANY_QUEUE, VMCPUID_ALL or VMCPUID_ALL_REVERSE.
7610	* @param pfnFunction Pointer to the function to call.
7611	* @param cArgs Number of arguments following in the ellipsis.
7612	* @param ... Argument list.
7613	*
7614	* @remarks See remarks on VMR3ReqCallVU.
7615	*/
7616	DECLINLINE(int) RT_IPRT_CALLREQ_ATTR(3, 4, 5)
7617	PDMDevHlpVMReqCallNoWait(PPDMDEVINS pDevIns, VMCPUID idDstCpu, PFNRT pfnFunction, unsigned cArgs, ...)
7618	{
7619	va_list Args;
7620	va_start(Args, cArgs);
7621	int rc = pDevIns->CTX_SUFF(pHlp)->pfnVMReqCallNoWaitV(pDevIns, idDstCpu, pfnFunction, cArgs, Args);
7622	va_end(Args);
7623	return rc;
7624	}
7625
7626	/**
7627	* Convenience wrapper for VMR3ReqCallU.
7628	*
7629	* This assumes (1) you're calling a function that returns void, (2) that you
7630	* wish to wait for ever for it to return, and (3) that it's priority request
7631	* that can be safely be handled during async suspend and power off.
7632	*
7633	* @returns VBox status code of VMR3ReqCallVU.
7634	*
7635	* @param pDevIns The device instance.
7636	* @param idDstCpu The destination CPU(s). Either a specific CPU ID or
7637	* one of the following special values:
7638	* VMCPUID_ANY, VMCPUID_ANY_QUEUE, VMCPUID_ALL or VMCPUID_ALL_REVERSE.
7639	* @param pfnFunction Pointer to the function to call.
7640	* @param cArgs Number of arguments following in the ellipsis.
7641	* @param ... Argument list.
7642	*
7643	* @remarks See remarks on VMR3ReqCallVU.
7644	*/
7645	DECLINLINE(int) RT_IPRT_CALLREQ_ATTR(3, 4, 5)
7646	PDMDevHlpVMReqPriorityCallWait(PPDMDEVINS pDevIns, VMCPUID idDstCpu, PFNRT pfnFunction, unsigned cArgs, ...)
7647	{
7648	va_list Args;
7649	va_start(Args, cArgs);
7650	int rc = pDevIns->CTX_SUFF(pHlp)->pfnVMReqPriorityCallWaitV(pDevIns, idDstCpu, pfnFunction, cArgs, Args);
7651	va_end(Args);
7652	return rc;
7653	}
7654
7655	#endif /* IN_RING3 */
7656
7657	/**
7658	* VBOX_STRICT wrapper for pHlp->pfnDBGFStopV.
7659	*
7660	* @returns VBox status code which must be passed up to the VMM. This will be
7661	* VINF_SUCCESS in non-strict builds.
7662	* @param pDevIns The device instance.
7663	* @param SRC_POS Use RT_SRC_POS.
7664	* @param pszFormat Message. (optional)
7665	* @param ... Message parameters.
7666	*/
7667	DECLINLINE(int) RT_IPRT_FORMAT_ATTR(5, 6) PDMDevHlpDBGFStop(PPDMDEVINS pDevIns, RT_SRC_POS_DECL, const char *pszFormat, ...)
7668	{
7669	#ifdef VBOX_STRICT
7670	# ifdef IN_RING3
7671	int rc;
7672	va_list args;
7673	va_start(args, pszFormat);
7674	rc = pDevIns->pHlpR3->pfnDBGFStopV(pDevIns, RT_SRC_POS_ARGS, pszFormat, args);
7675	va_end(args);
7676	return rc;
7677	# else
7678	NOREF(pDevIns);
7679	NOREF(pszFile);
7680	NOREF(iLine);
7681	NOREF(pszFunction);
7682	NOREF(pszFormat);
7683	return VINF_EM_DBG_STOP;
7684	# endif
7685	#else
7686	NOREF(pDevIns);
7687	NOREF(pszFile);
7688	NOREF(iLine);
7689	NOREF(pszFunction);
7690	NOREF(pszFormat);
7691	return VINF_SUCCESS;
7692	#endif
7693	}
7694
7695	#ifdef IN_RING3
7696
7697	/**
7698	* @copydoc PDMDEVHLPR3::pfnDBGFInfoRegister
7699	*/
7700	DECLINLINE(int) PDMDevHlpDBGFInfoRegister(PPDMDEVINS pDevIns, const char pszName, const char pszDesc, PFNDBGFHANDLERDEV pfnHandler)
7701	{
7702	return pDevIns->pHlpR3->pfnDBGFInfoRegister(pDevIns, pszName, pszDesc, pfnHandler);
7703	}
7704
7705	/**
7706	* @copydoc PDMDEVHLPR3::pfnDBGFInfoRegisterArgv
7707	*/
7708	DECLINLINE(int) PDMDevHlpDBGFInfoRegisterArgv(PPDMDEVINS pDevIns, const char pszName, const char pszDesc, PFNDBGFINFOARGVDEV pfnHandler)
7709	{
7710	return pDevIns->pHlpR3->pfnDBGFInfoRegisterArgv(pDevIns, pszName, pszDesc, pfnHandler);
7711	}
7712
7713	/**
7714	* @copydoc PDMDEVHLPR3::pfnDBGFRegRegister
7715	*/
7716	DECLINLINE(int) PDMDevHlpDBGFRegRegister(PPDMDEVINS pDevIns, PCDBGFREGDESC paRegisters)
7717	{
7718	return pDevIns->pHlpR3->pfnDBGFRegRegister(pDevIns, paRegisters);
7719	}
7720
7721	/**
7722	* @copydoc PDMDEVHLPR3::pfnDBGFReportBugCheck
7723	*/
7724	DECLINLINE(VBOXSTRICTRC) PDMDevHlpDBGFReportBugCheck(PPDMDEVINS pDevIns, DBGFEVENTTYPE enmEvent, uint64_t uBugCheck,
7725	uint64_t uP1, uint64_t uP2, uint64_t uP3, uint64_t uP4)
7726	{
7727	return pDevIns->pHlpR3->pfnDBGFReportBugCheck(pDevIns, enmEvent, uBugCheck, uP1, uP2, uP3, uP4);
7728	}
7729
7730	/**
7731	* @copydoc PDMDEVHLPR3::pfnDBGFCoreWrite
7732	*/
7733	DECLINLINE(int) PDMDevHlpDBGFCoreWrite(PPDMDEVINS pDevIns, const char *pszFilename, bool fReplaceFile)
7734	{
7735	return pDevIns->pHlpR3->pfnDBGFCoreWrite(pDevIns, pszFilename, fReplaceFile);
7736	}
7737
7738	/**
7739	* @copydoc PDMDEVHLPR3::pfnDBGFInfoLogHlp
7740	*/
7741	DECLINLINE(PCDBGFINFOHLP) PDMDevHlpDBGFInfoLogHlp(PPDMDEVINS pDevIns)
7742	{
7743	return pDevIns->pHlpR3->pfnDBGFInfoLogHlp(pDevIns);
7744	}
7745
7746	/**
7747	* @copydoc PDMDEVHLPR3::pfnDBGFRegNmQueryU64
7748	*/
7749	DECLINLINE(int) PDMDevHlpDBGFRegNmQueryU64(PPDMDEVINS pDevIns, VMCPUID idDefCpu, const char pszReg, uint64_t pu64)
7750	{
7751	return pDevIns->pHlpR3->pfnDBGFRegNmQueryU64(pDevIns, idDefCpu, pszReg, pu64);
7752	}
7753
7754	/**
7755	* Format a set of registers.
7756	*
7757	* This is restricted to registers from one CPU, that specified by @a idCpu.
7758	*
7759	* @returns VBox status code.
7760	* @param pDevIns The device instance.
7761	* @param idCpu The CPU ID of any CPU registers that may be
7762	* printed, pass VMCPUID_ANY if not applicable.
7763	* @param pszBuf The output buffer.
7764	* @param cbBuf The size of the output buffer.
7765	* @param pszFormat The format string. Register names are given by
7766	* %VR{name}, they take no arguments.
7767	* @param ... Argument list.
7768	*/
7769	DECLINLINE(int) RT_IPRT_FORMAT_ATTR(4, 5) PDMDevHlpDBGFRegPrintf(PPDMDEVINS pDevIns, VMCPUID idCpu, char *pszBuf, size_t cbBuf,
7770	const char *pszFormat, ...)
7771	{
7772	va_list Args;
7773	va_start(Args, pszFormat);
7774	int rc = pDevIns->pHlpR3->pfnDBGFRegPrintfV(pDevIns, idCpu, pszBuf, cbBuf, pszFormat, Args);
7775	va_end(Args);
7776	return rc;
7777	}
7778
7779	/**
7780	* @copydoc PDMDEVHLPR3::pfnSTAMRegister
7781	*/
7782	DECLINLINE(void) PDMDevHlpSTAMRegister(PPDMDEVINS pDevIns, void pvSample, STAMTYPE enmType, const char pszName, STAMUNIT enmUnit, const char *pszDesc)
7783	{
7784	pDevIns->pHlpR3->pfnSTAMRegister(pDevIns, pvSample, enmType, pszName, enmUnit, pszDesc);
7785	}
7786
7787	/**
7788	* Same as pfnSTAMRegister except that the name is specified in a
7789	* RTStrPrintf like fashion.
7790	*
7791	* @param pDevIns Device instance of the DMA.
7792	* @param pvSample Pointer to the sample.
7793	* @param enmType Sample type. This indicates what pvSample is
7794	* pointing at.
7795	* @param enmVisibility Visibility type specifying whether unused
7796	* statistics should be visible or not.
7797	* @param enmUnit Sample unit.
7798	* @param pszDesc Sample description.
7799	* @param pszName Sample name format string, unix path style. If
7800	* this does not start with a '/', the default
7801	* prefix will be prepended, otherwise it will be
7802	* used as-is.
7803	* @param ... Arguments to the format string.
7804	*/
7805	DECLINLINE(void) RT_IPRT_FORMAT_ATTR(7, 8) PDMDevHlpSTAMRegisterF(PPDMDEVINS pDevIns, void *pvSample, STAMTYPE enmType,
7806	STAMVISIBILITY enmVisibility, STAMUNIT enmUnit,
7807	const char pszDesc, const char pszName, ...)
7808	{
7809	va_list va;
7810	va_start(va, pszName);
7811	pDevIns->pHlpR3->pfnSTAMRegisterV(pDevIns, pvSample, enmType, enmVisibility, enmUnit, pszDesc, pszName, va);
7812	va_end(va);
7813	}
7814
7815	/**
7816	* @copydoc PDMDEVHLPR3::pfnSTAMDeregisterByPrefix
7817	*/
7818	DECLINLINE(int) PDMDevHlpSTAMDeregisterByPrefix(PPDMDEVINS pDevIns, const char *pszPrefix)
7819	{
7820	return pDevIns->pHlpR3->pfnSTAMDeregisterByPrefix(pDevIns, pszPrefix);
7821	}
7822
7823	/**
7824	* Registers the device with the default PCI bus.
7825	*
7826	* @returns VBox status code.
7827	* @param pDevIns The device instance.
7828	* @param pPciDev The PCI device structure.
7829	* This must be kept in the instance data.
7830	* The PCI configuration must be initialized before registration.
7831	*/
7832	DECLINLINE(int) PDMDevHlpPCIRegister(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev)
7833	{
7834	return pDevIns->pHlpR3->pfnPCIRegister(pDevIns, pPciDev, 0 /fFlags/,
7835	PDMPCIDEVREG_DEV_NO_FIRST_UNUSED, PDMPCIDEVREG_FUN_NO_FIRST_UNUSED, NULL);
7836	}
7837
7838	/**
7839	* @copydoc PDMDEVHLPR3::pfnPCIRegister
7840	*/
7841	DECLINLINE(int) PDMDevHlpPCIRegisterEx(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t fFlags,
7842	uint8_t uPciDevNo, uint8_t uPciFunNo, const char *pszName)
7843	{
7844	return pDevIns->pHlpR3->pfnPCIRegister(pDevIns, pPciDev, fFlags, uPciDevNo, uPciFunNo, pszName);
7845	}
7846
7847	/**
7848	* Initialize MSI emulation support for the first PCI device.
7849	*
7850	* @returns VBox status code.
7851	* @param pDevIns The device instance.
7852	* @param pMsiReg MSI emulation registration structure.
7853	*/
7854	DECLINLINE(int) PDMDevHlpPCIRegisterMsi(PPDMDEVINS pDevIns, PPDMMSIREG pMsiReg)
7855	{
7856	return pDevIns->pHlpR3->pfnPCIRegisterMsi(pDevIns, NULL, pMsiReg);
7857	}
7858
7859	/**
7860	* @copydoc PDMDEVHLPR3::pfnPCIRegisterMsi
7861	*/
7862	DECLINLINE(int) PDMDevHlpPCIRegisterMsiEx(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, PPDMMSIREG pMsiReg)
7863	{
7864	return pDevIns->pHlpR3->pfnPCIRegisterMsi(pDevIns, pPciDev, pMsiReg);
7865	}
7866
7867	/**
7868	* Registers a I/O port region for the default PCI device.
7869	*
7870	* @returns VBox status code.
7871	* @param pDevIns The device instance.
7872	* @param iRegion The region number.
7873	* @param cbRegion Size of the region.
7874	* @param hIoPorts Handle to the I/O port region.
7875	*/
7876	DECLINLINE(int) PDMDevHlpPCIIORegionRegisterIo(PPDMDEVINS pDevIns, uint32_t iRegion, RTGCPHYS cbRegion, IOMIOPORTHANDLE hIoPorts)
7877	{
7878	return pDevIns->pHlpR3->pfnPCIIORegionRegister(pDevIns, NULL, iRegion, cbRegion, PCI_ADDRESS_SPACE_IO,
7879	PDMPCIDEV_IORGN_F_IOPORT_HANDLE \| PDMPCIDEV_IORGN_F_NEW_STYLE, hIoPorts, NULL);
7880	}
7881
7882	/**
7883	* Registers a I/O port region for the default PCI device, custom map/unmap.
7884	*
7885	* @returns VBox status code.
7886	* @param pDevIns The device instance.
7887	* @param iRegion The region number.
7888	* @param cbRegion Size of the region.
7889	* @param pfnMapUnmap Callback for doing the mapping, optional. The
7890	* callback will be invoked holding only the PDM lock.
7891	* The device lock will _not_ be taken (due to lock
7892	* order).
7893	*/
7894	DECLINLINE(int) PDMDevHlpPCIIORegionRegisterIoCustom(PPDMDEVINS pDevIns, uint32_t iRegion, RTGCPHYS cbRegion,
7895	PFNPCIIOREGIONMAP pfnMapUnmap)
7896	{
7897	return pDevIns->pHlpR3->pfnPCIIORegionRegister(pDevIns, NULL, iRegion, cbRegion, PCI_ADDRESS_SPACE_IO,
7898	PDMPCIDEV_IORGN_F_NO_HANDLE \| PDMPCIDEV_IORGN_F_NEW_STYLE,
7899	UINT64_MAX, pfnMapUnmap);
7900	}
7901
7902	/**
7903	* Combines PDMDevHlpIoPortCreate and PDMDevHlpPCIIORegionRegisterIo, creating
7904	* and registering an I/O port region for the default PCI device.
7905	*
7906	* @returns VBox status code.
7907	* @param pDevIns The device instance to register the ports with.
7908	* @param cPorts The count of I/O ports in the region (the size).
7909	* @param iPciRegion The PCI device region.
7910	* @param pfnOut Pointer to function which is gonna handle OUT
7911	* operations. Optional.
7912	* @param pfnIn Pointer to function which is gonna handle IN operations.
7913	* Optional.
7914	* @param pvUser User argument to pass to the callbacks.
7915	* @param pszDesc Pointer to description string. This must not be freed.
7916	* @param paExtDescs Extended per-port descriptions, optional. Partial range
7917	* coverage is allowed. This must not be freed.
7918	* @param phIoPorts Where to return the I/O port range handle.
7919	*
7920	*/
7921	DECLINLINE(int) PDMDevHlpPCIIORegionCreateIo(PPDMDEVINS pDevIns, uint32_t iPciRegion, RTIOPORT cPorts,
7922	PFNIOMIOPORTNEWOUT pfnOut, PFNIOMIOPORTNEWIN pfnIn, void *pvUser,
7923	const char *pszDesc, PCIOMIOPORTDESC paExtDescs, PIOMIOPORTHANDLE phIoPorts)
7924
7925	{
7926	int rc = pDevIns->pHlpR3->pfnIoPortCreateEx(pDevIns, cPorts, 0 /fFlags/, pDevIns->apPciDevs[0], iPciRegion << 16,
7927	pfnOut, pfnIn, NULL, NULL, pvUser, pszDesc, paExtDescs, phIoPorts);
7928	if (RT_SUCCESS(rc))
7929	rc = pDevIns->pHlpR3->pfnPCIIORegionRegister(pDevIns, pDevIns->apPciDevs[0], iPciRegion, cPorts, PCI_ADDRESS_SPACE_IO,
7930	PDMPCIDEV_IORGN_F_IOPORT_HANDLE \| PDMPCIDEV_IORGN_F_NEW_STYLE,
7931	phIoPorts, NULL /pfnMapUnmap*/);
7932	return rc;
7933	}
7934
7935	/**
7936	* Registers an MMIO region for the default PCI device.
7937	*
7938	* @returns VBox status code.
7939	* @param pDevIns The device instance.
7940	* @param iRegion The region number.
7941	* @param cbRegion Size of the region.
7942	* @param enmType PCI_ADDRESS_SPACE_MEM or
7943	* PCI_ADDRESS_SPACE_MEM_PREFETCH, optionally or-ing in
7944	* PCI_ADDRESS_SPACE_BAR64 or PCI_ADDRESS_SPACE_BAR32.
7945	* @param hMmioRegion Handle to the MMIO region.
7946	* @param pfnMapUnmap Callback for doing the mapping, optional. The
7947	* callback will be invoked holding only the PDM lock.
7948	* The device lock will _not_ be taken (due to lock
7949	* order).
7950	*/
7951	DECLINLINE(int) PDMDevHlpPCIIORegionRegisterMmio(PPDMDEVINS pDevIns, uint32_t iRegion, RTGCPHYS cbRegion, PCIADDRESSSPACE enmType,
7952	IOMMMIOHANDLE hMmioRegion, PFNPCIIOREGIONMAP pfnMapUnmap)
7953	{
7954	return pDevIns->pHlpR3->pfnPCIIORegionRegister(pDevIns, NULL, iRegion, cbRegion, enmType,
7955	PDMPCIDEV_IORGN_F_MMIO_HANDLE \| PDMPCIDEV_IORGN_F_NEW_STYLE,
7956	hMmioRegion, pfnMapUnmap);
7957	}
7958
7959	/**
7960	* Registers an MMIO region for the default PCI device, extended version.
7961	*
7962	* @returns VBox status code.
7963	* @param pDevIns The device instance.
7964	* @param pPciDev The PCI device structure.
7965	* @param iRegion The region number.
7966	* @param cbRegion Size of the region.
7967	* @param enmType PCI_ADDRESS_SPACE_MEM or
7968	* PCI_ADDRESS_SPACE_MEM_PREFETCH, optionally or-ing in
7969	* PCI_ADDRESS_SPACE_BAR64 or PCI_ADDRESS_SPACE_BAR32.
7970	* @param hMmioRegion Handle to the MMIO region.
7971	* @param pfnMapUnmap Callback for doing the mapping, optional. The
7972	* callback will be invoked holding only the PDM lock.
7973	* The device lock will _not_ be taken (due to lock
7974	* order).
7975	*/
7976	DECLINLINE(int) PDMDevHlpPCIIORegionRegisterMmioEx(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t iRegion,
7977	RTGCPHYS cbRegion, PCIADDRESSSPACE enmType, IOMMMIOHANDLE hMmioRegion,
7978	PFNPCIIOREGIONMAP pfnMapUnmap)
7979	{
7980	return pDevIns->pHlpR3->pfnPCIIORegionRegister(pDevIns, pPciDev, iRegion, cbRegion, enmType,
7981	PDMPCIDEV_IORGN_F_MMIO_HANDLE \| PDMPCIDEV_IORGN_F_NEW_STYLE,
7982	hMmioRegion, pfnMapUnmap);
7983	}
7984
7985	/**
7986	* Combines PDMDevHlpMmioCreate and PDMDevHlpPCIIORegionRegisterMmio, creating
7987	* and registering an MMIO region for the default PCI device.
7988	*
7989	* @returns VBox status code.
7990	* @param pDevIns The device instance to register the ports with.
7991	* @param cbRegion The size of the region in bytes.
7992	* @param iPciRegion The PCI device region.
7993	* @param enmType PCI_ADDRESS_SPACE_MEM or
7994	* PCI_ADDRESS_SPACE_MEM_PREFETCH, optionally or-ing in
7995	* PCI_ADDRESS_SPACE_BAR64 or PCI_ADDRESS_SPACE_BAR32.
7996	* @param fFlags Flags, IOMMMIO_FLAGS_XXX.
7997	* @param pfnWrite Pointer to function which is gonna handle Write
7998	* operations.
7999	* @param pfnRead Pointer to function which is gonna handle Read
8000	* operations.
8001	* @param pvUser User argument to pass to the callbacks.
8002	* @param pszDesc Pointer to description string. This must not be freed.
8003	* @param phRegion Where to return the MMIO region handle.
8004	*
8005	*/
8006	DECLINLINE(int) PDMDevHlpPCIIORegionCreateMmio(PPDMDEVINS pDevIns, uint32_t iPciRegion, RTGCPHYS cbRegion, PCIADDRESSSPACE enmType,
8007	PFNIOMMMIONEWWRITE pfnWrite, PFNIOMMMIONEWREAD pfnRead, void *pvUser,
8008	uint32_t fFlags, const char *pszDesc, PIOMMMIOHANDLE phRegion)
8009
8010	{
8011	int rc = pDevIns->pHlpR3->pfnMmioCreateEx(pDevIns, cbRegion, fFlags, pDevIns->apPciDevs[0], iPciRegion << 16,
8012	pfnWrite, pfnRead, NULL /pfnFill/, pvUser, pszDesc, phRegion);
8013	if (RT_SUCCESS(rc))
8014	rc = pDevIns->pHlpR3->pfnPCIIORegionRegister(pDevIns, pDevIns->apPciDevs[0], iPciRegion, cbRegion, enmType,
8015	PDMPCIDEV_IORGN_F_MMIO_HANDLE \| PDMPCIDEV_IORGN_F_NEW_STYLE,
8016	phRegion, NULL /pfnMapUnmap*/);
8017	return rc;
8018	}
8019
8020
8021	/**
8022	* Registers an MMIO2 region for the default PCI device.
8023	*
8024	* @returns VBox status code.
8025	* @param pDevIns The device instance.
8026	* @param iRegion The region number.
8027	* @param cbRegion Size of the region.
8028	* @param enmType PCI_ADDRESS_SPACE_MEM or
8029	* PCI_ADDRESS_SPACE_MEM_PREFETCH, optionally or-ing in
8030	* PCI_ADDRESS_SPACE_BAR64 or PCI_ADDRESS_SPACE_BAR32.
8031	* @param hMmio2Region Handle to the MMIO2 region.
8032	*/
8033	DECLINLINE(int) PDMDevHlpPCIIORegionRegisterMmio2(PPDMDEVINS pDevIns, uint32_t iRegion, RTGCPHYS cbRegion,
8034	PCIADDRESSSPACE enmType, PGMMMIO2HANDLE hMmio2Region)
8035	{
8036	return pDevIns->pHlpR3->pfnPCIIORegionRegister(pDevIns, NULL, iRegion, cbRegion, enmType,
8037	PDMPCIDEV_IORGN_F_MMIO2_HANDLE \| PDMPCIDEV_IORGN_F_NEW_STYLE,
8038	hMmio2Region, NULL);
8039	}
8040
8041	/**
8042	* Combines PDMDevHlpMmio2Create and PDMDevHlpPCIIORegionRegisterMmio2, creating
8043	* and registering an MMIO2 region for the default PCI device, extended edition.
8044	*
8045	* @returns VBox status code.
8046	* @param pDevIns The device instance to register the ports with.
8047	* @param cbRegion The size of the region in bytes.
8048	* @param iPciRegion The PCI device region.
8049	* @param enmType PCI_ADDRESS_SPACE_MEM or
8050	* PCI_ADDRESS_SPACE_MEM_PREFETCH, optionally or-ing in
8051	* PCI_ADDRESS_SPACE_BAR64 or PCI_ADDRESS_SPACE_BAR32.
8052	* @param pszDesc Pointer to description string. This must not be freed.
8053	* @param ppvMapping Where to store the address of the ring-3 mapping of
8054	* the memory.
8055	* @param phRegion Where to return the MMIO2 region handle.
8056	*
8057	*/
8058	DECLINLINE(int) PDMDevHlpPCIIORegionCreateMmio2(PPDMDEVINS pDevIns, uint32_t iPciRegion, RTGCPHYS cbRegion,
8059	PCIADDRESSSPACE enmType, const char *pszDesc,
8060	void **ppvMapping, PPGMMMIO2HANDLE phRegion)
8061
8062	{
8063	int rc = pDevIns->pHlpR3->pfnMmio2Create(pDevIns, pDevIns->apPciDevs[0], iPciRegion << 16, cbRegion, 0 /fFlags/,
8064	pszDesc, ppvMapping, phRegion);
8065	if (RT_SUCCESS(rc))
8066	rc = pDevIns->pHlpR3->pfnPCIIORegionRegister(pDevIns, pDevIns->apPciDevs[0], iPciRegion, cbRegion, enmType,
8067	PDMPCIDEV_IORGN_F_MMIO2_HANDLE \| PDMPCIDEV_IORGN_F_NEW_STYLE,
8068	phRegion, NULL /pfnCallback*/);
8069	return rc;
8070	}
8071
8072	/**
8073	* Combines PDMDevHlpMmio2Create and PDMDevHlpPCIIORegionRegisterMmio2, creating
8074	* and registering an MMIO2 region for the default PCI device.
8075	*
8076	* @returns VBox status code.
8077	* @param pDevIns The device instance to register the ports with.
8078	* @param cbRegion The size of the region in bytes.
8079	* @param iPciRegion The PCI device region.
8080	* @param enmType PCI_ADDRESS_SPACE_MEM or
8081	* PCI_ADDRESS_SPACE_MEM_PREFETCH, optionally or-ing in
8082	* PCI_ADDRESS_SPACE_BAR64 or PCI_ADDRESS_SPACE_BAR32.
8083	* @param fMmio2Flags PGMPHYS_MMIO2_FLAGS_XXX (see pgm.h).
8084	* @param pfnMapUnmap Callback for doing the mapping, optional. The
8085	* callback will be invoked holding only the PDM lock.
8086	* The device lock will _not_ be taken (due to lock
8087	* order).
8088	* @param pszDesc Pointer to description string. This must not be freed.
8089	* @param ppvMapping Where to store the address of the ring-3 mapping of
8090	* the memory.
8091	* @param phRegion Where to return the MMIO2 region handle.
8092	*
8093	*/
8094	DECLINLINE(int) PDMDevHlpPCIIORegionCreateMmio2Ex(PPDMDEVINS pDevIns, uint32_t iPciRegion, RTGCPHYS cbRegion,
8095	PCIADDRESSSPACE enmType, uint32_t fMmio2Flags, PFNPCIIOREGIONMAP pfnMapUnmap,
8096	const char pszDesc, void *ppvMapping, PPGMMMIO2HANDLE phRegion)
8097
8098	{
8099	int rc = pDevIns->pHlpR3->pfnMmio2Create(pDevIns, pDevIns->apPciDevs[0], iPciRegion << 16, cbRegion, fMmio2Flags,
8100	pszDesc, ppvMapping, phRegion);
8101	if (RT_SUCCESS(rc))
8102	rc = pDevIns->pHlpR3->pfnPCIIORegionRegister(pDevIns, pDevIns->apPciDevs[0], iPciRegion, cbRegion, enmType,
8103	PDMPCIDEV_IORGN_F_MMIO2_HANDLE \| PDMPCIDEV_IORGN_F_NEW_STYLE,
8104	*phRegion, pfnMapUnmap);
8105	return rc;
8106	}
8107
8108	/**
8109	* @copydoc PDMDEVHLPR3::pfnPCIInterceptConfigAccesses
8110	*/
8111	DECLINLINE(int) PDMDevHlpPCIInterceptConfigAccesses(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev,
8112	PFNPCICONFIGREAD pfnRead, PFNPCICONFIGWRITE pfnWrite)
8113	{
8114	return pDevIns->pHlpR3->pfnPCIInterceptConfigAccesses(pDevIns, pPciDev, pfnRead, pfnWrite);
8115	}
8116
8117	/**
8118	* @copydoc PDMDEVHLPR3::pfnPCIConfigRead
8119	*/
8120	DECLINLINE(VBOXSTRICTRC) PDMDevHlpPCIConfigRead(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t uAddress,
8121	unsigned cb, uint32_t *pu32Value)
8122	{
8123	return pDevIns->pHlpR3->pfnPCIConfigRead(pDevIns, pPciDev, uAddress, cb, pu32Value);
8124	}
8125
8126	/**
8127	* @copydoc PDMDEVHLPR3::pfnPCIConfigWrite
8128	*/
8129	DECLINLINE(VBOXSTRICTRC) PDMDevHlpPCIConfigWrite(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t uAddress,
8130	unsigned cb, uint32_t u32Value)
8131	{
8132	return pDevIns->pHlpR3->pfnPCIConfigWrite(pDevIns, pPciDev, uAddress, cb, u32Value);
8133	}
8134
8135	#endif /* IN_RING3 */
8136
8137	/**
8138	* Bus master physical memory read from the default PCI device.
8139	*
8140	* @returns VINF_SUCCESS or VERR_PGM_PCI_PHYS_READ_BM_DISABLED, later maybe
8141	* VERR_EM_MEMORY. The informational status shall NOT be propagated!
8142	* @param pDevIns The device instance.
8143	* @param GCPhys Physical address start reading from.
8144	* @param pvBuf Where to put the read bits.
8145	* @param cbRead How many bytes to read.
8146	* @thread Any thread, but the call may involve the emulation thread.
8147	*/
8148	DECLINLINE(int) PDMDevHlpPCIPhysRead(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, void *pvBuf, size_t cbRead)
8149	{
8150	return pDevIns->CTX_SUFF(pHlp)->pfnPCIPhysRead(pDevIns, NULL, GCPhys, pvBuf, cbRead, PDM_DEVHLP_PHYS_RW_F_DEFAULT);
8151	}
8152
8153	/**
8154	* Bus master physical memory read - unknown data usage.
8155	*
8156	* @returns VINF_SUCCESS or VERR_PGM_PCI_PHYS_READ_BM_DISABLED, later maybe
8157	* VERR_EM_MEMORY. The informational status shall NOT be propagated!
8158	* @param pDevIns The device instance.
8159	* @param pPciDev The PCI device structure. If NULL the default
8160	* PCI device for this device instance is used.
8161	* @param GCPhys Physical address start reading from.
8162	* @param pvBuf Where to put the read bits.
8163	* @param cbRead How many bytes to read.
8164	* @thread Any thread, but the call may involve the emulation thread.
8165	*/
8166	DECLINLINE(int) PDMDevHlpPCIPhysReadEx(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, RTGCPHYS GCPhys, void *pvBuf, size_t cbRead)
8167	{
8168	return pDevIns->CTX_SUFF(pHlp)->pfnPCIPhysRead(pDevIns, pPciDev, GCPhys, pvBuf, cbRead, PDM_DEVHLP_PHYS_RW_F_DEFAULT);
8169	}
8170
8171	/**
8172	* Bus master physical memory read from the default PCI device.
8173	*
8174	* @returns VINF_SUCCESS or VERR_PGM_PCI_PHYS_READ_BM_DISABLED, later maybe
8175	* VERR_EM_MEMORY. The informational status shall NOT be propagated!
8176	* @param pDevIns The device instance.
8177	* @param GCPhys Physical address start reading from.
8178	* @param pvBuf Where to put the read bits.
8179	* @param cbRead How many bytes to read.
8180	* @thread Any thread, but the call may involve the emulation thread.
8181	*/
8182	DECLINLINE(int) PDMDevHlpPCIPhysReadMeta(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, void *pvBuf, size_t cbRead)
8183	{
8184	return pDevIns->CTX_SUFF(pHlp)->pfnPCIPhysRead(pDevIns, NULL, GCPhys, pvBuf, cbRead, PDM_DEVHLP_PHYS_RW_F_DATA_META);
8185	}
8186
8187	/**
8188	* Bus master physical memory read - reads meta data processed by the device.
8189	*
8190	* @returns VINF_SUCCESS or VERR_PGM_PCI_PHYS_READ_BM_DISABLED, later maybe
8191	* VERR_EM_MEMORY. The informational status shall NOT be propagated!
8192	* @param pDevIns The device instance.
8193	* @param pPciDev The PCI device structure. If NULL the default
8194	* PCI device for this device instance is used.
8195	* @param GCPhys Physical address start reading from.
8196	* @param pvBuf Where to put the read bits.
8197	* @param cbRead How many bytes to read.
8198	* @thread Any thread, but the call may involve the emulation thread.
8199	*/
8200	DECLINLINE(int) PDMDevHlpPCIPhysReadMetaEx(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, RTGCPHYS GCPhys, void *pvBuf, size_t cbRead)
8201	{
8202	return pDevIns->CTX_SUFF(pHlp)->pfnPCIPhysRead(pDevIns, pPciDev, GCPhys, pvBuf, cbRead, PDM_DEVHLP_PHYS_RW_F_DATA_META);
8203	}
8204
8205	/**
8206	* Bus master physical memory read from the default PCI device - read data will not be touched by the device.
8207	*
8208	* @returns VINF_SUCCESS or VERR_PGM_PCI_PHYS_READ_BM_DISABLED, later maybe
8209	* VERR_EM_MEMORY. The informational status shall NOT be propagated!
8210	* @param pDevIns The device instance.
8211	* @param GCPhys Physical address start reading from.
8212	* @param pvBuf Where to put the read bits.
8213	* @param cbRead How many bytes to read.
8214	* @thread Any thread, but the call may involve the emulation thread.
8215	*/
8216	DECLINLINE(int) PDMDevHlpPCIPhysReadUser(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, void *pvBuf, size_t cbRead)
8217	{
8218	return pDevIns->CTX_SUFF(pHlp)->pfnPCIPhysRead(pDevIns, NULL, GCPhys, pvBuf, cbRead, PDM_DEVHLP_PHYS_RW_F_DATA_USER);
8219	}
8220
8221	/**
8222	* Bus master physical memory read - read data will not be touched by the device.
8223	*
8224	* @returns VINF_SUCCESS or VERR_PGM_PCI_PHYS_READ_BM_DISABLED, later maybe
8225	* VERR_EM_MEMORY. The informational status shall NOT be propagated!
8226	* @param pDevIns The device instance.
8227	* @param pPciDev The PCI device structure. If NULL the default
8228	* PCI device for this device instance is used.
8229	* @param GCPhys Physical address start reading from.
8230	* @param pvBuf Where to put the read bits.
8231	* @param cbRead How many bytes to read.
8232	* @thread Any thread, but the call may involve the emulation thread.
8233	*/
8234	DECLINLINE(int) PDMDevHlpPCIPhysReadUserEx(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, RTGCPHYS GCPhys, void *pvBuf, size_t cbRead)
8235	{
8236	return pDevIns->CTX_SUFF(pHlp)->pfnPCIPhysRead(pDevIns, pPciDev, GCPhys, pvBuf, cbRead, PDM_DEVHLP_PHYS_RW_F_DATA_USER);
8237	}
8238
8239	/**
8240	* Bus master physical memory write from the default PCI device - unknown data usage.
8241	*
8242	* @returns VINF_SUCCESS or VERR_PGM_PCI_PHYS_WRITE_BM_DISABLED, later maybe
8243	* VERR_EM_MEMORY. The informational status shall NOT be propagated!
8244	* @param pDevIns The device instance.
8245	* @param GCPhys Physical address to write to.
8246	* @param pvBuf What to write.
8247	* @param cbWrite How many bytes to write.
8248	* @thread Any thread, but the call may involve the emulation thread.
8249	*/
8250	DECLINLINE(int) PDMDevHlpPCIPhysWrite(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, const void *pvBuf, size_t cbWrite)
8251	{
8252	return pDevIns->CTX_SUFF(pHlp)->pfnPCIPhysWrite(pDevIns, NULL, GCPhys, pvBuf, cbWrite, PDM_DEVHLP_PHYS_RW_F_DEFAULT);
8253	}
8254
8255	/**
8256	* Bus master physical memory write - unknown data usage.
8257	*
8258	* @returns VINF_SUCCESS or VERR_PGM_PCI_PHYS_WRITE_BM_DISABLED, later maybe
8259	* VERR_EM_MEMORY. The informational status shall NOT be propagated!
8260	* @param pDevIns The device instance.
8261	* @param pPciDev The PCI device structure. If NULL the default
8262	* PCI device for this device instance is used.
8263	* @param GCPhys Physical address to write to.
8264	* @param pvBuf What to write.
8265	* @param cbWrite How many bytes to write.
8266	* @thread Any thread, but the call may involve the emulation thread.
8267	*/
8268	DECLINLINE(int) PDMDevHlpPCIPhysWriteEx(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, RTGCPHYS GCPhys, const void *pvBuf, size_t cbWrite)
8269	{
8270	return pDevIns->CTX_SUFF(pHlp)->pfnPCIPhysWrite(pDevIns, pPciDev, GCPhys, pvBuf, cbWrite, PDM_DEVHLP_PHYS_RW_F_DEFAULT);
8271	}
8272
8273	/**
8274	* Bus master physical memory write from the default PCI device.
8275	*
8276	* @returns VINF_SUCCESS or VERR_PGM_PCI_PHYS_WRITE_BM_DISABLED, later maybe
8277	* VERR_EM_MEMORY. The informational status shall NOT be propagated!
8278	* @param pDevIns The device instance.
8279	* @param GCPhys Physical address to write to.
8280	* @param pvBuf What to write.
8281	* @param cbWrite How many bytes to write.
8282	* @thread Any thread, but the call may involve the emulation thread.
8283	*/
8284	DECLINLINE(int) PDMDevHlpPCIPhysWriteMeta(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, const void *pvBuf, size_t cbWrite)
8285	{
8286	return pDevIns->CTX_SUFF(pHlp)->pfnPCIPhysWrite(pDevIns, NULL, GCPhys, pvBuf, cbWrite, PDM_DEVHLP_PHYS_RW_F_DATA_META);
8287	}
8288
8289	/**
8290	* Bus master physical memory write - written data was created/altered by the device.
8291	*
8292	* @returns VINF_SUCCESS or VERR_PGM_PCI_PHYS_WRITE_BM_DISABLED, later maybe
8293	* VERR_EM_MEMORY. The informational status shall NOT be propagated!
8294	* @param pDevIns The device instance.
8295	* @param pPciDev The PCI device structure. If NULL the default
8296	* PCI device for this device instance is used.
8297	* @param GCPhys Physical address to write to.
8298	* @param pvBuf What to write.
8299	* @param cbWrite How many bytes to write.
8300	* @thread Any thread, but the call may involve the emulation thread.
8301	*/
8302	DECLINLINE(int) PDMDevHlpPCIPhysWriteMetaEx(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, RTGCPHYS GCPhys, const void *pvBuf, size_t cbWrite)
8303	{
8304	return pDevIns->CTX_SUFF(pHlp)->pfnPCIPhysWrite(pDevIns, pPciDev, GCPhys, pvBuf, cbWrite, PDM_DEVHLP_PHYS_RW_F_DATA_META);
8305	}
8306
8307	/**
8308	* Bus master physical memory write from the default PCI device.
8309	*
8310	* @returns VINF_SUCCESS or VERR_PGM_PCI_PHYS_WRITE_BM_DISABLED, later maybe
8311	* VERR_EM_MEMORY. The informational status shall NOT be propagated!
8312	* @param pDevIns The device instance.
8313	* @param GCPhys Physical address to write to.
8314	* @param pvBuf What to write.
8315	* @param cbWrite How many bytes to write.
8316	* @thread Any thread, but the call may involve the emulation thread.
8317	*/
8318	DECLINLINE(int) PDMDevHlpPCIPhysWriteUser(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, const void *pvBuf, size_t cbWrite)
8319	{
8320	return pDevIns->CTX_SUFF(pHlp)->pfnPCIPhysWrite(pDevIns, NULL, GCPhys, pvBuf, cbWrite, PDM_DEVHLP_PHYS_RW_F_DATA_USER);
8321	}
8322
8323	/**
8324	* Bus master physical memory write - written data was not touched/created by the device.
8325	*
8326	* @returns VINF_SUCCESS or VERR_PGM_PCI_PHYS_WRITE_BM_DISABLED, later maybe
8327	* VERR_EM_MEMORY. The informational status shall NOT be propagated!
8328	* @param pDevIns The device instance.
8329	* @param pPciDev The PCI device structure. If NULL the default
8330	* PCI device for this device instance is used.
8331	* @param GCPhys Physical address to write to.
8332	* @param pvBuf What to write.
8333	* @param cbWrite How many bytes to write.
8334	* @thread Any thread, but the call may involve the emulation thread.
8335	*/
8336	DECLINLINE(int) PDMDevHlpPCIPhysWriteUserEx(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, RTGCPHYS GCPhys, const void *pvBuf, size_t cbWrite)
8337	{
8338	return pDevIns->CTX_SUFF(pHlp)->pfnPCIPhysWrite(pDevIns, pPciDev, GCPhys, pvBuf, cbWrite, PDM_DEVHLP_PHYS_RW_F_DATA_USER);
8339	}
8340
8341	#ifdef IN_RING3
8342	/**
8343	* @copydoc PDMDEVHLPR3::pfnPCIPhysGCPhys2CCPtr
8344	*/
8345	DECLINLINE(int) PDMDevHlpPCIPhysGCPhys2CCPtr(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, RTGCPHYS GCPhys, uint32_t fFlags,
8346	void **ppv, PPGMPAGEMAPLOCK pLock)
8347	{
8348	return pDevIns->CTX_SUFF(pHlp)->pfnPCIPhysGCPhys2CCPtr(pDevIns, pPciDev, GCPhys, fFlags, ppv, pLock);
8349	}
8350
8351	/**
8352	* @copydoc PDMDEVHLPR3::pfnPCIPhysGCPhys2CCPtrReadOnly
8353	*/
8354	DECLINLINE(int) PDMDevHlpPCIPhysGCPhys2CCPtrReadOnly(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, RTGCPHYS GCPhys, uint32_t fFlags,
8355	void const **ppv, PPGMPAGEMAPLOCK pLock)
8356	{
8357	return pDevIns->CTX_SUFF(pHlp)->pfnPCIPhysGCPhys2CCPtrReadOnly(pDevIns, pPciDev, GCPhys, fFlags, ppv, pLock);
8358	}
8359
8360	/**
8361	* @copydoc PDMDEVHLPR3::pfnPCIPhysBulkGCPhys2CCPtr
8362	*/
8363	DECLINLINE(int) PDMDevHlpPCIPhysBulkGCPhys2CCPtr(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t cPages,
8364	PCRTGCPHYS paGCPhysPages, uint32_t fFlags, void **papvPages,
8365	PPGMPAGEMAPLOCK paLocks)
8366	{
8367	return pDevIns->CTX_SUFF(pHlp)->pfnPCIPhysBulkGCPhys2CCPtr(pDevIns, pPciDev, cPages, paGCPhysPages, fFlags, papvPages,
8368	paLocks);
8369	}
8370
8371	/**
8372	* @copydoc PDMDEVHLPR3::pfnPCIPhysBulkGCPhys2CCPtrReadOnly
8373	*/
8374	DECLINLINE(int) PDMDevHlpPCIPhysBulkGCPhys2CCPtrReadOnly(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t cPages,
8375	PCRTGCPHYS paGCPhysPages, uint32_t fFlags, void const **papvPages,
8376	PPGMPAGEMAPLOCK paLocks)
8377	{
8378	return pDevIns->CTX_SUFF(pHlp)->pfnPCIPhysBulkGCPhys2CCPtrReadOnly(pDevIns, pPciDev, cPages, paGCPhysPages, fFlags,
8379	papvPages, paLocks);
8380	}
8381	#endif /* IN_RING3 */
8382
8383	/**
8384	* Sets the IRQ for the default PCI device.
8385	*
8386	* @param pDevIns The device instance.
8387	* @param iIrq IRQ number to set.
8388	* @param iLevel IRQ level. See the PDM_IRQ_LEVEL_* \#defines.
8389	* @thread Any thread, but will involve the emulation thread.
8390	*/
8391	DECLINLINE(void) PDMDevHlpPCISetIrq(PPDMDEVINS pDevIns, int iIrq, int iLevel)
8392	{
8393	pDevIns->CTX_SUFF(pHlp)->pfnPCISetIrq(pDevIns, NULL, iIrq, iLevel);
8394	}
8395
8396	/**
8397	* @copydoc PDMDEVHLPR3::pfnPCISetIrq
8398	*/
8399	DECLINLINE(void) PDMDevHlpPCISetIrqEx(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, int iIrq, int iLevel)
8400	{
8401	pDevIns->CTX_SUFF(pHlp)->pfnPCISetIrq(pDevIns, pPciDev, iIrq, iLevel);
8402	}
8403
8404	/**
8405	* Sets the IRQ for the given PCI device, but doesn't wait for EMT to process
8406	* the request when not called from EMT.
8407	*
8408	* @param pDevIns The device instance.
8409	* @param iIrq IRQ number to set.
8410	* @param iLevel IRQ level.
8411	* @thread Any thread, but will involve the emulation thread.
8412	*/
8413	DECLINLINE(void) PDMDevHlpPCISetIrqNoWait(PPDMDEVINS pDevIns, int iIrq, int iLevel)
8414	{
8415	pDevIns->CTX_SUFF(pHlp)->pfnPCISetIrq(pDevIns, NULL, iIrq, iLevel);
8416	}
8417
8418	/**
8419	* @copydoc PDMDEVHLPR3::pfnPCISetIrqNoWait
8420	*/
8421	DECLINLINE(void) PDMDevHlpPCISetIrqNoWaitEx(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, int iIrq, int iLevel)
8422	{
8423	pDevIns->CTX_SUFF(pHlp)->pfnPCISetIrq(pDevIns, pPciDev, iIrq, iLevel);
8424	}
8425
8426	/**
8427	* @copydoc PDMDEVHLPR3::pfnISASetIrq
8428	*/
8429	DECLINLINE(void) PDMDevHlpISASetIrq(PPDMDEVINS pDevIns, int iIrq, int iLevel)
8430	{
8431	pDevIns->CTX_SUFF(pHlp)->pfnISASetIrq(pDevIns, iIrq, iLevel);
8432	}
8433
8434	/**
8435	* @copydoc PDMDEVHLPR3::pfnISASetIrqNoWait
8436	*/
8437	DECLINLINE(void) PDMDevHlpISASetIrqNoWait(PPDMDEVINS pDevIns, int iIrq, int iLevel)
8438	{
8439	pDevIns->CTX_SUFF(pHlp)->pfnISASetIrq(pDevIns, iIrq, iLevel);
8440	}
8441
8442	#ifdef IN_RING3
8443
8444	/**
8445	* @copydoc PDMDEVHLPR3::pfnDriverAttach
8446	*/
8447	DECLINLINE(int) PDMDevHlpDriverAttach(PPDMDEVINS pDevIns, uint32_t iLun, PPDMIBASE pBaseInterface, PPDMIBASE ppBaseInterface, const char pszDesc)
8448	{
8449	return pDevIns->pHlpR3->pfnDriverAttach(pDevIns, iLun, pBaseInterface, ppBaseInterface, pszDesc);
8450	}
8451
8452	/**
8453	* @copydoc PDMDEVHLPR3::pfnDriverDetach
8454	*/
8455	DECLINLINE(int) PDMDevHlpDriverDetach(PPDMDEVINS pDevIns, PPDMDRVINS pDrvIns, uint32_t fFlags)
8456	{
8457	return pDevIns->pHlpR3->pfnDriverDetach(pDevIns, pDrvIns, fFlags);
8458	}
8459
8460	/**
8461	* @copydoc PDMDEVHLPR3::pfnDriverReconfigure
8462	*/
8463	DECLINLINE(int) PDMDevHlpDriverReconfigure(PPDMDEVINS pDevIns, uint32_t iLun, uint32_t cDepth,
8464	const char * const papszDrivers, PCFGMNODE papConfigs, uint32_t fFlags)
8465	{
8466	return pDevIns->pHlpR3->pfnDriverReconfigure(pDevIns, iLun, cDepth, papszDrivers, papConfigs, fFlags);
8467	}
8468
8469	/**
8470	* Reconfigures with a single driver reattachement, no config, noflags.
8471	* @sa PDMDevHlpDriverReconfigure
8472	*/
8473	DECLINLINE(int) PDMDevHlpDriverReconfigure1(PPDMDEVINS pDevIns, uint32_t iLun, const char *pszDriver0)
8474	{
8475	return pDevIns->pHlpR3->pfnDriverReconfigure(pDevIns, iLun, 1, &pszDriver0, NULL, 0);
8476	}
8477
8478	/**
8479	* Reconfigures with a two drivers reattachement, no config, noflags.
8480	* @sa PDMDevHlpDriverReconfigure
8481	*/
8482	DECLINLINE(int) PDMDevHlpDriverReconfigure2(PPDMDEVINS pDevIns, uint32_t iLun, const char pszDriver0, const char pszDriver1)
8483	{
8484	char const * apszDrivers[2];
8485	apszDrivers[0] = pszDriver0;
8486	apszDrivers[1] = pszDriver1;
8487	return pDevIns->pHlpR3->pfnDriverReconfigure(pDevIns, iLun, 2, apszDrivers, NULL, 0);
8488	}
8489
8490	/**
8491	* @copydoc PDMDEVHLPR3::pfnQueueCreate
8492	*/
8493	DECLINLINE(int) PDMDevHlpQueueCreate(PPDMDEVINS pDevIns, size_t cbItem, uint32_t cItems, uint32_t cMilliesInterval,
8494	PFNPDMQUEUEDEV pfnCallback, bool fRZEnabled, const char pszName, PDMQUEUEHANDLE phQueue)
8495	{
8496	return pDevIns->pHlpR3->pfnQueueCreate(pDevIns, cbItem, cItems, cMilliesInterval, pfnCallback, fRZEnabled, pszName, phQueue);
8497	}
8498
8499	#endif /* IN_RING3 */
8500
8501	/**
8502	* @copydoc PDMDEVHLPR3::pfnQueueAlloc
8503	*/
8504	DECLINLINE(PPDMQUEUEITEMCORE) PDMDevHlpQueueAlloc(PPDMDEVINS pDevIns, PDMQUEUEHANDLE hQueue)
8505	{
8506	return pDevIns->CTX_SUFF(pHlp)->pfnQueueAlloc(pDevIns, hQueue);
8507	}
8508
8509	/**
8510	* @copydoc PDMDEVHLPR3::pfnQueueInsert
8511	*/
8512	DECLINLINE(int) PDMDevHlpQueueInsert(PPDMDEVINS pDevIns, PDMQUEUEHANDLE hQueue, PPDMQUEUEITEMCORE pItem)
8513	{
8514	return pDevIns->CTX_SUFF(pHlp)->pfnQueueInsert(pDevIns, hQueue, pItem);
8515	}
8516
8517	/**
8518	* @copydoc PDMDEVHLPR3::pfnQueueFlushIfNecessary
8519	*/
8520	DECLINLINE(bool) PDMDevHlpQueueFlushIfNecessary(PPDMDEVINS pDevIns, PDMQUEUEHANDLE hQueue)
8521	{
8522	return pDevIns->CTX_SUFF(pHlp)->pfnQueueFlushIfNecessary(pDevIns, hQueue);
8523	}
8524
8525	#ifdef IN_RING3
8526	/**
8527	* @copydoc PDMDEVHLPR3::pfnTaskCreate
8528	*/
8529	DECLINLINE(int) PDMDevHlpTaskCreate(PPDMDEVINS pDevIns, uint32_t fFlags, const char *pszName,
8530	PFNPDMTASKDEV pfnCallback, void pvUser, PDMTASKHANDLE phTask)
8531	{
8532	return pDevIns->pHlpR3->pfnTaskCreate(pDevIns, fFlags, pszName, pfnCallback, pvUser, phTask);
8533	}
8534	#endif
8535
8536	/**
8537	* @copydoc PDMDEVHLPR3::pfnTaskTrigger
8538	*/
8539	DECLINLINE(int) PDMDevHlpTaskTrigger(PPDMDEVINS pDevIns, PDMTASKHANDLE hTask)
8540	{
8541	return pDevIns->CTX_SUFF(pHlp)->pfnTaskTrigger(pDevIns, hTask);
8542	}
8543
8544	#ifdef IN_RING3
8545
8546	/**
8547	* @copydoc PDMDEVHLPR3::pfnSUPSemEventCreate
8548	*/
8549	DECLINLINE(int) PDMDevHlpSUPSemEventCreate(PPDMDEVINS pDevIns, PSUPSEMEVENT phEvent)
8550	{
8551	return pDevIns->pHlpR3->pfnSUPSemEventCreate(pDevIns, phEvent);
8552	}
8553
8554	/**
8555	* @copydoc PDMDEVHLPR3::pfnSUPSemEventClose
8556	*/
8557	DECLINLINE(int) PDMDevHlpSUPSemEventClose(PPDMDEVINS pDevIns, SUPSEMEVENT hEvent)
8558	{
8559	return pDevIns->pHlpR3->pfnSUPSemEventClose(pDevIns, hEvent);
8560	}
8561
8562	#endif /* IN_RING3 */
8563
8564	/**
8565	* @copydoc PDMDEVHLPR3::pfnSUPSemEventSignal
8566	*/
8567	DECLINLINE(int) PDMDevHlpSUPSemEventSignal(PPDMDEVINS pDevIns, SUPSEMEVENT hEvent)
8568	{
8569	return pDevIns->CTX_SUFF(pHlp)->pfnSUPSemEventSignal(pDevIns, hEvent);
8570	}
8571
8572	/**
8573	* @copydoc PDMDEVHLPR3::pfnSUPSemEventWaitNoResume
8574	*/
8575	DECLINLINE(int) PDMDevHlpSUPSemEventWaitNoResume(PPDMDEVINS pDevIns, SUPSEMEVENT hEvent, uint32_t cMillies)
8576	{
8577	return pDevIns->CTX_SUFF(pHlp)->pfnSUPSemEventWaitNoResume(pDevIns, hEvent, cMillies);
8578	}
8579
8580	/**
8581	* @copydoc PDMDEVHLPR3::pfnSUPSemEventWaitNsAbsIntr
8582	*/
8583	DECLINLINE(int) PDMDevHlpSUPSemEventWaitNsAbsIntr(PPDMDEVINS pDevIns, SUPSEMEVENT hEvent, uint64_t uNsTimeout)
8584	{
8585	return pDevIns->CTX_SUFF(pHlp)->pfnSUPSemEventWaitNsAbsIntr(pDevIns, hEvent, uNsTimeout);
8586	}
8587
8588	/**
8589	* @copydoc PDMDEVHLPR3::pfnSUPSemEventWaitNsRelIntr
8590	*/
8591	DECLINLINE(int) PDMDevHlpSUPSemEventWaitNsRelIntr(PPDMDEVINS pDevIns, SUPSEMEVENT hEvent, uint64_t cNsTimeout)
8592	{
8593	return pDevIns->CTX_SUFF(pHlp)->pfnSUPSemEventWaitNsRelIntr(pDevIns, hEvent, cNsTimeout);
8594	}
8595
8596	/**
8597	* @copydoc PDMDEVHLPR3::pfnSUPSemEventGetResolution
8598	*/
8599	DECLINLINE(uint32_t) PDMDevHlpSUPSemEventGetResolution(PPDMDEVINS pDevIns)
8600	{
8601	return pDevIns->CTX_SUFF(pHlp)->pfnSUPSemEventGetResolution(pDevIns);
8602	}
8603
8604	#ifdef IN_RING3
8605
8606	/**
8607	* @copydoc PDMDEVHLPR3::pfnSUPSemEventMultiCreate
8608	*/
8609	DECLINLINE(int) PDMDevHlpSUPSemEventMultiCreate(PPDMDEVINS pDevIns, PSUPSEMEVENTMULTI phEventMulti)
8610	{
8611	return pDevIns->pHlpR3->pfnSUPSemEventMultiCreate(pDevIns, phEventMulti);
8612	}
8613
8614	/**
8615	* @copydoc PDMDEVHLPR3::pfnSUPSemEventMultiClose
8616	*/
8617	DECLINLINE(int) PDMDevHlpSUPSemEventMultiClose(PPDMDEVINS pDevIns, SUPSEMEVENTMULTI hEventMulti)
8618	{
8619	return pDevIns->pHlpR3->pfnSUPSemEventMultiClose(pDevIns, hEventMulti);
8620	}
8621
8622	#endif /* IN_RING3 */
8623
8624	/**
8625	* @copydoc PDMDEVHLPR3::pfnSUPSemEventMultiSignal
8626	*/
8627	DECLINLINE(int) PDMDevHlpSUPSemEventMultiSignal(PPDMDEVINS pDevIns, SUPSEMEVENTMULTI hEventMulti)
8628	{
8629	return pDevIns->CTX_SUFF(pHlp)->pfnSUPSemEventMultiSignal(pDevIns, hEventMulti);
8630	}
8631
8632	/**
8633	* @copydoc PDMDEVHLPR3::pfnSUPSemEventMultiReset
8634	*/
8635	DECLINLINE(int) PDMDevHlpSUPSemEventMultiReset(PPDMDEVINS pDevIns, SUPSEMEVENTMULTI hEventMulti)
8636	{
8637	return pDevIns->CTX_SUFF(pHlp)->pfnSUPSemEventMultiReset(pDevIns, hEventMulti);
8638	}
8639
8640	/**
8641	* @copydoc PDMDEVHLPR3::pfnSUPSemEventMultiWaitNoResume
8642	*/
8643	DECLINLINE(int) PDMDevHlpSUPSemEventMultiWaitNoResume(PPDMDEVINS pDevIns, SUPSEMEVENTMULTI hEventMulti, uint32_t cMillies)
8644	{
8645	return pDevIns->CTX_SUFF(pHlp)->pfnSUPSemEventMultiWaitNsRelIntr(pDevIns, hEventMulti, cMillies);
8646	}
8647
8648	/**
8649	* @copydoc PDMDEVHLPR3::pfnSUPSemEventMultiWaitNsAbsIntr
8650	*/
8651	DECLINLINE(int) PDMDevHlpSUPSemEventMultiWaitNsAbsIntr(PPDMDEVINS pDevIns, SUPSEMEVENTMULTI hEventMulti, uint64_t uNsTimeout)
8652	{
8653	return pDevIns->CTX_SUFF(pHlp)->pfnSUPSemEventMultiWaitNsAbsIntr(pDevIns, hEventMulti, uNsTimeout);
8654	}
8655
8656	/**
8657	* @copydoc PDMDEVHLPR3::pfnSUPSemEventMultiWaitNsRelIntr
8658	*/
8659	DECLINLINE(int) PDMDevHlpSUPSemEventMultiWaitNsRelIntr(PPDMDEVINS pDevIns, SUPSEMEVENTMULTI hEventMulti, uint64_t cNsTimeout)
8660	{
8661	return pDevIns->CTX_SUFF(pHlp)->pfnSUPSemEventMultiWaitNsRelIntr(pDevIns, hEventMulti, cNsTimeout);
8662	}
8663
8664	/**
8665	* @copydoc PDMDEVHLPR3::pfnSUPSemEventMultiGetResolution
8666	*/
8667	DECLINLINE(uint32_t) PDMDevHlpSUPSemEventMultiGetResolution(PPDMDEVINS pDevIns)
8668	{
8669	return pDevIns->CTX_SUFF(pHlp)->pfnSUPSemEventMultiGetResolution(pDevIns);
8670	}
8671
8672	#ifdef IN_RING3
8673
8674	/**
8675	* Initializes a PDM critical section.
8676	*
8677	* The PDM critical sections are derived from the IPRT critical sections, but
8678	* works in RC and R0 as well.
8679	*
8680	* @returns VBox status code.
8681	* @param pDevIns The device instance.
8682	* @param pCritSect Pointer to the critical section.
8683	* @param SRC_POS Use RT_SRC_POS.
8684	* @param pszNameFmt Format string for naming the critical section.
8685	* For statistics and lock validation.
8686	* @param ... Arguments for the format string.
8687	*/
8688	DECLINLINE(int) RT_IPRT_FORMAT_ATTR(6, 7) PDMDevHlpCritSectInit(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect, RT_SRC_POS_DECL,
8689	const char *pszNameFmt, ...)
8690	{
8691	int rc;
8692	va_list va;
8693	va_start(va, pszNameFmt);
8694	rc = pDevIns->pHlpR3->pfnCritSectInit(pDevIns, pCritSect, RT_SRC_POS_ARGS, pszNameFmt, va);
8695	va_end(va);
8696	return rc;
8697	}
8698
8699	#endif /* IN_RING3 */
8700
8701	/**
8702	* @copydoc PDMDEVHLPR3::pfnCritSectGetNop
8703	*/
8704	DECLINLINE(PPDMCRITSECT) PDMDevHlpCritSectGetNop(PPDMDEVINS pDevIns)
8705	{
8706	return pDevIns->CTX_SUFF(pHlp)->pfnCritSectGetNop(pDevIns);
8707	}
8708
8709	/**
8710	* @copydoc PDMDEVHLPR3::pfnSetDeviceCritSect
8711	*/
8712	DECLINLINE(int) PDMDevHlpSetDeviceCritSect(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect)
8713	{
8714	return pDevIns->CTX_SUFF(pHlp)->pfnSetDeviceCritSect(pDevIns, pCritSect);
8715	}
8716
8717	/**
8718	* Enters a PDM critical section.
8719	*
8720	* @returns VINF_SUCCESS if entered successfully.
8721	* @returns rcBusy when encountering a busy critical section in RC/R0.
8722	* @retval VERR_SEM_DESTROYED if the critical section is delete before or
8723	* during the operation.
8724	*
8725	* @param pDevIns The device instance.
8726	* @param pCritSect The PDM critical section to enter.
8727	* @param rcBusy The status code to return when we're in RC or R0
8728	* and the section is busy. Pass VINF_SUCCESS to
8729	* acquired the critical section thru a ring-3
8730	* call if necessary.
8731	*
8732	* @note Even callers setting @a rcBusy to VINF_SUCCESS must either handle
8733	* possible failures in ring-0 or at least apply
8734	* PDM_CRITSECT_RELEASE_ASSERT_RC_DEV() to the return value of this
8735	* function.
8736	*
8737	* @sa PDMCritSectEnter
8738	*/
8739	DECLINLINE(DECL_CHECK_RETURN(int)) PDMDevHlpCritSectEnter(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect, int rcBusy)
8740	{
8741	return pDevIns->CTX_SUFF(pHlp)->pfnCritSectEnter(pDevIns, pCritSect, rcBusy);
8742	}
8743
8744	/**
8745	* Enters a PDM critical section, with location information for debugging.
8746	*
8747	* @returns VINF_SUCCESS if entered successfully.
8748	* @returns rcBusy when encountering a busy critical section in RC/R0.
8749	* @retval VERR_SEM_DESTROYED if the critical section is delete before or
8750	* during the operation.
8751	*
8752	* @param pDevIns The device instance.
8753	* @param pCritSect The PDM critical section to enter.
8754	* @param rcBusy The status code to return when we're in RC or R0
8755	* and the section is busy. Pass VINF_SUCCESS to
8756	* acquired the critical section thru a ring-3
8757	* call if necessary.
8758	* @param uId Some kind of locking location ID. Typically a
8759	* return address up the stack. Optional (0).
8760	* @param SRC_POS The source position where to lock is being
8761	* acquired from. Optional.
8762	* @sa PDMCritSectEnterDebug
8763	*/
8764	DECLINLINE(DECL_CHECK_RETURN(int))
8765	PDMDevHlpCritSectEnterDebug(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect, int rcBusy, RTHCUINTPTR uId, RT_SRC_POS_DECL)
8766	{
8767	return pDevIns->CTX_SUFF(pHlp)->pfnCritSectEnterDebug(pDevIns, pCritSect, rcBusy, uId, RT_SRC_POS_ARGS);
8768	}
8769
8770	/**
8771	* Try enter a critical section.
8772	*
8773	* @retval VINF_SUCCESS on success.
8774	* @retval VERR_SEM_BUSY if the critsect was owned.
8775	* @retval VERR_SEM_NESTED if nested enter on a no nesting section. (Asserted.)
8776	* @retval VERR_SEM_DESTROYED if the critical section is delete before or
8777	* during the operation.
8778	*
8779	* @param pDevIns The device instance.
8780	* @param pCritSect The critical section.
8781	* @sa PDMCritSectTryEnter
8782	*/
8783	DECLINLINE(DECL_CHECK_RETURN(int))
8784	PDMDevHlpCritSectTryEnter(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect)
8785	{
8786	return pDevIns->CTX_SUFF(pHlp)->pfnCritSectTryEnter(pDevIns, pCritSect);
8787	}
8788
8789	/**
8790	* Try enter a critical section, with location information for debugging.
8791	*
8792	* @retval VINF_SUCCESS on success.
8793	* @retval VERR_SEM_BUSY if the critsect was owned.
8794	* @retval VERR_SEM_NESTED if nested enter on a no nesting section. (Asserted.)
8795	* @retval VERR_SEM_DESTROYED if the critical section is delete before or
8796	* during the operation.
8797	*
8798	* @param pDevIns The device instance.
8799	* @param pCritSect The critical section.
8800	* @param uId Some kind of locking location ID. Typically a
8801	* return address up the stack. Optional (0).
8802	* @param SRC_POS The source position where to lock is being
8803	* acquired from. Optional.
8804	* @sa PDMCritSectTryEnterDebug
8805	*/
8806	DECLINLINE(DECL_CHECK_RETURN(int))
8807	PDMDevHlpCritSectTryEnterDebug(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect, RTHCUINTPTR uId, RT_SRC_POS_DECL)
8808	{
8809	return pDevIns->CTX_SUFF(pHlp)->pfnCritSectTryEnterDebug(pDevIns, pCritSect, uId, RT_SRC_POS_ARGS);
8810	}
8811
8812	/**
8813	* Leaves a critical section entered with PDMCritSectEnter().
8814	*
8815	* @returns Indication whether we really exited the critical section.
8816	* @retval VINF_SUCCESS if we really exited.
8817	* @retval VINF_SEM_NESTED if we only reduced the nesting count.
8818	* @retval VERR_NOT_OWNER if you somehow ignore release assertions.
8819	*
8820	* @param pDevIns The device instance.
8821	* @param pCritSect The PDM critical section to leave.
8822	* @sa PDMCritSectLeave
8823	*/
8824	DECLINLINE(int) PDMDevHlpCritSectLeave(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect)
8825	{
8826	return pDevIns->CTX_SUFF(pHlp)->pfnCritSectLeave(pDevIns, pCritSect);
8827	}
8828
8829	/**
8830	* @see PDMCritSectIsOwner
8831	*/
8832	DECLINLINE(bool) PDMDevHlpCritSectIsOwner(PPDMDEVINS pDevIns, PCPDMCRITSECT pCritSect)
8833	{
8834	return pDevIns->CTX_SUFF(pHlp)->pfnCritSectIsOwner(pDevIns, pCritSect);
8835	}
8836
8837	/**
8838	* @see PDMCritSectIsInitialized
8839	*/
8840	DECLINLINE(bool) PDMDevHlpCritSectIsInitialized(PPDMDEVINS pDevIns, PCPDMCRITSECT pCritSect)
8841	{
8842	return pDevIns->CTX_SUFF(pHlp)->pfnCritSectIsInitialized(pDevIns, pCritSect);
8843	}
8844
8845	/**
8846	* @see PDMCritSectHasWaiters
8847	*/
8848	DECLINLINE(bool) PDMDevHlpCritSectHasWaiters(PPDMDEVINS pDevIns, PCPDMCRITSECT pCritSect)
8849	{
8850	return pDevIns->CTX_SUFF(pHlp)->pfnCritSectHasWaiters(pDevIns, pCritSect);
8851	}
8852
8853	/**
8854	* @see PDMCritSectGetRecursion
8855	*/
8856	DECLINLINE(uint32_t) PDMDevHlpCritSectGetRecursion(PPDMDEVINS pDevIns, PCPDMCRITSECT pCritSect)
8857	{
8858	return pDevIns->CTX_SUFF(pHlp)->pfnCritSectGetRecursion(pDevIns, pCritSect);
8859	}
8860
8861	#if defined(IN_RING3) \|\| defined(IN_RING0)
8862	/**
8863	* @see PDMHCCritSectScheduleExitEvent
8864	*/
8865	DECLINLINE(int) PDMDevHlpCritSectScheduleExitEvent(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect, SUPSEMEVENT hEventToSignal)
8866	{
8867	return pDevIns->CTX_SUFF(pHlp)->pfnCritSectScheduleExitEvent(pDevIns, pCritSect, hEventToSignal);
8868	}
8869	#endif
8870
8871	/* Strict build: Remap the two enter calls to the debug versions. */
8872	#ifdef VBOX_STRICT
8873	# ifdef IPRT_INCLUDED_asm_h
8874	# define PDMDevHlpCritSectEnter(pDevIns, pCritSect, rcBusy) PDMDevHlpCritSectEnterDebug((pDevIns), (pCritSect), (rcBusy), (uintptr_t)ASMReturnAddress(), RT_SRC_POS)
8875	# define PDMDevHlpCritSectTryEnter(pDevIns, pCritSect) PDMDevHlpCritSectTryEnterDebug((pDevIns), (pCritSect), (uintptr_t)ASMReturnAddress(), RT_SRC_POS)
8876	# else
8877	# define PDMDevHlpCritSectEnter(pDevIns, pCritSect, rcBusy) PDMDevHlpCritSectEnterDebug((pDevIns), (pCritSect), (rcBusy), 0, RT_SRC_POS)
8878	# define PDMDevHlpCritSectTryEnter(pDevIns, pCritSect) PDMDevHlpCritSectTryEnterDebug((pDevIns), (pCritSect), 0, RT_SRC_POS)
8879	# endif
8880	#endif
8881
8882	#if defined(IN_RING3) \|\| defined(DOXYGEN_RUNNING)
8883
8884	/**
8885	* Deletes the critical section.
8886	*
8887	* @returns VBox status code.
8888	* @param pDevIns The device instance.
8889	* @param pCritSect The PDM critical section to destroy.
8890	* @sa PDMR3CritSectDelete
8891	*/
8892	DECLINLINE(int) PDMDevHlpCritSectDelete(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect)
8893	{
8894	return pDevIns->pHlpR3->pfnCritSectDelete(pDevIns, pCritSect);
8895	}
8896
8897	/**
8898	* Initializes a PDM read/write critical section.
8899	*
8900	* The PDM read/write critical sections are derived from the IPRT critical
8901	* sections, but works in RC and R0 as well.
8902	*
8903	* @returns VBox status code.
8904	* @param pDevIns The device instance.
8905	* @param pCritSect Pointer to the read/write critical section.
8906	* @param SRC_POS Use RT_SRC_POS.
8907	* @param pszNameFmt Format string for naming the critical section.
8908	* For statistics and lock validation.
8909	* @param ... Arguments for the format string.
8910	*/
8911	DECLINLINE(int) RT_IPRT_FORMAT_ATTR(6, 7) PDMDevHlpCritSectRwInit(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect, RT_SRC_POS_DECL,
8912	const char *pszNameFmt, ...)
8913	{
8914	int rc;
8915	va_list va;
8916	va_start(va, pszNameFmt);
8917	rc = pDevIns->pHlpR3->pfnCritSectRwInit(pDevIns, pCritSect, RT_SRC_POS_ARGS, pszNameFmt, va);
8918	va_end(va);
8919	return rc;
8920	}
8921
8922	/**
8923	* Deletes the read/write critical section.
8924	*
8925	* @returns VBox status code.
8926	* @param pDevIns The device instance.
8927	* @param pCritSect The PDM read/write critical section to destroy.
8928	* @sa PDMR3CritSectRwDelete
8929	*/
8930	DECLINLINE(int) PDMDevHlpCritSectRwDelete(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect)
8931	{
8932	return pDevIns->pHlpR3->pfnCritSectRwDelete(pDevIns, pCritSect);
8933	}
8934
8935	#endif /* IN_RING3 */
8936
8937	/**
8938	* @sa PDMCritSectRwEnterShared, PDM_CRITSECT_RELEASE_ASSERT_RC_DEV
8939	*/
8940	DECLINLINE(DECL_CHECK_RETURN(int)) PDMDevHlpCritSectRwEnterShared(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect, int rcBusy)
8941	{
8942	return pDevIns->CTX_SUFF(pHlp)->pfnCritSectRwEnterShared(pDevIns, pCritSect, rcBusy);
8943	}
8944
8945	/**
8946	* @sa PDMCritSectRwEnterSharedDebug, PDM_CRITSECT_RELEASE_ASSERT_RC_DEV
8947	*/
8948	DECLINLINE(DECL_CHECK_RETURN(int))
8949	PDMDevHlpCritSectRwEnterSharedDebug(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect, int rcBusy, RTHCUINTPTR uId, RT_SRC_POS_DECL)
8950	{
8951	return pDevIns->CTX_SUFF(pHlp)->pfnCritSectRwEnterSharedDebug(pDevIns, pCritSect, rcBusy, uId, RT_SRC_POS_ARGS);
8952	}
8953
8954	/**
8955	* @sa PDMCritSectRwTryEnterShared
8956	*/
8957	DECLINLINE(DECL_CHECK_RETURN(int))
8958	PDMDevHlpCritSectRwTryEnterShared(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect)
8959	{
8960	return pDevIns->CTX_SUFF(pHlp)->pfnCritSectRwTryEnterShared(pDevIns, pCritSect);
8961	}
8962
8963	/**
8964	* @sa PDMCritSectRwTryEnterSharedDebug
8965	*/
8966	DECLINLINE(DECL_CHECK_RETURN(int))
8967	PDMDevHlpCritSectRwTryEnterSharedDebug(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect, RTHCUINTPTR uId, RT_SRC_POS_DECL)
8968	{
8969	return pDevIns->CTX_SUFF(pHlp)->pfnCritSectRwTryEnterSharedDebug(pDevIns, pCritSect, uId, RT_SRC_POS_ARGS);
8970	}
8971
8972	/**
8973	* @sa PDMCritSectRwLeaveShared
8974	*/
8975	DECLINLINE(int) PDMDevHlpCritSectRwLeaveShared(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect)
8976	{
8977	return pDevIns->CTX_SUFF(pHlp)->pfnCritSectRwLeaveShared(pDevIns, pCritSect);
8978	}
8979
8980	/**
8981	* @sa PDMCritSectRwEnterExcl, PDM_CRITSECT_RELEASE_ASSERT_RC_DEV
8982	*/
8983	DECLINLINE(DECL_CHECK_RETURN(int)) PDMDevHlpCritSectRwEnterExcl(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect, int rcBusy)
8984	{
8985	return pDevIns->CTX_SUFF(pHlp)->pfnCritSectRwEnterExcl(pDevIns, pCritSect, rcBusy);
8986	}
8987
8988	/**
8989	* @sa PDMCritSectRwEnterExclDebug, PDM_CRITSECT_RELEASE_ASSERT_RC_DEV
8990	*/
8991	DECLINLINE(DECL_CHECK_RETURN(int))
8992	PDMDevHlpCritSectRwEnterExclDebug(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect, int rcBusy, RTHCUINTPTR uId, RT_SRC_POS_DECL)
8993	{
8994	return pDevIns->CTX_SUFF(pHlp)->pfnCritSectRwEnterExclDebug(pDevIns, pCritSect, rcBusy, uId, RT_SRC_POS_ARGS);
8995	}
8996
8997	/**
8998	* @sa PDMCritSectRwTryEnterExcl
8999	*/
9000	DECLINLINE(DECL_CHECK_RETURN(int))
9001	PDMDevHlpCritSectRwTryEnterExcl(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect)
9002	{
9003	return pDevIns->CTX_SUFF(pHlp)->pfnCritSectRwTryEnterExcl(pDevIns, pCritSect);
9004	}
9005
9006	/**
9007	* @sa PDMCritSectRwTryEnterExclDebug
9008	*/
9009	DECLINLINE(DECL_CHECK_RETURN(int))
9010	PDMDevHlpCritSectRwTryEnterExclDebug(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect, RTHCUINTPTR uId, RT_SRC_POS_DECL)
9011	{
9012	return pDevIns->CTX_SUFF(pHlp)->pfnCritSectRwTryEnterExclDebug(pDevIns, pCritSect, uId, RT_SRC_POS_ARGS);
9013	}
9014
9015	/**
9016	* @sa PDMCritSectRwLeaveExcl
9017	*/
9018	DECLINLINE(int) PDMDevHlpCritSectRwLeaveExcl(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect)
9019	{
9020	return pDevIns->CTX_SUFF(pHlp)->pfnCritSectRwLeaveExcl(pDevIns, pCritSect);
9021	}
9022
9023	/**
9024	* @see PDMCritSectRwIsWriteOwner
9025	*/
9026	DECLINLINE(bool) PDMDevHlpCritSectRwIsWriteOwner(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect)
9027	{
9028	return pDevIns->CTX_SUFF(pHlp)->pfnCritSectRwIsWriteOwner(pDevIns, pCritSect);
9029	}
9030
9031	/**
9032	* @see PDMCritSectRwIsReadOwner
9033	*/
9034	DECLINLINE(bool) PDMDevHlpCritSectRwIsReadOwner(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect, bool fWannaHear)
9035	{
9036	return pDevIns->CTX_SUFF(pHlp)->pfnCritSectRwIsReadOwner(pDevIns, pCritSect, fWannaHear);
9037	}
9038
9039	/**
9040	* @see PDMCritSectRwGetWriteRecursion
9041	*/
9042	DECLINLINE(uint32_t) PDMDevHlpCritSectRwGetWriteRecursion(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect)
9043	{
9044	return pDevIns->CTX_SUFF(pHlp)->pfnCritSectRwGetWriteRecursion(pDevIns, pCritSect);
9045	}
9046
9047	/**
9048	* @see PDMCritSectRwGetWriterReadRecursion
9049	*/
9050	DECLINLINE(uint32_t) PDMDevHlpCritSectRwGetWriterReadRecursion(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect)
9051	{
9052	return pDevIns->CTX_SUFF(pHlp)->pfnCritSectRwGetWriterReadRecursion(pDevIns, pCritSect);
9053	}
9054
9055	/**
9056	* @see PDMCritSectRwGetReadCount
9057	*/
9058	DECLINLINE(uint32_t) PDMDevHlpCritSectRwGetReadCount(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect)
9059	{
9060	return pDevIns->CTX_SUFF(pHlp)->pfnCritSectRwGetReadCount(pDevIns, pCritSect);
9061	}
9062
9063	/**
9064	* @see PDMCritSectRwIsInitialized
9065	*/
9066	DECLINLINE(bool) PDMDevHlpCritSectRwIsInitialized(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect)
9067	{
9068	return pDevIns->CTX_SUFF(pHlp)->pfnCritSectRwIsInitialized(pDevIns, pCritSect);
9069	}
9070
9071	/* Strict build: Remap the two enter calls to the debug versions. */
9072	#ifdef VBOX_STRICT
9073	# ifdef IPRT_INCLUDED_asm_h
9074	# define PDMDevHlpCritSectRwEnterShared(pDevIns, pCritSect, rcBusy) PDMDevHlpCritSectRwEnterSharedDebug((pDevIns), (pCritSect), (rcBusy), (uintptr_t)ASMReturnAddress(), RT_SRC_POS)
9075	# define PDMDevHlpCritSectRwTryEnterShared(pDevIns, pCritSect) PDMDevHlpCritSectRwTryEnterSharedDebug((pDevIns), (pCritSect), (uintptr_t)ASMReturnAddress(), RT_SRC_POS)
9076	# define PDMDevHlpCritSectRwEnterExcl(pDevIns, pCritSect, rcBusy) PDMDevHlpCritSectRwEnterExclDebug((pDevIns), (pCritSect), (rcBusy), (uintptr_t)ASMReturnAddress(), RT_SRC_POS)
9077	# define PDMDevHlpCritSectRwTryEnterExcl(pDevIns, pCritSect) PDMDevHlpCritSectRwTryEnterExclDebug((pDevIns), (pCritSect), (uintptr_t)ASMReturnAddress(), RT_SRC_POS)
9078	# else
9079	# define PDMDevHlpCritSectRwEnterShared(pDevIns, pCritSect, rcBusy) PDMDevHlpCritSectRwEnterSharedDebug((pDevIns), (pCritSect), (rcBusy), 0, RT_SRC_POS)
9080	# define PDMDevHlpCritSectRwTryEnterShared(pDevIns, pCritSect) PDMDevHlpCritSectRwTryEnterSharedDebug((pDevIns), (pCritSect), 0, RT_SRC_POS)
9081	# define PDMDevHlpCritSectRwEnterExcl(pDevIns, pCritSect, rcBusy) PDMDevHlpCritSectRwEnterExclDebug((pDevIns), (pCritSect), (rcBusy), 0, RT_SRC_POS)
9082	# define PDMDevHlpCritSectRwTryEnterExcl(pDevIns, pCritSect) PDMDevHlpCritSectRwTryEnterExclDebug((pDevIns), (pCritSect), 0, RT_SRC_POS)
9083	# endif
9084	#endif
9085
9086	#if defined(IN_RING3) \|\| defined(DOXYGEN_RUNNING)
9087
9088	/**
9089	* @copydoc PDMDEVHLPR3::pfnThreadCreate
9090	*/
9091	DECLINLINE(int) PDMDevHlpThreadCreate(PPDMDEVINS pDevIns, PPPDMTHREAD ppThread, void *pvUser, PFNPDMTHREADDEV pfnThread,
9092	PFNPDMTHREADWAKEUPDEV pfnWakeup, size_t cbStack, RTTHREADTYPE enmType, const char *pszName)
9093	{
9094	return pDevIns->pHlpR3->pfnThreadCreate(pDevIns, ppThread, pvUser, pfnThread, pfnWakeup, cbStack, enmType, pszName);
9095	}
9096
9097	/**
9098	* @copydoc PDMR3ThreadDestroy
9099	* @param pDevIns The device instance.
9100	*/
9101	DECLINLINE(int) PDMDevHlpThreadDestroy(PPDMDEVINS pDevIns, PPDMTHREAD pThread, int *pRcThread)
9102	{
9103	return pDevIns->pHlpR3->pfnThreadDestroy(pThread, pRcThread);
9104	}
9105
9106	/**
9107	* @copydoc PDMR3ThreadIAmSuspending
9108	* @param pDevIns The device instance.
9109	*/
9110	DECLINLINE(int) PDMDevHlpThreadIAmSuspending(PPDMDEVINS pDevIns, PPDMTHREAD pThread)
9111	{
9112	return pDevIns->pHlpR3->pfnThreadIAmSuspending(pThread);
9113	}
9114
9115	/**
9116	* @copydoc PDMR3ThreadIAmRunning
9117	* @param pDevIns The device instance.
9118	*/
9119	DECLINLINE(int) PDMDevHlpThreadIAmRunning(PPDMDEVINS pDevIns, PPDMTHREAD pThread)
9120	{
9121	return pDevIns->pHlpR3->pfnThreadIAmRunning(pThread);
9122	}
9123
9124	/**
9125	* @copydoc PDMR3ThreadSleep
9126	* @param pDevIns The device instance.
9127	*/
9128	DECLINLINE(int) PDMDevHlpThreadSleep(PPDMDEVINS pDevIns, PPDMTHREAD pThread, RTMSINTERVAL cMillies)
9129	{
9130	return pDevIns->pHlpR3->pfnThreadSleep(pThread, cMillies);
9131	}
9132
9133	/**
9134	* @copydoc PDMR3ThreadSuspend
9135	* @param pDevIns The device instance.
9136	*/
9137	DECLINLINE(int) PDMDevHlpThreadSuspend(PPDMDEVINS pDevIns, PPDMTHREAD pThread)
9138	{
9139	return pDevIns->pHlpR3->pfnThreadSuspend(pThread);
9140	}
9141
9142	/**
9143	* @copydoc PDMR3ThreadResume
9144	* @param pDevIns The device instance.
9145	*/
9146	DECLINLINE(int) PDMDevHlpThreadResume(PPDMDEVINS pDevIns, PPDMTHREAD pThread)
9147	{
9148	return pDevIns->pHlpR3->pfnThreadResume(pThread);
9149	}
9150
9151	/**
9152	* @copydoc PDMDEVHLPR3::pfnSetAsyncNotification
9153	*/
9154	DECLINLINE(int) PDMDevHlpSetAsyncNotification(PPDMDEVINS pDevIns, PFNPDMDEVASYNCNOTIFY pfnAsyncNotify)
9155	{
9156	return pDevIns->pHlpR3->pfnSetAsyncNotification(pDevIns, pfnAsyncNotify);
9157	}
9158
9159	/**
9160	* @copydoc PDMDEVHLPR3::pfnAsyncNotificationCompleted
9161	*/
9162	DECLINLINE(void) PDMDevHlpAsyncNotificationCompleted(PPDMDEVINS pDevIns)
9163	{
9164	pDevIns->pHlpR3->pfnAsyncNotificationCompleted(pDevIns);
9165	}
9166
9167	/**
9168	* @copydoc PDMDEVHLPR3::pfnA20Set
9169	*/
9170	DECLINLINE(void) PDMDevHlpA20Set(PPDMDEVINS pDevIns, bool fEnable)
9171	{
9172	pDevIns->pHlpR3->pfnA20Set(pDevIns, fEnable);
9173	}
9174
9175	/**
9176	* @copydoc PDMDEVHLPR3::pfnRTCRegister
9177	*/
9178	DECLINLINE(int) PDMDevHlpRTCRegister(PPDMDEVINS pDevIns, PCPDMRTCREG pRtcReg, PCPDMRTCHLP *ppRtcHlp)
9179	{
9180	return pDevIns->pHlpR3->pfnRTCRegister(pDevIns, pRtcReg, ppRtcHlp);
9181	}
9182
9183	/**
9184	* @copydoc PDMDEVHLPR3::pfnPCIBusRegister
9185	*/
9186	DECLINLINE(int) PDMDevHlpPCIBusRegister(PPDMDEVINS pDevIns, PPDMPCIBUSREGR3 pPciBusReg, PCPDMPCIHLPR3 ppPciHlp, uint32_t piBus)
9187	{
9188	return pDevIns->pHlpR3->pfnPCIBusRegister(pDevIns, pPciBusReg, ppPciHlp, piBus);
9189	}
9190
9191	/**
9192	* @copydoc PDMDEVHLPR3::pfnIommuRegister
9193	*/
9194	DECLINLINE(int) PDMDevHlpIommuRegister(PPDMDEVINS pDevIns, PPDMIOMMUREGR3 pIommuReg, PCPDMIOMMUHLPR3 ppIommuHlp, uint32_t pidxIommu)
9195	{
9196	return pDevIns->pHlpR3->pfnIommuRegister(pDevIns, pIommuReg, ppIommuHlp, pidxIommu);
9197	}
9198
9199	/**
9200	* @copydoc PDMDEVHLPR3::pfnPICRegister
9201	*/
9202	DECLINLINE(int) PDMDevHlpPICRegister(PPDMDEVINS pDevIns, PPDMPICREG pPicReg, PCPDMPICHLP *ppPicHlp)
9203	{
9204	return pDevIns->pHlpR3->pfnPICRegister(pDevIns, pPicReg, ppPicHlp);
9205	}
9206
9207	/**
9208	* @copydoc PDMDEVHLPR3::pfnApicRegister
9209	*/
9210	DECLINLINE(int) PDMDevHlpApicRegister(PPDMDEVINS pDevIns)
9211	{
9212	return pDevIns->pHlpR3->pfnApicRegister(pDevIns);
9213	}
9214
9215	/**
9216	* @copydoc PDMDEVHLPR3::pfnIoApicRegister
9217	*/
9218	DECLINLINE(int) PDMDevHlpIoApicRegister(PPDMDEVINS pDevIns, PPDMIOAPICREG pIoApicReg, PCPDMIOAPICHLP *ppIoApicHlp)
9219	{
9220	return pDevIns->pHlpR3->pfnIoApicRegister(pDevIns, pIoApicReg, ppIoApicHlp);
9221	}
9222
9223	/**
9224	* @copydoc PDMDEVHLPR3::pfnHpetRegister
9225	*/
9226	DECLINLINE(int) PDMDevHlpHpetRegister(PPDMDEVINS pDevIns, PPDMHPETREG pHpetReg, PCPDMHPETHLPR3 *ppHpetHlpR3)
9227	{
9228	return pDevIns->pHlpR3->pfnHpetRegister(pDevIns, pHpetReg, ppHpetHlpR3);
9229	}
9230
9231	/**
9232	* @copydoc PDMDEVHLPR3::pfnPciRawRegister
9233	*/
9234	DECLINLINE(int) PDMDevHlpPciRawRegister(PPDMDEVINS pDevIns, PPDMPCIRAWREG pPciRawReg, PCPDMPCIRAWHLPR3 *ppPciRawHlpR3)
9235	{
9236	return pDevIns->pHlpR3->pfnPciRawRegister(pDevIns, pPciRawReg, ppPciRawHlpR3);
9237	}
9238
9239	/**
9240	* @copydoc PDMDEVHLPR3::pfnDMACRegister
9241	*/
9242	DECLINLINE(int) PDMDevHlpDMACRegister(PPDMDEVINS pDevIns, PPDMDMACREG pDmacReg, PCPDMDMACHLP *ppDmacHlp)
9243	{
9244	return pDevIns->pHlpR3->pfnDMACRegister(pDevIns, pDmacReg, ppDmacHlp);
9245	}
9246
9247	/**
9248	* @copydoc PDMDEVHLPR3::pfnDMARegister
9249	*/
9250	DECLINLINE(int) PDMDevHlpDMARegister(PPDMDEVINS pDevIns, unsigned uChannel, PFNDMATRANSFERHANDLER pfnTransferHandler, void *pvUser)
9251	{
9252	return pDevIns->pHlpR3->pfnDMARegister(pDevIns, uChannel, pfnTransferHandler, pvUser);
9253	}
9254
9255	/**
9256	* @copydoc PDMDEVHLPR3::pfnDMAReadMemory
9257	*/
9258	DECLINLINE(int) PDMDevHlpDMAReadMemory(PPDMDEVINS pDevIns, unsigned uChannel, void pvBuffer, uint32_t off, uint32_t cbBlock, uint32_t pcbRead)
9259	{
9260	return pDevIns->pHlpR3->pfnDMAReadMemory(pDevIns, uChannel, pvBuffer, off, cbBlock, pcbRead);
9261	}
9262
9263	/**
9264	* @copydoc PDMDEVHLPR3::pfnDMAWriteMemory
9265	*/
9266	DECLINLINE(int) PDMDevHlpDMAWriteMemory(PPDMDEVINS pDevIns, unsigned uChannel, const void pvBuffer, uint32_t off, uint32_t cbBlock, uint32_t pcbWritten)
9267	{
9268	return pDevIns->pHlpR3->pfnDMAWriteMemory(pDevIns, uChannel, pvBuffer, off, cbBlock, pcbWritten);
9269	}
9270
9271	/**
9272	* @copydoc PDMDEVHLPR3::pfnDMASetDREQ
9273	*/
9274	DECLINLINE(int) PDMDevHlpDMASetDREQ(PPDMDEVINS pDevIns, unsigned uChannel, unsigned uLevel)
9275	{
9276	return pDevIns->pHlpR3->pfnDMASetDREQ(pDevIns, uChannel, uLevel);
9277	}
9278
9279	/**
9280	* @copydoc PDMDEVHLPR3::pfnDMAGetChannelMode
9281	*/
9282	DECLINLINE(uint8_t) PDMDevHlpDMAGetChannelMode(PPDMDEVINS pDevIns, unsigned uChannel)
9283	{
9284	return pDevIns->pHlpR3->pfnDMAGetChannelMode(pDevIns, uChannel);
9285	}
9286
9287	/**
9288	* @copydoc PDMDEVHLPR3::pfnDMASchedule
9289	*/
9290	DECLINLINE(void) PDMDevHlpDMASchedule(PPDMDEVINS pDevIns)
9291	{
9292	pDevIns->pHlpR3->pfnDMASchedule(pDevIns);
9293	}
9294
9295	/**
9296	* @copydoc PDMDEVHLPR3::pfnCMOSWrite
9297	*/
9298	DECLINLINE(int) PDMDevHlpCMOSWrite(PPDMDEVINS pDevIns, unsigned iReg, uint8_t u8Value)
9299	{
9300	return pDevIns->pHlpR3->pfnCMOSWrite(pDevIns, iReg, u8Value);
9301	}
9302
9303	/**
9304	* @copydoc PDMDEVHLPR3::pfnCMOSRead
9305	*/
9306	DECLINLINE(int) PDMDevHlpCMOSRead(PPDMDEVINS pDevIns, unsigned iReg, uint8_t *pu8Value)
9307	{
9308	return pDevIns->pHlpR3->pfnCMOSRead(pDevIns, iReg, pu8Value);
9309	}
9310
9311	/**
9312	* @copydoc PDMDEVHLPR3::pfnCallR0
9313	*/
9314	DECLINLINE(int) PDMDevHlpCallR0(PPDMDEVINS pDevIns, uint32_t uOperation, uint64_t u64Arg)
9315	{
9316	return pDevIns->pHlpR3->pfnCallR0(pDevIns, uOperation, u64Arg);
9317	}
9318
9319	/**
9320	* @copydoc PDMDEVHLPR3::pfnVMGetSuspendReason
9321	*/
9322	DECLINLINE(VMSUSPENDREASON) PDMDevHlpVMGetSuspendReason(PPDMDEVINS pDevIns)
9323	{
9324	return pDevIns->pHlpR3->pfnVMGetSuspendReason(pDevIns);
9325	}
9326
9327	/**
9328	* @copydoc PDMDEVHLPR3::pfnVMGetResumeReason
9329	*/
9330	DECLINLINE(VMRESUMEREASON) PDMDevHlpVMGetResumeReason(PPDMDEVINS pDevIns)
9331	{
9332	return pDevIns->pHlpR3->pfnVMGetResumeReason(pDevIns);
9333	}
9334
9335	/**
9336	* @copydoc PDMDEVHLPR3::pfnGetUVM
9337	*/
9338	DECLINLINE(PUVM) PDMDevHlpGetUVM(PPDMDEVINS pDevIns)
9339	{
9340	return pDevIns->CTX_SUFF(pHlp)->pfnGetUVM(pDevIns);
9341	}
9342
9343	#endif /* IN_RING3 \|\| DOXYGEN_RUNNING */
9344
9345	#if !defined(IN_RING3) \|\| defined(DOXYGEN_RUNNING)
9346
9347	/**
9348	* @copydoc PDMDEVHLPR0::pfnPCIBusSetUpContext
9349	*/
9350	DECLINLINE(int) PDMDevHlpPCIBusSetUpContext(PPDMDEVINS pDevIns, CTX_SUFF(PPDMPCIBUSREG) pPciBusReg, CTX_SUFF(PCPDMPCIHLP) *ppPciHlp)
9351	{
9352	return pDevIns->CTX_SUFF(pHlp)->pfnPCIBusSetUpContext(pDevIns, pPciBusReg, ppPciHlp);
9353	}
9354
9355	/**
9356	* @copydoc PDMDEVHLPR0::pfnIommuSetUpContext
9357	*/
9358	DECLINLINE(int) PDMDevHlpIommuSetUpContext(PPDMDEVINS pDevIns, CTX_SUFF(PPDMIOMMUREG) pIommuReg, CTX_SUFF(PCPDMIOMMUHLP) *ppIommuHlp)
9359	{
9360	return pDevIns->CTX_SUFF(pHlp)->pfnIommuSetUpContext(pDevIns, pIommuReg, ppIommuHlp);
9361	}
9362
9363	/**
9364	* @copydoc PDMDEVHLPR0::pfnPICSetUpContext
9365	*/
9366	DECLINLINE(int) PDMDevHlpPICSetUpContext(PPDMDEVINS pDevIns, PPDMPICREG pPicReg, PCPDMPICHLP *ppPicHlp)
9367	{
9368	return pDevIns->CTX_SUFF(pHlp)->pfnPICSetUpContext(pDevIns, pPicReg, ppPicHlp);
9369	}
9370
9371	/**
9372	* @copydoc PDMDEVHLPR0::pfnApicSetUpContext
9373	*/
9374	DECLINLINE(int) PDMDevHlpApicSetUpContext(PPDMDEVINS pDevIns)
9375	{
9376	return pDevIns->CTX_SUFF(pHlp)->pfnApicSetUpContext(pDevIns);
9377	}
9378
9379	/**
9380	* @copydoc PDMDEVHLPR0::pfnIoApicSetUpContext
9381	*/
9382	DECLINLINE(int) PDMDevHlpIoApicSetUpContext(PPDMDEVINS pDevIns, PPDMIOAPICREG pIoApicReg, PCPDMIOAPICHLP *ppIoApicHlp)
9383	{
9384	return pDevIns->CTX_SUFF(pHlp)->pfnIoApicSetUpContext(pDevIns, pIoApicReg, ppIoApicHlp);
9385	}
9386
9387	/**
9388	* @copydoc PDMDEVHLPR0::pfnHpetSetUpContext
9389	*/
9390	DECLINLINE(int) PDMDevHlpHpetSetUpContext(PPDMDEVINS pDevIns, PPDMHPETREG pHpetReg, CTX_SUFF(PCPDMHPETHLP) *ppHpetHlp)
9391	{
9392	return pDevIns->CTX_SUFF(pHlp)->pfnHpetSetUpContext(pDevIns, pHpetReg, ppHpetHlp);
9393	}
9394
9395	#endif /* !IN_RING3 \|\| DOXYGEN_RUNNING */
9396
9397	/**
9398	* @copydoc PDMDEVHLPR3::pfnGetVM
9399	*/
9400	DECLINLINE(PVMCC) PDMDevHlpGetVM(PPDMDEVINS pDevIns)
9401	{
9402	return pDevIns->CTX_SUFF(pHlp)->pfnGetVM(pDevIns);
9403	}
9404
9405	/**
9406	* @copydoc PDMDEVHLPR3::pfnGetVMCPU
9407	*/
9408	DECLINLINE(PVMCPUCC) PDMDevHlpGetVMCPU(PPDMDEVINS pDevIns)
9409	{
9410	return pDevIns->CTX_SUFF(pHlp)->pfnGetVMCPU(pDevIns);
9411	}
9412
9413	/**
9414	* @copydoc PDMDEVHLPR3::pfnGetCurrentCpuId
9415	*/
9416	DECLINLINE(VMCPUID) PDMDevHlpGetCurrentCpuId(PPDMDEVINS pDevIns)
9417	{
9418	return pDevIns->CTX_SUFF(pHlp)->pfnGetCurrentCpuId(pDevIns);
9419	}
9420
9421	/**
9422	* @copydoc PDMDEVHLPR3::pfnTMTimeVirtGet
9423	*/
9424	DECLINLINE(uint64_t) PDMDevHlpTMTimeVirtGet(PPDMDEVINS pDevIns)
9425	{
9426	return pDevIns->CTX_SUFF(pHlp)->pfnTMTimeVirtGet(pDevIns);
9427	}
9428
9429	/**
9430	* @copydoc PDMDEVHLPR3::pfnTMTimeVirtGetFreq
9431	*/
9432	DECLINLINE(uint64_t) PDMDevHlpTMTimeVirtGetFreq(PPDMDEVINS pDevIns)
9433	{
9434	return pDevIns->CTX_SUFF(pHlp)->pfnTMTimeVirtGetFreq(pDevIns);
9435	}
9436
9437	/**
9438	* @copydoc PDMDEVHLPR3::pfnTMTimeVirtGetFreq
9439	*/
9440	DECLINLINE(uint64_t) PDMDevHlpTMTimeVirtGetNano(PPDMDEVINS pDevIns)
9441	{
9442	return pDevIns->CTX_SUFF(pHlp)->pfnTMTimeVirtGetNano(pDevIns);
9443	}
9444
9445	#ifdef IN_RING3
9446	/**
9447	* @copydoc PDMDEVHLPR3::pfnTMCpuTicksPerSecond
9448	*/
9449	DECLINLINE(uint64_t) PDMDevHlpTMCpuTicksPerSecond(PPDMDEVINS pDevIns)
9450	{
9451	return pDevIns->CTX_SUFF(pHlp)->pfnTMCpuTicksPerSecond(pDevIns);
9452	}
9453
9454	/**
9455	* @copydoc PDMDEVHLPR3::pfnRegisterVMMDevHeap
9456	*/
9457	DECLINLINE(int) PDMDevHlpRegisterVMMDevHeap(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, RTR3PTR pvHeap, unsigned cbHeap)
9458	{
9459	return pDevIns->pHlpR3->pfnRegisterVMMDevHeap(pDevIns, GCPhys, pvHeap, cbHeap);
9460	}
9461
9462	/**
9463	* @copydoc PDMDEVHLPR3::pfnFirmwareRegister
9464	*/
9465	DECLINLINE(int) PDMDevHlpFirmwareRegister(PPDMDEVINS pDevIns, PCPDMFWREG pFwReg, PCPDMFWHLPR3 *ppFwHlp)
9466	{
9467	return pDevIns->pHlpR3->pfnFirmwareRegister(pDevIns, pFwReg, ppFwHlp);
9468	}
9469
9470	/**
9471	* @copydoc PDMDEVHLPR3::pfnVMReset
9472	*/
9473	DECLINLINE(int) PDMDevHlpVMReset(PPDMDEVINS pDevIns, uint32_t fFlags)
9474	{
9475	return pDevIns->pHlpR3->pfnVMReset(pDevIns, fFlags);
9476	}
9477
9478	/**
9479	* @copydoc PDMDEVHLPR3::pfnVMSuspend
9480	*/
9481	DECLINLINE(int) PDMDevHlpVMSuspend(PPDMDEVINS pDevIns)
9482	{
9483	return pDevIns->pHlpR3->pfnVMSuspend(pDevIns);
9484	}
9485
9486	/**
9487	* @copydoc PDMDEVHLPR3::pfnVMSuspendSaveAndPowerOff
9488	*/
9489	DECLINLINE(int) PDMDevHlpVMSuspendSaveAndPowerOff(PPDMDEVINS pDevIns)
9490	{
9491	return pDevIns->pHlpR3->pfnVMSuspendSaveAndPowerOff(pDevIns);
9492	}
9493
9494	/**
9495	* @copydoc PDMDEVHLPR3::pfnVMPowerOff
9496	*/
9497	DECLINLINE(int) PDMDevHlpVMPowerOff(PPDMDEVINS pDevIns)
9498	{
9499	return pDevIns->pHlpR3->pfnVMPowerOff(pDevIns);
9500	}
9501
9502	#endif /* IN_RING3 */
9503
9504	/**
9505	* @copydoc PDMDEVHLPR3::pfnA20IsEnabled
9506	*/
9507	DECLINLINE(bool) PDMDevHlpA20IsEnabled(PPDMDEVINS pDevIns)
9508	{
9509	return pDevIns->CTX_SUFF(pHlp)->pfnA20IsEnabled(pDevIns);
9510	}
9511
9512	#ifdef IN_RING3
9513	/**
9514	* @copydoc PDMDEVHLPR3::pfnGetCpuId
9515	*/
9516	DECLINLINE(void) PDMDevHlpGetCpuId(PPDMDEVINS pDevIns, uint32_t iLeaf, uint32_t pEax, uint32_t pEbx, uint32_t pEcx, uint32_t pEdx)
9517	{
9518	pDevIns->pHlpR3->pfnGetCpuId(pDevIns, iLeaf, pEax, pEbx, pEcx, pEdx);
9519	}
9520	#endif
9521
9522	/**
9523	* @copydoc PDMDEVHLPR3::pfnGetMainExecutionEngine
9524	*/
9525	DECLINLINE(uint8_t) PDMDevHlpGetMainExecutionEngine(PPDMDEVINS pDevIns)
9526	{
9527	return pDevIns->CTX_SUFF(pHlp)->pfnGetMainExecutionEngine(pDevIns);
9528	}
9529
9530	#ifdef IN_RING3
9531
9532	/**
9533	* @copydoc PDMDEVHLPR3::pfnGetSupDrvSession
9534	*/
9535	DECLINLINE(PSUPDRVSESSION) PDMDevHlpGetSupDrvSession(PPDMDEVINS pDevIns)
9536	{
9537	return pDevIns->pHlpR3->pfnGetSupDrvSession(pDevIns);
9538	}
9539
9540	/**
9541	* @copydoc PDMDEVHLPR3::pfnQueryGenericUserObject
9542	*/
9543	DECLINLINE(void *) PDMDevHlpQueryGenericUserObject(PPDMDEVINS pDevIns, PCRTUUID pUuid)
9544	{
9545	return pDevIns->pHlpR3->pfnQueryGenericUserObject(pDevIns, pUuid);
9546	}
9547
9548	/**
9549	* @copydoc PDMDEVHLPR3::pfnPGMHandlerPhysicalTypeRegister
9550	*/
9551	DECLINLINE(int) PDMDevHlpPGMHandlerPhysicalTypeRegister(PPDMDEVINS pDevIns, PGMPHYSHANDLERKIND enmKind,
9552	PFNPGMPHYSHANDLER pfnHandler, const char *pszDesc,
9553	PPGMPHYSHANDLERTYPE phType)
9554	{
9555	return pDevIns->pHlpR3->pfnPGMHandlerPhysicalTypeRegister(pDevIns, enmKind, pfnHandler, pszDesc, phType);
9556	}
9557
9558	#elif defined(IN_RING0)
9559
9560	/**
9561	* @copydoc PDMDEVHLPR0::pfnPGMHandlerPhysicalTypeSetUpContext
9562	*/
9563	DECLINLINE(int) PDMDevHlpPGMHandlerPhysicalTypeSetUpContext(PPDMDEVINS pDevIns, PGMPHYSHANDLERKIND enmKind,
9564	PFNPGMPHYSHANDLER pfnHandler, PFNPGMRZPHYSPFHANDLER pfnPfHandler,
9565	const char *pszDesc, PGMPHYSHANDLERTYPE hType)
9566	{
9567	return pDevIns->pHlpR0->pfnPGMHandlerPhysicalTypeSetUpContext(pDevIns, enmKind, pfnHandler, pfnPfHandler, pszDesc, hType);
9568	}
9569
9570	#endif
9571	#ifdef IN_RING3
9572
9573	/**
9574	* @copydoc PDMDEVHLPR3::pfnPGMHandlerPhysicalRegister
9575	*/
9576	DECLINLINE(int) PDMDevHlpPGMHandlerPhysicalRegister(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, RTGCPHYS GCPhysLast,
9577	PGMPHYSHANDLERTYPE hType, R3PTRTYPE(const char *) pszDesc)
9578	{
9579	return pDevIns->pHlpR3->pfnPGMHandlerPhysicalRegister(pDevIns, GCPhys, GCPhysLast, hType, pszDesc);
9580	}
9581
9582	/**
9583	* @copydoc PDMDEVHLPR3::pfnPGMHandlerPhysicalDeregister
9584	*/
9585	DECLINLINE(int) PDMDevHlpPGMHandlerPhysicalDeregister(PPDMDEVINS pDevIns, RTGCPHYS GCPhys)
9586	{
9587	return pDevIns->pHlpR3->pfnPGMHandlerPhysicalDeregister(pDevIns, GCPhys);
9588	}
9589
9590	#endif /* IN_RING3 */
9591
9592	/**
9593	* @copydoc PDMDEVHLPR3::pfnPGMHandlerPhysicalPageTempOff
9594	*/
9595	DECLINLINE(int) PDMDevHlpPGMHandlerPhysicalPageTempOff(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, RTGCPHYS GCPhysPage)
9596	{
9597	return pDevIns->CTX_SUFF(pHlp)->pfnPGMHandlerPhysicalPageTempOff(pDevIns, GCPhys, GCPhysPage);
9598	}
9599
9600	#ifdef IN_RING3
9601
9602	/**
9603	* @copydoc PDMDEVHLPR3::pfnPGMHandlerPhysicalReset
9604	*/
9605	DECLINLINE(int) PDMDevHlpPGMHandlerPhysicalReset(PPDMDEVINS pDevIns, RTGCPHYS GCPhys)
9606	{
9607	return pDevIns->pHlpR3->pfnPGMHandlerPhysicalReset(pDevIns, GCPhys);
9608	}
9609
9610	/**
9611	* @copydoc PDMDEVHLPR3::pfnVMMRegisterPatchMemory
9612	*/
9613	DECLINLINE(int) PDMDevHlpVMMRegisterPatchMemory(PPDMDEVINS pDevIns, RTGCPTR GCPtrPatchMem, uint32_t cbPatchMem)
9614	{
9615	return pDevIns->pHlpR3->pfnVMMRegisterPatchMemory(pDevIns, GCPtrPatchMem, cbPatchMem);
9616	}
9617
9618	/**
9619	* @copydoc PDMDEVHLPR3::pfnVMMDeregisterPatchMemory
9620	*/
9621	DECLINLINE(int) PDMDevHlpVMMDeregisterPatchMemory(PPDMDEVINS pDevIns, RTGCPTR GCPtrPatchMem, uint32_t cbPatchMem)
9622	{
9623	return pDevIns->pHlpR3->pfnVMMDeregisterPatchMemory(pDevIns, GCPtrPatchMem, cbPatchMem);
9624	}
9625
9626	/**
9627	* @copydoc PDMDEVHLPR3::pfnSharedModuleRegister
9628	*/
9629	DECLINLINE(int) PDMDevHlpSharedModuleRegister(PPDMDEVINS pDevIns, VBOXOSFAMILY enmGuestOS, char pszModuleName, char pszVersion,
9630	RTGCPTR GCBaseAddr, uint32_t cbModule,
9631	uint32_t cRegions, VMMDEVSHAREDREGIONDESC const *paRegions)
9632	{
9633	return pDevIns->pHlpR3->pfnSharedModuleRegister(pDevIns, enmGuestOS, pszModuleName, pszVersion,
9634	GCBaseAddr, cbModule, cRegions, paRegions);
9635	}
9636
9637	/**
9638	* @copydoc PDMDEVHLPR3::pfnSharedModuleUnregister
9639	*/
9640	DECLINLINE(int) PDMDevHlpSharedModuleUnregister(PPDMDEVINS pDevIns, char pszModuleName, char pszVersion,
9641	RTGCPTR GCBaseAddr, uint32_t cbModule)
9642	{
9643	return pDevIns->pHlpR3->pfnSharedModuleUnregister(pDevIns, pszModuleName, pszVersion, GCBaseAddr, cbModule);
9644	}
9645
9646	/**
9647	* @copydoc PDMDEVHLPR3::pfnSharedModuleGetPageState
9648	*/
9649	DECLINLINE(int) PDMDevHlpSharedModuleGetPageState(PPDMDEVINS pDevIns, RTGCPTR GCPtrPage, bool *pfShared,
9650	uint64_t *pfPageFlags)
9651	{
9652	return pDevIns->pHlpR3->pfnSharedModuleGetPageState(pDevIns, GCPtrPage, pfShared, pfPageFlags);
9653	}
9654
9655	/**
9656	* @copydoc PDMDEVHLPR3::pfnSharedModuleCheckAll
9657	*/
9658	DECLINLINE(int) PDMDevHlpSharedModuleCheckAll(PPDMDEVINS pDevIns)
9659	{
9660	return pDevIns->pHlpR3->pfnSharedModuleCheckAll(pDevIns);
9661	}
9662
9663	/**
9664	* @copydoc PDMDEVHLPR3::pfnQueryLun
9665	*/
9666	DECLINLINE(int) PDMDevHlpQueryLun(PPDMDEVINS pDevIns, const char pszDevice, unsigned iInstance, unsigned iLun, PPDMIBASE ppBase)
9667	{
9668	return pDevIns->pHlpR3->pfnQueryLun(pDevIns, pszDevice, iInstance, iLun, ppBase);
9669	}
9670
9671	/**
9672	* @copydoc PDMDEVHLPR3::pfnGIMDeviceRegister
9673	*/
9674	DECLINLINE(void) PDMDevHlpGIMDeviceRegister(PPDMDEVINS pDevIns, PGIMDEBUG pDbg)
9675	{
9676	pDevIns->pHlpR3->pfnGIMDeviceRegister(pDevIns, pDbg);
9677	}
9678
9679	/**
9680	* @copydoc PDMDEVHLPR3::pfnGIMGetDebugSetup
9681	*/
9682	DECLINLINE(int) PDMDevHlpGIMGetDebugSetup(PPDMDEVINS pDevIns, PGIMDEBUGSETUP pDbgSetup)
9683	{
9684	return pDevIns->pHlpR3->pfnGIMGetDebugSetup(pDevIns, pDbgSetup);
9685	}
9686
9687	#endif /* IN_RING3 */
9688
9689	/**
9690	* @copydoc PDMDEVHLPR3::pfnGIMGetMmio2Regions
9691	*/
9692	DECLINLINE(PGIMMMIO2REGION) PDMDevHlpGIMGetMmio2Regions(PPDMDEVINS pDevIns, uint32_t *pcRegions)
9693	{
9694	return pDevIns->CTX_SUFF(pHlp)->pfnGIMGetMmio2Regions(pDevIns, pcRegions);
9695	}
9696
9697	#ifdef IN_RING3
9698
9699	/** Wrapper around SSMR3GetU32 for simplifying getting enum values saved as uint32_t. */
9700	# define PDMDEVHLP_SSM_GET_ENUM32_RET(a_pHlp, a_pSSM, a_enmDst, a_EnumType) \
9701	do { \
9702	uint32_t u32GetEnumTmp = 0; \
9703	int rcGetEnum32Tmp = (a_pHlp)->pfnSSMGetU32((a_pSSM), &u32GetEnumTmp); \
9704	AssertRCReturn(rcGetEnum32Tmp, rcGetEnum32Tmp); \
9705	(a_enmDst) = (a_EnumType)u32GetEnumTmp; \
9706	AssertCompile(sizeof(a_EnumType) == sizeof(u32GetEnumTmp)); \
9707	} while (0)
9708
9709	/** Wrapper around SSMR3GetU8 for simplifying getting enum values saved as uint8_t. */
9710	# define PDMDEVHLP_SSM_GET_ENUM8_RET(a_pHlp, a_pSSM, a_enmDst, a_EnumType) \
9711	do { \
9712	uint8_t bGetEnumTmp = 0; \
9713	int rcGetEnum32Tmp = (a_pHlp)->pfnSSMGetU8((a_pSSM), &bGetEnumTmp); \
9714	AssertRCReturn(rcGetEnum32Tmp, rcGetEnum32Tmp); \
9715	(a_enmDst) = (a_EnumType)bGetEnumTmp; \
9716	} while (0)
9717
9718	#endif /* IN_RING3 */
9719
9720	/** Pointer to callbacks provided to the VBoxDeviceRegister() call. */
9721	typedef struct PDMDEVREGCB *PPDMDEVREGCB;
9722
9723	/**
9724	* Callbacks for VBoxDeviceRegister().
9725	*/
9726	typedef struct PDMDEVREGCB
9727	{
9728	/** Interface version.
9729	* This is set to PDM_DEVREG_CB_VERSION. */
9730	uint32_t u32Version;
9731
9732	/**
9733	* Registers a device with the current VM instance.
9734	*
9735	* @returns VBox status code.
9736	* @param pCallbacks Pointer to the callback table.
9737	* @param pReg Pointer to the device registration record.
9738	* This data must be permanent and readonly.
9739	*/
9740	DECLR3CALLBACKMEMBER(int, pfnRegister,(PPDMDEVREGCB pCallbacks, PCPDMDEVREG pReg));
9741	} PDMDEVREGCB;
9742
9743	/** Current version of the PDMDEVREGCB structure. */
9744	#define PDM_DEVREG_CB_VERSION PDM_VERSION_MAKE(0xffe3, 1, 0)
9745
9746
9747	/**
9748	* The VBoxDevicesRegister callback function.
9749	*
9750	* PDM will invoke this function after loading a device module and letting
9751	* the module decide which devices to register and how to handle conflicts.
9752	*
9753	* @returns VBox status code.
9754	* @param pCallbacks Pointer to the callback table.
9755	* @param u32Version VBox version number.
9756	*/
9757	typedef DECLCALLBACKTYPE(int, FNPDMVBOXDEVICESREGISTER,(PPDMDEVREGCB pCallbacks, uint32_t u32Version));
9758
9759	/** @} */
9760
9761	RT_C_DECLS_END
9762
9763	#endif /* !VBOX_INCLUDED_vmm_pdmdev_h */

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

source: vbox/trunk/include/VBox/vmm/pdmdev.h

Download in other formats: