VirtualBox

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

Last change on this file since 69162 was 69162, checked in by vboxsync, 7 years ago

Devices/testcase: Skeleton for PDM device unit test framework, disabled by default (for backup purposes and to move more easily between hosts)
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 75.5 KB
Line 
1/* $Id: tstDevicePdmDevHlp.cpp 69162 2017-10-23 11:10:23Z vboxsync $ */
2/** @file
3 * tstDevice - Test framework for PDM devices/drivers, PDM helper implementation.
4 */
5
6/*
7 * Copyright (C) 2017 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/mem.h>
28
29#include "tstDeviceInternal.h"
30
31/*********************************************************************************************************************************
32* Defined Constants And Macros *
33*********************************************************************************************************************************/
34
35/** @def PDMDEV_ASSERT_DEVINS
36 * Asserts the validity of the device instance.
37 */
38#ifdef VBOX_STRICT
39# define PDMDEV_ASSERT_DEVINS(pDevIns) \
40 do { \
41 AssertPtr(pDevIns); \
42 Assert(pDevIns->u32Version == PDM_DEVINS_VERSION); \
43 Assert(pDevIns->CTX_SUFF(pvInstanceData) == (void *)&pDevIns->achInstanceData[0]); \
44 } while (0)
45#else
46# define PDMDEV_ASSERT_DEVINS(pDevIns) do { } while (0)
47#endif
48
49
50/*********************************************************************************************************************************
51* Structures and Typedefs *
52*********************************************************************************************************************************/
53
54
55
56/*********************************************************************************************************************************
57* Global Variables *
58*********************************************************************************************************************************/
59
60
61
62/*********************************************************************************************************************************
63* Internal Functions *
64*********************************************************************************************************************************/
65
66
67
68/** @interface_method_impl{PDMDEVHLPR3,pfnIOPortRegister} */
69static DECLCALLBACK(int) pdmR3DevHlp_IOPortRegister(PPDMDEVINS pDevIns, RTIOPORT Port, RTIOPORT cPorts, RTHCPTR pvUser, PFNIOMIOPORTOUT pfnOut, PFNIOMIOPORTIN pfnIn,
70 PFNIOMIOPORTOUTSTRING pfnOutStr, PFNIOMIOPORTINSTRING pfnInStr, const char *pszDesc)
71{
72 PDMDEV_ASSERT_DEVINS(pDevIns);
73 LogFlow(("pdmR3DevHlp_IOPortRegister: caller='%s'/%d: Port=%#x cPorts=%#x pvUser=%p pfnOut=%p pfnIn=%p pfnOutStr=%p pfnInStr=%p p32_tszDesc=%p:{%s}\n",
74 pDevIns->pReg->szName, pDevIns->iInstance, Port, cPorts, pvUser, pfnOut, pfnIn, pfnOutStr, pfnInStr, pszDesc, pszDesc));
75
76 /** @todo: Verify there is no overlapping. */
77
78 RT_NOREF(pszDesc);
79 int rc = VINF_SUCCESS;
80 PRTDEVDUTIOPORT pIoPort = (PRTDEVDUTIOPORT)RTMemAllocZ(sizeof(RTDEVDUTIOPORT));
81 if (RT_LIKELY(pIoPort))
82 {
83 pIoPort->PortStart = Port;
84 pIoPort->cPorts = cPorts;
85 pIoPort->pvUserR3 = pvUser;
86 pIoPort->pfnOutR3 = pfnOut;
87 pIoPort->pfnInR3 = pfnIn;
88 pIoPort->pfnOutStrR3 = pfnOutStr;
89 pIoPort->pfnInStrR3 = pfnInStr;
90 RTListAppend(&pDevIns->Internal.s.pDut->LstIoPorts, &pIoPort->NdIoPorts);
91 }
92 else
93 rc = VERR_NO_MEMORY;
94
95 LogFlow(("pdmR3DevHlp_IOPortRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
96 return rc;
97}
98
99
100/** @interface_method_impl{PDMDEVHLPR3,pfnIOPortRegisterRC} */
101static DECLCALLBACK(int) pdmR3DevHlp_IOPortRegisterRC(PPDMDEVINS pDevIns, RTIOPORT Port, RTIOPORT cPorts, RTRCPTR pvUser,
102 const char *pszOut, const char *pszIn,
103 const char *pszOutStr, const char *pszInStr, const char *pszDesc)
104{
105 PDMDEV_ASSERT_DEVINS(pDevIns);
106 LogFlow(("pdmR3DevHlp_IOPortRegisterRC: caller='%s'/%d: Port=%#x cPorts=%#x pvUser=%p pszOut=%p:{%s} pszIn=%p:{%s} pszOutStr=%p:{%s} pszInStr=%p:{%s} pszDesc=%p:{%s}\n",
107 pDevIns->pReg->szName, pDevIns->iInstance, Port, cPorts, pvUser, pszOut, pszOut, pszIn, pszIn, pszOutStr, pszOutStr, pszInStr, pszInStr, pszDesc, pszDesc));
108
109 /** @todo */
110 int rc = VINF_SUCCESS;
111 //AssertFailed();
112
113 LogFlow(("pdmR3DevHlp_IOPortRegisterRC: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
114 return rc;
115}
116
117
118/** @interface_method_impl{PDMDEVHLPR3,pfnIOPortRegisterR0} */
119static DECLCALLBACK(int) pdmR3DevHlp_IOPortRegisterR0(PPDMDEVINS pDevIns, RTIOPORT Port, RTIOPORT cPorts, RTR0PTR pvUser,
120 const char *pszOut, const char *pszIn,
121 const char *pszOutStr, const char *pszInStr, const char *pszDesc)
122{
123 PDMDEV_ASSERT_DEVINS(pDevIns);
124 LogFlow(("pdmR3DevHlp_IOPortRegisterR0: caller='%s'/%d: Port=%#x cPorts=%#x pvUser=%p pszOut=%p:{%s} pszIn=%p:{%s} pszOutStr=%p:{%s} pszInStr=%p:{%s} pszDesc=%p:{%s}\n",
125 pDevIns->pReg->szName, pDevIns->iInstance, Port, cPorts, pvUser, pszOut, pszOut, pszIn, pszIn, pszOutStr, pszOutStr, pszInStr, pszInStr, pszDesc, pszDesc));
126
127 PDEVDUTINT pThis = pDevIns->Internal.s.pDut;
128 PRTDEVDUTIOPORT pIoPort;
129 int rc = VERR_NOT_FOUND;
130 RTListForEach(&pThis->LstIoPorts, pIoPort, RTDEVDUTIOPORT, NdIoPorts)
131 {
132 /** @todo: Support overlapping port ranges. */
133 if ( pIoPort->PortStart == Port
134 && pIoPort->cPorts == cPorts)
135 {
136 rc = VINF_SUCCESS;
137 pIoPort->pvUserR0 = (void *)pvUser;
138 if (pszOut)
139 rc = tstDevPdmLdrGetSymbol(pThis, pDevIns->pReg->szR0Mod, TSTDEVPDMMODTYPE_R0, pszOut, (PFNRT *)&pIoPort->pfnOutR0);
140 if (RT_SUCCESS(rc) && pszIn)
141 rc = tstDevPdmLdrGetSymbol(pThis, pDevIns->pReg->szR0Mod, TSTDEVPDMMODTYPE_R0, pszIn, (PFNRT *)&pIoPort->pfnInR0);
142 if (RT_SUCCESS(rc) && pszOutStr)
143 rc = tstDevPdmLdrGetSymbol(pThis, pDevIns->pReg->szR0Mod, TSTDEVPDMMODTYPE_R0, pszOutStr, (PFNRT *)&pIoPort->pfnOutStrR0);
144 if (RT_SUCCESS(rc) && pszInStr)
145 rc = tstDevPdmLdrGetSymbol(pThis, pDevIns->pReg->szR0Mod, TSTDEVPDMMODTYPE_R0, pszInStr, (PFNRT *)&pIoPort->pfnInStrR0);
146 break;
147 }
148 }
149
150 LogFlow(("pdmR3DevHlp_IOPortRegisterR0: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
151 return rc;
152}
153
154
155/** @interface_method_impl{PDMDEVHLPR3,pfnIOPortDeregister} */
156static DECLCALLBACK(int) pdmR3DevHlp_IOPortDeregister(PPDMDEVINS pDevIns, RTIOPORT Port, RTIOPORT cPorts)
157{
158 PDMDEV_ASSERT_DEVINS(pDevIns);
159 LogFlow(("pdmR3DevHlp_IOPortDeregister: caller='%s'/%d: Port=%#x cPorts=%#x\n",
160 pDevIns->pReg->szName, pDevIns->iInstance, Port, cPorts));
161
162 int rc = VERR_NOT_IMPLEMENTED;
163 AssertFailed();
164
165 LogFlow(("pdmR3DevHlp_IOPortDeregister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
166 return rc;
167}
168
169
170/** @interface_method_impl{PDMDEVHLPR3,pfnMMIORegister} */
171static DECLCALLBACK(int) pdmR3DevHlp_MMIORegister(PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, RTGCPHYS cbRange, RTHCPTR pvUser,
172 PFNIOMMMIOWRITE pfnWrite, PFNIOMMMIOREAD pfnRead, PFNIOMMMIOFILL pfnFill,
173 uint32_t fFlags, const char *pszDesc)
174{
175 PDMDEV_ASSERT_DEVINS(pDevIns);
176 LogFlow(("pdmR3DevHlp_MMIORegister: caller='%s'/%d: GCPhysStart=%RGp cbRange=%RGp pvUser=%p pfnWrite=%p pfnRead=%p pfnFill=%p fFlags=%#x pszDesc=%p:{%s}\n",
177 pDevIns->pReg->szName, pDevIns->iInstance, GCPhysStart, cbRange, pvUser, pfnWrite, pfnRead, pfnFill, pszDesc, fFlags, pszDesc));
178
179 int rc = VERR_NOT_IMPLEMENTED;
180 AssertFailed();
181
182 LogFlow(("pdmR3DevHlp_MMIORegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
183 return rc;
184}
185
186
187/** @interface_method_impl{PDMDEVHLPR3,pfnMMIORegisterRC} */
188static DECLCALLBACK(int) pdmR3DevHlp_MMIORegisterRC(PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, RTGCPHYS cbRange, RTRCPTR pvUser,
189 const char *pszWrite, const char *pszRead, const char *pszFill)
190{
191 PDMDEV_ASSERT_DEVINS(pDevIns);
192 LogFlow(("pdmR3DevHlp_MMIORegisterRC: caller='%s'/%d: GCPhysStart=%RGp cbRange=%RGp pvUser=%p pszWrite=%p:{%s} pszRead=%p:{%s} pszFill=%p:{%s}\n",
193 pDevIns->pReg->szName, pDevIns->iInstance, GCPhysStart, cbRange, pvUser, pszWrite, pszWrite, pszRead, pszRead, pszFill, pszFill));
194
195 int rc = VERR_NOT_IMPLEMENTED;
196 AssertFailed();
197
198 LogFlow(("pdmR3DevHlp_MMIORegisterRC: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
199 return rc;
200}
201
202/** @interface_method_impl{PDMDEVHLPR3,pfnMMIORegisterR0} */
203static DECLCALLBACK(int) pdmR3DevHlp_MMIORegisterR0(PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, RTGCPHYS cbRange, RTR0PTR pvUser,
204 const char *pszWrite, const char *pszRead, const char *pszFill)
205{
206 PDMDEV_ASSERT_DEVINS(pDevIns);
207 LogFlow(("pdmR3DevHlp_MMIORegisterHC: caller='%s'/%d: GCPhysStart=%RGp cbRange=%RGp pvUser=%p pszWrite=%p:{%s} pszRead=%p:{%s} pszFill=%p:{%s}\n",
208 pDevIns->pReg->szName, pDevIns->iInstance, GCPhysStart, cbRange, pvUser, pszWrite, pszWrite, pszRead, pszRead, pszFill, pszFill));
209
210 int rc = VERR_NOT_IMPLEMENTED;
211 AssertFailed();
212
213 LogFlow(("pdmR3DevHlp_MMIORegisterR0: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
214 return rc;
215}
216
217
218/** @interface_method_impl{PDMDEVHLPR3,pfnMMIODeregister} */
219static DECLCALLBACK(int) pdmR3DevHlp_MMIODeregister(PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, RTGCPHYS cbRange)
220{
221 PDMDEV_ASSERT_DEVINS(pDevIns);
222 LogFlow(("pdmR3DevHlp_MMIODeregister: caller='%s'/%d: GCPhysStart=%RGp cbRange=%RGp\n",
223 pDevIns->pReg->szName, pDevIns->iInstance, GCPhysStart, cbRange));
224
225 int rc = VERR_NOT_IMPLEMENTED;
226 AssertFailed();
227
228 LogFlow(("pdmR3DevHlp_MMIODeregister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
229 return rc;
230}
231
232
233/**
234 * @copydoc PDMDEVHLPR3::pfnMMIO2Register
235 */
236static DECLCALLBACK(int) pdmR3DevHlp_MMIO2Register(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t iRegion, RTGCPHYS cb,
237 uint32_t fFlags, void **ppv, const char *pszDesc)
238{
239 PDMDEV_ASSERT_DEVINS(pDevIns);
240 LogFlow(("pdmR3DevHlp_MMIO2Register: caller='%s'/%d: pPciDev=%p (%#x) iRegion=%#x cb=%#RGp fFlags=%RX32 ppv=%p pszDescp=%p:{%s}\n",
241 pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pPciDev ? pPciDev->uDevFn : UINT32_MAX, iRegion,
242 cb, fFlags, ppv, pszDesc, pszDesc));
243 //AssertReturn(!pPciDev || pPciDev->Int.s.pDevInsR3 == pDevIns, VERR_INVALID_PARAMETER);
244
245 int rc = VERR_NOT_IMPLEMENTED;
246 AssertFailed();
247
248 LogFlow(("pdmR3DevHlp_MMIO2Register: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
249 return rc;
250}
251
252
253/**
254 * @interface_method_impl{PDMDEVHLPR3,pfnMMIOExPreRegister}
255 */
256static DECLCALLBACK(int)
257pdmR3DevHlp_MMIOExPreRegister(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t iRegion, RTGCPHYS cbRegion, uint32_t fFlags,
258 const char *pszDesc,
259 RTHCPTR pvUser, PFNIOMMMIOWRITE pfnWrite, PFNIOMMMIOREAD pfnRead, PFNIOMMMIOFILL pfnFill,
260 RTR0PTR pvUserR0, const char *pszWriteR0, const char *pszReadR0, const char *pszFillR0,
261 RTRCPTR pvUserRC, const char *pszWriteRC, const char *pszReadRC, const char *pszFillRC)
262{
263 PDMDEV_ASSERT_DEVINS(pDevIns);
264 LogFlow(("pdmR3DevHlp_MMIOExPreRegister: caller='%s'/%d: pPciDev=%p:{%#x} iRegion=%#x cbRegion=%#RGp fFlags=%RX32 pszDesc=%p:{%s}\n"
265 " pvUser=%p pfnWrite=%p pfnRead=%p pfnFill=%p\n"
266 " pvUserR0=%p pszWriteR0=%s pszReadR0=%s pszFillR0=%s\n"
267 " pvUserRC=%p pszWriteRC=%s pszReadRC=%s pszFillRC=%s\n",
268 pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pPciDev ? pPciDev->uDevFn : UINT32_MAX, iRegion, cbRegion,
269 fFlags, pszDesc, pszDesc,
270 pvUser, pfnWrite, pfnRead, pfnFill,
271 pvUserR0, pszWriteR0, pszReadR0, pszFillR0,
272 pvUserRC, pszWriteRC, pszReadRC, pszFillRC));
273 //AssertReturn(!pPciDev || pPciDev->Int.s.pDevInsR3 == pDevIns, VERR_INVALID_PARAMETER);
274
275 /*
276 * Resolve the functions.
277 */
278 AssertLogRelReturn( (!pszWriteR0 && !pszReadR0 && !pszFillR0)
279 || (pDevIns->pReg->szR0Mod[0] && (pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_R0)),
280 VERR_INVALID_PARAMETER);
281 AssertLogRelReturn( (!pszWriteRC && !pszReadRC && !pszFillRC)
282 || (pDevIns->pReg->szRCMod[0] && (pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_RC)),
283 VERR_INVALID_PARAMETER);
284
285 int rc = VERR_NOT_IMPLEMENTED;
286 AssertFailed();
287
288 LogFlow(("pdmR3DevHlp_MMIOExPreRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
289 return rc;
290}
291
292
293/**
294 * @copydoc PDMDEVHLPR3::pfnMMIOExDeregister
295 */
296static DECLCALLBACK(int) pdmR3DevHlp_MMIOExDeregister(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t iRegion)
297{
298 PDMDEV_ASSERT_DEVINS(pDevIns);
299 LogFlow(("pdmR3DevHlp_MMIOExDeregister: caller='%s'/%d: pPciDev=%p:{%#x} iRegion=%#x\n",
300 pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pPciDev ? pPciDev->uDevFn : UINT32_MAX, iRegion));
301
302 AssertReturn(iRegion <= UINT8_MAX || iRegion == UINT32_MAX, VERR_INVALID_PARAMETER);
303 //AssertReturn(!pPciDev || pPciDev->Int.s.pDevInsR3 == pDevIns, VERR_INVALID_PARAMETER);
304
305 int rc = VERR_NOT_IMPLEMENTED;
306 AssertFailed();
307
308 LogFlow(("pdmR3DevHlp_MMIOExDeregister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
309 return rc;
310}
311
312
313/**
314 * @copydoc PDMDEVHLPR3::pfnMMIOExMap
315 */
316static DECLCALLBACK(int) pdmR3DevHlp_MMIOExMap(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t iRegion, RTGCPHYS GCPhys)
317{
318 PDMDEV_ASSERT_DEVINS(pDevIns);
319 LogFlow(("pdmR3DevHlp_MMIOExMap: caller='%s'/%d: pPciDev=%p:{%#x} iRegion=%#x GCPhys=%#RGp\n",
320 pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pPciDev ? pPciDev->uDevFn : UINT32_MAX, iRegion, GCPhys));
321 //AssertReturn(!pPciDev || pPciDev->Int.s.pDevInsR3 != NULL, VERR_INVALID_PARAMETER);
322
323 int rc = VERR_NOT_IMPLEMENTED;
324 AssertFailed();
325
326 LogFlow(("pdmR3DevHlp_MMIOExMap: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
327 return rc;
328}
329
330
331/**
332 * @copydoc PDMDEVHLPR3::pfnMMIOExUnmap
333 */
334static DECLCALLBACK(int) pdmR3DevHlp_MMIOExUnmap(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t iRegion, RTGCPHYS GCPhys)
335{
336 PDMDEV_ASSERT_DEVINS(pDevIns);
337 LogFlow(("pdmR3DevHlp_MMIOExUnmap: caller='%s'/%d: pPciDev=%p:{%#x} iRegion=%#x GCPhys=%#RGp\n",
338 pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pPciDev ? pPciDev->uDevFn : UINT32_MAX, iRegion, GCPhys));
339 //AssertReturn(!pPciDev || pPciDev->Int.s.pDevInsR3 != NULL, VERR_INVALID_PARAMETER);
340
341 int rc = VERR_NOT_IMPLEMENTED;
342 AssertFailed();
343
344 LogFlow(("pdmR3DevHlp_MMIOExUnmap: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
345 return rc;
346}
347
348
349/**
350 * @copydoc PDMDEVHLPR3::pfnMMIOExReduce
351 */
352static DECLCALLBACK(int) pdmR3DevHlp_MMIOExReduce(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t iRegion, RTGCPHYS cbRegion)
353{
354 PDMDEV_ASSERT_DEVINS(pDevIns);
355 LogFlow(("pdmR3DevHlp_MMIOExReduce: caller='%s'/%d: pPciDev=%p:{%#x} iRegion=%#x cbRegion=%RGp\n",
356 pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pPciDev ? pPciDev->uDevFn : UINT32_MAX, iRegion, cbRegion));
357 //AssertReturn(!pPciDev || pPciDev->Int.s.pDevInsR3 != NULL, VERR_INVALID_PARAMETER);
358
359 int rc = VERR_NOT_IMPLEMENTED;
360 AssertFailed();
361
362 LogFlow(("pdmR3DevHlp_MMIOExReduce: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
363 return rc;
364}
365
366
367/**
368 * @copydoc PDMDEVHLPR3::pfnMMHyperMapMMIO2
369 */
370static DECLCALLBACK(int) pdmR3DevHlp_MMHyperMapMMIO2(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t iRegion, RTGCPHYS off,
371 RTGCPHYS cb, const char *pszDesc, PRTRCPTR pRCPtr)
372{
373 PDMDEV_ASSERT_DEVINS(pDevIns);
374 LogFlow(("pdmR3DevHlp_MMHyperMapMMIO2: caller='%s'/%d: pPciDev=%p:{%#x} iRegion=%#x off=%RGp cb=%RGp pszDesc=%p:{%s} pRCPtr=%p\n",
375 pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pPciDev ? pPciDev->uDevFn : UINT32_MAX, iRegion, off, cb, pszDesc, pszDesc, pRCPtr));
376 //AssertReturn(!pPciDev || pPciDev->Int.s.pDevInsR3 == pDevIns, VERR_INVALID_PARAMETER);
377
378 int rc = VERR_NOT_IMPLEMENTED;
379 AssertFailed();
380
381 LogFlow(("pdmR3DevHlp_MMHyperMapMMIO2: caller='%s'/%d: returns %Rrc *pRCPtr=%RRv\n", pDevIns->pReg->szName, pDevIns->iInstance, rc, *pRCPtr));
382 return rc;
383}
384
385
386/**
387 * @copydoc PDMDEVHLPR3::pfnMMIO2MapKernel
388 */
389static DECLCALLBACK(int) pdmR3DevHlp_MMIO2MapKernel(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t iRegion, RTGCPHYS off,
390 RTGCPHYS cb,const char *pszDesc, PRTR0PTR pR0Ptr)
391{
392 PDMDEV_ASSERT_DEVINS(pDevIns);
393 LogFlow(("pdmR3DevHlp_MMIO2MapKernel: caller='%s'/%d: pPciDev=%p:{%#x} iRegion=%#x off=%RGp cb=%RGp pszDesc=%p:{%s} pR0Ptr=%p\n",
394 pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pPciDev ? pPciDev->uDevFn : UINT32_MAX, iRegion, off, cb, pszDesc, pszDesc, pR0Ptr));
395 //AssertReturn(!pPciDev || pPciDev->Int.s.pDevInsR3 == pDevIns, VERR_INVALID_PARAMETER);
396
397 int rc = VERR_NOT_IMPLEMENTED;
398 AssertFailed();
399
400 LogFlow(("pdmR3DevHlp_MMIO2MapKernel: caller='%s'/%d: returns %Rrc *pR0Ptr=%RHv\n", pDevIns->pReg->szName, pDevIns->iInstance, rc, *pR0Ptr));
401 return rc;
402}
403
404
405/** @interface_method_impl{PDMDEVHLPR3,pfnROMRegister} */
406static DECLCALLBACK(int) pdmR3DevHlp_ROMRegister(PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, uint32_t cbRange,
407 const void *pvBinary, uint32_t cbBinary, uint32_t fFlags, const char *pszDesc)
408{
409 PDMDEV_ASSERT_DEVINS(pDevIns);
410 LogFlow(("pdmR3DevHlp_ROMRegister: caller='%s'/%d: GCPhysStart=%RGp cbRange=%#x pvBinary=%p cbBinary=%#x fFlags=%#RX32 pszDesc=%p:{%s}\n",
411 pDevIns->pReg->szName, pDevIns->iInstance, GCPhysStart, cbRange, pvBinary, cbBinary, fFlags, pszDesc, pszDesc));
412
413 int rc = VERR_NOT_IMPLEMENTED;
414 AssertFailed();
415
416 LogFlow(("pdmR3DevHlp_ROMRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
417 return rc;
418}
419
420
421/** @interface_method_impl{PDMDEVHLPR3,pfnROMProtectShadow} */
422static DECLCALLBACK(int) pdmR3DevHlp_ROMProtectShadow(PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, uint32_t cbRange, PGMROMPROT enmProt)
423{
424 PDMDEV_ASSERT_DEVINS(pDevIns);
425 LogFlow(("pdmR3DevHlp_ROMProtectShadow: caller='%s'/%d: GCPhysStart=%RGp cbRange=%#x enmProt=%d\n",
426 pDevIns->pReg->szName, pDevIns->iInstance, GCPhysStart, cbRange, enmProt));
427
428 int rc = VERR_NOT_IMPLEMENTED;
429 AssertFailed();
430
431 LogFlow(("pdmR3DevHlp_ROMProtectShadow: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
432 return rc;
433}
434
435
436/** @interface_method_impl{PDMDEVHLPR3,pfnSSMRegister} */
437static DECLCALLBACK(int) pdmR3DevHlp_SSMRegister(PPDMDEVINS pDevIns, uint32_t uVersion, size_t cbGuess, const char *pszBefore,
438 PFNSSMDEVLIVEPREP pfnLivePrep, PFNSSMDEVLIVEEXEC pfnLiveExec, PFNSSMDEVLIVEVOTE pfnLiveVote,
439 PFNSSMDEVSAVEPREP pfnSavePrep, PFNSSMDEVSAVEEXEC pfnSaveExec, PFNSSMDEVSAVEDONE pfnSaveDone,
440 PFNSSMDEVLOADPREP pfnLoadPrep, PFNSSMDEVLOADEXEC pfnLoadExec, PFNSSMDEVLOADDONE pfnLoadDone)
441{
442 PDMDEV_ASSERT_DEVINS(pDevIns);
443 LogFlow(("pdmR3DevHlp_SSMRegister: caller='%s'/%d: uVersion=%#x cbGuess=%#x pszBefore=%p:{%s}\n"
444 " pfnLivePrep=%p pfnLiveExec=%p pfnLiveVote=%p pfnSavePrep=%p pfnSaveExec=%p pfnSaveDone=%p pszLoadPrep=%p pfnLoadExec=%p pfnLoadDone=%p\n",
445 pDevIns->pReg->szName, pDevIns->iInstance, uVersion, cbGuess, pszBefore, pszBefore,
446 pfnLivePrep, pfnLiveExec, pfnLiveVote,
447 pfnSavePrep, pfnSaveExec, pfnSaveDone,
448 pfnLoadPrep, pfnLoadExec, pfnLoadDone));
449
450 /** @todo */
451 int rc = VINF_SUCCESS;
452 //AssertFailed();
453
454 LogFlow(("pdmR3DevHlp_SSMRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
455 return rc;
456}
457
458
459/** @interface_method_impl{PDMDEVHLPR3,pfnTMTimerCreate} */
460static DECLCALLBACK(int) pdmR3DevHlp_TMTimerCreate(PPDMDEVINS pDevIns, TMCLOCK enmClock, PFNTMTIMERDEV pfnCallback, void *pvUser,
461 uint32_t fFlags, const char *pszDesc, PPTMTIMERR3 ppTimer)
462{
463 PDMDEV_ASSERT_DEVINS(pDevIns);
464 LogFlow(("pdmR3DevHlp_TMTimerCreate: caller='%s'/%d: enmClock=%d pfnCallback=%p pvUser=%p fFlags=%#x pszDesc=%p:{%s} ppTimer=%p\n",
465 pDevIns->pReg->szName, pDevIns->iInstance, enmClock, pfnCallback, pvUser, fFlags, pszDesc, pszDesc, ppTimer));
466
467 int rc = VINF_SUCCESS;
468 PTMTIMERR3 pTimer = (PTMTIMERR3)RTMemAllocZ(sizeof(TMTIMER));
469 if (RT_LIKELY(pTimer))
470 {
471 pTimer->pVmmCallbacks = pDevIns->Internal.s.pVmmCallbacks;
472 pTimer->enmClock = enmClock;
473 pTimer->pfnCallbackDev = pfnCallback;
474 pTimer->pvUser = pvUser;
475 pTimer->fFlags = fFlags;
476 RTListAppend(&pDevIns->Internal.s.pDut->LstTimers, &pTimer->NdDevTimers);
477 *ppTimer = pTimer;
478 }
479 else
480 rc = VERR_NO_MEMORY;
481
482 LogFlow(("pdmR3DevHlp_TMTimerCreate: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
483 return rc;
484}
485
486
487/** @interface_method_impl{PDMDEVHLPR3,pfnTMUtcNow} */
488static DECLCALLBACK(PRTTIMESPEC) pdmR3DevHlp_TMUtcNow(PPDMDEVINS pDevIns, PRTTIMESPEC pTime)
489{
490 PDMDEV_ASSERT_DEVINS(pDevIns);
491 LogFlow(("pdmR3DevHlp_TMUtcNow: caller='%s'/%d: pTime=%p\n",
492 pDevIns->pReg->szName, pDevIns->iInstance, pTime));
493
494 AssertFailed();
495
496 LogFlow(("pdmR3DevHlp_TMUtcNow: caller='%s'/%d: returns %RU64\n", pDevIns->pReg->szName, pDevIns->iInstance, RTTimeSpecGetNano(pTime)));
497 return pTime;
498}
499
500
501/** @interface_method_impl{PDMDEVHLPR3,pfnTMTimeVirtGet} */
502static DECLCALLBACK(uint64_t) pdmR3DevHlp_TMTimeVirtGet(PPDMDEVINS pDevIns)
503{
504 PDMDEV_ASSERT_DEVINS(pDevIns);
505 LogFlow(("pdmR3DevHlp_TMTimeVirtGet: caller='%s'/%d\n",
506 pDevIns->pReg->szName, pDevIns->iInstance));
507
508 uint64_t u64Time = 0;
509 AssertFailed();
510
511 LogFlow(("pdmR3DevHlp_TMTimeVirtGet: caller='%s'/%d: returns %RU64\n", pDevIns->pReg->szName, pDevIns->iInstance, u64Time));
512 return u64Time;
513}
514
515
516/** @interface_method_impl{PDMDEVHLPR3,pfnTMTimeVirtGetFreq} */
517static DECLCALLBACK(uint64_t) pdmR3DevHlp_TMTimeVirtGetFreq(PPDMDEVINS pDevIns)
518{
519 PDMDEV_ASSERT_DEVINS(pDevIns);
520 LogFlow(("pdmR3DevHlp_TMTimeVirtGetFreq: caller='%s'/%d\n",
521 pDevIns->pReg->szName, pDevIns->iInstance));
522
523 uint64_t u64Freq = 0;
524 AssertFailed();
525
526 LogFlow(("pdmR3DevHlp_TMTimeVirtGetFreq: caller='%s'/%d: returns %RU64\n", pDevIns->pReg->szName, pDevIns->iInstance, u64Freq));
527 return u64Freq;
528}
529
530
531/** @interface_method_impl{PDMDEVHLPR3,pfnTMTimeVirtGetNano} */
532static DECLCALLBACK(uint64_t) pdmR3DevHlp_TMTimeVirtGetNano(PPDMDEVINS pDevIns)
533{
534 PDMDEV_ASSERT_DEVINS(pDevIns);
535 LogFlow(("pdmR3DevHlp_TMTimeVirtGetNano: caller='%s'/%d\n",
536 pDevIns->pReg->szName, pDevIns->iInstance));
537
538 uint64_t u64Nano = 0;
539 AssertFailed();
540
541 LogFlow(("pdmR3DevHlp_TMTimeVirtGetNano: caller='%s'/%d: returns %RU64\n", pDevIns->pReg->szName, pDevIns->iInstance, u64Nano));
542 return u64Nano;
543}
544
545
546/** @interface_method_impl{PDMDEVHLPR3,pfnGetSupDrvSession} */
547static DECLCALLBACK(PSUPDRVSESSION) pdmR3DevHlp_GetSupDrvSession(PPDMDEVINS pDevIns)
548{
549 PDMDEV_ASSERT_DEVINS(pDevIns);
550 LogFlow(("pdmR3DevHlp_GetSupDrvSession: caller='%s'/%d\n",
551 pDevIns->pReg->szName, pDevIns->iInstance));
552
553 PSUPDRVSESSION pSession = 0;
554 AssertFailed();
555
556 LogFlow(("pdmR3DevHlp_GetSupDrvSession: caller='%s'/%d: returns %#p\n", pDevIns->pReg->szName, pDevIns->iInstance, pSession));
557 return pSession;
558}
559
560
561/** @interface_method_impl{PDMDEVHLPR3,pfnQueryGenericUserObject} */
562static DECLCALLBACK(void *) pdmR3DevHlp_QueryGenericUserObject(PPDMDEVINS pDevIns, PCRTUUID pUuid)
563{
564 PDMDEV_ASSERT_DEVINS(pDevIns);
565 LogFlow(("pdmR3DevHlp_QueryGenericUserObject: caller='%s'/%d: pUuid=%p:%RTuuid\n",
566 pDevIns->pReg->szName, pDevIns->iInstance, pUuid, pUuid));
567
568 void *pvRet = NULL;
569
570 LogRel(("pdmR3DevHlp_QueryGenericUserObject: caller='%s'/%d: returns %#p for %RTuuid\n",
571 pDevIns->pReg->szName, pDevIns->iInstance, pvRet, pUuid));
572 return pvRet;
573}
574
575
576/** @interface_method_impl{PDMDEVHLPR3,pfnPhysRead} */
577static DECLCALLBACK(int) pdmR3DevHlp_PhysRead(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, void *pvBuf, size_t cbRead)
578{
579 PDMDEV_ASSERT_DEVINS(pDevIns);
580 LogFlow(("pdmR3DevHlp_PhysRead: caller='%s'/%d: GCPhys=%RGp pvBuf=%p cbRead=%#x\n",
581 pDevIns->pReg->szName, pDevIns->iInstance, GCPhys, pvBuf, cbRead));
582
583 int rc = VERR_NOT_IMPLEMENTED;
584 AssertFailed();
585
586 Log(("pdmR3DevHlp_PhysRead: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
587 return rc;
588}
589
590
591/** @interface_method_impl{PDMDEVHLPR3,pfnPhysWrite} */
592static DECLCALLBACK(int) pdmR3DevHlp_PhysWrite(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, const void *pvBuf, size_t cbWrite)
593{
594 PDMDEV_ASSERT_DEVINS(pDevIns);
595 LogFlow(("pdmR3DevHlp_PhysWrite: caller='%s'/%d: GCPhys=%RGp pvBuf=%p cbWrite=%#x\n",
596 pDevIns->pReg->szName, pDevIns->iInstance, GCPhys, pvBuf, cbWrite));
597
598 int rc = VERR_NOT_IMPLEMENTED;
599 AssertFailed();
600
601 Log(("pdmR3DevHlp_PhysWrite: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
602 return rc;
603}
604
605
606/** @interface_method_impl{PDMDEVHLPR3,pfnPhysGCPhys2CCPtr} */
607static DECLCALLBACK(int) pdmR3DevHlp_PhysGCPhys2CCPtr(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, uint32_t fFlags, void **ppv, PPGMPAGEMAPLOCK pLock)
608{
609 PDMDEV_ASSERT_DEVINS(pDevIns);
610 LogFlow(("pdmR3DevHlp_PhysGCPhys2CCPtr: caller='%s'/%d: GCPhys=%RGp fFlags=%#x ppv=%p pLock=%p\n",
611 pDevIns->pReg->szName, pDevIns->iInstance, GCPhys, fFlags, ppv, pLock));
612 AssertReturn(!fFlags, VERR_INVALID_PARAMETER);
613
614 int rc = VERR_NOT_IMPLEMENTED;
615 AssertFailed();
616
617 Log(("pdmR3DevHlp_PhysGCPhys2CCPtr: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
618 return rc;
619}
620
621
622/** @interface_method_impl{PDMDEVHLPR3,pfnPhysGCPhys2CCPtrReadOnly} */
623static DECLCALLBACK(int) pdmR3DevHlp_PhysGCPhys2CCPtrReadOnly(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, uint32_t fFlags, const void **ppv, PPGMPAGEMAPLOCK pLock)
624{
625 PDMDEV_ASSERT_DEVINS(pDevIns);
626 LogFlow(("pdmR3DevHlp_PhysGCPhys2CCPtrReadOnly: caller='%s'/%d: GCPhys=%RGp fFlags=%#x ppv=%p pLock=%p\n",
627 pDevIns->pReg->szName, pDevIns->iInstance, GCPhys, fFlags, ppv, pLock));
628 AssertReturn(!fFlags, VERR_INVALID_PARAMETER);
629
630 int rc = VERR_NOT_IMPLEMENTED;
631 AssertFailed();
632
633 Log(("pdmR3DevHlp_PhysGCPhys2CCPtrReadOnly: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
634 return rc;
635}
636
637
638/** @interface_method_impl{PDMDEVHLPR3,pfnPhysReleasePageMappingLock} */
639static DECLCALLBACK(void) pdmR3DevHlp_PhysReleasePageMappingLock(PPDMDEVINS pDevIns, PPGMPAGEMAPLOCK pLock)
640{
641 PDMDEV_ASSERT_DEVINS(pDevIns);
642 LogFlow(("pdmR3DevHlp_PhysReleasePageMappingLock: caller='%s'/%d: pLock=%p\n",
643 pDevIns->pReg->szName, pDevIns->iInstance, pLock));
644
645 AssertFailed();
646
647 Log(("pdmR3DevHlp_PhysReleasePageMappingLock: caller='%s'/%d: returns void\n", pDevIns->pReg->szName, pDevIns->iInstance));
648}
649
650
651/** @interface_method_impl{PDMDEVHLPR3,pfnPhysReadGCVirt} */
652static DECLCALLBACK(int) pdmR3DevHlp_PhysReadGCVirt(PPDMDEVINS pDevIns, void *pvDst, RTGCPTR GCVirtSrc, size_t cb)
653{
654 PDMDEV_ASSERT_DEVINS(pDevIns);
655 LogFlow(("pdmR3DevHlp_PhysReadGCVirt: caller='%s'/%d: pvDst=%p GCVirt=%RGv cb=%#x\n",
656 pDevIns->pReg->szName, pDevIns->iInstance, pvDst, GCVirtSrc, cb));
657
658 int rc = VERR_NOT_IMPLEMENTED;
659 AssertFailed();
660
661 LogFlow(("pdmR3DevHlp_PhysReadGCVirt: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
662
663 return rc;
664}
665
666
667/** @interface_method_impl{PDMDEVHLPR3,pfnPhysWriteGCVirt} */
668static DECLCALLBACK(int) pdmR3DevHlp_PhysWriteGCVirt(PPDMDEVINS pDevIns, RTGCPTR GCVirtDst, const void *pvSrc, size_t cb)
669{
670 PDMDEV_ASSERT_DEVINS(pDevIns);
671 LogFlow(("pdmR3DevHlp_PhysWriteGCVirt: caller='%s'/%d: GCVirtDst=%RGv pvSrc=%p cb=%#x\n",
672 pDevIns->pReg->szName, pDevIns->iInstance, GCVirtDst, pvSrc, cb));
673
674 int rc = VERR_NOT_IMPLEMENTED;
675 AssertFailed();
676
677 LogFlow(("pdmR3DevHlp_PhysWriteGCVirt: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
678
679 return rc;
680}
681
682
683/** @interface_method_impl{PDMDEVHLPR3,pfnPhysGCPtr2GCPhys} */
684static DECLCALLBACK(int) pdmR3DevHlp_PhysGCPtr2GCPhys(PPDMDEVINS pDevIns, RTGCPTR GCPtr, PRTGCPHYS pGCPhys)
685{
686 PDMDEV_ASSERT_DEVINS(pDevIns);
687 LogFlow(("pdmR3DevHlp_PhysGCPtr2GCPhys: caller='%s'/%d: GCPtr=%RGv pGCPhys=%p\n",
688 pDevIns->pReg->szName, pDevIns->iInstance, GCPtr, pGCPhys));
689
690 int rc = VERR_NOT_IMPLEMENTED;
691 AssertFailed();
692
693 LogFlow(("pdmR3DevHlp_PhysGCPtr2GCPhys: caller='%s'/%d: returns %Rrc *pGCPhys=%RGp\n", pDevIns->pReg->szName, pDevIns->iInstance, rc, *pGCPhys));
694
695 return rc;
696}
697
698
699/** @interface_method_impl{PDMDEVHLPR3,pfnMMHeapAlloc} */
700static DECLCALLBACK(void *) pdmR3DevHlp_MMHeapAlloc(PPDMDEVINS pDevIns, size_t cb)
701{
702 PDMDEV_ASSERT_DEVINS(pDevIns);
703 LogFlow(("pdmR3DevHlp_MMHeapAlloc: caller='%s'/%d: cb=%#x\n", pDevIns->pReg->szName, pDevIns->iInstance, cb));
704
705 void *pv = NULL;
706 AssertFailed();
707
708 LogFlow(("pdmR3DevHlp_MMHeapAlloc: caller='%s'/%d: returns %p\n", pDevIns->pReg->szName, pDevIns->iInstance, pv));
709 return pv;
710}
711
712
713/** @interface_method_impl{PDMDEVHLPR3,pfnMMHeapAllocZ} */
714static DECLCALLBACK(void *) pdmR3DevHlp_MMHeapAllocZ(PPDMDEVINS pDevIns, size_t cb)
715{
716 PDMDEV_ASSERT_DEVINS(pDevIns);
717 LogFlow(("pdmR3DevHlp_MMHeapAllocZ: caller='%s'/%d: cb=%#x\n", pDevIns->pReg->szName, pDevIns->iInstance, cb));
718
719 void *pv = NULL;
720 AssertFailed();
721
722 LogFlow(("pdmR3DevHlp_MMHeapAllocZ: caller='%s'/%d: returns %p\n", pDevIns->pReg->szName, pDevIns->iInstance, pv));
723 return pv;
724}
725
726
727/** @interface_method_impl{PDMDEVHLPR3,pfnMMHeapFree} */
728static DECLCALLBACK(void) pdmR3DevHlp_MMHeapFree(PPDMDEVINS pDevIns, void *pv)
729{
730 PDMDEV_ASSERT_DEVINS(pDevIns); RT_NOREF_PV(pDevIns);
731 LogFlow(("pdmR3DevHlp_MMHeapFree: caller='%s'/%d: pv=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, pv));
732
733 AssertFailed();
734
735 LogFlow(("pdmR3DevHlp_MMHeapAlloc: caller='%s'/%d: returns void\n", pDevIns->pReg->szName, pDevIns->iInstance));
736}
737
738
739/** @interface_method_impl{PDMDEVHLPR3,pfnVMState} */
740static DECLCALLBACK(VMSTATE) pdmR3DevHlp_VMState(PPDMDEVINS pDevIns)
741{
742 PDMDEV_ASSERT_DEVINS(pDevIns);
743
744 VMSTATE enmVMState = VMSTATE_CREATING;
745 AssertFailed();
746
747 LogFlow(("pdmR3DevHlp_VMState: caller='%s'/%d: returns %d\n", pDevIns->pReg->szName, pDevIns->iInstance,
748 enmVMState));
749 return enmVMState;
750}
751
752
753/** @interface_method_impl{PDMDEVHLPR3,pfnVMTeleportedAndNotFullyResumedYet} */
754static DECLCALLBACK(bool) pdmR3DevHlp_VMTeleportedAndNotFullyResumedYet(PPDMDEVINS pDevIns)
755{
756 PDMDEV_ASSERT_DEVINS(pDevIns);
757
758 bool fRc = false;
759 AssertFailed();
760
761 LogFlow(("pdmR3DevHlp_VMState: caller='%s'/%d: returns %RTbool\n", pDevIns->pReg->szName, pDevIns->iInstance,
762 fRc));
763 return fRc;
764}
765
766
767/** @interface_method_impl{PDMDEVHLPR3,pfnVMSetError} */
768static DECLCALLBACK(int) pdmR3DevHlp_VMSetError(PPDMDEVINS pDevIns, int rc, RT_SRC_POS_DECL, const char *pszFormat, ...)
769{
770 PDMDEV_ASSERT_DEVINS(pDevIns);
771 RT_NOREF(rc, pszFile, iLine, pszFunction, pszFormat);
772 rc = VERR_NOT_IMPLEMENTED;
773 AssertFailed();
774 return rc;
775}
776
777
778/** @interface_method_impl{PDMDEVHLPR3,pfnVMSetErrorV} */
779static DECLCALLBACK(int) pdmR3DevHlp_VMSetErrorV(PPDMDEVINS pDevIns, int rc, RT_SRC_POS_DECL, const char *pszFormat, va_list va)
780{
781 PDMDEV_ASSERT_DEVINS(pDevIns);
782 RT_NOREF(rc, pszFile, iLine, pszFunction, pszFormat, va);
783 rc = VERR_NOT_IMPLEMENTED;
784 AssertFailed();
785 return rc;
786}
787
788
789/** @interface_method_impl{PDMDEVHLPR3,pfnVMSetRuntimeError} */
790static DECLCALLBACK(int) pdmR3DevHlp_VMSetRuntimeError(PPDMDEVINS pDevIns, uint32_t fFlags, const char *pszErrorId, const char *pszFormat, ...)
791{
792 PDMDEV_ASSERT_DEVINS(pDevIns);
793 RT_NOREF(fFlags, pszErrorId, pszFormat);
794 int rc = VERR_NOT_IMPLEMENTED;
795 AssertFailed();
796 return rc;
797}
798
799
800/** @interface_method_impl{PDMDEVHLPR3,pfnVMSetRuntimeErrorV} */
801static DECLCALLBACK(int) pdmR3DevHlp_VMSetRuntimeErrorV(PPDMDEVINS pDevIns, uint32_t fFlags, const char *pszErrorId, const char *pszFormat, va_list va)
802{
803 PDMDEV_ASSERT_DEVINS(pDevIns);
804 RT_NOREF(fFlags, pszErrorId, pszFormat, va);
805 int rc = VERR_NOT_IMPLEMENTED;
806 AssertFailed();
807 return rc;
808}
809
810
811/** @interface_method_impl{PDMDEVHLPR3,pfnDBGFStopV} */
812static DECLCALLBACK(int) pdmR3DevHlp_DBGFStopV(PPDMDEVINS pDevIns, const char *pszFile, unsigned iLine, const char *pszFunction, const char *pszFormat, va_list args)
813{
814 PDMDEV_ASSERT_DEVINS(pDevIns);
815#ifdef LOG_ENABLED
816 va_list va2;
817 va_copy(va2, args);
818 LogFlow(("pdmR3DevHlp_DBGFStopV: caller='%s'/%d: pszFile=%p:{%s} iLine=%d pszFunction=%p:{%s} pszFormat=%p:{%s} (%N)\n",
819 pDevIns->pReg->szName, pDevIns->iInstance, pszFile, pszFile, iLine, pszFunction, pszFunction, pszFormat, pszFormat, pszFormat, &va2));
820 va_end(va2);
821#endif
822
823 int rc = VERR_NOT_IMPLEMENTED;
824 AssertFailed();
825
826 LogFlow(("pdmR3DevHlp_DBGFStopV: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
827 return rc;
828}
829
830
831/** @interface_method_impl{PDMDEVHLPR3,pfnDBGFInfoRegister} */
832static DECLCALLBACK(int) pdmR3DevHlp_DBGFInfoRegister(PPDMDEVINS pDevIns, const char *pszName, const char *pszDesc, PFNDBGFHANDLERDEV pfnHandler)
833{
834 PDMDEV_ASSERT_DEVINS(pDevIns);
835 LogFlow(("pdmR3DevHlp_DBGFInfoRegister: caller='%s'/%d: pszName=%p:{%s} pszDesc=%p:{%s} pfnHandler=%p\n",
836 pDevIns->pReg->szName, pDevIns->iInstance, pszName, pszName, pszDesc, pszDesc, pfnHandler));
837
838 int rc = VERR_NOT_IMPLEMENTED;
839 AssertFailed();
840
841 LogFlow(("pdmR3DevHlp_DBGFInfoRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
842 return rc;
843}
844
845
846/** @interface_method_impl{PDMDEVHLPR3,pfnDBGFRegRegister} */
847static DECLCALLBACK(int) pdmR3DevHlp_DBGFRegRegister(PPDMDEVINS pDevIns, PCDBGFREGDESC paRegisters)
848{
849 PDMDEV_ASSERT_DEVINS(pDevIns);
850 LogFlow(("pdmR3DevHlp_DBGFRegRegister: caller='%s'/%d: paRegisters=%p\n",
851 pDevIns->pReg->szName, pDevIns->iInstance, paRegisters));
852
853 int rc = VERR_NOT_IMPLEMENTED;
854 AssertFailed();
855
856 LogFlow(("pdmR3DevHlp_DBGFRegRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
857 return rc;
858}
859
860
861/** @interface_method_impl{PDMDEVHLPR3,pfnDBGFTraceBuf} */
862static DECLCALLBACK(RTTRACEBUF) pdmR3DevHlp_DBGFTraceBuf(PPDMDEVINS pDevIns)
863{
864 PDMDEV_ASSERT_DEVINS(pDevIns);
865 RTTRACEBUF hTraceBuf = NULL;
866 AssertFailed();
867 LogFlow(("pdmR3DevHlp_DBGFTraceBuf: caller='%s'/%d: returns %p\n", pDevIns->pReg->szName, pDevIns->iInstance, hTraceBuf));
868 return hTraceBuf;
869}
870
871
872/** @interface_method_impl{PDMDEVHLPR3,pfnSTAMRegister} */
873static DECLCALLBACK(void) pdmR3DevHlp_STAMRegister(PPDMDEVINS pDevIns, void *pvSample, STAMTYPE enmType, const char *pszName,
874 STAMUNIT enmUnit, const char *pszDesc)
875{
876 PDMDEV_ASSERT_DEVINS(pDevIns);
877 RT_NOREF(pvSample, enmType, pszName, enmUnit, pszDesc);
878 AssertFailed();
879}
880
881
882
883/** @interface_method_impl{PDMDEVHLPR3,pfnSTAMRegisterF} */
884static DECLCALLBACK(void) pdmR3DevHlp_STAMRegisterF(PPDMDEVINS pDevIns, void *pvSample, STAMTYPE enmType, STAMVISIBILITY enmVisibility,
885 STAMUNIT enmUnit, const char *pszDesc, const char *pszName, ...)
886{
887 PDMDEV_ASSERT_DEVINS(pDevIns);
888 RT_NOREF(pvSample, enmType, enmVisibility, enmUnit, pszDesc, pszName);
889 AssertFailed();
890}
891
892
893/** @interface_method_impl{PDMDEVHLPR3,pfnSTAMRegisterV} */
894static DECLCALLBACK(void) pdmR3DevHlp_STAMRegisterV(PPDMDEVINS pDevIns, void *pvSample, STAMTYPE enmType, STAMVISIBILITY enmVisibility,
895 STAMUNIT enmUnit, const char *pszDesc, const char *pszName, va_list args)
896{
897 PDMDEV_ASSERT_DEVINS(pDevIns);
898 RT_NOREF(pvSample, enmType, enmVisibility, enmUnit, pszDesc, pszName, args);
899 AssertFailed();
900}
901
902
903/**
904 * @interface_method_impl{PDMDEVHLPR3,pfnPCIRegister}
905 */
906static DECLCALLBACK(int) pdmR3DevHlp_PCIRegister(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t idxDevCfg, uint32_t fFlags,
907 uint8_t uPciDevNo, uint8_t uPciFunNo, const char *pszName)
908{
909 PDMDEV_ASSERT_DEVINS(pDevIns);
910 LogFlow(("pdmR3DevHlp_PCIRegister: caller='%s'/%d: pPciDev=%p:{.config={%#.256Rhxs} idxDevCfg=%d fFlags=%#x uPciDevNo=%#x uPciFunNo=%#x pszName=%p:{%s}\n",
911 pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pPciDev->abConfig, idxDevCfg, fFlags, uPciDevNo, uPciFunNo, pszName, pszName ? pszName : ""));
912
913 /*
914 * Validate input.
915 */
916 AssertLogRelMsgReturn(RT_VALID_PTR(pPciDev),
917 ("'%s'/%d: Invalid pPciDev value: %p\n", pDevIns->pReg->szName, pDevIns->iInstance, pPciDev),
918 VERR_INVALID_POINTER);
919 AssertLogRelMsgReturn(PDMPciDevGetVendorId(pPciDev),
920 ("'%s'/%d: Vendor ID is not set!\n", pDevIns->pReg->szName, pDevIns->iInstance),
921 VERR_INVALID_POINTER);
922 AssertLogRelMsgReturn(idxDevCfg < 256 || idxDevCfg == PDMPCIDEVREG_CFG_NEXT,
923 ("'%s'/%d: Invalid config selector: %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, idxDevCfg),
924 VERR_OUT_OF_RANGE);
925 AssertLogRelMsgReturn( uPciDevNo < 32
926 || uPciDevNo == PDMPCIDEVREG_DEV_NO_FIRST_UNUSED
927 || uPciDevNo == PDMPCIDEVREG_DEV_NO_SAME_AS_PREV,
928 ("'%s'/%d: Invalid PCI device number: %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, uPciDevNo),
929 VERR_INVALID_PARAMETER);
930 AssertLogRelMsgReturn( uPciFunNo < 8
931 || uPciFunNo == PDMPCIDEVREG_FUN_NO_FIRST_UNUSED,
932 ("'%s'/%d: Invalid PCI funcion number: %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, uPciFunNo),
933 VERR_INVALID_PARAMETER);
934 AssertLogRelMsgReturn(!(fFlags & ~PDMPCIDEVREG_F_VALID_MASK),
935 ("'%s'/%d: Invalid flags: %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, fFlags),
936 VERR_INVALID_FLAGS);
937 int rc = VERR_NOT_IMPLEMENTED;
938 AssertFailed();
939
940 LogFlow(("pdmR3DevHlp_PCIRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
941 return rc;
942}
943
944
945/** @interface_method_impl{PDMDEVHLPR3,pfnPCIRegisterMsi} */
946static DECLCALLBACK(int) pdmR3DevHlp_PCIRegisterMsi(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, PPDMMSIREG pMsiReg)
947{
948 PDMDEV_ASSERT_DEVINS(pDevIns);
949 LogFlow(("pdmR3DevHlp_PCIRegisterMsi: caller='%s'/%d: pPciDev=%p:{%#x} pMsgReg=%p:{cMsiVectors=%d, cMsixVectors=%d}\n",
950 pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pPciDev->uDevFn, pMsiReg, pMsiReg->cMsiVectors, pMsiReg->cMsixVectors));
951
952 int rc = VERR_NOT_IMPLEMENTED;
953 AssertFailed();
954
955 LogFlow(("pdmR3DevHlp_PCIRegisterMsi: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
956 return rc;
957}
958
959
960/** @interface_method_impl{PDMDEVHLPR3,pfnPCIIORegionRegister} */
961static DECLCALLBACK(int) pdmR3DevHlp_PCIIORegionRegister(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t iRegion,
962 RTGCPHYS cbRegion, PCIADDRESSSPACE enmType, PFNPCIIOREGIONMAP pfnCallback)
963{
964 PDMDEV_ASSERT_DEVINS(pDevIns);
965 LogFlow(("pdmR3DevHlp_PCIIORegionRegister: caller='%s'/%d: pPciDev=%p:{%#x} iRegion=%d cbRegion=%RGp enmType=%d pfnCallback=%p\n",
966 pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pPciDev->uDevFn, iRegion, cbRegion, enmType, pfnCallback));
967
968 int rc = VERR_NOT_IMPLEMENTED;
969 AssertFailed();
970
971 LogFlow(("pdmR3DevHlp_PCIIORegionRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
972 return rc;
973}
974
975
976/** @interface_method_impl{PDMDEVHLPR3,pfnPCISetConfigCallbacks} */
977static DECLCALLBACK(void) pdmR3DevHlp_PCISetConfigCallbacks(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, PFNPCICONFIGREAD pfnRead, PPFNPCICONFIGREAD ppfnReadOld,
978 PFNPCICONFIGWRITE pfnWrite, PPFNPCICONFIGWRITE ppfnWriteOld)
979{
980 PDMDEV_ASSERT_DEVINS(pDevIns);
981 LogFlow(("pdmR3DevHlp_PCISetConfigCallbacks: caller='%s'/%d: pPciDev=%p pfnRead=%p ppfnReadOld=%p pfnWrite=%p ppfnWriteOld=%p\n",
982 pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pfnRead, ppfnReadOld, pfnWrite, ppfnWriteOld));
983
984 /*
985 * Validate input and resolve defaults.
986 */
987 AssertPtr(pfnRead);
988 AssertPtr(pfnWrite);
989 AssertPtrNull(ppfnReadOld);
990 AssertPtrNull(ppfnWriteOld);
991 AssertPtrNull(pPciDev);
992
993 AssertFailed();
994
995 LogFlow(("pdmR3DevHlp_PCISetConfigCallbacks: caller='%s'/%d: returns void\n", pDevIns->pReg->szName, pDevIns->iInstance));
996}
997
998
999/** @interface_method_impl{PDMDEVHLPR3,pfnPCIPhysRead} */
1000static DECLCALLBACK(int) pdmR3DevHlp_PCIPhysRead(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, RTGCPHYS GCPhys, void *pvBuf, size_t cbRead)
1001{
1002 PDMDEV_ASSERT_DEVINS(pDevIns);
1003 RT_NOREF(pPciDev);
1004 return pDevIns->pHlpR3->pfnPhysRead(pDevIns, GCPhys, pvBuf, cbRead);
1005}
1006
1007
1008/** @interface_method_impl{PDMDEVHLPR3,pfnPCIPhysWrite} */
1009static DECLCALLBACK(int)
1010pdmR3DevHlp_PCIPhysWrite(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, RTGCPHYS GCPhys, const void *pvBuf, size_t cbWrite)
1011{
1012 PDMDEV_ASSERT_DEVINS(pDevIns);
1013 RT_NOREF(pPciDev);
1014 return pDevIns->pHlpR3->pfnPhysWrite(pDevIns, GCPhys, pvBuf, cbWrite);
1015}
1016
1017
1018/** @interface_method_impl{PDMDEVHLPR3,pfnPCISetIrq} */
1019static DECLCALLBACK(void) pdmR3DevHlp_PCISetIrq(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, int iIrq, int iLevel)
1020{
1021 PDMDEV_ASSERT_DEVINS(pDevIns);
1022 LogFlow(("pdmR3DevHlp_PCISetIrq: caller='%s'/%d: pPciDev=%p:{%#x} iIrq=%d iLevel=%d\n",
1023 pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pPciDev->uDevFn, iIrq, iLevel));
1024
1025 AssertFailed();
1026
1027 LogFlow(("pdmR3DevHlp_PCISetIrq: caller='%s'/%d: returns void\n", pDevIns->pReg->szName, pDevIns->iInstance));
1028}
1029
1030
1031/** @interface_method_impl{PDMDEVHLPR3,pfnPCISetIrqNoWait} */
1032static DECLCALLBACK(void) pdmR3DevHlp_PCISetIrqNoWait(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, int iIrq, int iLevel)
1033{
1034 pdmR3DevHlp_PCISetIrq(pDevIns, pPciDev, iIrq, iLevel);
1035}
1036
1037
1038/** @interface_method_impl{PDMDEVHLPR3,pfnISASetIrq} */
1039static DECLCALLBACK(void) pdmR3DevHlp_ISASetIrq(PPDMDEVINS pDevIns, int iIrq, int iLevel)
1040{
1041 PDMDEV_ASSERT_DEVINS(pDevIns);
1042 LogFlow(("pdmR3DevHlp_ISASetIrq: caller='%s'/%d: iIrq=%d iLevel=%d\n", pDevIns->pReg->szName, pDevIns->iInstance, iIrq, iLevel));
1043
1044 //AssertFailed();
1045
1046 LogFlow(("pdmR3DevHlp_ISASetIrq: caller='%s'/%d: returns void\n", pDevIns->pReg->szName, pDevIns->iInstance));
1047}
1048
1049
1050/** @interface_method_impl{PDMDEVHLPR3,pfnISASetIrqNoWait} */
1051static DECLCALLBACK(void) pdmR3DevHlp_ISASetIrqNoWait(PPDMDEVINS pDevIns, int iIrq, int iLevel)
1052{
1053 pdmR3DevHlp_ISASetIrq(pDevIns, iIrq, iLevel);
1054}
1055
1056
1057/** @interface_method_impl{PDMDEVHLPR3,pfnIoApicSendMsi} */
1058static DECLCALLBACK(void) pdmR3DevHlp_IoApicSendMsi(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, uint32_t uValue)
1059{
1060 PDMDEV_ASSERT_DEVINS(pDevIns);
1061 LogFlow(("pdmR3DevHlp_IoApicSendMsi: caller='%s'/%d: GCPhys=%RGp uValue=%#x\n", pDevIns->pReg->szName, pDevIns->iInstance, GCPhys, uValue));
1062
1063 /*
1064 * Validate input.
1065 */
1066 Assert(GCPhys != 0);
1067 Assert(uValue != 0);
1068 AssertFailed();
1069
1070 LogFlow(("pdmR3DevHlp_IoApicSendMsi: caller='%s'/%d: returns void\n", pDevIns->pReg->szName, pDevIns->iInstance));
1071}
1072
1073
1074/** @interface_method_impl{PDMDEVHLPR3,pfnDriverAttach} */
1075static DECLCALLBACK(int) pdmR3DevHlp_DriverAttach(PPDMDEVINS pDevIns, uint32_t iLun, PPDMIBASE pBaseInterface, PPDMIBASE *ppBaseInterface, const char *pszDesc)
1076{
1077 PDMDEV_ASSERT_DEVINS(pDevIns);
1078 LogFlow(("pdmR3DevHlp_DriverAttach: caller='%s'/%d: iLun=%d pBaseInterface=%p ppBaseInterface=%p pszDesc=%p:{%s}\n",
1079 pDevIns->pReg->szName, pDevIns->iInstance, iLun, pBaseInterface, ppBaseInterface, pszDesc, pszDesc));
1080
1081 /** @todo */
1082 int rc = VERR_PDM_NO_ATTACHED_DRIVER;
1083 //AssertFailed();
1084
1085 LogFlow(("pdmR3DevHlp_DriverAttach: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
1086 return rc;
1087}
1088
1089
1090/** @interface_method_impl{PDMDEVHLPR3,pfnDriverDetach} */
1091static DECLCALLBACK(int) pdmR3DevHlp_DriverDetach(PPDMDEVINS pDevIns, PPDMDRVINS pDrvIns, uint32_t fFlags)
1092{
1093 PDMDEV_ASSERT_DEVINS(pDevIns); RT_NOREF_PV(pDevIns);
1094 LogFlow(("pdmR3DevHlp_DriverDetach: caller='%s'/%d: pDrvIns=%p\n",
1095 pDevIns->pReg->szName, pDevIns->iInstance, pDrvIns));
1096
1097 RT_NOREF(fFlags);
1098 int rc = VERR_NOT_IMPLEMENTED;
1099 AssertFailed();
1100
1101 LogFlow(("pdmR3DevHlp_DriverDetach: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
1102 return rc;
1103}
1104
1105
1106/** @interface_method_impl{PDMDEVHLPR3,pfnQueueCreate} */
1107static DECLCALLBACK(int) pdmR3DevHlp_QueueCreate(PPDMDEVINS pDevIns, size_t cbItem, uint32_t cItems, uint32_t cMilliesInterval,
1108 PFNPDMQUEUEDEV pfnCallback, bool fRZEnabled, const char *pszName, PPDMQUEUE *ppQueue)
1109{
1110 PDMDEV_ASSERT_DEVINS(pDevIns);
1111 LogFlow(("pdmR3DevHlp_QueueCreate: caller='%s'/%d: cbItem=%#x cItems=%#x cMilliesInterval=%u pfnCallback=%p fRZEnabled=%RTbool pszName=%p:{%s} ppQueue=%p\n",
1112 pDevIns->pReg->szName, pDevIns->iInstance, cbItem, cItems, cMilliesInterval, pfnCallback, fRZEnabled, pszName, pszName, ppQueue));
1113
1114 int rc = VERR_NOT_IMPLEMENTED;
1115 AssertFailed();
1116
1117 LogFlow(("pdmR3DevHlp_QueueCreate: caller='%s'/%d: returns %Rrc *ppQueue=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, rc, *ppQueue));
1118 return rc;
1119}
1120
1121
1122/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectInit} */
1123static DECLCALLBACK(int) pdmR3DevHlp_CritSectInit(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect, RT_SRC_POS_DECL,
1124 const char *pszNameFmt, va_list va)
1125{
1126 PDMDEV_ASSERT_DEVINS(pDevIns);
1127 LogFlow(("pdmR3DevHlp_CritSectInit: caller='%s'/%d: pCritSect=%p pszNameFmt=%p:{%s}\n",
1128 pDevIns->pReg->szName, pDevIns->iInstance, pCritSect, pszNameFmt, pszNameFmt));
1129
1130 RT_NOREF(RT_SRC_POS_ARGS, pszNameFmt, pCritSect, va);
1131 int rc = RTCritSectInit(&pCritSect->s.CritSect);
1132 if (RT_SUCCESS(rc))
1133 pCritSect->s.pVmmCallbacks = pDevIns->Internal.s.pVmmCallbacks;
1134
1135 LogFlow(("pdmR3DevHlp_CritSectInit: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
1136 return rc;
1137}
1138
1139
1140/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectGetNop} */
1141static DECLCALLBACK(PPDMCRITSECT) pdmR3DevHlp_CritSectGetNop(PPDMDEVINS pDevIns)
1142{
1143 PDMDEV_ASSERT_DEVINS(pDevIns);
1144
1145 AssertFailed();
1146 PPDMCRITSECT pCritSect = NULL;
1147
1148 LogFlow(("pdmR3DevHlp_CritSectGetNop: caller='%s'/%d: return %p\n",
1149 pDevIns->pReg->szName, pDevIns->iInstance, pCritSect));
1150 return pCritSect;
1151}
1152
1153
1154/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectGetNopR0} */
1155static DECLCALLBACK(R0PTRTYPE(PPDMCRITSECT)) pdmR3DevHlp_CritSectGetNopR0(PPDMDEVINS pDevIns)
1156{
1157 PDMDEV_ASSERT_DEVINS(pDevIns);
1158
1159 R0PTRTYPE(PPDMCRITSECT) pCritSect = 0;
1160 AssertFailed();
1161
1162 LogFlow(("pdmR3DevHlp_CritSectGetNopR0: caller='%s'/%d: return %RHv\n",
1163 pDevIns->pReg->szName, pDevIns->iInstance, pCritSect));
1164 return pCritSect;
1165}
1166
1167
1168/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectGetNopRC} */
1169static DECLCALLBACK(RCPTRTYPE(PPDMCRITSECT)) pdmR3DevHlp_CritSectGetNopRC(PPDMDEVINS pDevIns)
1170{
1171 PDMDEV_ASSERT_DEVINS(pDevIns);
1172
1173 RCPTRTYPE(PPDMCRITSECT) pCritSect = 0;
1174 AssertFailed();
1175
1176 LogFlow(("pdmR3DevHlp_CritSectGetNopRC: caller='%s'/%d: return %RRv\n",
1177 pDevIns->pReg->szName, pDevIns->iInstance, pCritSect));
1178 return pCritSect;
1179}
1180
1181
1182/** @interface_method_impl{PDMDEVHLPR3,pfnSetDeviceCritSect} */
1183static DECLCALLBACK(int) pdmR3DevHlp_SetDeviceCritSect(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect)
1184{
1185 /*
1186 * Validate input.
1187 *
1188 * Note! We only allow the automatically created default critical section
1189 * to be replaced by this API.
1190 */
1191 PDMDEV_ASSERT_DEVINS(pDevIns);
1192 AssertPtrReturn(pCritSect, VERR_INVALID_POINTER);
1193 LogFlow(("pdmR3DevHlp_SetDeviceCritSect: caller='%s'/%d: pCritSect=%p\n",
1194 pDevIns->pReg->szName, pDevIns->iInstance, pCritSect));
1195
1196 /** @todo: Implement default atomatic critical section. */
1197 pDevIns->pCritSectRoR3 = pCritSect;
1198
1199 LogFlow(("pdmR3DevHlp_SetDeviceCritSect: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, VINF_SUCCESS));
1200 return VINF_SUCCESS;
1201}
1202
1203
1204/** @interface_method_impl{PDMDEVHLPR3,pfnThreadCreate} */
1205static DECLCALLBACK(int) pdmR3DevHlp_ThreadCreate(PPDMDEVINS pDevIns, PPPDMTHREAD ppThread, void *pvUser, PFNPDMTHREADDEV pfnThread,
1206 PFNPDMTHREADWAKEUPDEV pfnWakeup, size_t cbStack, RTTHREADTYPE enmType, const char *pszName)
1207{
1208 PDMDEV_ASSERT_DEVINS(pDevIns);
1209 LogFlow(("pdmR3DevHlp_ThreadCreate: caller='%s'/%d: ppThread=%p pvUser=%p pfnThread=%p pfnWakeup=%p cbStack=%#zx enmType=%d pszName=%p:{%s}\n",
1210 pDevIns->pReg->szName, pDevIns->iInstance, ppThread, pvUser, pfnThread, pfnWakeup, cbStack, enmType, pszName, pszName));
1211
1212 int rc = VERR_NOT_IMPLEMENTED;
1213 AssertFailed();
1214
1215 LogFlow(("pdmR3DevHlp_ThreadCreate: caller='%s'/%d: returns %Rrc *ppThread=%RTthrd\n", pDevIns->pReg->szName, pDevIns->iInstance,
1216 rc, *ppThread));
1217 return rc;
1218}
1219
1220
1221/** @interface_method_impl{PDMDEVHLPR3,pfnSetAsyncNotification} */
1222static DECLCALLBACK(int) pdmR3DevHlp_SetAsyncNotification(PPDMDEVINS pDevIns, PFNPDMDEVASYNCNOTIFY pfnAsyncNotify)
1223{
1224 PDMDEV_ASSERT_DEVINS(pDevIns);
1225 LogFlow(("pdmR3DevHlp_SetAsyncNotification: caller='%s'/%d: pfnAsyncNotify=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, pfnAsyncNotify));
1226
1227 int rc = VERR_NOT_IMPLEMENTED;
1228 AssertFailed();
1229
1230 LogFlow(("pdmR3DevHlp_SetAsyncNotification: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
1231 return rc;
1232}
1233
1234
1235/** @interface_method_impl{PDMDEVHLPR3,pfnAsyncNotificationCompleted} */
1236static DECLCALLBACK(void) pdmR3DevHlp_AsyncNotificationCompleted(PPDMDEVINS pDevIns)
1237{
1238 PDMDEV_ASSERT_DEVINS(pDevIns);
1239 AssertFailed();
1240}
1241
1242
1243/** @interface_method_impl{PDMDEVHLPR3,pfnRTCRegister} */
1244static DECLCALLBACK(int) pdmR3DevHlp_RTCRegister(PPDMDEVINS pDevIns, PCPDMRTCREG pRtcReg, PCPDMRTCHLP *ppRtcHlp)
1245{
1246 PDMDEV_ASSERT_DEVINS(pDevIns);
1247 LogFlow(("pdmR3DevHlp_RTCRegister: caller='%s'/%d: pRtcReg=%p:{.u32Version=%#x, .pfnWrite=%p, .pfnRead=%p} ppRtcHlp=%p\n",
1248 pDevIns->pReg->szName, pDevIns->iInstance, pRtcReg, pRtcReg->u32Version, pRtcReg->pfnWrite,
1249 pRtcReg->pfnWrite, ppRtcHlp));
1250
1251 int rc = VERR_NOT_IMPLEMENTED;
1252 AssertFailed();
1253
1254 LogFlow(("pdmR3DevHlp_RTCRegister: caller='%s'/%d: returns %Rrc\n",
1255 pDevIns->pReg->szName, pDevIns->iInstance, rc));
1256 return rc;
1257}
1258
1259
1260/** @interface_method_impl{PDMDEVHLPR3,pfnDMARegister} */
1261static DECLCALLBACK(int) pdmR3DevHlp_DMARegister(PPDMDEVINS pDevIns, unsigned uChannel, PFNDMATRANSFERHANDLER pfnTransferHandler, void *pvUser)
1262{
1263 PDMDEV_ASSERT_DEVINS(pDevIns);
1264
1265 RT_NOREF(uChannel, pfnTransferHandler, pvUser);
1266 int rc = VERR_NOT_IMPLEMENTED;
1267 AssertFailed();
1268
1269 LogFlow(("pdmR3DevHlp_DMARegister: caller='%s'/%d: returns %Rrc\n",
1270 pDevIns->pReg->szName, pDevIns->iInstance, rc));
1271 return rc;
1272}
1273
1274
1275/** @interface_method_impl{PDMDEVHLPR3,pfnDMAReadMemory} */
1276static DECLCALLBACK(int) pdmR3DevHlp_DMAReadMemory(PPDMDEVINS pDevIns, unsigned uChannel, void *pvBuffer, uint32_t off, uint32_t cbBlock, uint32_t *pcbRead)
1277{
1278 PDMDEV_ASSERT_DEVINS(pDevIns);
1279 LogFlow(("pdmR3DevHlp_DMAReadMemory: caller='%s'/%d: uChannel=%d pvBuffer=%p off=%#x cbBlock=%#x pcbRead=%p\n",
1280 pDevIns->pReg->szName, pDevIns->iInstance, uChannel, pvBuffer, off, cbBlock, pcbRead));
1281
1282 RT_NOREF(uChannel, pvBuffer, off, cbBlock, pcbRead);
1283 int rc = VERR_NOT_IMPLEMENTED;
1284 AssertFailed();
1285
1286 LogFlow(("pdmR3DevHlp_DMAReadMemory: caller='%s'/%d: returns %Rrc\n",
1287 pDevIns->pReg->szName, pDevIns->iInstance, rc));
1288 return rc;
1289}
1290
1291
1292/** @interface_method_impl{PDMDEVHLPR3,pfnDMAWriteMemory} */
1293static DECLCALLBACK(int) pdmR3DevHlp_DMAWriteMemory(PPDMDEVINS pDevIns, unsigned uChannel, const void *pvBuffer, uint32_t off, uint32_t cbBlock, uint32_t *pcbWritten)
1294{
1295 PDMDEV_ASSERT_DEVINS(pDevIns);
1296 LogFlow(("pdmR3DevHlp_DMAWriteMemory: caller='%s'/%d: uChannel=%d pvBuffer=%p off=%#x cbBlock=%#x pcbWritten=%p\n",
1297 pDevIns->pReg->szName, pDevIns->iInstance, uChannel, pvBuffer, off, cbBlock, pcbWritten));
1298
1299 RT_NOREF(uChannel, pvBuffer, off, cbBlock, pcbWritten);
1300 int rc = VERR_NOT_IMPLEMENTED;
1301 AssertFailed();
1302
1303 LogFlow(("pdmR3DevHlp_DMAWriteMemory: caller='%s'/%d: returns %Rrc\n",
1304 pDevIns->pReg->szName, pDevIns->iInstance, rc));
1305 return rc;
1306}
1307
1308
1309/** @interface_method_impl{PDMDEVHLPR3,pfnDMASetDREQ} */
1310static DECLCALLBACK(int) pdmR3DevHlp_DMASetDREQ(PPDMDEVINS pDevIns, unsigned uChannel, unsigned uLevel)
1311{
1312 PDMDEV_ASSERT_DEVINS(pDevIns);
1313 LogFlow(("pdmR3DevHlp_DMASetDREQ: caller='%s'/%d: uChannel=%d uLevel=%d\n",
1314 pDevIns->pReg->szName, pDevIns->iInstance, uChannel, uLevel));
1315
1316 RT_NOREF(uChannel, uLevel);
1317 int rc = VERR_NOT_IMPLEMENTED;
1318 AssertFailed();
1319
1320 LogFlow(("pdmR3DevHlp_DMASetDREQ: caller='%s'/%d: returns %Rrc\n",
1321 pDevIns->pReg->szName, pDevIns->iInstance, rc));
1322 return rc;
1323}
1324
1325/** @interface_method_impl{PDMDEVHLPR3,pfnDMAGetChannelMode} */
1326static DECLCALLBACK(uint8_t) pdmR3DevHlp_DMAGetChannelMode(PPDMDEVINS pDevIns, unsigned uChannel)
1327{
1328 PDMDEV_ASSERT_DEVINS(pDevIns);
1329 LogFlow(("pdmR3DevHlp_DMAGetChannelMode: caller='%s'/%d: uChannel=%d\n",
1330 pDevIns->pReg->szName, pDevIns->iInstance, uChannel));
1331
1332 uint8_t u8Mode = 0;
1333 AssertFailed();
1334
1335 LogFlow(("pdmR3DevHlp_DMAGetChannelMode: caller='%s'/%d: returns %#04x\n",
1336 pDevIns->pReg->szName, pDevIns->iInstance, u8Mode));
1337 return u8Mode;
1338}
1339
1340/** @interface_method_impl{PDMDEVHLPR3,pfnDMASchedule} */
1341static DECLCALLBACK(void) pdmR3DevHlp_DMASchedule(PPDMDEVINS pDevIns)
1342{
1343 PDMDEV_ASSERT_DEVINS(pDevIns);
1344 LogFlow(("pdmR3DevHlp_DMASchedule: caller='%s'/%d\n",
1345 pDevIns->pReg->szName, pDevIns->iInstance));
1346
1347 AssertFailed();
1348}
1349
1350
1351/** @interface_method_impl{PDMDEVHLPR3,pfnCMOSWrite} */
1352static DECLCALLBACK(int) pdmR3DevHlp_CMOSWrite(PPDMDEVINS pDevIns, unsigned iReg, uint8_t u8Value)
1353{
1354 PDMDEV_ASSERT_DEVINS(pDevIns);
1355 LogFlow(("pdmR3DevHlp_CMOSWrite: caller='%s'/%d: iReg=%#04x u8Value=%#04x\n",
1356 pDevIns->pReg->szName, pDevIns->iInstance, iReg, u8Value));
1357
1358 int rc = VERR_NOT_IMPLEMENTED;
1359 AssertFailed();
1360
1361 LogFlow(("pdmR3DevHlp_CMOSWrite: caller='%s'/%d: return %Rrc\n",
1362 pDevIns->pReg->szName, pDevIns->iInstance, rc));
1363 return rc;
1364}
1365
1366
1367/** @interface_method_impl{PDMDEVHLPR3,pfnCMOSRead} */
1368static DECLCALLBACK(int) pdmR3DevHlp_CMOSRead(PPDMDEVINS pDevIns, unsigned iReg, uint8_t *pu8Value)
1369{
1370 PDMDEV_ASSERT_DEVINS(pDevIns);
1371 LogFlow(("pdmR3DevHlp_CMOSWrite: caller='%s'/%d: iReg=%#04x pu8Value=%p\n",
1372 pDevIns->pReg->szName, pDevIns->iInstance, iReg, pu8Value));
1373
1374 int rc = VERR_NOT_IMPLEMENTED;
1375 AssertFailed();
1376
1377 LogFlow(("pdmR3DevHlp_CMOSWrite: caller='%s'/%d: return %Rrc\n",
1378 pDevIns->pReg->szName, pDevIns->iInstance, rc));
1379 return rc;
1380}
1381
1382
1383/** @interface_method_impl{PDMDEVHLPR3,pfnAssertEMT} */
1384static DECLCALLBACK(bool) pdmR3DevHlp_AssertEMT(PPDMDEVINS pDevIns, const char *pszFile, unsigned iLine, const char *pszFunction)
1385{
1386 PDMDEV_ASSERT_DEVINS(pDevIns);
1387 RT_NOREF(pszFile, iLine, pszFunction);
1388 AssertFailed();
1389 return false;
1390}
1391
1392
1393/** @interface_method_impl{PDMDEVHLPR3,pfnAssertOther} */
1394static DECLCALLBACK(bool) pdmR3DevHlp_AssertOther(PPDMDEVINS pDevIns, const char *pszFile, unsigned iLine, const char *pszFunction)
1395{
1396 PDMDEV_ASSERT_DEVINS(pDevIns);
1397 RT_NOREF(pszFile, iLine, pszFunction);
1398 AssertFailed();
1399 return false;
1400}
1401
1402
1403/** @interface_method_impl{PDMDEVHLPR3,pfnLdrGetRCInterfaceSymbols} */
1404static DECLCALLBACK(int) pdmR3DevHlp_LdrGetRCInterfaceSymbols(PPDMDEVINS pDevIns, void *pvInterface, size_t cbInterface,
1405 const char *pszSymPrefix, const char *pszSymList)
1406{
1407 PDMDEV_ASSERT_DEVINS(pDevIns);
1408 LogFlow(("pdmR3DevHlp_PDMLdrGetRCInterfaceSymbols: caller='%s'/%d: pvInterface=%p cbInterface=%zu pszSymPrefix=%p:{%s} pszSymList=%p:{%s}\n",
1409 pDevIns->pReg->szName, pDevIns->iInstance, pvInterface, cbInterface, pszSymPrefix, pszSymPrefix, pszSymList, pszSymList));
1410
1411 int rc = VERR_NOT_IMPLEMENTED;
1412 AssertFailed();
1413
1414 LogFlow(("pdmR3DevHlp_PDMLdrGetRCInterfaceSymbols: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName,
1415 pDevIns->iInstance, rc));
1416 return rc;
1417}
1418
1419
1420/** @interface_method_impl{PDMDEVHLPR3,pfnLdrGetR0InterfaceSymbols} */
1421static DECLCALLBACK(int) pdmR3DevHlp_LdrGetR0InterfaceSymbols(PPDMDEVINS pDevIns, void *pvInterface, size_t cbInterface,
1422 const char *pszSymPrefix, const char *pszSymList)
1423{
1424 PDMDEV_ASSERT_DEVINS(pDevIns);
1425 LogFlow(("pdmR3DevHlp_PDMLdrGetR0InterfaceSymbols: caller='%s'/%d: pvInterface=%p cbInterface=%zu pszSymPrefix=%p:{%s} pszSymList=%p:{%s}\n",
1426 pDevIns->pReg->szName, pDevIns->iInstance, pvInterface, cbInterface, pszSymPrefix, pszSymPrefix, pszSymList, pszSymList));
1427
1428 int rc = VERR_NOT_IMPLEMENTED;
1429 AssertFailed();
1430
1431 LogFlow(("pdmR3DevHlp_PDMLdrGetR0InterfaceSymbols: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName,
1432 pDevIns->iInstance, rc));
1433 return rc;
1434}
1435
1436
1437/** @interface_method_impl{PDMDEVHLPR3,pfnCallR0} */
1438static DECLCALLBACK(int) pdmR3DevHlp_CallR0(PPDMDEVINS pDevIns, uint32_t uOperation, uint64_t u64Arg)
1439{
1440 PDMDEV_ASSERT_DEVINS(pDevIns);
1441 LogFlow(("pdmR3DevHlp_CallR0: caller='%s'/%d: uOperation=%#x u64Arg=%#RX64\n",
1442 pDevIns->pReg->szName, pDevIns->iInstance, uOperation, u64Arg));
1443
1444 int rc = VERR_NOT_IMPLEMENTED;
1445 AssertFailed();
1446
1447 LogFlow(("pdmR3DevHlp_CallR0: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName,
1448 pDevIns->iInstance, rc));
1449 return rc;
1450}
1451
1452
1453/** @interface_method_impl{PDMDEVHLPR3,pfnVMGetSuspendReason} */
1454static DECLCALLBACK(VMSUSPENDREASON) pdmR3DevHlp_VMGetSuspendReason(PPDMDEVINS pDevIns)
1455{
1456 PDMDEV_ASSERT_DEVINS(pDevIns);
1457 VMSUSPENDREASON enmReason = VMSUSPENDREASON_INVALID;
1458 AssertFailed();
1459 LogFlow(("pdmR3DevHlp_VMGetSuspendReason: caller='%s'/%d: returns %d\n",
1460 pDevIns->pReg->szName, pDevIns->iInstance, enmReason));
1461 return enmReason;
1462}
1463
1464
1465/** @interface_method_impl{PDMDEVHLPR3,pfnVMGetResumeReason} */
1466static DECLCALLBACK(VMRESUMEREASON) pdmR3DevHlp_VMGetResumeReason(PPDMDEVINS pDevIns)
1467{
1468 PDMDEV_ASSERT_DEVINS(pDevIns);
1469 VMRESUMEREASON enmReason = VMRESUMEREASON_INVALID;
1470 AssertFailed();
1471 LogFlow(("pdmR3DevHlp_VMGetResumeReason: caller='%s'/%d: returns %d\n",
1472 pDevIns->pReg->szName, pDevIns->iInstance, enmReason));
1473 return enmReason;
1474}
1475
1476
1477/** @interface_method_impl{PDMDEVHLPR3,pfnGetUVM} */
1478static DECLCALLBACK(PUVM) pdmR3DevHlp_GetUVM(PPDMDEVINS pDevIns)
1479{
1480 PDMDEV_ASSERT_DEVINS(pDevIns);
1481 AssertFailed();
1482 LogFlow(("pdmR3DevHlp_GetUVM: caller='%s'/%d: returns %p\n", pDevIns->pReg->szName, pDevIns->iInstance, NULL));
1483 return NULL;
1484}
1485
1486
1487/** @interface_method_impl{PDMDEVHLPR3,pfnGetVM} */
1488static DECLCALLBACK(PVM) pdmR3DevHlp_GetVM(PPDMDEVINS pDevIns)
1489{
1490 PDMDEV_ASSERT_DEVINS(pDevIns);
1491 AssertFailed();
1492 LogFlow(("pdmR3DevHlp_GetVM: caller='%s'/%d: returns %p\n", pDevIns->pReg->szName, pDevIns->iInstance, NULL));
1493 return NULL;
1494}
1495
1496
1497/** @interface_method_impl{PDMDEVHLPR3,pfnGetVMCPU} */
1498static DECLCALLBACK(PVMCPU) pdmR3DevHlp_GetVMCPU(PPDMDEVINS pDevIns)
1499{
1500 PDMDEV_ASSERT_DEVINS(pDevIns);
1501 AssertFailed();
1502 LogFlow(("pdmR3DevHlp_GetVMCPU: caller='%s'/%d for CPU %u\n", pDevIns->pReg->szName, pDevIns->iInstance, NULL));
1503 return NULL;
1504}
1505
1506
1507/** @interface_method_impl{PDMDEVHLPR3,pfnGetCurrentCpuId} */
1508static DECLCALLBACK(VMCPUID) pdmR3DevHlp_GetCurrentCpuId(PPDMDEVINS pDevIns)
1509{
1510 PDMDEV_ASSERT_DEVINS(pDevIns);
1511 VMCPUID idCpu = 0;
1512 AssertFailed();
1513 LogFlow(("pdmR3DevHlp_GetCurrentCpuId: caller='%s'/%d for CPU %u\n", pDevIns->pReg->szName, pDevIns->iInstance, idCpu));
1514 return idCpu;
1515}
1516
1517
1518/** @interface_method_impl{PDMDEVHLPR3,pfnPCIBusRegister} */
1519static DECLCALLBACK(int) pdmR3DevHlp_PCIBusRegister(PPDMDEVINS pDevIns, PPDMPCIBUSREG pPciBusReg,
1520 PCPDMPCIHLPR3 *ppPciHlpR3, uint32_t *piBus)
1521{
1522 PDMDEV_ASSERT_DEVINS(pDevIns);
1523 LogFlow(("pdmR3DevHlp_PCIBusRegister: caller='%s'/%d: pPciBusReg=%p:{.u32Version=%#x, .pfnRegisterR3=%p, .pfnIORegionRegisterR3=%p, "
1524 ".pfnSetIrqR3=%p, .pszSetIrqRC=%p:{%s}, .pszSetIrqR0=%p:{%s}} ppPciHlpR3=%p piBus=%p\n",
1525 pDevIns->pReg->szName, pDevIns->iInstance, pPciBusReg, pPciBusReg->u32Version, pPciBusReg->pfnRegisterR3,
1526 pPciBusReg->pfnIORegionRegisterR3, pPciBusReg->pfnSetIrqR3, pPciBusReg->pszSetIrqRC, pPciBusReg->pszSetIrqRC,
1527 pPciBusReg->pszSetIrqR0, pPciBusReg->pszSetIrqR0, ppPciHlpR3, piBus));
1528
1529 int rc = VERR_NOT_IMPLEMENTED;
1530 AssertFailed();
1531
1532 LogFlow(("pdmR3DevHlp_PCIBusRegister: caller='%s'/%d: returns %Rrc *piBus=%u\n",
1533 pDevIns->pReg->szName, pDevIns->iInstance, rc, *piBus));
1534 return rc;
1535}
1536
1537
1538/** @interface_method_impl{PDMDEVHLPR3,pfnPICRegister} */
1539static DECLCALLBACK(int) pdmR3DevHlp_PICRegister(PPDMDEVINS pDevIns, PPDMPICREG pPicReg, PCPDMPICHLPR3 *ppPicHlpR3)
1540{
1541 PDMDEV_ASSERT_DEVINS(pDevIns);
1542 LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: pPicReg=%p:{.u32Version=%#x, .pfnSetIrqR3=%p, .pfnGetInterruptR3=%p, .pszGetIrqRC=%p:{%s}, .pszGetInterruptRC=%p:{%s}, .pszGetIrqR0=%p:{%s}, .pszGetInterruptR0=%p:{%s} } ppPicHlpR3=%p\n",
1543 pDevIns->pReg->szName, pDevIns->iInstance, pPicReg, pPicReg->u32Version, pPicReg->pfnSetIrqR3, pPicReg->pfnGetInterruptR3,
1544 pPicReg->pszSetIrqRC, pPicReg->pszSetIrqRC, pPicReg->pszGetInterruptRC, pPicReg->pszGetInterruptRC,
1545 pPicReg->pszSetIrqR0, pPicReg->pszSetIrqR0, pPicReg->pszGetInterruptR0, pPicReg->pszGetInterruptR0,
1546 ppPicHlpR3));
1547
1548 int rc = VERR_NOT_IMPLEMENTED;
1549 AssertFailed();
1550
1551 LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
1552 return rc;
1553}
1554
1555
1556/** @interface_method_impl{PDMDEVHLPR3,pfnAPICRegister} */
1557static DECLCALLBACK(int) pdmR3DevHlp_APICRegister(PPDMDEVINS pDevIns)
1558{
1559 PDMDEV_ASSERT_DEVINS(pDevIns);
1560
1561 int rc = VERR_NOT_IMPLEMENTED;
1562 AssertFailed();
1563
1564 LogFlow(("pdmR3DevHlp_APICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
1565 return rc;
1566}
1567
1568
1569/** @interface_method_impl{PDMDEVHLPR3,pfnIOAPICRegister} */
1570static DECLCALLBACK(int) pdmR3DevHlp_IOAPICRegister(PPDMDEVINS pDevIns, PPDMIOAPICREG pIoApicReg, PCPDMIOAPICHLPR3 *ppIoApicHlpR3)
1571{
1572 PDMDEV_ASSERT_DEVINS(pDevIns);
1573 LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: pIoApicReg=%p:{.u32Version=%#x, .pfnSetIrqR3=%p, .pszSetIrqRC=%p:{%s}, .pszSetIrqR0=%p:{%s}} ppIoApicHlpR3=%p\n",
1574 pDevIns->pReg->szName, pDevIns->iInstance, pIoApicReg, pIoApicReg->u32Version, pIoApicReg->pfnSetIrqR3,
1575 pIoApicReg->pszSetIrqRC, pIoApicReg->pszSetIrqRC, pIoApicReg->pszSetIrqR0, pIoApicReg->pszSetIrqR0, ppIoApicHlpR3));
1576
1577 int rc = VERR_NOT_IMPLEMENTED;
1578 AssertFailed();
1579
1580 LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
1581 return rc;
1582}
1583
1584
1585/** @interface_method_impl{PDMDEVHLPR3,pfnHPETRegister} */
1586static DECLCALLBACK(int) pdmR3DevHlp_HPETRegister(PPDMDEVINS pDevIns, PPDMHPETREG pHpetReg, PCPDMHPETHLPR3 *ppHpetHlpR3)
1587{
1588 PDMDEV_ASSERT_DEVINS(pDevIns); RT_NOREF_PV(pDevIns);
1589 LogFlow(("pdmR3DevHlp_HPETRegister: caller='%s'/%d:\n", pDevIns->pReg->szName, pDevIns->iInstance));
1590
1591 RT_NOREF(pHpetReg, ppHpetHlpR3);
1592 int rc = VERR_NOT_IMPLEMENTED;
1593 AssertFailed();
1594
1595 LogFlow(("pdmR3DevHlp_HPETRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
1596 return rc;
1597}
1598
1599
1600/** @interface_method_impl{PDMDEVHLPR3,pfnPciRawRegister} */
1601static DECLCALLBACK(int) pdmR3DevHlp_PciRawRegister(PPDMDEVINS pDevIns, PPDMPCIRAWREG pPciRawReg, PCPDMPCIRAWHLPR3 *ppPciRawHlpR3)
1602{
1603 PDMDEV_ASSERT_DEVINS(pDevIns); RT_NOREF_PV(pDevIns);
1604 LogFlow(("pdmR3DevHlp_PciRawRegister: caller='%s'/%d:\n", pDevIns->pReg->szName, pDevIns->iInstance));
1605
1606 RT_NOREF(pPciRawReg, ppPciRawHlpR3);
1607 int rc = VERR_NOT_IMPLEMENTED;
1608 AssertFailed();
1609
1610 LogFlow(("pdmR3DevHlp_PciRawRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
1611 return rc;
1612}
1613
1614
1615/** @interface_method_impl{PDMDEVHLPR3,pfnDMACRegister} */
1616static DECLCALLBACK(int) pdmR3DevHlp_DMACRegister(PPDMDEVINS pDevIns, PPDMDMACREG pDmacReg, PCPDMDMACHLP *ppDmacHlp)
1617{
1618 PDMDEV_ASSERT_DEVINS(pDevIns);
1619 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",
1620 pDevIns->pReg->szName, pDevIns->iInstance, pDmacReg, pDmacReg->u32Version, pDmacReg->pfnRun, pDmacReg->pfnRegister,
1621 pDmacReg->pfnReadMemory, pDmacReg->pfnWriteMemory, pDmacReg->pfnSetDREQ, pDmacReg->pfnGetChannelMode, ppDmacHlp));
1622
1623 RT_NOREF(pDmacReg, ppDmacHlp);
1624 int rc = VERR_NOT_IMPLEMENTED;
1625 AssertFailed();
1626
1627 LogFlow(("pdmR3DevHlp_DMACRegister: caller='%s'/%d: returns %Rrc\n",
1628 pDevIns->pReg->szName, pDevIns->iInstance, rc));
1629 return rc;
1630}
1631
1632
1633/**
1634 * @copydoc PDMDEVHLPR3::pfnRegisterVMMDevHeap
1635 */
1636static DECLCALLBACK(int) pdmR3DevHlp_RegisterVMMDevHeap(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, RTR3PTR pvHeap, unsigned cbHeap)
1637{
1638 PDMDEV_ASSERT_DEVINS(pDevIns);
1639 LogFlow(("pdmR3DevHlp_RegisterVMMDevHeap: caller='%s'/%d: GCPhys=%RGp pvHeap=%p cbHeap=%#x\n",
1640 pDevIns->pReg->szName, pDevIns->iInstance, GCPhys, pvHeap, cbHeap));
1641
1642 int rc = VERR_NOT_IMPLEMENTED;
1643 AssertFailed();
1644
1645 LogFlow(("pdmR3DevHlp_RegisterVMMDevHeap: caller='%s'/%d: returns %Rrc\n",
1646 pDevIns->pReg->szName, pDevIns->iInstance, rc));
1647 return rc;
1648}
1649
1650
1651/**
1652 * @interface_method_impl{PDMDEVHLPR3,pfnFirmwareRegister}
1653 */
1654static DECLCALLBACK(int) pdmR3DevHlp_FirmwareRegister(PPDMDEVINS pDevIns, PCPDMFWREG pFwReg, PCPDMFWHLPR3 *ppFwHlp)
1655{
1656 PDMDEV_ASSERT_DEVINS(pDevIns);
1657 LogFlow(("pdmR3DevHlp_FirmwareRegister: caller='%s'/%d: pFWReg=%p:{.u32Version=%#x, .pfnIsHardReset=%p, .u32TheEnd=%#x} ppFwHlp=%p\n",
1658 pDevIns->pReg->szName, pDevIns->iInstance, pFwReg, pFwReg->u32Version, pFwReg->pfnIsHardReset, pFwReg->u32TheEnd, ppFwHlp));
1659
1660 RT_NOREF(pFwReg, ppFwHlp);
1661 int rc = VERR_NOT_IMPLEMENTED;
1662 AssertFailed();
1663
1664 LogFlow(("pdmR3DevHlp_FirmwareRegister: caller='%s'/%d: returns %Rrc\n",
1665 pDevIns->pReg->szName, pDevIns->iInstance, rc));
1666 return rc;
1667}
1668
1669
1670/** @interface_method_impl{PDMDEVHLPR3,pfnVMReset} */
1671static DECLCALLBACK(int) pdmR3DevHlp_VMReset(PPDMDEVINS pDevIns, uint32_t fFlags)
1672{
1673 PDMDEV_ASSERT_DEVINS(pDevIns);
1674 LogFlow(("pdmR3DevHlp_VMReset: caller='%s'/%d: fFlags=%#x\n",
1675 pDevIns->pReg->szName, pDevIns->iInstance, fFlags));
1676
1677 int rc = VERR_NOT_IMPLEMENTED;
1678 AssertFailed();
1679
1680 LogFlow(("pdmR3DevHlp_VMReset: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
1681 return rc;
1682}
1683
1684
1685/** @interface_method_impl{PDMDEVHLPR3,pfnVMSuspend} */
1686static DECLCALLBACK(int) pdmR3DevHlp_VMSuspend(PPDMDEVINS pDevIns)
1687{
1688 PDMDEV_ASSERT_DEVINS(pDevIns);
1689 LogFlow(("pdmR3DevHlp_VMSuspend: caller='%s'/%d:\n",
1690 pDevIns->pReg->szName, pDevIns->iInstance));
1691
1692 int rc = VERR_NOT_IMPLEMENTED;
1693 AssertFailed();
1694
1695 LogFlow(("pdmR3DevHlp_VMSuspend: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
1696 return rc;
1697}
1698
1699
1700/** @interface_method_impl{PDMDEVHLPR3,pfnVMSuspendSaveAndPowerOff} */
1701static DECLCALLBACK(int) pdmR3DevHlp_VMSuspendSaveAndPowerOff(PPDMDEVINS pDevIns)
1702{
1703 PDMDEV_ASSERT_DEVINS(pDevIns);
1704 LogFlow(("pdmR3DevHlp_VMSuspendSaveAndPowerOff: caller='%s'/%d:\n",
1705 pDevIns->pReg->szName, pDevIns->iInstance));
1706
1707 int rc = VERR_NOT_IMPLEMENTED;
1708 AssertFailed();
1709
1710 LogFlow(("pdmR3DevHlp_VMSuspendSaveAndPowerOff: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
1711 return rc;
1712}
1713
1714
1715/** @interface_method_impl{PDMDEVHLPR3,pfnVMPowerOff} */
1716static DECLCALLBACK(int) pdmR3DevHlp_VMPowerOff(PPDMDEVINS pDevIns)
1717{
1718 PDMDEV_ASSERT_DEVINS(pDevIns);
1719 LogFlow(("pdmR3DevHlp_VMPowerOff: caller='%s'/%d:\n",
1720 pDevIns->pReg->szName, pDevIns->iInstance));
1721
1722 int rc = VERR_NOT_IMPLEMENTED;
1723 AssertFailed();
1724
1725 LogFlow(("pdmR3DevHlp_VMPowerOff: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
1726 return rc;
1727}
1728
1729
1730/** @interface_method_impl{PDMDEVHLPR3,pfnA20IsEnabled} */
1731static DECLCALLBACK(bool) pdmR3DevHlp_A20IsEnabled(PPDMDEVINS pDevIns)
1732{
1733 PDMDEV_ASSERT_DEVINS(pDevIns);
1734
1735 bool fRc = false;
1736 AssertFailed();
1737
1738 LogFlow(("pdmR3DevHlp_A20IsEnabled: caller='%s'/%d: returns %d\n", pDevIns->pReg->szName, pDevIns->iInstance, fRc));
1739 return fRc;
1740}
1741
1742
1743/** @interface_method_impl{PDMDEVHLPR3,pfnA20Set} */
1744static DECLCALLBACK(void) pdmR3DevHlp_A20Set(PPDMDEVINS pDevIns, bool fEnable)
1745{
1746 PDMDEV_ASSERT_DEVINS(pDevIns);
1747 LogFlow(("pdmR3DevHlp_A20Set: caller='%s'/%d: fEnable=%d\n", pDevIns->pReg->szName, pDevIns->iInstance, fEnable));
1748 AssertFailed();
1749}
1750
1751
1752/** @interface_method_impl{PDMDEVHLPR3,pfnGetCpuId} */
1753static DECLCALLBACK(void) pdmR3DevHlp_GetCpuId(PPDMDEVINS pDevIns, uint32_t iLeaf,
1754 uint32_t *pEax, uint32_t *pEbx, uint32_t *pEcx, uint32_t *pEdx)
1755{
1756 PDMDEV_ASSERT_DEVINS(pDevIns);
1757 LogFlow(("pdmR3DevHlp_GetCpuId: caller='%s'/%d: iLeaf=%d pEax=%p pEbx=%p pEcx=%p pEdx=%p\n",
1758 pDevIns->pReg->szName, pDevIns->iInstance, iLeaf, pEax, pEbx, pEcx, pEdx));
1759 AssertPtr(pEax); AssertPtr(pEbx); AssertPtr(pEcx); AssertPtr(pEdx);
1760
1761 AssertFailed();
1762
1763 LogFlow(("pdmR3DevHlp_GetCpuId: caller='%s'/%d: returns void - *pEax=%#x *pEbx=%#x *pEcx=%#x *pEdx=%#x\n",
1764 pDevIns->pReg->szName, pDevIns->iInstance, *pEax, *pEbx, *pEcx, *pEdx));
1765}
1766
1767const PDMDEVHLPR3 g_tstDevPdmDevHlpR3 =
1768{
1769 PDM_DEVHLPR3_VERSION,
1770 pdmR3DevHlp_IOPortRegister,
1771 pdmR3DevHlp_IOPortRegisterRC,
1772 pdmR3DevHlp_IOPortRegisterR0,
1773 pdmR3DevHlp_IOPortDeregister,
1774 pdmR3DevHlp_MMIORegister,
1775 pdmR3DevHlp_MMIORegisterRC,
1776 pdmR3DevHlp_MMIORegisterR0,
1777 pdmR3DevHlp_MMIODeregister,
1778 pdmR3DevHlp_MMIO2Register,
1779 pdmR3DevHlp_MMIOExPreRegister,
1780 pdmR3DevHlp_MMIOExDeregister,
1781 pdmR3DevHlp_MMIOExMap,
1782 pdmR3DevHlp_MMIOExUnmap,
1783 pdmR3DevHlp_MMIOExReduce,
1784 pdmR3DevHlp_MMHyperMapMMIO2,
1785 pdmR3DevHlp_MMIO2MapKernel,
1786 pdmR3DevHlp_ROMRegister,
1787 pdmR3DevHlp_ROMProtectShadow,
1788 pdmR3DevHlp_SSMRegister,
1789 pdmR3DevHlp_TMTimerCreate,
1790 pdmR3DevHlp_TMUtcNow,
1791 pdmR3DevHlp_PhysRead,
1792 pdmR3DevHlp_PhysWrite,
1793 pdmR3DevHlp_PhysGCPhys2CCPtr,
1794 pdmR3DevHlp_PhysGCPhys2CCPtrReadOnly,
1795 pdmR3DevHlp_PhysReleasePageMappingLock,
1796 pdmR3DevHlp_PhysReadGCVirt,
1797 pdmR3DevHlp_PhysWriteGCVirt,
1798 pdmR3DevHlp_PhysGCPtr2GCPhys,
1799 pdmR3DevHlp_MMHeapAlloc,
1800 pdmR3DevHlp_MMHeapAllocZ,
1801 pdmR3DevHlp_MMHeapFree,
1802 pdmR3DevHlp_VMState,
1803 pdmR3DevHlp_VMTeleportedAndNotFullyResumedYet,
1804 pdmR3DevHlp_VMSetError,
1805 pdmR3DevHlp_VMSetErrorV,
1806 pdmR3DevHlp_VMSetRuntimeError,
1807 pdmR3DevHlp_VMSetRuntimeErrorV,
1808 pdmR3DevHlp_DBGFStopV,
1809 pdmR3DevHlp_DBGFInfoRegister,
1810 pdmR3DevHlp_DBGFRegRegister,
1811 pdmR3DevHlp_DBGFTraceBuf,
1812 pdmR3DevHlp_STAMRegister,
1813 pdmR3DevHlp_STAMRegisterF,
1814 pdmR3DevHlp_STAMRegisterV,
1815 pdmR3DevHlp_PCIRegister,
1816 pdmR3DevHlp_PCIRegisterMsi,
1817 pdmR3DevHlp_PCIIORegionRegister,
1818 pdmR3DevHlp_PCISetConfigCallbacks,
1819 pdmR3DevHlp_PCIPhysRead,
1820 pdmR3DevHlp_PCIPhysWrite,
1821 pdmR3DevHlp_PCISetIrq,
1822 pdmR3DevHlp_PCISetIrqNoWait,
1823 pdmR3DevHlp_ISASetIrq,
1824 pdmR3DevHlp_ISASetIrqNoWait,
1825 pdmR3DevHlp_IoApicSendMsi,
1826 pdmR3DevHlp_DriverAttach,
1827 pdmR3DevHlp_DriverDetach,
1828 pdmR3DevHlp_QueueCreate,
1829 pdmR3DevHlp_CritSectInit,
1830 pdmR3DevHlp_CritSectGetNop,
1831 pdmR3DevHlp_CritSectGetNopR0,
1832 pdmR3DevHlp_CritSectGetNopRC,
1833 pdmR3DevHlp_SetDeviceCritSect,
1834 pdmR3DevHlp_ThreadCreate,
1835 pdmR3DevHlp_SetAsyncNotification,
1836 pdmR3DevHlp_AsyncNotificationCompleted,
1837 pdmR3DevHlp_RTCRegister,
1838 pdmR3DevHlp_PCIBusRegister,
1839 pdmR3DevHlp_PICRegister,
1840 pdmR3DevHlp_APICRegister,
1841 pdmR3DevHlp_IOAPICRegister,
1842 pdmR3DevHlp_HPETRegister,
1843 pdmR3DevHlp_PciRawRegister,
1844 pdmR3DevHlp_DMACRegister,
1845 pdmR3DevHlp_DMARegister,
1846 pdmR3DevHlp_DMAReadMemory,
1847 pdmR3DevHlp_DMAWriteMemory,
1848 pdmR3DevHlp_DMASetDREQ,
1849 pdmR3DevHlp_DMAGetChannelMode,
1850 pdmR3DevHlp_DMASchedule,
1851 pdmR3DevHlp_CMOSWrite,
1852 pdmR3DevHlp_CMOSRead,
1853 pdmR3DevHlp_AssertEMT,
1854 pdmR3DevHlp_AssertOther,
1855 pdmR3DevHlp_LdrGetRCInterfaceSymbols,
1856 pdmR3DevHlp_LdrGetR0InterfaceSymbols,
1857 pdmR3DevHlp_CallR0,
1858 pdmR3DevHlp_VMGetSuspendReason,
1859 pdmR3DevHlp_VMGetResumeReason,
1860 0,
1861 0,
1862 0,
1863 0,
1864 0,
1865 0,
1866 0,
1867 0,
1868 0,
1869 0,
1870 pdmR3DevHlp_GetUVM,
1871 pdmR3DevHlp_GetVM,
1872 pdmR3DevHlp_GetVMCPU,
1873 pdmR3DevHlp_GetCurrentCpuId,
1874 pdmR3DevHlp_RegisterVMMDevHeap,
1875 pdmR3DevHlp_FirmwareRegister,
1876 pdmR3DevHlp_VMReset,
1877 pdmR3DevHlp_VMSuspend,
1878 pdmR3DevHlp_VMSuspendSaveAndPowerOff,
1879 pdmR3DevHlp_VMPowerOff,
1880 pdmR3DevHlp_A20IsEnabled,
1881 pdmR3DevHlp_A20Set,
1882 pdmR3DevHlp_GetCpuId,
1883 pdmR3DevHlp_TMTimeVirtGet,
1884 pdmR3DevHlp_TMTimeVirtGetFreq,
1885 pdmR3DevHlp_TMTimeVirtGetNano,
1886 pdmR3DevHlp_GetSupDrvSession,
1887 pdmR3DevHlp_QueryGenericUserObject,
1888 PDM_DEVHLPR3_VERSION /* the end */
1889};
1890
Note: See TracBrowser for help on using the repository browser.

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