VirtualBox

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

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

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