pdmdev.h@ 93725

Last change on this file since 93725 was 93650, checked in by vboxsync, 3 years ago
VMM/PGM,*: Split the physical access handler type registration into separate ring-0 and ring-3 steps, expanding the type to 64-bit. bugref:10094
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 404.9 KB

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

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

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

Download in other formats: