PDMDevHlp.cpp@ 29566

Last change on this file since 29566 was 29521, checked in by vboxsync, 15 years ago
PDM: Added PDMDevHlpCallR0 and PDMDEV_VALIDATE_CONFIG_RETURN.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 131.2 KB

Line
1	/* $Id: PDMDevHlp.cpp 29521 2010-05-17 10:14:22Z vboxsync $ */
2	/** @file
3	* PDM - Pluggable Device and Driver Manager, Device Helpers.
4	*/
5
6	/*
7	* Copyright (C) 2006-2010 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18
19	/*******************************************************************************
20	* Header Files *
21	*******************************************************************************/
22	#define LOG_GROUP LOG_GROUP_PDM_DEVICE
23	#include "PDMInternal.h"
24	#include <VBox/pdm.h>
25	#include <VBox/mm.h>
26	#include <VBox/pgm.h>
27	#include <VBox/iom.h>
28	#include <VBox/rem.h>
29	#include <VBox/dbgf.h>
30	#include <VBox/vm.h>
31	#include <VBox/vmm.h>
32
33	#include <VBox/version.h>
34	#include <VBox/log.h>
35	#include <VBox/err.h>
36	#include <iprt/asm.h>
37	#include <iprt/assert.h>
38	#include <iprt/ctype.h>
39	#include <iprt/string.h>
40	#include <iprt/thread.h>
41
42
43	/*******************************************************************************
44	* Defined Constants And Macros *
45	*******************************************************************************/
46	/** @def PDM_DEVHLP_DEADLOCK_DETECTION
47	* Define this to enable the deadlock detection when accessing physical memory.
48	*/
49	#if /defined(DEBUG_bird) \|\|/ defined(DOXYGEN_RUNNING)
50	# define PDM_DEVHLP_DEADLOCK_DETECTION /*< @todo enable DevHlp deadlock detection! /
51	#endif
52
53
54	/*******************************************************************************
55	* Defined Constants And Macros *
56	*******************************************************************************/
57	/** @name R3 DevHlp
58	* @{
59	*/
60
61
62	/** @interface_method_impl{PDMDEVHLPR3,pfnIOPortRegister} */
63	static DECLCALLBACK(int) pdmR3DevHlp_IOPortRegister(PPDMDEVINS pDevIns, RTIOPORT Port, RTUINT cPorts, RTHCPTR pvUser, PFNIOMIOPORTOUT pfnOut, PFNIOMIOPORTIN pfnIn,
64	PFNIOMIOPORTOUTSTRING pfnOutStr, PFNIOMIOPORTINSTRING pfnInStr, const char *pszDesc)
65	{
66	PDMDEV_ASSERT_DEVINS(pDevIns);
67	LogFlow(("pdmR3DevHlp_IOPortRegister: caller='%s'/%d: Port=%#x cPorts=%#x pvUser=%p pfnOut=%p pfnIn=%p pfnOutStr=%p pfnInStr=%p p32_tszDesc=%p:{%s}\n", pDevIns->pReg->szName, pDevIns->iInstance,
68	Port, cPorts, pvUser, pfnOut, pfnIn, pfnOutStr, pfnInStr, pszDesc, pszDesc));
69	VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
70
71	#if 0 /** @todo needs a real string cache for this */
72	if (pDevIns->iInstance > 0)
73	{
74	char *pszDesc2 = MMR3HeapAPrintf(pVM, MM_TAG_PDM_DEVICE_DESC, "%s [%u]", pszDesc, pDevIns->iInstance);
75	if (pszDesc2)
76	pszDesc = pszDesc2;
77	}
78	#endif
79
80	int rc = IOMR3IOPortRegisterR3(pDevIns->Internal.s.pVMR3, pDevIns, Port, cPorts, pvUser, pfnOut, pfnIn, pfnOutStr, pfnInStr, pszDesc);
81
82	LogFlow(("pdmR3DevHlp_IOPortRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
83	return rc;
84	}
85
86
87	/** @interface_method_impl{PDMDEVHLPR3,pfnIOPortRegisterRC} */
88	static DECLCALLBACK(int) pdmR3DevHlp_IOPortRegisterRC(PPDMDEVINS pDevIns, RTIOPORT Port, RTUINT cPorts, RTRCPTR pvUser,
89	const char pszOut, const char pszIn,
90	const char pszOutStr, const char pszInStr, const char *pszDesc)
91	{
92	PDMDEV_ASSERT_DEVINS(pDevIns);
93	VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
94	LogFlow(("pdmR3DevHlp_IOPortRegisterRC: caller='%s'/%d: Port=%#x cPorts=%#x pvUser=%p pszOut=%p:{%s} pszIn=%p:{%s} pszOutStr=%p:{%s} pszInStr=%p:{%s} pszDesc=%p:{%s}\n", pDevIns->pReg->szName, pDevIns->iInstance,
95	Port, cPorts, pvUser, pszOut, pszOut, pszIn, pszIn, pszOutStr, pszOutStr, pszInStr, pszInStr, pszDesc, pszDesc));
96
97	/*
98	* Resolve the functions (one of the can be NULL).
99	*/
100	int rc = VINF_SUCCESS;
101	if ( pDevIns->pReg->szRCMod[0]
102	&& (pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_RC))
103	{
104	RTRCPTR RCPtrIn = NIL_RTRCPTR;
105	if (pszIn)
106	{
107	rc = PDMR3LdrGetSymbolRCLazy(pDevIns->Internal.s.pVMR3, pDevIns->pReg->szRCMod, pszIn, &RCPtrIn);
108	AssertMsgRC(rc, ("Failed to resolve %s.%s (pszIn)\n", pDevIns->pReg->szRCMod, pszIn));
109	}
110	RTRCPTR RCPtrOut = NIL_RTRCPTR;
111	if (pszOut && RT_SUCCESS(rc))
112	{
113	rc = PDMR3LdrGetSymbolRCLazy(pDevIns->Internal.s.pVMR3, pDevIns->pReg->szRCMod, pszOut, &RCPtrOut);
114	AssertMsgRC(rc, ("Failed to resolve %s.%s (pszOut)\n", pDevIns->pReg->szRCMod, pszOut));
115	}
116	RTRCPTR RCPtrInStr = NIL_RTRCPTR;
117	if (pszInStr && RT_SUCCESS(rc))
118	{
119	rc = PDMR3LdrGetSymbolRCLazy(pDevIns->Internal.s.pVMR3, pDevIns->pReg->szRCMod, pszInStr, &RCPtrInStr);
120	AssertMsgRC(rc, ("Failed to resolve %s.%s (pszInStr)\n", pDevIns->pReg->szRCMod, pszInStr));
121	}
122	RTRCPTR RCPtrOutStr = NIL_RTRCPTR;
123	if (pszOutStr && RT_SUCCESS(rc))
124	{
125	rc = PDMR3LdrGetSymbolRCLazy(pDevIns->Internal.s.pVMR3, pDevIns->pReg->szRCMod, pszOutStr, &RCPtrOutStr);
126	AssertMsgRC(rc, ("Failed to resolve %s.%s (pszOutStr)\n", pDevIns->pReg->szRCMod, pszOutStr));
127	}
128
129	if (RT_SUCCESS(rc))
130	{
131	#if 0 /** @todo needs a real string cache for this */
132	if (pDevIns->iInstance > 0)
133	{
134	char *pszDesc2 = MMR3HeapAPrintf(pVM, MM_TAG_PDM_DEVICE_DESC, "%s [%u]", pszDesc, pDevIns->iInstance);
135	if (pszDesc2)
136	pszDesc = pszDesc2;
137	}
138	#endif
139
140	rc = IOMR3IOPortRegisterRC(pDevIns->Internal.s.pVMR3, pDevIns, Port, cPorts, pvUser, RCPtrOut, RCPtrIn, RCPtrOutStr, RCPtrInStr, pszDesc);
141	}
142	}
143	else
144	{
145	AssertMsgFailed(("No GC module for this driver!\n"));
146	rc = VERR_INVALID_PARAMETER;
147	}
148
149	LogFlow(("pdmR3DevHlp_IOPortRegisterRC: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
150	return rc;
151	}
152
153
154	/** @interface_method_impl{PDMDEVHLPR3,pfnIOPortRegisterR0} */
155	static DECLCALLBACK(int) pdmR3DevHlp_IOPortRegisterR0(PPDMDEVINS pDevIns, RTIOPORT Port, RTUINT cPorts, RTR0PTR pvUser,
156	const char pszOut, const char pszIn,
157	const char pszOutStr, const char pszInStr, const char *pszDesc)
158	{
159	PDMDEV_ASSERT_DEVINS(pDevIns);
160	VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
161	LogFlow(("pdmR3DevHlp_IOPortRegisterR0: caller='%s'/%d: Port=%#x cPorts=%#x pvUser=%p pszOut=%p:{%s} pszIn=%p:{%s} pszOutStr=%p:{%s} pszInStr=%p:{%s} pszDesc=%p:{%s}\n", pDevIns->pReg->szName, pDevIns->iInstance,
162	Port, cPorts, pvUser, pszOut, pszOut, pszIn, pszIn, pszOutStr, pszOutStr, pszInStr, pszInStr, pszDesc, pszDesc));
163
164	/*
165	* Resolve the functions (one of the can be NULL).
166	*/
167	int rc = VINF_SUCCESS;
168	if ( pDevIns->pReg->szR0Mod[0]
169	&& (pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_R0))
170	{
171	R0PTRTYPE(PFNIOMIOPORTIN) pfnR0PtrIn = 0;
172	if (pszIn)
173	{
174	rc = PDMR3LdrGetSymbolR0Lazy(pDevIns->Internal.s.pVMR3, pDevIns->pReg->szR0Mod, pszIn, &pfnR0PtrIn);
175	AssertMsgRC(rc, ("Failed to resolve %s.%s (pszIn)\n", pDevIns->pReg->szR0Mod, pszIn));
176	}
177	R0PTRTYPE(PFNIOMIOPORTOUT) pfnR0PtrOut = 0;
178	if (pszOut && RT_SUCCESS(rc))
179	{
180	rc = PDMR3LdrGetSymbolR0Lazy(pDevIns->Internal.s.pVMR3, pDevIns->pReg->szR0Mod, pszOut, &pfnR0PtrOut);
181	AssertMsgRC(rc, ("Failed to resolve %s.%s (pszOut)\n", pDevIns->pReg->szR0Mod, pszOut));
182	}
183	R0PTRTYPE(PFNIOMIOPORTINSTRING) pfnR0PtrInStr = 0;
184	if (pszInStr && RT_SUCCESS(rc))
185	{
186	rc = PDMR3LdrGetSymbolR0Lazy(pDevIns->Internal.s.pVMR3, pDevIns->pReg->szR0Mod, pszInStr, &pfnR0PtrInStr);
187	AssertMsgRC(rc, ("Failed to resolve %s.%s (pszInStr)\n", pDevIns->pReg->szR0Mod, pszInStr));
188	}
189	R0PTRTYPE(PFNIOMIOPORTOUTSTRING) pfnR0PtrOutStr = 0;
190	if (pszOutStr && RT_SUCCESS(rc))
191	{
192	rc = PDMR3LdrGetSymbolR0Lazy(pDevIns->Internal.s.pVMR3, pDevIns->pReg->szR0Mod, pszOutStr, &pfnR0PtrOutStr);
193	AssertMsgRC(rc, ("Failed to resolve %s.%s (pszOutStr)\n", pDevIns->pReg->szR0Mod, pszOutStr));
194	}
195
196	if (RT_SUCCESS(rc))
197	{
198	#if 0 /** @todo needs a real string cache for this */
199	if (pDevIns->iInstance > 0)
200	{
201	char *pszDesc2 = MMR3HeapAPrintf(pVM, MM_TAG_PDM_DEVICE_DESC, "%s [%u]", pszDesc, pDevIns->iInstance);
202	if (pszDesc2)
203	pszDesc = pszDesc2;
204	}
205	#endif
206
207	rc = IOMR3IOPortRegisterR0(pDevIns->Internal.s.pVMR3, pDevIns, Port, cPorts, pvUser, pfnR0PtrOut, pfnR0PtrIn, pfnR0PtrOutStr, pfnR0PtrInStr, pszDesc);
208	}
209	}
210	else
211	{
212	AssertMsgFailed(("No R0 module for this driver!\n"));
213	rc = VERR_INVALID_PARAMETER;
214	}
215
216	LogFlow(("pdmR3DevHlp_IOPortRegisterR0: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
217	return rc;
218	}
219
220
221	/** @interface_method_impl{PDMDEVHLPR3,pfnIOPortDeregister} */
222	static DECLCALLBACK(int) pdmR3DevHlp_IOPortDeregister(PPDMDEVINS pDevIns, RTIOPORT Port, RTUINT cPorts)
223	{
224	PDMDEV_ASSERT_DEVINS(pDevIns);
225	VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
226	LogFlow(("pdmR3DevHlp_IOPortDeregister: caller='%s'/%d: Port=%#x cPorts=%#x\n", pDevIns->pReg->szName, pDevIns->iInstance,
227	Port, cPorts));
228
229	int rc = IOMR3IOPortDeregister(pDevIns->Internal.s.pVMR3, pDevIns, Port, cPorts);
230
231	LogFlow(("pdmR3DevHlp_IOPortDeregister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
232	return rc;
233	}
234
235
236	/** @interface_method_impl{PDMDEVHLPR3,pfnMMIORegister} */
237	static DECLCALLBACK(int) pdmR3DevHlp_MMIORegister(PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, RTUINT cbRange, RTHCPTR pvUser,
238	PFNIOMMMIOWRITE pfnWrite, PFNIOMMMIOREAD pfnRead, PFNIOMMMIOFILL pfnFill,
239	const char *pszDesc)
240	{
241	PDMDEV_ASSERT_DEVINS(pDevIns);
242	VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
243	LogFlow(("pdmR3DevHlp_MMIORegister: caller='%s'/%d: GCPhysStart=%RGp cbRange=%#x pvUser=%p pfnWrite=%p pfnRead=%p pfnFill=%p pszDesc=%p:{%s}\n",
244	pDevIns->pReg->szName, pDevIns->iInstance, GCPhysStart, cbRange, pvUser, pfnWrite, pfnRead, pfnFill, pszDesc, pszDesc));
245
246	/** @todo IOMR3MMIORegisterR3 mangles the description, move it here. */
247	int rc = IOMR3MMIORegisterR3(pDevIns->Internal.s.pVMR3, pDevIns, GCPhysStart, cbRange, pvUser, pfnWrite, pfnRead, pfnFill, pszDesc);
248
249	LogFlow(("pdmR3DevHlp_MMIORegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
250	return rc;
251	}
252
253
254	/** @interface_method_impl{PDMDEVHLPR3,pfnMMIORegisterRC} */
255	static DECLCALLBACK(int) pdmR3DevHlp_MMIORegisterRC(PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, RTUINT cbRange, RTGCPTR pvUser,
256	const char pszWrite, const char pszRead, const char *pszFill,
257	const char *pszDesc)
258	{
259	PDMDEV_ASSERT_DEVINS(pDevIns);
260	VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
261	LogFlow(("pdmR3DevHlp_MMIORegisterRC: caller='%s'/%d: GCPhysStart=%RGp cbRange=%#x pvUser=%p pszWrite=%p:{%s} pszRead=%p:{%s} pszFill=%p:{%s}\n",
262	pDevIns->pReg->szName, pDevIns->iInstance, GCPhysStart, cbRange, pvUser, pszWrite, pszWrite, pszRead, pszRead, pszFill, pszFill));
263
264	/** @todo pszDesc is unused here, drop it. */
265
266	/*
267	* Resolve the functions.
268	* Not all function have to present, leave it to IOM to enforce this.
269	*/
270	int rc = VINF_SUCCESS;
271	if ( pDevIns->pReg->szRCMod[0]
272	&& (pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_RC))
273	{
274	RTRCPTR RCPtrWrite = NIL_RTRCPTR;
275	if (pszWrite)
276	rc = PDMR3LdrGetSymbolRCLazy(pDevIns->Internal.s.pVMR3, pDevIns->pReg->szRCMod, pszWrite, &RCPtrWrite);
277
278	RTRCPTR RCPtrRead = NIL_RTRCPTR;
279	int rc2 = VINF_SUCCESS;
280	if (pszRead)
281	rc2 = PDMR3LdrGetSymbolRCLazy(pDevIns->Internal.s.pVMR3, pDevIns->pReg->szRCMod, pszRead, &RCPtrRead);
282
283	RTRCPTR RCPtrFill = NIL_RTRCPTR;
284	int rc3 = VINF_SUCCESS;
285	if (pszFill)
286	rc3 = PDMR3LdrGetSymbolRCLazy(pDevIns->Internal.s.pVMR3, pDevIns->pReg->szRCMod, pszFill, &RCPtrFill);
287
288	if (RT_SUCCESS(rc) && RT_SUCCESS(rc2) && RT_SUCCESS(rc3))
289	rc = IOMR3MMIORegisterRC(pDevIns->Internal.s.pVMR3, pDevIns, GCPhysStart, cbRange, pvUser, RCPtrWrite, RCPtrRead, RCPtrFill);
290	else
291	{
292	AssertMsgRC(rc, ("Failed to resolve %s.%s (pszWrite)\n", pDevIns->pReg->szRCMod, pszWrite));
293	AssertMsgRC(rc2, ("Failed to resolve %s.%s (pszRead)\n", pDevIns->pReg->szRCMod, pszRead));
294	AssertMsgRC(rc3, ("Failed to resolve %s.%s (pszFill)\n", pDevIns->pReg->szRCMod, pszFill));
295	if (RT_FAILURE(rc2) && RT_SUCCESS(rc))
296	rc = rc2;
297	if (RT_FAILURE(rc3) && RT_SUCCESS(rc))
298	rc = rc3;
299	}
300	}
301	else
302	{
303	AssertMsgFailed(("No GC module for this driver!\n"));
304	rc = VERR_INVALID_PARAMETER;
305	}
306
307	LogFlow(("pdmR3DevHlp_MMIORegisterRC: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
308	return rc;
309	}
310
311	/** @interface_method_impl{PDMDEVHLPR3,pfnMMIORegisterR0} */
312	static DECLCALLBACK(int) pdmR3DevHlp_MMIORegisterR0(PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, RTUINT cbRange, RTR0PTR pvUser,
313	const char pszWrite, const char pszRead, const char *pszFill,
314	const char *pszDesc)
315	{
316	PDMDEV_ASSERT_DEVINS(pDevIns);
317	VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
318	LogFlow(("pdmR3DevHlp_MMIORegisterHC: caller='%s'/%d: GCPhysStart=%RGp cbRange=%#x pvUser=%p pszWrite=%p:{%s} pszRead=%p:{%s} pszFill=%p:{%s}\n",
319	pDevIns->pReg->szName, pDevIns->iInstance, GCPhysStart, cbRange, pvUser, pszWrite, pszWrite, pszRead, pszRead, pszFill, pszFill));
320
321	/** @todo pszDesc is unused here, remove it. */
322
323	/*
324	* Resolve the functions.
325	* Not all function have to present, leave it to IOM to enforce this.
326	*/
327	int rc = VINF_SUCCESS;
328	if ( pDevIns->pReg->szR0Mod[0]
329	&& (pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_R0))
330	{
331	R0PTRTYPE(PFNIOMMMIOWRITE) pfnR0PtrWrite = 0;
332	if (pszWrite)
333	rc = PDMR3LdrGetSymbolR0Lazy(pDevIns->Internal.s.pVMR3, pDevIns->pReg->szR0Mod, pszWrite, &pfnR0PtrWrite);
334	R0PTRTYPE(PFNIOMMMIOREAD) pfnR0PtrRead = 0;
335	int rc2 = VINF_SUCCESS;
336	if (pszRead)
337	rc2 = PDMR3LdrGetSymbolR0Lazy(pDevIns->Internal.s.pVMR3, pDevIns->pReg->szR0Mod, pszRead, &pfnR0PtrRead);
338	R0PTRTYPE(PFNIOMMMIOFILL) pfnR0PtrFill = 0;
339	int rc3 = VINF_SUCCESS;
340	if (pszFill)
341	rc3 = PDMR3LdrGetSymbolR0Lazy(pDevIns->Internal.s.pVMR3, pDevIns->pReg->szR0Mod, pszFill, &pfnR0PtrFill);
342	if (RT_SUCCESS(rc) && RT_SUCCESS(rc2) && RT_SUCCESS(rc3))
343	rc = IOMR3MMIORegisterR0(pDevIns->Internal.s.pVMR3, pDevIns, GCPhysStart, cbRange, pvUser, pfnR0PtrWrite, pfnR0PtrRead, pfnR0PtrFill);
344	else
345	{
346	AssertMsgRC(rc, ("Failed to resolve %s.%s (pszWrite)\n", pDevIns->pReg->szR0Mod, pszWrite));
347	AssertMsgRC(rc2, ("Failed to resolve %s.%s (pszRead)\n", pDevIns->pReg->szR0Mod, pszRead));
348	AssertMsgRC(rc3, ("Failed to resolve %s.%s (pszFill)\n", pDevIns->pReg->szR0Mod, pszFill));
349	if (RT_FAILURE(rc2) && RT_SUCCESS(rc))
350	rc = rc2;
351	if (RT_FAILURE(rc3) && RT_SUCCESS(rc))
352	rc = rc3;
353	}
354	}
355	else
356	{
357	AssertMsgFailed(("No R0 module for this driver!\n"));
358	rc = VERR_INVALID_PARAMETER;
359	}
360
361	LogFlow(("pdmR3DevHlp_MMIORegisterR0: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
362	return rc;
363	}
364
365
366	/** @interface_method_impl{PDMDEVHLPR3,pfnMMIODeregister} */
367	static DECLCALLBACK(int) pdmR3DevHlp_MMIODeregister(PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, RTUINT cbRange)
368	{
369	PDMDEV_ASSERT_DEVINS(pDevIns);
370	VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
371	LogFlow(("pdmR3DevHlp_MMIODeregister: caller='%s'/%d: GCPhysStart=%RGp cbRange=%#x\n",
372	pDevIns->pReg->szName, pDevIns->iInstance, GCPhysStart, cbRange));
373
374	int rc = IOMR3MMIODeregister(pDevIns->Internal.s.pVMR3, pDevIns, GCPhysStart, cbRange);
375
376	LogFlow(("pdmR3DevHlp_MMIODeregister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
377	return rc;
378	}
379
380
381	/**
382	* @copydoc PDMDEVHLPR3::pfnMMIO2Register
383	*/
384	static DECLCALLBACK(int) pdmR3DevHlp_MMIO2Register(PPDMDEVINS pDevIns, uint32_t iRegion, RTGCPHYS cb, uint32_t fFlags, void *ppv, const char pszDesc)
385	{
386	PDMDEV_ASSERT_DEVINS(pDevIns);
387	VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
388	LogFlow(("pdmR3DevHlp_MMIO2Register: caller='%s'/%d: iRegion=%#x cb=%#RGp fFlags=%RX32 ppv=%p pszDescp=%p:{%s}\n",
389	pDevIns->pReg->szName, pDevIns->iInstance, iRegion, cb, fFlags, ppv, pszDesc, pszDesc));
390
391	/** @todo PGMR3PhysMMIO2Register mangles the description, move it here and
392	* use a real string cache. */
393	int rc = PGMR3PhysMMIO2Register(pDevIns->Internal.s.pVMR3, pDevIns, iRegion, cb, fFlags, ppv, pszDesc);
394
395	LogFlow(("pdmR3DevHlp_MMIO2Register: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
396	return rc;
397	}
398
399
400	/**
401	* @copydoc PDMDEVHLPR3::pfnMMIO2Deregister
402	*/
403	static DECLCALLBACK(int) pdmR3DevHlp_MMIO2Deregister(PPDMDEVINS pDevIns, uint32_t iRegion)
404	{
405	PDMDEV_ASSERT_DEVINS(pDevIns);
406	VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
407	LogFlow(("pdmR3DevHlp_MMIO2Deregister: caller='%s'/%d: iRegion=%#x\n",
408	pDevIns->pReg->szName, pDevIns->iInstance, iRegion));
409
410	AssertReturn(iRegion == UINT32_MAX, VERR_INVALID_PARAMETER);
411
412	int rc = PGMR3PhysMMIO2Deregister(pDevIns->Internal.s.pVMR3, pDevIns, iRegion);
413
414	LogFlow(("pdmR3DevHlp_MMIO2Deregister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
415	return rc;
416	}
417
418
419	/**
420	* @copydoc PDMDEVHLPR3::pfnMMIO2Map
421	*/
422	static DECLCALLBACK(int) pdmR3DevHlp_MMIO2Map(PPDMDEVINS pDevIns, uint32_t iRegion, RTGCPHYS GCPhys)
423	{
424	PDMDEV_ASSERT_DEVINS(pDevIns);
425	VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
426	LogFlow(("pdmR3DevHlp_MMIO2Map: caller='%s'/%d: iRegion=%#x GCPhys=%#RGp\n",
427	pDevIns->pReg->szName, pDevIns->iInstance, iRegion, GCPhys));
428
429	int rc = PGMR3PhysMMIO2Map(pDevIns->Internal.s.pVMR3, pDevIns, iRegion, GCPhys);
430
431	LogFlow(("pdmR3DevHlp_MMIO2Map: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
432	return rc;
433	}
434
435
436	/**
437	* @copydoc PDMDEVHLPR3::pfnMMIO2Unmap
438	*/
439	static DECLCALLBACK(int) pdmR3DevHlp_MMIO2Unmap(PPDMDEVINS pDevIns, uint32_t iRegion, RTGCPHYS GCPhys)
440	{
441	PDMDEV_ASSERT_DEVINS(pDevIns);
442	VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
443	LogFlow(("pdmR3DevHlp_MMIO2Unmap: caller='%s'/%d: iRegion=%#x GCPhys=%#RGp\n",
444	pDevIns->pReg->szName, pDevIns->iInstance, iRegion, GCPhys));
445
446	int rc = PGMR3PhysMMIO2Unmap(pDevIns->Internal.s.pVMR3, pDevIns, iRegion, GCPhys);
447
448	LogFlow(("pdmR3DevHlp_MMIO2Unmap: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
449	return rc;
450	}
451
452
453	/**
454	* @copydoc PDMDEVHLPR3::pfnMMHyperMapMMIO2
455	*/
456	static DECLCALLBACK(int) pdmR3DevHlp_MMHyperMapMMIO2(PPDMDEVINS pDevIns, uint32_t iRegion, RTGCPHYS off, RTGCPHYS cb,
457	const char *pszDesc, PRTRCPTR pRCPtr)
458	{
459	PDMDEV_ASSERT_DEVINS(pDevIns);
460	PVM pVM = pDevIns->Internal.s.pVMR3;
461	VM_ASSERT_EMT(pVM);
462	LogFlow(("pdmR3DevHlp_MMHyperMapMMIO2: caller='%s'/%d: iRegion=%#x off=%RGp cb=%RGp pszDesc=%p:{%s} pRCPtr=%p\n",
463	pDevIns->pReg->szName, pDevIns->iInstance, iRegion, off, cb, pszDesc, pszDesc, pRCPtr));
464
465	if (pDevIns->iInstance > 0)
466	{
467	char *pszDesc2 = MMR3HeapAPrintf(pVM, MM_TAG_PDM_DEVICE_DESC, "%s [%u]", pszDesc, pDevIns->iInstance);
468	if (pszDesc2)
469	pszDesc = pszDesc2;
470	}
471
472	int rc = MMR3HyperMapMMIO2(pVM, pDevIns, iRegion, off, cb, pszDesc, pRCPtr);
473
474	LogFlow(("pdmR3DevHlp_MMHyperMapMMIO2: caller='%s'/%d: returns %Rrc pRCPtr=%RRv\n", pDevIns->pReg->szName, pDevIns->iInstance, rc, pRCPtr));
475	return rc;
476	}
477
478
479	/**
480	* @copydoc PDMDEVHLPR3::pfnMMIO2MapKernel
481	*/
482	static DECLCALLBACK(int) pdmR3DevHlp_MMIO2MapKernel(PPDMDEVINS pDevIns, uint32_t iRegion, RTGCPHYS off, RTGCPHYS cb,
483	const char *pszDesc, PRTR0PTR pR0Ptr)
484	{
485	PDMDEV_ASSERT_DEVINS(pDevIns);
486	PVM pVM = pDevIns->Internal.s.pVMR3;
487	VM_ASSERT_EMT(pVM);
488	LogFlow(("pdmR3DevHlp_MMIO2MapKernel: caller='%s'/%d: iRegion=%#x off=%RGp cb=%RGp pszDesc=%p:{%s} pR0Ptr=%p\n",
489	pDevIns->pReg->szName, pDevIns->iInstance, iRegion, off, cb, pszDesc, pszDesc, pR0Ptr));
490
491	if (pDevIns->iInstance > 0)
492	{
493	char *pszDesc2 = MMR3HeapAPrintf(pVM, MM_TAG_PDM_DEVICE_DESC, "%s [%u]", pszDesc, pDevIns->iInstance);
494	if (pszDesc2)
495	pszDesc = pszDesc2;
496	}
497
498	int rc = PGMR3PhysMMIO2MapKernel(pVM, pDevIns, iRegion, off, cb, pszDesc, pR0Ptr);
499
500	LogFlow(("pdmR3DevHlp_MMIO2MapKernel: caller='%s'/%d: returns %Rrc pR0Ptr=%RHv\n", pDevIns->pReg->szName, pDevIns->iInstance, rc, pR0Ptr));
501	return rc;
502	}
503
504
505	/** @interface_method_impl{PDMDEVHLPR3,pfnROMRegister} */
506	static DECLCALLBACK(int) pdmR3DevHlp_ROMRegister(PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, RTUINT cbRange, const void pvBinary, uint32_t fFlags, const char pszDesc)
507	{
508	PDMDEV_ASSERT_DEVINS(pDevIns);
509	VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
510	LogFlow(("pdmR3DevHlp_ROMRegister: caller='%s'/%d: GCPhysStart=%RGp cbRange=%#x pvBinary=%p fFlags=%#RX32 pszDesc=%p:{%s}\n",
511	pDevIns->pReg->szName, pDevIns->iInstance, GCPhysStart, cbRange, pvBinary, fFlags, pszDesc, pszDesc));
512
513	/** @todo can we mangle pszDesc? */
514	int rc = PGMR3PhysRomRegister(pDevIns->Internal.s.pVMR3, pDevIns, GCPhysStart, cbRange, pvBinary, fFlags, pszDesc);
515
516	LogFlow(("pdmR3DevHlp_ROMRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
517	return rc;
518	}
519
520
521	/** @interface_method_impl{PDMDEVHLPR3,pfnROMProtectShadow} */
522	static DECLCALLBACK(int) pdmR3DevHlp_ROMProtectShadow(PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, RTUINT cbRange, PGMROMPROT enmProt)
523	{
524	PDMDEV_ASSERT_DEVINS(pDevIns);
525	LogFlow(("pdmR3DevHlp_ROMProtectShadow: caller='%s'/%d: GCPhysStart=%RGp cbRange=%#x enmProt=%d\n",
526	pDevIns->pReg->szName, pDevIns->iInstance, GCPhysStart, cbRange, enmProt));
527
528	int rc = PGMR3PhysRomProtect(pDevIns->Internal.s.pVMR3, GCPhysStart, cbRange, enmProt);
529
530	LogFlow(("pdmR3DevHlp_ROMProtectShadow: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
531	return rc;
532	}
533
534
535	/** @interface_method_impl{PDMDEVHLPR3,pfnSSMRegister} */
536	static DECLCALLBACK(int) pdmR3DevHlp_SSMRegister(PPDMDEVINS pDevIns, uint32_t uVersion, size_t cbGuess, const char *pszBefore,
537	PFNSSMDEVLIVEPREP pfnLivePrep, PFNSSMDEVLIVEEXEC pfnLiveExec, PFNSSMDEVLIVEVOTE pfnLiveVote,
538	PFNSSMDEVSAVEPREP pfnSavePrep, PFNSSMDEVSAVEEXEC pfnSaveExec, PFNSSMDEVSAVEDONE pfnSaveDone,
539	PFNSSMDEVLOADPREP pfnLoadPrep, PFNSSMDEVLOADEXEC pfnLoadExec, PFNSSMDEVLOADDONE pfnLoadDone)
540	{
541	PDMDEV_ASSERT_DEVINS(pDevIns);
542	VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
543	LogFlow(("pdmR3DevHlp_SSMRegister: caller='%s'/%d: uVersion=#x cbGuess=%#x pszBefore=%p:{%s}\n"
544	" pfnLivePrep=%p pfnLiveExec=%p pfnLiveVote=%p pfnSavePrep=%p pfnSaveExec=%p pfnSaveDone=%p pszLoadPrep=%p pfnLoadExec=%p pfnLoadDone=%p\n",
545	pDevIns->pReg->szName, pDevIns->iInstance, uVersion, cbGuess, pszBefore, pszBefore,
546	pfnLivePrep, pfnLiveExec, pfnLiveVote,
547	pfnSavePrep, pfnSaveExec, pfnSaveDone,
548	pfnLoadPrep, pfnLoadExec, pfnLoadDone));
549
550	int rc = SSMR3RegisterDevice(pDevIns->Internal.s.pVMR3, pDevIns, pDevIns->pReg->szName, pDevIns->iInstance,
551	uVersion, cbGuess, pszBefore,
552	pfnLivePrep, pfnLiveExec, pfnLiveVote,
553	pfnSavePrep, pfnSaveExec, pfnSaveDone,
554	pfnLoadPrep, pfnLoadExec, pfnLoadDone);
555
556	LogFlow(("pdmR3DevHlp_SSMRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
557	return rc;
558	}
559
560
561	/** @interface_method_impl{PDMDEVHLPR3,pfnTMTimerCreate} */
562	static DECLCALLBACK(int) pdmR3DevHlp_TMTimerCreate(PPDMDEVINS pDevIns, TMCLOCK enmClock, PFNTMTIMERDEV pfnCallback, void pvUser, uint32_t fFlags, const char pszDesc, PPTMTIMERR3 ppTimer)
563	{
564	PDMDEV_ASSERT_DEVINS(pDevIns);
565	PVM pVM = pDevIns->Internal.s.pVMR3;
566	VM_ASSERT_EMT(pVM);
567	LogFlow(("pdmR3DevHlp_TMTimerCreate: caller='%s'/%d: enmClock=%d pfnCallback=%p pvUser=%p fFlags=%#x pszDesc=%p:{%s} ppTimer=%p\n",
568	pDevIns->pReg->szName, pDevIns->iInstance, enmClock, pfnCallback, pvUser, fFlags, pszDesc, pszDesc, ppTimer));
569
570	if (pDevIns->iInstance > 0) /** @todo use a string cache here later. */
571	{
572	char *pszDesc2 = MMR3HeapAPrintf(pVM, MM_TAG_PDM_DEVICE_DESC, "%s [%u]", pszDesc, pDevIns->iInstance);
573	if (pszDesc2)
574	pszDesc = pszDesc2;
575	}
576
577	int rc = TMR3TimerCreateDevice(pVM, pDevIns, enmClock, pfnCallback, pvUser, fFlags, pszDesc, ppTimer);
578
579	LogFlow(("pdmR3DevHlp_TMTimerCreate: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
580	return rc;
581	}
582
583
584	/** @interface_method_impl{PDMDEVHLPR3,pfnTMUtcNow} */
585	static DECLCALLBACK(PRTTIMESPEC) pdmR3DevHlp_TMUtcNow(PPDMDEVINS pDevIns, PRTTIMESPEC pTime)
586	{
587	PDMDEV_ASSERT_DEVINS(pDevIns);
588	LogFlow(("pdmR3DevHlp_TMUtcNow: caller='%s'/%d: pTime=%p\n",
589	pDevIns->pReg->szName, pDevIns->iInstance, pTime));
590
591	pTime = TMR3UtcNow(pDevIns->Internal.s.pVMR3, pTime);
592
593	LogFlow(("pdmR3DevHlp_TMUtcNow: caller='%s'/%d: returns %RU64\n", pDevIns->pReg->szName, pDevIns->iInstance, RTTimeSpecGetNano(pTime)));
594	return pTime;
595	}
596
597
598	/** @interface_method_impl{PDMDEVHLPR3,pfnPhysRead} */
599	static DECLCALLBACK(int) pdmR3DevHlp_PhysRead(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, void *pvBuf, size_t cbRead)
600	{
601	PDMDEV_ASSERT_DEVINS(pDevIns);
602	PVM pVM = pDevIns->Internal.s.pVMR3;
603	LogFlow(("pdmR3DevHlp_PhysRead: caller='%s'/%d: GCPhys=%RGp pvBuf=%p cbRead=%#x\n",
604	pDevIns->pReg->szName, pDevIns->iInstance, GCPhys, pvBuf, cbRead));
605
606	#if defined(VBOX_STRICT) && defined(PDM_DEVHLP_DEADLOCK_DETECTION)
607	if (!VM_IS_EMT(pVM))
608	{
609	char szNames[128];
610	uint32_t cLocks = PDMR3CritSectCountOwned(pVM, szNames, sizeof(szNames));
611	AssertMsg(cLocks == 0, ("cLocks=%u %s\n", cLocks, szNames));
612	}
613	#endif
614
615	int rc;
616	if (VM_IS_EMT(pVM))
617	rc = PGMPhysRead(pVM, GCPhys, pvBuf, cbRead);
618	else
619	rc = PGMR3PhysReadExternal(pVM, GCPhys, pvBuf, cbRead);
620
621	Log(("pdmR3DevHlp_PhysRead: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
622	return rc;
623	}
624
625
626	/** @interface_method_impl{PDMDEVHLPR3,pfnPhysWrite} */
627	static DECLCALLBACK(int) pdmR3DevHlp_PhysWrite(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, const void *pvBuf, size_t cbWrite)
628	{
629	PDMDEV_ASSERT_DEVINS(pDevIns);
630	PVM pVM = pDevIns->Internal.s.pVMR3;
631	LogFlow(("pdmR3DevHlp_PhysWrite: caller='%s'/%d: GCPhys=%RGp pvBuf=%p cbWrite=%#x\n",
632	pDevIns->pReg->szName, pDevIns->iInstance, GCPhys, pvBuf, cbWrite));
633
634	#if defined(VBOX_STRICT) && defined(PDM_DEVHLP_DEADLOCK_DETECTION)
635	if (!VM_IS_EMT(pVM))
636	{
637	char szNames[128];
638	uint32_t cLocks = PDMR3CritSectCountOwned(pVM, szNames, sizeof(szNames));
639	AssertMsg(cLocks == 0, ("cLocks=%u %s\n", cLocks, szNames));
640	}
641	#endif
642
643	int rc;
644	if (VM_IS_EMT(pVM))
645	rc = PGMPhysWrite(pVM, GCPhys, pvBuf, cbWrite);
646	else
647	rc = PGMR3PhysWriteExternal(pVM, GCPhys, pvBuf, cbWrite, pDevIns->pReg->szName);
648
649	Log(("pdmR3DevHlp_PhysWrite: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
650	return rc;
651	}
652
653
654	/** @interface_method_impl{PDMDEVHLPR3,pfnPhysGCPhys2CCPtr} */
655	static DECLCALLBACK(int) pdmR3DevHlp_PhysGCPhys2CCPtr(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, uint32_t fFlags, void **ppv, PPGMPAGEMAPLOCK pLock)
656	{
657	PDMDEV_ASSERT_DEVINS(pDevIns);
658	PVM pVM = pDevIns->Internal.s.pVMR3;
659	LogFlow(("pdmR3DevHlp_PhysGCPhys2CCPtr: caller='%s'/%d: GCPhys=%RGp fFlags=%#x ppv=%p pLock=%p\n",
660	pDevIns->pReg->szName, pDevIns->iInstance, GCPhys, fFlags, ppv, pLock));
661	AssertReturn(!fFlags, VERR_INVALID_PARAMETER);
662
663	#if defined(VBOX_STRICT) && defined(PDM_DEVHLP_DEADLOCK_DETECTION)
664	if (!VM_IS_EMT(pVM))
665	{
666	char szNames[128];
667	uint32_t cLocks = PDMR3CritSectCountOwned(pVM, szNames, sizeof(szNames));
668	AssertMsg(cLocks == 0, ("cLocks=%u %s\n", cLocks, szNames));
669	}
670	#endif
671
672	int rc = PGMR3PhysGCPhys2CCPtrExternal(pVM, GCPhys, ppv, pLock);
673
674	Log(("pdmR3DevHlp_PhysGCPhys2CCPtr: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
675	return rc;
676	}
677
678
679	/** @interface_method_impl{PDMDEVHLPR3,pfnPhysGCPhys2CCPtrReadOnly} */
680	static DECLCALLBACK(int) pdmR3DevHlp_PhysGCPhys2CCPtrReadOnly(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, uint32_t fFlags, const void **ppv, PPGMPAGEMAPLOCK pLock)
681	{
682	PDMDEV_ASSERT_DEVINS(pDevIns);
683	PVM pVM = pDevIns->Internal.s.pVMR3;
684	LogFlow(("pdmR3DevHlp_PhysGCPhys2CCPtrReadOnly: caller='%s'/%d: GCPhys=%RGp fFlags=%#x ppv=%p pLock=%p\n",
685	pDevIns->pReg->szName, pDevIns->iInstance, GCPhys, fFlags, ppv, pLock));
686	AssertReturn(!fFlags, VERR_INVALID_PARAMETER);
687
688	#if defined(VBOX_STRICT) && defined(PDM_DEVHLP_DEADLOCK_DETECTION)
689	if (!VM_IS_EMT(pVM))
690	{
691	char szNames[128];
692	uint32_t cLocks = PDMR3CritSectCountOwned(pVM, szNames, sizeof(szNames));
693	AssertMsg(cLocks == 0, ("cLocks=%u %s\n", cLocks, szNames));
694	}
695	#endif
696
697	int rc = PGMR3PhysGCPhys2CCPtrReadOnlyExternal(pVM, GCPhys, ppv, pLock);
698
699	Log(("pdmR3DevHlp_PhysGCPhys2CCPtrReadOnly: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
700	return rc;
701	}
702
703
704	/** @interface_method_impl{PDMDEVHLPR3,pfnPhysReleasePageMappingLock} */
705	static DECLCALLBACK(void) pdmR3DevHlp_PhysReleasePageMappingLock(PPDMDEVINS pDevIns, PPGMPAGEMAPLOCK pLock)
706	{
707	PDMDEV_ASSERT_DEVINS(pDevIns);
708	PVM pVM = pDevIns->Internal.s.pVMR3;
709	LogFlow(("pdmR3DevHlp_PhysReleasePageMappingLock: caller='%s'/%d: pLock=%p\n",
710	pDevIns->pReg->szName, pDevIns->iInstance, pLock));
711
712	PGMPhysReleasePageMappingLock(pVM, pLock);
713
714	Log(("pdmR3DevHlp_PhysReleasePageMappingLock: caller='%s'/%d: returns void\n", pDevIns->pReg->szName, pDevIns->iInstance));
715	}
716
717
718	/** @interface_method_impl{PDMDEVHLPR3,pfnPhysReadGCVirt} */
719	static DECLCALLBACK(int) pdmR3DevHlp_PhysReadGCVirt(PPDMDEVINS pDevIns, void *pvDst, RTGCPTR GCVirtSrc, size_t cb)
720	{
721	PDMDEV_ASSERT_DEVINS(pDevIns);
722	PVM pVM = pDevIns->Internal.s.pVMR3;
723	VM_ASSERT_EMT(pVM);
724	LogFlow(("pdmR3DevHlp_PhysReadGCVirt: caller='%s'/%d: pvDst=%p GCVirt=%RGv cb=%#x\n",
725	pDevIns->pReg->szName, pDevIns->iInstance, pvDst, GCVirtSrc, cb));
726
727	PVMCPU pVCpu = VMMGetCpu(pVM);
728	if (!pVCpu)
729	return VERR_ACCESS_DENIED;
730	#if defined(VBOX_STRICT) && defined(PDM_DEVHLP_DEADLOCK_DETECTION)
731	/** @todo SMP. */
732	#endif
733
734	int rc = PGMPhysSimpleReadGCPtr(pVCpu, pvDst, GCVirtSrc, cb);
735
736	LogFlow(("pdmR3DevHlp_PhysReadGCVirt: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
737
738	return rc;
739	}
740
741
742	/** @interface_method_impl{PDMDEVHLPR3,pfnPhysWriteGCVirt} */
743	static DECLCALLBACK(int) pdmR3DevHlp_PhysWriteGCVirt(PPDMDEVINS pDevIns, RTGCPTR GCVirtDst, const void *pvSrc, size_t cb)
744	{
745	PDMDEV_ASSERT_DEVINS(pDevIns);
746	PVM pVM = pDevIns->Internal.s.pVMR3;
747	VM_ASSERT_EMT(pVM);
748	LogFlow(("pdmR3DevHlp_PhysWriteGCVirt: caller='%s'/%d: GCVirtDst=%RGv pvSrc=%p cb=%#x\n",
749	pDevIns->pReg->szName, pDevIns->iInstance, GCVirtDst, pvSrc, cb));
750
751	PVMCPU pVCpu = VMMGetCpu(pVM);
752	if (!pVCpu)
753	return VERR_ACCESS_DENIED;
754	#if defined(VBOX_STRICT) && defined(PDM_DEVHLP_DEADLOCK_DETECTION)
755	/** @todo SMP. */
756	#endif
757
758	int rc = PGMPhysSimpleWriteGCPtr(pVCpu, GCVirtDst, pvSrc, cb);
759
760	LogFlow(("pdmR3DevHlp_PhysWriteGCVirt: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
761
762	return rc;
763	}
764
765
766	/** @interface_method_impl{PDMDEVHLPR3,pfnPhysGCPtr2GCPhys} */
767	static DECLCALLBACK(int) pdmR3DevHlp_PhysGCPtr2GCPhys(PPDMDEVINS pDevIns, RTGCPTR GCPtr, PRTGCPHYS pGCPhys)
768	{
769	PDMDEV_ASSERT_DEVINS(pDevIns);
770	PVM pVM = pDevIns->Internal.s.pVMR3;
771	VM_ASSERT_EMT(pVM);
772	LogFlow(("pdmR3DevHlp_PhysGCPtr2GCPhys: caller='%s'/%d: GCPtr=%RGv pGCPhys=%p\n",
773	pDevIns->pReg->szName, pDevIns->iInstance, GCPtr, pGCPhys));
774
775	PVMCPU pVCpu = VMMGetCpu(pVM);
776	if (!pVCpu)
777	return VERR_ACCESS_DENIED;
778	#if defined(VBOX_STRICT) && defined(PDM_DEVHLP_DEADLOCK_DETECTION)
779	/** @todo SMP. */
780	#endif
781
782	int rc = PGMPhysGCPtr2GCPhys(pVCpu, GCPtr, pGCPhys);
783
784	LogFlow(("pdmR3DevHlp_PhysGCPtr2GCPhys: caller='%s'/%d: returns %Rrc pGCPhys=%RGp\n", pDevIns->pReg->szName, pDevIns->iInstance, rc, pGCPhys));
785
786	return rc;
787	}
788
789
790	/** @interface_method_impl{PDMDEVHLPR3,pfnMMHeapAlloc} */
791	static DECLCALLBACK(void *) pdmR3DevHlp_MMHeapAlloc(PPDMDEVINS pDevIns, size_t cb)
792	{
793	PDMDEV_ASSERT_DEVINS(pDevIns);
794	LogFlow(("pdmR3DevHlp_MMHeapAlloc: caller='%s'/%d: cb=%#x\n", pDevIns->pReg->szName, pDevIns->iInstance, cb));
795
796	void *pv = MMR3HeapAlloc(pDevIns->Internal.s.pVMR3, MM_TAG_PDM_DEVICE_USER, cb);
797
798	LogFlow(("pdmR3DevHlp_MMHeapAlloc: caller='%s'/%d: returns %p\n", pDevIns->pReg->szName, pDevIns->iInstance, pv));
799	return pv;
800	}
801
802
803	/** @interface_method_impl{PDMDEVHLPR3,pfnMMHeapAllocZ} */
804	static DECLCALLBACK(void *) pdmR3DevHlp_MMHeapAllocZ(PPDMDEVINS pDevIns, size_t cb)
805	{
806	PDMDEV_ASSERT_DEVINS(pDevIns);
807	LogFlow(("pdmR3DevHlp_MMHeapAllocZ: caller='%s'/%d: cb=%#x\n", pDevIns->pReg->szName, pDevIns->iInstance, cb));
808
809	void *pv = MMR3HeapAllocZ(pDevIns->Internal.s.pVMR3, MM_TAG_PDM_DEVICE_USER, cb);
810
811	LogFlow(("pdmR3DevHlp_MMHeapAllocZ: caller='%s'/%d: returns %p\n", pDevIns->pReg->szName, pDevIns->iInstance, pv));
812	return pv;
813	}
814
815
816	/** @interface_method_impl{PDMDEVHLPR3,pfnMMHeapFree} */
817	static DECLCALLBACK(void) pdmR3DevHlp_MMHeapFree(PPDMDEVINS pDevIns, void *pv)
818	{
819	PDMDEV_ASSERT_DEVINS(pDevIns);
820	LogFlow(("pdmR3DevHlp_MMHeapFree: caller='%s'/%d: pv=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, pv));
821
822	MMR3HeapFree(pv);
823
824	LogFlow(("pdmR3DevHlp_MMHeapAlloc: caller='%s'/%d: returns void\n", pDevIns->pReg->szName, pDevIns->iInstance));
825	}
826
827
828	/** @interface_method_impl{PDMDEVHLPR3,pfnVMState} */
829	static DECLCALLBACK(VMSTATE) pdmR3DevHlp_VMState(PPDMDEVINS pDevIns)
830	{
831	PDMDEV_ASSERT_DEVINS(pDevIns);
832
833	VMSTATE enmVMState = VMR3GetState(pDevIns->Internal.s.pVMR3);
834
835	LogFlow(("pdmR3DevHlp_VMState: caller='%s'/%d: returns %d (%s)\n", pDevIns->pReg->szName, pDevIns->iInstance,
836	enmVMState, VMR3GetStateName(enmVMState)));
837	return enmVMState;
838	}
839
840
841	/** @interface_method_impl{PDMDEVHLPR3,pfnVMTeleportedAndNotFullyResumedYet} */
842	static DECLCALLBACK(bool) pdmR3DevHlp_VMTeleportedAndNotFullyResumedYet(PPDMDEVINS pDevIns)
843	{
844	PDMDEV_ASSERT_DEVINS(pDevIns);
845
846	bool fRc = VMR3TeleportedAndNotFullyResumedYet(pDevIns->Internal.s.pVMR3);
847
848	LogFlow(("pdmR3DevHlp_VMState: caller='%s'/%d: returns %RTbool\n", pDevIns->pReg->szName, pDevIns->iInstance,
849	fRc));
850	return fRc;
851	}
852
853
854	/** @interface_method_impl{PDMDEVHLPR3,pfnVMSetError} */
855	static DECLCALLBACK(int) pdmR3DevHlp_VMSetError(PPDMDEVINS pDevIns, int rc, RT_SRC_POS_DECL, const char *pszFormat, ...)
856	{
857	PDMDEV_ASSERT_DEVINS(pDevIns);
858	va_list args;
859	va_start(args, pszFormat);
860	int rc2 = VMSetErrorV(pDevIns->Internal.s.pVMR3, rc, RT_SRC_POS_ARGS, pszFormat, args); Assert(rc2 == rc); NOREF(rc2);
861	va_end(args);
862	return rc;
863	}
864
865
866	/** @interface_method_impl{PDMDEVHLPR3,pfnVMSetErrorV} */
867	static DECLCALLBACK(int) pdmR3DevHlp_VMSetErrorV(PPDMDEVINS pDevIns, int rc, RT_SRC_POS_DECL, const char *pszFormat, va_list va)
868	{
869	PDMDEV_ASSERT_DEVINS(pDevIns);
870	int rc2 = VMSetErrorV(pDevIns->Internal.s.pVMR3, rc, RT_SRC_POS_ARGS, pszFormat, va); Assert(rc2 == rc); NOREF(rc2);
871	return rc;
872	}
873
874
875	/** @interface_method_impl{PDMDEVHLPR3,pfnVMSetRuntimeError} */
876	static DECLCALLBACK(int) pdmR3DevHlp_VMSetRuntimeError(PPDMDEVINS pDevIns, uint32_t fFlags, const char pszErrorId, const char pszFormat, ...)
877	{
878	PDMDEV_ASSERT_DEVINS(pDevIns);
879	va_list args;
880	va_start(args, pszFormat);
881	int rc = VMSetRuntimeErrorV(pDevIns->Internal.s.pVMR3, fFlags, pszErrorId, pszFormat, args);
882	va_end(args);
883	return rc;
884	}
885
886
887	/** @interface_method_impl{PDMDEVHLPR3,pfnVMSetRuntimeErrorV} */
888	static DECLCALLBACK(int) pdmR3DevHlp_VMSetRuntimeErrorV(PPDMDEVINS pDevIns, uint32_t fFlags, const char pszErrorId, const char pszFormat, va_list va)
889	{
890	PDMDEV_ASSERT_DEVINS(pDevIns);
891	int rc = VMSetRuntimeErrorV(pDevIns->Internal.s.pVMR3, fFlags, pszErrorId, pszFormat, va);
892	return rc;
893	}
894
895
896	/** @interface_method_impl{PDMDEVHLPR3,pfnDBGFStopV} */
897	static DECLCALLBACK(int) pdmR3DevHlp_DBGFStopV(PPDMDEVINS pDevIns, const char pszFile, unsigned iLine, const char pszFunction, const char *pszFormat, va_list args)
898	{
899	PDMDEV_ASSERT_DEVINS(pDevIns);
900	#ifdef LOG_ENABLED
901	va_list va2;
902	va_copy(va2, args);
903	LogFlow(("pdmR3DevHlp_DBGFStopV: caller='%s'/%d: pszFile=%p:{%s} iLine=%d pszFunction=%p:{%s} pszFormat=%p:{%s} (%N)\n",
904	pDevIns->pReg->szName, pDevIns->iInstance, pszFile, pszFile, iLine, pszFunction, pszFunction, pszFormat, pszFormat, pszFormat, &va2));
905	va_end(va2);
906	#endif
907
908	PVM pVM = pDevIns->Internal.s.pVMR3;
909	VM_ASSERT_EMT(pVM);
910	int rc = DBGFR3EventSrcV(pVM, DBGFEVENT_DEV_STOP, pszFile, iLine, pszFunction, pszFormat, args);
911	if (rc == VERR_DBGF_NOT_ATTACHED)
912	rc = VINF_SUCCESS;
913
914	LogFlow(("pdmR3DevHlp_DBGFStopV: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
915	return rc;
916	}
917
918
919	/** @interface_method_impl{PDMDEVHLPR3,pfnDBGFInfoRegister} */
920	static DECLCALLBACK(int) pdmR3DevHlp_DBGFInfoRegister(PPDMDEVINS pDevIns, const char pszName, const char pszDesc, PFNDBGFHANDLERDEV pfnHandler)
921	{
922	PDMDEV_ASSERT_DEVINS(pDevIns);
923	LogFlow(("pdmR3DevHlp_DBGFInfoRegister: caller='%s'/%d: pszName=%p:{%s} pszDesc=%p:{%s} pfnHandler=%p\n",
924	pDevIns->pReg->szName, pDevIns->iInstance, pszName, pszName, pszDesc, pszDesc, pfnHandler));
925
926	PVM pVM = pDevIns->Internal.s.pVMR3;
927	VM_ASSERT_EMT(pVM);
928	int rc = DBGFR3InfoRegisterDevice(pVM, pszName, pszDesc, pfnHandler, pDevIns);
929
930	LogFlow(("pdmR3DevHlp_DBGFInfoRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
931	return rc;
932	}
933
934
935	/** @interface_method_impl{PDMDEVHLPR3,pfnSTAMRegister} */
936	static DECLCALLBACK(void) pdmR3DevHlp_STAMRegister(PPDMDEVINS pDevIns, void pvSample, STAMTYPE enmType, const char pszName, STAMUNIT enmUnit, const char *pszDesc)
937	{
938	PDMDEV_ASSERT_DEVINS(pDevIns);
939	PVM pVM = pDevIns->Internal.s.pVMR3;
940	VM_ASSERT_EMT(pVM);
941
942	STAM_REG(pVM, pvSample, enmType, pszName, enmUnit, pszDesc);
943	NOREF(pVM);
944	}
945
946
947
948	/** @interface_method_impl{PDMDEVHLPR3,pfnSTAMRegisterF} */
949	static DECLCALLBACK(void) pdmR3DevHlp_STAMRegisterF(PPDMDEVINS pDevIns, void *pvSample, STAMTYPE enmType, STAMVISIBILITY enmVisibility,
950	STAMUNIT enmUnit, const char pszDesc, const char pszName, ...)
951	{
952	PDMDEV_ASSERT_DEVINS(pDevIns);
953	PVM pVM = pDevIns->Internal.s.pVMR3;
954	VM_ASSERT_EMT(pVM);
955
956	va_list args;
957	va_start(args, pszName);
958	int rc = STAMR3RegisterV(pVM, pvSample, enmType, enmVisibility, enmUnit, pszDesc, pszName, args);
959	va_end(args);
960	AssertRC(rc);
961
962	NOREF(pVM);
963	}
964
965
966	/** @interface_method_impl{PDMDEVHLPR3,pfnSTAMRegisterV} */
967	static DECLCALLBACK(void) pdmR3DevHlp_STAMRegisterV(PPDMDEVINS pDevIns, void *pvSample, STAMTYPE enmType, STAMVISIBILITY enmVisibility,
968	STAMUNIT enmUnit, const char pszDesc, const char pszName, va_list args)
969	{
970	PDMDEV_ASSERT_DEVINS(pDevIns);
971	PVM pVM = pDevIns->Internal.s.pVMR3;
972	VM_ASSERT_EMT(pVM);
973
974	int rc = STAMR3RegisterV(pVM, pvSample, enmType, enmVisibility, enmUnit, pszDesc, pszName, args);
975	AssertRC(rc);
976
977	NOREF(pVM);
978	}
979
980
981	/** @interface_method_impl{PDMDEVHLPR3,pfnPCIRegister} */
982	static DECLCALLBACK(int) pdmR3DevHlp_PCIRegister(PPDMDEVINS pDevIns, PPCIDEVICE pPciDev)
983	{
984	PDMDEV_ASSERT_DEVINS(pDevIns);
985	PVM pVM = pDevIns->Internal.s.pVMR3;
986	VM_ASSERT_EMT(pVM);
987	LogFlow(("pdmR3DevHlp_PCIRegister: caller='%s'/%d: pPciDev=%p:{.config={%#.256Rhxs}\n",
988	pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pPciDev->config));
989
990	/*
991	* Validate input.
992	*/
993	if (!pPciDev)
994	{
995	Assert(pPciDev);
996	LogFlow(("pdmR3DevHlp_PCIRegister: caller='%s'/%d: returns %Rrc (pPciDev)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
997	return VERR_INVALID_PARAMETER;
998	}
999	if (!pPciDev->config[0] && !pPciDev->config[1])
1000	{
1001	Assert(pPciDev->config[0] \|\| pPciDev->config[1]);
1002	LogFlow(("pdmR3DevHlp_PCIRegister: caller='%s'/%d: returns %Rrc (vendor)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
1003	return VERR_INVALID_PARAMETER;
1004	}
1005	if (pDevIns->Internal.s.pPciDeviceR3)
1006	{
1007	/** @todo the PCI device vs. PDM device designed is a bit flawed if we have to
1008	* support a PDM device with multiple PCI devices. This might become a problem
1009	* when upgrading the chipset for instance because of multiple functions in some
1010	* devices...
1011	*/
1012	AssertMsgFailed(("Only one PCI device per device is currently implemented!\n"));
1013	return VERR_INTERNAL_ERROR;
1014	}
1015
1016	/*
1017	* Choose the PCI bus for the device.
1018	*
1019	* This is simple. If the device was configured for a particular bus, the PCIBusNo
1020	* configuration value will be set. If not the default bus is 0.
1021	*/
1022	int rc;
1023	PPDMPCIBUS pBus = pDevIns->Internal.s.pPciBusR3;
1024	if (!pBus)
1025	{
1026	uint8_t u8Bus;
1027	rc = CFGMR3QueryU8Def(pDevIns->Internal.s.pCfgHandle, "PCIBusNo", &u8Bus, 0);
1028	AssertLogRelMsgRCReturn(rc, ("Configuration error: PCIBusNo query failed with rc=%Rrc (%s/%d)\n",
1029	rc, pDevIns->pReg->szName, pDevIns->iInstance), rc);
1030	AssertLogRelMsgReturn(u8Bus < RT_ELEMENTS(pVM->pdm.s.aPciBuses),
1031	("Configuration error: PCIBusNo=%d, max is %d. (%s/%d)\n", u8Bus,
1032	RT_ELEMENTS(pVM->pdm.s.aPciBuses), pDevIns->pReg->szName, pDevIns->iInstance),
1033	VERR_PDM_NO_PCI_BUS);
1034	pBus = pDevIns->Internal.s.pPciBusR3 = &pVM->pdm.s.aPciBuses[u8Bus];
1035	}
1036	if (pBus->pDevInsR3)
1037	{
1038	if (pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_RC)
1039	pDevIns->Internal.s.pPciBusR0 = MMHyperR3ToR0(pVM, pDevIns->Internal.s.pPciBusR3);
1040	else
1041	pDevIns->Internal.s.pPciBusR0 = NIL_RTR0PTR;
1042
1043	if (pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_RC)
1044	pDevIns->Internal.s.pPciBusRC = MMHyperR3ToRC(pVM, pDevIns->Internal.s.pPciBusR3);
1045	else
1046	pDevIns->Internal.s.pPciBusRC = NIL_RTRCPTR;
1047
1048	/*
1049	* Check the configuration for PCI device and function assignment.
1050	*/
1051	int iDev = -1;
1052	uint8_t u8Device;
1053	rc = CFGMR3QueryU8(pDevIns->Internal.s.pCfgHandle, "PCIDeviceNo", &u8Device);
1054	if (RT_SUCCESS(rc))
1055	{
1056	if (u8Device > 31)
1057	{
1058	AssertMsgFailed(("Configuration error: PCIDeviceNo=%d, max is 31. (%s/%d)\n",
1059	u8Device, pDevIns->pReg->szName, pDevIns->iInstance));
1060	return VERR_INTERNAL_ERROR;
1061	}
1062
1063	uint8_t u8Function;
1064	rc = CFGMR3QueryU8(pDevIns->Internal.s.pCfgHandle, "PCIFunctionNo", &u8Function);
1065	if (RT_FAILURE(rc))
1066	{
1067	AssertMsgFailed(("Configuration error: PCIDeviceNo, but PCIFunctionNo query failed with rc=%Rrc (%s/%d)\n",
1068	rc, pDevIns->pReg->szName, pDevIns->iInstance));
1069	return rc;
1070	}
1071	if (u8Function > 7)
1072	{
1073	AssertMsgFailed(("Configuration error: PCIFunctionNo=%d, max is 7. (%s/%d)\n",
1074	u8Function, pDevIns->pReg->szName, pDevIns->iInstance));
1075	return VERR_INTERNAL_ERROR;
1076	}
1077	iDev = (u8Device << 3) \| u8Function;
1078	}
1079	else if (rc != VERR_CFGM_VALUE_NOT_FOUND)
1080	{
1081	AssertMsgFailed(("Configuration error: PCIDeviceNo query failed with rc=%Rrc (%s/%d)\n",
1082	rc, pDevIns->pReg->szName, pDevIns->iInstance));
1083	return rc;
1084	}
1085
1086	/*
1087	* Call the pci bus device to do the actual registration.
1088	*/
1089	pdmLock(pVM);
1090	rc = pBus->pfnRegisterR3(pBus->pDevInsR3, pPciDev, pDevIns->pReg->szName, iDev);
1091	pdmUnlock(pVM);
1092	if (RT_SUCCESS(rc))
1093	{
1094	pPciDev->pDevIns = pDevIns;
1095
1096	pDevIns->Internal.s.pPciDeviceR3 = pPciDev;
1097	if (pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_R0)
1098	pDevIns->Internal.s.pPciDeviceR0 = MMHyperR3ToR0(pVM, pPciDev);
1099	else
1100	pDevIns->Internal.s.pPciDeviceR0 = NIL_RTR0PTR;
1101
1102	if (pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_RC)
1103	pDevIns->Internal.s.pPciDeviceRC = MMHyperR3ToRC(pVM, pPciDev);
1104	else
1105	pDevIns->Internal.s.pPciDeviceRC = NIL_RTRCPTR;
1106
1107	Log(("PDM: Registered device '%s'/%d as PCI device %d on bus %d\n",
1108	pDevIns->pReg->szName, pDevIns->iInstance, pPciDev->devfn, pDevIns->Internal.s.pPciBusR3->iBus));
1109	}
1110	}
1111	else
1112	{
1113	AssertLogRelMsgFailed(("Configuration error: No PCI bus available. This could be related to init order too!\n"));
1114	rc = VERR_PDM_NO_PCI_BUS;
1115	}
1116
1117	LogFlow(("pdmR3DevHlp_PCIRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
1118	return rc;
1119	}
1120
1121
1122	/** @interface_method_impl{PDMDEVHLPR3,pfnPCIIORegionRegister} */
1123	static DECLCALLBACK(int) pdmR3DevHlp_PCIIORegionRegister(PPDMDEVINS pDevIns, int iRegion, uint32_t cbRegion, PCIADDRESSSPACE enmType, PFNPCIIOREGIONMAP pfnCallback)
1124	{
1125	PDMDEV_ASSERT_DEVINS(pDevIns);
1126	PVM pVM = pDevIns->Internal.s.pVMR3;
1127	VM_ASSERT_EMT(pVM);
1128	LogFlow(("pdmR3DevHlp_PCIIORegionRegister: caller='%s'/%d: iRegion=%d cbRegion=%#x enmType=%d pfnCallback=%p\n",
1129	pDevIns->pReg->szName, pDevIns->iInstance, iRegion, cbRegion, enmType, pfnCallback));
1130
1131	/*
1132	* Validate input.
1133	*/
1134	if (iRegion < 0 \|\| iRegion >= PCI_NUM_REGIONS)
1135	{
1136	Assert(iRegion >= 0 && iRegion < PCI_NUM_REGIONS);
1137	LogFlow(("pdmR3DevHlp_PCIIORegionRegister: caller='%s'/%d: returns %Rrc (iRegion)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
1138	return VERR_INVALID_PARAMETER;
1139	}
1140	switch (enmType)
1141	{
1142	case PCI_ADDRESS_SPACE_IO:
1143	/*
1144	* Sanity check: don't allow to register more than 32K of the PCI I/O space.
1145	*/
1146	AssertMsgReturn(cbRegion <= _32K,
1147	("caller='%s'/%d: %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, cbRegion),
1148	VERR_INVALID_PARAMETER);
1149	break;
1150
1151	case PCI_ADDRESS_SPACE_MEM:
1152	case PCI_ADDRESS_SPACE_MEM_PREFETCH:
1153	/*
1154	* Sanity check: don't allow to register more than 512MB of the PCI MMIO space for
1155	* now. If this limit is increased beyond 2GB, adapt the aligned check below as well!
1156	*/
1157	AssertMsgReturn(cbRegion <= 512 * _1M,
1158	("caller='%s'/%d: %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, cbRegion),
1159	VERR_INVALID_PARAMETER);
1160	break;
1161	default:
1162	AssertMsgFailed(("enmType=%#x is unknown\n", enmType));
1163	LogFlow(("pdmR3DevHlp_PCIIORegionRegister: caller='%s'/%d: returns %Rrc (enmType)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
1164	return VERR_INVALID_PARAMETER;
1165	}
1166	if (!pfnCallback)
1167	{
1168	Assert(pfnCallback);
1169	LogFlow(("pdmR3DevHlp_PCIIORegionRegister: caller='%s'/%d: returns %Rrc (callback)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
1170	return VERR_INVALID_PARAMETER;
1171	}
1172	AssertRelease(VMR3GetState(pVM) != VMSTATE_RUNNING);
1173
1174	/*
1175	* Must have a PCI device registered!
1176	*/
1177	int rc;
1178	PPCIDEVICE pPciDev = pDevIns->Internal.s.pPciDeviceR3;
1179	if (pPciDev)
1180	{
1181	/*
1182	* We're currently restricted to page aligned MMIO regions.
1183	*/
1184	if ( (enmType == PCI_ADDRESS_SPACE_MEM \|\| enmType == PCI_ADDRESS_SPACE_MEM_PREFETCH)
1185	&& cbRegion != RT_ALIGN_32(cbRegion, PAGE_SIZE))
1186	{
1187	Log(("pdmR3DevHlp_PCIIORegionRegister: caller='%s'/%d: aligning cbRegion %#x -> %#x\n",
1188	pDevIns->pReg->szName, pDevIns->iInstance, cbRegion, RT_ALIGN_32(cbRegion, PAGE_SIZE)));
1189	cbRegion = RT_ALIGN_32(cbRegion, PAGE_SIZE);
1190	}
1191
1192	/*
1193	* For registering PCI MMIO memory or PCI I/O memory, the size of the region must be a power of 2!
1194	*/
1195	int iLastSet = ASMBitLastSetU32(cbRegion);
1196	Assert(iLastSet > 0);
1197	uint32_t cbRegionAligned = RT_BIT_32(iLastSet - 1);
1198	if (cbRegion > cbRegionAligned)
1199	cbRegion = cbRegionAligned * 2; /* round up */
1200
1201	PPDMPCIBUS pBus = pDevIns->Internal.s.pPciBusR3;
1202	Assert(pBus);
1203	pdmLock(pVM);
1204	rc = pBus->pfnIORegionRegisterR3(pBus->pDevInsR3, pPciDev, iRegion, cbRegion, enmType, pfnCallback);
1205	pdmUnlock(pVM);
1206	}
1207	else
1208	{
1209	AssertMsgFailed(("No PCI device registered!\n"));
1210	rc = VERR_PDM_NOT_PCI_DEVICE;
1211	}
1212
1213	LogFlow(("pdmR3DevHlp_PCIIORegionRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
1214	return rc;
1215	}
1216
1217
1218	/** @interface_method_impl{PDMDEVHLPR3,pfnPCISetConfigCallbacks} */
1219	static DECLCALLBACK(void) pdmR3DevHlp_PCISetConfigCallbacks(PPDMDEVINS pDevIns, PPCIDEVICE pPciDev, PFNPCICONFIGREAD pfnRead, PPFNPCICONFIGREAD ppfnReadOld,
1220	PFNPCICONFIGWRITE pfnWrite, PPFNPCICONFIGWRITE ppfnWriteOld)
1221	{
1222	PDMDEV_ASSERT_DEVINS(pDevIns);
1223	PVM pVM = pDevIns->Internal.s.pVMR3;
1224	VM_ASSERT_EMT(pVM);
1225	LogFlow(("pdmR3DevHlp_PCISetConfigCallbacks: caller='%s'/%d: pPciDev=%p pfnRead=%p ppfnReadOld=%p pfnWrite=%p ppfnWriteOld=%p\n",
1226	pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pfnRead, ppfnReadOld, pfnWrite, ppfnWriteOld));
1227
1228	/*
1229	* Validate input and resolve defaults.
1230	*/
1231	AssertPtr(pfnRead);
1232	AssertPtr(pfnWrite);
1233	AssertPtrNull(ppfnReadOld);
1234	AssertPtrNull(ppfnWriteOld);
1235	AssertPtrNull(pPciDev);
1236
1237	if (!pPciDev)
1238	pPciDev = pDevIns->Internal.s.pPciDeviceR3;
1239	AssertReleaseMsg(pPciDev, ("You must register your device first!\n"));
1240	PPDMPCIBUS pBus = pDevIns->Internal.s.pPciBusR3;
1241	AssertRelease(pBus);
1242	AssertRelease(VMR3GetState(pVM) != VMSTATE_RUNNING);
1243
1244	/*
1245	* Do the job.
1246	*/
1247	pdmLock(pVM);
1248	pBus->pfnSetConfigCallbacksR3(pBus->pDevInsR3, pPciDev, pfnRead, ppfnReadOld, pfnWrite, ppfnWriteOld);
1249	pdmUnlock(pVM);
1250
1251	LogFlow(("pdmR3DevHlp_PCISetConfigCallbacks: caller='%s'/%d: returns void\n", pDevIns->pReg->szName, pDevIns->iInstance));
1252	}
1253
1254
1255	/** @interface_method_impl{PDMDEVHLPR3,pfnPCISetIrq} */
1256	static DECLCALLBACK(void) pdmR3DevHlp_PCISetIrq(PPDMDEVINS pDevIns, int iIrq, int iLevel)
1257	{
1258	PDMDEV_ASSERT_DEVINS(pDevIns);
1259	LogFlow(("pdmR3DevHlp_PCISetIrq: caller='%s'/%d: iIrq=%d iLevel=%d\n", pDevIns->pReg->szName, pDevIns->iInstance, iIrq, iLevel));
1260
1261	/*
1262	* Validate input.
1263	*/
1264	/** @todo iIrq and iLevel checks. */
1265
1266	/*
1267	* Must have a PCI device registered!
1268	*/
1269	PPCIDEVICE pPciDev = pDevIns->Internal.s.pPciDeviceR3;
1270	if (pPciDev)
1271	{
1272	PPDMPCIBUS pBus = pDevIns->Internal.s.pPciBusR3; /** @todo the bus should be associated with the PCI device not the PDM device. */
1273	Assert(pBus);
1274	PVM pVM = pDevIns->Internal.s.pVMR3;
1275	pdmLock(pVM);
1276	pBus->pfnSetIrqR3(pBus->pDevInsR3, pPciDev, iIrq, iLevel);
1277	pdmUnlock(pVM);
1278	}
1279	else
1280	AssertReleaseMsgFailed(("No PCI device registered!\n"));
1281
1282	LogFlow(("pdmR3DevHlp_PCISetIrq: caller='%s'/%d: returns void\n", pDevIns->pReg->szName, pDevIns->iInstance));
1283	}
1284
1285
1286	/** @interface_method_impl{PDMDEVHLPR3,pfnPCISetIrqNoWait} */
1287	static DECLCALLBACK(void) pdmR3DevHlp_PCISetIrqNoWait(PPDMDEVINS pDevIns, int iIrq, int iLevel)
1288	{
1289	pdmR3DevHlp_PCISetIrq(pDevIns, iIrq, iLevel);
1290	}
1291
1292
1293	/** @interface_method_impl{PDMDEVHLPR3,pfnISASetIrq} */
1294	static DECLCALLBACK(void) pdmR3DevHlp_ISASetIrq(PPDMDEVINS pDevIns, int iIrq, int iLevel)
1295	{
1296	PDMDEV_ASSERT_DEVINS(pDevIns);
1297	LogFlow(("pdmR3DevHlp_ISASetIrq: caller='%s'/%d: iIrq=%d iLevel=%d\n", pDevIns->pReg->szName, pDevIns->iInstance, iIrq, iLevel));
1298
1299	/*
1300	* Validate input.
1301	*/
1302	/** @todo iIrq and iLevel checks. */
1303
1304	PVM pVM = pDevIns->Internal.s.pVMR3;
1305	PDMIsaSetIrq(pVM, iIrq, iLevel); /* (The API takes the lock.) */
1306
1307	LogFlow(("pdmR3DevHlp_ISASetIrq: caller='%s'/%d: returns void\n", pDevIns->pReg->szName, pDevIns->iInstance));
1308	}
1309
1310
1311	/** @interface_method_impl{PDMDEVHLPR3,pfnISASetIrqNoWait} */
1312	static DECLCALLBACK(void) pdmR3DevHlp_ISASetIrqNoWait(PPDMDEVINS pDevIns, int iIrq, int iLevel)
1313	{
1314	pdmR3DevHlp_ISASetIrq(pDevIns, iIrq, iLevel);
1315	}
1316
1317
1318	/** @interface_method_impl{PDMDEVHLPR3,pfnDriverAttach} */
1319	static DECLCALLBACK(int) pdmR3DevHlp_DriverAttach(PPDMDEVINS pDevIns, RTUINT iLun, PPDMIBASE pBaseInterface, PPDMIBASE ppBaseInterface, const char pszDesc)
1320	{
1321	PDMDEV_ASSERT_DEVINS(pDevIns);
1322	PVM pVM = pDevIns->Internal.s.pVMR3;
1323	VM_ASSERT_EMT(pVM);
1324	LogFlow(("pdmR3DevHlp_DriverAttach: caller='%s'/%d: iLun=%d pBaseInterface=%p ppBaseInterface=%p pszDesc=%p:{%s}\n",
1325	pDevIns->pReg->szName, pDevIns->iInstance, iLun, pBaseInterface, ppBaseInterface, pszDesc, pszDesc));
1326
1327	/*
1328	* Lookup the LUN, it might already be registered.
1329	*/
1330	PPDMLUN pLunPrev = NULL;
1331	PPDMLUN pLun = pDevIns->Internal.s.pLunsR3;
1332	for (; pLun; pLunPrev = pLun, pLun = pLun->pNext)
1333	if (pLun->iLun == iLun)
1334	break;
1335
1336	/*
1337	* Create the LUN if if wasn't found, else check if driver is already attached to it.
1338	*/
1339	if (!pLun)
1340	{
1341	if ( !pBaseInterface
1342	\|\| !pszDesc
1343	\|\| !*pszDesc)
1344	{
1345	Assert(pBaseInterface);
1346	Assert(pszDesc \|\| *pszDesc);
1347	return VERR_INVALID_PARAMETER;
1348	}
1349
1350	pLun = (PPDMLUN)MMR3HeapAlloc(pVM, MM_TAG_PDM_LUN, sizeof(*pLun));
1351	if (!pLun)
1352	return VERR_NO_MEMORY;
1353
1354	pLun->iLun = iLun;
1355	pLun->pNext = pLunPrev ? pLunPrev->pNext : NULL;
1356	pLun->pTop = NULL;
1357	pLun->pBottom = NULL;
1358	pLun->pDevIns = pDevIns;
1359	pLun->pUsbIns = NULL;
1360	pLun->pszDesc = pszDesc;
1361	pLun->pBase = pBaseInterface;
1362	if (!pLunPrev)
1363	pDevIns->Internal.s.pLunsR3 = pLun;
1364	else
1365	pLunPrev->pNext = pLun;
1366	Log(("pdmR3DevHlp_DriverAttach: Registered LUN#%d '%s' with device '%s'/%d.\n",
1367	iLun, pszDesc, pDevIns->pReg->szName, pDevIns->iInstance));
1368	}
1369	else if (pLun->pTop)
1370	{
1371	AssertMsgFailed(("Already attached! The device should keep track of such things!\n"));
1372	LogFlow(("pdmR3DevHlp_DriverAttach: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_PDM_DRIVER_ALREADY_ATTACHED));
1373	return VERR_PDM_DRIVER_ALREADY_ATTACHED;
1374	}
1375	Assert(pLun->pBase == pBaseInterface);
1376
1377
1378	/*
1379	* Get the attached driver configuration.
1380	*/
1381	int rc;
1382	PCFGMNODE pNode = CFGMR3GetChildF(pDevIns->Internal.s.pCfgHandle, "LUN#%u", iLun);
1383	if (pNode)
1384	rc = pdmR3DrvInstantiate(pVM, pNode, pBaseInterface, NULL /pDrvAbove/, pLun, ppBaseInterface);
1385	else
1386	rc = VERR_PDM_NO_ATTACHED_DRIVER;
1387
1388
1389	LogFlow(("pdmR3DevHlp_DriverAttach: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
1390	return rc;
1391	}
1392
1393
1394	/** @interface_method_impl{PDMDEVHLPR3,pfnQueueCreate} */
1395	static DECLCALLBACK(int) pdmR3DevHlp_QueueCreate(PPDMDEVINS pDevIns, RTUINT cbItem, RTUINT cItems, uint32_t cMilliesInterval,
1396	PFNPDMQUEUEDEV pfnCallback, bool fGCEnabled, const char pszName, PPDMQUEUE ppQueue)
1397	{
1398	PDMDEV_ASSERT_DEVINS(pDevIns);
1399	LogFlow(("pdmR3DevHlp_QueueCreate: caller='%s'/%d: cbItem=%#x cItems=%#x cMilliesInterval=%u pfnCallback=%p fGCEnabled=%RTbool pszName=%p:{%s} ppQueue=%p\n",
1400	pDevIns->pReg->szName, pDevIns->iInstance, cbItem, cItems, cMilliesInterval, pfnCallback, fGCEnabled, pszName, pszName, ppQueue));
1401
1402	PVM pVM = pDevIns->Internal.s.pVMR3;
1403	VM_ASSERT_EMT(pVM);
1404
1405	if (pDevIns->iInstance > 0)
1406	{
1407	pszName = MMR3HeapAPrintf(pVM, MM_TAG_PDM_DEVICE_DESC, "%s_%u", pszName, pDevIns->iInstance);
1408	AssertLogRelReturn(pszName, VERR_NO_MEMORY);
1409	}
1410
1411	int rc = PDMR3QueueCreateDevice(pVM, pDevIns, cbItem, cItems, cMilliesInterval, pfnCallback, fGCEnabled, pszName, ppQueue);
1412
1413	LogFlow(("pdmR3DevHlp_QueueCreate: caller='%s'/%d: returns %Rrc ppQueue=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, rc, ppQueue));
1414	return rc;
1415	}
1416
1417
1418	/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectInit} */
1419	static DECLCALLBACK(int) pdmR3DevHlp_CritSectInit(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect, RT_SRC_POS_DECL,
1420	const char *pszNameFmt, va_list va)
1421	{
1422	PDMDEV_ASSERT_DEVINS(pDevIns);
1423	LogFlow(("pdmR3DevHlp_CritSectInit: caller='%s'/%d: pCritSect=%p pszNameFmt=%p:{%s}\n",
1424	pDevIns->pReg->szName, pDevIns->iInstance, pCritSect, pszNameFmt, pszNameFmt));
1425
1426	PVM pVM = pDevIns->Internal.s.pVMR3;
1427	VM_ASSERT_EMT(pVM);
1428	int rc = pdmR3CritSectInitDevice(pVM, pDevIns, pCritSect, RT_SRC_POS_ARGS, pszNameFmt, va);
1429
1430	LogFlow(("pdmR3DevHlp_CritSectInit: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
1431	return rc;
1432	}
1433
1434
1435	/** @interface_method_impl{PDMDEVHLPR3,pfnThreadCreate} */
1436	static DECLCALLBACK(int) pdmR3DevHlp_ThreadCreate(PPDMDEVINS pDevIns, PPPDMTHREAD ppThread, void *pvUser, PFNPDMTHREADDEV pfnThread,
1437	PFNPDMTHREADWAKEUPDEV pfnWakeup, size_t cbStack, RTTHREADTYPE enmType, const char *pszName)
1438	{
1439	PDMDEV_ASSERT_DEVINS(pDevIns);
1440	VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
1441	LogFlow(("pdmR3DevHlp_ThreadCreate: caller='%s'/%d: ppThread=%p pvUser=%p pfnThread=%p pfnWakeup=%p cbStack=%#zx enmType=%d pszName=%p:{%s}\n",
1442	pDevIns->pReg->szName, pDevIns->iInstance, ppThread, pvUser, pfnThread, pfnWakeup, cbStack, enmType, pszName, pszName));
1443
1444	int rc = pdmR3ThreadCreateDevice(pDevIns->Internal.s.pVMR3, pDevIns, ppThread, pvUser, pfnThread, pfnWakeup, cbStack, enmType, pszName);
1445
1446	LogFlow(("pdmR3DevHlp_ThreadCreate: caller='%s'/%d: returns %Rrc *ppThread=%RTthrd\n", pDevIns->pReg->szName, pDevIns->iInstance,
1447	rc, *ppThread));
1448	return rc;
1449	}
1450
1451
1452	/** @interface_method_impl{PDMDEVHLPR3,pfnSetAsyncNotification} */
1453	static DECLCALLBACK(int) pdmR3DevHlp_SetAsyncNotification(PPDMDEVINS pDevIns, PFNPDMDEVASYNCNOTIFY pfnAsyncNotify)
1454	{
1455	PDMDEV_ASSERT_DEVINS(pDevIns);
1456	VM_ASSERT_EMT0(pDevIns->Internal.s.pVMR3);
1457	LogFlow(("pdmR3DevHlp_SetAsyncNotification: caller='%s'/%d: pfnAsyncNotify=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, pfnAsyncNotify));
1458
1459	int rc = VINF_SUCCESS;
1460	AssertStmt(pfnAsyncNotify, rc = VERR_INVALID_PARAMETER);
1461	AssertStmt(!pDevIns->Internal.s.pfnAsyncNotify, rc = VERR_WRONG_ORDER);
1462	AssertStmt(pDevIns->Internal.s.fIntFlags & (PDMDEVINSINT_FLAGS_SUSPENDED \| PDMDEVINSINT_FLAGS_RESET), rc = VERR_WRONG_ORDER);
1463	VMSTATE enmVMState = VMR3GetState(pDevIns->Internal.s.pVMR3);
1464	AssertStmt( enmVMState == VMSTATE_SUSPENDING
1465	\|\| enmVMState == VMSTATE_SUSPENDING_EXT_LS
1466	\|\| enmVMState == VMSTATE_SUSPENDING_LS
1467	\|\| enmVMState == VMSTATE_RESETTING
1468	\|\| enmVMState == VMSTATE_RESETTING_LS
1469	\|\| enmVMState == VMSTATE_POWERING_OFF
1470	\|\| enmVMState == VMSTATE_POWERING_OFF_LS,
1471	rc = VERR_INVALID_STATE);
1472
1473	if (RT_SUCCESS(rc))
1474	pDevIns->Internal.s.pfnAsyncNotify = pfnAsyncNotify;
1475
1476	LogFlow(("pdmR3DevHlp_SetAsyncNotification: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
1477	return rc;
1478	}
1479
1480
1481	/** @interface_method_impl{PDMDEVHLPR3,pfnAsyncNotificationCompleted} */
1482	static DECLCALLBACK(void) pdmR3DevHlp_AsyncNotificationCompleted(PPDMDEVINS pDevIns)
1483	{
1484	PDMDEV_ASSERT_DEVINS(pDevIns);
1485	PVM pVM = pDevIns->Internal.s.pVMR3;
1486
1487	VMSTATE enmVMState = VMR3GetState(pVM);
1488	if ( enmVMState == VMSTATE_SUSPENDING
1489	\|\| enmVMState == VMSTATE_SUSPENDING_EXT_LS
1490	\|\| enmVMState == VMSTATE_SUSPENDING_LS
1491	\|\| enmVMState == VMSTATE_RESETTING
1492	\|\| enmVMState == VMSTATE_RESETTING_LS
1493	\|\| enmVMState == VMSTATE_POWERING_OFF
1494	\|\| enmVMState == VMSTATE_POWERING_OFF_LS)
1495	{
1496	LogFlow(("pdmR3DevHlp_AsyncNotificationCompleted: caller='%s'/%d:\n", pDevIns->pReg->szName, pDevIns->iInstance));
1497	VMR3AsyncPdmNotificationWakeupU(pVM->pUVM);
1498	}
1499	else
1500	LogFlow(("pdmR3DevHlp_AsyncNotificationCompleted: caller='%s'/%d: enmVMState=%d\n", pDevIns->pReg->szName, pDevIns->iInstance, enmVMState));
1501	}
1502
1503
1504	/** @interface_method_impl{PDMDEVHLPR3,pfnRTCRegister} */
1505	static DECLCALLBACK(int) pdmR3DevHlp_RTCRegister(PPDMDEVINS pDevIns, PCPDMRTCREG pRtcReg, PCPDMRTCHLP *ppRtcHlp)
1506	{
1507	PDMDEV_ASSERT_DEVINS(pDevIns);
1508	VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
1509	LogFlow(("pdmR3DevHlp_RTCRegister: caller='%s'/%d: pRtcReg=%p:{.u32Version=%#x, .pfnWrite=%p, .pfnRead=%p} ppRtcHlp=%p\n",
1510	pDevIns->pReg->szName, pDevIns->iInstance, pRtcReg, pRtcReg->u32Version, pRtcReg->pfnWrite,
1511	pRtcReg->pfnWrite, ppRtcHlp));
1512
1513	/*
1514	* Validate input.
1515	*/
1516	if (pRtcReg->u32Version != PDM_RTCREG_VERSION)
1517	{
1518	AssertMsgFailed(("u32Version=%#x expected %#x\n", pRtcReg->u32Version,
1519	PDM_RTCREG_VERSION));
1520	LogFlow(("pdmR3DevHlp_RTCRegister: caller='%s'/%d: returns %Rrc (version)\n",
1521	pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
1522	return VERR_INVALID_PARAMETER;
1523	}
1524	if ( !pRtcReg->pfnWrite
1525	\|\| !pRtcReg->pfnRead)
1526	{
1527	Assert(pRtcReg->pfnWrite);
1528	Assert(pRtcReg->pfnRead);
1529	LogFlow(("pdmR3DevHlp_RTCRegister: caller='%s'/%d: returns %Rrc (callbacks)\n",
1530	pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
1531	return VERR_INVALID_PARAMETER;
1532	}
1533
1534	if (!ppRtcHlp)
1535	{
1536	Assert(ppRtcHlp);
1537	LogFlow(("pdmR3DevHlp_RTCRegister: caller='%s'/%d: returns %Rrc (ppRtcHlp)\n",
1538	pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
1539	return VERR_INVALID_PARAMETER;
1540	}
1541
1542	/*
1543	* Only one DMA device.
1544	*/
1545	PVM pVM = pDevIns->Internal.s.pVMR3;
1546	if (pVM->pdm.s.pRtc)
1547	{
1548	AssertMsgFailed(("Only one RTC device is supported!\n"));
1549	LogFlow(("pdmR3DevHlp_RTCRegister: caller='%s'/%d: returns %Rrc\n",
1550	pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
1551	return VERR_INVALID_PARAMETER;
1552	}
1553
1554	/*
1555	* Allocate and initialize pci bus structure.
1556	*/
1557	int rc = VINF_SUCCESS;
1558	PPDMRTC pRtc = (PPDMRTC)MMR3HeapAlloc(pDevIns->Internal.s.pVMR3, MM_TAG_PDM_DEVICE, sizeof(*pRtc));
1559	if (pRtc)
1560	{
1561	pRtc->pDevIns = pDevIns;
1562	pRtc->Reg = *pRtcReg;
1563	pVM->pdm.s.pRtc = pRtc;
1564
1565	/* set the helper pointer. */
1566	*ppRtcHlp = &g_pdmR3DevRtcHlp;
1567	Log(("PDM: Registered RTC device '%s'/%d pDevIns=%p\n",
1568	pDevIns->pReg->szName, pDevIns->iInstance, pDevIns));
1569	}
1570	else
1571	rc = VERR_NO_MEMORY;
1572
1573	LogFlow(("pdmR3DevHlp_RTCRegister: caller='%s'/%d: returns %Rrc\n",
1574	pDevIns->pReg->szName, pDevIns->iInstance, rc));
1575	return rc;
1576	}
1577
1578
1579	/** @interface_method_impl{PDMDEVHLPR3,pfnDMARegister} */
1580	static DECLCALLBACK(int) pdmR3DevHlp_DMARegister(PPDMDEVINS pDevIns, unsigned uChannel, PFNDMATRANSFERHANDLER pfnTransferHandler, void *pvUser)
1581	{
1582	PDMDEV_ASSERT_DEVINS(pDevIns);
1583	PVM pVM = pDevIns->Internal.s.pVMR3;
1584	VM_ASSERT_EMT(pVM);
1585	LogFlow(("pdmR3DevHlp_DMARegister: caller='%s'/%d: uChannel=%d pfnTransferHandler=%p pvUser=%p\n",
1586	pDevIns->pReg->szName, pDevIns->iInstance, uChannel, pfnTransferHandler, pvUser));
1587	int rc = VINF_SUCCESS;
1588	if (pVM->pdm.s.pDmac)
1589	pVM->pdm.s.pDmac->Reg.pfnRegister(pVM->pdm.s.pDmac->pDevIns, uChannel, pfnTransferHandler, pvUser);
1590	else
1591	{
1592	AssertMsgFailed(("Configuration error: No DMAC controller available. This could be related to init order too!\n"));
1593	rc = VERR_PDM_NO_DMAC_INSTANCE;
1594	}
1595	LogFlow(("pdmR3DevHlp_DMARegister: caller='%s'/%d: returns %Rrc\n",
1596	pDevIns->pReg->szName, pDevIns->iInstance, rc));
1597	return rc;
1598	}
1599
1600
1601	/** @interface_method_impl{PDMDEVHLPR3,pfnDMAReadMemory} */
1602	static DECLCALLBACK(int) pdmR3DevHlp_DMAReadMemory(PPDMDEVINS pDevIns, unsigned uChannel, void pvBuffer, uint32_t off, uint32_t cbBlock, uint32_t pcbRead)
1603	{
1604	PDMDEV_ASSERT_DEVINS(pDevIns);
1605	PVM pVM = pDevIns->Internal.s.pVMR3;
1606	VM_ASSERT_EMT(pVM);
1607	LogFlow(("pdmR3DevHlp_DMAReadMemory: caller='%s'/%d: uChannel=%d pvBuffer=%p off=%#x cbBlock=%#x pcbRead=%p\n",
1608	pDevIns->pReg->szName, pDevIns->iInstance, uChannel, pvBuffer, off, cbBlock, pcbRead));
1609	int rc = VINF_SUCCESS;
1610	if (pVM->pdm.s.pDmac)
1611	{
1612	uint32_t cb = pVM->pdm.s.pDmac->Reg.pfnReadMemory(pVM->pdm.s.pDmac->pDevIns, uChannel, pvBuffer, off, cbBlock);
1613	if (pcbRead)
1614	*pcbRead = cb;
1615	}
1616	else
1617	{
1618	AssertMsgFailed(("Configuration error: No DMAC controller available. This could be related to init order too!\n"));
1619	rc = VERR_PDM_NO_DMAC_INSTANCE;
1620	}
1621	LogFlow(("pdmR3DevHlp_DMAReadMemory: caller='%s'/%d: returns %Rrc\n",
1622	pDevIns->pReg->szName, pDevIns->iInstance, rc));
1623	return rc;
1624	}
1625
1626
1627	/** @interface_method_impl{PDMDEVHLPR3,pfnDMAWriteMemory} */
1628	static DECLCALLBACK(int) pdmR3DevHlp_DMAWriteMemory(PPDMDEVINS pDevIns, unsigned uChannel, const void pvBuffer, uint32_t off, uint32_t cbBlock, uint32_t pcbWritten)
1629	{
1630	PDMDEV_ASSERT_DEVINS(pDevIns);
1631	PVM pVM = pDevIns->Internal.s.pVMR3;
1632	VM_ASSERT_EMT(pVM);
1633	LogFlow(("pdmR3DevHlp_DMAWriteMemory: caller='%s'/%d: uChannel=%d pvBuffer=%p off=%#x cbBlock=%#x pcbWritten=%p\n",
1634	pDevIns->pReg->szName, pDevIns->iInstance, uChannel, pvBuffer, off, cbBlock, pcbWritten));
1635	int rc = VINF_SUCCESS;
1636	if (pVM->pdm.s.pDmac)
1637	{
1638	uint32_t cb = pVM->pdm.s.pDmac->Reg.pfnWriteMemory(pVM->pdm.s.pDmac->pDevIns, uChannel, pvBuffer, off, cbBlock);
1639	if (pcbWritten)
1640	*pcbWritten = cb;
1641	}
1642	else
1643	{
1644	AssertMsgFailed(("Configuration error: No DMAC controller available. This could be related to init order too!\n"));
1645	rc = VERR_PDM_NO_DMAC_INSTANCE;
1646	}
1647	LogFlow(("pdmR3DevHlp_DMAWriteMemory: caller='%s'/%d: returns %Rrc\n",
1648	pDevIns->pReg->szName, pDevIns->iInstance, rc));
1649	return rc;
1650	}
1651
1652
1653	/** @interface_method_impl{PDMDEVHLPR3,pfnDMASetDREQ} */
1654	static DECLCALLBACK(int) pdmR3DevHlp_DMASetDREQ(PPDMDEVINS pDevIns, unsigned uChannel, unsigned uLevel)
1655	{
1656	PDMDEV_ASSERT_DEVINS(pDevIns);
1657	PVM pVM = pDevIns->Internal.s.pVMR3;
1658	VM_ASSERT_EMT(pVM);
1659	LogFlow(("pdmR3DevHlp_DMASetDREQ: caller='%s'/%d: uChannel=%d uLevel=%d\n",
1660	pDevIns->pReg->szName, pDevIns->iInstance, uChannel, uLevel));
1661	int rc = VINF_SUCCESS;
1662	if (pVM->pdm.s.pDmac)
1663	pVM->pdm.s.pDmac->Reg.pfnSetDREQ(pVM->pdm.s.pDmac->pDevIns, uChannel, uLevel);
1664	else
1665	{
1666	AssertMsgFailed(("Configuration error: No DMAC controller available. This could be related to init order too!\n"));
1667	rc = VERR_PDM_NO_DMAC_INSTANCE;
1668	}
1669	LogFlow(("pdmR3DevHlp_DMASetDREQ: caller='%s'/%d: returns %Rrc\n",
1670	pDevIns->pReg->szName, pDevIns->iInstance, rc));
1671	return rc;
1672	}
1673
1674	/** @interface_method_impl{PDMDEVHLPR3,pfnDMAGetChannelMode} */
1675	static DECLCALLBACK(uint8_t) pdmR3DevHlp_DMAGetChannelMode(PPDMDEVINS pDevIns, unsigned uChannel)
1676	{
1677	PDMDEV_ASSERT_DEVINS(pDevIns);
1678	PVM pVM = pDevIns->Internal.s.pVMR3;
1679	VM_ASSERT_EMT(pVM);
1680	LogFlow(("pdmR3DevHlp_DMAGetChannelMode: caller='%s'/%d: uChannel=%d\n",
1681	pDevIns->pReg->szName, pDevIns->iInstance, uChannel));
1682	uint8_t u8Mode;
1683	if (pVM->pdm.s.pDmac)
1684	u8Mode = pVM->pdm.s.pDmac->Reg.pfnGetChannelMode(pVM->pdm.s.pDmac->pDevIns, uChannel);
1685	else
1686	{
1687	AssertMsgFailed(("Configuration error: No DMAC controller available. This could be related to init order too!\n"));
1688	u8Mode = 3 << 2 /* illegal mode type */;
1689	}
1690	LogFlow(("pdmR3DevHlp_DMAGetChannelMode: caller='%s'/%d: returns %#04x\n",
1691	pDevIns->pReg->szName, pDevIns->iInstance, u8Mode));
1692	return u8Mode;
1693	}
1694
1695	/** @interface_method_impl{PDMDEVHLPR3,pfnDMASchedule} */
1696	static DECLCALLBACK(void) pdmR3DevHlp_DMASchedule(PPDMDEVINS pDevIns)
1697	{
1698	PDMDEV_ASSERT_DEVINS(pDevIns);
1699	PVM pVM = pDevIns->Internal.s.pVMR3;
1700	VM_ASSERT_EMT(pVM);
1701	LogFlow(("pdmR3DevHlp_DMASchedule: caller='%s'/%d: VM_FF_PDM_DMA %d -> 1\n",
1702	pDevIns->pReg->szName, pDevIns->iInstance, VM_FF_ISSET(pVM, VM_FF_PDM_DMA)));
1703
1704	AssertMsg(pVM->pdm.s.pDmac, ("Configuration error: No DMAC controller available. This could be related to init order too!\n"));
1705	VM_FF_SET(pVM, VM_FF_PDM_DMA);
1706	REMR3NotifyDmaPending(pVM);
1707	VMR3NotifyGlobalFFU(pVM->pUVM, VMNOTIFYFF_FLAGS_DONE_REM);
1708	}
1709
1710
1711	/** @interface_method_impl{PDMDEVHLPR3,pfnCMOSWrite} */
1712	static DECLCALLBACK(int) pdmR3DevHlp_CMOSWrite(PPDMDEVINS pDevIns, unsigned iReg, uint8_t u8Value)
1713	{
1714	PDMDEV_ASSERT_DEVINS(pDevIns);
1715	PVM pVM = pDevIns->Internal.s.pVMR3;
1716	VM_ASSERT_EMT(pVM);
1717
1718	LogFlow(("pdmR3DevHlp_CMOSWrite: caller='%s'/%d: iReg=%#04x u8Value=%#04x\n",
1719	pDevIns->pReg->szName, pDevIns->iInstance, iReg, u8Value));
1720	int rc;
1721	if (pVM->pdm.s.pRtc)
1722	rc = pVM->pdm.s.pRtc->Reg.pfnWrite(pVM->pdm.s.pRtc->pDevIns, iReg, u8Value);
1723	else
1724	rc = VERR_PDM_NO_RTC_INSTANCE;
1725
1726	LogFlow(("pdmR3DevHlp_CMOSWrite: caller='%s'/%d: return %Rrc\n",
1727	pDevIns->pReg->szName, pDevIns->iInstance, rc));
1728	return rc;
1729	}
1730
1731
1732	/** @interface_method_impl{PDMDEVHLPR3,pfnCMOSRead} */
1733	static DECLCALLBACK(int) pdmR3DevHlp_CMOSRead(PPDMDEVINS pDevIns, unsigned iReg, uint8_t *pu8Value)
1734	{
1735	PDMDEV_ASSERT_DEVINS(pDevIns);
1736	PVM pVM = pDevIns->Internal.s.pVMR3;
1737	VM_ASSERT_EMT(pVM);
1738
1739	LogFlow(("pdmR3DevHlp_CMOSWrite: caller='%s'/%d: iReg=%#04x pu8Value=%p\n",
1740	pDevIns->pReg->szName, pDevIns->iInstance, iReg, pu8Value));
1741	int rc;
1742	if (pVM->pdm.s.pRtc)
1743	rc = pVM->pdm.s.pRtc->Reg.pfnRead(pVM->pdm.s.pRtc->pDevIns, iReg, pu8Value);
1744	else
1745	rc = VERR_PDM_NO_RTC_INSTANCE;
1746
1747	LogFlow(("pdmR3DevHlp_CMOSWrite: caller='%s'/%d: return %Rrc\n",
1748	pDevIns->pReg->szName, pDevIns->iInstance, rc));
1749	return rc;
1750	}
1751
1752
1753	/** @interface_method_impl{PDMDEVHLPR3,pfnAssertEMT} */
1754	static DECLCALLBACK(bool) pdmR3DevHlp_AssertEMT(PPDMDEVINS pDevIns, const char pszFile, unsigned iLine, const char pszFunction)
1755	{
1756	PDMDEV_ASSERT_DEVINS(pDevIns);
1757	if (VM_IS_EMT(pDevIns->Internal.s.pVMR3))
1758	return true;
1759
1760	char szMsg[100];
1761	RTStrPrintf(szMsg, sizeof(szMsg), "AssertEMT '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance);
1762	RTAssertMsg1Weak(szMsg, iLine, pszFile, pszFunction);
1763	AssertBreakpoint();
1764	return false;
1765	}
1766
1767
1768	/** @interface_method_impl{PDMDEVHLPR3,pfnAssertOther} */
1769	static DECLCALLBACK(bool) pdmR3DevHlp_AssertOther(PPDMDEVINS pDevIns, const char pszFile, unsigned iLine, const char pszFunction)
1770	{
1771	PDMDEV_ASSERT_DEVINS(pDevIns);
1772	if (!VM_IS_EMT(pDevIns->Internal.s.pVMR3))
1773	return true;
1774
1775	char szMsg[100];
1776	RTStrPrintf(szMsg, sizeof(szMsg), "AssertOther '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance);
1777	RTAssertMsg1Weak(szMsg, iLine, pszFile, pszFunction);
1778	AssertBreakpoint();
1779	return false;
1780	}
1781
1782
1783	/** @interface_method_impl{PDMDEVHLP,pfnLdrGetRCInterfaceSymbols} */
1784	static DECLCALLBACK(int) pdmR3DevHlp_LdrGetRCInterfaceSymbols(PPDMDEVINS pDevIns, void *pvInterface, size_t cbInterface,
1785	const char pszSymPrefix, const char pszSymList)
1786	{
1787	PDMDEV_ASSERT_DEVINS(pDevIns);
1788	VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
1789	LogFlow(("pdmR3DevHlp_PDMLdrGetRCInterfaceSymbols: caller='%s'/%d: pvInterface=%p cbInterface=%zu pszSymPrefix=%p:{%s} pszSymList=%p:{%s}\n",
1790	pDevIns->pReg->szName, pDevIns->iInstance, pvInterface, cbInterface, pszSymPrefix, pszSymPrefix, pszSymList, pszSymList));
1791
1792	int rc;
1793	if ( strncmp(pszSymPrefix, "dev", 3) == 0
1794	&& RTStrIStr(pszSymPrefix + 3, pDevIns->pReg->szName) != NULL)
1795	{
1796	if (pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_RC)
1797	rc = PDMR3LdrGetInterfaceSymbols(pDevIns->Internal.s.pVMR3, pvInterface, cbInterface,
1798	pDevIns->pReg->szRCMod, pszSymPrefix, pszSymList,
1799	false /fRing0OrRC/);
1800	else
1801	{
1802	AssertMsgFailed(("Not a raw-mode enabled driver\n"));
1803	rc = VERR_PERMISSION_DENIED;
1804	}
1805	}
1806	else
1807	{
1808	AssertMsgFailed(("Invalid prefix '%s' for '%s'; must start with 'dev' and contain the driver name!\n",
1809	pszSymPrefix, pDevIns->pReg->szName));
1810	rc = VERR_INVALID_NAME;
1811	}
1812
1813	LogFlow(("pdmR3DevHlp_PDMLdrGetRCInterfaceSymbols: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName,
1814	pDevIns->iInstance, rc));
1815	return rc;
1816	}
1817
1818
1819	/** @interface_method_impl{PDMDEVHLP,pfnLdrGetR0InterfaceSymbols} */
1820	static DECLCALLBACK(int) pdmR3DevHlp_LdrGetR0InterfaceSymbols(PPDMDEVINS pDevIns, void *pvInterface, size_t cbInterface,
1821	const char pszSymPrefix, const char pszSymList)
1822	{
1823	PDMDEV_ASSERT_DEVINS(pDevIns);
1824	VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
1825	LogFlow(("pdmR3DevHlp_PDMLdrGetR0InterfaceSymbols: caller='%s'/%d: pvInterface=%p cbInterface=%zu pszSymPrefix=%p:{%s} pszSymList=%p:{%s}\n",
1826	pDevIns->pReg->szName, pDevIns->iInstance, pvInterface, cbInterface, pszSymPrefix, pszSymPrefix, pszSymList, pszSymList));
1827
1828	int rc;
1829	if ( strncmp(pszSymPrefix, "dev", 3) == 0
1830	&& RTStrIStr(pszSymPrefix + 3, pDevIns->pReg->szName) != NULL)
1831	{
1832	if (pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_R0)
1833	rc = PDMR3LdrGetInterfaceSymbols(pDevIns->Internal.s.pVMR3, pvInterface, cbInterface,
1834	pDevIns->pReg->szR0Mod, pszSymPrefix, pszSymList,
1835	true /fRing0OrRC/);
1836	else
1837	{
1838	AssertMsgFailed(("Not a ring-0 enabled driver\n"));
1839	rc = VERR_PERMISSION_DENIED;
1840	}
1841	}
1842	else
1843	{
1844	AssertMsgFailed(("Invalid prefix '%s' for '%s'; must start with 'dev' and contain the driver name!\n",
1845	pszSymPrefix, pDevIns->pReg->szName));
1846	rc = VERR_INVALID_NAME;
1847	}
1848
1849	LogFlow(("pdmR3DevHlp_PDMLdrGetR0InterfaceSymbols: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName,
1850	pDevIns->iInstance, rc));
1851	return rc;
1852	}
1853
1854
1855	/** @interface_method_impl{PDMDEVHLP,pfnCallR0} */
1856	static DECLCALLBACK(int) pdmR3DevHlp_CallR0(PPDMDEVINS pDevIns, uint32_t uOperation, uint64_t u64Arg)
1857	{
1858	PDMDEV_ASSERT_DEVINS(pDevIns);
1859	PVM pVM = pDevIns->Internal.s.pVMR3;
1860	VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
1861	LogFlow(("pdmR3DevHlp_CallR0: caller='%s'/%d: uOperation=%#x u64Arg=%#RX64\n",
1862	pDevIns->pReg->szName, pDevIns->iInstance, uOperation, u64Arg));
1863
1864	/*
1865	* Resolve the ring-0 entry point. There is not need to remember this like
1866	* we do for drivers since this is mainly for construction time hacks and
1867	* other things that aren't performance critical.
1868	*/
1869	int rc;
1870	if (pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_R0)
1871	{
1872	char szSymbol[ sizeof("devR0") + sizeof(pDevIns->pReg->szName) + sizeof("ReqHandler")];
1873	strcat(strcat(strcpy(szSymbol, "devR0"), pDevIns->pReg->szName), "ReqHandler");
1874	szSymbol[sizeof("devR0") - 1] = RT_C_TO_UPPER(szSymbol[sizeof("devR0") - 1]);
1875
1876	PFNPDMDRVREQHANDLERR0 pfnReqHandlerR0;
1877	rc = PDMR3LdrGetSymbolR0Lazy(pVM, pDevIns->pReg->szR0Mod, szSymbol, &pfnReqHandlerR0);
1878	if (RT_SUCCESS(rc))
1879	{
1880	/*
1881	* Make the ring-0 call.
1882	*/
1883	PDMDEVICECALLREQHANDLERREQ Req;
1884	Req.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
1885	Req.Hdr.cbReq = sizeof(Req);
1886	Req.pDevInsR0 = PDMDEVINS_2_R0PTR(pDevIns);
1887	Req.pfnReqHandlerR0 = pfnReqHandlerR0;
1888	Req.uOperation = uOperation;
1889	Req.u32Alignment = 0;
1890	Req.u64Arg = u64Arg;
1891	rc = SUPR3CallVMMR0Ex(pVM->pVMR0, NIL_VMCPUID, VMMR0_DO_PDM_DEVICE_CALL_REQ_HANDLER, 0, &Req.Hdr);
1892	}
1893	else
1894	pfnReqHandlerR0 = NIL_RTR0PTR;
1895	}
1896	else
1897	rc = VERR_ACCESS_DENIED;
1898	LogFlow(("pdmR3DevHlp_CallR0: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName,
1899	pDevIns->iInstance, rc));
1900	return rc;
1901	}
1902
1903
1904	/** @interface_method_impl{PDMDEVHLPR3,pfnGetVM} */
1905	static DECLCALLBACK(PVM) pdmR3DevHlp_GetVM(PPDMDEVINS pDevIns)
1906	{
1907	PDMDEV_ASSERT_DEVINS(pDevIns);
1908	LogFlow(("pdmR3DevHlp_GetVM: caller='%s'/%d: returns %p\n", pDevIns->pReg->szName, pDevIns->iInstance, pDevIns->Internal.s.pVMR3));
1909	return pDevIns->Internal.s.pVMR3;
1910	}
1911
1912
1913	/** @interface_method_impl{PDMDEVHLPR3,pfnGetVMCPU} */
1914	static DECLCALLBACK(PVMCPU) pdmR3DevHlp_GetVMCPU(PPDMDEVINS pDevIns)
1915	{
1916	PDMDEV_ASSERT_DEVINS(pDevIns);
1917	VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
1918	LogFlow(("pdmR3DevHlp_GetVMCPU: caller='%s'/%d for CPU %u\n", pDevIns->pReg->szName, pDevIns->iInstance, VMMGetCpuId(pDevIns->Internal.s.pVMR3)));
1919	return VMMGetCpu(pDevIns->Internal.s.pVMR3);
1920	}
1921
1922
1923	/** @interface_method_impl{PDMDEVHLPR3,pfnPCIBusRegister} */
1924	static DECLCALLBACK(int) pdmR3DevHlp_PCIBusRegister(PPDMDEVINS pDevIns, PPDMPCIBUSREG pPciBusReg, PCPDMPCIHLPR3 *ppPciHlpR3)
1925	{
1926	PDMDEV_ASSERT_DEVINS(pDevIns);
1927	PVM pVM = pDevIns->Internal.s.pVMR3;
1928	VM_ASSERT_EMT(pVM);
1929	LogFlow(("pdmR3DevHlp_PCIBusRegister: caller='%s'/%d: pPciBusReg=%p:{.u32Version=%#x, .pfnRegisterR3=%p, .pfnIORegionRegisterR3=%p, .pfnSetIrqR3=%p, "
1930	".pfnSaveExecR3=%p, .pfnLoadExecR3=%p, .pfnFakePCIBIOSR3=%p, .pszSetIrqRC=%p:{%s}, .pszSetIrqR0=%p:{%s}} ppPciHlpR3=%p\n",
1931	pDevIns->pReg->szName, pDevIns->iInstance, pPciBusReg, pPciBusReg->u32Version, pPciBusReg->pfnRegisterR3,
1932	pPciBusReg->pfnIORegionRegisterR3, pPciBusReg->pfnSetIrqR3, pPciBusReg->pfnSaveExecR3, pPciBusReg->pfnLoadExecR3,
1933	pPciBusReg->pfnFakePCIBIOSR3, pPciBusReg->pszSetIrqRC, pPciBusReg->pszSetIrqRC, pPciBusReg->pszSetIrqR0, pPciBusReg->pszSetIrqR0, ppPciHlpR3));
1934
1935	/*
1936	* Validate the structure.
1937	*/
1938	if (pPciBusReg->u32Version != PDM_PCIBUSREG_VERSION)
1939	{
1940	AssertMsgFailed(("u32Version=%#x expected %#x\n", pPciBusReg->u32Version, PDM_PCIBUSREG_VERSION));
1941	LogFlow(("pdmR3DevHlp_PCIRegister: caller='%s'/%d: returns %Rrc (version)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
1942	return VERR_INVALID_PARAMETER;
1943	}
1944	if ( !pPciBusReg->pfnRegisterR3
1945	\|\| !pPciBusReg->pfnIORegionRegisterR3
1946	\|\| !pPciBusReg->pfnSetIrqR3
1947	\|\| !pPciBusReg->pfnSaveExecR3
1948	\|\| !pPciBusReg->pfnLoadExecR3
1949	\|\| (!pPciBusReg->pfnFakePCIBIOSR3 && !pVM->pdm.s.aPciBuses[0].pDevInsR3)) /* Only the first bus needs to do the BIOS work. */
1950	{
1951	Assert(pPciBusReg->pfnRegisterR3);
1952	Assert(pPciBusReg->pfnIORegionRegisterR3);
1953	Assert(pPciBusReg->pfnSetIrqR3);
1954	Assert(pPciBusReg->pfnSaveExecR3);
1955	Assert(pPciBusReg->pfnLoadExecR3);
1956	Assert(pPciBusReg->pfnFakePCIBIOSR3);
1957	LogFlow(("pdmR3DevHlp_PCIBusRegister: caller='%s'/%d: returns %Rrc (R3 callbacks)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
1958	return VERR_INVALID_PARAMETER;
1959	}
1960	if ( pPciBusReg->pszSetIrqRC
1961	&& !VALID_PTR(pPciBusReg->pszSetIrqRC))
1962	{
1963	Assert(VALID_PTR(pPciBusReg->pszSetIrqRC));
1964	LogFlow(("pdmR3DevHlp_PCIBusRegister: caller='%s'/%d: returns %Rrc (GC callbacks)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
1965	return VERR_INVALID_PARAMETER;
1966	}
1967	if ( pPciBusReg->pszSetIrqR0
1968	&& !VALID_PTR(pPciBusReg->pszSetIrqR0))
1969	{
1970	Assert(VALID_PTR(pPciBusReg->pszSetIrqR0));
1971	LogFlow(("pdmR3DevHlp_PCIBusRegister: caller='%s'/%d: returns %Rrc (GC callbacks)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
1972	return VERR_INVALID_PARAMETER;
1973	}
1974	if (!ppPciHlpR3)
1975	{
1976	Assert(ppPciHlpR3);
1977	LogFlow(("pdmR3DevHlp_PCIBusRegister: caller='%s'/%d: returns %Rrc (ppPciHlpR3)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
1978	return VERR_INVALID_PARAMETER;
1979	}
1980
1981	/*
1982	* Find free PCI bus entry.
1983	*/
1984	unsigned iBus = 0;
1985	for (iBus = 0; iBus < RT_ELEMENTS(pVM->pdm.s.aPciBuses); iBus++)
1986	if (!pVM->pdm.s.aPciBuses[iBus].pDevInsR3)
1987	break;
1988	if (iBus >= RT_ELEMENTS(pVM->pdm.s.aPciBuses))
1989	{
1990	AssertMsgFailed(("Too many PCI buses. Max=%u\n", RT_ELEMENTS(pVM->pdm.s.aPciBuses)));
1991	LogFlow(("pdmR3DevHlp_PCIBusRegister: caller='%s'/%d: returns %Rrc (pci bus)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
1992	return VERR_INVALID_PARAMETER;
1993	}
1994	PPDMPCIBUS pPciBus = &pVM->pdm.s.aPciBuses[iBus];
1995
1996	/*
1997	* Resolve and init the RC bits.
1998	*/
1999	if (pPciBusReg->pszSetIrqRC)
2000	{
2001	int rc = PDMR3LdrGetSymbolRCLazy(pVM, pDevIns->pReg->szRCMod, pPciBusReg->pszSetIrqRC, &pPciBus->pfnSetIrqRC);
2002	AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szRCMod, pPciBusReg->pszSetIrqRC, rc));
2003	if (RT_FAILURE(rc))
2004	{
2005	LogFlow(("pdmR3DevHlp_PCIRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
2006	return rc;
2007	}
2008	pPciBus->pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
2009	}
2010	else
2011	{
2012	pPciBus->pfnSetIrqRC = 0;
2013	pPciBus->pDevInsRC = 0;
2014	}
2015
2016	/*
2017	* Resolve and init the R0 bits.
2018	*/
2019	if (pPciBusReg->pszSetIrqR0)
2020	{
2021	int rc = PDMR3LdrGetSymbolR0Lazy(pVM, pDevIns->pReg->szR0Mod, pPciBusReg->pszSetIrqR0, &pPciBus->pfnSetIrqR0);
2022	AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szR0Mod, pPciBusReg->pszSetIrqR0, rc));
2023	if (RT_FAILURE(rc))
2024	{
2025	LogFlow(("pdmR3DevHlp_PCIRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
2026	return rc;
2027	}
2028	pPciBus->pDevInsR0 = PDMDEVINS_2_R0PTR(pDevIns);
2029	}
2030	else
2031	{
2032	pPciBus->pfnSetIrqR0 = 0;
2033	pPciBus->pDevInsR0 = 0;
2034	}
2035
2036	/*
2037	* Init the R3 bits.
2038	*/
2039	pPciBus->iBus = iBus;
2040	pPciBus->pDevInsR3 = pDevIns;
2041	pPciBus->pfnRegisterR3 = pPciBusReg->pfnRegisterR3;
2042	pPciBus->pfnIORegionRegisterR3 = pPciBusReg->pfnIORegionRegisterR3;
2043	pPciBus->pfnSetConfigCallbacksR3 = pPciBusReg->pfnSetConfigCallbacksR3;
2044	pPciBus->pfnSetIrqR3 = pPciBusReg->pfnSetIrqR3;
2045	pPciBus->pfnSaveExecR3 = pPciBusReg->pfnSaveExecR3;
2046	pPciBus->pfnLoadExecR3 = pPciBusReg->pfnLoadExecR3;
2047	pPciBus->pfnFakePCIBIOSR3 = pPciBusReg->pfnFakePCIBIOSR3;
2048
2049	Log(("PDM: Registered PCI bus device '%s'/%d pDevIns=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, pDevIns));
2050
2051	/* set the helper pointer and return. */
2052	*ppPciHlpR3 = &g_pdmR3DevPciHlp;
2053	LogFlow(("pdmR3DevHlp_PCIBusRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, VINF_SUCCESS));
2054	return VINF_SUCCESS;
2055	}
2056
2057
2058	/** @interface_method_impl{PDMDEVHLPR3,pfnPICRegister} */
2059	static DECLCALLBACK(int) pdmR3DevHlp_PICRegister(PPDMDEVINS pDevIns, PPDMPICREG pPicReg, PCPDMPICHLPR3 *ppPicHlpR3)
2060	{
2061	PDMDEV_ASSERT_DEVINS(pDevIns);
2062	VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
2063	LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: pPicReg=%p:{.u32Version=%#x, .pfnSetIrqR3=%p, .pfnGetInterruptR3=%p, .pszGetIrqRC=%p:{%s}, .pszGetInterruptRC=%p:{%s}, .pszGetIrqR0=%p:{%s}, .pszGetInterruptR0=%p:{%s} } ppPicHlpR3=%p\n",
2064	pDevIns->pReg->szName, pDevIns->iInstance, pPicReg, pPicReg->u32Version, pPicReg->pfnSetIrqR3, pPicReg->pfnGetInterruptR3,
2065	pPicReg->pszSetIrqRC, pPicReg->pszSetIrqRC, pPicReg->pszGetInterruptRC, pPicReg->pszGetInterruptRC,
2066	pPicReg->pszSetIrqR0, pPicReg->pszSetIrqR0, pPicReg->pszGetInterruptR0, pPicReg->pszGetInterruptR0,
2067	ppPicHlpR3));
2068
2069	/*
2070	* Validate input.
2071	*/
2072	if (pPicReg->u32Version != PDM_PICREG_VERSION)
2073	{
2074	AssertMsgFailed(("u32Version=%#x expected %#x\n", pPicReg->u32Version, PDM_PICREG_VERSION));
2075	LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc (version)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
2076	return VERR_INVALID_PARAMETER;
2077	}
2078	if ( !pPicReg->pfnSetIrqR3
2079	\|\| !pPicReg->pfnGetInterruptR3)
2080	{
2081	Assert(pPicReg->pfnSetIrqR3);
2082	Assert(pPicReg->pfnGetInterruptR3);
2083	LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc (R3 callbacks)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
2084	return VERR_INVALID_PARAMETER;
2085	}
2086	if ( ( pPicReg->pszSetIrqRC
2087	\|\| pPicReg->pszGetInterruptRC)
2088	&& ( !VALID_PTR(pPicReg->pszSetIrqRC)
2089	\|\| !VALID_PTR(pPicReg->pszGetInterruptRC))
2090	)
2091	{
2092	Assert(VALID_PTR(pPicReg->pszSetIrqRC));
2093	Assert(VALID_PTR(pPicReg->pszGetInterruptRC));
2094	LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc (RC callbacks)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
2095	return VERR_INVALID_PARAMETER;
2096	}
2097	if ( pPicReg->pszSetIrqRC
2098	&& !(pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_RC))
2099	{
2100	Assert(pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_RC);
2101	LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc (RC flag)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
2102	return VERR_INVALID_PARAMETER;
2103	}
2104	if ( pPicReg->pszSetIrqR0
2105	&& !(pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_R0))
2106	{
2107	Assert(pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_R0);
2108	LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc (R0 flag)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
2109	return VERR_INVALID_PARAMETER;
2110	}
2111	if (!ppPicHlpR3)
2112	{
2113	Assert(ppPicHlpR3);
2114	LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc (ppPicHlpR3)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
2115	return VERR_INVALID_PARAMETER;
2116	}
2117
2118	/*
2119	* Only one PIC device.
2120	*/
2121	PVM pVM = pDevIns->Internal.s.pVMR3;
2122	if (pVM->pdm.s.Pic.pDevInsR3)
2123	{
2124	AssertMsgFailed(("Only one pic device is supported!\n"));
2125	LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
2126	return VERR_INVALID_PARAMETER;
2127	}
2128
2129	/*
2130	* RC stuff.
2131	*/
2132	if (pPicReg->pszSetIrqRC)
2133	{
2134	int rc = PDMR3LdrGetSymbolRCLazy(pVM, pDevIns->pReg->szRCMod, pPicReg->pszSetIrqRC, &pVM->pdm.s.Pic.pfnSetIrqRC);
2135	AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szRCMod, pPicReg->pszSetIrqRC, rc));
2136	if (RT_SUCCESS(rc))
2137	{
2138	rc = PDMR3LdrGetSymbolRCLazy(pVM, pDevIns->pReg->szRCMod, pPicReg->pszGetInterruptRC, &pVM->pdm.s.Pic.pfnGetInterruptRC);
2139	AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szRCMod, pPicReg->pszGetInterruptRC, rc));
2140	}
2141	if (RT_FAILURE(rc))
2142	{
2143	LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
2144	return rc;
2145	}
2146	pVM->pdm.s.Pic.pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
2147	}
2148	else
2149	{
2150	pVM->pdm.s.Pic.pDevInsRC = 0;
2151	pVM->pdm.s.Pic.pfnSetIrqRC = 0;
2152	pVM->pdm.s.Pic.pfnGetInterruptRC = 0;
2153	}
2154
2155	/*
2156	* R0 stuff.
2157	*/
2158	if (pPicReg->pszSetIrqR0)
2159	{
2160	int rc = PDMR3LdrGetSymbolR0Lazy(pVM, pDevIns->pReg->szR0Mod, pPicReg->pszSetIrqR0, &pVM->pdm.s.Pic.pfnSetIrqR0);
2161	AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szR0Mod, pPicReg->pszSetIrqR0, rc));
2162	if (RT_SUCCESS(rc))
2163	{
2164	rc = PDMR3LdrGetSymbolR0Lazy(pVM, pDevIns->pReg->szR0Mod, pPicReg->pszGetInterruptR0, &pVM->pdm.s.Pic.pfnGetInterruptR0);
2165	AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szR0Mod, pPicReg->pszGetInterruptR0, rc));
2166	}
2167	if (RT_FAILURE(rc))
2168	{
2169	LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
2170	return rc;
2171	}
2172	pVM->pdm.s.Pic.pDevInsR0 = PDMDEVINS_2_R0PTR(pDevIns);
2173	Assert(pVM->pdm.s.Pic.pDevInsR0);
2174	}
2175	else
2176	{
2177	pVM->pdm.s.Pic.pfnSetIrqR0 = 0;
2178	pVM->pdm.s.Pic.pfnGetInterruptR0 = 0;
2179	pVM->pdm.s.Pic.pDevInsR0 = 0;
2180	}
2181
2182	/*
2183	* R3 stuff.
2184	*/
2185	pVM->pdm.s.Pic.pDevInsR3 = pDevIns;
2186	pVM->pdm.s.Pic.pfnSetIrqR3 = pPicReg->pfnSetIrqR3;
2187	pVM->pdm.s.Pic.pfnGetInterruptR3 = pPicReg->pfnGetInterruptR3;
2188	Log(("PDM: Registered PIC device '%s'/%d pDevIns=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, pDevIns));
2189
2190	/* set the helper pointer and return. */
2191	*ppPicHlpR3 = &g_pdmR3DevPicHlp;
2192	LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, VINF_SUCCESS));
2193	return VINF_SUCCESS;
2194	}
2195
2196
2197	/** @interface_method_impl{PDMDEVHLPR3,pfnAPICRegister} */
2198	static DECLCALLBACK(int) pdmR3DevHlp_APICRegister(PPDMDEVINS pDevIns, PPDMAPICREG pApicReg, PCPDMAPICHLPR3 *ppApicHlpR3)
2199	{
2200	PDMDEV_ASSERT_DEVINS(pDevIns);
2201	VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
2202	LogFlow(("pdmR3DevHlp_APICRegister: caller='%s'/%d: pApicReg=%p:{.u32Version=%#x, .pfnGetInterruptR3=%p, .pfnSetBaseR3=%p, .pfnGetBaseR3=%p, "
2203	".pfnSetTPRR3=%p, .pfnGetTPRR3=%p, .pfnWriteMSR3=%p, .pfnReadMSR3=%p, .pfnBusDeliverR3=%p, .pfnLocalInterruptR3=%p, pszGetInterruptRC=%p:{%s}, pszSetBaseRC=%p:{%s}, pszGetBaseRC=%p:{%s}, "
2204	".pszSetTPRRC=%p:{%s}, .pszGetTPRRC=%p:{%s}, .pszWriteMSRRC=%p:{%s}, .pszReadMSRRC=%p:{%s}, .pszBusDeliverRC=%p:{%s}, .pszLocalInterruptRC=%p:{%s}} ppApicHlpR3=%p\n",
2205	pDevIns->pReg->szName, pDevIns->iInstance, pApicReg, pApicReg->u32Version, pApicReg->pfnGetInterruptR3, pApicReg->pfnSetBaseR3,
2206	pApicReg->pfnGetBaseR3, pApicReg->pfnSetTPRR3, pApicReg->pfnGetTPRR3, pApicReg->pfnWriteMSRR3, pApicReg->pfnReadMSRR3, pApicReg->pfnBusDeliverR3, pApicReg->pfnLocalInterruptR3, pApicReg->pszGetInterruptRC,
2207	pApicReg->pszGetInterruptRC, pApicReg->pszSetBaseRC, pApicReg->pszSetBaseRC, pApicReg->pszGetBaseRC, pApicReg->pszGetBaseRC,
2208	pApicReg->pszSetTPRRC, pApicReg->pszSetTPRRC, pApicReg->pszGetTPRRC, pApicReg->pszGetTPRRC, pApicReg->pszWriteMSRRC, pApicReg->pszWriteMSRRC, pApicReg->pszReadMSRRC, pApicReg->pszReadMSRRC, pApicReg->pszBusDeliverRC,
2209	pApicReg->pszBusDeliverRC, pApicReg->pszLocalInterruptRC, pApicReg->pszLocalInterruptRC, ppApicHlpR3));
2210
2211	/*
2212	* Validate input.
2213	*/
2214	if (pApicReg->u32Version != PDM_APICREG_VERSION)
2215	{
2216	AssertMsgFailed(("u32Version=%#x expected %#x\n", pApicReg->u32Version, PDM_APICREG_VERSION));
2217	LogFlow(("pdmR3DevHlp_APICRegister: caller='%s'/%d: returns %Rrc (version)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
2218	return VERR_INVALID_PARAMETER;
2219	}
2220	if ( !pApicReg->pfnGetInterruptR3
2221	\|\| !pApicReg->pfnHasPendingIrqR3
2222	\|\| !pApicReg->pfnSetBaseR3
2223	\|\| !pApicReg->pfnGetBaseR3
2224	\|\| !pApicReg->pfnSetTPRR3
2225	\|\| !pApicReg->pfnGetTPRR3
2226	\|\| !pApicReg->pfnWriteMSRR3
2227	\|\| !pApicReg->pfnReadMSRR3
2228	\|\| !pApicReg->pfnBusDeliverR3
2229	\|\| !pApicReg->pfnLocalInterruptR3)
2230	{
2231	Assert(pApicReg->pfnGetInterruptR3);
2232	Assert(pApicReg->pfnHasPendingIrqR3);
2233	Assert(pApicReg->pfnSetBaseR3);
2234	Assert(pApicReg->pfnGetBaseR3);
2235	Assert(pApicReg->pfnSetTPRR3);
2236	Assert(pApicReg->pfnGetTPRR3);
2237	Assert(pApicReg->pfnWriteMSRR3);
2238	Assert(pApicReg->pfnReadMSRR3);
2239	Assert(pApicReg->pfnBusDeliverR3);
2240	Assert(pApicReg->pfnLocalInterruptR3);
2241	LogFlow(("pdmR3DevHlp_APICRegister: caller='%s'/%d: returns %Rrc (R3 callbacks)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
2242	return VERR_INVALID_PARAMETER;
2243	}
2244	if ( ( pApicReg->pszGetInterruptRC
2245	\|\| pApicReg->pszHasPendingIrqRC
2246	\|\| pApicReg->pszSetBaseRC
2247	\|\| pApicReg->pszGetBaseRC
2248	\|\| pApicReg->pszSetTPRRC
2249	\|\| pApicReg->pszGetTPRRC
2250	\|\| pApicReg->pszWriteMSRRC
2251	\|\| pApicReg->pszReadMSRRC
2252	\|\| pApicReg->pszBusDeliverRC
2253	\|\| pApicReg->pszLocalInterruptRC)
2254	&& ( !VALID_PTR(pApicReg->pszGetInterruptRC)
2255	\|\| !VALID_PTR(pApicReg->pszHasPendingIrqRC)
2256	\|\| !VALID_PTR(pApicReg->pszSetBaseRC)
2257	\|\| !VALID_PTR(pApicReg->pszGetBaseRC)
2258	\|\| !VALID_PTR(pApicReg->pszSetTPRRC)
2259	\|\| !VALID_PTR(pApicReg->pszGetTPRRC)
2260	\|\| !VALID_PTR(pApicReg->pszWriteMSRRC)
2261	\|\| !VALID_PTR(pApicReg->pszReadMSRRC)
2262	\|\| !VALID_PTR(pApicReg->pszBusDeliverRC)
2263	\|\| !VALID_PTR(pApicReg->pszLocalInterruptRC))
2264	)
2265	{
2266	Assert(VALID_PTR(pApicReg->pszGetInterruptRC));
2267	Assert(VALID_PTR(pApicReg->pszHasPendingIrqRC));
2268	Assert(VALID_PTR(pApicReg->pszSetBaseRC));
2269	Assert(VALID_PTR(pApicReg->pszGetBaseRC));
2270	Assert(VALID_PTR(pApicReg->pszSetTPRRC));
2271	Assert(VALID_PTR(pApicReg->pszGetTPRRC));
2272	Assert(VALID_PTR(pApicReg->pszReadMSRRC));
2273	Assert(VALID_PTR(pApicReg->pszWriteMSRRC));
2274	Assert(VALID_PTR(pApicReg->pszBusDeliverRC));
2275	Assert(VALID_PTR(pApicReg->pszLocalInterruptRC));
2276	LogFlow(("pdmR3DevHlp_APICRegister: caller='%s'/%d: returns %Rrc (RC callbacks)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
2277	return VERR_INVALID_PARAMETER;
2278	}
2279	if ( ( pApicReg->pszGetInterruptR0
2280	\|\| pApicReg->pszHasPendingIrqR0
2281	\|\| pApicReg->pszSetBaseR0
2282	\|\| pApicReg->pszGetBaseR0
2283	\|\| pApicReg->pszSetTPRR0
2284	\|\| pApicReg->pszGetTPRR0
2285	\|\| pApicReg->pszWriteMSRR0
2286	\|\| pApicReg->pszReadMSRR0
2287	\|\| pApicReg->pszBusDeliverR0
2288	\|\| pApicReg->pszLocalInterruptR0)
2289	&& ( !VALID_PTR(pApicReg->pszGetInterruptR0)
2290	\|\| !VALID_PTR(pApicReg->pszHasPendingIrqR0)
2291	\|\| !VALID_PTR(pApicReg->pszSetBaseR0)
2292	\|\| !VALID_PTR(pApicReg->pszGetBaseR0)
2293	\|\| !VALID_PTR(pApicReg->pszSetTPRR0)
2294	\|\| !VALID_PTR(pApicReg->pszGetTPRR0)
2295	\|\| !VALID_PTR(pApicReg->pszReadMSRR0)
2296	\|\| !VALID_PTR(pApicReg->pszWriteMSRR0)
2297	\|\| !VALID_PTR(pApicReg->pszBusDeliverR0)
2298	\|\| !VALID_PTR(pApicReg->pszLocalInterruptR0))
2299	)
2300	{
2301	Assert(VALID_PTR(pApicReg->pszGetInterruptR0));
2302	Assert(VALID_PTR(pApicReg->pszHasPendingIrqR0));
2303	Assert(VALID_PTR(pApicReg->pszSetBaseR0));
2304	Assert(VALID_PTR(pApicReg->pszGetBaseR0));
2305	Assert(VALID_PTR(pApicReg->pszSetTPRR0));
2306	Assert(VALID_PTR(pApicReg->pszGetTPRR0));
2307	Assert(VALID_PTR(pApicReg->pszReadMSRR0));
2308	Assert(VALID_PTR(pApicReg->pszWriteMSRR0));
2309	Assert(VALID_PTR(pApicReg->pszBusDeliverR0));
2310	Assert(VALID_PTR(pApicReg->pszLocalInterruptR0));
2311	LogFlow(("pdmR3DevHlp_APICRegister: caller='%s'/%d: returns %Rrc (R0 callbacks)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
2312	return VERR_INVALID_PARAMETER;
2313	}
2314	if (!ppApicHlpR3)
2315	{
2316	Assert(ppApicHlpR3);
2317	LogFlow(("pdmR3DevHlp_APICRegister: caller='%s'/%d: returns %Rrc (ppApicHlpR3)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
2318	return VERR_INVALID_PARAMETER;
2319	}
2320
2321	/*
2322	* Only one APIC device. On SMP we have single logical device covering all LAPICs,
2323	* as they need to communicate and share state easily.
2324	*/
2325	PVM pVM = pDevIns->Internal.s.pVMR3;
2326	if (pVM->pdm.s.Apic.pDevInsR3)
2327	{
2328	AssertMsgFailed(("Only one apic device is supported!\n"));
2329	LogFlow(("pdmR3DevHlp_APICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
2330	return VERR_INVALID_PARAMETER;
2331	}
2332
2333	/*
2334	* Resolve & initialize the RC bits.
2335	*/
2336	if (pApicReg->pszGetInterruptRC)
2337	{
2338	int rc = PDMR3LdrGetSymbolRCLazy(pVM, pDevIns->pReg->szRCMod, pApicReg->pszGetInterruptRC, &pVM->pdm.s.Apic.pfnGetInterruptRC);
2339	AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szRCMod, pApicReg->pszGetInterruptRC, rc));
2340	if (RT_SUCCESS(rc))
2341	{
2342	rc = PDMR3LdrGetSymbolRCLazy(pVM, pDevIns->pReg->szRCMod, pApicReg->pszHasPendingIrqRC, &pVM->pdm.s.Apic.pfnHasPendingIrqRC);
2343	AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szRCMod, pApicReg->pszHasPendingIrqRC, rc));
2344	}
2345	if (RT_SUCCESS(rc))
2346	{
2347	rc = PDMR3LdrGetSymbolRCLazy(pVM, pDevIns->pReg->szRCMod, pApicReg->pszSetBaseRC, &pVM->pdm.s.Apic.pfnSetBaseRC);
2348	AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szRCMod, pApicReg->pszSetBaseRC, rc));
2349	}
2350	if (RT_SUCCESS(rc))
2351	{
2352	rc = PDMR3LdrGetSymbolRCLazy(pVM, pDevIns->pReg->szRCMod, pApicReg->pszGetBaseRC, &pVM->pdm.s.Apic.pfnGetBaseRC);
2353	AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szRCMod, pApicReg->pszGetBaseRC, rc));
2354	}
2355	if (RT_SUCCESS(rc))
2356	{
2357	rc = PDMR3LdrGetSymbolRCLazy(pVM, pDevIns->pReg->szRCMod, pApicReg->pszSetTPRRC, &pVM->pdm.s.Apic.pfnSetTPRRC);
2358	AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szRCMod, pApicReg->pszSetTPRRC, rc));
2359	}
2360	if (RT_SUCCESS(rc))
2361	{
2362	rc = PDMR3LdrGetSymbolRCLazy(pVM, pDevIns->pReg->szRCMod, pApicReg->pszGetTPRRC, &pVM->pdm.s.Apic.pfnGetTPRRC);
2363	AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szRCMod, pApicReg->pszGetTPRRC, rc));
2364	}
2365	if (RT_SUCCESS(rc))
2366	{
2367	rc = PDMR3LdrGetSymbolRCLazy(pVM, pDevIns->pReg->szRCMod, pApicReg->pszWriteMSRRC, &pVM->pdm.s.Apic.pfnWriteMSRRC);
2368	AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szRCMod, pApicReg->pszWriteMSRRC, rc));
2369	}
2370	if (RT_SUCCESS(rc))
2371	{
2372	rc = PDMR3LdrGetSymbolRCLazy(pVM, pDevIns->pReg->szRCMod, pApicReg->pszReadMSRRC, &pVM->pdm.s.Apic.pfnReadMSRRC);
2373	AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szRCMod, pApicReg->pszReadMSRRC, rc));
2374	}
2375	if (RT_SUCCESS(rc))
2376	{
2377	rc = PDMR3LdrGetSymbolRCLazy(pVM, pDevIns->pReg->szRCMod, pApicReg->pszBusDeliverRC, &pVM->pdm.s.Apic.pfnBusDeliverRC);
2378	AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szRCMod, pApicReg->pszBusDeliverRC, rc));
2379	}
2380	if (RT_SUCCESS(rc))
2381	{
2382	rc = PDMR3LdrGetSymbolRCLazy(pVM, pDevIns->pReg->szRCMod, pApicReg->pszLocalInterruptRC, &pVM->pdm.s.Apic.pfnLocalInterruptRC);
2383	AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szRCMod, pApicReg->pszLocalInterruptRC, rc));
2384	}
2385	if (RT_FAILURE(rc))
2386	{
2387	LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
2388	return rc;
2389	}
2390	pVM->pdm.s.Apic.pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
2391	}
2392	else
2393	{
2394	pVM->pdm.s.Apic.pDevInsRC = 0;
2395	pVM->pdm.s.Apic.pfnGetInterruptRC = 0;
2396	pVM->pdm.s.Apic.pfnHasPendingIrqRC = 0;
2397	pVM->pdm.s.Apic.pfnSetBaseRC = 0;
2398	pVM->pdm.s.Apic.pfnGetBaseRC = 0;
2399	pVM->pdm.s.Apic.pfnSetTPRRC = 0;
2400	pVM->pdm.s.Apic.pfnGetTPRRC = 0;
2401	pVM->pdm.s.Apic.pfnWriteMSRRC = 0;
2402	pVM->pdm.s.Apic.pfnReadMSRRC = 0;
2403	pVM->pdm.s.Apic.pfnBusDeliverRC = 0;
2404	pVM->pdm.s.Apic.pfnLocalInterruptRC = 0;
2405	}
2406
2407	/*
2408	* Resolve & initialize the R0 bits.
2409	*/
2410	if (pApicReg->pszGetInterruptR0)
2411	{
2412	int rc = PDMR3LdrGetSymbolR0Lazy(pVM, pDevIns->pReg->szR0Mod, pApicReg->pszGetInterruptR0, &pVM->pdm.s.Apic.pfnGetInterruptR0);
2413	AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szR0Mod, pApicReg->pszGetInterruptR0, rc));
2414	if (RT_SUCCESS(rc))
2415	{
2416	rc = PDMR3LdrGetSymbolR0Lazy(pVM, pDevIns->pReg->szR0Mod, pApicReg->pszHasPendingIrqR0, &pVM->pdm.s.Apic.pfnHasPendingIrqR0);
2417	AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szR0Mod, pApicReg->pszHasPendingIrqR0, rc));
2418	}
2419	if (RT_SUCCESS(rc))
2420	{
2421	rc = PDMR3LdrGetSymbolR0Lazy(pVM, pDevIns->pReg->szR0Mod, pApicReg->pszSetBaseR0, &pVM->pdm.s.Apic.pfnSetBaseR0);
2422	AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szR0Mod, pApicReg->pszSetBaseR0, rc));
2423	}
2424	if (RT_SUCCESS(rc))
2425	{
2426	rc = PDMR3LdrGetSymbolR0Lazy(pVM, pDevIns->pReg->szR0Mod, pApicReg->pszGetBaseR0, &pVM->pdm.s.Apic.pfnGetBaseR0);
2427	AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szR0Mod, pApicReg->pszGetBaseR0, rc));
2428	}
2429	if (RT_SUCCESS(rc))
2430	{
2431	rc = PDMR3LdrGetSymbolR0Lazy(pVM, pDevIns->pReg->szR0Mod, pApicReg->pszSetTPRR0, &pVM->pdm.s.Apic.pfnSetTPRR0);
2432	AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szR0Mod, pApicReg->pszSetTPRR0, rc));
2433	}
2434	if (RT_SUCCESS(rc))
2435	{
2436	rc = PDMR3LdrGetSymbolR0Lazy(pVM, pDevIns->pReg->szR0Mod, pApicReg->pszGetTPRR0, &pVM->pdm.s.Apic.pfnGetTPRR0);
2437	AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szR0Mod, pApicReg->pszGetTPRR0, rc));
2438	}
2439	if (RT_SUCCESS(rc))
2440	{
2441	rc = PDMR3LdrGetSymbolR0Lazy(pVM, pDevIns->pReg->szR0Mod, pApicReg->pszWriteMSRR0, &pVM->pdm.s.Apic.pfnWriteMSRR0);
2442	AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szR0Mod, pApicReg->pszWriteMSRR0, rc));
2443	}
2444	if (RT_SUCCESS(rc))
2445	{
2446	rc = PDMR3LdrGetSymbolR0Lazy(pVM, pDevIns->pReg->szR0Mod, pApicReg->pszReadMSRR0, &pVM->pdm.s.Apic.pfnReadMSRR0);
2447	AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szR0Mod, pApicReg->pszReadMSRR0, rc));
2448	}
2449	if (RT_SUCCESS(rc))
2450	{
2451	rc = PDMR3LdrGetSymbolR0Lazy(pVM, pDevIns->pReg->szR0Mod, pApicReg->pszBusDeliverR0, &pVM->pdm.s.Apic.pfnBusDeliverR0);
2452	AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szR0Mod, pApicReg->pszBusDeliverR0, rc));
2453	}
2454	if (RT_SUCCESS(rc))
2455	{
2456	rc = PDMR3LdrGetSymbolR0Lazy(pVM, pDevIns->pReg->szR0Mod, pApicReg->pszLocalInterruptR0, &pVM->pdm.s.Apic.pfnLocalInterruptR0);
2457	AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szR0Mod, pApicReg->pszLocalInterruptR0, rc));
2458	}
2459	if (RT_FAILURE(rc))
2460	{
2461	LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
2462	return rc;
2463	}
2464	pVM->pdm.s.Apic.pDevInsR0 = PDMDEVINS_2_R0PTR(pDevIns);
2465	Assert(pVM->pdm.s.Apic.pDevInsR0);
2466	}
2467	else
2468	{
2469	pVM->pdm.s.Apic.pfnGetInterruptR0 = 0;
2470	pVM->pdm.s.Apic.pfnHasPendingIrqR0 = 0;
2471	pVM->pdm.s.Apic.pfnSetBaseR0 = 0;
2472	pVM->pdm.s.Apic.pfnGetBaseR0 = 0;
2473	pVM->pdm.s.Apic.pfnSetTPRR0 = 0;
2474	pVM->pdm.s.Apic.pfnGetTPRR0 = 0;
2475	pVM->pdm.s.Apic.pfnWriteMSRR0 = 0;
2476	pVM->pdm.s.Apic.pfnReadMSRR0 = 0;
2477	pVM->pdm.s.Apic.pfnBusDeliverR0 = 0;
2478	pVM->pdm.s.Apic.pfnLocalInterruptR0 = 0;
2479	pVM->pdm.s.Apic.pDevInsR0 = 0;
2480	}
2481
2482	/*
2483	* Initialize the HC bits.
2484	*/
2485	pVM->pdm.s.Apic.pDevInsR3 = pDevIns;
2486	pVM->pdm.s.Apic.pfnGetInterruptR3 = pApicReg->pfnGetInterruptR3;
2487	pVM->pdm.s.Apic.pfnHasPendingIrqR3 = pApicReg->pfnHasPendingIrqR3;
2488	pVM->pdm.s.Apic.pfnSetBaseR3 = pApicReg->pfnSetBaseR3;
2489	pVM->pdm.s.Apic.pfnGetBaseR3 = pApicReg->pfnGetBaseR3;
2490	pVM->pdm.s.Apic.pfnSetTPRR3 = pApicReg->pfnSetTPRR3;
2491	pVM->pdm.s.Apic.pfnGetTPRR3 = pApicReg->pfnGetTPRR3;
2492	pVM->pdm.s.Apic.pfnWriteMSRR3 = pApicReg->pfnWriteMSRR3;
2493	pVM->pdm.s.Apic.pfnReadMSRR3 = pApicReg->pfnReadMSRR3;
2494	pVM->pdm.s.Apic.pfnBusDeliverR3 = pApicReg->pfnBusDeliverR3;
2495	pVM->pdm.s.Apic.pfnLocalInterruptR3 = pApicReg->pfnLocalInterruptR3;
2496	Log(("PDM: Registered APIC device '%s'/%d pDevIns=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, pDevIns));
2497
2498	/* set the helper pointer and return. */
2499	*ppApicHlpR3 = &g_pdmR3DevApicHlp;
2500	LogFlow(("pdmR3DevHlp_APICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, VINF_SUCCESS));
2501	return VINF_SUCCESS;
2502	}
2503
2504
2505	/** @interface_method_impl{PDMDEVHLPR3,pfnIOAPICRegister} */
2506	static DECLCALLBACK(int) pdmR3DevHlp_IOAPICRegister(PPDMDEVINS pDevIns, PPDMIOAPICREG pIoApicReg, PCPDMIOAPICHLPR3 *ppIoApicHlpR3)
2507	{
2508	PDMDEV_ASSERT_DEVINS(pDevIns);
2509	VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
2510	LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: pIoApicReg=%p:{.u32Version=%#x, .pfnSetIrqR3=%p, .pszSetIrqRC=%p:{%s}, .pszSetIrqR0=%p:{%s}} ppIoApicHlpR3=%p\n",
2511	pDevIns->pReg->szName, pDevIns->iInstance, pIoApicReg, pIoApicReg->u32Version, pIoApicReg->pfnSetIrqR3,
2512	pIoApicReg->pszSetIrqRC, pIoApicReg->pszSetIrqRC, pIoApicReg->pszSetIrqR0, pIoApicReg->pszSetIrqR0, ppIoApicHlpR3));
2513
2514	/*
2515	* Validate input.
2516	*/
2517	if (pIoApicReg->u32Version != PDM_IOAPICREG_VERSION)
2518	{
2519	AssertMsgFailed(("u32Version=%#x expected %#x\n", pIoApicReg->u32Version, PDM_IOAPICREG_VERSION));
2520	LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc (version)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
2521	return VERR_INVALID_PARAMETER;
2522	}
2523	if (!pIoApicReg->pfnSetIrqR3)
2524	{
2525	Assert(pIoApicReg->pfnSetIrqR3);
2526	LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc (R3 callbacks)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
2527	return VERR_INVALID_PARAMETER;
2528	}
2529	if ( pIoApicReg->pszSetIrqRC
2530	&& !VALID_PTR(pIoApicReg->pszSetIrqRC))
2531	{
2532	Assert(VALID_PTR(pIoApicReg->pszSetIrqRC));
2533	LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc (GC callbacks)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
2534	return VERR_INVALID_PARAMETER;
2535	}
2536	if ( pIoApicReg->pszSetIrqR0
2537	&& !VALID_PTR(pIoApicReg->pszSetIrqR0))
2538	{
2539	Assert(VALID_PTR(pIoApicReg->pszSetIrqR0));
2540	LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc (GC callbacks)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
2541	return VERR_INVALID_PARAMETER;
2542	}
2543	if (!ppIoApicHlpR3)
2544	{
2545	Assert(ppIoApicHlpR3);
2546	LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc (ppApicHlp)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
2547	return VERR_INVALID_PARAMETER;
2548	}
2549
2550	/*
2551	* The I/O APIC requires the APIC to be present (hacks++).
2552	* If the I/O APIC does GC stuff so must the APIC.
2553	*/
2554	PVM pVM = pDevIns->Internal.s.pVMR3;
2555	if (!pVM->pdm.s.Apic.pDevInsR3)
2556	{
2557	AssertMsgFailed(("Configuration error / Init order error! No APIC!\n"));
2558	LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc (no APIC)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
2559	return VERR_INVALID_PARAMETER;
2560	}
2561	if ( pIoApicReg->pszSetIrqRC
2562	&& !pVM->pdm.s.Apic.pDevInsRC)
2563	{
2564	AssertMsgFailed(("Configuration error! APIC doesn't do GC, I/O APIC does!\n"));
2565	LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc (no GC APIC)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
2566	return VERR_INVALID_PARAMETER;
2567	}
2568
2569	/*
2570	* Only one I/O APIC device.
2571	*/
2572	if (pVM->pdm.s.IoApic.pDevInsR3)
2573	{
2574	AssertMsgFailed(("Only one ioapic device is supported!\n"));
2575	LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc (only one)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
2576	return VERR_INVALID_PARAMETER;
2577	}
2578
2579	/*
2580	* Resolve & initialize the GC bits.
2581	*/
2582	if (pIoApicReg->pszSetIrqRC)
2583	{
2584	int rc = PDMR3LdrGetSymbolRCLazy(pVM, pDevIns->pReg->szRCMod, pIoApicReg->pszSetIrqRC, &pVM->pdm.s.IoApic.pfnSetIrqRC);
2585	AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szRCMod, pIoApicReg->pszSetIrqRC, rc));
2586	if (RT_FAILURE(rc))
2587	{
2588	LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
2589	return rc;
2590	}
2591	pVM->pdm.s.IoApic.pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
2592	}
2593	else
2594	{
2595	pVM->pdm.s.IoApic.pDevInsRC = 0;
2596	pVM->pdm.s.IoApic.pfnSetIrqRC = 0;
2597	}
2598
2599	/*
2600	* Resolve & initialize the R0 bits.
2601	*/
2602	if (pIoApicReg->pszSetIrqR0)
2603	{
2604	int rc = PDMR3LdrGetSymbolR0Lazy(pVM, pDevIns->pReg->szR0Mod, pIoApicReg->pszSetIrqR0, &pVM->pdm.s.IoApic.pfnSetIrqR0);
2605	AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szR0Mod, pIoApicReg->pszSetIrqR0, rc));
2606	if (RT_FAILURE(rc))
2607	{
2608	LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
2609	return rc;
2610	}
2611	pVM->pdm.s.IoApic.pDevInsR0 = PDMDEVINS_2_R0PTR(pDevIns);
2612	Assert(pVM->pdm.s.IoApic.pDevInsR0);
2613	}
2614	else
2615	{
2616	pVM->pdm.s.IoApic.pfnSetIrqR0 = 0;
2617	pVM->pdm.s.IoApic.pDevInsR0 = 0;
2618	}
2619
2620	/*
2621	* Initialize the R3 bits.
2622	*/
2623	pVM->pdm.s.IoApic.pDevInsR3 = pDevIns;
2624	pVM->pdm.s.IoApic.pfnSetIrqR3 = pIoApicReg->pfnSetIrqR3;
2625	Log(("PDM: Registered I/O APIC device '%s'/%d pDevIns=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, pDevIns));
2626
2627	/* set the helper pointer and return. */
2628	*ppIoApicHlpR3 = &g_pdmR3DevIoApicHlp;
2629	LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, VINF_SUCCESS));
2630	return VINF_SUCCESS;
2631	}
2632
2633
2634	/** @interface_method_impl{PDMDEVHLPR3,pfnHPETRegister} */
2635	static DECLCALLBACK(int) pdmR3DevHlp_HPETRegister(PPDMDEVINS pDevIns, PPDMHPETREG pHpetReg, PCPDMHPETHLPR3 *ppHpetHlpR3)
2636	{
2637	PDMDEV_ASSERT_DEVINS(pDevIns);
2638	VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
2639	LogFlow(("pdmR3DevHlp_HPETRegister: caller='%s'/%d:\n"));
2640
2641	/*
2642	* Validate input.
2643	*/
2644	if (pHpetReg->u32Version != PDM_HPETREG_VERSION)
2645	{
2646	AssertMsgFailed(("u32Version=%#x expected %#x\n", pHpetReg->u32Version, PDM_HPETREG_VERSION));
2647	LogFlow(("pdmR3DevHlp_HPETRegister: caller='%s'/%d: returns %Rrc (version)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
2648	return VERR_INVALID_PARAMETER;
2649	}
2650
2651	if (!ppHpetHlpR3)
2652	{
2653	Assert(ppHpetHlpR3);
2654	LogFlow(("pdmR3DevHlp_HPETRegister: caller='%s'/%d: returns %Rrc (ppApicHlpR3)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
2655	return VERR_INVALID_PARAMETER;
2656	}
2657
2658	/* set the helper pointer and return. */
2659	*ppHpetHlpR3 = &g_pdmR3DevHpetHlp;
2660	LogFlow(("pdmR3DevHlp_HPETRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, VINF_SUCCESS));
2661	return VINF_SUCCESS;
2662	}
2663
2664
2665	/** @interface_method_impl{PDMDEVHLPR3,pfnDMACRegister} */
2666	static DECLCALLBACK(int) pdmR3DevHlp_DMACRegister(PPDMDEVINS pDevIns, PPDMDMACREG pDmacReg, PCPDMDMACHLP *ppDmacHlp)
2667	{
2668	PDMDEV_ASSERT_DEVINS(pDevIns);
2669	VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
2670	LogFlow(("pdmR3DevHlp_DMACRegister: caller='%s'/%d: pDmacReg=%p:{.u32Version=%#x, .pfnRun=%p, .pfnRegister=%p, .pfnReadMemory=%p, .pfnWriteMemory=%p, .pfnSetDREQ=%p, .pfnGetChannelMode=%p} ppDmacHlp=%p\n",
2671	pDevIns->pReg->szName, pDevIns->iInstance, pDmacReg, pDmacReg->u32Version, pDmacReg->pfnRun, pDmacReg->pfnRegister,
2672	pDmacReg->pfnReadMemory, pDmacReg->pfnWriteMemory, pDmacReg->pfnSetDREQ, pDmacReg->pfnGetChannelMode, ppDmacHlp));
2673
2674	/*
2675	* Validate input.
2676	*/
2677	if (pDmacReg->u32Version != PDM_DMACREG_VERSION)
2678	{
2679	AssertMsgFailed(("u32Version=%#x expected %#x\n", pDmacReg->u32Version,
2680	PDM_DMACREG_VERSION));
2681	LogFlow(("pdmR3DevHlp_DMACRegister: caller='%s'/%d: returns %Rrc (version)\n",
2682	pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
2683	return VERR_INVALID_PARAMETER;
2684	}
2685	if ( !pDmacReg->pfnRun
2686	\|\| !pDmacReg->pfnRegister
2687	\|\| !pDmacReg->pfnReadMemory
2688	\|\| !pDmacReg->pfnWriteMemory
2689	\|\| !pDmacReg->pfnSetDREQ
2690	\|\| !pDmacReg->pfnGetChannelMode)
2691	{
2692	Assert(pDmacReg->pfnRun);
2693	Assert(pDmacReg->pfnRegister);
2694	Assert(pDmacReg->pfnReadMemory);
2695	Assert(pDmacReg->pfnWriteMemory);
2696	Assert(pDmacReg->pfnSetDREQ);
2697	Assert(pDmacReg->pfnGetChannelMode);
2698	LogFlow(("pdmR3DevHlp_DMACRegister: caller='%s'/%d: returns %Rrc (callbacks)\n",
2699	pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
2700	return VERR_INVALID_PARAMETER;
2701	}
2702
2703	if (!ppDmacHlp)
2704	{
2705	Assert(ppDmacHlp);
2706	LogFlow(("pdmR3DevHlp_DMACRegister: caller='%s'/%d: returns %Rrc (ppDmacHlp)\n",
2707	pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
2708	return VERR_INVALID_PARAMETER;
2709	}
2710
2711	/*
2712	* Only one DMA device.
2713	*/
2714	PVM pVM = pDevIns->Internal.s.pVMR3;
2715	if (pVM->pdm.s.pDmac)
2716	{
2717	AssertMsgFailed(("Only one DMA device is supported!\n"));
2718	LogFlow(("pdmR3DevHlp_DMACRegister: caller='%s'/%d: returns %Rrc\n",
2719	pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
2720	return VERR_INVALID_PARAMETER;
2721	}
2722
2723	/*
2724	* Allocate and initialize pci bus structure.
2725	*/
2726	int rc = VINF_SUCCESS;
2727	PPDMDMAC pDmac = (PPDMDMAC)MMR3HeapAlloc(pDevIns->Internal.s.pVMR3, MM_TAG_PDM_DEVICE, sizeof(*pDmac));
2728	if (pDmac)
2729	{
2730	pDmac->pDevIns = pDevIns;
2731	pDmac->Reg = *pDmacReg;
2732	pVM->pdm.s.pDmac = pDmac;
2733
2734	/* set the helper pointer. */
2735	*ppDmacHlp = &g_pdmR3DevDmacHlp;
2736	Log(("PDM: Registered DMAC device '%s'/%d pDevIns=%p\n",
2737	pDevIns->pReg->szName, pDevIns->iInstance, pDevIns));
2738	}
2739	else
2740	rc = VERR_NO_MEMORY;
2741
2742	LogFlow(("pdmR3DevHlp_DMACRegister: caller='%s'/%d: returns %Rrc\n",
2743	pDevIns->pReg->szName, pDevIns->iInstance, rc));
2744	return rc;
2745	}
2746
2747
2748	/**
2749	* @copydoc PDMDEVHLPR3::pfnRegisterVMMDevHeap
2750	*/
2751	static DECLCALLBACK(int) pdmR3DevHlp_RegisterVMMDevHeap(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, RTR3PTR pvHeap, unsigned cbSize)
2752	{
2753	PDMDEV_ASSERT_DEVINS(pDevIns);
2754	VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
2755
2756	int rc = PDMR3RegisterVMMDevHeap(pDevIns->Internal.s.pVMR3, GCPhys, pvHeap, cbSize);
2757	return rc;
2758	}
2759
2760
2761	/**
2762	* @copydoc PDMDEVHLPR3::pfnUnregisterVMMDevHeap
2763	*/
2764	static DECLCALLBACK(int) pdmR3DevHlp_UnregisterVMMDevHeap(PPDMDEVINS pDevIns, RTGCPHYS GCPhys)
2765	{
2766	PDMDEV_ASSERT_DEVINS(pDevIns);
2767	VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
2768
2769	int rc = PDMR3UnregisterVMMDevHeap(pDevIns->Internal.s.pVMR3, GCPhys);
2770	return rc;
2771	}
2772
2773
2774	/** @interface_method_impl{PDMDEVHLPR3,pfnVMReset} */
2775	static DECLCALLBACK(int) pdmR3DevHlp_VMReset(PPDMDEVINS pDevIns)
2776	{
2777	PDMDEV_ASSERT_DEVINS(pDevIns);
2778	PVM pVM = pDevIns->Internal.s.pVMR3;
2779	VM_ASSERT_EMT(pVM);
2780	LogFlow(("pdmR3DevHlp_VMReset: caller='%s'/%d: VM_FF_RESET %d -> 1\n",
2781	pDevIns->pReg->szName, pDevIns->iInstance, VM_FF_ISSET(pVM, VM_FF_RESET)));
2782
2783	/*
2784	* We postpone this operation because we're likely to be inside a I/O instruction
2785	* and the EIP will be updated when we return.
2786	* We still return VINF_EM_RESET to break out of any execution loops and force FF evaluation.
2787	*/
2788	bool fHaltOnReset;
2789	int rc = CFGMR3QueryBool(CFGMR3GetChild(CFGMR3GetRoot(pVM), "PDM"), "HaltOnReset", &fHaltOnReset);
2790	if (RT_SUCCESS(rc) && fHaltOnReset)
2791	{
2792	Log(("pdmR3DevHlp_VMReset: Halt On Reset!\n"));
2793	rc = VINF_EM_HALT;
2794	}
2795	else
2796	{
2797	VM_FF_SET(pVM, VM_FF_RESET);
2798	rc = VINF_EM_RESET;
2799	}
2800
2801	LogFlow(("pdmR3DevHlp_VMReset: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
2802	return rc;
2803	}
2804
2805
2806	/** @interface_method_impl{PDMDEVHLPR3,pfnVMSuspend} */
2807	static DECLCALLBACK(int) pdmR3DevHlp_VMSuspend(PPDMDEVINS pDevIns)
2808	{
2809	int rc;
2810	PDMDEV_ASSERT_DEVINS(pDevIns);
2811	PVM pVM = pDevIns->Internal.s.pVMR3;
2812	VM_ASSERT_EMT(pVM);
2813	LogFlow(("pdmR3DevHlp_VMSuspend: caller='%s'/%d:\n",
2814	pDevIns->pReg->szName, pDevIns->iInstance));
2815
2816	if (pVM->cCpus > 1)
2817	{
2818	/* We own the IOM lock here and could cause a deadlock by waiting for a VCPU that is blocking on the IOM lock. */
2819	rc = VMR3ReqCallNoWaitU(pVM->pUVM, VMCPUID_ANY_QUEUE, (PFNRT)VMR3Suspend, 1, pVM);
2820	AssertRC(rc);
2821	rc = VINF_EM_SUSPEND;
2822	}
2823	else
2824	rc = VMR3Suspend(pVM);
2825
2826	LogFlow(("pdmR3DevHlp_VMSuspend: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
2827	return rc;
2828	}
2829
2830
2831	/** @interface_method_impl{PDMDEVHLPR3,pfnVMPowerOff} */
2832	static DECLCALLBACK(int) pdmR3DevHlp_VMPowerOff(PPDMDEVINS pDevIns)
2833	{
2834	int rc;
2835	PDMDEV_ASSERT_DEVINS(pDevIns);
2836	PVM pVM = pDevIns->Internal.s.pVMR3;
2837	VM_ASSERT_EMT(pVM);
2838	LogFlow(("pdmR3DevHlp_VMPowerOff: caller='%s'/%d:\n",
2839	pDevIns->pReg->szName, pDevIns->iInstance));
2840
2841	if (pVM->cCpus > 1)
2842	{
2843	/* We own the IOM lock here and could cause a deadlock by waiting for a VCPU that is blocking on the IOM lock. */
2844	rc = VMR3ReqCallNoWaitU(pVM->pUVM, VMCPUID_ANY_QUEUE, (PFNRT)VMR3PowerOff, 1, pVM);
2845	AssertRC(rc);
2846	/* Set the VCPU state to stopped here as well to make sure no
2847	* inconsistency with the EM state occurs.
2848	*/
2849	VMCPU_SET_STATE(VMMGetCpu(pVM), VMCPUSTATE_STOPPED);
2850	rc = VINF_EM_OFF;
2851	}
2852	else
2853	rc = VMR3PowerOff(pVM);
2854
2855	LogFlow(("pdmR3DevHlp_VMPowerOff: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
2856	return rc;
2857	}
2858
2859
2860	/** @interface_method_impl{PDMDEVHLPR3,pfnA20IsEnabled} */
2861	static DECLCALLBACK(bool) pdmR3DevHlp_A20IsEnabled(PPDMDEVINS pDevIns)
2862	{
2863	PDMDEV_ASSERT_DEVINS(pDevIns);
2864	VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
2865
2866	bool fRc = PGMPhysIsA20Enabled(VMMGetCpu(pDevIns->Internal.s.pVMR3));
2867
2868	LogFlow(("pdmR3DevHlp_A20IsEnabled: caller='%s'/%d: returns %d\n", pDevIns->pReg->szName, pDevIns->iInstance, fRc));
2869	return fRc;
2870	}
2871
2872
2873	/** @interface_method_impl{PDMDEVHLPR3,pfnA20Set} */
2874	static DECLCALLBACK(void) pdmR3DevHlp_A20Set(PPDMDEVINS pDevIns, bool fEnable)
2875	{
2876	PDMDEV_ASSERT_DEVINS(pDevIns);
2877	VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
2878	LogFlow(("pdmR3DevHlp_A20Set: caller='%s'/%d: fEnable=%d\n", pDevIns->pReg->szName, pDevIns->iInstance, fEnable));
2879	PGMR3PhysSetA20(VMMGetCpu(pDevIns->Internal.s.pVMR3), fEnable);
2880	}
2881
2882
2883	/** @interface_method_impl{PDMDEVHLPR3,pfnGetCpuId} */
2884	static DECLCALLBACK(void) pdmR3DevHlp_GetCpuId(PPDMDEVINS pDevIns, uint32_t iLeaf,
2885	uint32_t pEax, uint32_t pEbx, uint32_t pEcx, uint32_t pEdx)
2886	{
2887	PDMDEV_ASSERT_DEVINS(pDevIns);
2888	VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
2889
2890	LogFlow(("pdmR3DevHlp_GetCpuId: caller='%s'/%d: iLeaf=%d pEax=%p pEbx=%p pEcx=%p pEdx=%p\n",
2891	pDevIns->pReg->szName, pDevIns->iInstance, iLeaf, pEax, pEbx, pEcx, pEdx));
2892	AssertPtr(pEax); AssertPtr(pEbx); AssertPtr(pEcx); AssertPtr(pEdx);
2893
2894	CPUMGetGuestCpuId(VMMGetCpu(pDevIns->Internal.s.pVMR3), iLeaf, pEax, pEbx, pEcx, pEdx);
2895
2896	LogFlow(("pdmR3DevHlp_GetCpuId: caller='%s'/%d: returns void - pEax=%#x pEbx=%#x pEcx=%#x pEdx=%#x\n",
2897	pDevIns->pReg->szName, pDevIns->iInstance, pEax, pEbx, pEcx, pEdx));
2898	}
2899
2900
2901	/**
2902	* The device helper structure for trusted devices.
2903	*/
2904	const PDMDEVHLPR3 g_pdmR3DevHlpTrusted =
2905	{
2906	PDM_DEVHLPR3_VERSION,
2907	pdmR3DevHlp_IOPortRegister,
2908	pdmR3DevHlp_IOPortRegisterRC,
2909	pdmR3DevHlp_IOPortRegisterR0,
2910	pdmR3DevHlp_IOPortDeregister,
2911	pdmR3DevHlp_MMIORegister,
2912	pdmR3DevHlp_MMIORegisterRC,
2913	pdmR3DevHlp_MMIORegisterR0,
2914	pdmR3DevHlp_MMIODeregister,
2915	pdmR3DevHlp_MMIO2Register,
2916	pdmR3DevHlp_MMIO2Deregister,
2917	pdmR3DevHlp_MMIO2Map,
2918	pdmR3DevHlp_MMIO2Unmap,
2919	pdmR3DevHlp_MMHyperMapMMIO2,
2920	pdmR3DevHlp_MMIO2MapKernel,
2921	pdmR3DevHlp_ROMRegister,
2922	pdmR3DevHlp_ROMProtectShadow,
2923	pdmR3DevHlp_SSMRegister,
2924	pdmR3DevHlp_TMTimerCreate,
2925	pdmR3DevHlp_TMUtcNow,
2926	pdmR3DevHlp_PhysRead,
2927	pdmR3DevHlp_PhysWrite,
2928	pdmR3DevHlp_PhysGCPhys2CCPtr,
2929	pdmR3DevHlp_PhysGCPhys2CCPtrReadOnly,
2930	pdmR3DevHlp_PhysReleasePageMappingLock,
2931	pdmR3DevHlp_PhysReadGCVirt,
2932	pdmR3DevHlp_PhysWriteGCVirt,
2933	pdmR3DevHlp_PhysGCPtr2GCPhys,
2934	pdmR3DevHlp_MMHeapAlloc,
2935	pdmR3DevHlp_MMHeapAllocZ,
2936	pdmR3DevHlp_MMHeapFree,
2937	pdmR3DevHlp_VMState,
2938	pdmR3DevHlp_VMTeleportedAndNotFullyResumedYet,
2939	pdmR3DevHlp_VMSetError,
2940	pdmR3DevHlp_VMSetErrorV,
2941	pdmR3DevHlp_VMSetRuntimeError,
2942	pdmR3DevHlp_VMSetRuntimeErrorV,
2943	pdmR3DevHlp_DBGFStopV,
2944	pdmR3DevHlp_DBGFInfoRegister,
2945	pdmR3DevHlp_STAMRegister,
2946	pdmR3DevHlp_STAMRegisterF,
2947	pdmR3DevHlp_STAMRegisterV,
2948	pdmR3DevHlp_PCIRegister,
2949	pdmR3DevHlp_PCIIORegionRegister,
2950	pdmR3DevHlp_PCISetConfigCallbacks,
2951	pdmR3DevHlp_PCISetIrq,
2952	pdmR3DevHlp_PCISetIrqNoWait,
2953	pdmR3DevHlp_ISASetIrq,
2954	pdmR3DevHlp_ISASetIrqNoWait,
2955	pdmR3DevHlp_DriverAttach,
2956	pdmR3DevHlp_QueueCreate,
2957	pdmR3DevHlp_CritSectInit,
2958	pdmR3DevHlp_ThreadCreate,
2959	pdmR3DevHlp_SetAsyncNotification,
2960	pdmR3DevHlp_AsyncNotificationCompleted,
2961	pdmR3DevHlp_RTCRegister,
2962	pdmR3DevHlp_PCIBusRegister,
2963	pdmR3DevHlp_PICRegister,
2964	pdmR3DevHlp_APICRegister,
2965	pdmR3DevHlp_IOAPICRegister,
2966	pdmR3DevHlp_HPETRegister,
2967	pdmR3DevHlp_DMACRegister,
2968	pdmR3DevHlp_DMARegister,
2969	pdmR3DevHlp_DMAReadMemory,
2970	pdmR3DevHlp_DMAWriteMemory,
2971	pdmR3DevHlp_DMASetDREQ,
2972	pdmR3DevHlp_DMAGetChannelMode,
2973	pdmR3DevHlp_DMASchedule,
2974	pdmR3DevHlp_CMOSWrite,
2975	pdmR3DevHlp_CMOSRead,
2976	pdmR3DevHlp_AssertEMT,
2977	pdmR3DevHlp_AssertOther,
2978	pdmR3DevHlp_LdrGetRCInterfaceSymbols,
2979	pdmR3DevHlp_LdrGetR0InterfaceSymbols,
2980	pdmR3DevHlp_CallR0,
2981	0,
2982	0,
2983	0,
2984	0,
2985	0,
2986	0,
2987	0,
2988	0,
2989	0,
2990	0,
2991	pdmR3DevHlp_GetVM,
2992	pdmR3DevHlp_GetVMCPU,
2993	pdmR3DevHlp_RegisterVMMDevHeap,
2994	pdmR3DevHlp_UnregisterVMMDevHeap,
2995	pdmR3DevHlp_VMReset,
2996	pdmR3DevHlp_VMSuspend,
2997	pdmR3DevHlp_VMPowerOff,
2998	pdmR3DevHlp_A20IsEnabled,
2999	pdmR3DevHlp_A20Set,
3000	pdmR3DevHlp_GetCpuId,
3001	PDM_DEVHLPR3_VERSION /* the end */
3002	};
3003
3004
3005
3006
3007	/** @interface_method_impl{PDMDEVHLPR3,pfnGetVM} */
3008	static DECLCALLBACK(PVM) pdmR3DevHlp_Untrusted_GetVM(PPDMDEVINS pDevIns)
3009	{
3010	PDMDEV_ASSERT_DEVINS(pDevIns);
3011	AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance));
3012	return NULL;
3013	}
3014
3015
3016	/** @interface_method_impl{PDMDEVHLPR3,pfnGetVMCPU} */
3017	static DECLCALLBACK(PVMCPU) pdmR3DevHlp_Untrusted_GetVMCPU(PPDMDEVINS pDevIns)
3018	{
3019	PDMDEV_ASSERT_DEVINS(pDevIns);
3020	AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance));
3021	return NULL;
3022	}
3023
3024
3025	/** @interface_method_impl{PDMDEVHLPR3,pfnRegisterVMMDevHeap} */
3026	static DECLCALLBACK(int) pdmR3DevHlp_Untrusted_RegisterVMMDevHeap(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, RTR3PTR pvHeap, unsigned cbSize)
3027	{
3028	PDMDEV_ASSERT_DEVINS(pDevIns);
3029	AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance));
3030	return VERR_ACCESS_DENIED;
3031	}
3032
3033
3034	/** @interface_method_impl{PDMDEVHLPR3,pfnUnregisterVMMDevHeap} */
3035	static DECLCALLBACK(int) pdmR3DevHlp_Untrusted_UnregisterVMMDevHeap(PPDMDEVINS pDevIns, RTGCPHYS GCPhys)
3036	{
3037	PDMDEV_ASSERT_DEVINS(pDevIns);
3038	AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance));
3039	return VERR_ACCESS_DENIED;
3040	}
3041
3042
3043	/** @interface_method_impl{PDMDEVHLPR3,pfnVMReset} */
3044	static DECLCALLBACK(int) pdmR3DevHlp_Untrusted_VMReset(PPDMDEVINS pDevIns)
3045	{
3046	PDMDEV_ASSERT_DEVINS(pDevIns);
3047	AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance));
3048	return VERR_ACCESS_DENIED;
3049	}
3050
3051
3052	/** @interface_method_impl{PDMDEVHLPR3,pfnVMSuspend} */
3053	static DECLCALLBACK(int) pdmR3DevHlp_Untrusted_VMSuspend(PPDMDEVINS pDevIns)
3054	{
3055	PDMDEV_ASSERT_DEVINS(pDevIns);
3056	AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance));
3057	return VERR_ACCESS_DENIED;
3058	}
3059
3060
3061	/** @interface_method_impl{PDMDEVHLPR3,pfnVMPowerOff} */
3062	static DECLCALLBACK(int) pdmR3DevHlp_Untrusted_VMPowerOff(PPDMDEVINS pDevIns)
3063	{
3064	PDMDEV_ASSERT_DEVINS(pDevIns);
3065	AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance));
3066	return VERR_ACCESS_DENIED;
3067	}
3068
3069
3070	/** @interface_method_impl{PDMDEVHLPR3,pfnA20IsEnabled} */
3071	static DECLCALLBACK(bool) pdmR3DevHlp_Untrusted_A20IsEnabled(PPDMDEVINS pDevIns)
3072	{
3073	PDMDEV_ASSERT_DEVINS(pDevIns);
3074	AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance));
3075	return false;
3076	}
3077
3078
3079	/** @interface_method_impl{PDMDEVHLPR3,pfnA20Set} */
3080	static DECLCALLBACK(void) pdmR3DevHlp_Untrusted_A20Set(PPDMDEVINS pDevIns, bool fEnable)
3081	{
3082	PDMDEV_ASSERT_DEVINS(pDevIns);
3083	AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance));
3084	NOREF(fEnable);
3085	}
3086
3087
3088	/** @interface_method_impl{PDMDEVHLPR3,pfnGetCpuId} */
3089	static DECLCALLBACK(void) pdmR3DevHlp_Untrusted_GetCpuId(PPDMDEVINS pDevIns, uint32_t iLeaf,
3090	uint32_t pEax, uint32_t pEbx, uint32_t pEcx, uint32_t pEdx)
3091	{
3092	PDMDEV_ASSERT_DEVINS(pDevIns);
3093	AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance));
3094	}
3095
3096
3097	/**
3098	* The device helper structure for non-trusted devices.
3099	*/
3100	const PDMDEVHLPR3 g_pdmR3DevHlpUnTrusted =
3101	{
3102	PDM_DEVHLPR3_VERSION,
3103	pdmR3DevHlp_IOPortRegister,
3104	pdmR3DevHlp_IOPortRegisterRC,
3105	pdmR3DevHlp_IOPortRegisterR0,
3106	pdmR3DevHlp_IOPortDeregister,
3107	pdmR3DevHlp_MMIORegister,
3108	pdmR3DevHlp_MMIORegisterRC,
3109	pdmR3DevHlp_MMIORegisterR0,
3110	pdmR3DevHlp_MMIODeregister,
3111	pdmR3DevHlp_MMIO2Register,
3112	pdmR3DevHlp_MMIO2Deregister,
3113	pdmR3DevHlp_MMIO2Map,
3114	pdmR3DevHlp_MMIO2Unmap,
3115	pdmR3DevHlp_MMHyperMapMMIO2,
3116	pdmR3DevHlp_MMIO2MapKernel,
3117	pdmR3DevHlp_ROMRegister,
3118	pdmR3DevHlp_ROMProtectShadow,
3119	pdmR3DevHlp_SSMRegister,
3120	pdmR3DevHlp_TMTimerCreate,
3121	pdmR3DevHlp_TMUtcNow,
3122	pdmR3DevHlp_PhysRead,
3123	pdmR3DevHlp_PhysWrite,
3124	pdmR3DevHlp_PhysGCPhys2CCPtr,
3125	pdmR3DevHlp_PhysGCPhys2CCPtrReadOnly,
3126	pdmR3DevHlp_PhysReleasePageMappingLock,
3127	pdmR3DevHlp_PhysReadGCVirt,
3128	pdmR3DevHlp_PhysWriteGCVirt,
3129	pdmR3DevHlp_PhysGCPtr2GCPhys,
3130	pdmR3DevHlp_MMHeapAlloc,
3131	pdmR3DevHlp_MMHeapAllocZ,
3132	pdmR3DevHlp_MMHeapFree,
3133	pdmR3DevHlp_VMState,
3134	pdmR3DevHlp_VMTeleportedAndNotFullyResumedYet,
3135	pdmR3DevHlp_VMSetError,
3136	pdmR3DevHlp_VMSetErrorV,
3137	pdmR3DevHlp_VMSetRuntimeError,
3138	pdmR3DevHlp_VMSetRuntimeErrorV,
3139	pdmR3DevHlp_DBGFStopV,
3140	pdmR3DevHlp_DBGFInfoRegister,
3141	pdmR3DevHlp_STAMRegister,
3142	pdmR3DevHlp_STAMRegisterF,
3143	pdmR3DevHlp_STAMRegisterV,
3144	pdmR3DevHlp_PCIRegister,
3145	pdmR3DevHlp_PCIIORegionRegister,
3146	pdmR3DevHlp_PCISetConfigCallbacks,
3147	pdmR3DevHlp_PCISetIrq,
3148	pdmR3DevHlp_PCISetIrqNoWait,
3149	pdmR3DevHlp_ISASetIrq,
3150	pdmR3DevHlp_ISASetIrqNoWait,
3151	pdmR3DevHlp_DriverAttach,
3152	pdmR3DevHlp_QueueCreate,
3153	pdmR3DevHlp_CritSectInit,
3154	pdmR3DevHlp_ThreadCreate,
3155	pdmR3DevHlp_SetAsyncNotification,
3156	pdmR3DevHlp_AsyncNotificationCompleted,
3157	pdmR3DevHlp_RTCRegister,
3158	pdmR3DevHlp_PCIBusRegister,
3159	pdmR3DevHlp_PICRegister,
3160	pdmR3DevHlp_APICRegister,
3161	pdmR3DevHlp_IOAPICRegister,
3162	pdmR3DevHlp_HPETRegister,
3163	pdmR3DevHlp_DMACRegister,
3164	pdmR3DevHlp_DMARegister,
3165	pdmR3DevHlp_DMAReadMemory,
3166	pdmR3DevHlp_DMAWriteMemory,
3167	pdmR3DevHlp_DMASetDREQ,
3168	pdmR3DevHlp_DMAGetChannelMode,
3169	pdmR3DevHlp_DMASchedule,
3170	pdmR3DevHlp_CMOSWrite,
3171	pdmR3DevHlp_CMOSRead,
3172	pdmR3DevHlp_AssertEMT,
3173	pdmR3DevHlp_AssertOther,
3174	pdmR3DevHlp_LdrGetRCInterfaceSymbols,
3175	pdmR3DevHlp_LdrGetR0InterfaceSymbols,
3176	pdmR3DevHlp_CallR0,
3177	0,
3178	0,
3179	0,
3180	0,
3181	0,
3182	0,
3183	0,
3184	0,
3185	0,
3186	0,
3187	pdmR3DevHlp_Untrusted_GetVM,
3188	pdmR3DevHlp_Untrusted_GetVMCPU,
3189	pdmR3DevHlp_Untrusted_RegisterVMMDevHeap,
3190	pdmR3DevHlp_Untrusted_UnregisterVMMDevHeap,
3191	pdmR3DevHlp_Untrusted_VMReset,
3192	pdmR3DevHlp_Untrusted_VMSuspend,
3193	pdmR3DevHlp_Untrusted_VMPowerOff,
3194	pdmR3DevHlp_Untrusted_A20IsEnabled,
3195	pdmR3DevHlp_Untrusted_A20Set,
3196	pdmR3DevHlp_Untrusted_GetCpuId,
3197	PDM_DEVHLPR3_VERSION /* the end */
3198	};
3199
3200
3201
3202	/**
3203	* Queue consumer callback for internal component.
3204	*
3205	* @returns Success indicator.
3206	* If false the item will not be removed and the flushing will stop.
3207	* @param pVM The VM handle.
3208	* @param pItem The item to consume. Upon return this item will be freed.
3209	*/
3210	DECLCALLBACK(bool) pdmR3DevHlpQueueConsumer(PVM pVM, PPDMQUEUEITEMCORE pItem)
3211	{
3212	PPDMDEVHLPTASK pTask = (PPDMDEVHLPTASK)pItem;
3213	LogFlow(("pdmR3DevHlpQueueConsumer: enmOp=%d pDevIns=%p\n", pTask->enmOp, pTask->pDevInsR3));
3214	switch (pTask->enmOp)
3215	{
3216	case PDMDEVHLPTASKOP_ISA_SET_IRQ:
3217	PDMIsaSetIrq(pVM, pTask->u.SetIRQ.iIrq, pTask->u.SetIRQ.iLevel);
3218	break;
3219
3220	case PDMDEVHLPTASKOP_PCI_SET_IRQ:
3221	pdmR3DevHlp_PCISetIrq(pTask->pDevInsR3, pTask->u.SetIRQ.iIrq, pTask->u.SetIRQ.iLevel);
3222	break;
3223
3224	case PDMDEVHLPTASKOP_IOAPIC_SET_IRQ:
3225	PDMIoApicSetIrq(pVM, pTask->u.SetIRQ.iIrq, pTask->u.SetIRQ.iLevel);
3226	break;
3227
3228	default:
3229	AssertReleaseMsgFailed(("Invalid operation %d\n", pTask->enmOp));
3230	break;
3231	}
3232	return true;
3233	}
3234
3235	/** @} */

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

source: vbox/trunk/src/VBox/VMM/PDMDevHlp.cpp@ 29566

Download in other formats: