VirtualBox

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

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

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