VirtualBox

source: vbox/trunk/src/VBox/Devices/testcase/tstDevicePdmDevHlp.cpp@ 82903

Last change on this file since 82903 was 82903, checked in by vboxsync, 5 years ago

Devices/tstDevice: Working on restoring the old state of the device testbench [scm fix]
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 153.1 KB
Line 
1/* $Id: tstDevicePdmDevHlp.cpp 82903 2020-01-29 10:05:36Z vboxsync $ */
2/** @file
3 * tstDevice - Test framework for PDM devices/drivers, PDM helper implementation.
4 */
5
6/*
7 * Copyright (C) 2017-2019 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_DEFAULT /** @todo */
23#include <VBox/types.h>
24#include <VBox/version.h>
25#include <VBox/vmm/pdmpci.h>
26
27#include <iprt/assert.h>
28#include <iprt/mem.h>
29
30#include "tstDeviceInternal.h"
31
32
33/*********************************************************************************************************************************
34* Defined Constants And Macros *
35*********************************************************************************************************************************/
36
37/** @def PDMDEV_ASSERT_DEVINS
38 * Asserts the validity of the device instance.
39 */
40#ifdef VBOX_STRICT
41# define PDMDEV_ASSERT_DEVINS(pDevIns) \
42 do { \
43 AssertPtr(pDevIns); \
44 Assert(pDevIns->u32Version == PDM_DEVINS_VERSION); \
45 Assert(pDevIns->CTX_SUFF(pvInstanceDataFor) == (void *)&pDevIns->achInstanceData[0]); \
46 } while (0)
47#else
48# define PDMDEV_ASSERT_DEVINS(pDevIns) do { } while (0)
49#endif
50
51
52/** Frequency of the real clock. */
53#define TMCLOCK_FREQ_REAL UINT32_C(1000)
54/** Frequency of the virtual clock. */
55#define TMCLOCK_FREQ_VIRTUAL UINT32_C(1000000000)
56
57
58/*********************************************************************************************************************************
59* Structures and Typedefs *
60*********************************************************************************************************************************/
61
62
63
64/*********************************************************************************************************************************
65* Global Variables *
66*********************************************************************************************************************************/
67
68
69
70/*********************************************************************************************************************************
71* Internal Functions *
72*********************************************************************************************************************************/
73
74
75/**
76 * Resolves a path reference to a configuration item.
77 *
78 * @returns VBox status code.
79 * @param paDevCfg The array of config items.
80 * @param pszName Name of a byte string value.
81 * @param ppItem Where to store the pointer to the item.
82 */
83static int tstDev_CfgmR3ResolveItem(PCTSTDEVCFGITEM paDevCfg, const char *pszName, PCTSTDEVCFGITEM *ppItem)
84{
85 *ppItem = NULL;
86 if (!paDevCfg)
87 return VERR_CFGM_VALUE_NOT_FOUND;
88
89 size_t cchName = strlen(pszName);
90 PCTSTDEVCFGITEM pDevCfgItem = paDevCfg;
91 while (pDevCfgItem->pszKey != NULL)
92 {
93 size_t cchKey = strlen(pDevCfgItem->pszKey);
94 if (cchName == cchKey)
95 {
96 int iDiff = memcmp(pszName, pDevCfgItem->pszKey, cchName);
97 if (iDiff <= 0)
98 {
99 if (iDiff != 0)
100 break;
101 *ppItem = pDevCfgItem;
102 return VINF_SUCCESS;
103 }
104 }
105
106 /* next */
107 pDevCfgItem++;
108 }
109 return VERR_CFGM_VALUE_NOT_FOUND;
110}
111
112
113/** @interface_method_impl{PDMDEVHLPR3,pfnIoPortCreateEx} */
114static DECLCALLBACK(int) pdmR3DevHlp_IoPortCreateEx(PPDMDEVINS pDevIns, RTIOPORT cPorts, uint32_t fFlags, PPDMPCIDEV pPciDev,
115 uint32_t iPciRegion, PFNIOMIOPORTNEWOUT pfnOut, PFNIOMIOPORTNEWIN pfnIn,
116 PFNIOMIOPORTNEWOUTSTRING pfnOutStr, PFNIOMIOPORTNEWINSTRING pfnInStr, RTR3PTR pvUser,
117 const char *pszDesc, PCIOMIOPORTDESC paExtDescs, PIOMIOPORTHANDLE phIoPorts)
118{
119 PDMDEV_ASSERT_DEVINS(pDevIns);
120 LogFlow(("pdmR3DevHlp_IoPortCreateEx: caller='%s'/%d: cPorts=%#x fFlags=%#x pPciDev=%p iPciRegion=%#x pfnOut=%p pfnIn=%p pfnOutStr=%p pfnInStr=%p pvUser=%p pszDesc=%p:{%s} paExtDescs=%p phIoPorts=%p\n",
121 pDevIns->pReg->szName, pDevIns->iInstance, cPorts, fFlags, pPciDev, iPciRegion, pfnOut, pfnIn, pfnOutStr, pfnInStr,
122 pvUser, pszDesc, pszDesc, paExtDescs, phIoPorts));
123
124 int rc = VERR_NOT_IMPLEMENTED;
125 AssertFailed();
126
127 LogFlow(("pdmR3DevHlp_IoPortCreateEx: caller='%s'/%d: returns %Rrc (*phIoPorts=%#x)\n",
128 pDevIns->pReg->szName, pDevIns->iInstance, rc, *phIoPorts));
129 return rc;
130}
131
132
133/** @interface_method_impl{PDMDEVHLPR3,pfnIoPortMap} */
134static DECLCALLBACK(int) pdmR3DevHlp_IoPortMap(PPDMDEVINS pDevIns, IOMIOPORTHANDLE hIoPorts, RTIOPORT Port)
135{
136 PDMDEV_ASSERT_DEVINS(pDevIns);
137 LogFlow(("pdmR3DevHlp_IoPortMap: caller='%s'/%d: hIoPorts=%#x Port=%#x\n", pDevIns->pReg->szName, pDevIns->iInstance, hIoPorts, Port));
138
139 int rc = VERR_NOT_IMPLEMENTED;
140 AssertFailed();
141
142 LogFlow(("pdmR3DevHlp_IoPortMap: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
143 return rc;
144}
145
146
147/** @interface_method_impl{PDMDEVHLPR3,pfnIoPortUnmap} */
148static DECLCALLBACK(int) pdmR3DevHlp_IoPortUnmap(PPDMDEVINS pDevIns, IOMIOPORTHANDLE hIoPorts)
149{
150 PDMDEV_ASSERT_DEVINS(pDevIns);
151 LogFlow(("pdmR3DevHlp_IoPortMap: caller='%s'/%d: hIoPorts=%#x\n", pDevIns->pReg->szName, pDevIns->iInstance, hIoPorts));
152
153 int rc = VERR_NOT_IMPLEMENTED;
154 AssertFailed();
155
156 LogFlow(("pdmR3DevHlp_IoPortMap: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
157 return rc;
158}
159
160
161/** @interface_method_impl{PDMDEVHLPR3,pfnIoPortGetMappingAddress} */
162static DECLCALLBACK(uint32_t) pdmR3DevHlp_IoPortGetMappingAddress(PPDMDEVINS pDevIns, IOMIOPORTHANDLE hIoPorts)
163{
164 PDMDEV_ASSERT_DEVINS(pDevIns);
165 LogFlow(("pdmR3DevHlp_IoPortGetMappingAddress: caller='%s'/%d: hIoPorts=%#x\n", pDevIns->pReg->szName, pDevIns->iInstance, hIoPorts));
166
167 uint32_t uAddress = 0;
168 AssertFailed();
169
170 LogFlow(("pdmR3DevHlp_IoPortGetMappingAddress: caller='%s'/%d: returns %#RX32\n", pDevIns->pReg->szName, pDevIns->iInstance, uAddress));
171 return uAddress;
172}
173
174
175/** @interface_method_impl{PDMDEVHLPR3,pfnMmioCreateEx} */
176static DECLCALLBACK(int) pdmR3DevHlp_MmioCreateEx(PPDMDEVINS pDevIns, RTGCPHYS cbRegion,
177 uint32_t fFlags, PPDMPCIDEV pPciDev, uint32_t iPciRegion,
178 PFNIOMMMIONEWWRITE pfnWrite, PFNIOMMMIONEWREAD pfnRead, PFNIOMMMIONEWFILL pfnFill,
179 void *pvUser, const char *pszDesc, PIOMMMIOHANDLE phRegion)
180{
181 PDMDEV_ASSERT_DEVINS(pDevIns);
182 LogFlow(("pdmR3DevHlp_MmioCreateEx: caller='%s'/%d: cbRegion=%#RGp fFlags=%#x pPciDev=%p iPciRegion=%#x pfnWrite=%p pfnRead=%p pfnFill=%p pvUser=%p pszDesc=%p:{%s} phRegion=%p\n",
183 pDevIns->pReg->szName, pDevIns->iInstance, cbRegion, fFlags, pPciDev, iPciRegion, pfnWrite, pfnRead, pfnFill, pvUser, pszDesc, pszDesc, phRegion));
184
185 int rc = VERR_NOT_IMPLEMENTED;
186 AssertFailed();
187
188 LogFlow(("pdmR3DevHlp_MmioCreateEx: caller='%s'/%d: returns %Rrc (*phRegion=%#x)\n",
189 pDevIns->pReg->szName, pDevIns->iInstance, rc, *phRegion));
190 return rc;
191}
192
193
194/** @interface_method_impl{PDMDEVHLPR3,pfnMmioMap} */
195static DECLCALLBACK(int) pdmR3DevHlp_MmioMap(PPDMDEVINS pDevIns, IOMMMIOHANDLE hRegion, RTGCPHYS GCPhys)
196{
197 PDMDEV_ASSERT_DEVINS(pDevIns);
198 LogFlow(("pdmR3DevHlp_MmioMap: caller='%s'/%d: hRegion=%#x GCPhys=%#RGp\n", pDevIns->pReg->szName, pDevIns->iInstance, hRegion, GCPhys));
199
200 int rc = VERR_NOT_IMPLEMENTED;
201 AssertFailed();
202
203 LogFlow(("pdmR3DevHlp_MmioMap: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
204 return rc;
205}
206
207
208/** @interface_method_impl{PDMDEVHLPR3,pfnMmioUnmap} */
209static DECLCALLBACK(int) pdmR3DevHlp_MmioUnmap(PPDMDEVINS pDevIns, IOMMMIOHANDLE hRegion)
210{
211 PDMDEV_ASSERT_DEVINS(pDevIns);
212 LogFlow(("pdmR3DevHlp_MmioUnmap: caller='%s'/%d: hRegion=%#x\n", pDevIns->pReg->szName, pDevIns->iInstance, hRegion));
213
214 int rc = VERR_NOT_IMPLEMENTED;
215 AssertFailed();
216
217 LogFlow(("pdmR3DevHlp_MmioUnmap: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
218 return rc;
219}
220
221
222/** @interface_method_impl{PDMDEVHLPR3,pfnMmioReduce} */
223static DECLCALLBACK(int) pdmR3DevHlp_MmioReduce(PPDMDEVINS pDevIns, IOMMMIOHANDLE hRegion, RTGCPHYS cbRegion)
224{
225 PDMDEV_ASSERT_DEVINS(pDevIns);
226 LogFlow(("pdmR3DevHlp_MmioReduce: caller='%s'/%d: hRegion=%#x cbRegion=%#RGp\n", pDevIns->pReg->szName, pDevIns->iInstance, hRegion, cbRegion));
227
228 int rc = VERR_NOT_IMPLEMENTED;
229 AssertFailed();
230
231 LogFlow(("pdmR3DevHlp_MmioReduce: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
232 return rc;
233}
234
235
236/** @interface_method_impl{PDMDEVHLPR3,pfnMmioGetMappingAddress} */
237static DECLCALLBACK(RTGCPHYS) pdmR3DevHlp_MmioGetMappingAddress(PPDMDEVINS pDevIns, IOMMMIOHANDLE hRegion)
238{
239 PDMDEV_ASSERT_DEVINS(pDevIns);
240 LogFlow(("pdmR3DevHlp_MmioGetMappingAddress: caller='%s'/%d: hRegion=%#x\n", pDevIns->pReg->szName, pDevIns->iInstance, hRegion));
241
242 RTGCPHYS GCPhys = NIL_RTGCPHYS;
243 AssertFailed();
244
245 LogFlow(("pdmR3DevHlp_MmioGetMappingAddress: caller='%s'/%d: returns %RGp\n", pDevIns->pReg->szName, pDevIns->iInstance, GCPhys));
246 return GCPhys;
247}
248
249
250/** @interface_method_impl{PDMDEVHLPR3,pfnMmio2Create} */
251static DECLCALLBACK(int) pdmR3DevHlp_Mmio2Create(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t iPciRegion, RTGCPHYS cbRegion,
252 uint32_t fFlags, const char *pszDesc, void **ppvMapping, PPGMMMIO2HANDLE phRegion)
253{
254 PDMDEV_ASSERT_DEVINS(pDevIns);
255 LogFlow(("pdmR3DevHlp_Mmio2Create: caller='%s'/%d: pPciDev=%p (%#x) iPciRegion=%#x cbRegion=%#RGp fFlags=%RX32 pszDesc=%p:{%s} ppvMapping=%p phRegion=%p\n",
256 pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pPciDev ? pPciDev->uDevFn : UINT32_MAX, iPciRegion, cbRegion,
257 fFlags, pszDesc, pszDesc, ppvMapping, phRegion));
258
259 int rc = VERR_NOT_IMPLEMENTED;
260 AssertFailed();
261
262 LogFlow(("pdmR3DevHlp_Mmio2Create: caller='%s'/%d: returns %Rrc *ppvMapping=%p phRegion=%#RX64\n",
263 pDevIns->pReg->szName, pDevIns->iInstance, rc, *ppvMapping, *phRegion));
264 return rc;
265}
266
267
268/** @interface_method_impl{PDMDEVHLPR3,pfnMmio2Destroy} */
269static DECLCALLBACK(int) pdmR3DevHlp_Mmio2Destroy(PPDMDEVINS pDevIns, PGMMMIO2HANDLE hRegion)
270{
271 PDMDEV_ASSERT_DEVINS(pDevIns);
272 LogFlow(("pdmR3DevHlp_Mmio2Destroy: caller='%s'/%d: hRegion=%#RX64\n", pDevIns->pReg->szName, pDevIns->iInstance, hRegion));
273
274 int rc = VERR_NOT_IMPLEMENTED;
275 AssertFailed();
276
277 LogFlow(("pdmR3DevHlp_Mmio2Destroy: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
278 return rc;
279}
280
281
282/** @interface_method_impl{PDMDEVHLPR3,pfnMmio2Map} */
283static DECLCALLBACK(int) pdmR3DevHlp_Mmio2Map(PPDMDEVINS pDevIns, PGMMMIO2HANDLE hRegion, RTGCPHYS GCPhys)
284{
285 PDMDEV_ASSERT_DEVINS(pDevIns);
286 LogFlow(("pdmR3DevHlp_Mmio2Map: caller='%s'/%d: hRegion=%#RX64 GCPhys=%RGp\n", pDevIns->pReg->szName, pDevIns->iInstance, hRegion, GCPhys));
287
288 int rc = VERR_NOT_IMPLEMENTED;
289 AssertFailed();
290
291 LogFlow(("pdmR3DevHlp_Mmio2Map: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
292 return rc;
293}
294
295
296/** @interface_method_impl{PDMDEVHLPR3,pfnMmio2Unmap} */
297static DECLCALLBACK(int) pdmR3DevHlp_Mmio2Unmap(PPDMDEVINS pDevIns, PGMMMIO2HANDLE hRegion)
298{
299 PDMDEV_ASSERT_DEVINS(pDevIns);
300 LogFlow(("pdmR3DevHlp_Mmio2Unmap: caller='%s'/%d: hRegion=%#RX64\n", pDevIns->pReg->szName, pDevIns->iInstance, hRegion));
301
302 int rc = VERR_NOT_IMPLEMENTED;
303 AssertFailed();
304
305 LogFlow(("pdmR3DevHlp_Mmio2Unmap: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
306 return rc;
307}
308
309
310/** @interface_method_impl{PDMDEVHLPR3,pfnMmio2Reduce} */
311static DECLCALLBACK(int) pdmR3DevHlp_Mmio2Reduce(PPDMDEVINS pDevIns, PGMMMIO2HANDLE hRegion, RTGCPHYS cbRegion)
312{
313 PDMDEV_ASSERT_DEVINS(pDevIns);
314 LogFlow(("pdmR3DevHlp_Mmio2Reduce: caller='%s'/%d: hRegion=%#RX64 cbRegion=%RGp\n", pDevIns->pReg->szName, pDevIns->iInstance, hRegion, cbRegion));
315
316 int rc = VERR_NOT_IMPLEMENTED;
317 AssertFailed();
318
319 LogFlow(("pdmR3DevHlp_Mmio2Reduce: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
320 return rc;
321}
322
323
324/** @interface_method_impl{PDMDEVHLPR3,pfnMmio2GetMappingAddress} */
325static DECLCALLBACK(RTGCPHYS) pdmR3DevHlp_Mmio2GetMappingAddress(PPDMDEVINS pDevIns, PGMMMIO2HANDLE hRegion)
326{
327 PDMDEV_ASSERT_DEVINS(pDevIns);
328 LogFlow(("pdmR3DevHlp_Mmio2GetMappingAddress: caller='%s'/%d: hRegion=%#RX6r\n", pDevIns->pReg->szName, pDevIns->iInstance, hRegion));
329
330 RTGCPHYS GCPhys = NIL_RTGCPHYS;
331 AssertFailed();
332
333 LogFlow(("pdmR3DevHlp_Mmio2GetMappingAddress: caller='%s'/%d: returns %RGp\n", pDevIns->pReg->szName, pDevIns->iInstance, GCPhys));
334 return GCPhys;
335}
336
337/**
338 * @copydoc PDMDEVHLPR3::pfnMmio2ChangeRegionNo
339 */
340static DECLCALLBACK(int) pdmR3DevHlp_Mmio2ChangeRegionNo(PPDMDEVINS pDevIns, PGMMMIO2HANDLE hRegion, uint32_t iNewRegion)
341{
342 PDMDEV_ASSERT_DEVINS(pDevIns);
343 LogFlow(("pdmR3DevHlp_Mmio2ChangeRegionNo: caller='%s'/%d: hRegion=%#RX6r iNewRegion=%#x\n", pDevIns->pReg->szName, pDevIns->iInstance, hRegion, iNewRegion));
344
345 int rc = VERR_NOT_IMPLEMENTED;
346 AssertFailed();
347
348 LogFlow(("pdmR3DevHlp_Mmio2ChangeRegionNo: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
349 return rc;
350}
351
352
353/** @interface_method_impl{PDMDEVHLPR3,pfnROMRegister} */
354static DECLCALLBACK(int) pdmR3DevHlp_ROMRegister(PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, uint32_t cbRange,
355 const void *pvBinary, uint32_t cbBinary, uint32_t fFlags, const char *pszDesc)
356{
357 PDMDEV_ASSERT_DEVINS(pDevIns);
358 LogFlow(("pdmR3DevHlp_ROMRegister: caller='%s'/%d: GCPhysStart=%RGp cbRange=%#x pvBinary=%p cbBinary=%#x fFlags=%#RX32 pszDesc=%p:{%s}\n",
359 pDevIns->pReg->szName, pDevIns->iInstance, GCPhysStart, cbRange, pvBinary, cbBinary, fFlags, pszDesc, pszDesc));
360
361 int rc = VERR_NOT_IMPLEMENTED;
362 AssertFailed();
363
364 LogFlow(("pdmR3DevHlp_ROMRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
365 return rc;
366}
367
368
369/** @interface_method_impl{PDMDEVHLPR3,pfnROMProtectShadow} */
370static DECLCALLBACK(int) pdmR3DevHlp_ROMProtectShadow(PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, uint32_t cbRange, PGMROMPROT enmProt)
371{
372 PDMDEV_ASSERT_DEVINS(pDevIns);
373 LogFlow(("pdmR3DevHlp_ROMProtectShadow: caller='%s'/%d: GCPhysStart=%RGp cbRange=%#x enmProt=%d\n",
374 pDevIns->pReg->szName, pDevIns->iInstance, GCPhysStart, cbRange, enmProt));
375
376 int rc = VERR_NOT_IMPLEMENTED;
377 AssertFailed();
378
379 LogFlow(("pdmR3DevHlp_ROMProtectShadow: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
380 return rc;
381}
382
383
384static DECLCALLBACK(int) pdmR3DevHlp_SSMRegister(PPDMDEVINS pDevIns, uint32_t uVersion, size_t cbGuess, const char *pszBefore,
385 PFNSSMDEVLIVEPREP pfnLivePrep, PFNSSMDEVLIVEEXEC pfnLiveExec, PFNSSMDEVLIVEVOTE pfnLiveVote,
386 PFNSSMDEVSAVEPREP pfnSavePrep, PFNSSMDEVSAVEEXEC pfnSaveExec, PFNSSMDEVSAVEDONE pfnSaveDone,
387 PFNSSMDEVLOADPREP pfnLoadPrep, PFNSSMDEVLOADEXEC pfnLoadExec, PFNSSMDEVLOADDONE pfnLoadDone)
388{
389 PDMDEV_ASSERT_DEVINS(pDevIns);
390 LogFlow(("pdmR3DevHlp_SSMRegister: caller='%s'/%d: uVersion=%#x cbGuess=%#x pszBefore=%p:{%s}\n"
391 " pfnLivePrep=%p pfnLiveExec=%p pfnLiveVote=%p pfnSavePrep=%p pfnSaveExec=%p pfnSaveDone=%p pszLoadPrep=%p pfnLoadExec=%p pfnLoadDone=%p\n",
392 pDevIns->pReg->szName, pDevIns->iInstance, uVersion, cbGuess, pszBefore, pszBefore,
393 pfnLivePrep, pfnLiveExec, pfnLiveVote,
394 pfnSavePrep, pfnSaveExec, pfnSaveDone,
395 pfnLoadPrep, pfnLoadExec, pfnLoadDone));
396
397 RT_NOREF(uVersion, cbGuess, pszBefore, pfnLivePrep, pfnLiveExec, pfnLiveVote, pfnSavePrep, pfnSaveExec, pfnSaveDone,
398 pfnLoadPrep, pfnLoadExec, pfnLoadDone);
399 int rc = VERR_NOT_IMPLEMENTED;
400 AssertFailed();
401
402 LogFlow(("pdmR3DevHlp_SSMRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
403 return rc;
404}
405
406
407static DECLCALLBACK(int) pdmR3DevHlp_SSMPutStruct(PSSMHANDLE pSSM, const void *pvStruct, PCSSMFIELD paFields)
408{
409 RT_NOREF(pSSM, pvStruct, paFields);
410 AssertFailed();
411 return VERR_NOT_IMPLEMENTED;
412}
413
414
415static DECLCALLBACK(int) pdmR3DevHlp_SSMPutStructEx(PSSMHANDLE pSSM, const void *pvStruct, size_t cbStruct, uint32_t fFlags, PCSSMFIELD paFields, void *pvUser)
416{
417 RT_NOREF(pSSM, pvStruct, cbStruct, fFlags, paFields, pvUser);
418 AssertFailed();
419 return VERR_NOT_IMPLEMENTED;
420}
421
422
423static DECLCALLBACK(int) pdmR3DevHlp_SSMPutBool(PSSMHANDLE pSSM, bool fBool)
424{
425 RT_NOREF(pSSM, fBool);
426 AssertFailed();
427 return VERR_NOT_IMPLEMENTED;
428}
429
430
431static DECLCALLBACK(int) pdmR3DevHlp_SSMPutU8(PSSMHANDLE pSSM, uint8_t u8)
432{
433 RT_NOREF(pSSM, u8);
434 AssertFailed();
435 return VERR_NOT_IMPLEMENTED;
436}
437
438
439static DECLCALLBACK(int) pdmR3DevHlp_SSMPutS8(PSSMHANDLE pSSM, int8_t i8)
440{
441 RT_NOREF(pSSM, i8);
442 AssertFailed();
443 return VERR_NOT_IMPLEMENTED;
444}
445
446
447static DECLCALLBACK(int) pdmR3DevHlp_SSMPutU16(PSSMHANDLE pSSM, uint16_t u16)
448{
449 RT_NOREF(pSSM, u16);
450 AssertFailed();
451 return VERR_NOT_IMPLEMENTED;
452}
453
454
455static DECLCALLBACK(int) pdmR3DevHlp_SSMPutS16(PSSMHANDLE pSSM, int16_t i16)
456{
457 RT_NOREF(pSSM, i16);
458 AssertFailed();
459 return VERR_NOT_IMPLEMENTED;
460}
461
462
463static DECLCALLBACK(int) pdmR3DevHlp_SSMPutU32(PSSMHANDLE pSSM, uint32_t u32)
464{
465 RT_NOREF(pSSM, u32);
466 AssertFailed();
467 return VERR_NOT_IMPLEMENTED;
468}
469
470
471static DECLCALLBACK(int) pdmR3DevHlp_SSMPutS32(PSSMHANDLE pSSM, int32_t i32)
472{
473 RT_NOREF(pSSM, i32);
474 AssertFailed();
475 return VERR_NOT_IMPLEMENTED;
476}
477
478
479static DECLCALLBACK(int) pdmR3DevHlp_SSMPutU64(PSSMHANDLE pSSM, uint64_t u64)
480{
481 RT_NOREF(pSSM, u64);
482 AssertFailed();
483 return VERR_NOT_IMPLEMENTED;
484}
485
486
487static DECLCALLBACK(int) pdmR3DevHlp_SSMPutS64(PSSMHANDLE pSSM, int64_t i64)
488{
489 RT_NOREF(pSSM, i64);
490 AssertFailed();
491 return VERR_NOT_IMPLEMENTED;
492}
493
494
495static DECLCALLBACK(int) pdmR3DevHlp_SSMPutU128(PSSMHANDLE pSSM, uint128_t u128)
496{
497 RT_NOREF(pSSM, u128);
498 AssertFailed();
499 return VERR_NOT_IMPLEMENTED;
500}
501
502
503static DECLCALLBACK(int) pdmR3DevHlp_SSMPutS128(PSSMHANDLE pSSM, int128_t i128)
504{
505 RT_NOREF(pSSM, i128);
506 AssertFailed();
507 return VERR_NOT_IMPLEMENTED;
508}
509
510
511static DECLCALLBACK(int) pdmR3DevHlp_SSMPutUInt(PSSMHANDLE pSSM, RTUINT u)
512{
513 RT_NOREF(pSSM, u);
514 AssertFailed();
515 return VERR_NOT_IMPLEMENTED;
516}
517
518
519static DECLCALLBACK(int) pdmR3DevHlp_SSMPutSInt(PSSMHANDLE pSSM, RTINT i)
520{
521 RT_NOREF(pSSM, i);
522 AssertFailed();
523 return VERR_NOT_IMPLEMENTED;
524}
525
526
527static DECLCALLBACK(int) pdmR3DevHlp_SSMPutGCUInt(PSSMHANDLE pSSM, RTGCUINT u)
528{
529 RT_NOREF(pSSM, u);
530 AssertFailed();
531 return VERR_NOT_IMPLEMENTED;
532}
533
534
535static DECLCALLBACK(int) pdmR3DevHlp_SSMPutGCUIntReg(PSSMHANDLE pSSM, RTGCUINTREG u)
536{
537 RT_NOREF(pSSM, u);
538 AssertFailed();
539 return VERR_NOT_IMPLEMENTED;
540}
541
542
543static DECLCALLBACK(int) pdmR3DevHlp_SSMPutGCPhys32(PSSMHANDLE pSSM, RTGCPHYS32 GCPhys)
544{
545 RT_NOREF(pSSM, GCPhys);
546 AssertFailed();
547 return VERR_NOT_IMPLEMENTED;
548}
549
550
551static DECLCALLBACK(int) pdmR3DevHlp_SSMPutGCPhys64(PSSMHANDLE pSSM, RTGCPHYS64 GCPhys)
552{
553 RT_NOREF(pSSM, GCPhys);
554 AssertFailed();
555 return VERR_NOT_IMPLEMENTED;
556}
557
558
559static DECLCALLBACK(int) pdmR3DevHlp_SSMPutGCPhys(PSSMHANDLE pSSM, RTGCPHYS GCPhys)
560{
561 RT_NOREF(pSSM, GCPhys);
562 AssertFailed();
563 return VERR_NOT_IMPLEMENTED;
564}
565
566
567static DECLCALLBACK(int) pdmR3DevHlp_SSMPutGCPtr(PSSMHANDLE pSSM, RTGCPTR GCPtr)
568{
569 RT_NOREF(pSSM, GCPtr);
570 AssertFailed();
571 return VERR_NOT_IMPLEMENTED;
572}
573
574
575static DECLCALLBACK(int) pdmR3DevHlp_SSMPutGCUIntPtr(PSSMHANDLE pSSM, RTGCUINTPTR GCPtr)
576{
577 RT_NOREF(pSSM, GCPtr);
578 AssertFailed();
579 return VERR_NOT_IMPLEMENTED;
580}
581
582
583static DECLCALLBACK(int) pdmR3DevHlp_SSMPutRCPtr(PSSMHANDLE pSSM, RTRCPTR RCPtr)
584{
585 RT_NOREF(pSSM, RCPtr);
586 AssertFailed();
587 return VERR_NOT_IMPLEMENTED;
588}
589
590
591static DECLCALLBACK(int) pdmR3DevHlp_SSMPutIOPort(PSSMHANDLE pSSM, RTIOPORT IOPort)
592{
593 RT_NOREF(pSSM, IOPort);
594 AssertFailed();
595 return VERR_NOT_IMPLEMENTED;
596}
597
598
599static DECLCALLBACK(int) pdmR3DevHlp_SSMPutSel(PSSMHANDLE pSSM, RTSEL Sel)
600{
601 RT_NOREF(pSSM, Sel);
602 AssertFailed();
603 return VERR_NOT_IMPLEMENTED;
604}
605
606
607static DECLCALLBACK(int) pdmR3DevHlp_SSMPutMem(PSSMHANDLE pSSM, const void *pv, size_t cb)
608{
609 RT_NOREF(pSSM, pv, cb);
610 AssertFailed();
611 return VERR_NOT_IMPLEMENTED;
612}
613
614
615static DECLCALLBACK(int) pdmR3DevHlp_SSMPutStrZ(PSSMHANDLE pSSM, const char *psz)
616{
617 RT_NOREF(pSSM, psz);
618 AssertFailed();
619 return VERR_NOT_IMPLEMENTED;
620}
621
622
623static DECLCALLBACK(int) pdmR3DevHlp_SSMGetStruct(PSSMHANDLE pSSM, void *pvStruct, PCSSMFIELD paFields)
624{
625 RT_NOREF(pSSM, pvStruct, paFields);
626 AssertFailed();
627 return VERR_NOT_IMPLEMENTED;
628}
629
630
631static DECLCALLBACK(int) pdmR3DevHlp_SSMGetStructEx(PSSMHANDLE pSSM, void *pvStruct, size_t cbStruct, uint32_t fFlags, PCSSMFIELD paFields, void *pvUser)
632{
633 RT_NOREF(pSSM, pvStruct, cbStruct, fFlags, paFields, pvUser);
634 AssertFailed();
635 return VERR_NOT_IMPLEMENTED;
636}
637
638
639static DECLCALLBACK(int) pdmR3DevHlp_SSMGetBool(PSSMHANDLE pSSM, bool *pfBool)
640{
641 RT_NOREF(pSSM, pfBool);
642 AssertFailed();
643 return VERR_NOT_IMPLEMENTED;
644}
645
646
647static DECLCALLBACK(int) pdmR3DevHlp_SSMGetBoolV(PSSMHANDLE pSSM, bool volatile *pfBool)
648{
649 RT_NOREF(pSSM, pfBool);
650 AssertFailed();
651 return VERR_NOT_IMPLEMENTED;
652}
653
654
655static DECLCALLBACK(int) pdmR3DevHlp_SSMGetU8(PSSMHANDLE pSSM, uint8_t *pu8)
656{
657 RT_NOREF(pSSM, pu8);
658 AssertFailed();
659 return VERR_NOT_IMPLEMENTED;
660}
661
662
663static DECLCALLBACK(int) pdmR3DevHlp_SSMGetU8V(PSSMHANDLE pSSM, uint8_t volatile *pu8)
664{
665 RT_NOREF(pSSM, pu8);
666 AssertFailed();
667 return VERR_NOT_IMPLEMENTED;
668}
669
670
671static DECLCALLBACK(int) pdmR3DevHlp_SSMGetS8(PSSMHANDLE pSSM, int8_t *pi8)
672{
673 RT_NOREF(pSSM, pi8);
674 AssertFailed();
675 return VERR_NOT_IMPLEMENTED;
676}
677
678
679static DECLCALLBACK(int) pdmR3DevHlp_SSMGetS8V(PSSMHANDLE pSSM, int8_t volatile *pi8)
680{
681 RT_NOREF(pSSM, pi8);
682 AssertFailed();
683 return VERR_NOT_IMPLEMENTED;
684}
685
686
687static DECLCALLBACK(int) pdmR3DevHlp_SSMGetU16(PSSMHANDLE pSSM, uint16_t *pu16)
688{
689 RT_NOREF(pSSM, pu16);
690 AssertFailed();
691 return VERR_NOT_IMPLEMENTED;
692}
693
694
695static DECLCALLBACK(int) pdmR3DevHlp_SSMGetU16V(PSSMHANDLE pSSM, uint16_t volatile *pu16)
696{
697 RT_NOREF(pSSM, pu16);
698 AssertFailed();
699 return VERR_NOT_IMPLEMENTED;
700}
701
702
703static DECLCALLBACK(int) pdmR3DevHlp_SSMGetS16(PSSMHANDLE pSSM, int16_t *pi16)
704{
705 RT_NOREF(pSSM, pi16);
706 AssertFailed();
707 return VERR_NOT_IMPLEMENTED;
708}
709
710
711static DECLCALLBACK(int) pdmR3DevHlp_SSMGetS16V(PSSMHANDLE pSSM, int16_t volatile *pi16)
712{
713 RT_NOREF(pSSM, pi16);
714 AssertFailed();
715 return VERR_NOT_IMPLEMENTED;
716}
717
718
719static DECLCALLBACK(int) pdmR3DevHlp_SSMGetU32(PSSMHANDLE pSSM, uint32_t *pu32)
720{
721 RT_NOREF(pSSM, pu32);
722 AssertFailed();
723 return VERR_NOT_IMPLEMENTED;
724}
725
726
727static DECLCALLBACK(int) pdmR3DevHlp_SSMGetU32V(PSSMHANDLE pSSM, uint32_t volatile *pu32)
728{
729 RT_NOREF(pSSM, pu32);
730 AssertFailed();
731 return VERR_NOT_IMPLEMENTED;
732}
733
734
735static DECLCALLBACK(int) pdmR3DevHlp_SSMGetS32(PSSMHANDLE pSSM, int32_t *pi32)
736{
737 RT_NOREF(pSSM, pi32);
738 AssertFailed();
739 return VERR_NOT_IMPLEMENTED;
740}
741
742
743static DECLCALLBACK(int) pdmR3DevHlp_SSMGetS32V(PSSMHANDLE pSSM, int32_t volatile *pi32)
744{
745 RT_NOREF(pSSM, pi32);
746 AssertFailed();
747 return VERR_NOT_IMPLEMENTED;
748}
749
750
751static DECLCALLBACK(int) pdmR3DevHlp_SSMGetU64(PSSMHANDLE pSSM, uint64_t *pu64)
752{
753 RT_NOREF(pSSM, pu64);
754 AssertFailed();
755 return VERR_NOT_IMPLEMENTED;
756}
757
758
759static DECLCALLBACK(int) pdmR3DevHlp_SSMGetU64V(PSSMHANDLE pSSM, uint64_t volatile *pu64)
760{
761 RT_NOREF(pSSM, pu64);
762 AssertFailed();
763 return VERR_NOT_IMPLEMENTED;
764}
765
766
767static DECLCALLBACK(int) pdmR3DevHlp_SSMGetS64(PSSMHANDLE pSSM, int64_t *pi64)
768{
769 RT_NOREF(pSSM, pi64);
770 AssertFailed();
771 return VERR_NOT_IMPLEMENTED;
772}
773
774
775static DECLCALLBACK(int) pdmR3DevHlp_SSMGetS64V(PSSMHANDLE pSSM, int64_t volatile *pi64)
776{
777 RT_NOREF(pSSM, pi64);
778 AssertFailed();
779 return VERR_NOT_IMPLEMENTED;
780}
781
782
783static DECLCALLBACK(int) pdmR3DevHlp_SSMGetU128(PSSMHANDLE pSSM, uint128_t *pu128)
784{
785 RT_NOREF(pSSM, pu128);
786 AssertFailed();
787 return VERR_NOT_IMPLEMENTED;
788}
789
790
791static DECLCALLBACK(int) pdmR3DevHlp_SSMGetU128V(PSSMHANDLE pSSM, uint128_t volatile *pu128)
792{
793 RT_NOREF(pSSM, pu128);
794 AssertFailed();
795 return VERR_NOT_IMPLEMENTED;
796}
797
798
799static DECLCALLBACK(int) pdmR3DevHlp_SSMGetS128(PSSMHANDLE pSSM, int128_t *pi128)
800{
801 RT_NOREF(pSSM, pi128);
802 AssertFailed();
803 return VERR_NOT_IMPLEMENTED;
804}
805
806
807static DECLCALLBACK(int) pdmR3DevHlp_SSMGetS128V(PSSMHANDLE pSSM, int128_t volatile *pi128)
808{
809 RT_NOREF(pSSM, pi128);
810 AssertFailed();
811 return VERR_NOT_IMPLEMENTED;
812}
813
814
815static DECLCALLBACK(int) pdmR3DevHlp_SSMGetGCPhys32(PSSMHANDLE pSSM, PRTGCPHYS32 pGCPhys)
816{
817 RT_NOREF(pSSM, pGCPhys);
818 AssertFailed();
819 return VERR_NOT_IMPLEMENTED;
820}
821
822
823static DECLCALLBACK(int) pdmR3DevHlp_SSMGetGCPhys32V(PSSMHANDLE pSSM, RTGCPHYS32 volatile *pGCPhys)
824{
825 RT_NOREF(pSSM, pGCPhys);
826 AssertFailed();
827 return VERR_NOT_IMPLEMENTED;
828}
829
830
831static DECLCALLBACK(int) pdmR3DevHlp_SSMGetGCPhys64(PSSMHANDLE pSSM, PRTGCPHYS64 pGCPhys)
832{
833 RT_NOREF(pSSM, pGCPhys);
834 AssertFailed();
835 return VERR_NOT_IMPLEMENTED;
836}
837
838
839static DECLCALLBACK(int) pdmR3DevHlp_SSMGetGCPhys64V(PSSMHANDLE pSSM, RTGCPHYS64 volatile *pGCPhys)
840{
841 RT_NOREF(pSSM, pGCPhys);
842 AssertFailed();
843 return VERR_NOT_IMPLEMENTED;
844}
845
846
847static DECLCALLBACK(int) pdmR3DevHlp_SSMGetGCPhys(PSSMHANDLE pSSM, PRTGCPHYS pGCPhys)
848{
849 RT_NOREF(pSSM, pGCPhys);
850 AssertFailed();
851 return VERR_NOT_IMPLEMENTED;
852}
853
854
855static DECLCALLBACK(int) pdmR3DevHlp_SSMGetGCPhysV(PSSMHANDLE pSSM, RTGCPHYS volatile *pGCPhys)
856{
857 RT_NOREF(pSSM, pGCPhys);
858 AssertFailed();
859 return VERR_NOT_IMPLEMENTED;
860}
861
862
863static DECLCALLBACK(int) pdmR3DevHlp_SSMGetUInt(PSSMHANDLE pSSM, PRTUINT pu)
864{
865 RT_NOREF(pSSM, pu);
866 AssertFailed();
867 return VERR_NOT_IMPLEMENTED;
868}
869
870
871static DECLCALLBACK(int) pdmR3DevHlp_SSMGetSInt(PSSMHANDLE pSSM, PRTINT pi)
872{
873 RT_NOREF(pSSM, pi);
874 AssertFailed();
875 return VERR_NOT_IMPLEMENTED;
876}
877
878
879static DECLCALLBACK(int) pdmR3DevHlp_SSMGetGCUInt(PSSMHANDLE pSSM, PRTGCUINT pu)
880{
881 RT_NOREF(pSSM, pu);
882 AssertFailed();
883 return VERR_NOT_IMPLEMENTED;
884}
885
886
887static DECLCALLBACK(int) pdmR3DevHlp_SSMGetGCUIntReg(PSSMHANDLE pSSM, PRTGCUINTREG pu)
888{
889 RT_NOREF(pSSM, pu);
890 AssertFailed();
891 return VERR_NOT_IMPLEMENTED;
892}
893
894
895static DECLCALLBACK(int) pdmR3DevHlp_SSMGetGCPtr(PSSMHANDLE pSSM, PRTGCPTR pGCPtr)
896{
897 RT_NOREF(pSSM, pGCPtr);
898 AssertFailed();
899 return VERR_NOT_IMPLEMENTED;
900}
901
902
903static DECLCALLBACK(int) pdmR3DevHlp_SSMGetGCUIntPtr(PSSMHANDLE pSSM, PRTGCUINTPTR pGCPtr)
904{
905 RT_NOREF(pSSM, pGCPtr);
906 AssertFailed();
907 return VERR_NOT_IMPLEMENTED;
908}
909
910
911static DECLCALLBACK(int) pdmR3DevHlp_SSMGetRCPtr(PSSMHANDLE pSSM, PRTRCPTR pRCPtr)
912{
913 RT_NOREF(pSSM, pRCPtr);
914 AssertFailed();
915 return VERR_NOT_IMPLEMENTED;
916}
917
918
919static DECLCALLBACK(int) pdmR3DevHlp_SSMGetIOPort(PSSMHANDLE pSSM, PRTIOPORT pIOPort)
920{
921 RT_NOREF(pSSM, pIOPort);
922 AssertFailed();
923 return VERR_NOT_IMPLEMENTED;
924}
925
926
927static DECLCALLBACK(int) pdmR3DevHlp_SSMGetSel(PSSMHANDLE pSSM, PRTSEL pSel)
928{
929 RT_NOREF(pSSM, pSel);
930 AssertFailed();
931 return VERR_NOT_IMPLEMENTED;
932}
933
934
935static DECLCALLBACK(int) pdmR3DevHlp_SSMGetMem(PSSMHANDLE pSSM, void *pv, size_t cb)
936{
937 RT_NOREF(pSSM, pv, cb);
938 AssertFailed();
939 return VERR_NOT_IMPLEMENTED;
940}
941
942
943static DECLCALLBACK(int) pdmR3DevHlp_SSMGetStrZ(PSSMHANDLE pSSM, char *psz, size_t cbMax)
944{
945 RT_NOREF(pSSM, psz, cbMax);
946 AssertFailed();
947 return VERR_NOT_IMPLEMENTED;
948}
949
950
951static DECLCALLBACK(int) pdmR3DevHlp_SSMGetStrZEx(PSSMHANDLE pSSM, char *psz, size_t cbMax, size_t *pcbStr)
952{
953 RT_NOREF(pSSM, psz,cbMax, pcbStr);
954 AssertFailed();
955 return VERR_NOT_IMPLEMENTED;
956}
957
958
959static DECLCALLBACK(int) pdmR3DevHlp_SSMSkip(PSSMHANDLE pSSM, size_t cb)
960{
961 RT_NOREF(pSSM, cb);
962 AssertFailed();
963 return VERR_NOT_IMPLEMENTED;
964}
965
966
967static DECLCALLBACK(int) pdmR3DevHlp_SSMSkipToEndOfUnit(PSSMHANDLE pSSM)
968{
969 RT_NOREF(pSSM);
970 AssertFailed();
971 return VERR_NOT_IMPLEMENTED;
972}
973
974
975static DECLCALLBACK(int) pdmR3DevHlp_SSMSetLoadError(PSSMHANDLE pSSM, int rc, RT_SRC_POS_DECL, const char *pszFormat, ...) RT_IPRT_FORMAT_ATTR(6, 7)
976{
977 RT_NOREF(pSSM, rc, RT_SRC_POS_ARGS, pszFormat);
978 AssertFailed();
979 return VERR_NOT_IMPLEMENTED;
980}
981
982
983static DECLCALLBACK(int) pdmR3DevHlp_SSMSetLoadErrorV(PSSMHANDLE pSSM, int rc, RT_SRC_POS_DECL, const char *pszFormat, va_list va) RT_IPRT_FORMAT_ATTR(6, 0)
984{
985 RT_NOREF(pSSM, rc, RT_SRC_POS_ARGS, pszFormat, va);
986 AssertFailed();
987 return VERR_NOT_IMPLEMENTED;
988}
989
990
991static DECLCALLBACK(int) pdmR3DevHlp_SSMSetCfgError(PSSMHANDLE pSSM, RT_SRC_POS_DECL, const char *pszFormat, ...) RT_IPRT_FORMAT_ATTR(5, 6)
992{
993 RT_NOREF(pSSM, RT_SRC_POS_ARGS, pszFormat);
994 AssertFailed();
995 return VERR_NOT_IMPLEMENTED;
996}
997
998
999static DECLCALLBACK(int) pdmR3DevHlp_SSMSetCfgErrorV(PSSMHANDLE pSSM, RT_SRC_POS_DECL, const char *pszFormat, va_list va) RT_IPRT_FORMAT_ATTR(5, 0)
1000{
1001 RT_NOREF(pSSM, RT_SRC_POS_ARGS, pszFormat, va);
1002 AssertFailed();
1003 return VERR_NOT_IMPLEMENTED;
1004}
1005
1006
1007static DECLCALLBACK(int) pdmR3DevHlp_SSMHandleGetStatus(PSSMHANDLE pSSM)
1008{
1009 RT_NOREF(pSSM);
1010 AssertFailed();
1011 return VERR_NOT_IMPLEMENTED;
1012}
1013
1014
1015static DECLCALLBACK(SSMAFTER) pdmR3DevHlp_SSMHandleGetAfter(PSSMHANDLE pSSM)
1016{
1017 RT_NOREF(pSSM);
1018 AssertFailed();
1019 return SSMAFTER_INVALID;
1020}
1021
1022
1023static DECLCALLBACK(bool) pdmR3DevHlp_SSMHandleIsLiveSave(PSSMHANDLE pSSM)
1024{
1025 RT_NOREF(pSSM);
1026 AssertFailed();
1027 return false;
1028}
1029
1030
1031static DECLCALLBACK(uint32_t) pdmR3DevHlp_SSMHandleMaxDowntime(PSSMHANDLE pSSM)
1032{
1033 RT_NOREF(pSSM);
1034 AssertFailed();
1035 return 0;
1036}
1037
1038
1039static DECLCALLBACK(uint32_t) pdmR3DevHlp_SSMHandleHostBits(PSSMHANDLE pSSM)
1040{
1041 RT_NOREF(pSSM);
1042 AssertFailed();
1043 return 0;
1044}
1045
1046
1047static DECLCALLBACK(uint32_t) pdmR3DevHlp_SSMHandleRevision(PSSMHANDLE pSSM)
1048{
1049 RT_NOREF(pSSM);
1050 AssertFailed();
1051 return 0;
1052}
1053
1054
1055static DECLCALLBACK(uint32_t) pdmR3DevHlp_SSMHandleVersion(PSSMHANDLE pSSM)
1056{
1057 RT_NOREF(pSSM);
1058 AssertFailed();
1059 return 0;
1060}
1061
1062
1063static DECLCALLBACK(const char *) pdmR3DevHlp_SSMHandleHostOSAndArch(PSSMHANDLE pSSM)
1064{
1065 RT_NOREF(pSSM);
1066 AssertFailed();
1067 return NULL;
1068}
1069
1070
1071/** @interface_method_impl{PDMDEVHLPR3,pfnTMTimerCreate} */
1072static DECLCALLBACK(int) pdmR3DevHlp_TMTimerCreate(PPDMDEVINS pDevIns, TMCLOCK enmClock, PFNTMTIMERDEV pfnCallback, void *pvUser, uint32_t fFlags, const char *pszDesc, PPTMTIMERR3 ppTimer)
1073{
1074 PDMDEV_ASSERT_DEVINS(pDevIns);
1075 LogFlow(("pdmR3DevHlp_TMTimerCreate: caller='%s'/%d: enmClock=%d pfnCallback=%p pvUser=%p fFlags=%#x pszDesc=%p:{%s} ppTimer=%p\n",
1076 pDevIns->pReg->szName, pDevIns->iInstance, enmClock, pfnCallback, pvUser, fFlags, pszDesc, pszDesc, ppTimer));
1077
1078 int rc = VERR_NOT_IMPLEMENTED;
1079 AssertFailed();
1080
1081 LogFlow(("pdmR3DevHlp_TMTimerCreate: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
1082 return rc;
1083}
1084
1085
1086
1087/** @interface_method_impl{PDMDEVHLPR3,pfnTimerCreate} */
1088static DECLCALLBACK(int) pdmR3DevHlp_TimerCreate(PPDMDEVINS pDevIns, TMCLOCK enmClock, PFNTMTIMERDEV pfnCallback,
1089 void *pvUser, uint32_t fFlags, const char *pszDesc, PTMTIMERHANDLE phTimer)
1090{
1091 PDMDEV_ASSERT_DEVINS(pDevIns);
1092 LogFlow(("pdmR3DevHlp_TimerCreate: caller='%s'/%d: enmClock=%d pfnCallback=%p pvUser=%p fFlags=%#x pszDesc=%p:{%s} phTimer=%p\n",
1093 pDevIns->pReg->szName, pDevIns->iInstance, enmClock, pfnCallback, pvUser, fFlags, pszDesc, pszDesc, phTimer));
1094
1095 int rc = VERR_NOT_IMPLEMENTED;
1096 AssertFailed();
1097
1098 LogFlow(("pdmR3DevHlp_TimerCreate: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
1099 return rc;
1100}
1101
1102
1103/** @interface_method_impl{PDMDEVHLPR3,pfnTimerToPtr} */
1104static DECLCALLBACK(PTMTIMERR3) pdmR3DevHlp_TimerToPtr(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
1105{
1106 PDMDEV_ASSERT_DEVINS(pDevIns);
1107 RT_NOREF(pDevIns);
1108 return (PTMTIMERR3)hTimer;
1109}
1110
1111
1112/** @interface_method_impl{PDMDEVHLPR3,pfnTimerFromMicro} */
1113static DECLCALLBACK(uint64_t) pdmR3DevHlp_TimerFromMicro(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cMicroSecs)
1114{
1115 RT_NOREF(pDevIns, hTimer, cMicroSecs);
1116 AssertFailed();
1117 return 0;
1118}
1119
1120
1121/** @interface_method_impl{PDMDEVHLPR3,pfnTimerFromMilli} */
1122static DECLCALLBACK(uint64_t) pdmR3DevHlp_TimerFromMilli(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cMilliSecs)
1123{
1124 RT_NOREF(pDevIns, hTimer, cMilliSecs);
1125 AssertFailed();
1126 return 0;
1127}
1128
1129
1130/** @interface_method_impl{PDMDEVHLPR3,pfnTimerFromNano} */
1131static DECLCALLBACK(uint64_t) pdmR3DevHlp_TimerFromNano(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cNanoSecs)
1132{
1133 RT_NOREF(pDevIns, hTimer, cNanoSecs);
1134 AssertFailed();
1135 return 0;
1136}
1137
1138/** @interface_method_impl{PDMDEVHLPR3,pfnTimerGet} */
1139static DECLCALLBACK(uint64_t) pdmR3DevHlp_TimerGet(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
1140{
1141 RT_NOREF(pDevIns, hTimer);
1142 AssertFailed();
1143 return 0;
1144}
1145
1146
1147/** @interface_method_impl{PDMDEVHLPR3,pfnTimerGetFreq} */
1148static DECLCALLBACK(uint64_t) pdmR3DevHlp_TimerGetFreq(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
1149{
1150 PDMDEV_ASSERT_DEVINS(pDevIns);
1151
1152 PTMTIMERR3 pTimer = (PTMTIMERR3)hTimer;
1153 switch (pTimer->enmClock)
1154 {
1155 case TMCLOCK_VIRTUAL:
1156 case TMCLOCK_VIRTUAL_SYNC:
1157 return TMCLOCK_FREQ_VIRTUAL;
1158
1159 case TMCLOCK_REAL:
1160 return TMCLOCK_FREQ_REAL;
1161
1162 default:
1163 AssertMsgFailed(("Invalid enmClock=%d\n", pTimer->enmClock));
1164 return 0;
1165 }
1166}
1167
1168
1169/** @interface_method_impl{PDMDEVHLPR3,pfnTimerGetNano} */
1170static DECLCALLBACK(uint64_t) pdmR3DevHlp_TimerGetNano(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
1171{
1172 RT_NOREF(pDevIns, hTimer);
1173 AssertFailed();
1174 return 0;
1175}
1176
1177
1178/** @interface_method_impl{PDMDEVHLPR3,pfnTimerIsActive} */
1179static DECLCALLBACK(bool) pdmR3DevHlp_TimerIsActive(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
1180{
1181 RT_NOREF(pDevIns, hTimer);
1182 AssertFailed();
1183 return false;
1184}
1185
1186
1187/** @interface_method_impl{PDMDEVHLPR3,pfnTimerIsLockOwner} */
1188static DECLCALLBACK(bool) pdmR3DevHlp_TimerIsLockOwner(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
1189{
1190 RT_NOREF(pDevIns, hTimer);
1191 AssertFailed();
1192 return false;
1193}
1194
1195
1196/** @interface_method_impl{PDMDEVHLPR3,pfnTimerLockClock} */
1197static DECLCALLBACK(VBOXSTRICTRC) pdmR3DevHlp_TimerLockClock(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, int rcBusy)
1198{
1199 RT_NOREF(pDevIns, hTimer, rcBusy);
1200 int rc = VERR_NOT_IMPLEMENTED;
1201 AssertFailed();
1202 return rc;
1203}
1204
1205
1206/** @interface_method_impl{PDMDEVHLPR3,pfnTimerLockClock2} */
1207static DECLCALLBACK(VBOXSTRICTRC) pdmR3DevHlp_TimerLockClock2(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer,
1208 PPDMCRITSECT pCritSect, int rcBusy)
1209{
1210 RT_NOREF(pDevIns, hTimer, pCritSect, rcBusy);
1211 int rc = VERR_NOT_IMPLEMENTED;
1212 AssertFailed();
1213 return rc;
1214}
1215
1216
1217/** @interface_method_impl{PDMDEVHLPR3,pfnTimerSet} */
1218static DECLCALLBACK(int) pdmR3DevHlp_TimerSet(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t uExpire)
1219{
1220 RT_NOREF(pDevIns, hTimer, uExpire);
1221 int rc = VERR_NOT_IMPLEMENTED;
1222 AssertFailed();
1223 return rc;
1224}
1225
1226
1227/** @interface_method_impl{PDMDEVHLPR3,pfnTimerSetFrequencyHint} */
1228static DECLCALLBACK(int) pdmR3DevHlp_TimerSetFrequencyHint(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint32_t uHz)
1229{
1230 RT_NOREF(pDevIns, hTimer, uHz);
1231 int rc = VERR_NOT_IMPLEMENTED;
1232 AssertFailed();
1233 return rc;
1234}
1235
1236
1237/** @interface_method_impl{PDMDEVHLPR3,pfnTimerSetMicro} */
1238static DECLCALLBACK(int) pdmR3DevHlp_TimerSetMicro(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cMicrosToNext)
1239{
1240 RT_NOREF(pDevIns, hTimer, cMicrosToNext);
1241 int rc = VERR_NOT_IMPLEMENTED;
1242 AssertFailed();
1243 return rc;
1244}
1245
1246
1247/** @interface_method_impl{PDMDEVHLPR3,pfnTimerSetMillies} */
1248static DECLCALLBACK(int) pdmR3DevHlp_TimerSetMillies(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cMilliesToNext)
1249{
1250 RT_NOREF(pDevIns, hTimer, cMilliesToNext);
1251 int rc = VERR_NOT_IMPLEMENTED;
1252 AssertFailed();
1253 return rc;
1254}
1255
1256
1257/** @interface_method_impl{PDMDEVHLPR3,pfnTimerSetNano} */
1258static DECLCALLBACK(int) pdmR3DevHlp_TimerSetNano(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cNanosToNext)
1259{
1260 RT_NOREF(pDevIns, hTimer, cNanosToNext);
1261 int rc = VERR_NOT_IMPLEMENTED;
1262 AssertFailed();
1263 return rc;
1264}
1265
1266
1267/** @interface_method_impl{PDMDEVHLPR3,pfnTimerSetRelative} */
1268static DECLCALLBACK(int) pdmR3DevHlp_TimerSetRelative(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cTicksToNext, uint64_t *pu64Now)
1269{
1270 RT_NOREF(pDevIns, hTimer, cTicksToNext, pu64Now);
1271 int rc = VERR_NOT_IMPLEMENTED;
1272 AssertFailed();
1273 return rc;
1274}
1275
1276
1277/** @interface_method_impl{PDMDEVHLPR3,pfnTimerStop} */
1278static DECLCALLBACK(int) pdmR3DevHlp_TimerStop(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
1279{
1280 RT_NOREF(pDevIns, hTimer);
1281 int rc = VERR_NOT_IMPLEMENTED;
1282 AssertFailed();
1283 return rc;
1284}
1285
1286
1287/** @interface_method_impl{PDMDEVHLPR3,pfnTimerUnlockClock} */
1288static DECLCALLBACK(void) pdmR3DevHlp_TimerUnlockClock(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
1289{
1290 RT_NOREF(pDevIns, hTimer);
1291 AssertFailed();
1292}
1293
1294
1295/** @interface_method_impl{PDMDEVHLPR3,pfnTimerUnlockClock2} */
1296static DECLCALLBACK(void) pdmR3DevHlp_TimerUnlockClock2(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, PPDMCRITSECT pCritSect)
1297{
1298 RT_NOREF(pDevIns, hTimer, pCritSect);
1299 AssertFailed();
1300}
1301
1302
1303/** @interface_method_impl{PDMDEVHLPR3,pfnTimerSetCritSect} */
1304static DECLCALLBACK(int) pdmR3DevHlp_TimerSetCritSect(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, PPDMCRITSECT pCritSect)
1305{
1306 RT_NOREF(pDevIns, hTimer, pCritSect);
1307 int rc = VERR_NOT_IMPLEMENTED;
1308 AssertFailed();
1309 return rc;
1310}
1311
1312
1313/** @interface_method_impl{PDMDEVHLPR3,pfnTimerSave} */
1314static DECLCALLBACK(int) pdmR3DevHlp_TimerSave(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, PSSMHANDLE pSSM)
1315{
1316 RT_NOREF(pDevIns, hTimer, pSSM);
1317 int rc = VERR_NOT_IMPLEMENTED;
1318 AssertFailed();
1319 return rc;
1320}
1321
1322
1323/** @interface_method_impl{PDMDEVHLPR3,pfnTimerLoad} */
1324static DECLCALLBACK(int) pdmR3DevHlp_TimerLoad(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, PSSMHANDLE pSSM)
1325{
1326 RT_NOREF(pDevIns, hTimer, pSSM);
1327 int rc = VERR_NOT_IMPLEMENTED;
1328 AssertFailed();
1329 return rc;
1330}
1331
1332
1333/** @interface_method_impl{PDMDEVHLPR3,pfnTimerDestroy} */
1334static DECLCALLBACK(int) pdmR3DevHlp_TimerDestroy(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
1335{
1336 RT_NOREF(pDevIns, hTimer);
1337 int rc = VERR_NOT_IMPLEMENTED;
1338 AssertFailed();
1339 return rc;
1340}
1341
1342
1343static DECLCALLBACK(int) pdmR3DevHlp_TimerSkipLoad(PSSMHANDLE pSSM, bool *pfActive)
1344{
1345 RT_NOREF(pSSM, pfActive);
1346 int rc = VERR_NOT_IMPLEMENTED;
1347 AssertFailed();
1348 return rc;
1349}
1350
1351
1352/** @interface_method_impl{PDMDEVHLPR3,pfnTMUtcNow} */
1353static DECLCALLBACK(PRTTIMESPEC) pdmR3DevHlp_TMUtcNow(PPDMDEVINS pDevIns, PRTTIMESPEC pTime)
1354{
1355 PDMDEV_ASSERT_DEVINS(pDevIns);
1356 LogFlow(("pdmR3DevHlp_TMUtcNow: caller='%s'/%d: pTime=%p\n",
1357 pDevIns->pReg->szName, pDevIns->iInstance, pTime));
1358
1359 RT_NOREF(pDevIns, pTime);
1360 AssertFailed();
1361
1362 LogFlow(("pdmR3DevHlp_TMUtcNow: caller='%s'/%d: returns %RU64\n", pDevIns->pReg->szName, pDevIns->iInstance, RTTimeSpecGetNano(pTime)));
1363 return pTime;
1364}
1365
1366
1367static DECLCALLBACK(bool) pdmR3DevHlp_CFGMExists(PCFGMNODE pNode, const char *pszName)
1368{
1369 RT_NOREF(pNode, pszName);
1370 AssertFailed();
1371 return false;
1372}
1373
1374
1375static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryType(PCFGMNODE pNode, const char *pszName, PCFGMVALUETYPE penmType)
1376{
1377 RT_NOREF(pNode, pszName, penmType);
1378 AssertFailed();
1379 return VERR_NOT_IMPLEMENTED;
1380}
1381
1382
1383static DECLCALLBACK(int) pdmR3DevHlp_CFGMQuerySize(PCFGMNODE pNode, const char *pszName, size_t *pcb)
1384{
1385 if (!pNode)
1386 return VERR_CFGM_NO_PARENT;
1387
1388 PCTSTDEVCFGITEM pCfgItem;
1389 int rc = tstDev_CfgmR3ResolveItem(pNode->pDut->pTestcaseReg->paDevCfg, pszName, &pCfgItem);
1390 if (RT_SUCCESS(rc))
1391 {
1392 switch (pCfgItem->enmType)
1393 {
1394 case TSTDEVCFGITEMTYPE_INTEGER:
1395 *pcb = sizeof(uint64_t);
1396 break;
1397
1398 case TSTDEVCFGITEMTYPE_STRING:
1399 *pcb = strlen(pCfgItem->pszVal) + 1;
1400 break;
1401
1402 case TSTDEVCFGITEMTYPE_BYTES:
1403 AssertFailed();
1404 break;
1405
1406 default:
1407 rc = VERR_CFGM_IPE_1;
1408 AssertMsgFailed(("Invalid value type %d\n", pCfgItem->enmType));
1409 break;
1410 }
1411 }
1412 return rc;
1413}
1414
1415
1416static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryInteger(PCFGMNODE pNode, const char *pszName, uint64_t *pu64)
1417{
1418 if (!pNode)
1419 return VERR_CFGM_NO_PARENT;
1420
1421 PCTSTDEVCFGITEM pCfgItem;
1422 int rc = tstDev_CfgmR3ResolveItem(pNode->pDut->pTestcaseReg->paDevCfg, pszName, &pCfgItem);
1423 if (RT_SUCCESS(rc))
1424 {
1425 if (pCfgItem->enmType == TSTDEVCFGITEMTYPE_INTEGER)
1426 *pu64 = RTStrToUInt64(pCfgItem->pszVal);
1427 else
1428 rc = VERR_CFGM_NOT_INTEGER;
1429 }
1430
1431 return rc;
1432}
1433
1434
1435static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryIntegerDef(PCFGMNODE pNode, const char *pszName, uint64_t *pu64, uint64_t u64Def)
1436{
1437 int rc = pdmR3DevHlp_CFGMQueryInteger(pNode, pszName, pu64);
1438 if (RT_FAILURE(rc))
1439 {
1440 *pu64 = u64Def;
1441 if (rc == VERR_CFGM_VALUE_NOT_FOUND || rc == VERR_CFGM_NO_PARENT)
1442 rc = VINF_SUCCESS;
1443 }
1444
1445 return rc;
1446}
1447
1448
1449static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryString(PCFGMNODE pNode, const char *pszName, char *pszString, size_t cchString)
1450{
1451 if (!pNode)
1452 return VERR_CFGM_NO_PARENT;
1453
1454 PCTSTDEVCFGITEM pCfgItem;
1455 int rc = tstDev_CfgmR3ResolveItem(pNode->pDut->pTestcaseReg->paDevCfg, pszName, &pCfgItem);
1456 if (RT_SUCCESS(rc))
1457 {
1458 switch (pCfgItem->enmType)
1459 {
1460 case TSTDEVCFGITEMTYPE_STRING:
1461 {
1462 size_t cchVal = strlen(pCfgItem->pszVal);
1463 if (cchString <= cchVal + 1)
1464 memcpy(pszString, pCfgItem->pszVal, cchVal);
1465 else
1466 rc = VERR_CFGM_NOT_ENOUGH_SPACE;
1467 break;
1468 }
1469 case TSTDEVCFGITEMTYPE_INTEGER:
1470 case TSTDEVCFGITEMTYPE_BYTES:
1471 default:
1472 rc = VERR_CFGM_IPE_1;
1473 AssertMsgFailed(("Invalid value type %d\n", pCfgItem->enmType));
1474 break;
1475 }
1476 }
1477 else
1478 rc = VERR_CFGM_VALUE_NOT_FOUND;
1479
1480 return rc;
1481}
1482
1483
1484static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryStringDef(PCFGMNODE pNode, const char *pszName, char *pszString, size_t cchString, const char *pszDef)
1485{
1486 int rc = pdmR3DevHlp_CFGMQueryString(pNode, pszName, pszString, cchString);
1487 if (RT_FAILURE(rc) && rc != VERR_CFGM_NOT_ENOUGH_SPACE)
1488 {
1489 size_t cchDef = strlen(pszDef);
1490 if (cchString > cchDef)
1491 {
1492 memcpy(pszString, pszDef, cchDef);
1493 memset(pszString + cchDef, 0, cchString - cchDef);
1494 if (rc == VERR_CFGM_VALUE_NOT_FOUND || rc == VERR_CFGM_NO_PARENT)
1495 rc = VINF_SUCCESS;
1496 }
1497 else if (rc == VERR_CFGM_VALUE_NOT_FOUND || rc == VERR_CFGM_NO_PARENT)
1498 rc = VERR_CFGM_NOT_ENOUGH_SPACE;
1499 }
1500
1501 return rc;
1502}
1503
1504
1505static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryBytes(PCFGMNODE pNode, const char *pszName, void *pvData, size_t cbData)
1506{
1507 RT_NOREF(pNode, pszName, pvData, cbData);
1508 AssertFailed();
1509 return VERR_NOT_IMPLEMENTED;
1510}
1511
1512
1513static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryU64(PCFGMNODE pNode, const char *pszName, uint64_t *pu64)
1514{
1515 return pdmR3DevHlp_CFGMQueryInteger(pNode, pszName, pu64);
1516}
1517
1518
1519static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryU64Def(PCFGMNODE pNode, const char *pszName, uint64_t *pu64, uint64_t u64Def)
1520{
1521 return pdmR3DevHlp_CFGMQueryIntegerDef(pNode, pszName, pu64, u64Def);
1522}
1523
1524
1525static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryS64(PCFGMNODE pNode, const char *pszName, int64_t *pi64)
1526{
1527 RT_NOREF(pNode, pszName, pi64);
1528 AssertFailed();
1529 return VERR_NOT_IMPLEMENTED;
1530}
1531
1532
1533static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryS64Def(PCFGMNODE pNode, const char *pszName, int64_t *pi64, int64_t i64Def)
1534{
1535 RT_NOREF(pNode, pszName, pi64, i64Def);
1536 AssertFailed();
1537 return VERR_NOT_IMPLEMENTED;
1538}
1539
1540
1541static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryU32(PCFGMNODE pNode, const char *pszName, uint32_t *pu32)
1542{
1543 uint64_t u64;
1544 int rc = pdmR3DevHlp_CFGMQueryInteger(pNode, pszName, &u64);
1545 if (RT_SUCCESS(rc))
1546 {
1547 if (!(u64 & UINT64_C(0xffffffff00000000)))
1548 *pu32 = (uint32_t)u64;
1549 else
1550 rc = VERR_CFGM_INTEGER_TOO_BIG;
1551 }
1552 return rc;
1553}
1554
1555
1556static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryU32Def(PCFGMNODE pNode, const char *pszName, uint32_t *pu32, uint32_t u32Def)
1557{
1558 uint64_t u64;
1559 int rc = pdmR3DevHlp_CFGMQueryIntegerDef(pNode, pszName, &u64, u32Def);
1560 if (RT_SUCCESS(rc))
1561 {
1562 if (!(u64 & UINT64_C(0xffffffff00000000)))
1563 *pu32 = (uint32_t)u64;
1564 else
1565 rc = VERR_CFGM_INTEGER_TOO_BIG;
1566 }
1567 if (RT_FAILURE(rc))
1568 *pu32 = u32Def;
1569 return rc;
1570}
1571
1572
1573static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryS32(PCFGMNODE pNode, const char *pszName, int32_t *pi32)
1574{
1575 uint64_t u64;
1576 int rc = pdmR3DevHlp_CFGMQueryInteger(pNode, pszName, &u64);
1577 if (RT_SUCCESS(rc))
1578 {
1579 if ( !(u64 & UINT64_C(0xffffffff80000000))
1580 || (u64 & UINT64_C(0xffffffff80000000)) == UINT64_C(0xffffffff80000000))
1581 *pi32 = (int32_t)u64;
1582 else
1583 rc = VERR_CFGM_INTEGER_TOO_BIG;
1584 }
1585 return rc;
1586}
1587
1588
1589static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryS32Def(PCFGMNODE pNode, const char *pszName, int32_t *pi32, int32_t i32Def)
1590{
1591 uint64_t u64;
1592 int rc = pdmR3DevHlp_CFGMQueryIntegerDef(pNode, pszName, &u64, i32Def);
1593 if (RT_SUCCESS(rc))
1594 {
1595 if ( !(u64 & UINT64_C(0xffffffff80000000))
1596 || (u64 & UINT64_C(0xffffffff80000000)) == UINT64_C(0xffffffff80000000))
1597 *pi32 = (int32_t)u64;
1598 else
1599 rc = VERR_CFGM_INTEGER_TOO_BIG;
1600 }
1601 if (RT_FAILURE(rc))
1602 *pi32 = i32Def;
1603 return rc;
1604}
1605
1606
1607static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryU16(PCFGMNODE pNode, const char *pszName, uint16_t *pu16)
1608{
1609 uint64_t u64;
1610 int rc = pdmR3DevHlp_CFGMQueryInteger(pNode, pszName, &u64);
1611 if (RT_SUCCESS(rc))
1612 {
1613 if (!(u64 & UINT64_C(0xffffffffffff0000)))
1614 *pu16 = (int16_t)u64;
1615 else
1616 rc = VERR_CFGM_INTEGER_TOO_BIG;
1617 }
1618 return rc;
1619}
1620
1621
1622static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryU16Def(PCFGMNODE pNode, const char *pszName, uint16_t *pu16, uint16_t u16Def)
1623{
1624 uint64_t u64;
1625 int rc = pdmR3DevHlp_CFGMQueryIntegerDef(pNode, pszName, &u64, u16Def);
1626 if (RT_SUCCESS(rc))
1627 {
1628 if (!(u64 & UINT64_C(0xffffffffffff0000)))
1629 *pu16 = (int16_t)u64;
1630 else
1631 rc = VERR_CFGM_INTEGER_TOO_BIG;
1632 }
1633 if (RT_FAILURE(rc))
1634 *pu16 = u16Def;
1635 return rc;
1636}
1637
1638
1639static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryS16(PCFGMNODE pNode, const char *pszName, int16_t *pi16)
1640{
1641 RT_NOREF(pNode, pszName, pi16);
1642 AssertFailed();
1643 return VERR_NOT_IMPLEMENTED;
1644}
1645
1646
1647static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryS16Def(PCFGMNODE pNode, const char *pszName, int16_t *pi16, int16_t i16Def)
1648{
1649 RT_NOREF(pNode, pszName, pi16, i16Def);
1650 AssertFailed();
1651 return VERR_NOT_IMPLEMENTED;
1652}
1653
1654
1655static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryU8(PCFGMNODE pNode, const char *pszName, uint8_t *pu8)
1656{
1657 uint64_t u64;
1658 int rc = pdmR3DevHlp_CFGMQueryInteger(pNode, pszName, &u64);
1659 if (RT_SUCCESS(rc))
1660 {
1661 if (!(u64 & UINT64_C(0xffffffffffffff00)))
1662 *pu8 = (uint8_t)u64;
1663 else
1664 rc = VERR_CFGM_INTEGER_TOO_BIG;
1665 }
1666 return rc;
1667}
1668
1669
1670static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryU8Def(PCFGMNODE pNode, const char *pszName, uint8_t *pu8, uint8_t u8Def)
1671{
1672 uint64_t u64;
1673 int rc = pdmR3DevHlp_CFGMQueryIntegerDef(pNode, pszName, &u64, u8Def);
1674 if (RT_SUCCESS(rc))
1675 {
1676 if (!(u64 & UINT64_C(0xffffffffffffff00)))
1677 *pu8 = (uint8_t)u64;
1678 else
1679 rc = VERR_CFGM_INTEGER_TOO_BIG;
1680 }
1681 if (RT_FAILURE(rc))
1682 *pu8 = u8Def;
1683 return rc;
1684}
1685
1686
1687static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryS8(PCFGMNODE pNode, const char *pszName, int8_t *pi8)
1688{
1689 RT_NOREF(pNode, pszName, pi8);
1690 AssertFailed();
1691 return VERR_NOT_IMPLEMENTED;
1692}
1693
1694
1695static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryS8Def(PCFGMNODE pNode, const char *pszName, int8_t *pi8, int8_t i8Def)
1696{
1697 RT_NOREF(pNode, pszName, pi8, i8Def);
1698 AssertFailed();
1699 return VERR_NOT_IMPLEMENTED;
1700}
1701
1702
1703static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryBool(PCFGMNODE pNode, const char *pszName, bool *pf)
1704{
1705 uint64_t u64;
1706 int rc = pdmR3DevHlp_CFGMQueryInteger(pNode, pszName, &u64);
1707 if (RT_SUCCESS(rc))
1708 *pf = u64 ? true : false;
1709 return rc;
1710}
1711
1712
1713static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryBoolDef(PCFGMNODE pNode, const char *pszName, bool *pf, bool fDef)
1714{
1715 uint64_t u64;
1716 int rc = pdmR3DevHlp_CFGMQueryIntegerDef(pNode, pszName, &u64, fDef);
1717 *pf = u64 ? true : false;
1718 return rc;
1719}
1720
1721
1722static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryPort(PCFGMNODE pNode, const char *pszName, PRTIOPORT pPort)
1723{
1724 RT_NOREF(pNode, pszName, pPort);
1725 AssertFailed();
1726 return VERR_NOT_IMPLEMENTED;
1727}
1728
1729
1730static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryPortDef(PCFGMNODE pNode, const char *pszName, PRTIOPORT pPort, RTIOPORT PortDef)
1731{
1732 AssertCompileSize(RTIOPORT, 2);
1733 return pdmR3DevHlp_CFGMQueryU16Def(pNode, pszName, pPort, PortDef);
1734}
1735
1736
1737static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryUInt(PCFGMNODE pNode, const char *pszName, unsigned int *pu)
1738{
1739 RT_NOREF(pNode, pszName, pu);
1740 AssertFailed();
1741 return VERR_NOT_IMPLEMENTED;
1742}
1743
1744
1745static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryUIntDef(PCFGMNODE pNode, const char *pszName, unsigned int *pu, unsigned int uDef)
1746{
1747 RT_NOREF(pNode, pszName, pu, uDef);
1748 AssertFailed();
1749 return VERR_NOT_IMPLEMENTED;
1750}
1751
1752
1753static DECLCALLBACK(int) pdmR3DevHlp_CFGMQuerySInt(PCFGMNODE pNode, const char *pszName, signed int *pi)
1754{
1755 RT_NOREF(pNode, pszName, pi);
1756 AssertFailed();
1757 return VERR_NOT_IMPLEMENTED;
1758}
1759
1760
1761static DECLCALLBACK(int) pdmR3DevHlp_CFGMQuerySIntDef(PCFGMNODE pNode, const char *pszName, signed int *pi, signed int iDef)
1762{
1763 RT_NOREF(pNode, pszName, pi, iDef);
1764 AssertFailed();
1765 return VERR_NOT_IMPLEMENTED;
1766}
1767
1768
1769static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryPtr(PCFGMNODE pNode, const char *pszName, void **ppv)
1770{
1771 uint64_t u64;
1772 int rc = pdmR3DevHlp_CFGMQueryInteger(pNode, pszName, &u64);
1773 if (RT_SUCCESS(rc))
1774 {
1775 uintptr_t u = (uintptr_t)u64;
1776 if (u64 == u)
1777 *ppv = (void *)u;
1778 else
1779 rc = VERR_CFGM_INTEGER_TOO_BIG;
1780 }
1781 return rc;
1782}
1783
1784
1785static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryPtrDef(PCFGMNODE pNode, const char *pszName, void **ppv, void *pvDef)
1786{
1787 RT_NOREF(pNode, pszName, ppv, pvDef);
1788 AssertFailed();
1789 return VERR_NOT_IMPLEMENTED;
1790}
1791
1792
1793static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryGCPtr(PCFGMNODE pNode, const char *pszName, PRTGCPTR pGCPtr)
1794{
1795 RT_NOREF(pNode, pszName, pGCPtr);
1796 AssertFailed();
1797 return VERR_NOT_IMPLEMENTED;
1798}
1799
1800
1801static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryGCPtrDef(PCFGMNODE pNode, const char *pszName, PRTGCPTR pGCPtr, RTGCPTR GCPtrDef)
1802{
1803 RT_NOREF(pNode, pszName, pGCPtr, GCPtrDef);
1804 AssertFailed();
1805 return VERR_NOT_IMPLEMENTED;
1806}
1807
1808
1809static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryGCPtrU(PCFGMNODE pNode, const char *pszName, PRTGCUINTPTR pGCPtr)
1810{
1811 RT_NOREF(pNode, pszName, pGCPtr);
1812 AssertFailed();
1813 return VERR_NOT_IMPLEMENTED;
1814}
1815
1816
1817static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryGCPtrUDef(PCFGMNODE pNode, const char *pszName, PRTGCUINTPTR pGCPtr, RTGCUINTPTR GCPtrDef)
1818{
1819 RT_NOREF(pNode, pszName, pGCPtr, GCPtrDef);
1820 AssertFailed();
1821 return VERR_NOT_IMPLEMENTED;
1822}
1823
1824
1825static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryGCPtrS(PCFGMNODE pNode, const char *pszName, PRTGCINTPTR pGCPtr)
1826{
1827 RT_NOREF(pNode, pszName, pGCPtr);
1828 AssertFailed();
1829 return VERR_NOT_IMPLEMENTED;
1830}
1831
1832
1833static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryGCPtrSDef(PCFGMNODE pNode, const char *pszName, PRTGCINTPTR pGCPtr, RTGCINTPTR GCPtrDef)
1834{
1835 RT_NOREF(pNode, pszName, pGCPtr, GCPtrDef);
1836 AssertFailed();
1837 return VERR_NOT_IMPLEMENTED;
1838}
1839
1840
1841static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryStringAlloc(PCFGMNODE pNode, const char *pszName, char **ppszString)
1842{
1843 RT_NOREF(pNode, pszName, ppszString);
1844 AssertFailed();
1845 return VERR_NOT_IMPLEMENTED;
1846}
1847
1848
1849static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryStringAllocDef(PCFGMNODE pNode, const char *pszName, char **ppszString, const char *pszDef)
1850{
1851 RT_NOREF(pNode, pszName, ppszString, pszDef);
1852 AssertFailed();
1853 return VERR_NOT_IMPLEMENTED;
1854}
1855
1856
1857static DECLCALLBACK(PCFGMNODE) pdmR3DevHlp_CFGMGetParent(PCFGMNODE pNode)
1858{
1859 RT_NOREF(pNode);
1860 AssertFailed();
1861 return NULL;
1862}
1863
1864
1865static DECLCALLBACK(PCFGMNODE) pdmR3DevHlp_CFGMGetChild(PCFGMNODE pNode, const char *pszPath)
1866{
1867 RT_NOREF(pNode, pszPath);
1868 AssertFailed();
1869 return NULL;
1870}
1871
1872
1873static DECLCALLBACK(PCFGMNODE) pdmR3DevHlp_CFGMGetChildF(PCFGMNODE pNode, const char *pszPathFormat, ...) RT_IPRT_FORMAT_ATTR(2, 3)
1874{
1875 RT_NOREF(pNode, pszPathFormat);
1876 AssertFailed();
1877 return NULL;
1878}
1879
1880
1881static DECLCALLBACK(PCFGMNODE) pdmR3DevHlp_CFGMGetChildFV(PCFGMNODE pNode, const char *pszPathFormat, va_list Args) RT_IPRT_FORMAT_ATTR(3, 0)
1882{
1883 RT_NOREF(pNode, pszPathFormat, Args);
1884 AssertFailed();
1885 return NULL;
1886}
1887
1888
1889static DECLCALLBACK(PCFGMNODE) pdmR3DevHlp_CFGMGetFirstChild(PCFGMNODE pNode)
1890{
1891 RT_NOREF(pNode);
1892 AssertFailed();
1893 return NULL;
1894}
1895
1896
1897static DECLCALLBACK(PCFGMNODE) pdmR3DevHlp_CFGMGetNextChild(PCFGMNODE pCur)
1898{
1899 RT_NOREF(pCur);
1900 AssertFailed();
1901 return NULL;
1902}
1903
1904
1905static DECLCALLBACK(int) pdmR3DevHlp_CFGMGetName(PCFGMNODE pCur, char *pszName, size_t cchName)
1906{
1907 RT_NOREF(pCur, pszName, cchName);
1908 AssertFailed();
1909 return VERR_NOT_IMPLEMENTED;
1910}
1911
1912
1913static DECLCALLBACK(size_t) pdmR3DevHlp_CFGMGetNameLen(PCFGMNODE pCur)
1914{
1915 RT_NOREF(pCur);
1916 AssertFailed();
1917 return 0;
1918}
1919
1920
1921static DECLCALLBACK(bool) pdmR3DevHlp_CFGMAreChildrenValid(PCFGMNODE pNode, const char *pszzValid)
1922{
1923 RT_NOREF(pNode, pszzValid);
1924 AssertFailed();
1925 return false;
1926}
1927
1928
1929static DECLCALLBACK(PCFGMLEAF) pdmR3DevHlp_CFGMGetFirstValue(PCFGMNODE pCur)
1930{
1931 RT_NOREF(pCur);
1932 AssertFailed();
1933 return NULL;
1934}
1935
1936
1937static DECLCALLBACK(PCFGMLEAF) pdmR3DevHlp_CFGMGetNextValue(PCFGMLEAF pCur)
1938{
1939 RT_NOREF(pCur);
1940 AssertFailed();
1941 return NULL;
1942}
1943
1944
1945static DECLCALLBACK(int) pdmR3DevHlp_CFGMGetValueName(PCFGMLEAF pCur, char *pszName, size_t cchName)
1946{
1947 RT_NOREF(pCur, pszName, cchName);
1948 AssertFailed();
1949 return VERR_NOT_IMPLEMENTED;
1950}
1951
1952
1953static DECLCALLBACK(size_t) pdmR3DevHlp_CFGMGetValueNameLen(PCFGMLEAF pCur)
1954{
1955 RT_NOREF(pCur);
1956 AssertFailed();
1957 return 0;
1958}
1959
1960
1961static DECLCALLBACK(CFGMVALUETYPE) pdmR3DevHlp_CFGMGetValueType(PCFGMLEAF pCur)
1962{
1963 RT_NOREF(pCur);
1964 AssertFailed();
1965 return CFGMVALUETYPE_INTEGER;
1966}
1967
1968
1969static DECLCALLBACK(bool) pdmR3DevHlp_CFGMAreValuesValid(PCFGMNODE pNode, const char *pszzValid)
1970{
1971 if (pNode && pNode->pDut->pTestcaseReg->paDevCfg)
1972 {
1973 PCTSTDEVCFGITEM pDevCfgItem = pNode->pDut->pTestcaseReg->paDevCfg;
1974 while (pDevCfgItem->pszKey != NULL)
1975 {
1976 size_t cchKey = strlen(pDevCfgItem->pszKey);
1977
1978 /* search pszzValid for the name */
1979 const char *psz = pszzValid;
1980 while (*psz)
1981 {
1982 size_t cch = strlen(psz);
1983 if ( cch == cchKey
1984 && !memcmp(psz, pDevCfgItem->pszKey, cch))
1985 break;
1986
1987 /* next */
1988 psz += cch + 1;
1989 }
1990
1991 /* if at end of pszzValid we didn't find it => failure */
1992 if (!*psz)
1993 return false;
1994
1995 pDevCfgItem++;
1996 }
1997 }
1998
1999 return true;
2000}
2001
2002
2003static DECLCALLBACK(int) pdmR3DevHlp_CFGMValidateConfig(PCFGMNODE pNode, const char *pszNode,
2004 const char *pszValidValues, const char *pszValidNodes,
2005 const char *pszWho, uint32_t uInstance)
2006{
2007 RT_NOREF(pNode, pszNode, pszValidValues, pszValidNodes, pszWho, uInstance);
2008#if 1
2009 return VINF_SUCCESS;
2010#else
2011 AssertFailed();
2012 return VERR_NOT_IMPLEMENTED;
2013#endif
2014}
2015
2016
2017/** @interface_method_impl{PDMDEVHLPR3,pfnTMTimeVirtGet} */
2018static DECLCALLBACK(uint64_t) pdmR3DevHlp_TMTimeVirtGet(PPDMDEVINS pDevIns)
2019{
2020 PDMDEV_ASSERT_DEVINS(pDevIns);
2021 LogFlow(("pdmR3DevHlp_TMTimeVirtGet: caller='%s'/%d\n",
2022 pDevIns->pReg->szName, pDevIns->iInstance));
2023
2024 uint64_t u64Time = 0;
2025 AssertFailed();
2026
2027 LogFlow(("pdmR3DevHlp_TMTimeVirtGet: caller='%s'/%d: returns %RU64\n", pDevIns->pReg->szName, pDevIns->iInstance, u64Time));
2028 return u64Time;
2029}
2030
2031
2032/** @interface_method_impl{PDMDEVHLPR3,pfnTMTimeVirtGetFreq} */
2033static DECLCALLBACK(uint64_t) pdmR3DevHlp_TMTimeVirtGetFreq(PPDMDEVINS pDevIns)
2034{
2035 PDMDEV_ASSERT_DEVINS(pDevIns);
2036 LogFlow(("pdmR3DevHlp_TMTimeVirtGetFreq: caller='%s'/%d\n",
2037 pDevIns->pReg->szName, pDevIns->iInstance));
2038
2039 uint64_t u64Freq = 0;
2040 AssertFailed();
2041
2042 LogFlow(("pdmR3DevHlp_TMTimeVirtGetFreq: caller='%s'/%d: returns %RU64\n", pDevIns->pReg->szName, pDevIns->iInstance, u64Freq));
2043 return u64Freq;
2044}
2045
2046
2047/** @interface_method_impl{PDMDEVHLPR3,pfnTMTimeVirtGetNano} */
2048static DECLCALLBACK(uint64_t) pdmR3DevHlp_TMTimeVirtGetNano(PPDMDEVINS pDevIns)
2049{
2050 PDMDEV_ASSERT_DEVINS(pDevIns);
2051 LogFlow(("pdmR3DevHlp_TMTimeVirtGetNano: caller='%s'/%d\n",
2052 pDevIns->pReg->szName, pDevIns->iInstance));
2053
2054 uint64_t u64Nano = 0;
2055 AssertFailed();
2056
2057 LogFlow(("pdmR3DevHlp_TMTimeVirtGetNano: caller='%s'/%d: returns %RU64\n", pDevIns->pReg->szName, pDevIns->iInstance, u64Nano));
2058 return u64Nano;
2059}
2060
2061
2062/** @interface_method_impl{PDMDEVHLPR3,pfnGetSupDrvSession} */
2063static DECLCALLBACK(PSUPDRVSESSION) pdmR3DevHlp_GetSupDrvSession(PPDMDEVINS pDevIns)
2064{
2065 PDMDEV_ASSERT_DEVINS(pDevIns);
2066 LogFlow(("pdmR3DevHlp_GetSupDrvSession: caller='%s'/%d\n",
2067 pDevIns->pReg->szName, pDevIns->iInstance));
2068
2069 PSUPDRVSESSION pSession = NIL_RTR0PTR;
2070 AssertFailed();
2071
2072 LogFlow(("pdmR3DevHlp_GetSupDrvSession: caller='%s'/%d: returns %#p\n", pDevIns->pReg->szName, pDevIns->iInstance, pSession));
2073 return pSession;
2074}
2075
2076
2077/** @interface_method_impl{PDMDEVHLPR3,pfnQueryGenericUserObject} */
2078static DECLCALLBACK(void *) pdmR3DevHlp_QueryGenericUserObject(PPDMDEVINS pDevIns, PCRTUUID pUuid)
2079{
2080 PDMDEV_ASSERT_DEVINS(pDevIns);
2081 LogFlow(("pdmR3DevHlp_QueryGenericUserObject: caller='%s'/%d: pUuid=%p:%RTuuid\n",
2082 pDevIns->pReg->szName, pDevIns->iInstance, pUuid, pUuid));
2083
2084#if defined(DEBUG_bird) || defined(DEBUG_ramshankar) || defined(DEBUG_sunlover) || defined(DEBUG_michael) || defined(DEBUG_andy)
2085 AssertMsgFailed(("'%s' wants %RTuuid - external only interface!\n", pDevIns->pReg->szName, pUuid));
2086#endif
2087
2088 void *pvRet = NULL;
2089 AssertFailed();
2090
2091 LogRel(("pdmR3DevHlp_QueryGenericUserObject: caller='%s'/%d: returns %#p for %RTuuid\n",
2092 pDevIns->pReg->szName, pDevIns->iInstance, pvRet, pUuid));
2093 return pvRet;
2094}
2095
2096
2097/** @interface_method_impl{PDMDEVHLPR3,pfnPhysRead} */
2098static DECLCALLBACK(int) pdmR3DevHlp_PhysRead(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, void *pvBuf, size_t cbRead)
2099{
2100 PDMDEV_ASSERT_DEVINS(pDevIns);
2101 LogFlow(("pdmR3DevHlp_PhysRead: caller='%s'/%d: GCPhys=%RGp pvBuf=%p cbRead=%#x\n",
2102 pDevIns->pReg->szName, pDevIns->iInstance, GCPhys, pvBuf, cbRead));
2103
2104 VBOXSTRICTRC rcStrict = VERR_NOT_IMPLEMENTED;;
2105 AssertFailed();
2106
2107 Log(("pdmR3DevHlp_PhysRead: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, VBOXSTRICTRC_VAL(rcStrict) ));
2108 return VBOXSTRICTRC_VAL(rcStrict);
2109}
2110
2111
2112/** @interface_method_impl{PDMDEVHLPR3,pfnPhysWrite} */
2113static DECLCALLBACK(int) pdmR3DevHlp_PhysWrite(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, const void *pvBuf, size_t cbWrite)
2114{
2115 PDMDEV_ASSERT_DEVINS(pDevIns);
2116 LogFlow(("pdmR3DevHlp_PhysWrite: caller='%s'/%d: GCPhys=%RGp pvBuf=%p cbWrite=%#x\n",
2117 pDevIns->pReg->szName, pDevIns->iInstance, GCPhys, pvBuf, cbWrite));
2118
2119 VBOXSTRICTRC rcStrict = VERR_NOT_IMPLEMENTED;;
2120 AssertFailed();
2121
2122 Log(("pdmR3DevHlp_PhysWrite: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, VBOXSTRICTRC_VAL(rcStrict) ));
2123 return VBOXSTRICTRC_VAL(rcStrict);
2124}
2125
2126
2127/** @interface_method_impl{PDMDEVHLPR3,pfnPhysGCPhys2CCPtr} */
2128static DECLCALLBACK(int) pdmR3DevHlp_PhysGCPhys2CCPtr(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, uint32_t fFlags, void **ppv, PPGMPAGEMAPLOCK pLock)
2129{
2130 PDMDEV_ASSERT_DEVINS(pDevIns);
2131 LogFlow(("pdmR3DevHlp_PhysGCPhys2CCPtr: caller='%s'/%d: GCPhys=%RGp fFlags=%#x ppv=%p pLock=%p\n",
2132 pDevIns->pReg->szName, pDevIns->iInstance, GCPhys, fFlags, ppv, pLock));
2133 AssertReturn(!fFlags, VERR_INVALID_PARAMETER);
2134
2135 int rc = VERR_NOT_IMPLEMENTED;;
2136 AssertFailed();
2137
2138 Log(("pdmR3DevHlp_PhysGCPhys2CCPtr: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
2139 return rc;
2140}
2141
2142
2143/** @interface_method_impl{PDMDEVHLPR3,pfnPhysGCPhys2CCPtrReadOnly} */
2144static DECLCALLBACK(int) pdmR3DevHlp_PhysGCPhys2CCPtrReadOnly(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, uint32_t fFlags, const void **ppv, PPGMPAGEMAPLOCK pLock)
2145{
2146 PDMDEV_ASSERT_DEVINS(pDevIns);
2147 LogFlow(("pdmR3DevHlp_PhysGCPhys2CCPtrReadOnly: caller='%s'/%d: GCPhys=%RGp fFlags=%#x ppv=%p pLock=%p\n",
2148 pDevIns->pReg->szName, pDevIns->iInstance, GCPhys, fFlags, ppv, pLock));
2149 AssertReturn(!fFlags, VERR_INVALID_PARAMETER);
2150
2151 int rc = VERR_NOT_IMPLEMENTED;;
2152 AssertFailed();
2153
2154 Log(("pdmR3DevHlp_PhysGCPhys2CCPtrReadOnly: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
2155 return rc;
2156}
2157
2158
2159/** @interface_method_impl{PDMDEVHLPR3,pfnPhysReleasePageMappingLock} */
2160static DECLCALLBACK(void) pdmR3DevHlp_PhysReleasePageMappingLock(PPDMDEVINS pDevIns, PPGMPAGEMAPLOCK pLock)
2161{
2162 PDMDEV_ASSERT_DEVINS(pDevIns);
2163 LogFlow(("pdmR3DevHlp_PhysReleasePageMappingLock: caller='%s'/%d: pLock=%p\n",
2164 pDevIns->pReg->szName, pDevIns->iInstance, pLock));
2165
2166 AssertFailed();
2167
2168 Log(("pdmR3DevHlp_PhysReleasePageMappingLock: caller='%s'/%d: returns void\n", pDevIns->pReg->szName, pDevIns->iInstance));
2169}
2170
2171
2172/** @interface_method_impl{PDMDEVHLPR3,pfnPhysBulkGCPhys2CCPtr} */
2173static DECLCALLBACK(int) pdmR3DevHlp_PhysBulkGCPhys2CCPtr(PPDMDEVINS pDevIns, uint32_t cPages, PCRTGCPHYS paGCPhysPages,
2174 uint32_t fFlags, void **papvPages, PPGMPAGEMAPLOCK paLocks)
2175{
2176 PDMDEV_ASSERT_DEVINS(pDevIns);
2177 LogFlow(("pdmR3DevHlp_PhysBulkGCPhys2CCPtr: caller='%s'/%d: cPages=%#x paGCPhysPages=%p (%RGp,..) fFlags=%#x papvPages=%p paLocks=%p\n",
2178 pDevIns->pReg->szName, pDevIns->iInstance, cPages, paGCPhysPages, paGCPhysPages[0], fFlags, papvPages, paLocks));
2179 AssertReturn(!fFlags, VERR_INVALID_PARAMETER);
2180 AssertReturn(cPages > 0, VERR_INVALID_PARAMETER);
2181
2182 int rc = VERR_NOT_IMPLEMENTED;;
2183 AssertFailed();
2184
2185 Log(("pdmR3DevHlp_PhysBulkGCPhys2CCPtr: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
2186 return rc;
2187}
2188
2189
2190/** @interface_method_impl{PDMDEVHLPR3,pfnPhysBulkGCPhys2CCPtrReadOnly} */
2191static DECLCALLBACK(int) pdmR3DevHlp_PhysBulkGCPhys2CCPtrReadOnly(PPDMDEVINS pDevIns, uint32_t cPages, PCRTGCPHYS paGCPhysPages,
2192 uint32_t fFlags, const void **papvPages, PPGMPAGEMAPLOCK paLocks)
2193{
2194 PDMDEV_ASSERT_DEVINS(pDevIns);
2195 LogFlow(("pdmR3DevHlp_PhysBulkGCPhys2CCPtrReadOnly: caller='%s'/%d: cPages=%#x paGCPhysPages=%p (%RGp,...) fFlags=%#x papvPages=%p paLocks=%p\n",
2196 pDevIns->pReg->szName, pDevIns->iInstance, cPages, paGCPhysPages, paGCPhysPages[0], fFlags, papvPages, paLocks));
2197 AssertReturn(!fFlags, VERR_INVALID_PARAMETER);
2198 AssertReturn(cPages > 0, VERR_INVALID_PARAMETER);
2199
2200 int rc = VERR_NOT_IMPLEMENTED;;
2201 AssertFailed();
2202
2203 Log(("pdmR3DevHlp_PhysBulkGCPhys2CCPtrReadOnly: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
2204 return rc;
2205}
2206
2207
2208/** @interface_method_impl{PDMDEVHLPR3,pfnPhysBulkReleasePageMappingLocks} */
2209static DECLCALLBACK(void) pdmR3DevHlp_PhysBulkReleasePageMappingLocks(PPDMDEVINS pDevIns, uint32_t cPages, PPGMPAGEMAPLOCK paLocks)
2210{
2211 PDMDEV_ASSERT_DEVINS(pDevIns);
2212 LogFlow(("pdmR3DevHlp_PhysBulkReleasePageMappingLocks: caller='%s'/%d: cPages=%#x paLocks=%p\n",
2213 pDevIns->pReg->szName, pDevIns->iInstance, cPages, paLocks));
2214 Assert(cPages > 0);
2215
2216 AssertFailed();
2217
2218 Log(("pdmR3DevHlp_PhysBulkReleasePageMappingLocks: caller='%s'/%d: returns void\n", pDevIns->pReg->szName, pDevIns->iInstance));
2219}
2220
2221
2222/** @interface_method_impl{PDMDEVHLPR3,pfnPhysReadGCVirt} */
2223static DECLCALLBACK(int) pdmR3DevHlp_PhysReadGCVirt(PPDMDEVINS pDevIns, void *pvDst, RTGCPTR GCVirtSrc, size_t cb)
2224{
2225 PDMDEV_ASSERT_DEVINS(pDevIns);
2226 LogFlow(("pdmR3DevHlp_PhysReadGCVirt: caller='%s'/%d: pvDst=%p GCVirt=%RGv cb=%#x\n",
2227 pDevIns->pReg->szName, pDevIns->iInstance, pvDst, GCVirtSrc, cb));
2228
2229 int rc = VERR_NOT_IMPLEMENTED;;
2230 AssertFailed();
2231
2232 LogFlow(("pdmR3DevHlp_PhysReadGCVirt: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
2233
2234 return rc;
2235}
2236
2237
2238/** @interface_method_impl{PDMDEVHLPR3,pfnPhysWriteGCVirt} */
2239static DECLCALLBACK(int) pdmR3DevHlp_PhysWriteGCVirt(PPDMDEVINS pDevIns, RTGCPTR GCVirtDst, const void *pvSrc, size_t cb)
2240{
2241 PDMDEV_ASSERT_DEVINS(pDevIns);
2242 LogFlow(("pdmR3DevHlp_PhysWriteGCVirt: caller='%s'/%d: GCVirtDst=%RGv pvSrc=%p cb=%#x\n",
2243 pDevIns->pReg->szName, pDevIns->iInstance, GCVirtDst, pvSrc, cb));
2244
2245 int rc = VERR_NOT_IMPLEMENTED;;
2246 AssertFailed();
2247
2248 LogFlow(("pdmR3DevHlp_PhysWriteGCVirt: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
2249
2250 return rc;
2251}
2252
2253
2254/** @interface_method_impl{PDMDEVHLPR3,pfnPhysGCPtr2GCPhys} */
2255static DECLCALLBACK(int) pdmR3DevHlp_PhysGCPtr2GCPhys(PPDMDEVINS pDevIns, RTGCPTR GCPtr, PRTGCPHYS pGCPhys)
2256{
2257 PDMDEV_ASSERT_DEVINS(pDevIns);
2258 LogFlow(("pdmR3DevHlp_PhysGCPtr2GCPhys: caller='%s'/%d: GCPtr=%RGv pGCPhys=%p\n",
2259 pDevIns->pReg->szName, pDevIns->iInstance, GCPtr, pGCPhys));
2260
2261 int rc = VERR_NOT_IMPLEMENTED;
2262 AssertFailed();
2263
2264 LogFlow(("pdmR3DevHlp_PhysGCPtr2GCPhys: caller='%s'/%d: returns %Rrc *pGCPhys=%RGp\n", pDevIns->pReg->szName, pDevIns->iInstance, rc, *pGCPhys));
2265
2266 return rc;
2267}
2268
2269
2270/** @interface_method_impl{PDMDEVHLPR3,pfnMMHeapAlloc} */
2271static DECLCALLBACK(void *) pdmR3DevHlp_MMHeapAlloc(PPDMDEVINS pDevIns, size_t cb)
2272{
2273 PDMDEV_ASSERT_DEVINS(pDevIns);
2274 LogFlow(("pdmR3DevHlp_MMHeapAlloc: caller='%s'/%d: cb=%#x\n", pDevIns->pReg->szName, pDevIns->iInstance, cb));
2275
2276 void *pv = NULL;
2277 AssertFailed();
2278
2279 LogFlow(("pdmR3DevHlp_MMHeapAlloc: caller='%s'/%d: returns %p\n", pDevIns->pReg->szName, pDevIns->iInstance, pv));
2280 return pv;
2281}
2282
2283
2284/** @interface_method_impl{PDMDEVHLPR3,pfnMMHeapAllocZ} */
2285static DECLCALLBACK(void *) pdmR3DevHlp_MMHeapAllocZ(PPDMDEVINS pDevIns, size_t cb)
2286{
2287 PDMDEV_ASSERT_DEVINS(pDevIns);
2288 LogFlow(("pdmR3DevHlp_MMHeapAllocZ: caller='%s'/%d: cb=%#x\n", pDevIns->pReg->szName, pDevIns->iInstance, cb));
2289
2290 void *pv = NULL;
2291 AssertFailed();
2292
2293 LogFlow(("pdmR3DevHlp_MMHeapAllocZ: caller='%s'/%d: returns %p\n", pDevIns->pReg->szName, pDevIns->iInstance, pv));
2294 return pv;
2295}
2296
2297
2298/** @interface_method_impl{PDMDEVHLPR3,pfnMMHeapFree} */
2299static DECLCALLBACK(void) pdmR3DevHlp_MMHeapFree(PPDMDEVINS pDevIns, void *pv)
2300{
2301 PDMDEV_ASSERT_DEVINS(pDevIns); RT_NOREF_PV(pDevIns);
2302 LogFlow(("pdmR3DevHlp_MMHeapFree: caller='%s'/%d: pv=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, pv));
2303
2304 PTSTDEVMMHEAPALLOC pHeapAlloc = (PTSTDEVMMHEAPALLOC)((uint8_t *)pv - RT_UOFFSETOF(TSTDEVMMHEAPALLOC, abAlloc[0]));
2305 PTSTDEVDUTINT pThis = pHeapAlloc->pDut;
2306
2307 tstDevDutLockExcl(pThis);
2308 RTListNodeRemove(&pHeapAlloc->NdMmHeap);
2309 tstDevDutUnlockExcl(pThis);
2310
2311 /* Poison */
2312 memset(&pHeapAlloc->abAlloc[0], 0xfc, pHeapAlloc->cbAlloc);
2313 RTMemFree(pHeapAlloc);
2314
2315 LogFlow(("pdmR3DevHlp_MMHeapAlloc: caller='%s'/%d: returns void\n", pDevIns->pReg->szName, pDevIns->iInstance));
2316}
2317
2318
2319/** @interface_method_impl{PDMDEVHLPR3,pfnVMState} */
2320static DECLCALLBACK(VMSTATE) pdmR3DevHlp_VMState(PPDMDEVINS pDevIns)
2321{
2322 PDMDEV_ASSERT_DEVINS(pDevIns);
2323
2324 VMSTATE enmVMState = VMSTATE_CREATING;
2325 AssertFailed();
2326
2327 LogFlow(("pdmR3DevHlp_VMState: caller='%s'/%d: returns %d\n", pDevIns->pReg->szName, pDevIns->iInstance,
2328 enmVMState));
2329 return enmVMState;
2330}
2331
2332
2333/** @interface_method_impl{PDMDEVHLPR3,pfnVMTeleportedAndNotFullyResumedYet} */
2334static DECLCALLBACK(bool) pdmR3DevHlp_VMTeleportedAndNotFullyResumedYet(PPDMDEVINS pDevIns)
2335{
2336 PDMDEV_ASSERT_DEVINS(pDevIns);
2337
2338 bool fRc = false;
2339 AssertFailed();
2340
2341 LogFlow(("pdmR3DevHlp_VMState: caller='%s'/%d: returns %RTbool\n", pDevIns->pReg->szName, pDevIns->iInstance,
2342 fRc));
2343 return fRc;
2344}
2345
2346
2347/** @interface_method_impl{PDMDEVHLPR3,pfnVMSetError} */
2348static DECLCALLBACK(int) pdmR3DevHlp_VMSetError(PPDMDEVINS pDevIns, int rc, RT_SRC_POS_DECL, const char *pszFormat, ...)
2349{
2350 PDMDEV_ASSERT_DEVINS(pDevIns);
2351
2352 RT_NOREF(pDevIns, rc, RT_SRC_POS_ARGS, pszFormat);
2353 AssertFailed();
2354
2355 return VERR_NOT_IMPLEMENTED;
2356}
2357
2358
2359/** @interface_method_impl{PDMDEVHLPR3,pfnVMSetErrorV} */
2360static DECLCALLBACK(int) pdmR3DevHlp_VMSetErrorV(PPDMDEVINS pDevIns, int rc, RT_SRC_POS_DECL, const char *pszFormat, va_list va)
2361{
2362 PDMDEV_ASSERT_DEVINS(pDevIns);
2363
2364 RT_NOREF(pDevIns, rc, RT_SRC_POS_ARGS, pszFormat, va);
2365 AssertFailed();
2366
2367 return VERR_NOT_IMPLEMENTED;
2368}
2369
2370
2371/** @interface_method_impl{PDMDEVHLPR3,pfnVMSetRuntimeError} */
2372static DECLCALLBACK(int) pdmR3DevHlp_VMSetRuntimeError(PPDMDEVINS pDevIns, uint32_t fFlags, const char *pszErrorId, const char *pszFormat, ...)
2373{
2374 PDMDEV_ASSERT_DEVINS(pDevIns);
2375
2376 RT_NOREF(pDevIns, fFlags, pszErrorId, pszFormat);
2377 int rc = VERR_NOT_IMPLEMENTED;
2378 AssertFailed();
2379
2380 return rc;
2381}
2382
2383
2384/** @interface_method_impl{PDMDEVHLPR3,pfnVMSetRuntimeErrorV} */
2385static DECLCALLBACK(int) pdmR3DevHlp_VMSetRuntimeErrorV(PPDMDEVINS pDevIns, uint32_t fFlags, const char *pszErrorId, const char *pszFormat, va_list va)
2386{
2387 PDMDEV_ASSERT_DEVINS(pDevIns);
2388
2389 RT_NOREF(pDevIns, fFlags, pszErrorId, pszFormat, va);
2390 int rc = VERR_NOT_IMPLEMENTED;
2391 AssertFailed();
2392
2393 return rc;
2394}
2395
2396
2397/** @interface_method_impl{PDMDEVHLPR3,pfnDBGFStopV} */
2398static DECLCALLBACK(int) pdmR3DevHlp_DBGFStopV(PPDMDEVINS pDevIns, const char *pszFile, unsigned iLine, const char *pszFunction, const char *pszFormat, va_list args)
2399{
2400 PDMDEV_ASSERT_DEVINS(pDevIns);
2401#ifdef LOG_ENABLED
2402 va_list va2;
2403 va_copy(va2, args);
2404 LogFlow(("pdmR3DevHlp_DBGFStopV: caller='%s'/%d: pszFile=%p:{%s} iLine=%d pszFunction=%p:{%s} pszFormat=%p:{%s} (%N)\n",
2405 pDevIns->pReg->szName, pDevIns->iInstance, pszFile, pszFile, iLine, pszFunction, pszFunction, pszFormat, pszFormat, pszFormat, &va2));
2406 va_end(va2);
2407#endif
2408
2409 int rc = VERR_NOT_IMPLEMENTED;
2410 AssertFailed();
2411
2412 LogFlow(("pdmR3DevHlp_DBGFStopV: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
2413 return rc;
2414}
2415
2416
2417/** @interface_method_impl{PDMDEVHLPR3,pfnDBGFInfoRegister} */
2418static DECLCALLBACK(int) pdmR3DevHlp_DBGFInfoRegister(PPDMDEVINS pDevIns, const char *pszName, const char *pszDesc, PFNDBGFHANDLERDEV pfnHandler)
2419{
2420 PDMDEV_ASSERT_DEVINS(pDevIns);
2421 LogFlow(("pdmR3DevHlp_DBGFInfoRegister: caller='%s'/%d: pszName=%p:{%s} pszDesc=%p:{%s} pfnHandler=%p\n",
2422 pDevIns->pReg->szName, pDevIns->iInstance, pszName, pszName, pszDesc, pszDesc, pfnHandler));
2423
2424 int rc = VERR_NOT_IMPLEMENTED;
2425 AssertFailed();
2426
2427 LogFlow(("pdmR3DevHlp_DBGFInfoRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
2428 return rc;
2429}
2430
2431
2432/** @interface_method_impl{PDMDEVHLPR3,pfnDBGFInfoRegisterArgv} */
2433static DECLCALLBACK(int) pdmR3DevHlp_DBGFInfoRegisterArgv(PPDMDEVINS pDevIns, const char *pszName, const char *pszDesc, PFNDBGFINFOARGVDEV pfnHandler)
2434{
2435 PDMDEV_ASSERT_DEVINS(pDevIns);
2436 LogFlow(("pdmR3DevHlp_DBGFInfoRegisterArgv: caller='%s'/%d: pszName=%p:{%s} pszDesc=%p:{%s} pfnHandler=%p\n",
2437 pDevIns->pReg->szName, pDevIns->iInstance, pszName, pszName, pszDesc, pszDesc, pfnHandler));
2438
2439 int rc = VERR_NOT_IMPLEMENTED;
2440 AssertFailed();
2441
2442 LogFlow(("pdmR3DevHlp_DBGFInfoRegisterArgv: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
2443 return rc;
2444}
2445
2446
2447/** @interface_method_impl{PDMDEVHLPR3,pfnDBGFRegRegister} */
2448static DECLCALLBACK(int) pdmR3DevHlp_DBGFRegRegister(PPDMDEVINS pDevIns, PCDBGFREGDESC paRegisters)
2449{
2450 PDMDEV_ASSERT_DEVINS(pDevIns);
2451 LogFlow(("pdmR3DevHlp_DBGFRegRegister: caller='%s'/%d: paRegisters=%p\n",
2452 pDevIns->pReg->szName, pDevIns->iInstance, paRegisters));
2453
2454 int rc = VERR_NOT_IMPLEMENTED;
2455 AssertFailed();
2456
2457 LogFlow(("pdmR3DevHlp_DBGFRegRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
2458 return rc;
2459}
2460
2461
2462/** @interface_method_impl{PDMDEVHLPR3,pfnDBGFTraceBuf} */
2463static DECLCALLBACK(RTTRACEBUF) pdmR3DevHlp_DBGFTraceBuf(PPDMDEVINS pDevIns)
2464{
2465 PDMDEV_ASSERT_DEVINS(pDevIns);
2466 RTTRACEBUF hTraceBuf = NIL_RTTRACEBUF;
2467 AssertFailed();
2468 LogFlow(("pdmR3DevHlp_DBGFTraceBuf: caller='%s'/%d: returns %p\n", pDevIns->pReg->szName, pDevIns->iInstance, hTraceBuf));
2469 return hTraceBuf;
2470}
2471
2472
2473/** @interface_method_impl{PDMDEVHLPR3,pfnSTAMRegister} */
2474static DECLCALLBACK(void) pdmR3DevHlp_STAMRegister(PPDMDEVINS pDevIns, void *pvSample, STAMTYPE enmType, const char *pszName,
2475 STAMUNIT enmUnit, const char *pszDesc)
2476{
2477 PDMDEV_ASSERT_DEVINS(pDevIns);
2478
2479 RT_NOREF(pDevIns, pvSample, enmType, pszName, enmUnit, pszDesc);
2480 AssertFailed();
2481}
2482
2483
2484/** @interface_method_impl{PDMDEVHLPR3,pfnSTAMRegisterV} */
2485static DECLCALLBACK(void) pdmR3DevHlp_STAMRegisterV(PPDMDEVINS pDevIns, void *pvSample, STAMTYPE enmType, STAMVISIBILITY enmVisibility,
2486 STAMUNIT enmUnit, const char *pszDesc, const char *pszName, va_list args)
2487{
2488 PDMDEV_ASSERT_DEVINS(pDevIns);
2489
2490 RT_NOREF(pDevIns, pvSample, enmType, enmVisibility, enmUnit, pszDesc, pszName, args);
2491 AssertFailed();
2492}
2493
2494
2495/**
2496 * @interface_method_impl{PDMDEVHLPR3,pfnPCIRegister}
2497 */
2498static DECLCALLBACK(int) pdmR3DevHlp_PCIRegister(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t fFlags,
2499 uint8_t uPciDevNo, uint8_t uPciFunNo, const char *pszName)
2500{
2501 PDMDEV_ASSERT_DEVINS(pDevIns);
2502 LogFlow(("pdmR3DevHlp_PCIRegister: caller='%s'/%d: pPciDev=%p:{.config={%#.256Rhxs} fFlags=%#x uPciDevNo=%#x uPciFunNo=%#x pszName=%p:{%s}\n",
2503 pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pPciDev->abConfig, fFlags, uPciDevNo, uPciFunNo, pszName, pszName ? pszName : ""));
2504
2505 /*
2506 * Validate input.
2507 */
2508 AssertLogRelMsgReturn(pDevIns->pReg->cMaxPciDevices > 0,
2509 ("'%s'/%d: cMaxPciDevices is 0\n", pDevIns->pReg->szName, pDevIns->iInstance),
2510 VERR_WRONG_ORDER);
2511 AssertLogRelMsgReturn(RT_VALID_PTR(pPciDev),
2512 ("'%s'/%d: Invalid pPciDev value: %p\n", pDevIns->pReg->szName, pDevIns->iInstance, pPciDev),
2513 VERR_INVALID_POINTER);
2514 AssertLogRelMsgReturn(PDMPciDevGetVendorId(pPciDev),
2515 ("'%s'/%d: Vendor ID is not set!\n", pDevIns->pReg->szName, pDevIns->iInstance),
2516 VERR_INVALID_POINTER);
2517 AssertLogRelMsgReturn( uPciDevNo < 32
2518 || uPciDevNo == PDMPCIDEVREG_DEV_NO_FIRST_UNUSED
2519 || uPciDevNo == PDMPCIDEVREG_DEV_NO_SAME_AS_PREV,
2520 ("'%s'/%d: Invalid PCI device number: %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, uPciDevNo),
2521 VERR_INVALID_PARAMETER);
2522 AssertLogRelMsgReturn( uPciFunNo < 8
2523 || uPciFunNo == PDMPCIDEVREG_FUN_NO_FIRST_UNUSED,
2524 ("'%s'/%d: Invalid PCI funcion number: %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, uPciFunNo),
2525 VERR_INVALID_PARAMETER);
2526 AssertLogRelMsgReturn(!(fFlags & ~PDMPCIDEVREG_F_VALID_MASK),
2527 ("'%s'/%d: Invalid flags: %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, fFlags),
2528 VERR_INVALID_FLAGS);
2529 if (!pszName)
2530 pszName = pDevIns->pReg->szName;
2531
2532#if 0
2533 AssertLogRelReturn(RT_VALID_PTR(pszName), VERR_INVALID_POINTER);
2534 AssertLogRelReturn(!pPciDev->Int.s.fRegistered, VERR_PDM_NOT_PCI_DEVICE);
2535 AssertLogRelReturn(pPciDev == PDMDEV_GET_PPCIDEV(pDevIns, pPciDev->Int.s.idxSubDev), VERR_PDM_NOT_PCI_DEVICE);
2536 AssertLogRelReturn(pPciDev == PDMDEV_CALC_PPCIDEV(pDevIns, pPciDev->Int.s.idxSubDev), VERR_PDM_NOT_PCI_DEVICE);
2537 AssertMsgReturn(pPciDev->u32Magic == PDMPCIDEV_MAGIC, ("%#x\n", pPciDev->u32Magic), VERR_PDM_NOT_PCI_DEVICE);
2538#endif
2539
2540 int rc = VERR_NOT_IMPLEMENTED;
2541 AssertFailed();
2542
2543 LogFlow(("pdmR3DevHlp_PCIRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
2544 return rc;
2545}
2546
2547
2548/** @interface_method_impl{PDMDEVHLPR3,pfnPCIRegisterMsi} */
2549static DECLCALLBACK(int) pdmR3DevHlp_PCIRegisterMsi(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, PPDMMSIREG pMsiReg)
2550{
2551 PDMDEV_ASSERT_DEVINS(pDevIns);
2552 if (!pPciDev) /* NULL is an alias for the default PCI device. */
2553 pPciDev = pDevIns->apPciDevs[0];
2554 AssertReturn(pPciDev, VERR_PDM_NOT_PCI_DEVICE);
2555 LogFlow(("pdmR3DevHlp_PCIRegisterMsi: caller='%s'/%d: pPciDev=%p:{%#x} pMsgReg=%p:{cMsiVectors=%d, cMsixVectors=%d}\n",
2556 pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pPciDev->uDevFn, pMsiReg, pMsiReg->cMsiVectors, pMsiReg->cMsixVectors));
2557 PDMPCIDEV_ASSERT_VALID_RET(pDevIns, pPciDev);
2558
2559 AssertLogRelMsgReturn(pDevIns->pReg->cMaxPciDevices > 0,
2560 ("'%s'/%d: cMaxPciDevices is 0\n", pDevIns->pReg->szName, pDevIns->iInstance),
2561 VERR_WRONG_ORDER);
2562 AssertLogRelMsgReturn(pMsiReg->cMsixVectors <= pDevIns->pReg->cMaxMsixVectors,
2563 ("'%s'/%d: cMsixVectors=%u cMaxMsixVectors=%u\n",
2564 pDevIns->pReg->szName, pDevIns->iInstance, pMsiReg->cMsixVectors, pDevIns->pReg->cMaxMsixVectors),
2565 VERR_INVALID_FLAGS);
2566
2567 int rc = VERR_NOT_IMPLEMENTED;
2568 AssertFailed();
2569
2570 LogFlow(("pdmR3DevHlp_PCIRegisterMsi: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
2571 return rc;
2572}
2573
2574
2575/** @interface_method_impl{PDMDEVHLPR3,pfnPCIIORegionRegister} */
2576static DECLCALLBACK(int) pdmR3DevHlp_PCIIORegionRegister(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t iRegion,
2577 RTGCPHYS cbRegion, PCIADDRESSSPACE enmType, uint32_t fFlags,
2578 uint64_t hHandle, PFNPCIIOREGIONMAP pfnMapUnmap)
2579{
2580 PDMDEV_ASSERT_DEVINS(pDevIns);
2581 if (!pPciDev) /* NULL is an alias for the default PCI device. */
2582 pPciDev = pDevIns->apPciDevs[0];
2583 AssertReturn(pPciDev, VERR_PDM_NOT_PCI_DEVICE);
2584 LogFlow(("pdmR3DevHlp_PCIIORegionRegister: caller='%s'/%d: pPciDev=%p:{%#x} iRegion=%d cbRegion=%RGp enmType=%d fFlags=%#x, hHandle=%#RX64 pfnMapUnmap=%p\n",
2585 pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pPciDev->uDevFn, iRegion, cbRegion, enmType, fFlags, hHandle, pfnMapUnmap));
2586 PDMPCIDEV_ASSERT_VALID_RET(pDevIns, pPciDev);
2587
2588 /*
2589 * Validate input.
2590 */
2591 if (iRegion >= VBOX_PCI_NUM_REGIONS)
2592 {
2593 Assert(iRegion < VBOX_PCI_NUM_REGIONS);
2594 LogFlow(("pdmR3DevHlp_PCIIORegionRegister: caller='%s'/%d: returns %Rrc (iRegion)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
2595 return VERR_INVALID_PARAMETER;
2596 }
2597
2598 switch ((int)enmType)
2599 {
2600 case PCI_ADDRESS_SPACE_IO:
2601 /*
2602 * Sanity check: don't allow to register more than 32K of the PCI I/O space.
2603 */
2604 AssertLogRelMsgReturn(cbRegion <= _32K,
2605 ("caller='%s'/%d: %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, cbRegion),
2606 VERR_INVALID_PARAMETER);
2607 break;
2608
2609 case PCI_ADDRESS_SPACE_MEM:
2610 case PCI_ADDRESS_SPACE_MEM_PREFETCH:
2611 /*
2612 * Sanity check: Don't allow to register more than 2GB of the PCI MMIO space.
2613 */
2614 AssertLogRelMsgReturn(cbRegion <= MM_MMIO_32_MAX,
2615 ("caller='%s'/%d: %RGp (max %RGp)\n",
2616 pDevIns->pReg->szName, pDevIns->iInstance, cbRegion, (RTGCPHYS)MM_MMIO_32_MAX),
2617 VERR_OUT_OF_RANGE);
2618 break;
2619
2620 case PCI_ADDRESS_SPACE_BAR64 | PCI_ADDRESS_SPACE_MEM:
2621 case PCI_ADDRESS_SPACE_BAR64 | PCI_ADDRESS_SPACE_MEM_PREFETCH:
2622 /*
2623 * Sanity check: Don't allow to register more than 64GB of the 64-bit PCI MMIO space.
2624 */
2625 AssertLogRelMsgReturn(cbRegion <= MM_MMIO_64_MAX,
2626 ("caller='%s'/%d: %RGp (max %RGp)\n",
2627 pDevIns->pReg->szName, pDevIns->iInstance, cbRegion, MM_MMIO_64_MAX),
2628 VERR_OUT_OF_RANGE);
2629 break;
2630
2631 default:
2632 AssertMsgFailed(("enmType=%#x is unknown\n", enmType));
2633 LogFlow(("pdmR3DevHlp_PCIIORegionRegister: caller='%s'/%d: returns %Rrc (enmType)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
2634 return VERR_INVALID_PARAMETER;
2635 }
2636
2637 AssertMsgReturn( pfnMapUnmap
2638 || ( hHandle != UINT64_MAX
2639 && (fFlags & PDMPCIDEV_IORGN_F_HANDLE_MASK) != PDMPCIDEV_IORGN_F_NO_HANDLE),
2640 ("caller='%s'/%d: fFlags=%#x hHandle=%#RX64\n", pDevIns->pReg->szName, pDevIns->iInstance, fFlags, hHandle),
2641 VERR_INVALID_PARAMETER);
2642
2643 AssertMsgReturn(!(fFlags & ~PDMPCIDEV_IORGN_F_VALID_MASK), ("fFlags=%#x\n", fFlags), VERR_INVALID_FLAGS);
2644 int rc = VERR_NOT_IMPLEMENTED;
2645 AssertFailed();
2646
2647 LogFlow(("pdmR3DevHlp_PCIIORegionRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
2648 return rc;
2649}
2650
2651
2652/** @interface_method_impl{PDMDEVHLPR3,pfnPCIInterceptConfigAccesses} */
2653static DECLCALLBACK(int) pdmR3DevHlp_PCIInterceptConfigAccesses(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev,
2654 PFNPCICONFIGREAD pfnRead, PFNPCICONFIGWRITE pfnWrite)
2655{
2656 PDMDEV_ASSERT_DEVINS(pDevIns);
2657 if (!pPciDev) /* NULL is an alias for the default PCI device. */
2658 pPciDev = pDevIns->apPciDevs[0];
2659 AssertReturn(pPciDev, VERR_PDM_NOT_PCI_DEVICE);
2660 LogFlow(("pdmR3DevHlp_PCIInterceptConfigAccesses: caller='%s'/%d: pPciDev=%p pfnRead=%p pfnWrite=%p\n",
2661 pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pfnRead, pfnWrite));
2662 PDMPCIDEV_ASSERT_VALID_RET(pDevIns, pPciDev);
2663
2664 int rc = VERR_NOT_IMPLEMENTED;
2665 AssertFailed();
2666
2667 LogFlow(("pdmR3DevHlp_PCIInterceptConfigAccesses: caller='%s'/%d: returns %Rrc\n",
2668 pDevIns->pReg->szName, pDevIns->iInstance, rc));
2669 return rc;
2670}
2671
2672
2673/** @interface_method_impl{PDMDEVHLPR3,pfnPCIConfigWrite} */
2674static DECLCALLBACK(VBOXSTRICTRC)
2675pdmR3DevHlp_PCIConfigWrite(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t uAddress, unsigned cb, uint32_t u32Value)
2676{
2677 PDMDEV_ASSERT_DEVINS(pDevIns);
2678 AssertPtrReturn(pPciDev, VERR_PDM_NOT_PCI_DEVICE);
2679 LogFlow(("pdmR3DevHlp_PCIConfigWrite: caller='%s'/%d: pPciDev=%p uAddress=%#x cd=%d u32Value=%#x\n",
2680 pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, uAddress, cb, u32Value));
2681
2682 VBOXSTRICTRC rcStrict = VERR_NOT_IMPLEMENTED;
2683 AssertFailed();
2684
2685 LogFlow(("pdmR3DevHlp_PCIConfigWrite: caller='%s'/%d: returns %Rrc\n",
2686 pDevIns->pReg->szName, pDevIns->iInstance, VBOXSTRICTRC_VAL(rcStrict)));
2687 return rcStrict;
2688}
2689
2690
2691/** @interface_method_impl{PDMDEVHLPR3,pfnPCIConfigRead} */
2692static DECLCALLBACK(VBOXSTRICTRC)
2693pdmR3DevHlp_PCIConfigRead(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t uAddress, unsigned cb, uint32_t *pu32Value)
2694{
2695 PDMDEV_ASSERT_DEVINS(pDevIns);
2696 AssertPtrReturn(pPciDev, VERR_PDM_NOT_PCI_DEVICE);
2697 LogFlow(("pdmR3DevHlp_PCIConfigRead: caller='%s'/%d: pPciDev=%p uAddress=%#x cd=%d pu32Value=%p:{%#x}\n",
2698 pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, uAddress, cb, pu32Value, *pu32Value));
2699
2700 VBOXSTRICTRC rcStrict = VERR_NOT_IMPLEMENTED;
2701 AssertFailed();
2702
2703 LogFlow(("pdmR3DevHlp_PCIConfigRead: caller='%s'/%d: returns %Rrc (*pu32Value=%#x)\n",
2704 pDevIns->pReg->szName, pDevIns->iInstance, VBOXSTRICTRC_VAL(rcStrict), *pu32Value));
2705 return rcStrict;
2706}
2707
2708
2709/** @interface_method_impl{PDMDEVHLPR3,pfnPCIPhysRead} */
2710static DECLCALLBACK(int)
2711pdmR3DevHlp_PCIPhysRead(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, RTGCPHYS GCPhys, void *pvBuf, size_t cbRead)
2712{
2713 PDMDEV_ASSERT_DEVINS(pDevIns);
2714 if (!pPciDev) /* NULL is an alias for the default PCI device. */
2715 pPciDev = pDevIns->apPciDevs[0];
2716 AssertReturn(pPciDev, VERR_PDM_NOT_PCI_DEVICE);
2717 PDMPCIDEV_ASSERT_VALID_AND_REGISTERED(pDevIns, pPciDev);
2718
2719#ifndef PDM_DO_NOT_RESPECT_PCI_BM_BIT
2720 /*
2721 * Just check the busmaster setting here and forward the request to the generic read helper.
2722 */
2723 if (PCIDevIsBusmaster(pPciDev))
2724 { /* likely */ }
2725 else
2726 {
2727 Log(("pdmR3DevHlp_PCIPhysRead: caller='%s'/%d: returns %Rrc - Not bus master! GCPhys=%RGp cbRead=%#zx\n",
2728 pDevIns->pReg->szName, pDevIns->iInstance, VERR_PDM_NOT_PCI_BUS_MASTER, GCPhys, cbRead));
2729 memset(pvBuf, 0xff, cbRead);
2730 return VERR_PDM_NOT_PCI_BUS_MASTER;
2731 }
2732#endif
2733
2734 int rc = VERR_NOT_IMPLEMENTED;
2735 AssertFailed();
2736 return rc;
2737}
2738
2739
2740/** @interface_method_impl{PDMDEVHLPR3,pfnPCIPhysWrite} */
2741static DECLCALLBACK(int)
2742pdmR3DevHlp_PCIPhysWrite(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, RTGCPHYS GCPhys, const void *pvBuf, size_t cbWrite)
2743{
2744 PDMDEV_ASSERT_DEVINS(pDevIns);
2745 if (!pPciDev) /* NULL is an alias for the default PCI device. */
2746 pPciDev = pDevIns->apPciDevs[0];
2747 AssertReturn(pPciDev, VERR_PDM_NOT_PCI_DEVICE);
2748 PDMPCIDEV_ASSERT_VALID_AND_REGISTERED(pDevIns, pPciDev);
2749
2750#ifndef PDM_DO_NOT_RESPECT_PCI_BM_BIT
2751 /*
2752 * Just check the busmaster setting here and forward the request to the generic read helper.
2753 */
2754 if (PCIDevIsBusmaster(pPciDev))
2755 { /* likely */ }
2756 else
2757 {
2758 Log(("pdmR3DevHlp_PCIPhysWrite: caller='%s'/%d: returns %Rrc - Not bus master! GCPhys=%RGp cbWrite=%#zx\n",
2759 pDevIns->pReg->szName, pDevIns->iInstance, VERR_PDM_NOT_PCI_BUS_MASTER, GCPhys, cbWrite));
2760 return VERR_PDM_NOT_PCI_BUS_MASTER;
2761 }
2762#endif
2763
2764 RT_NOREF(GCPhys, pvBuf, cbWrite);
2765 int rc = VERR_NOT_IMPLEMENTED;
2766 AssertFailed();
2767 return rc;
2768}
2769
2770
2771/** @interface_method_impl{PDMDEVHLPR3,pfnPCISetIrq} */
2772static DECLCALLBACK(void) pdmR3DevHlp_PCISetIrq(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, int iIrq, int iLevel)
2773{
2774 PDMDEV_ASSERT_DEVINS(pDevIns);
2775 if (!pPciDev) /* NULL is an alias for the default PCI device. */
2776 pPciDev = pDevIns->apPciDevs[0];
2777 AssertReturnVoid(pPciDev);
2778 LogFlow(("pdmR3DevHlp_PCISetIrq: caller='%s'/%d: pPciDev=%p:{%#x} iIrq=%d iLevel=%d\n",
2779 pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pPciDev->uDevFn, iIrq, iLevel));
2780 PDMPCIDEV_ASSERT_VALID_AND_REGISTERED(pDevIns, pPciDev);
2781
2782 RT_NOREF(iIrq, iLevel);
2783 AssertFailed();
2784
2785 LogFlow(("pdmR3DevHlp_PCISetIrq: caller='%s'/%d: returns void\n", pDevIns->pReg->szName, pDevIns->iInstance));
2786}
2787
2788
2789/** @interface_method_impl{PDMDEVHLPR3,pfnPCISetIrqNoWait} */
2790static DECLCALLBACK(void) pdmR3DevHlp_PCISetIrqNoWait(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, int iIrq, int iLevel)
2791{
2792 pdmR3DevHlp_PCISetIrq(pDevIns, pPciDev, iIrq, iLevel);
2793}
2794
2795
2796/** @interface_method_impl{PDMDEVHLPR3,pfnISASetIrq} */
2797static DECLCALLBACK(void) pdmR3DevHlp_ISASetIrq(PPDMDEVINS pDevIns, int iIrq, int iLevel)
2798{
2799 PDMDEV_ASSERT_DEVINS(pDevIns);
2800 LogFlow(("pdmR3DevHlp_ISASetIrq: caller='%s'/%d: iIrq=%d iLevel=%d\n", pDevIns->pReg->szName, pDevIns->iInstance, iIrq, iLevel));
2801
2802 /*
2803 * Validate input.
2804 */
2805 Assert(iIrq < 16);
2806 Assert((uint32_t)iLevel <= PDM_IRQ_LEVEL_FLIP_FLOP);
2807
2808 AssertFailed();
2809
2810 LogFlow(("pdmR3DevHlp_ISASetIrq: caller='%s'/%d: returns void\n", pDevIns->pReg->szName, pDevIns->iInstance));
2811}
2812
2813
2814/** @interface_method_impl{PDMDEVHLPR3,pfnISASetIrqNoWait} */
2815static DECLCALLBACK(void) pdmR3DevHlp_ISASetIrqNoWait(PPDMDEVINS pDevIns, int iIrq, int iLevel)
2816{
2817 pdmR3DevHlp_ISASetIrq(pDevIns, iIrq, iLevel);
2818}
2819
2820
2821/** @interface_method_impl{PDMDEVHLPR3,pfnIoApicSendMsi} */
2822static DECLCALLBACK(void) pdmR3DevHlp_IoApicSendMsi(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, uint32_t uValue)
2823{
2824 PDMDEV_ASSERT_DEVINS(pDevIns);
2825 LogFlow(("pdmR3DevHlp_IoApicSendMsi: caller='%s'/%d: GCPhys=%RGp uValue=%#x\n", pDevIns->pReg->szName, pDevIns->iInstance, GCPhys, uValue));
2826
2827 /*
2828 * Validate input.
2829 */
2830 Assert(GCPhys != 0);
2831 Assert(uValue != 0);
2832
2833 AssertFailed();
2834
2835 LogFlow(("pdmR3DevHlp_IoApicSendMsi: caller='%s'/%d: returns void\n", pDevIns->pReg->szName, pDevIns->iInstance));
2836}
2837
2838
2839/** @interface_method_impl{PDMDEVHLPR3,pfnDriverAttach} */
2840static DECLCALLBACK(int) pdmR3DevHlp_DriverAttach(PPDMDEVINS pDevIns, uint32_t iLun, PPDMIBASE pBaseInterface, PPDMIBASE *ppBaseInterface, const char *pszDesc)
2841{
2842 PDMDEV_ASSERT_DEVINS(pDevIns);
2843 LogFlow(("pdmR3DevHlp_DriverAttach: caller='%s'/%d: iLun=%d pBaseInterface=%p ppBaseInterface=%p pszDesc=%p:{%s}\n",
2844 pDevIns->pReg->szName, pDevIns->iInstance, iLun, pBaseInterface, ppBaseInterface, pszDesc, pszDesc));
2845
2846 int rc = VERR_NOT_IMPLEMENTED;
2847 AssertFailed();
2848
2849 LogFlow(("pdmR3DevHlp_DriverAttach: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
2850 return rc;
2851}
2852
2853
2854/** @interface_method_impl{PDMDEVHLPR3,pfnDriverDetach} */
2855static DECLCALLBACK(int) pdmR3DevHlp_DriverDetach(PPDMDEVINS pDevIns, PPDMDRVINS pDrvIns, uint32_t fFlags)
2856{
2857 PDMDEV_ASSERT_DEVINS(pDevIns); RT_NOREF_PV(pDevIns);
2858 LogFlow(("pdmR3DevHlp_DriverDetach: caller='%s'/%d: pDrvIns=%p\n",
2859 pDevIns->pReg->szName, pDevIns->iInstance, pDrvIns));
2860
2861 RT_NOREF(fFlags);
2862 int rc = VERR_NOT_IMPLEMENTED;
2863 AssertFailed();
2864
2865 LogFlow(("pdmR3DevHlp_DriverDetach: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
2866 return rc;
2867}
2868
2869
2870/** @interface_method_impl{PDMDEVHLPR3,pfnDriverReconfigure} */
2871static DECLCALLBACK(int) pdmR3DevHlp_DriverReconfigure(PPDMDEVINS pDevIns, uint32_t iLun, uint32_t cDepth,
2872 const char * const *papszDrivers, PCFGMNODE *papConfigs, uint32_t fFlags)
2873{
2874 PDMDEV_ASSERT_DEVINS(pDevIns);
2875 LogFlow(("pdmR3DevHlp_DriverReconfigure: caller='%s'/%d: iLun=%u cDepth=%u fFlags=%#x\n",
2876 pDevIns->pReg->szName, pDevIns->iInstance, iLun, cDepth, fFlags));
2877
2878 /*
2879 * Validate input.
2880 */
2881 AssertReturn(cDepth <= 8, VERR_INVALID_PARAMETER);
2882 AssertPtrReturn(papszDrivers, VERR_INVALID_POINTER);
2883 AssertPtrNullReturn(papConfigs, VERR_INVALID_POINTER);
2884 for (uint32_t i = 0; i < cDepth; i++)
2885 {
2886 AssertPtrReturn(papszDrivers[i], VERR_INVALID_POINTER);
2887 size_t cchDriver = strlen(papszDrivers[i]);
2888 AssertPtrReturn(cchDriver > 0 && cchDriver < RT_SIZEOFMEMB(PDMDRVREG, szName), VERR_OUT_OF_RANGE);
2889
2890 if (papConfigs)
2891 AssertPtrNullReturn(papConfigs[i], VERR_INVALID_POINTER);
2892 }
2893 AssertReturn(fFlags == 0, VERR_INVALID_FLAGS);
2894
2895 int rc = VERR_NOT_IMPLEMENTED;
2896 AssertFailed();
2897
2898 LogFlow(("pdmR3DevHlp_DriverReconfigure: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
2899 return rc;
2900}
2901
2902
2903/** @interface_method_impl{PDMDEVHLPR3,pfnQueueCreatePtr} */
2904static DECLCALLBACK(int) pdmR3DevHlp_QueueCreatePtr(PPDMDEVINS pDevIns, size_t cbItem, uint32_t cItems, uint32_t cMilliesInterval,
2905 PFNPDMQUEUEDEV pfnCallback, bool fRZEnabled, const char *pszName, PPDMQUEUE *ppQueue)
2906{
2907 PDMDEV_ASSERT_DEVINS(pDevIns);
2908 LogFlow(("pdmR3DevHlp_QueueCreatePtr: caller='%s'/%d: cbItem=%#x cItems=%#x cMilliesInterval=%u pfnCallback=%p fRZEnabled=%RTbool pszName=%p:{%s} ppQueue=%p\n",
2909 pDevIns->pReg->szName, pDevIns->iInstance, cbItem, cItems, cMilliesInterval, pfnCallback, fRZEnabled, pszName, pszName, ppQueue));
2910
2911 int rc = VERR_NOT_IMPLEMENTED;
2912 AssertFailed();
2913
2914 LogFlow(("pdmR3DevHlp_QueueCreatePtr: caller='%s'/%d: returns %Rrc *ppQueue=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, rc, *ppQueue));
2915 return rc;
2916}
2917
2918
2919/** @interface_method_impl{PDMDEVHLPR3,pfnQueueCreate} */
2920static DECLCALLBACK(int) pdmR3DevHlp_QueueCreate(PPDMDEVINS pDevIns, size_t cbItem, uint32_t cItems, uint32_t cMilliesInterval,
2921 PFNPDMQUEUEDEV pfnCallback, bool fRZEnabled, const char *pszName,
2922 PDMQUEUEHANDLE *phQueue)
2923{
2924 PDMDEV_ASSERT_DEVINS(pDevIns);
2925 LogFlow(("pdmR3DevHlp_QueueCreate: caller='%s'/%d: cbItem=%#x cItems=%#x cMilliesInterval=%u pfnCallback=%p fRZEnabled=%RTbool pszName=%p:{%s} phQueue=%p\n",
2926 pDevIns->pReg->szName, pDevIns->iInstance, cbItem, cItems, cMilliesInterval, pfnCallback, fRZEnabled, pszName, pszName, phQueue));
2927
2928 int rc = VERR_NOT_IMPLEMENTED;
2929 AssertFailed();
2930
2931 LogFlow(("pdmR3DevHlp_QueueCreate: caller='%s'/%d: returns %Rrc *ppQueue=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, rc, *phQueue));
2932 return rc;
2933}
2934
2935
2936/** @interface_method_impl{PDMDEVHLPR3,pfnQueueToPtr} */
2937static DECLCALLBACK(PPDMQUEUE) pdmR3DevHlp_QueueToPtr(PPDMDEVINS pDevIns, PDMQUEUEHANDLE hQueue)
2938{
2939 PDMDEV_ASSERT_DEVINS(pDevIns);
2940 RT_NOREF(pDevIns);
2941 return (PPDMQUEUE)hQueue;
2942}
2943
2944
2945/** @interface_method_impl{PDMDEVHLPR3,pfnQueueAlloc} */
2946static DECLCALLBACK(PPDMQUEUEITEMCORE) pdmR3DevHlp_QueueAlloc(PPDMDEVINS pDevIns, PDMQUEUEHANDLE hQueue)
2947{
2948 RT_NOREF(pDevIns, hQueue);
2949 AssertFailed();
2950 return NULL;
2951}
2952
2953
2954/** @interface_method_impl{PDMDEVHLPR3,pfnQueueInsert} */
2955static DECLCALLBACK(void) pdmR3DevHlp_QueueInsert(PPDMDEVINS pDevIns, PDMQUEUEHANDLE hQueue, PPDMQUEUEITEMCORE pItem)
2956{
2957 RT_NOREF(pDevIns, hQueue, pItem);
2958 AssertFailed();
2959}
2960
2961
2962/** @interface_method_impl{PDMDEVHLPR3,pfnQueueInsertEx} */
2963static DECLCALLBACK(void) pdmR3DevHlp_QueueInsertEx(PPDMDEVINS pDevIns, PDMQUEUEHANDLE hQueue, PPDMQUEUEITEMCORE pItem,
2964 uint64_t cNanoMaxDelay)
2965{
2966 RT_NOREF(pDevIns, hQueue, pItem, cNanoMaxDelay);
2967 AssertFailed();
2968}
2969
2970
2971/** @interface_method_impl{PDMDEVHLPR3,pfnQueueFlushIfNecessary} */
2972static DECLCALLBACK(bool) pdmR3DevHlp_QueueFlushIfNecessary(PPDMDEVINS pDevIns, PDMQUEUEHANDLE hQueue)
2973{
2974 RT_NOREF(pDevIns, hQueue);
2975 AssertFailed();
2976 return false;
2977}
2978
2979
2980/** @interface_method_impl{PDMDEVHLPR3,pfnTaskCreate} */
2981static DECLCALLBACK(int) pdmR3DevHlp_TaskCreate(PPDMDEVINS pDevIns, uint32_t fFlags, const char *pszName,
2982 PFNPDMTASKDEV pfnCallback, void *pvUser, PDMTASKHANDLE *phTask)
2983{
2984 PDMDEV_ASSERT_DEVINS(pDevIns);
2985 LogFlow(("pdmR3DevHlp_TaskTrigger: caller='%s'/%d: pfnCallback=%p fFlags=%#x pszName=%p:{%s} phTask=%p\n",
2986 pDevIns->pReg->szName, pDevIns->iInstance, pfnCallback, fFlags, pszName, pszName, phTask));
2987
2988 RT_NOREF(pDevIns, fFlags, pszName, pfnCallback, pvUser, phTask);
2989 int rc = VERR_NOT_IMPLEMENTED;
2990 AssertFailed();
2991
2992 LogFlow(("pdmR3DevHlp_TaskTrigger: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
2993 return rc;
2994}
2995
2996
2997/** @interface_method_impl{PDMDEVHLPR3,pfnTaskTrigger} */
2998static DECLCALLBACK(int) pdmR3DevHlp_TaskTrigger(PPDMDEVINS pDevIns, PDMTASKHANDLE hTask)
2999{
3000 PDMDEV_ASSERT_DEVINS(pDevIns);
3001 LogFlow(("pdmR3DevHlp_TaskTrigger: caller='%s'/%d: hTask=%RU64\n", pDevIns->pReg->szName, pDevIns->iInstance, hTask));
3002
3003 RT_NOREF(pDevIns, hTask);
3004 int rc = VERR_NOT_IMPLEMENTED;
3005 AssertFailed();
3006
3007 LogFlow(("pdmR3DevHlp_TaskTrigger: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3008 return rc;
3009}
3010
3011
3012/** @interface_method_impl{PDMDEVHLPR3,pfnSUPSemEventCreate} */
3013static DECLCALLBACK(int) pdmR3DevHlp_SUPSemEventCreate(PPDMDEVINS pDevIns, PSUPSEMEVENT phEvent)
3014{
3015 PDMDEV_ASSERT_DEVINS(pDevIns);
3016 LogFlow(("pdmR3DevHlp_SUPSemEventCreate: caller='%s'/%d: phEvent=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, phEvent));
3017
3018 RT_NOREF(pDevIns, phEvent);
3019 int rc = VERR_NOT_IMPLEMENTED;
3020 AssertFailed();
3021
3022 LogFlow(("pdmR3DevHlp_SUPSemEventCreate: caller='%s'/%d: returns %Rrc *phEvent=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, rc, *phEvent));
3023 return rc;
3024}
3025
3026
3027/** @interface_method_impl{PDMDEVHLPR3,pfnSUPSemEventClose} */
3028static DECLCALLBACK(int) pdmR3DevHlp_SUPSemEventClose(PPDMDEVINS pDevIns, SUPSEMEVENT hEvent)
3029{
3030 PDMDEV_ASSERT_DEVINS(pDevIns);
3031 LogFlow(("pdmR3DevHlp_SUPSemEventClose: caller='%s'/%d: hEvent=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, hEvent));
3032
3033 RT_NOREF(pDevIns, hEvent);
3034 int rc = VERR_NOT_IMPLEMENTED;
3035 AssertFailed();
3036
3037 LogFlow(("pdmR3DevHlp_SUPSemEventClose: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3038 return rc;
3039}
3040
3041
3042/** @interface_method_impl{PDMDEVHLPR3,pfnSUPSemEventSignal} */
3043static DECLCALLBACK(int) pdmR3DevHlp_SUPSemEventSignal(PPDMDEVINS pDevIns, SUPSEMEVENT hEvent)
3044{
3045 PDMDEV_ASSERT_DEVINS(pDevIns);
3046 LogFlow(("pdmR3DevHlp_SUPSemEventSignal: caller='%s'/%d: hEvent=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, hEvent));
3047
3048 RT_NOREF(pDevIns, hEvent);
3049 int rc = VERR_NOT_IMPLEMENTED;
3050 AssertFailed();
3051
3052 LogFlow(("pdmR3DevHlp_SUPSemEventSignal: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3053 return rc;
3054}
3055
3056
3057/** @interface_method_impl{PDMDEVHLPR3,pfnSUPSemEventWaitNoResume} */
3058static DECLCALLBACK(int) pdmR3DevHlp_SUPSemEventWaitNoResume(PPDMDEVINS pDevIns, SUPSEMEVENT hEvent, uint32_t cMillies)
3059{
3060 PDMDEV_ASSERT_DEVINS(pDevIns);
3061 LogFlow(("pdmR3DevHlp_SUPSemEventWaitNoResume: caller='%s'/%d: hEvent=%p cNsTimeout=%RU32\n",
3062 pDevIns->pReg->szName, pDevIns->iInstance, hEvent, cMillies));
3063
3064 RT_NOREF(pDevIns, hEvent, cMillies);
3065 int rc = VERR_NOT_IMPLEMENTED;
3066 AssertFailed();
3067
3068 LogFlow(("pdmR3DevHlp_SUPSemEventWaitNoResume: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3069 return rc;
3070}
3071
3072
3073/** @interface_method_impl{PDMDEVHLPR3,pfnSUPSemEventWaitNsAbsIntr} */
3074static DECLCALLBACK(int) pdmR3DevHlp_SUPSemEventWaitNsAbsIntr(PPDMDEVINS pDevIns, SUPSEMEVENT hEvent, uint64_t uNsTimeout)
3075{
3076 PDMDEV_ASSERT_DEVINS(pDevIns);
3077 LogFlow(("pdmR3DevHlp_SUPSemEventWaitNsAbsIntr: caller='%s'/%d: hEvent=%p uNsTimeout=%RU64\n",
3078 pDevIns->pReg->szName, pDevIns->iInstance, hEvent, uNsTimeout));
3079
3080 RT_NOREF(pDevIns, hEvent, uNsTimeout);
3081 int rc = VERR_NOT_IMPLEMENTED;
3082 AssertFailed();
3083
3084 LogFlow(("pdmR3DevHlp_SUPSemEventWaitNsAbsIntr: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3085 return rc;
3086}
3087
3088
3089/** @interface_method_impl{PDMDEVHLPR3,pfnSUPSemEventWaitNsRelIntr} */
3090static DECLCALLBACK(int) pdmR3DevHlp_SUPSemEventWaitNsRelIntr(PPDMDEVINS pDevIns, SUPSEMEVENT hEvent, uint64_t cNsTimeout)
3091{
3092 PDMDEV_ASSERT_DEVINS(pDevIns);
3093 LogFlow(("pdmR3DevHlp_SUPSemEventWaitNsRelIntr: caller='%s'/%d: hEvent=%p cNsTimeout=%RU64\n",
3094 pDevIns->pReg->szName, pDevIns->iInstance, hEvent, cNsTimeout));
3095
3096 RT_NOREF(pDevIns, hEvent, cNsTimeout);
3097 int rc = VERR_NOT_IMPLEMENTED;
3098 AssertFailed();
3099
3100 LogFlow(("pdmR3DevHlp_SUPSemEventWaitNsRelIntr: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3101 return rc;
3102}
3103
3104
3105/** @interface_method_impl{PDMDEVHLPR3,pfnSUPSemEventGetResolution} */
3106static DECLCALLBACK(uint32_t) pdmR3DevHlp_SUPSemEventGetResolution(PPDMDEVINS pDevIns)
3107{
3108 PDMDEV_ASSERT_DEVINS(pDevIns);
3109 LogFlow(("pdmR3DevHlp_SUPSemEventGetResolution: caller='%s'/%d:\n", pDevIns->pReg->szName, pDevIns->iInstance));
3110
3111 RT_NOREF(pDevIns);
3112 uint32_t cNsResolution = 0;
3113 AssertFailed();
3114
3115 LogFlow(("pdmR3DevHlp_SUPSemEventGetResolution: caller='%s'/%d: returns %u\n", pDevIns->pReg->szName, pDevIns->iInstance, cNsResolution));
3116 return cNsResolution;
3117}
3118
3119
3120/** @interface_method_impl{PDMDEVHLPR3,pfnSUPSemEventMultiCreate} */
3121static DECLCALLBACK(int) pdmR3DevHlp_SUPSemEventMultiCreate(PPDMDEVINS pDevIns, PSUPSEMEVENTMULTI phEventMulti)
3122{
3123 PDMDEV_ASSERT_DEVINS(pDevIns);
3124 LogFlow(("pdmR3DevHlp_SUPSemEventMultiCreate: caller='%s'/%d: phEventMulti=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, phEventMulti));
3125
3126 RT_NOREF(pDevIns, phEventMulti);
3127 int rc = VERR_NOT_IMPLEMENTED;
3128 AssertFailed();
3129
3130 LogFlow(("pdmR3DevHlp_SUPSemEventMultiCreate: caller='%s'/%d: returns %Rrc *phEventMulti=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, rc, *phEventMulti));
3131 return rc;
3132}
3133
3134
3135/** @interface_method_impl{PDMDEVHLPR3,pfnSUPSemEventMultiClose} */
3136static DECLCALLBACK(int) pdmR3DevHlp_SUPSemEventMultiClose(PPDMDEVINS pDevIns, SUPSEMEVENTMULTI hEventMulti)
3137{
3138 PDMDEV_ASSERT_DEVINS(pDevIns);
3139 LogFlow(("pdmR3DevHlp_SUPSemEventMultiClose: caller='%s'/%d: hEventMulti=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, hEventMulti));
3140
3141 RT_NOREF(pDevIns, hEventMulti);
3142 int rc = VERR_NOT_IMPLEMENTED;
3143 AssertFailed();
3144
3145 LogFlow(("pdmR3DevHlp_SUPSemEventMultiClose: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3146 return rc;
3147}
3148
3149
3150/** @interface_method_impl{PDMDEVHLPR3,pfnSUPSemEventMultiSignal} */
3151static DECLCALLBACK(int) pdmR3DevHlp_SUPSemEventMultiSignal(PPDMDEVINS pDevIns, SUPSEMEVENTMULTI hEventMulti)
3152{
3153 PDMDEV_ASSERT_DEVINS(pDevIns);
3154 LogFlow(("pdmR3DevHlp_SUPSemEventMultiSignal: caller='%s'/%d: hEventMulti=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, hEventMulti));
3155
3156 RT_NOREF(pDevIns, hEventMulti);
3157 int rc = VERR_NOT_IMPLEMENTED;
3158 AssertFailed();
3159
3160 LogFlow(("pdmR3DevHlp_SUPSemEventMultiSignal: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3161 return rc;
3162}
3163
3164
3165/** @interface_method_impl{PDMDEVHLPR3,pfnSUPSemEventMultiReset} */
3166static DECLCALLBACK(int) pdmR3DevHlp_SUPSemEventMultiReset(PPDMDEVINS pDevIns, SUPSEMEVENTMULTI hEventMulti)
3167{
3168 PDMDEV_ASSERT_DEVINS(pDevIns);
3169 LogFlow(("pdmR3DevHlp_SUPSemEventMultiReset: caller='%s'/%d: hEventMulti=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, hEventMulti));
3170
3171 RT_NOREF(pDevIns, hEventMulti);
3172 int rc = VERR_NOT_IMPLEMENTED;
3173 AssertFailed();
3174
3175 LogFlow(("pdmR3DevHlp_SUPSemEventMultiReset: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3176 return rc;
3177}
3178
3179
3180/** @interface_method_impl{PDMDEVHLPR3,pfnSUPSemEventMultiWaitNoResume} */
3181static DECLCALLBACK(int) pdmR3DevHlp_SUPSemEventMultiWaitNoResume(PPDMDEVINS pDevIns, SUPSEMEVENTMULTI hEventMulti,
3182 uint32_t cMillies)
3183{
3184 PDMDEV_ASSERT_DEVINS(pDevIns);
3185 LogFlow(("pdmR3DevHlp_SUPSemEventMultiWaitNoResume: caller='%s'/%d: hEventMulti=%p cMillies=%RU32\n",
3186 pDevIns->pReg->szName, pDevIns->iInstance, hEventMulti, cMillies));
3187
3188 RT_NOREF(pDevIns, hEventMulti, cMillies);
3189 int rc = VERR_NOT_IMPLEMENTED;
3190 AssertFailed();
3191
3192 LogFlow(("pdmR3DevHlp_SUPSemEventMultiWaitNoResume: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3193 return rc;
3194}
3195
3196
3197/** @interface_method_impl{PDMDEVHLPR3,pfnSUPSemEventMultiWaitNsAbsIntr} */
3198static DECLCALLBACK(int) pdmR3DevHlp_SUPSemEventMultiWaitNsAbsIntr(PPDMDEVINS pDevIns, SUPSEMEVENTMULTI hEventMulti,
3199 uint64_t uNsTimeout)
3200{
3201 PDMDEV_ASSERT_DEVINS(pDevIns);
3202 LogFlow(("pdmR3DevHlp_SUPSemEventMultiWaitNsAbsIntr: caller='%s'/%d: hEventMulti=%p uNsTimeout=%RU64\n",
3203 pDevIns->pReg->szName, pDevIns->iInstance, hEventMulti, uNsTimeout));
3204
3205 RT_NOREF(pDevIns, hEventMulti, uNsTimeout);
3206 int rc = VERR_NOT_IMPLEMENTED;
3207 AssertFailed();
3208
3209 LogFlow(("pdmR3DevHlp_SUPSemEventMultiWaitNsAbsIntr: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3210 return rc;
3211}
3212
3213
3214/** @interface_method_impl{PDMDEVHLPR3,pfnSUPSemEventMultiWaitNsRelIntr} */
3215static DECLCALLBACK(int) pdmR3DevHlp_SUPSemEventMultiWaitNsRelIntr(PPDMDEVINS pDevIns, SUPSEMEVENTMULTI hEventMulti,
3216 uint64_t cNsTimeout)
3217{
3218 PDMDEV_ASSERT_DEVINS(pDevIns);
3219 LogFlow(("pdmR3DevHlp_SUPSemEventMultiWaitNsRelIntr: caller='%s'/%d: hEventMulti=%p cNsTimeout=%RU64\n",
3220 pDevIns->pReg->szName, pDevIns->iInstance, hEventMulti, cNsTimeout));
3221
3222 RT_NOREF(pDevIns, hEventMulti, cNsTimeout);
3223 int rc = VERR_NOT_IMPLEMENTED;
3224 AssertFailed();
3225
3226 LogFlow(("pdmR3DevHlp_SUPSemEventMultiWaitNsRelIntr: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3227 return rc;
3228}
3229
3230
3231/** @interface_method_impl{PDMDEVHLPR3,pfnSUPSemEventMultiGetResolution} */
3232static DECLCALLBACK(uint32_t) pdmR3DevHlp_SUPSemEventMultiGetResolution(PPDMDEVINS pDevIns)
3233{
3234 PDMDEV_ASSERT_DEVINS(pDevIns);
3235 LogFlow(("pdmR3DevHlp_SUPSemEventMultiGetResolution: caller='%s'/%d:\n", pDevIns->pReg->szName, pDevIns->iInstance));
3236
3237 uint32_t cNsResolution = 0;
3238 AssertFailed();
3239
3240 LogFlow(("pdmR3DevHlp_SUPSemEventMultiGetResolution: caller='%s'/%d: returns %u\n", pDevIns->pReg->szName, pDevIns->iInstance, cNsResolution));
3241 return cNsResolution;
3242}
3243
3244
3245/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectInit} */
3246static DECLCALLBACK(int) pdmR3DevHlp_CritSectInit(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect, RT_SRC_POS_DECL,
3247 const char *pszNameFmt, va_list va)
3248{
3249 PDMDEV_ASSERT_DEVINS(pDevIns);
3250 LogFlow(("pdmR3DevHlp_CritSectInit: caller='%s'/%d: pCritSect=%p pszNameFmt=%p:{%s}\n",
3251 pDevIns->pReg->szName, pDevIns->iInstance, pCritSect, pszNameFmt, pszNameFmt));
3252
3253 RT_NOREF(pDevIns, pCritSect, RT_SRC_POS_ARGS, pszNameFmt, va);
3254 int rc = VERR_NOT_IMPLEMENTED;
3255 AssertFailed();
3256
3257 LogFlow(("pdmR3DevHlp_CritSectInit: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3258 return rc;
3259}
3260
3261
3262/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectGetNop} */
3263static DECLCALLBACK(PPDMCRITSECT) pdmR3DevHlp_CritSectGetNop(PPDMDEVINS pDevIns)
3264{
3265 PDMDEV_ASSERT_DEVINS(pDevIns);
3266
3267 PPDMCRITSECT pCritSect = NULL;
3268 AssertFailed();
3269
3270 LogFlow(("pdmR3DevHlp_CritSectGetNop: caller='%s'/%d: return %p\n",
3271 pDevIns->pReg->szName, pDevIns->iInstance, pCritSect));
3272 return pCritSect;
3273}
3274
3275
3276/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectGetNopR0} */
3277static DECLCALLBACK(R0PTRTYPE(PPDMCRITSECT)) pdmR3DevHlp_CritSectGetNopR0(PPDMDEVINS pDevIns)
3278{
3279 PDMDEV_ASSERT_DEVINS(pDevIns);
3280
3281 R0PTRTYPE(PPDMCRITSECT) pCritSect = 0;
3282 LogFlow(("pdmR3DevHlp_CritSectGetNopR0: caller='%s'/%d: return %RHv\n",
3283 pDevIns->pReg->szName, pDevIns->iInstance, pCritSect));
3284 return pCritSect;
3285}
3286
3287
3288/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectGetNopRC} */
3289static DECLCALLBACK(RCPTRTYPE(PPDMCRITSECT)) pdmR3DevHlp_CritSectGetNopRC(PPDMDEVINS pDevIns)
3290{
3291 PDMDEV_ASSERT_DEVINS(pDevIns);
3292
3293 RCPTRTYPE(PPDMCRITSECT) pCritSect = 0;
3294 LogFlow(("pdmR3DevHlp_CritSectGetNopRC: caller='%s'/%d: return %RRv\n",
3295 pDevIns->pReg->szName, pDevIns->iInstance, pCritSect));
3296 return pCritSect;
3297}
3298
3299
3300/** @interface_method_impl{PDMDEVHLPR3,pfnSetDeviceCritSect} */
3301static DECLCALLBACK(int) pdmR3DevHlp_SetDeviceCritSect(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect)
3302{
3303 /*
3304 * Validate input.
3305 *
3306 * Note! We only allow the automatically created default critical section
3307 * to be replaced by this API.
3308 */
3309 PDMDEV_ASSERT_DEVINS(pDevIns);
3310 AssertPtrReturn(pCritSect, VERR_INVALID_POINTER);
3311
3312#if 0
3313 LogFlow(("pdmR3DevHlp_SetDeviceCritSect: caller='%s'/%d: pCritSect=%p (%s)\n",
3314 pDevIns->pReg->szName, pDevIns->iInstance, pCritSect, pCritSect->s.pszName));
3315#endif
3316
3317 int rc = VERR_NOT_IMPLEMENTED;
3318 AssertFailed();
3319
3320 LogFlow(("pdmR3DevHlp_SetDeviceCritSect: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3321 return rc;
3322}
3323
3324
3325/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectYield} */
3326static DECLCALLBACK(bool) pdmR3DevHlp_CritSectYield(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect)
3327{
3328 PDMDEV_ASSERT_DEVINS(pDevIns);
3329
3330 RT_NOREF(pDevIns, pCritSect);
3331 AssertFailed();
3332 return false;
3333}
3334
3335
3336/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectEnter} */
3337static DECLCALLBACK(int) pdmR3DevHlp_CritSectEnter(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect, int rcBusy)
3338{
3339 PDMDEV_ASSERT_DEVINS(pDevIns);
3340
3341 RT_NOREF(pDevIns, pCritSect, rcBusy);
3342 int rc = VERR_NOT_IMPLEMENTED;
3343 AssertFailed();
3344 return rc;
3345}
3346
3347
3348/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectEnterDebug} */
3349static DECLCALLBACK(int) pdmR3DevHlp_CritSectEnterDebug(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect, int rcBusy, RTHCUINTPTR uId, RT_SRC_POS_DECL)
3350{
3351 PDMDEV_ASSERT_DEVINS(pDevIns);
3352
3353 RT_NOREF(pDevIns, rcBusy, uId, RT_SRC_POS_ARGS);
3354 return RTCritSectEnter(&pCritSect->s.CritSect);
3355}
3356
3357
3358/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectTryEnter} */
3359static DECLCALLBACK(int) pdmR3DevHlp_CritSectTryEnter(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect)
3360{
3361 PDMDEV_ASSERT_DEVINS(pDevIns);
3362
3363 RT_NOREF(pDevIns, pCritSect);
3364 int rc = VERR_NOT_IMPLEMENTED;
3365 AssertFailed();
3366 return rc;
3367}
3368
3369
3370/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectTryEnterDebug} */
3371static DECLCALLBACK(int) pdmR3DevHlp_CritSectTryEnterDebug(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect, RTHCUINTPTR uId, RT_SRC_POS_DECL)
3372{
3373 PDMDEV_ASSERT_DEVINS(pDevIns);
3374
3375 RT_NOREF(pDevIns, pCritSect, uId, RT_SRC_POS_ARGS);
3376 int rc = VERR_NOT_IMPLEMENTED;
3377 AssertFailed();
3378 return rc;
3379}
3380
3381
3382/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectLeave} */
3383static DECLCALLBACK(int) pdmR3DevHlp_CritSectLeave(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect)
3384{
3385 PDMDEV_ASSERT_DEVINS(pDevIns);
3386
3387 return RTCritSectLeave(&pCritSect->s.CritSect);
3388}
3389
3390
3391/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectIsOwner} */
3392static DECLCALLBACK(bool) pdmR3DevHlp_CritSectIsOwner(PPDMDEVINS pDevIns, PCPDMCRITSECT pCritSect)
3393{
3394 PDMDEV_ASSERT_DEVINS(pDevIns);
3395
3396 return RTCritSectIsOwner(&pCritSect->s.CritSect);
3397}
3398
3399
3400/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectIsInitialized} */
3401static DECLCALLBACK(bool) pdmR3DevHlp_CritSectIsInitialized(PPDMDEVINS pDevIns, PCPDMCRITSECT pCritSect)
3402{
3403 PDMDEV_ASSERT_DEVINS(pDevIns);
3404
3405 RT_NOREF(pDevIns, pCritSect);
3406 AssertFailed();
3407 return false;
3408}
3409
3410
3411/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectHasWaiters} */
3412static DECLCALLBACK(bool) pdmR3DevHlp_CritSectHasWaiters(PPDMDEVINS pDevIns, PCPDMCRITSECT pCritSect)
3413{
3414 PDMDEV_ASSERT_DEVINS(pDevIns);
3415 RT_NOREF(pDevIns, pCritSect);
3416 AssertFailed();
3417 return false;
3418}
3419
3420
3421/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectGetRecursion} */
3422static DECLCALLBACK(uint32_t) pdmR3DevHlp_CritSectGetRecursion(PPDMDEVINS pDevIns, PCPDMCRITSECT pCritSect)
3423{
3424 PDMDEV_ASSERT_DEVINS(pDevIns);
3425
3426 RT_NOREF(pDevIns, pCritSect);
3427 AssertFailed();
3428 return 0;
3429}
3430
3431
3432/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectScheduleExitEvent} */
3433static DECLCALLBACK(int) pdmR3DevHlp_CritSectScheduleExitEvent(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect,
3434 SUPSEMEVENT hEventToSignal)
3435{
3436 PDMDEV_ASSERT_DEVINS(pDevIns);
3437
3438 RT_NOREF(pDevIns, pCritSect, hEventToSignal);
3439 int rc = VERR_NOT_IMPLEMENTED;
3440 AssertFailed();
3441 return rc;
3442}
3443
3444
3445/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectDelete} */
3446static DECLCALLBACK(int) pdmR3DevHlp_CritSectDelete(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect)
3447{
3448 PDMDEV_ASSERT_DEVINS(pDevIns);
3449
3450 RT_NOREF(pDevIns, pCritSect);
3451 int rc = VERR_NOT_IMPLEMENTED;
3452 AssertFailed();
3453 return rc;
3454}
3455
3456
3457static DECLCALLBACK(int) pdmR3DevHlp_ThreadCreate(PPDMDEVINS pDevIns, PPPDMTHREAD ppThread, void *pvUser, PFNPDMTHREADDEV pfnThread,
3458 PFNPDMTHREADWAKEUPDEV pfnWakeup, size_t cbStack, RTTHREADTYPE enmType, const char *pszName)
3459{
3460 PDMDEV_ASSERT_DEVINS(pDevIns);
3461 LogFlow(("pdmR3DevHlp_ThreadCreate: caller='%s'/%d: ppThread=%p pvUser=%p pfnThread=%p pfnWakeup=%p cbStack=%#zx enmType=%d pszName=%p:{%s}\n",
3462 pDevIns->pReg->szName, pDevIns->iInstance, ppThread, pvUser, pfnThread, pfnWakeup, cbStack, enmType, pszName, pszName));
3463
3464 RT_NOREF(ppThread, pvUser, pfnThread, pfnWakeup, cbStack, enmType, pszName);
3465 int rc = VERR_NOT_IMPLEMENTED;
3466 AssertFailed();
3467
3468 LogFlow(("pdmR3DevHlp_ThreadCreate: caller='%s'/%d: returns %Rrc *ppThread=%RTthrd\n", pDevIns->pReg->szName, pDevIns->iInstance,
3469 rc, *ppThread));
3470 return rc;
3471}
3472
3473
3474static DECLCALLBACK(int) pdmR3DevHlp_ThreadDestroy(PPDMTHREAD pThread, int *pRcThread)
3475{
3476 RT_NOREF(pThread, pRcThread);
3477 int rc = VERR_NOT_IMPLEMENTED;
3478 AssertFailed();
3479 return rc;
3480}
3481
3482
3483static DECLCALLBACK(int) pdmR3DevHlp_ThreadIAmSuspending(PPDMTHREAD pThread)
3484{
3485 RT_NOREF(pThread);
3486 int rc = VERR_NOT_IMPLEMENTED;
3487 AssertFailed();
3488 return rc;
3489}
3490
3491
3492static DECLCALLBACK(int) pdmR3DevHlp_ThreadIamRunning(PPDMTHREAD pThread)
3493{
3494 RT_NOREF(pThread);
3495 int rc = VERR_NOT_IMPLEMENTED;
3496 AssertFailed();
3497 return rc;
3498}
3499
3500
3501static DECLCALLBACK(int) pdmR3DevHlp_ThreadSleep(PPDMTHREAD pThread, RTMSINTERVAL cMillies)
3502{
3503 RT_NOREF(pThread, cMillies);
3504 int rc = VERR_NOT_IMPLEMENTED;
3505 AssertFailed();
3506 return rc;
3507}
3508
3509
3510static DECLCALLBACK(int) pdmR3DevHlp_ThreadSuspend(PPDMTHREAD pThread)
3511{
3512 RT_NOREF(pThread);
3513 int rc = VERR_NOT_IMPLEMENTED;
3514 AssertFailed();
3515 return rc;
3516}
3517
3518
3519static DECLCALLBACK(int) pdmR3DevHlp_ThreadResume(PPDMTHREAD pThread)
3520{
3521 RT_NOREF(pThread);
3522 int rc = VERR_NOT_IMPLEMENTED;
3523 AssertFailed();
3524 return rc;
3525}
3526
3527
3528/** @interface_method_impl{PDMDEVHLPR3,pfnSetAsyncNotification} */
3529static DECLCALLBACK(int) pdmR3DevHlp_SetAsyncNotification(PPDMDEVINS pDevIns, PFNPDMDEVASYNCNOTIFY pfnAsyncNotify)
3530{
3531 PDMDEV_ASSERT_DEVINS(pDevIns);
3532 LogFlow(("pdmR3DevHlp_SetAsyncNotification: caller='%s'/%d: pfnAsyncNotify=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, pfnAsyncNotify));
3533
3534 int rc = VERR_NOT_IMPLEMENTED;
3535 AssertStmt(pfnAsyncNotify, rc = VERR_INVALID_PARAMETER);
3536#if 0
3537 AssertStmt(!pDevIns->Internal.s.pfnAsyncNotify, rc = VERR_WRONG_ORDER);
3538 AssertStmt(pDevIns->Internal.s.fIntFlags & (PDMDEVINSINT_FLAGS_SUSPENDED | PDMDEVINSINT_FLAGS_RESET), rc = VERR_WRONG_ORDER);
3539#endif
3540
3541 AssertFailed();
3542
3543 LogFlow(("pdmR3DevHlp_SetAsyncNotification: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3544 return rc;
3545}
3546
3547
3548/** @interface_method_impl{PDMDEVHLPR3,pfnAsyncNotificationCompleted} */
3549static DECLCALLBACK(void) pdmR3DevHlp_AsyncNotificationCompleted(PPDMDEVINS pDevIns)
3550{
3551 PDMDEV_ASSERT_DEVINS(pDevIns);
3552
3553 AssertFailed();
3554}
3555
3556
3557/** @interface_method_impl{PDMDEVHLPR3,pfnRTCRegister} */
3558static DECLCALLBACK(int) pdmR3DevHlp_RTCRegister(PPDMDEVINS pDevIns, PCPDMRTCREG pRtcReg, PCPDMRTCHLP *ppRtcHlp)
3559{
3560 PDMDEV_ASSERT_DEVINS(pDevIns);
3561 LogFlow(("pdmR3DevHlp_RTCRegister: caller='%s'/%d: pRtcReg=%p:{.u32Version=%#x, .pfnWrite=%p, .pfnRead=%p} ppRtcHlp=%p\n",
3562 pDevIns->pReg->szName, pDevIns->iInstance, pRtcReg, pRtcReg->u32Version, pRtcReg->pfnWrite,
3563 pRtcReg->pfnWrite, ppRtcHlp));
3564
3565 /*
3566 * Validate input.
3567 */
3568 if (pRtcReg->u32Version != PDM_RTCREG_VERSION)
3569 {
3570 AssertMsgFailed(("u32Version=%#x expected %#x\n", pRtcReg->u32Version,
3571 PDM_RTCREG_VERSION));
3572 LogFlow(("pdmR3DevHlp_RTCRegister: caller='%s'/%d: returns %Rrc (version)\n",
3573 pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
3574 return VERR_INVALID_PARAMETER;
3575 }
3576 if ( !pRtcReg->pfnWrite
3577 || !pRtcReg->pfnRead)
3578 {
3579 Assert(pRtcReg->pfnWrite);
3580 Assert(pRtcReg->pfnRead);
3581 LogFlow(("pdmR3DevHlp_RTCRegister: caller='%s'/%d: returns %Rrc (callbacks)\n",
3582 pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
3583 return VERR_INVALID_PARAMETER;
3584 }
3585
3586 if (!ppRtcHlp)
3587 {
3588 Assert(ppRtcHlp);
3589 LogFlow(("pdmR3DevHlp_RTCRegister: caller='%s'/%d: returns %Rrc (ppRtcHlp)\n",
3590 pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
3591 return VERR_INVALID_PARAMETER;
3592 }
3593
3594 int rc = VERR_NOT_IMPLEMENTED;
3595 AssertFailed();
3596
3597 LogFlow(("pdmR3DevHlp_RTCRegister: caller='%s'/%d: returns %Rrc\n",
3598 pDevIns->pReg->szName, pDevIns->iInstance, rc));
3599 return rc;
3600}
3601
3602
3603/** @interface_method_impl{PDMDEVHLPR3,pfnDMARegister} */
3604static DECLCALLBACK(int) pdmR3DevHlp_DMARegister(PPDMDEVINS pDevIns, unsigned uChannel, PFNDMATRANSFERHANDLER pfnTransferHandler, void *pvUser)
3605{
3606 PDMDEV_ASSERT_DEVINS(pDevIns);
3607 LogFlow(("pdmR3DevHlp_DMARegister: caller='%s'/%d: uChannel=%d pfnTransferHandler=%p pvUser=%p\n",
3608 pDevIns->pReg->szName, pDevIns->iInstance, uChannel, pfnTransferHandler, pvUser));
3609
3610 int rc = VERR_NOT_IMPLEMENTED;
3611 AssertFailed();
3612
3613 LogFlow(("pdmR3DevHlp_DMARegister: caller='%s'/%d: returns %Rrc\n",
3614 pDevIns->pReg->szName, pDevIns->iInstance, rc));
3615 return rc;
3616}
3617
3618
3619/** @interface_method_impl{PDMDEVHLPR3,pfnDMAReadMemory} */
3620static DECLCALLBACK(int) pdmR3DevHlp_DMAReadMemory(PPDMDEVINS pDevIns, unsigned uChannel, void *pvBuffer, uint32_t off, uint32_t cbBlock, uint32_t *pcbRead)
3621{
3622 PDMDEV_ASSERT_DEVINS(pDevIns);
3623 LogFlow(("pdmR3DevHlp_DMAReadMemory: caller='%s'/%d: uChannel=%d pvBuffer=%p off=%#x cbBlock=%#x pcbRead=%p\n",
3624 pDevIns->pReg->szName, pDevIns->iInstance, uChannel, pvBuffer, off, cbBlock, pcbRead));
3625
3626 int rc = VERR_NOT_IMPLEMENTED;
3627 AssertFailed();
3628
3629 LogFlow(("pdmR3DevHlp_DMAReadMemory: caller='%s'/%d: returns %Rrc\n",
3630 pDevIns->pReg->szName, pDevIns->iInstance, rc));
3631 return rc;
3632}
3633
3634
3635/** @interface_method_impl{PDMDEVHLPR3,pfnDMAWriteMemory} */
3636static DECLCALLBACK(int) pdmR3DevHlp_DMAWriteMemory(PPDMDEVINS pDevIns, unsigned uChannel, const void *pvBuffer, uint32_t off, uint32_t cbBlock, uint32_t *pcbWritten)
3637{
3638 PDMDEV_ASSERT_DEVINS(pDevIns);
3639 LogFlow(("pdmR3DevHlp_DMAWriteMemory: caller='%s'/%d: uChannel=%d pvBuffer=%p off=%#x cbBlock=%#x pcbWritten=%p\n",
3640 pDevIns->pReg->szName, pDevIns->iInstance, uChannel, pvBuffer, off, cbBlock, pcbWritten));
3641
3642 int rc = VERR_NOT_IMPLEMENTED;
3643 AssertFailed();
3644
3645 LogFlow(("pdmR3DevHlp_DMAWriteMemory: caller='%s'/%d: returns %Rrc\n",
3646 pDevIns->pReg->szName, pDevIns->iInstance, rc));
3647 return rc;
3648}
3649
3650
3651/** @interface_method_impl{PDMDEVHLPR3,pfnDMASetDREQ} */
3652static DECLCALLBACK(int) pdmR3DevHlp_DMASetDREQ(PPDMDEVINS pDevIns, unsigned uChannel, unsigned uLevel)
3653{
3654 PDMDEV_ASSERT_DEVINS(pDevIns);
3655 LogFlow(("pdmR3DevHlp_DMASetDREQ: caller='%s'/%d: uChannel=%d uLevel=%d\n",
3656 pDevIns->pReg->szName, pDevIns->iInstance, uChannel, uLevel));
3657
3658 int rc = VERR_NOT_IMPLEMENTED;
3659 AssertFailed();
3660
3661 LogFlow(("pdmR3DevHlp_DMASetDREQ: caller='%s'/%d: returns %Rrc\n",
3662 pDevIns->pReg->szName, pDevIns->iInstance, rc));
3663 return rc;
3664}
3665
3666/** @interface_method_impl{PDMDEVHLPR3,pfnDMAGetChannelMode} */
3667static DECLCALLBACK(uint8_t) pdmR3DevHlp_DMAGetChannelMode(PPDMDEVINS pDevIns, unsigned uChannel)
3668{
3669 PDMDEV_ASSERT_DEVINS(pDevIns);
3670 LogFlow(("pdmR3DevHlp_DMAGetChannelMode: caller='%s'/%d: uChannel=%d\n",
3671 pDevIns->pReg->szName, pDevIns->iInstance, uChannel));
3672
3673 uint8_t u8Mode = (3 << 2); /* Invalid mode. */
3674 AssertFailed();
3675
3676 LogFlow(("pdmR3DevHlp_DMAGetChannelMode: caller='%s'/%d: returns %#04x\n",
3677 pDevIns->pReg->szName, pDevIns->iInstance, u8Mode));
3678 return u8Mode;
3679}
3680
3681/** @interface_method_impl{PDMDEVHLPR3,pfnDMASchedule} */
3682static DECLCALLBACK(void) pdmR3DevHlp_DMASchedule(PPDMDEVINS pDevIns)
3683{
3684 PDMDEV_ASSERT_DEVINS(pDevIns);
3685 LogFlow(("pdmR3DevHlp_DMASchedule: caller='%s'/%d\n",
3686 pDevIns->pReg->szName, pDevIns->iInstance));
3687
3688 AssertFailed();
3689}
3690
3691
3692/** @interface_method_impl{PDMDEVHLPR3,pfnCMOSWrite} */
3693static DECLCALLBACK(int) pdmR3DevHlp_CMOSWrite(PPDMDEVINS pDevIns, unsigned iReg, uint8_t u8Value)
3694{
3695 PDMDEV_ASSERT_DEVINS(pDevIns);
3696 LogFlow(("pdmR3DevHlp_CMOSWrite: caller='%s'/%d: iReg=%#04x u8Value=%#04x\n",
3697 pDevIns->pReg->szName, pDevIns->iInstance, iReg, u8Value));
3698
3699 int rc = VERR_NOT_IMPLEMENTED;
3700 AssertFailed();
3701
3702 LogFlow(("pdmR3DevHlp_CMOSWrite: caller='%s'/%d: return %Rrc\n",
3703 pDevIns->pReg->szName, pDevIns->iInstance, rc));
3704 return rc;
3705}
3706
3707
3708/** @interface_method_impl{PDMDEVHLPR3,pfnCMOSRead} */
3709static DECLCALLBACK(int) pdmR3DevHlp_CMOSRead(PPDMDEVINS pDevIns, unsigned iReg, uint8_t *pu8Value)
3710{
3711 PDMDEV_ASSERT_DEVINS(pDevIns);
3712 LogFlow(("pdmR3DevHlp_CMOSWrite: caller='%s'/%d: iReg=%#04x pu8Value=%p\n",
3713 pDevIns->pReg->szName, pDevIns->iInstance, iReg, pu8Value));
3714
3715 int rc = VERR_NOT_IMPLEMENTED;
3716 AssertFailed();
3717
3718 LogFlow(("pdmR3DevHlp_CMOSWrite: caller='%s'/%d: return %Rrc\n",
3719 pDevIns->pReg->szName, pDevIns->iInstance, rc));
3720 return rc;
3721}
3722
3723
3724/** @interface_method_impl{PDMDEVHLPR3,pfnAssertEMT} */
3725static DECLCALLBACK(bool) pdmR3DevHlp_AssertEMT(PPDMDEVINS pDevIns, const char *pszFile, unsigned iLine, const char *pszFunction)
3726{
3727 PDMDEV_ASSERT_DEVINS(pDevIns);
3728
3729 char szMsg[100];
3730 RTStrPrintf(szMsg, sizeof(szMsg), "AssertEMT '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance);
3731 RTAssertMsg1Weak(szMsg, iLine, pszFile, pszFunction);
3732 AssertBreakpoint();
3733 return false;
3734}
3735
3736
3737/** @interface_method_impl{PDMDEVHLPR3,pfnAssertOther} */
3738static DECLCALLBACK(bool) pdmR3DevHlp_AssertOther(PPDMDEVINS pDevIns, const char *pszFile, unsigned iLine, const char *pszFunction)
3739{
3740 PDMDEV_ASSERT_DEVINS(pDevIns);
3741
3742 char szMsg[100];
3743 RTStrPrintf(szMsg, sizeof(szMsg), "AssertOther '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance);
3744 RTAssertMsg1Weak(szMsg, iLine, pszFile, pszFunction);
3745 AssertBreakpoint();
3746 return false;
3747}
3748
3749
3750/** @interface_method_impl{PDMDEVHLPR3,pfnLdrGetRCInterfaceSymbols} */
3751static DECLCALLBACK(int) pdmR3DevHlp_LdrGetRCInterfaceSymbols(PPDMDEVINS pDevIns, void *pvInterface, size_t cbInterface,
3752 const char *pszSymPrefix, const char *pszSymList)
3753{
3754 PDMDEV_ASSERT_DEVINS(pDevIns);
3755 LogFlow(("pdmR3DevHlp_PDMLdrGetRCInterfaceSymbols: caller='%s'/%d: pvInterface=%p cbInterface=%zu pszSymPrefix=%p:{%s} pszSymList=%p:{%s}\n",
3756 pDevIns->pReg->szName, pDevIns->iInstance, pvInterface, cbInterface, pszSymPrefix, pszSymPrefix, pszSymList, pszSymList));
3757
3758 int rc = VERR_NOT_IMPLEMENTED;
3759 AssertFailed();
3760
3761 LogFlow(("pdmR3DevHlp_PDMLdrGetRCInterfaceSymbols: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName,
3762 pDevIns->iInstance, rc));
3763 return rc;
3764}
3765
3766
3767/** @interface_method_impl{PDMDEVHLPR3,pfnLdrGetR0InterfaceSymbols} */
3768static DECLCALLBACK(int) pdmR3DevHlp_LdrGetR0InterfaceSymbols(PPDMDEVINS pDevIns, void *pvInterface, size_t cbInterface,
3769 const char *pszSymPrefix, const char *pszSymList)
3770{
3771 PDMDEV_ASSERT_DEVINS(pDevIns);
3772 LogFlow(("pdmR3DevHlp_PDMLdrGetR0InterfaceSymbols: caller='%s'/%d: pvInterface=%p cbInterface=%zu pszSymPrefix=%p:{%s} pszSymList=%p:{%s}\n",
3773 pDevIns->pReg->szName, pDevIns->iInstance, pvInterface, cbInterface, pszSymPrefix, pszSymPrefix, pszSymList, pszSymList));
3774
3775 int rc = VERR_NOT_IMPLEMENTED;
3776 AssertFailed();
3777
3778 LogFlow(("pdmR3DevHlp_PDMLdrGetR0InterfaceSymbols: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName,
3779 pDevIns->iInstance, rc));
3780 return rc;
3781}
3782
3783
3784/** @interface_method_impl{PDMDEVHLPR3,pfnCallR0} */
3785static DECLCALLBACK(int) pdmR3DevHlp_CallR0(PPDMDEVINS pDevIns, uint32_t uOperation, uint64_t u64Arg)
3786{
3787 PDMDEV_ASSERT_DEVINS(pDevIns);
3788 LogFlow(("pdmR3DevHlp_CallR0: caller='%s'/%d: uOperation=%#x u64Arg=%#RX64\n",
3789 pDevIns->pReg->szName, pDevIns->iInstance, uOperation, u64Arg));
3790
3791 int rc = VERR_NOT_IMPLEMENTED;
3792 AssertFailed();
3793
3794 LogFlow(("pdmR3DevHlp_CallR0: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName,
3795 pDevIns->iInstance, rc));
3796 return rc;
3797}
3798
3799
3800/** @interface_method_impl{PDMDEVHLPR3,pfnVMGetSuspendReason} */
3801static DECLCALLBACK(VMSUSPENDREASON) pdmR3DevHlp_VMGetSuspendReason(PPDMDEVINS pDevIns)
3802{
3803 PDMDEV_ASSERT_DEVINS(pDevIns);
3804
3805 VMSUSPENDREASON enmReason = VMSUSPENDREASON_INVALID;
3806 AssertFailed();
3807
3808 LogFlow(("pdmR3DevHlp_VMGetSuspendReason: caller='%s'/%d: returns %d\n",
3809 pDevIns->pReg->szName, pDevIns->iInstance, enmReason));
3810 return enmReason;
3811}
3812
3813
3814/** @interface_method_impl{PDMDEVHLPR3,pfnVMGetResumeReason} */
3815static DECLCALLBACK(VMRESUMEREASON) pdmR3DevHlp_VMGetResumeReason(PPDMDEVINS pDevIns)
3816{
3817 PDMDEV_ASSERT_DEVINS(pDevIns);
3818
3819 VMRESUMEREASON enmReason = VMRESUMEREASON_INVALID;
3820 AssertFailed();
3821
3822 LogFlow(("pdmR3DevHlp_VMGetResumeReason: caller='%s'/%d: returns %d\n",
3823 pDevIns->pReg->szName, pDevIns->iInstance, enmReason));
3824 return enmReason;
3825}
3826
3827
3828/** @interface_method_impl{PDMDEVHLPR3,pfnGetUVM} */
3829static DECLCALLBACK(PUVM) pdmR3DevHlp_GetUVM(PPDMDEVINS pDevIns)
3830{
3831 PDMDEV_ASSERT_DEVINS(pDevIns);
3832
3833 AssertFailed();
3834 LogFlow(("pdmR3DevHlp_GetUVM: caller='%s'/%d: returns %p\n", pDevIns->pReg->szName, pDevIns->iInstance, NULL));
3835 return NULL;
3836}
3837
3838
3839/** @interface_method_impl{PDMDEVHLPR3,pfnGetVM} */
3840static DECLCALLBACK(PVMCC) pdmR3DevHlp_GetVM(PPDMDEVINS pDevIns)
3841{
3842 PDMDEV_ASSERT_DEVINS(pDevIns);
3843
3844 AssertFailed();
3845 LogFlow(("pdmR3DevHlp_GetVM: caller='%s'/%d: returns %p\n", pDevIns->pReg->szName, pDevIns->iInstance, NULL));
3846 return NULL;
3847}
3848
3849
3850/** @interface_method_impl{PDMDEVHLPR3,pfnGetVMCPU} */
3851static DECLCALLBACK(PVMCPU) pdmR3DevHlp_GetVMCPU(PPDMDEVINS pDevIns)
3852{
3853 PDMDEV_ASSERT_DEVINS(pDevIns);
3854
3855 AssertFailed();
3856 LogFlow(("pdmR3DevHlp_GetVMCPU: caller='%s'/%d for CPU %u\n", pDevIns->pReg->szName, pDevIns->iInstance, NULL));
3857 return NULL;
3858}
3859
3860
3861/** @interface_method_impl{PDMDEVHLPR3,pfnGetCurrentCpuId} */
3862static DECLCALLBACK(VMCPUID) pdmR3DevHlp_GetCurrentCpuId(PPDMDEVINS pDevIns)
3863{
3864 PDMDEV_ASSERT_DEVINS(pDevIns);
3865
3866 VMCPUID idCpu = 0;
3867 AssertFailed();
3868
3869 LogFlow(("pdmR3DevHlp_GetCurrentCpuId: caller='%s'/%d for CPU %u\n", pDevIns->pReg->szName, pDevIns->iInstance, idCpu));
3870 return idCpu;
3871}
3872
3873
3874/** @interface_method_impl{PDMDEVHLPR3,pfnPCIBusRegister} */
3875static DECLCALLBACK(int) pdmR3DevHlp_PCIBusRegister(PPDMDEVINS pDevIns, PPDMPCIBUSREGR3 pPciBusReg,
3876 PCPDMPCIHLPR3 *ppPciHlp, uint32_t *piBus)
3877{
3878 PDMDEV_ASSERT_DEVINS(pDevIns);
3879 LogFlow(("pdmR3DevHlp_PCIBusRegister: caller='%s'/%d: pPciBusReg=%p:{.u32Version=%#x, .pfnRegisterR3=%p, .pfnIORegionRegisterR3=%p, "
3880 ".pfnInterceptConfigAccesses=%p, pfnConfigRead=%p, pfnConfigWrite=%p, .pfnSetIrqR3=%p, .u32EndVersion=%#x} ppPciHlpR3=%p piBus=%p\n",
3881 pDevIns->pReg->szName, pDevIns->iInstance, pPciBusReg, pPciBusReg->u32Version, pPciBusReg->pfnRegisterR3,
3882 pPciBusReg->pfnIORegionRegisterR3, pPciBusReg->pfnInterceptConfigAccesses, pPciBusReg->pfnConfigRead,
3883 pPciBusReg->pfnConfigWrite, pPciBusReg->pfnSetIrqR3, pPciBusReg->u32EndVersion, ppPciHlp, piBus));
3884
3885 /*
3886 * Validate the structure and output parameters.
3887 */
3888 AssertLogRelMsgReturn(pPciBusReg->u32Version == PDM_PCIBUSREGR3_VERSION,
3889 ("u32Version=%#x expected %#x\n", pPciBusReg->u32Version, PDM_PCIBUSREGR3_VERSION),
3890 VERR_INVALID_PARAMETER);
3891 AssertPtrReturn(pPciBusReg->pfnRegisterR3, VERR_INVALID_PARAMETER);
3892 AssertPtrNullReturn(pPciBusReg->pfnRegisterMsiR3, VERR_INVALID_POINTER);
3893 AssertPtrReturn(pPciBusReg->pfnIORegionRegisterR3, VERR_INVALID_POINTER);
3894 AssertPtrReturn(pPciBusReg->pfnInterceptConfigAccesses, VERR_INVALID_POINTER);
3895 AssertPtrReturn(pPciBusReg->pfnConfigWrite, VERR_INVALID_POINTER);
3896 AssertPtrReturn(pPciBusReg->pfnConfigRead, VERR_INVALID_POINTER);
3897 AssertPtrReturn(pPciBusReg->pfnSetIrqR3, VERR_INVALID_POINTER);
3898 AssertLogRelMsgReturn(pPciBusReg->u32EndVersion == PDM_PCIBUSREGR3_VERSION,
3899 ("u32Version=%#x expected %#x\n", pPciBusReg->u32Version, PDM_PCIBUSREGR3_VERSION),
3900 VERR_INVALID_PARAMETER);
3901 AssertPtrReturn(ppPciHlp, VERR_INVALID_POINTER);
3902 AssertPtrNullReturn(piBus, VERR_INVALID_POINTER);
3903
3904 int rc = VERR_NOT_IMPLEMENTED;
3905 AssertFailed();
3906
3907 Log(("PDM: Registered PCI bus device '%s'/%d pDevIns=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, pDevIns));
3908
3909 LogFlow(("pdmR3DevHlp_PCIBusRegister: caller='%s'/%d: returns %Rrc *piBus=%u\n", pDevIns->pReg->szName, pDevIns->iInstance, rc, *piBus));
3910 return rc;
3911}
3912
3913
3914/** @interface_method_impl{PDMDEVHLPR3,pfnPICRegister} */
3915static DECLCALLBACK(int) pdmR3DevHlp_PICRegister(PPDMDEVINS pDevIns, PPDMPICREG pPicReg, PCPDMPICHLP *ppPicHlp)
3916{
3917 PDMDEV_ASSERT_DEVINS(pDevIns);
3918 LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: pPicReg=%p:{.u32Version=%#x, .pfnSetIrq=%p, .pfnGetInterrupt=%p, .u32TheEnd=%#x } ppPicHlp=%p\n",
3919 pDevIns->pReg->szName, pDevIns->iInstance, pPicReg, pPicReg->u32Version, pPicReg->pfnSetIrq, pPicReg->pfnGetInterrupt, pPicReg->u32TheEnd, ppPicHlp));
3920
3921 /*
3922 * Validate input.
3923 */
3924 AssertMsgReturn(pPicReg->u32Version == PDM_PICREG_VERSION,
3925 ("%s/%d: u32Version=%#x expected %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, pPicReg->u32Version, PDM_PICREG_VERSION),
3926 VERR_INVALID_PARAMETER);
3927 AssertPtrReturn(pPicReg->pfnSetIrq, VERR_INVALID_POINTER);
3928 AssertPtrReturn(pPicReg->pfnGetInterrupt, VERR_INVALID_POINTER);
3929 AssertMsgReturn(pPicReg->u32TheEnd == PDM_PICREG_VERSION,
3930 ("%s/%d: u32TheEnd=%#x expected %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, pPicReg->u32TheEnd, PDM_PICREG_VERSION),
3931 VERR_INVALID_PARAMETER);
3932 AssertPtrReturn(ppPicHlp, VERR_INVALID_POINTER);
3933
3934 int rc = VERR_NOT_IMPLEMENTED;
3935 AssertFailed();
3936 Log(("PDM: Registered PIC device '%s'/%d pDevIns=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, pDevIns));
3937
3938 LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3939 return rc;
3940}
3941
3942
3943/** @interface_method_impl{PDMDEVHLPR3,pfnApicRegister} */
3944static DECLCALLBACK(int) pdmR3DevHlp_ApicRegister(PPDMDEVINS pDevIns)
3945{
3946 PDMDEV_ASSERT_DEVINS(pDevIns);
3947
3948 int rc = VERR_NOT_IMPLEMENTED;
3949 AssertFailed();
3950
3951 LogFlow(("pdmR3DevHlp_ApicRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3952 return rc;
3953}
3954
3955
3956/** @interface_method_impl{PDMDEVHLPR3,pfnIoApicRegister} */
3957static DECLCALLBACK(int) pdmR3DevHlp_IoApicRegister(PPDMDEVINS pDevIns, PPDMIOAPICREG pIoApicReg, PCPDMIOAPICHLP *ppIoApicHlp)
3958{
3959 PDMDEV_ASSERT_DEVINS(pDevIns);
3960 LogFlow(("pdmR3DevHlp_IoApicRegister: caller='%s'/%d: pIoApicReg=%p:{.u32Version=%#x, .pfnSetIrq=%p, .pfnSendMsi=%p, .pfnSetEoi=%p, .u32TheEnd=%#x } ppIoApicHlp=%p\n",
3961 pDevIns->pReg->szName, pDevIns->iInstance, pIoApicReg, pIoApicReg->u32Version, pIoApicReg->pfnSetIrq, pIoApicReg->pfnSendMsi, pIoApicReg->pfnSetEoi, pIoApicReg->u32TheEnd, ppIoApicHlp));
3962
3963 /*
3964 * Validate input.
3965 */
3966 AssertMsgReturn(pIoApicReg->u32Version == PDM_IOAPICREG_VERSION,
3967 ("%s/%d: u32Version=%#x expected %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, pIoApicReg->u32Version, PDM_IOAPICREG_VERSION),
3968 VERR_VERSION_MISMATCH);
3969 AssertPtrReturn(pIoApicReg->pfnSetIrq, VERR_INVALID_POINTER);
3970 AssertPtrReturn(pIoApicReg->pfnSendMsi, VERR_INVALID_POINTER);
3971 AssertPtrReturn(pIoApicReg->pfnSetEoi, VERR_INVALID_POINTER);
3972 AssertMsgReturn(pIoApicReg->u32TheEnd == PDM_IOAPICREG_VERSION,
3973 ("%s/%d: u32TheEnd=%#x expected %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, pIoApicReg->u32TheEnd, PDM_IOAPICREG_VERSION),
3974 VERR_VERSION_MISMATCH);
3975 AssertPtrReturn(ppIoApicHlp, VERR_INVALID_POINTER);
3976
3977 int rc = VERR_NOT_IMPLEMENTED;
3978 AssertFailed();
3979
3980 LogFlow(("pdmR3DevHlp_IoApicRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3981 return rc;
3982}
3983
3984
3985/** @interface_method_impl{PDMDEVHLPR3,pfnHpetRegister} */
3986static DECLCALLBACK(int) pdmR3DevHlp_HpetRegister(PPDMDEVINS pDevIns, PPDMHPETREG pHpetReg, PCPDMHPETHLPR3 *ppHpetHlpR3)
3987{
3988 PDMDEV_ASSERT_DEVINS(pDevIns);
3989 LogFlow(("pdmR3DevHlp_HpetRegister: caller='%s'/%d:\n", pDevIns->pReg->szName, pDevIns->iInstance));
3990
3991 /*
3992 * Validate input.
3993 */
3994 AssertMsgReturn(pHpetReg->u32Version == PDM_HPETREG_VERSION,
3995 ("%s/%u: u32Version=%#x expected %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, pHpetReg->u32Version, PDM_HPETREG_VERSION),
3996 VERR_VERSION_MISMATCH);
3997 AssertPtrReturn(ppHpetHlpR3, VERR_INVALID_POINTER);
3998
3999 int rc = VERR_NOT_IMPLEMENTED;
4000 AssertFailed();
4001
4002 LogFlow(("pdmR3DevHlp_HpetRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
4003 return rc;
4004}
4005
4006
4007/** @interface_method_impl{PDMDEVHLPR3,pfnPciRawRegister} */
4008static DECLCALLBACK(int) pdmR3DevHlp_PciRawRegister(PPDMDEVINS pDevIns, PPDMPCIRAWREG pPciRawReg, PCPDMPCIRAWHLPR3 *ppPciRawHlpR3)
4009{
4010 PDMDEV_ASSERT_DEVINS(pDevIns); RT_NOREF_PV(pDevIns);
4011 LogFlow(("pdmR3DevHlp_PciRawRegister: caller='%s'/%d:\n", pDevIns->pReg->szName, pDevIns->iInstance));
4012
4013 /*
4014 * Validate input.
4015 */
4016 if (pPciRawReg->u32Version != PDM_PCIRAWREG_VERSION)
4017 {
4018 AssertMsgFailed(("u32Version=%#x expected %#x\n", pPciRawReg->u32Version, PDM_PCIRAWREG_VERSION));
4019 LogFlow(("pdmR3DevHlp_PciRawRegister: caller='%s'/%d: returns %Rrc (version)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
4020 return VERR_INVALID_PARAMETER;
4021 }
4022
4023 if (!ppPciRawHlpR3)
4024 {
4025 Assert(ppPciRawHlpR3);
4026 LogFlow(("pdmR3DevHlp_PciRawRegister: caller='%s'/%d: returns %Rrc (ppPciRawHlpR3)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
4027 return VERR_INVALID_PARAMETER;
4028 }
4029
4030 int rc = VERR_NOT_IMPLEMENTED;
4031 AssertFailed();
4032
4033 LogFlow(("pdmR3DevHlp_PciRawRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
4034 return rc;
4035}
4036
4037
4038/** @interface_method_impl{PDMDEVHLPR3,pfnDMACRegister} */
4039static DECLCALLBACK(int) pdmR3DevHlp_DMACRegister(PPDMDEVINS pDevIns, PPDMDMACREG pDmacReg, PCPDMDMACHLP *ppDmacHlp)
4040{
4041 PDMDEV_ASSERT_DEVINS(pDevIns);
4042 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",
4043 pDevIns->pReg->szName, pDevIns->iInstance, pDmacReg, pDmacReg->u32Version, pDmacReg->pfnRun, pDmacReg->pfnRegister,
4044 pDmacReg->pfnReadMemory, pDmacReg->pfnWriteMemory, pDmacReg->pfnSetDREQ, pDmacReg->pfnGetChannelMode, ppDmacHlp));
4045
4046 /*
4047 * Validate input.
4048 */
4049 if (pDmacReg->u32Version != PDM_DMACREG_VERSION)
4050 {
4051 AssertMsgFailed(("u32Version=%#x expected %#x\n", pDmacReg->u32Version,
4052 PDM_DMACREG_VERSION));
4053 LogFlow(("pdmR3DevHlp_DMACRegister: caller='%s'/%d: returns %Rrc (version)\n",
4054 pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
4055 return VERR_INVALID_PARAMETER;
4056 }
4057 if ( !pDmacReg->pfnRun
4058 || !pDmacReg->pfnRegister
4059 || !pDmacReg->pfnReadMemory
4060 || !pDmacReg->pfnWriteMemory
4061 || !pDmacReg->pfnSetDREQ
4062 || !pDmacReg->pfnGetChannelMode)
4063 {
4064 Assert(pDmacReg->pfnRun);
4065 Assert(pDmacReg->pfnRegister);
4066 Assert(pDmacReg->pfnReadMemory);
4067 Assert(pDmacReg->pfnWriteMemory);
4068 Assert(pDmacReg->pfnSetDREQ);
4069 Assert(pDmacReg->pfnGetChannelMode);
4070 LogFlow(("pdmR3DevHlp_DMACRegister: caller='%s'/%d: returns %Rrc (callbacks)\n",
4071 pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
4072 return VERR_INVALID_PARAMETER;
4073 }
4074
4075 if (!ppDmacHlp)
4076 {
4077 Assert(ppDmacHlp);
4078 LogFlow(("pdmR3DevHlp_DMACRegister: caller='%s'/%d: returns %Rrc (ppDmacHlp)\n",
4079 pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
4080 return VERR_INVALID_PARAMETER;
4081 }
4082
4083 int rc = VERR_NOT_IMPLEMENTED;
4084 AssertFailed();
4085
4086 LogFlow(("pdmR3DevHlp_DMACRegister: caller='%s'/%d: returns %Rrc\n",
4087 pDevIns->pReg->szName, pDevIns->iInstance, rc));
4088 return rc;
4089}
4090
4091
4092/**
4093 * @copydoc PDMDEVHLPR3::pfnRegisterVMMDevHeap
4094 */
4095static DECLCALLBACK(int) pdmR3DevHlp_RegisterVMMDevHeap(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, RTR3PTR pvHeap, unsigned cbHeap)
4096{
4097 PDMDEV_ASSERT_DEVINS(pDevIns);
4098 LogFlow(("pdmR3DevHlp_RegisterVMMDevHeap: caller='%s'/%d: GCPhys=%RGp pvHeap=%p cbHeap=%#x\n",
4099 pDevIns->pReg->szName, pDevIns->iInstance, GCPhys, pvHeap, cbHeap));
4100
4101 int rc = VERR_NOT_IMPLEMENTED;
4102 AssertFailed();
4103
4104 LogFlow(("pdmR3DevHlp_RegisterVMMDevHeap: caller='%s'/%d: returns %Rrc\n",
4105 pDevIns->pReg->szName, pDevIns->iInstance, rc));
4106 return rc;
4107}
4108
4109
4110/**
4111 * @interface_method_impl{PDMDEVHLPR3,pfnFirmwareRegister}
4112 */
4113static DECLCALLBACK(int) pdmR3DevHlp_FirmwareRegister(PPDMDEVINS pDevIns, PCPDMFWREG pFwReg, PCPDMFWHLPR3 *ppFwHlp)
4114{
4115 PDMDEV_ASSERT_DEVINS(pDevIns);
4116 LogFlow(("pdmR3DevHlp_FirmwareRegister: caller='%s'/%d: pFWReg=%p:{.u32Version=%#x, .pfnIsHardReset=%p, .u32TheEnd=%#x} ppFwHlp=%p\n",
4117 pDevIns->pReg->szName, pDevIns->iInstance, pFwReg, pFwReg->u32Version, pFwReg->pfnIsHardReset, pFwReg->u32TheEnd, ppFwHlp));
4118
4119 /*
4120 * Validate input.
4121 */
4122 if (pFwReg->u32Version != PDM_FWREG_VERSION)
4123 {
4124 AssertMsgFailed(("u32Version=%#x expected %#x\n", pFwReg->u32Version, PDM_FWREG_VERSION));
4125 LogFlow(("pdmR3DevHlp_FirmwareRegister: caller='%s'/%d: returns %Rrc (version)\n",
4126 pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
4127 return VERR_INVALID_PARAMETER;
4128 }
4129 if (!pFwReg->pfnIsHardReset)
4130 {
4131 Assert(pFwReg->pfnIsHardReset);
4132 LogFlow(("pdmR3DevHlp_FirmwareRegister: caller='%s'/%d: returns %Rrc (callbacks)\n",
4133 pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
4134 return VERR_INVALID_PARAMETER;
4135 }
4136
4137 if (!ppFwHlp)
4138 {
4139 Assert(ppFwHlp);
4140 LogFlow(("pdmR3DevHlp_FirmwareRegister: caller='%s'/%d: returns %Rrc (ppFwHlp)\n",
4141 pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
4142 return VERR_INVALID_PARAMETER;
4143 }
4144
4145 int rc = VERR_NOT_IMPLEMENTED;
4146 AssertFailed();
4147
4148 LogFlow(("pdmR3DevHlp_FirmwareRegister: caller='%s'/%d: returns %Rrc\n",
4149 pDevIns->pReg->szName, pDevIns->iInstance, rc));
4150 return rc;
4151}
4152
4153
4154/** @interface_method_impl{PDMDEVHLPR3,pfnVMReset} */
4155static DECLCALLBACK(int) pdmR3DevHlp_VMReset(PPDMDEVINS pDevIns, uint32_t fFlags)
4156{
4157 PDMDEV_ASSERT_DEVINS(pDevIns);
4158 LogFlow(("pdmR3DevHlp_VMReset: caller='%s'/%d: fFlags=%#x\n",
4159 pDevIns->pReg->szName, pDevIns->iInstance, fFlags));
4160
4161 int rc = VERR_NOT_IMPLEMENTED;
4162 AssertFailed();
4163
4164 LogFlow(("pdmR3DevHlp_VMReset: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
4165 return rc;
4166}
4167
4168
4169/** @interface_method_impl{PDMDEVHLPR3,pfnVMSuspend} */
4170static DECLCALLBACK(int) pdmR3DevHlp_VMSuspend(PPDMDEVINS pDevIns)
4171{
4172 PDMDEV_ASSERT_DEVINS(pDevIns);
4173 LogFlow(("pdmR3DevHlp_VMSuspend: caller='%s'/%d:\n",
4174 pDevIns->pReg->szName, pDevIns->iInstance));
4175
4176 int rc = VERR_NOT_IMPLEMENTED;
4177 AssertFailed();
4178
4179 LogFlow(("pdmR3DevHlp_VMSuspend: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
4180 return rc;
4181}
4182
4183
4184/** @interface_method_impl{PDMDEVHLPR3,pfnVMSuspendSaveAndPowerOff} */
4185static DECLCALLBACK(int) pdmR3DevHlp_VMSuspendSaveAndPowerOff(PPDMDEVINS pDevIns)
4186{
4187 PDMDEV_ASSERT_DEVINS(pDevIns);
4188 LogFlow(("pdmR3DevHlp_VMSuspendSaveAndPowerOff: caller='%s'/%d:\n",
4189 pDevIns->pReg->szName, pDevIns->iInstance));
4190
4191 int rc = VERR_NOT_IMPLEMENTED;
4192 AssertFailed();
4193
4194 LogFlow(("pdmR3DevHlp_VMSuspendSaveAndPowerOff: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
4195 return rc;
4196}
4197
4198
4199/** @interface_method_impl{PDMDEVHLPR3,pfnVMPowerOff} */
4200static DECLCALLBACK(int) pdmR3DevHlp_VMPowerOff(PPDMDEVINS pDevIns)
4201{
4202 PDMDEV_ASSERT_DEVINS(pDevIns);
4203 LogFlow(("pdmR3DevHlp_VMPowerOff: caller='%s'/%d:\n",
4204 pDevIns->pReg->szName, pDevIns->iInstance));
4205
4206 int rc = VERR_NOT_IMPLEMENTED;
4207 AssertFailed();
4208
4209 LogFlow(("pdmR3DevHlp_VMPowerOff: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
4210 return rc;
4211}
4212
4213
4214/** @interface_method_impl{PDMDEVHLPR3,pfnA20IsEnabled} */
4215static DECLCALLBACK(bool) pdmR3DevHlp_A20IsEnabled(PPDMDEVINS pDevIns)
4216{
4217 PDMDEV_ASSERT_DEVINS(pDevIns);
4218
4219 bool fRc = false;
4220 AssertFailed();
4221
4222 LogFlow(("pdmR3DevHlp_A20IsEnabled: caller='%s'/%d: returns %d\n", pDevIns->pReg->szName, pDevIns->iInstance, fRc));
4223 return fRc;
4224}
4225
4226
4227/** @interface_method_impl{PDMDEVHLPR3,pfnA20Set} */
4228static DECLCALLBACK(void) pdmR3DevHlp_A20Set(PPDMDEVINS pDevIns, bool fEnable)
4229{
4230 PDMDEV_ASSERT_DEVINS(pDevIns);
4231 LogFlow(("pdmR3DevHlp_A20Set: caller='%s'/%d: fEnable=%d\n", pDevIns->pReg->szName, pDevIns->iInstance, fEnable));
4232 AssertFailed();
4233}
4234
4235
4236/** @interface_method_impl{PDMDEVHLPR3,pfnGetCpuId} */
4237static DECLCALLBACK(void) pdmR3DevHlp_GetCpuId(PPDMDEVINS pDevIns, uint32_t iLeaf,
4238 uint32_t *pEax, uint32_t *pEbx, uint32_t *pEcx, uint32_t *pEdx)
4239{
4240 PDMDEV_ASSERT_DEVINS(pDevIns);
4241 LogFlow(("pdmR3DevHlp_GetCpuId: caller='%s'/%d: iLeaf=%d pEax=%p pEbx=%p pEcx=%p pEdx=%p\n",
4242 pDevIns->pReg->szName, pDevIns->iInstance, iLeaf, pEax, pEbx, pEcx, pEdx));
4243 AssertPtr(pEax); AssertPtr(pEbx); AssertPtr(pEcx); AssertPtr(pEdx);
4244
4245 AssertFailed();
4246
4247 LogFlow(("pdmR3DevHlp_GetCpuId: caller='%s'/%d: returns void - *pEax=%#x *pEbx=%#x *pEcx=%#x *pEdx=%#x\n",
4248 pDevIns->pReg->szName, pDevIns->iInstance, *pEax, *pEbx, *pEcx, *pEdx));
4249}
4250
4251const PDMDEVHLPR3 g_tstDevPdmDevHlpR3 =
4252{
4253 PDM_DEVHLPR3_VERSION,
4254 pdmR3DevHlp_IoPortCreateEx,
4255 pdmR3DevHlp_IoPortMap,
4256 pdmR3DevHlp_IoPortUnmap,
4257 pdmR3DevHlp_IoPortGetMappingAddress,
4258 pdmR3DevHlp_MmioCreateEx,
4259 pdmR3DevHlp_MmioMap,
4260 pdmR3DevHlp_MmioUnmap,
4261 pdmR3DevHlp_MmioReduce,
4262 pdmR3DevHlp_MmioGetMappingAddress,
4263 pdmR3DevHlp_Mmio2Create,
4264 pdmR3DevHlp_Mmio2Destroy,
4265 pdmR3DevHlp_Mmio2Map,
4266 pdmR3DevHlp_Mmio2Unmap,
4267 pdmR3DevHlp_Mmio2Reduce,
4268 pdmR3DevHlp_Mmio2GetMappingAddress,
4269 pdmR3DevHlp_Mmio2ChangeRegionNo,
4270 pdmR3DevHlp_ROMRegister,
4271 pdmR3DevHlp_ROMProtectShadow,
4272 pdmR3DevHlp_SSMRegister,
4273 pdmR3DevHlp_SSMPutStruct,
4274 pdmR3DevHlp_SSMPutStructEx,
4275 pdmR3DevHlp_SSMPutBool,
4276 pdmR3DevHlp_SSMPutU8,
4277 pdmR3DevHlp_SSMPutS8,
4278 pdmR3DevHlp_SSMPutU16,
4279 pdmR3DevHlp_SSMPutS16,
4280 pdmR3DevHlp_SSMPutU32,
4281 pdmR3DevHlp_SSMPutS32,
4282 pdmR3DevHlp_SSMPutU64,
4283 pdmR3DevHlp_SSMPutS64,
4284 pdmR3DevHlp_SSMPutU128,
4285 pdmR3DevHlp_SSMPutS128,
4286 pdmR3DevHlp_SSMPutUInt,
4287 pdmR3DevHlp_SSMPutSInt,
4288 pdmR3DevHlp_SSMPutGCUInt,
4289 pdmR3DevHlp_SSMPutGCUIntReg,
4290 pdmR3DevHlp_SSMPutGCPhys32,
4291 pdmR3DevHlp_SSMPutGCPhys64,
4292 pdmR3DevHlp_SSMPutGCPhys,
4293 pdmR3DevHlp_SSMPutGCPtr,
4294 pdmR3DevHlp_SSMPutGCUIntPtr,
4295 pdmR3DevHlp_SSMPutRCPtr,
4296 pdmR3DevHlp_SSMPutIOPort,
4297 pdmR3DevHlp_SSMPutSel,
4298 pdmR3DevHlp_SSMPutMem,
4299 pdmR3DevHlp_SSMPutStrZ,
4300 pdmR3DevHlp_SSMGetStruct,
4301 pdmR3DevHlp_SSMGetStructEx,
4302 pdmR3DevHlp_SSMGetBool,
4303 pdmR3DevHlp_SSMGetBoolV,
4304 pdmR3DevHlp_SSMGetU8,
4305 pdmR3DevHlp_SSMGetU8V,
4306 pdmR3DevHlp_SSMGetS8,
4307 pdmR3DevHlp_SSMGetS8V,
4308 pdmR3DevHlp_SSMGetU16,
4309 pdmR3DevHlp_SSMGetU16V,
4310 pdmR3DevHlp_SSMGetS16,
4311 pdmR3DevHlp_SSMGetS16V,
4312 pdmR3DevHlp_SSMGetU32,
4313 pdmR3DevHlp_SSMGetU32V,
4314 pdmR3DevHlp_SSMGetS32,
4315 pdmR3DevHlp_SSMGetS32V,
4316 pdmR3DevHlp_SSMGetU64,
4317 pdmR3DevHlp_SSMGetU64V,
4318 pdmR3DevHlp_SSMGetS64,
4319 pdmR3DevHlp_SSMGetS64V,
4320 pdmR3DevHlp_SSMGetU128,
4321 pdmR3DevHlp_SSMGetU128V,
4322 pdmR3DevHlp_SSMGetS128,
4323 pdmR3DevHlp_SSMGetS128V,
4324 pdmR3DevHlp_SSMGetGCPhys32,
4325 pdmR3DevHlp_SSMGetGCPhys32V,
4326 pdmR3DevHlp_SSMGetGCPhys64,
4327 pdmR3DevHlp_SSMGetGCPhys64V,
4328 pdmR3DevHlp_SSMGetGCPhys,
4329 pdmR3DevHlp_SSMGetGCPhysV,
4330 pdmR3DevHlp_SSMGetUInt,
4331 pdmR3DevHlp_SSMGetSInt,
4332 pdmR3DevHlp_SSMGetGCUInt,
4333 pdmR3DevHlp_SSMGetGCUIntReg,
4334 pdmR3DevHlp_SSMGetGCPtr,
4335 pdmR3DevHlp_SSMGetGCUIntPtr,
4336 pdmR3DevHlp_SSMGetRCPtr,
4337 pdmR3DevHlp_SSMGetIOPort,
4338 pdmR3DevHlp_SSMGetSel,
4339 pdmR3DevHlp_SSMGetMem,
4340 pdmR3DevHlp_SSMGetStrZ,
4341 pdmR3DevHlp_SSMGetStrZEx,
4342 pdmR3DevHlp_SSMSkip,
4343 pdmR3DevHlp_SSMSkipToEndOfUnit,
4344 pdmR3DevHlp_SSMSetLoadError,
4345 pdmR3DevHlp_SSMSetLoadErrorV,
4346 pdmR3DevHlp_SSMSetCfgError,
4347 pdmR3DevHlp_SSMSetCfgErrorV,
4348 pdmR3DevHlp_SSMHandleGetStatus,
4349 pdmR3DevHlp_SSMHandleGetAfter,
4350 pdmR3DevHlp_SSMHandleIsLiveSave,
4351 pdmR3DevHlp_SSMHandleMaxDowntime,
4352 pdmR3DevHlp_SSMHandleHostBits,
4353 pdmR3DevHlp_SSMHandleRevision,
4354 pdmR3DevHlp_SSMHandleVersion,
4355 pdmR3DevHlp_SSMHandleHostOSAndArch,
4356 pdmR3DevHlp_TMTimerCreate,
4357 pdmR3DevHlp_TimerCreate,
4358 pdmR3DevHlp_TimerToPtr,
4359 pdmR3DevHlp_TimerFromMicro,
4360 pdmR3DevHlp_TimerFromMilli,
4361 pdmR3DevHlp_TimerFromNano,
4362 pdmR3DevHlp_TimerGet,
4363 pdmR3DevHlp_TimerGetFreq,
4364 pdmR3DevHlp_TimerGetNano,
4365 pdmR3DevHlp_TimerIsActive,
4366 pdmR3DevHlp_TimerIsLockOwner,
4367 pdmR3DevHlp_TimerLockClock,
4368 pdmR3DevHlp_TimerLockClock2,
4369 pdmR3DevHlp_TimerSet,
4370 pdmR3DevHlp_TimerSetFrequencyHint,
4371 pdmR3DevHlp_TimerSetMicro,
4372 pdmR3DevHlp_TimerSetMillies,
4373 pdmR3DevHlp_TimerSetNano,
4374 pdmR3DevHlp_TimerSetRelative,
4375 pdmR3DevHlp_TimerStop,
4376 pdmR3DevHlp_TimerUnlockClock,
4377 pdmR3DevHlp_TimerUnlockClock2,
4378 pdmR3DevHlp_TimerSetCritSect,
4379 pdmR3DevHlp_TimerSave,
4380 pdmR3DevHlp_TimerLoad,
4381 pdmR3DevHlp_TimerDestroy,
4382 pdmR3DevHlp_TimerSkipLoad,
4383 pdmR3DevHlp_TMUtcNow,
4384 pdmR3DevHlp_CFGMExists,
4385 pdmR3DevHlp_CFGMQueryType,
4386 pdmR3DevHlp_CFGMQuerySize,
4387 pdmR3DevHlp_CFGMQueryInteger,
4388 pdmR3DevHlp_CFGMQueryIntegerDef,
4389 pdmR3DevHlp_CFGMQueryString,
4390 pdmR3DevHlp_CFGMQueryStringDef,
4391 pdmR3DevHlp_CFGMQueryBytes,
4392 pdmR3DevHlp_CFGMQueryU64,
4393 pdmR3DevHlp_CFGMQueryU64Def,
4394 pdmR3DevHlp_CFGMQueryS64,
4395 pdmR3DevHlp_CFGMQueryS64Def,
4396 pdmR3DevHlp_CFGMQueryU32,
4397 pdmR3DevHlp_CFGMQueryU32Def,
4398 pdmR3DevHlp_CFGMQueryS32,
4399 pdmR3DevHlp_CFGMQueryS32Def,
4400 pdmR3DevHlp_CFGMQueryU16,
4401 pdmR3DevHlp_CFGMQueryU16Def,
4402 pdmR3DevHlp_CFGMQueryS16,
4403 pdmR3DevHlp_CFGMQueryS16Def,
4404 pdmR3DevHlp_CFGMQueryU8,
4405 pdmR3DevHlp_CFGMQueryU8Def,
4406 pdmR3DevHlp_CFGMQueryS8,
4407 pdmR3DevHlp_CFGMQueryS8Def,
4408 pdmR3DevHlp_CFGMQueryBool,
4409 pdmR3DevHlp_CFGMQueryBoolDef,
4410 pdmR3DevHlp_CFGMQueryPort,
4411 pdmR3DevHlp_CFGMQueryPortDef,
4412 pdmR3DevHlp_CFGMQueryUInt,
4413 pdmR3DevHlp_CFGMQueryUIntDef,
4414 pdmR3DevHlp_CFGMQuerySInt,
4415 pdmR3DevHlp_CFGMQuerySIntDef,
4416 pdmR3DevHlp_CFGMQueryPtr,
4417 pdmR3DevHlp_CFGMQueryPtrDef,
4418 pdmR3DevHlp_CFGMQueryGCPtr,
4419 pdmR3DevHlp_CFGMQueryGCPtrDef,
4420 pdmR3DevHlp_CFGMQueryGCPtrU,
4421 pdmR3DevHlp_CFGMQueryGCPtrUDef,
4422 pdmR3DevHlp_CFGMQueryGCPtrS,
4423 pdmR3DevHlp_CFGMQueryGCPtrSDef,
4424 pdmR3DevHlp_CFGMQueryStringAlloc,
4425 pdmR3DevHlp_CFGMQueryStringAllocDef,
4426 pdmR3DevHlp_CFGMGetParent,
4427 pdmR3DevHlp_CFGMGetChild,
4428 pdmR3DevHlp_CFGMGetChildF,
4429 pdmR3DevHlp_CFGMGetChildFV,
4430 pdmR3DevHlp_CFGMGetFirstChild,
4431 pdmR3DevHlp_CFGMGetNextChild,
4432 pdmR3DevHlp_CFGMGetName,
4433 pdmR3DevHlp_CFGMGetNameLen,
4434 pdmR3DevHlp_CFGMAreChildrenValid,
4435 pdmR3DevHlp_CFGMGetFirstValue,
4436 pdmR3DevHlp_CFGMGetNextValue,
4437 pdmR3DevHlp_CFGMGetValueName,
4438 pdmR3DevHlp_CFGMGetValueNameLen,
4439 pdmR3DevHlp_CFGMGetValueType,
4440 pdmR3DevHlp_CFGMAreValuesValid,
4441 pdmR3DevHlp_CFGMValidateConfig,
4442 pdmR3DevHlp_PhysRead,
4443 pdmR3DevHlp_PhysWrite,
4444 pdmR3DevHlp_PhysGCPhys2CCPtr,
4445 pdmR3DevHlp_PhysGCPhys2CCPtrReadOnly,
4446 pdmR3DevHlp_PhysReleasePageMappingLock,
4447 pdmR3DevHlp_PhysReadGCVirt,
4448 pdmR3DevHlp_PhysWriteGCVirt,
4449 pdmR3DevHlp_PhysGCPtr2GCPhys,
4450 pdmR3DevHlp_MMHeapAlloc,
4451 pdmR3DevHlp_MMHeapAllocZ,
4452 pdmR3DevHlp_MMHeapFree,
4453 pdmR3DevHlp_VMState,
4454 pdmR3DevHlp_VMTeleportedAndNotFullyResumedYet,
4455 pdmR3DevHlp_VMSetError,
4456 pdmR3DevHlp_VMSetErrorV,
4457 pdmR3DevHlp_VMSetRuntimeError,
4458 pdmR3DevHlp_VMSetRuntimeErrorV,
4459 pdmR3DevHlp_DBGFStopV,
4460 pdmR3DevHlp_DBGFInfoRegister,
4461 pdmR3DevHlp_DBGFInfoRegisterArgv,
4462 pdmR3DevHlp_DBGFRegRegister,
4463 pdmR3DevHlp_DBGFTraceBuf,
4464 pdmR3DevHlp_STAMRegister,
4465 pdmR3DevHlp_STAMRegisterV,
4466 pdmR3DevHlp_PCIRegister,
4467 pdmR3DevHlp_PCIRegisterMsi,
4468 pdmR3DevHlp_PCIIORegionRegister,
4469 pdmR3DevHlp_PCIInterceptConfigAccesses,
4470 pdmR3DevHlp_PCIConfigWrite,
4471 pdmR3DevHlp_PCIConfigRead,
4472 pdmR3DevHlp_PCIPhysRead,
4473 pdmR3DevHlp_PCIPhysWrite,
4474 pdmR3DevHlp_PCISetIrq,
4475 pdmR3DevHlp_PCISetIrqNoWait,
4476 pdmR3DevHlp_ISASetIrq,
4477 pdmR3DevHlp_ISASetIrqNoWait,
4478 pdmR3DevHlp_IoApicSendMsi,
4479 pdmR3DevHlp_DriverAttach,
4480 pdmR3DevHlp_DriverDetach,
4481 pdmR3DevHlp_DriverReconfigure,
4482 pdmR3DevHlp_QueueCreatePtr,
4483 pdmR3DevHlp_QueueCreate,
4484 pdmR3DevHlp_QueueToPtr,
4485 pdmR3DevHlp_QueueAlloc,
4486 pdmR3DevHlp_QueueInsert,
4487 pdmR3DevHlp_QueueInsertEx,
4488 pdmR3DevHlp_QueueFlushIfNecessary,
4489 pdmR3DevHlp_TaskCreate,
4490 pdmR3DevHlp_TaskTrigger,
4491 pdmR3DevHlp_SUPSemEventCreate,
4492 pdmR3DevHlp_SUPSemEventClose,
4493 pdmR3DevHlp_SUPSemEventSignal,
4494 pdmR3DevHlp_SUPSemEventWaitNoResume,
4495 pdmR3DevHlp_SUPSemEventWaitNsAbsIntr,
4496 pdmR3DevHlp_SUPSemEventWaitNsRelIntr,
4497 pdmR3DevHlp_SUPSemEventGetResolution,
4498 pdmR3DevHlp_SUPSemEventMultiCreate,
4499 pdmR3DevHlp_SUPSemEventMultiClose,
4500 pdmR3DevHlp_SUPSemEventMultiSignal,
4501 pdmR3DevHlp_SUPSemEventMultiReset,
4502 pdmR3DevHlp_SUPSemEventMultiWaitNoResume,
4503 pdmR3DevHlp_SUPSemEventMultiWaitNsAbsIntr,
4504 pdmR3DevHlp_SUPSemEventMultiWaitNsRelIntr,
4505 pdmR3DevHlp_SUPSemEventMultiGetResolution,
4506 pdmR3DevHlp_CritSectInit,
4507 pdmR3DevHlp_CritSectGetNop,
4508 pdmR3DevHlp_CritSectGetNopR0,
4509 pdmR3DevHlp_CritSectGetNopRC,
4510 pdmR3DevHlp_SetDeviceCritSect,
4511 pdmR3DevHlp_CritSectYield,
4512 pdmR3DevHlp_CritSectEnter,
4513 pdmR3DevHlp_CritSectEnterDebug,
4514 pdmR3DevHlp_CritSectTryEnter,
4515 pdmR3DevHlp_CritSectTryEnterDebug,
4516 pdmR3DevHlp_CritSectLeave,
4517 pdmR3DevHlp_CritSectIsOwner,
4518 pdmR3DevHlp_CritSectIsInitialized,
4519 pdmR3DevHlp_CritSectHasWaiters,
4520 pdmR3DevHlp_CritSectGetRecursion,
4521 pdmR3DevHlp_CritSectScheduleExitEvent,
4522 pdmR3DevHlp_CritSectDelete,
4523 pdmR3DevHlp_ThreadCreate,
4524 pdmR3DevHlp_ThreadDestroy,
4525 pdmR3DevHlp_ThreadIAmSuspending,
4526 pdmR3DevHlp_ThreadIamRunning,
4527 pdmR3DevHlp_ThreadSleep,
4528 pdmR3DevHlp_ThreadSuspend,
4529 pdmR3DevHlp_ThreadResume,
4530 pdmR3DevHlp_SetAsyncNotification,
4531 pdmR3DevHlp_AsyncNotificationCompleted,
4532 pdmR3DevHlp_RTCRegister,
4533 pdmR3DevHlp_PCIBusRegister,
4534 pdmR3DevHlp_PICRegister,
4535 pdmR3DevHlp_ApicRegister,
4536 pdmR3DevHlp_IoApicRegister,
4537 pdmR3DevHlp_HpetRegister,
4538 pdmR3DevHlp_PciRawRegister,
4539 pdmR3DevHlp_DMACRegister,
4540 pdmR3DevHlp_DMARegister,
4541 pdmR3DevHlp_DMAReadMemory,
4542 pdmR3DevHlp_DMAWriteMemory,
4543 pdmR3DevHlp_DMASetDREQ,
4544 pdmR3DevHlp_DMAGetChannelMode,
4545 pdmR3DevHlp_DMASchedule,
4546 pdmR3DevHlp_CMOSWrite,
4547 pdmR3DevHlp_CMOSRead,
4548 pdmR3DevHlp_AssertEMT,
4549 pdmR3DevHlp_AssertOther,
4550 pdmR3DevHlp_LdrGetRCInterfaceSymbols,
4551 pdmR3DevHlp_LdrGetR0InterfaceSymbols,
4552 pdmR3DevHlp_CallR0,
4553 pdmR3DevHlp_VMGetSuspendReason,
4554 pdmR3DevHlp_VMGetResumeReason,
4555 pdmR3DevHlp_PhysBulkGCPhys2CCPtr,
4556 pdmR3DevHlp_PhysBulkGCPhys2CCPtrReadOnly,
4557 pdmR3DevHlp_PhysBulkReleasePageMappingLocks,
4558 NULL,
4559 NULL,
4560 NULL,
4561 NULL,
4562 NULL,
4563 NULL,
4564 NULL,
4565 NULL,
4566 NULL,
4567 NULL,
4568 pdmR3DevHlp_GetUVM,
4569 pdmR3DevHlp_GetVM,
4570 pdmR3DevHlp_GetVMCPU,
4571 pdmR3DevHlp_GetCurrentCpuId,
4572 pdmR3DevHlp_RegisterVMMDevHeap,
4573 pdmR3DevHlp_FirmwareRegister,
4574 pdmR3DevHlp_VMReset,
4575 pdmR3DevHlp_VMSuspend,
4576 pdmR3DevHlp_VMSuspendSaveAndPowerOff,
4577 pdmR3DevHlp_VMPowerOff,
4578 pdmR3DevHlp_A20IsEnabled,
4579 pdmR3DevHlp_A20Set,
4580 pdmR3DevHlp_GetCpuId,
4581 pdmR3DevHlp_TMTimeVirtGet,
4582 pdmR3DevHlp_TMTimeVirtGetFreq,
4583 pdmR3DevHlp_TMTimeVirtGetNano,
4584 pdmR3DevHlp_GetSupDrvSession,
4585 pdmR3DevHlp_QueryGenericUserObject,
4586 PDM_DEVHLPR3_VERSION /* the end */
4587};
4588
Note: See TracBrowser for help on using the repository browser.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette