[92079] | 1 | /* $Id: tstDevicePdmDevHlpR0.cpp 98103 2023-01-17 14:15:46Z vboxsync $ */
|
---|
| 2 | /** @file
|
---|
| 3 | * tstDevice - Test framework for PDM devices/drivers, PDM fake R0 helper implementation.
|
---|
| 4 | */
|
---|
| 5 |
|
---|
| 6 | /*
|
---|
[98103] | 7 | * Copyright (C) 2021-2023 Oracle and/or its affiliates.
|
---|
[92079] | 8 | *
|
---|
[96407] | 9 | * This file is part of VirtualBox base platform packages, as
|
---|
| 10 | * available from https://www.virtualbox.org.
|
---|
| 11 | *
|
---|
| 12 | * This program is free software; you can redistribute it and/or
|
---|
| 13 | * modify it under the terms of the GNU General Public License
|
---|
| 14 | * as published by the Free Software Foundation, in version 3 of the
|
---|
| 15 | * License.
|
---|
| 16 | *
|
---|
| 17 | * This program is distributed in the hope that it will be useful, but
|
---|
| 18 | * WITHOUT ANY WARRANTY; without even the implied warranty of
|
---|
| 19 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
---|
| 20 | * General Public License for more details.
|
---|
| 21 | *
|
---|
| 22 | * You should have received a copy of the GNU General Public License
|
---|
| 23 | * along with this program; if not, see <https://www.gnu.org/licenses>.
|
---|
| 24 | *
|
---|
| 25 | * SPDX-License-Identifier: GPL-3.0-only
|
---|
[92079] | 26 | */
|
---|
| 27 |
|
---|
| 28 |
|
---|
| 29 | /*********************************************************************************************************************************
|
---|
| 30 | * Header Files *
|
---|
| 31 | *********************************************************************************************************************************/
|
---|
| 32 | #define LOG_GROUP LOG_GROUP_DEFAULT /** @todo */
|
---|
| 33 | #undef IN_RING3
|
---|
| 34 | #undef IN_SUP_R3
|
---|
| 35 | #define IN_RING0
|
---|
| 36 | #define IN_SUP_R0
|
---|
| 37 | #define LINUX_VERSION_CODE 0
|
---|
| 38 | #define KERNEL_VERSION(a,b,c) 1
|
---|
[93491] | 39 | #include <iprt/linux/version.h>
|
---|
[92079] | 40 | #include <VBox/types.h>
|
---|
| 41 | #include <VBox/version.h>
|
---|
| 42 | #include <VBox/vmm/pdmpci.h>
|
---|
| 43 |
|
---|
| 44 | #include <iprt/assert.h>
|
---|
| 45 | #include <iprt/mem.h>
|
---|
| 46 | #include <iprt/rand.h>
|
---|
| 47 | #include <iprt/string.h>
|
---|
| 48 |
|
---|
| 49 | #include "tstDeviceInternal.h"
|
---|
| 50 |
|
---|
| 51 |
|
---|
| 52 | /*********************************************************************************************************************************
|
---|
| 53 | * Defined Constants And Macros *
|
---|
| 54 | *********************************************************************************************************************************/
|
---|
| 55 |
|
---|
| 56 | /* Temporarily until the stubs got implemented. */
|
---|
| 57 | #define VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS 1
|
---|
| 58 |
|
---|
| 59 | /** @def PDMDEV_ASSERT_DEVINS
|
---|
| 60 | * Asserts the validity of the device instance.
|
---|
| 61 | */
|
---|
| 62 | #ifdef VBOX_STRICT
|
---|
| 63 | # define PDMDEV_ASSERT_DEVINS(pDevIns) \
|
---|
| 64 | do { \
|
---|
| 65 | AssertPtr(pDevIns); \
|
---|
| 66 | Assert(pDevIns->u32Version == PDM_DEVINS_VERSION); \
|
---|
| 67 | Assert(pDevIns->CTX_SUFF(pvInstanceDataFor) == (void *)&pDevIns->achInstanceData[0]); \
|
---|
| 68 | } while (0)
|
---|
| 69 | #else
|
---|
| 70 | # define PDMDEV_ASSERT_DEVINS(pDevIns) do { } while (0)
|
---|
| 71 | #endif
|
---|
| 72 |
|
---|
| 73 |
|
---|
| 74 | /** Frequency of the real clock. */
|
---|
| 75 | #define TMCLOCK_FREQ_REAL UINT32_C(1000)
|
---|
| 76 | /** Frequency of the virtual clock. */
|
---|
| 77 | #define TMCLOCK_FREQ_VIRTUAL UINT32_C(1000000000)
|
---|
| 78 |
|
---|
| 79 | #undef RT_VALID_PTR
|
---|
| 80 | #define RT_VALID_PTR(ptr) true
|
---|
| 81 |
|
---|
[92081] | 82 |
|
---|
[92079] | 83 | /*********************************************************************************************************************************
|
---|
| 84 | * Structures and Typedefs *
|
---|
| 85 | *********************************************************************************************************************************/
|
---|
| 86 |
|
---|
| 87 |
|
---|
| 88 |
|
---|
| 89 | /*********************************************************************************************************************************
|
---|
| 90 | * Global Variables *
|
---|
| 91 | *********************************************************************************************************************************/
|
---|
| 92 |
|
---|
| 93 |
|
---|
| 94 |
|
---|
| 95 | /*********************************************************************************************************************************
|
---|
| 96 | * Internal Functions *
|
---|
| 97 | *********************************************************************************************************************************/
|
---|
| 98 |
|
---|
| 99 | /** @interface_method_impl{PDMDEVHLPR0,pfnIoPortSetUpContextEx} */
|
---|
| 100 | static DECLCALLBACK(int) pdmR0DevHlp_IoPortSetUpContextEx(PPDMDEVINS pDevIns, IOMIOPORTHANDLE hIoPorts,
|
---|
| 101 | PFNIOMIOPORTNEWOUT pfnOut, PFNIOMIOPORTNEWIN pfnIn,
|
---|
| 102 | PFNIOMIOPORTNEWOUTSTRING pfnOutStr, PFNIOMIOPORTNEWINSTRING pfnInStr,
|
---|
| 103 | void *pvUser)
|
---|
| 104 | {
|
---|
| 105 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 106 | LogFlow(("pdmR0DevHlp_IoPortSetUpContextEx: caller='%s'/%d: hIoPorts=%#x pfnOut=%p pfnIn=%p pfnOutStr=%p pfnInStr=%p pvUser=%p\n",
|
---|
| 107 | pDevIns->pReg->szName, pDevIns->iInstance, hIoPorts, pfnOut, pfnIn, pfnOutStr, pfnInStr, pvUser));
|
---|
| 108 |
|
---|
[92124] | 109 | int rc = VINF_SUCCESS;
|
---|
| 110 | PRTDEVDUTIOPORT pIoPort = (PRTDEVDUTIOPORT)hIoPorts;
|
---|
| 111 | if (RT_LIKELY(pIoPort))
|
---|
| 112 | {
|
---|
| 113 | pIoPort->pvUserR0 = pvUser;
|
---|
| 114 | pIoPort->pfnOutR0 = pfnOut;
|
---|
| 115 | pIoPort->pfnInR0 = pfnIn;
|
---|
| 116 | pIoPort->pfnOutStrR0 = pfnOutStr;
|
---|
| 117 | pIoPort->pfnInStrR0 = pfnInStr;
|
---|
| 118 | }
|
---|
| 119 | else
|
---|
| 120 | AssertReleaseFailed();
|
---|
[92079] | 121 |
|
---|
| 122 | LogFlow(("pdmR0DevHlp_IoPortSetUpContextEx: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
|
---|
| 123 | return rc;
|
---|
| 124 | }
|
---|
| 125 |
|
---|
| 126 |
|
---|
| 127 | /** @interface_method_impl{PDMDEVHLPR0,pfnMmioSetUpContextEx} */
|
---|
| 128 | static DECLCALLBACK(int) pdmR0DevHlp_MmioSetUpContextEx(PPDMDEVINS pDevIns, IOMMMIOHANDLE hRegion, PFNIOMMMIONEWWRITE pfnWrite,
|
---|
| 129 | PFNIOMMMIONEWREAD pfnRead, PFNIOMMMIONEWFILL pfnFill, void *pvUser)
|
---|
| 130 | {
|
---|
| 131 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 132 | LogFlow(("pdmR0DevHlp_MmioSetUpContextEx: caller='%s'/%d: hRegion=%#x pfnWrite=%p pfnRead=%p pfnFill=%p pvUser=%p\n",
|
---|
| 133 | pDevIns->pReg->szName, pDevIns->iInstance, hRegion, pfnWrite, pfnRead, pfnFill, pvUser));
|
---|
| 134 |
|
---|
[92124] | 135 | int rc = VINF_SUCCESS;
|
---|
| 136 | PRTDEVDUTMMIO pMmio = (PRTDEVDUTMMIO)hRegion;
|
---|
| 137 | if (RT_LIKELY(pMmio))
|
---|
| 138 | {
|
---|
| 139 | pMmio->pvUserR0 = pvUser;
|
---|
| 140 | pMmio->pfnWriteR0 = pfnWrite;
|
---|
| 141 | pMmio->pfnReadR0 = pfnRead;
|
---|
| 142 | pMmio->pfnFillR0 = pfnFill;
|
---|
| 143 | }
|
---|
| 144 | else
|
---|
| 145 | AssertReleaseFailed();
|
---|
[92079] | 146 |
|
---|
| 147 | LogFlow(("pdmR0DevHlp_MmioSetUpContextEx: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
|
---|
| 148 | return rc;
|
---|
| 149 | }
|
---|
| 150 |
|
---|
| 151 |
|
---|
| 152 | /** @interface_method_impl{PDMDEVHLPR0,pfnMmio2SetUpContext} */
|
---|
| 153 | static DECLCALLBACK(int) pdmR0DevHlp_Mmio2SetUpContext(PPDMDEVINS pDevIns, PGMMMIO2HANDLE hRegion,
|
---|
| 154 | size_t offSub, size_t cbSub, void **ppvMapping)
|
---|
| 155 | {
|
---|
| 156 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 157 | LogFlow(("pdmR0DevHlp_Mmio2SetUpContext: caller='%s'/%d: hRegion=%#x offSub=%#zx cbSub=%#zx ppvMapping=%p\n",
|
---|
| 158 | pDevIns->pReg->szName, pDevIns->iInstance, hRegion, offSub, cbSub, ppvMapping));
|
---|
| 159 | *ppvMapping = NULL;
|
---|
| 160 |
|
---|
| 161 | int rc = VERR_NOT_IMPLEMENTED;
|
---|
| 162 | AssertFailed();
|
---|
| 163 |
|
---|
| 164 | LogFlow(("pdmR0DevHlp_Mmio2SetUpContext: caller='%s'/%d: returns %Rrc (%p)\n", pDevIns->pReg->szName, pDevIns->iInstance, rc, *ppvMapping));
|
---|
| 165 | return rc;
|
---|
| 166 | }
|
---|
| 167 |
|
---|
| 168 |
|
---|
| 169 | /** @interface_method_impl{PDMDEVHLPR0,pfnPCIPhysRead} */
|
---|
| 170 | static DECLCALLBACK(int) pdmR0DevHlp_PCIPhysRead(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, RTGCPHYS GCPhys,
|
---|
| 171 | void *pvBuf, size_t cbRead, uint32_t fFlags)
|
---|
| 172 | {
|
---|
| 173 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 174 | if (!pPciDev) /* NULL is an alias for the default PCI device. */
|
---|
| 175 | pPciDev = pDevIns->apPciDevs[0];
|
---|
| 176 | AssertReturn(pPciDev, VERR_PDM_NOT_PCI_DEVICE);
|
---|
| 177 | PDMPCIDEV_ASSERT_VALID_AND_REGISTERED(pDevIns, pPciDev);
|
---|
| 178 |
|
---|
| 179 | #ifndef PDM_DO_NOT_RESPECT_PCI_BM_BIT
|
---|
| 180 | /*
|
---|
| 181 | * Just check the busmaster setting here and forward the request to the generic read helper.
|
---|
| 182 | */
|
---|
| 183 | if (PCIDevIsBusmaster(pPciDev))
|
---|
| 184 | { /* likely */ }
|
---|
| 185 | else
|
---|
| 186 | {
|
---|
| 187 | LogFunc(("caller=%p/%d: returns %Rrc - Not bus master! GCPhys=%RGp cbRead=%#zx\n", pDevIns, pDevIns->iInstance,
|
---|
| 188 | VERR_PDM_NOT_PCI_BUS_MASTER, GCPhys, cbRead));
|
---|
| 189 | memset(pvBuf, 0xff, cbRead);
|
---|
| 190 | return VERR_PDM_NOT_PCI_BUS_MASTER;
|
---|
| 191 | }
|
---|
| 192 | #endif
|
---|
| 193 |
|
---|
| 194 | return pDevIns->pHlpR0->pfnPhysRead(pDevIns, GCPhys, pvBuf, cbRead, fFlags);
|
---|
| 195 | }
|
---|
| 196 |
|
---|
| 197 |
|
---|
| 198 | /** @interface_method_impl{PDMDEVHLPR0,pfnPCIPhysWrite} */
|
---|
| 199 | static DECLCALLBACK(int) pdmR0DevHlp_PCIPhysWrite(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, RTGCPHYS GCPhys,
|
---|
| 200 | const void *pvBuf, size_t cbWrite, uint32_t fFlags)
|
---|
| 201 | {
|
---|
| 202 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 203 | if (!pPciDev) /* NULL is an alias for the default PCI device. */
|
---|
| 204 | pPciDev = pDevIns->apPciDevs[0];
|
---|
| 205 | AssertReturn(pPciDev, VERR_PDM_NOT_PCI_DEVICE);
|
---|
| 206 | PDMPCIDEV_ASSERT_VALID_AND_REGISTERED(pDevIns, pPciDev);
|
---|
| 207 |
|
---|
| 208 | #ifndef PDM_DO_NOT_RESPECT_PCI_BM_BIT
|
---|
| 209 | /*
|
---|
| 210 | * Just check the busmaster setting here and forward the request to the generic read helper.
|
---|
| 211 | */
|
---|
| 212 | if (PCIDevIsBusmaster(pPciDev))
|
---|
| 213 | { /* likely */ }
|
---|
| 214 | else
|
---|
| 215 | {
|
---|
| 216 | LogFunc(("caller=%p/%d: returns %Rrc - Not bus master! GCPhys=%RGp cbWrite=%#zx\n", pDevIns, pDevIns->iInstance,
|
---|
| 217 | VERR_PDM_NOT_PCI_BUS_MASTER, GCPhys, cbWrite));
|
---|
| 218 | return VERR_PDM_NOT_PCI_BUS_MASTER;
|
---|
| 219 | }
|
---|
| 220 | #endif
|
---|
| 221 |
|
---|
| 222 | return pDevIns->pHlpR0->pfnPhysWrite(pDevIns, GCPhys, pvBuf, cbWrite, fFlags);
|
---|
| 223 | }
|
---|
| 224 |
|
---|
| 225 |
|
---|
| 226 | /** @interface_method_impl{PDMDEVHLPR0,pfnPCISetIrq} */
|
---|
| 227 | static DECLCALLBACK(void) pdmR0DevHlp_PCISetIrq(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, int iIrq, int iLevel)
|
---|
| 228 | {
|
---|
| 229 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 230 | if (!pPciDev) /* NULL is an alias for the default PCI device. */
|
---|
| 231 | pPciDev = pDevIns->apPciDevs[0];
|
---|
| 232 | AssertReturnVoid(pPciDev);
|
---|
| 233 | LogFlow(("pdmR0DevHlp_PCISetIrq: caller=%p/%d: pPciDev=%p:{%#x} iIrq=%d iLevel=%d\n",
|
---|
| 234 | pDevIns, pDevIns->iInstance, pPciDev, pPciDev->uDevFn, iIrq, iLevel));
|
---|
| 235 | PDMPCIDEV_ASSERT_VALID_AND_REGISTERED(pDevIns, pPciDev);
|
---|
| 236 |
|
---|
| 237 | AssertFailed();
|
---|
| 238 |
|
---|
| 239 | LogFlow(("pdmR0DevHlp_PCISetIrq: caller=%p/%d: returns void; uTagSrc=%#x\n", pDevIns, pDevIns->iInstance, 0 /*uTagSrc*/));
|
---|
| 240 | }
|
---|
| 241 |
|
---|
| 242 |
|
---|
| 243 | /** @interface_method_impl{PDMDEVHLPR0,pfnISASetIrq} */
|
---|
| 244 | static DECLCALLBACK(void) pdmR0DevHlp_ISASetIrq(PPDMDEVINS pDevIns, int iIrq, int iLevel)
|
---|
| 245 | {
|
---|
| 246 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 247 | LogFlow(("pdmR0DevHlp_ISASetIrq: caller=%p/%d: iIrq=%d iLevel=%d\n", pDevIns, pDevIns->iInstance, iIrq, iLevel));
|
---|
| 248 |
|
---|
| 249 | AssertFailed();
|
---|
| 250 |
|
---|
| 251 | LogFlow(("pdmR0DevHlp_ISASetIrq: caller=%p/%d: returns void; uTagSrc=%#x\n", pDevIns, pDevIns->iInstance, 0 /*uTagSrc*/));
|
---|
| 252 | }
|
---|
| 253 |
|
---|
| 254 |
|
---|
| 255 | /** @interface_method_impl{PDMDEVHLPR0,pfnPhysRead} */
|
---|
| 256 | static DECLCALLBACK(int) pdmR0DevHlp_PhysRead(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, void *pvBuf, size_t cbRead, uint32_t fFlags)
|
---|
| 257 | {
|
---|
| 258 | RT_NOREF(fFlags);
|
---|
| 259 |
|
---|
| 260 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 261 | LogFlow(("pdmR0DevHlp_PhysRead: caller=%p/%d: GCPhys=%RGp pvBuf=%p cbRead=%#x\n",
|
---|
| 262 | pDevIns, pDevIns->iInstance, GCPhys, pvBuf, cbRead));
|
---|
| 263 |
|
---|
| 264 | VBOXSTRICTRC rcStrict = VERR_NOT_IMPLEMENTED;
|
---|
| 265 | AssertFailed();
|
---|
| 266 |
|
---|
| 267 | Log(("pdmR0DevHlp_PhysRead: caller=%p/%d: returns %Rrc\n", pDevIns, pDevIns->iInstance, VBOXSTRICTRC_VAL(rcStrict) ));
|
---|
| 268 | return VBOXSTRICTRC_VAL(rcStrict);
|
---|
| 269 | }
|
---|
| 270 |
|
---|
| 271 |
|
---|
| 272 | /** @interface_method_impl{PDMDEVHLPR0,pfnPhysWrite} */
|
---|
| 273 | static DECLCALLBACK(int) pdmR0DevHlp_PhysWrite(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, const void *pvBuf, size_t cbWrite, uint32_t fFlags)
|
---|
| 274 | {
|
---|
| 275 | RT_NOREF(fFlags);
|
---|
| 276 |
|
---|
| 277 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 278 | LogFlow(("pdmR0DevHlp_PhysWrite: caller=%p/%d: GCPhys=%RGp pvBuf=%p cbWrite=%#x\n",
|
---|
| 279 | pDevIns, pDevIns->iInstance, GCPhys, pvBuf, cbWrite));
|
---|
| 280 |
|
---|
| 281 | VBOXSTRICTRC rcStrict = VERR_NOT_IMPLEMENTED;
|
---|
| 282 | AssertFailed();
|
---|
| 283 |
|
---|
| 284 | Log(("pdmR0DevHlp_PhysWrite: caller=%p/%d: returns %Rrc\n", pDevIns, pDevIns->iInstance, VBOXSTRICTRC_VAL(rcStrict) ));
|
---|
| 285 | return VBOXSTRICTRC_VAL(rcStrict);
|
---|
| 286 | }
|
---|
| 287 |
|
---|
| 288 |
|
---|
| 289 | /** @interface_method_impl{PDMDEVHLPR0,pfnA20IsEnabled} */
|
---|
| 290 | static DECLCALLBACK(bool) pdmR0DevHlp_A20IsEnabled(PPDMDEVINS pDevIns)
|
---|
| 291 | {
|
---|
| 292 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 293 | LogFlow(("pdmR0DevHlp_A20IsEnabled: caller=%p/%d:\n", pDevIns, pDevIns->iInstance));
|
---|
| 294 |
|
---|
| 295 | bool fEnabled = false;
|
---|
| 296 | AssertFailed();
|
---|
| 297 |
|
---|
| 298 | Log(("pdmR0DevHlp_A20IsEnabled: caller=%p/%d: returns %RTbool\n", pDevIns, pDevIns->iInstance, fEnabled));
|
---|
| 299 | return fEnabled;
|
---|
| 300 | }
|
---|
| 301 |
|
---|
| 302 |
|
---|
| 303 | /** @interface_method_impl{PDMDEVHLPR0,pfnVMState} */
|
---|
| 304 | static DECLCALLBACK(VMSTATE) pdmR0DevHlp_VMState(PPDMDEVINS pDevIns)
|
---|
| 305 | {
|
---|
| 306 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 307 |
|
---|
| 308 | VMSTATE enmVMState = VMSTATE_CREATING;// pDevIns->Internal.s.pGVM->enmVMState;
|
---|
| 309 |
|
---|
| 310 | LogFlow(("pdmR0DevHlp_VMState: caller=%p/%d: returns %d\n", pDevIns, pDevIns->iInstance, enmVMState));
|
---|
| 311 | return enmVMState;
|
---|
| 312 | }
|
---|
| 313 |
|
---|
| 314 |
|
---|
| 315 | /** @interface_method_impl{PDMDEVHLPR0,pfnGetVM} */
|
---|
| 316 | static DECLCALLBACK(PVMCC) pdmR0DevHlp_GetVM(PPDMDEVINS pDevIns)
|
---|
| 317 | {
|
---|
| 318 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 319 | LogFlow(("pdmR0DevHlp_GetVM: caller='%p'/%d\n", pDevIns, pDevIns->iInstance));
|
---|
| 320 | AssertFailed();
|
---|
| 321 | return NULL; //pDevIns->Internal.s.pGVM;
|
---|
| 322 | }
|
---|
| 323 |
|
---|
| 324 |
|
---|
| 325 | /** @interface_method_impl{PDMDEVHLPR0,pfnGetVMCPU} */
|
---|
| 326 | static DECLCALLBACK(PVMCPUCC) pdmR0DevHlp_GetVMCPU(PPDMDEVINS pDevIns)
|
---|
| 327 | {
|
---|
| 328 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 329 | LogFlow(("pdmR0DevHlp_GetVMCPU: caller='%p'/%d\n", pDevIns, pDevIns->iInstance));
|
---|
| 330 | AssertFailed();
|
---|
| 331 | return NULL; //VMMGetCpu(pDevIns->Internal.s.pGVM);
|
---|
| 332 | }
|
---|
| 333 |
|
---|
| 334 |
|
---|
| 335 | /** @interface_method_impl{PDMDEVHLPRC,pfnGetCurrentCpuId} */
|
---|
| 336 | static DECLCALLBACK(VMCPUID) pdmR0DevHlp_GetCurrentCpuId(PPDMDEVINS pDevIns)
|
---|
| 337 | {
|
---|
| 338 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 339 | LogFlow(("pdmR0DevHlp_GetCurrentCpuId: caller='%p'/%d for CPU %u\n", pDevIns, pDevIns->iInstance, 0 /*idCpu*/));
|
---|
| 340 | AssertFailed();
|
---|
| 341 | return 0; //idCpu;
|
---|
| 342 | }
|
---|
| 343 |
|
---|
| 344 |
|
---|
[93110] | 345 | /** @interface_method_impl{PDMDEVHLPR0,pfnGetMainExecutionEngine} */
|
---|
| 346 | static DECLCALLBACK(uint8_t) pdmR0DevHlp_GetMainExecutionEngine(PPDMDEVINS pDevIns)
|
---|
| 347 | {
|
---|
| 348 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 349 | LogFlow(("pdmR0DevHlp_GetMainExecutionEngine: caller='%s'/%d:\n", pDevIns->pReg->szName, pDevIns->iInstance));
|
---|
| 350 | return VM_EXEC_ENGINE_NOT_SET;
|
---|
| 351 | }
|
---|
| 352 |
|
---|
| 353 |
|
---|
[92079] | 354 | /** @interface_method_impl{PDMDEVHLPR0,pfnTimerFromMicro} */
|
---|
| 355 | static DECLCALLBACK(uint64_t) pdmR0DevHlp_TimerFromMicro(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cMicroSecs)
|
---|
| 356 | {
|
---|
| 357 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 358 | AssertFailed();
|
---|
| 359 | return 0; //TMTimerFromMicro(pDevIns->Internal.s.pGVM, hTimer, cMicroSecs);
|
---|
| 360 | }
|
---|
| 361 |
|
---|
| 362 |
|
---|
| 363 | /** @interface_method_impl{PDMDEVHLPR0,pfnTimerFromMilli} */
|
---|
| 364 | static DECLCALLBACK(uint64_t) pdmR0DevHlp_TimerFromMilli(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cMilliSecs)
|
---|
| 365 | {
|
---|
| 366 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 367 | AssertFailed();
|
---|
| 368 | return 0;
|
---|
| 369 | }
|
---|
| 370 |
|
---|
| 371 |
|
---|
| 372 | /** @interface_method_impl{PDMDEVHLPR0,pfnTimerFromNano} */
|
---|
| 373 | static DECLCALLBACK(uint64_t) pdmR0DevHlp_TimerFromNano(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cNanoSecs)
|
---|
| 374 | {
|
---|
| 375 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 376 | AssertFailed();
|
---|
| 377 | return 0;
|
---|
| 378 | }
|
---|
| 379 |
|
---|
| 380 | /** @interface_method_impl{PDMDEVHLPR0,pfnTimerGet} */
|
---|
| 381 | static DECLCALLBACK(uint64_t) pdmR0DevHlp_TimerGet(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
|
---|
| 382 | {
|
---|
| 383 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 384 | AssertFailed();
|
---|
| 385 | return 0;
|
---|
| 386 | }
|
---|
| 387 |
|
---|
| 388 |
|
---|
| 389 | /** @interface_method_impl{PDMDEVHLPR0,pfnTimerGetFreq} */
|
---|
| 390 | static DECLCALLBACK(uint64_t) pdmR0DevHlp_TimerGetFreq(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
|
---|
| 391 | {
|
---|
| 392 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 393 | AssertFailed();
|
---|
| 394 | return 0;
|
---|
| 395 | }
|
---|
| 396 |
|
---|
| 397 |
|
---|
| 398 | /** @interface_method_impl{PDMDEVHLPR0,pfnTimerGetNano} */
|
---|
| 399 | static DECLCALLBACK(uint64_t) pdmR0DevHlp_TimerGetNano(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
|
---|
| 400 | {
|
---|
| 401 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 402 | AssertFailed();
|
---|
| 403 | return 0;
|
---|
| 404 | }
|
---|
| 405 |
|
---|
| 406 |
|
---|
| 407 | /** @interface_method_impl{PDMDEVHLPR0,pfnTimerIsActive} */
|
---|
| 408 | static DECLCALLBACK(bool) pdmR0DevHlp_TimerIsActive(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
|
---|
| 409 | {
|
---|
| 410 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 411 | AssertFailed();
|
---|
| 412 | return false;
|
---|
| 413 | }
|
---|
| 414 |
|
---|
| 415 |
|
---|
| 416 | /** @interface_method_impl{PDMDEVHLPR0,pfnTimerIsLockOwner} */
|
---|
| 417 | static DECLCALLBACK(bool) pdmR0DevHlp_TimerIsLockOwner(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
|
---|
| 418 | {
|
---|
| 419 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 420 | AssertFailed();
|
---|
| 421 | return false;
|
---|
| 422 | }
|
---|
| 423 |
|
---|
| 424 |
|
---|
| 425 | /** @interface_method_impl{PDMDEVHLPR0,pfnTimerLockClock} */
|
---|
| 426 | static DECLCALLBACK(VBOXSTRICTRC) pdmR0DevHlp_TimerLockClock(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, int rcBusy)
|
---|
| 427 | {
|
---|
| 428 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 429 | AssertFailed();
|
---|
| 430 | return VERR_NOT_IMPLEMENTED;
|
---|
| 431 | }
|
---|
| 432 |
|
---|
| 433 |
|
---|
| 434 | /** @interface_method_impl{PDMDEVHLPR0,pfnTimerLockClock2} */
|
---|
| 435 | static DECLCALLBACK(VBOXSTRICTRC) pdmR0DevHlp_TimerLockClock2(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer,
|
---|
| 436 | PPDMCRITSECT pCritSect, int rcBusy)
|
---|
| 437 | {
|
---|
| 438 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 439 | AssertFailed();
|
---|
| 440 | return VERR_NOT_IMPLEMENTED;
|
---|
| 441 | }
|
---|
| 442 |
|
---|
| 443 |
|
---|
| 444 | /** @interface_method_impl{PDMDEVHLPR0,pfnTimerSet} */
|
---|
| 445 | static DECLCALLBACK(int) pdmR0DevHlp_TimerSet(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t uExpire)
|
---|
| 446 | {
|
---|
| 447 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 448 | AssertFailed();
|
---|
| 449 | return VERR_NOT_IMPLEMENTED;
|
---|
| 450 | }
|
---|
| 451 |
|
---|
| 452 |
|
---|
| 453 | /** @interface_method_impl{PDMDEVHLPR0,pfnTimerSetFrequencyHint} */
|
---|
| 454 | static DECLCALLBACK(int) pdmR0DevHlp_TimerSetFrequencyHint(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint32_t uHz)
|
---|
| 455 | {
|
---|
| 456 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 457 | AssertFailed();
|
---|
| 458 | return VERR_NOT_IMPLEMENTED;
|
---|
| 459 | }
|
---|
| 460 |
|
---|
| 461 |
|
---|
| 462 | /** @interface_method_impl{PDMDEVHLPR0,pfnTimerSetMicro} */
|
---|
| 463 | static DECLCALLBACK(int) pdmR0DevHlp_TimerSetMicro(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cMicrosToNext)
|
---|
| 464 | {
|
---|
| 465 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 466 | AssertFailed();
|
---|
| 467 | return VERR_NOT_IMPLEMENTED;
|
---|
| 468 | }
|
---|
| 469 |
|
---|
| 470 |
|
---|
| 471 | /** @interface_method_impl{PDMDEVHLPR0,pfnTimerSetMillies} */
|
---|
| 472 | static DECLCALLBACK(int) pdmR0DevHlp_TimerSetMillies(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cMilliesToNext)
|
---|
| 473 | {
|
---|
| 474 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 475 | AssertFailed();
|
---|
| 476 | return VERR_NOT_IMPLEMENTED;
|
---|
| 477 | }
|
---|
| 478 |
|
---|
| 479 |
|
---|
| 480 | /** @interface_method_impl{PDMDEVHLPR0,pfnTimerSetNano} */
|
---|
| 481 | static DECLCALLBACK(int) pdmR0DevHlp_TimerSetNano(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cNanosToNext)
|
---|
| 482 | {
|
---|
| 483 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 484 | AssertFailed();
|
---|
| 485 | return VERR_NOT_IMPLEMENTED;
|
---|
| 486 | }
|
---|
| 487 |
|
---|
| 488 |
|
---|
| 489 | /** @interface_method_impl{PDMDEVHLPR0,pfnTimerSetRelative} */
|
---|
| 490 | static DECLCALLBACK(int) pdmR0DevHlp_TimerSetRelative(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cTicksToNext, uint64_t *pu64Now)
|
---|
| 491 | {
|
---|
| 492 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 493 | AssertFailed();
|
---|
| 494 | return VERR_NOT_IMPLEMENTED;
|
---|
| 495 | }
|
---|
| 496 |
|
---|
| 497 |
|
---|
| 498 | /** @interface_method_impl{PDMDEVHLPR0,pfnTimerStop} */
|
---|
| 499 | static DECLCALLBACK(int) pdmR0DevHlp_TimerStop(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
|
---|
| 500 | {
|
---|
| 501 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 502 | AssertFailed();
|
---|
| 503 | return VERR_NOT_IMPLEMENTED;
|
---|
| 504 | }
|
---|
| 505 |
|
---|
| 506 |
|
---|
| 507 | /** @interface_method_impl{PDMDEVHLPR0,pfnTimerUnlockClock} */
|
---|
| 508 | static DECLCALLBACK(void) pdmR0DevHlp_TimerUnlockClock(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
|
---|
| 509 | {
|
---|
| 510 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 511 | AssertFailed();
|
---|
| 512 | }
|
---|
| 513 |
|
---|
| 514 |
|
---|
| 515 | /** @interface_method_impl{PDMDEVHLPR0,pfnTimerUnlockClock2} */
|
---|
| 516 | static DECLCALLBACK(void) pdmR0DevHlp_TimerUnlockClock2(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, PPDMCRITSECT pCritSect)
|
---|
| 517 | {
|
---|
| 518 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 519 | AssertFailed();
|
---|
| 520 | }
|
---|
| 521 |
|
---|
| 522 |
|
---|
| 523 | /** @interface_method_impl{PDMDEVHLPR0,pfnTMTimeVirtGet} */
|
---|
| 524 | static DECLCALLBACK(uint64_t) pdmR0DevHlp_TMTimeVirtGet(PPDMDEVINS pDevIns)
|
---|
| 525 | {
|
---|
| 526 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 527 | LogFlow(("pdmR0DevHlp_TMTimeVirtGet: caller='%p'/%d\n", pDevIns, pDevIns->iInstance));
|
---|
| 528 | AssertFailed();
|
---|
| 529 | return 0;
|
---|
| 530 | }
|
---|
| 531 |
|
---|
| 532 |
|
---|
| 533 | /** @interface_method_impl{PDMDEVHLPR0,pfnTMTimeVirtGetFreq} */
|
---|
| 534 | static DECLCALLBACK(uint64_t) pdmR0DevHlp_TMTimeVirtGetFreq(PPDMDEVINS pDevIns)
|
---|
| 535 | {
|
---|
| 536 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 537 | LogFlow(("pdmR0DevHlp_TMTimeVirtGetFreq: caller='%p'/%d\n", pDevIns, pDevIns->iInstance));
|
---|
| 538 | AssertFailed();
|
---|
| 539 | return 0;
|
---|
| 540 | }
|
---|
| 541 |
|
---|
| 542 |
|
---|
| 543 | /** @interface_method_impl{PDMDEVHLPR0,pfnTMTimeVirtGetNano} */
|
---|
| 544 | static DECLCALLBACK(uint64_t) pdmR0DevHlp_TMTimeVirtGetNano(PPDMDEVINS pDevIns)
|
---|
| 545 | {
|
---|
| 546 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 547 | LogFlow(("pdmR0DevHlp_TMTimeVirtGetNano: caller='%p'/%d\n", pDevIns, pDevIns->iInstance));
|
---|
| 548 | AssertFailed();
|
---|
| 549 | return 0;
|
---|
| 550 | }
|
---|
| 551 |
|
---|
| 552 |
|
---|
| 553 | /** Converts a queue handle to a ring-0 queue pointer. */
|
---|
| 554 | DECLINLINE(PPDMQUEUE) pdmR0DevHlp_QueueToPtr(PPDMDEVINS pDevIns, PDMQUEUEHANDLE hQueue)
|
---|
| 555 | {
|
---|
| 556 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 557 | AssertFailed();
|
---|
| 558 | return NULL;
|
---|
| 559 | }
|
---|
| 560 |
|
---|
| 561 |
|
---|
| 562 | /** @interface_method_impl{PDMDEVHLPR0,pfnQueueAlloc} */
|
---|
| 563 | static DECLCALLBACK(PPDMQUEUEITEMCORE) pdmR0DevHlp_QueueAlloc(PPDMDEVINS pDevIns, PDMQUEUEHANDLE hQueue)
|
---|
| 564 | {
|
---|
| 565 | AssertFailed();
|
---|
| 566 | return NULL; //PDMQueueAlloc(pdmR0DevHlp_QueueToPtr(pDevIns, hQueue));
|
---|
| 567 | }
|
---|
| 568 |
|
---|
| 569 |
|
---|
| 570 | /** @interface_method_impl{PDMDEVHLPR0,pfnQueueInsert} */
|
---|
| 571 | static DECLCALLBACK(void) pdmR0DevHlp_QueueInsert(PPDMDEVINS pDevIns, PDMQUEUEHANDLE hQueue, PPDMQUEUEITEMCORE pItem)
|
---|
| 572 | {
|
---|
| 573 | AssertFailed();
|
---|
| 574 | //return PDMQueueInsert(pdmR0DevHlp_QueueToPtr(pDevIns, hQueue), pItem);
|
---|
| 575 | }
|
---|
| 576 |
|
---|
| 577 |
|
---|
| 578 | /** @interface_method_impl{PDMDEVHLPR0,pfnQueueFlushIfNecessary} */
|
---|
| 579 | static DECLCALLBACK(bool) pdmR0DevHlp_QueueFlushIfNecessary(PPDMDEVINS pDevIns, PDMQUEUEHANDLE hQueue)
|
---|
| 580 | {
|
---|
| 581 | AssertFailed();
|
---|
| 582 | return false; //PDMQueueFlushIfNecessary(pdmR0DevHlp_QueueToPtr(pDevIns, hQueue));
|
---|
| 583 | }
|
---|
| 584 |
|
---|
| 585 |
|
---|
| 586 | /** @interface_method_impl{PDMDEVHLPR0,pfnTaskTrigger} */
|
---|
| 587 | static DECLCALLBACK(int) pdmR0DevHlp_TaskTrigger(PPDMDEVINS pDevIns, PDMTASKHANDLE hTask)
|
---|
| 588 | {
|
---|
| 589 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 590 | LogFlow(("pdmR0DevHlp_TaskTrigger: caller='%s'/%d: hTask=%RU64\n", pDevIns->pReg->szName, pDevIns->iInstance, hTask));
|
---|
| 591 |
|
---|
| 592 | AssertFailed();
|
---|
| 593 | int rc = VERR_NOT_IMPLEMENTED; //PDMTaskTrigger(pDevIns->Internal.s.pGVM, PDMTASKTYPE_DEV, pDevIns->pDevInsForR3, hTask);
|
---|
| 594 |
|
---|
| 595 | LogFlow(("pdmR0DevHlp_TaskTrigger: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
|
---|
| 596 | return rc;
|
---|
| 597 | }
|
---|
| 598 |
|
---|
| 599 |
|
---|
| 600 | /** @interface_method_impl{PDMDEVHLPR0,pfnSUPSemEventSignal} */
|
---|
| 601 | static DECLCALLBACK(int) pdmR0DevHlp_SUPSemEventSignal(PPDMDEVINS pDevIns, SUPSEMEVENT hEvent)
|
---|
| 602 | {
|
---|
| 603 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 604 | LogFlow(("pdmR0DevHlp_SUPSemEventSignal: caller='%s'/%d: hEvent=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, hEvent));
|
---|
| 605 |
|
---|
| 606 | AssertFailed();
|
---|
| 607 | int rc = VERR_NOT_IMPLEMENTED; //SUPSemEventSignal(pDevIns->Internal.s.pGVM->pSession, hEvent);
|
---|
| 608 |
|
---|
| 609 | LogFlow(("pdmR0DevHlp_SUPSemEventSignal: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
|
---|
| 610 | return rc;
|
---|
| 611 | }
|
---|
| 612 |
|
---|
| 613 |
|
---|
| 614 | /** @interface_method_impl{PDMDEVHLPR0,pfnSUPSemEventWaitNoResume} */
|
---|
| 615 | static DECLCALLBACK(int) pdmR0DevHlp_SUPSemEventWaitNoResume(PPDMDEVINS pDevIns, SUPSEMEVENT hEvent, uint32_t cMillies)
|
---|
| 616 | {
|
---|
| 617 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 618 | LogFlow(("pdmR0DevHlp_SUPSemEventWaitNoResume: caller='%s'/%d: hEvent=%p cNsTimeout=%RU32\n",
|
---|
| 619 | pDevIns->pReg->szName, pDevIns->iInstance, hEvent, cMillies));
|
---|
| 620 |
|
---|
| 621 | AssertFailed();
|
---|
| 622 | int rc = VERR_NOT_IMPLEMENTED; //SUPSemEventWaitNoResume(pDevIns->Internal.s.pGVM->pSession, hEvent, cMillies);
|
---|
| 623 |
|
---|
| 624 | LogFlow(("pdmR0DevHlp_SUPSemEventWaitNoResume: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
|
---|
| 625 | return rc;
|
---|
| 626 | }
|
---|
| 627 |
|
---|
| 628 |
|
---|
| 629 | /** @interface_method_impl{PDMDEVHLPR0,pfnSUPSemEventWaitNsAbsIntr} */
|
---|
| 630 | static DECLCALLBACK(int) pdmR0DevHlp_SUPSemEventWaitNsAbsIntr(PPDMDEVINS pDevIns, SUPSEMEVENT hEvent, uint64_t uNsTimeout)
|
---|
| 631 | {
|
---|
| 632 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 633 | LogFlow(("pdmR0DevHlp_SUPSemEventWaitNsAbsIntr: caller='%s'/%d: hEvent=%p uNsTimeout=%RU64\n",
|
---|
| 634 | pDevIns->pReg->szName, pDevIns->iInstance, hEvent, uNsTimeout));
|
---|
| 635 |
|
---|
| 636 | AssertFailed();
|
---|
| 637 | int rc = VERR_NOT_IMPLEMENTED; //SUPSemEventWaitNsAbsIntr(pDevIns->Internal.s.pGVM->pSession, hEvent, uNsTimeout);
|
---|
| 638 |
|
---|
| 639 | LogFlow(("pdmR0DevHlp_SUPSemEventWaitNsAbsIntr: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
|
---|
| 640 | return rc;
|
---|
| 641 | }
|
---|
| 642 |
|
---|
| 643 |
|
---|
| 644 | /** @interface_method_impl{PDMDEVHLPR0,pfnSUPSemEventWaitNsRelIntr} */
|
---|
| 645 | static DECLCALLBACK(int) pdmR0DevHlp_SUPSemEventWaitNsRelIntr(PPDMDEVINS pDevIns, SUPSEMEVENT hEvent, uint64_t cNsTimeout)
|
---|
| 646 | {
|
---|
| 647 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 648 | LogFlow(("pdmR0DevHlp_SUPSemEventWaitNsRelIntr: caller='%s'/%d: hEvent=%p cNsTimeout=%RU64\n",
|
---|
| 649 | pDevIns->pReg->szName, pDevIns->iInstance, hEvent, cNsTimeout));
|
---|
| 650 |
|
---|
| 651 | AssertFailed();
|
---|
| 652 | int rc = VERR_NOT_IMPLEMENTED; //SUPSemEventWaitNsRelIntr(pDevIns->Internal.s.pGVM->pSession, hEvent, cNsTimeout);
|
---|
| 653 |
|
---|
| 654 | LogFlow(("pdmR0DevHlp_SUPSemEventWaitNsRelIntr: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
|
---|
| 655 | return rc;
|
---|
| 656 | }
|
---|
| 657 |
|
---|
| 658 |
|
---|
| 659 | /** @interface_method_impl{PDMDEVHLPR0,pfnSUPSemEventGetResolution} */
|
---|
| 660 | static DECLCALLBACK(uint32_t) pdmR0DevHlp_SUPSemEventGetResolution(PPDMDEVINS pDevIns)
|
---|
| 661 | {
|
---|
| 662 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 663 | LogFlow(("pdmR0DevHlp_SUPSemEventGetResolution: caller='%s'/%d:\n", pDevIns->pReg->szName, pDevIns->iInstance));
|
---|
| 664 |
|
---|
| 665 | AssertFailed();
|
---|
| 666 | uint32_t cNsResolution = 0; //SUPSemEventGetResolution(pDevIns->Internal.s.pGVM->pSession);
|
---|
| 667 |
|
---|
| 668 | LogFlow(("pdmR0DevHlp_SUPSemEventGetResolution: caller='%s'/%d: returns %u\n", pDevIns->pReg->szName, pDevIns->iInstance, cNsResolution));
|
---|
| 669 | return cNsResolution;
|
---|
| 670 | }
|
---|
| 671 |
|
---|
| 672 |
|
---|
| 673 | /** @interface_method_impl{PDMDEVHLPR0,pfnSUPSemEventMultiSignal} */
|
---|
| 674 | static DECLCALLBACK(int) pdmR0DevHlp_SUPSemEventMultiSignal(PPDMDEVINS pDevIns, SUPSEMEVENTMULTI hEventMulti)
|
---|
| 675 | {
|
---|
| 676 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 677 | LogFlow(("pdmR0DevHlp_SUPSemEventMultiSignal: caller='%s'/%d: hEventMulti=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, hEventMulti));
|
---|
| 678 |
|
---|
| 679 | AssertFailed();
|
---|
| 680 | int rc = VERR_NOT_IMPLEMENTED; //SUPSemEventMultiSignal(pDevIns->Internal.s.pGVM->pSession, hEventMulti);
|
---|
| 681 |
|
---|
| 682 | LogFlow(("pdmR0DevHlp_SUPSemEventMultiSignal: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
|
---|
| 683 | return rc;
|
---|
| 684 | }
|
---|
| 685 |
|
---|
| 686 |
|
---|
| 687 | /** @interface_method_impl{PDMDEVHLPR0,pfnSUPSemEventMultiReset} */
|
---|
| 688 | static DECLCALLBACK(int) pdmR0DevHlp_SUPSemEventMultiReset(PPDMDEVINS pDevIns, SUPSEMEVENTMULTI hEventMulti)
|
---|
| 689 | {
|
---|
| 690 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 691 | LogFlow(("pdmR0DevHlp_SUPSemEventMultiReset: caller='%s'/%d: hEventMulti=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, hEventMulti));
|
---|
| 692 |
|
---|
| 693 | AssertFailed();
|
---|
| 694 | int rc = VERR_NOT_IMPLEMENTED; //SUPSemEventMultiReset(pDevIns->Internal.s.pGVM->pSession, hEventMulti);
|
---|
| 695 |
|
---|
| 696 | LogFlow(("pdmR0DevHlp_SUPSemEventMultiReset: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
|
---|
| 697 | return rc;
|
---|
| 698 | }
|
---|
| 699 |
|
---|
| 700 |
|
---|
| 701 | /** @interface_method_impl{PDMDEVHLPR0,pfnSUPSemEventMultiWaitNoResume} */
|
---|
| 702 | static DECLCALLBACK(int) pdmR0DevHlp_SUPSemEventMultiWaitNoResume(PPDMDEVINS pDevIns, SUPSEMEVENTMULTI hEventMulti,
|
---|
| 703 | uint32_t cMillies)
|
---|
| 704 | {
|
---|
| 705 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 706 | LogFlow(("pdmR0DevHlp_SUPSemEventMultiWaitNoResume: caller='%s'/%d: hEventMulti=%p cMillies=%RU32\n",
|
---|
| 707 | pDevIns->pReg->szName, pDevIns->iInstance, hEventMulti, cMillies));
|
---|
| 708 |
|
---|
| 709 | AssertFailed();
|
---|
| 710 | int rc = VERR_NOT_IMPLEMENTED; //SUPSemEventMultiWaitNoResume(pDevIns->Internal.s.pGVM->pSession, hEventMulti, cMillies);
|
---|
| 711 |
|
---|
| 712 | LogFlow(("pdmR0DevHlp_SUPSemEventMultiWaitNoResume: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
|
---|
| 713 | return rc;
|
---|
| 714 | }
|
---|
| 715 |
|
---|
| 716 |
|
---|
| 717 | /** @interface_method_impl{PDMDEVHLPR0,pfnSUPSemEventMultiWaitNsAbsIntr} */
|
---|
| 718 | static DECLCALLBACK(int) pdmR0DevHlp_SUPSemEventMultiWaitNsAbsIntr(PPDMDEVINS pDevIns, SUPSEMEVENTMULTI hEventMulti,
|
---|
| 719 | uint64_t uNsTimeout)
|
---|
| 720 | {
|
---|
| 721 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 722 | LogFlow(("pdmR0DevHlp_SUPSemEventMultiWaitNsAbsIntr: caller='%s'/%d: hEventMulti=%p uNsTimeout=%RU64\n",
|
---|
| 723 | pDevIns->pReg->szName, pDevIns->iInstance, hEventMulti, uNsTimeout));
|
---|
| 724 |
|
---|
| 725 | AssertFailed();
|
---|
| 726 | int rc = VERR_NOT_IMPLEMENTED; //SUPSemEventMultiWaitNsAbsIntr(pDevIns->Internal.s.pGVM->pSession, hEventMulti, uNsTimeout);
|
---|
| 727 |
|
---|
| 728 | LogFlow(("pdmR0DevHlp_SUPSemEventMultiWaitNsAbsIntr: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
|
---|
| 729 | return rc;
|
---|
| 730 | }
|
---|
| 731 |
|
---|
| 732 |
|
---|
| 733 | /** @interface_method_impl{PDMDEVHLPR0,pfnSUPSemEventMultiWaitNsRelIntr} */
|
---|
| 734 | static DECLCALLBACK(int) pdmR0DevHlp_SUPSemEventMultiWaitNsRelIntr(PPDMDEVINS pDevIns, SUPSEMEVENTMULTI hEventMulti,
|
---|
| 735 | uint64_t cNsTimeout)
|
---|
| 736 | {
|
---|
| 737 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 738 | LogFlow(("pdmR0DevHlp_SUPSemEventMultiWaitNsRelIntr: caller='%s'/%d: hEventMulti=%p cNsTimeout=%RU64\n",
|
---|
| 739 | pDevIns->pReg->szName, pDevIns->iInstance, hEventMulti, cNsTimeout));
|
---|
| 740 |
|
---|
| 741 | AssertFailed();
|
---|
| 742 | int rc = VERR_NOT_IMPLEMENTED; //SUPSemEventMultiWaitNsRelIntr(pDevIns->Internal.s.pGVM->pSession, hEventMulti, cNsTimeout);
|
---|
| 743 |
|
---|
| 744 | LogFlow(("pdmR0DevHlp_SUPSemEventMultiWaitNsRelIntr: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
|
---|
| 745 | return rc;
|
---|
| 746 | }
|
---|
| 747 |
|
---|
| 748 |
|
---|
| 749 | /** @interface_method_impl{PDMDEVHLPR0,pfnSUPSemEventMultiGetResolution} */
|
---|
| 750 | static DECLCALLBACK(uint32_t) pdmR0DevHlp_SUPSemEventMultiGetResolution(PPDMDEVINS pDevIns)
|
---|
| 751 | {
|
---|
| 752 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 753 | LogFlow(("pdmR0DevHlp_SUPSemEventMultiGetResolution: caller='%s'/%d:\n", pDevIns->pReg->szName, pDevIns->iInstance));
|
---|
| 754 |
|
---|
| 755 | AssertFailed();
|
---|
| 756 | uint32_t cNsResolution = 0; //SUPSemEventMultiGetResolution(pDevIns->Internal.s.pGVM->pSession);
|
---|
| 757 |
|
---|
| 758 | LogFlow(("pdmR0DevHlp_SUPSemEventMultiGetResolution: caller='%s'/%d: returns %u\n", pDevIns->pReg->szName, pDevIns->iInstance, cNsResolution));
|
---|
| 759 | return cNsResolution;
|
---|
| 760 | }
|
---|
| 761 |
|
---|
| 762 |
|
---|
| 763 | /** @interface_method_impl{PDMDEVHLPR0,pfnCritSectGetNop} */
|
---|
| 764 | static DECLCALLBACK(PPDMCRITSECT) pdmR0DevHlp_CritSectGetNop(PPDMDEVINS pDevIns)
|
---|
| 765 | {
|
---|
| 766 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 767 |
|
---|
[92124] | 768 | PPDMCRITSECT pCritSect = &pDevIns->Internal.s.pDut->CritSectNop;
|
---|
[92079] | 769 | LogFlow(("pdmR0DevHlp_CritSectGetNop: caller='%s'/%d: return %p\n", pDevIns->pReg->szName, pDevIns->iInstance, pCritSect));
|
---|
| 770 | return pCritSect;
|
---|
| 771 | }
|
---|
| 772 |
|
---|
| 773 |
|
---|
| 774 | /** @interface_method_impl{PDMDEVHLPR0,pfnSetDeviceCritSect} */
|
---|
| 775 | static DECLCALLBACK(int) pdmR0DevHlp_SetDeviceCritSect(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect)
|
---|
| 776 | {
|
---|
| 777 | /*
|
---|
| 778 | * Validate input.
|
---|
| 779 | *
|
---|
| 780 | * Note! We only allow the automatically created default critical section
|
---|
| 781 | * to be replaced by this API.
|
---|
| 782 | */
|
---|
| 783 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 784 | AssertPtrReturn(pCritSect, VERR_INVALID_POINTER);
|
---|
| 785 | LogFlow(("pdmR0DevHlp_SetDeviceCritSect: caller='%s'/%d: pCritSect=%p\n",
|
---|
| 786 | pDevIns->pReg->szName, pDevIns->iInstance, pCritSect));
|
---|
[92124] | 787 | AssertReturn(RTCritSectIsInitialized(&pCritSect->s.CritSect), VERR_INVALID_PARAMETER);
|
---|
[92079] | 788 |
|
---|
| 789 | pDevIns->pCritSectRoR0 = pCritSect;
|
---|
| 790 |
|
---|
| 791 | LogFlow(("pdmR0DevHlp_SetDeviceCritSect: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, VINF_SUCCESS));
|
---|
| 792 | return VINF_SUCCESS;
|
---|
| 793 | }
|
---|
| 794 |
|
---|
| 795 |
|
---|
| 796 | /** @interface_method_impl{PDMDEVHLPR0,pfnCritSectEnter} */
|
---|
| 797 | static DECLCALLBACK(int) pdmR0DevHlp_CritSectEnter(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect, int rcBusy)
|
---|
| 798 | {
|
---|
| 799 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 800 | AssertFailed();
|
---|
| 801 | return VERR_NOT_IMPLEMENTED; //PDMCritSectEnter(pDevIns->Internal.s.pGVM, pCritSect, rcBusy);
|
---|
| 802 | }
|
---|
| 803 |
|
---|
| 804 |
|
---|
| 805 | /** @interface_method_impl{PDMDEVHLPR0,pfnCritSectEnterDebug} */
|
---|
| 806 | static DECLCALLBACK(int) pdmR0DevHlp_CritSectEnterDebug(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect, int rcBusy, RTHCUINTPTR uId, RT_SRC_POS_DECL)
|
---|
| 807 | {
|
---|
| 808 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 809 | AssertFailed();
|
---|
| 810 | return VERR_NOT_IMPLEMENTED; //PDMCritSectEnterDebug(pDevIns->Internal.s.pGVM, pCritSect, rcBusy, uId, RT_SRC_POS_ARGS);
|
---|
| 811 | }
|
---|
| 812 |
|
---|
| 813 |
|
---|
| 814 | /** @interface_method_impl{PDMDEVHLPR0,pfnCritSectTryEnter} */
|
---|
| 815 | static DECLCALLBACK(int) pdmR0DevHlp_CritSectTryEnter(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect)
|
---|
| 816 | {
|
---|
| 817 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 818 | AssertFailed();
|
---|
| 819 | return VERR_NOT_IMPLEMENTED; //PDMCritSectTryEnter(pDevIns->Internal.s.pGVM, pCritSect);
|
---|
| 820 | }
|
---|
| 821 |
|
---|
| 822 |
|
---|
| 823 | /** @interface_method_impl{PDMDEVHLPR0,pfnCritSectTryEnterDebug} */
|
---|
| 824 | static DECLCALLBACK(int) pdmR0DevHlp_CritSectTryEnterDebug(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect, RTHCUINTPTR uId, RT_SRC_POS_DECL)
|
---|
| 825 | {
|
---|
| 826 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 827 | AssertFailed();
|
---|
| 828 | return VERR_NOT_IMPLEMENTED; //PDMCritSectTryEnterDebug(pDevIns->Internal.s.pGVM, pCritSect, uId, RT_SRC_POS_ARGS);
|
---|
| 829 | }
|
---|
| 830 |
|
---|
| 831 |
|
---|
| 832 | /** @interface_method_impl{PDMDEVHLPR0,pfnCritSectLeave} */
|
---|
| 833 | static DECLCALLBACK(int) pdmR0DevHlp_CritSectLeave(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect)
|
---|
| 834 | {
|
---|
| 835 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 836 | AssertFailed();
|
---|
| 837 | return VERR_NOT_IMPLEMENTED; //PDMCritSectLeave(pDevIns->Internal.s.pGVM, pCritSect);
|
---|
| 838 | }
|
---|
| 839 |
|
---|
| 840 |
|
---|
| 841 | /** @interface_method_impl{PDMDEVHLPR0,pfnCritSectIsOwner} */
|
---|
| 842 | static DECLCALLBACK(bool) pdmR0DevHlp_CritSectIsOwner(PPDMDEVINS pDevIns, PCPDMCRITSECT pCritSect)
|
---|
| 843 | {
|
---|
| 844 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 845 | AssertFailed();
|
---|
| 846 | return VERR_NOT_IMPLEMENTED; //PDMCritSectIsOwner(pDevIns->Internal.s.pGVM, pCritSect);
|
---|
| 847 | }
|
---|
| 848 |
|
---|
| 849 |
|
---|
| 850 | /** @interface_method_impl{PDMDEVHLPR0,pfnCritSectIsInitialized} */
|
---|
| 851 | static DECLCALLBACK(bool) pdmR0DevHlp_CritSectIsInitialized(PPDMDEVINS pDevIns, PCPDMCRITSECT pCritSect)
|
---|
| 852 | {
|
---|
| 853 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 854 | RT_NOREF(pDevIns);
|
---|
| 855 | AssertFailed();
|
---|
| 856 | return VERR_NOT_IMPLEMENTED; //PDMCritSectIsInitialized(pCritSect);
|
---|
| 857 | }
|
---|
| 858 |
|
---|
| 859 |
|
---|
| 860 | /** @interface_method_impl{PDMDEVHLPR0,pfnCritSectHasWaiters} */
|
---|
| 861 | static DECLCALLBACK(bool) pdmR0DevHlp_CritSectHasWaiters(PPDMDEVINS pDevIns, PCPDMCRITSECT pCritSect)
|
---|
| 862 | {
|
---|
| 863 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 864 | AssertFailed();
|
---|
| 865 | return VERR_NOT_IMPLEMENTED; //PDMCritSectHasWaiters(pDevIns->Internal.s.pGVM, pCritSect);
|
---|
| 866 | }
|
---|
| 867 |
|
---|
| 868 |
|
---|
| 869 | /** @interface_method_impl{PDMDEVHLPR0,pfnCritSectGetRecursion} */
|
---|
| 870 | static DECLCALLBACK(uint32_t) pdmR0DevHlp_CritSectGetRecursion(PPDMDEVINS pDevIns, PCPDMCRITSECT pCritSect)
|
---|
| 871 | {
|
---|
| 872 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 873 | RT_NOREF(pDevIns);
|
---|
| 874 | AssertFailed();
|
---|
| 875 | return VERR_NOT_IMPLEMENTED; //PDMCritSectGetRecursion(pCritSect);
|
---|
| 876 | }
|
---|
| 877 |
|
---|
| 878 |
|
---|
| 879 | /** @interface_method_impl{PDMDEVHLPR0,pfnCritSectScheduleExitEvent} */
|
---|
| 880 | static DECLCALLBACK(int) pdmR0DevHlp_CritSectScheduleExitEvent(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect,
|
---|
| 881 | SUPSEMEVENT hEventToSignal)
|
---|
| 882 | {
|
---|
| 883 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 884 | RT_NOREF(pDevIns);
|
---|
| 885 | AssertFailed();
|
---|
| 886 | return VERR_NOT_IMPLEMENTED; //PDMHCCritSectScheduleExitEvent(pCritSect, hEventToSignal);
|
---|
| 887 | }
|
---|
| 888 |
|
---|
| 889 |
|
---|
| 890 | /** @interface_method_impl{PDMDEVHLPR0,pfnCritSectRwEnterShared} */
|
---|
| 891 | static DECLCALLBACK(int) pdmR0DevHlp_CritSectRwEnterShared(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect, int rcBusy)
|
---|
| 892 | {
|
---|
| 893 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 894 | AssertFailed();
|
---|
| 895 | return VERR_NOT_IMPLEMENTED; //PDMCritSectRwEnterShared(pDevIns->Internal.s.pGVM, pCritSect, rcBusy);
|
---|
| 896 | }
|
---|
| 897 |
|
---|
| 898 |
|
---|
| 899 | /** @interface_method_impl{PDMDEVHLPR0,pfnCritSectRwEnterSharedDebug} */
|
---|
| 900 | static DECLCALLBACK(int) pdmR0DevHlp_CritSectRwEnterSharedDebug(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect, int rcBusy,
|
---|
| 901 | RTHCUINTPTR uId, RT_SRC_POS_DECL)
|
---|
| 902 | {
|
---|
| 903 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 904 | AssertFailed();
|
---|
| 905 | return VERR_NOT_IMPLEMENTED; //PDMCritSectRwEnterSharedDebug(pDevIns->Internal.s.pGVM, pCritSect, rcBusy, uId, RT_SRC_POS_ARGS);
|
---|
| 906 | }
|
---|
| 907 |
|
---|
| 908 |
|
---|
| 909 |
|
---|
| 910 | /** @interface_method_impl{PDMDEVHLPR0,pfnCritSectRwTryEnterShared} */
|
---|
| 911 | static DECLCALLBACK(int) pdmR0DevHlp_CritSectRwTryEnterShared(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect)
|
---|
| 912 | {
|
---|
| 913 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 914 | AssertFailed();
|
---|
| 915 | return VERR_NOT_IMPLEMENTED; //PDMCritSectRwTryEnterShared(pDevIns->Internal.s.pGVM, pCritSect);
|
---|
| 916 | }
|
---|
| 917 |
|
---|
| 918 |
|
---|
| 919 | /** @interface_method_impl{PDMDEVHLPR0,pfnCritSectRwTryEnterSharedDebug} */
|
---|
| 920 | static DECLCALLBACK(int) pdmR0DevHlp_CritSectRwTryEnterSharedDebug(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect,
|
---|
| 921 | RTHCUINTPTR uId, RT_SRC_POS_DECL)
|
---|
| 922 | {
|
---|
| 923 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 924 | AssertFailed();
|
---|
| 925 | return VERR_NOT_IMPLEMENTED; //PDMCritSectRwTryEnterSharedDebug(pDevIns->Internal.s.pGVM, pCritSect, uId, RT_SRC_POS_ARGS);
|
---|
| 926 | }
|
---|
| 927 |
|
---|
| 928 |
|
---|
| 929 | /** @interface_method_impl{PDMDEVHLPR0,pfnCritSectRwLeaveShared} */
|
---|
| 930 | static DECLCALLBACK(int) pdmR0DevHlp_CritSectRwLeaveShared(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect)
|
---|
| 931 | {
|
---|
| 932 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 933 | AssertFailed();
|
---|
| 934 | return VERR_NOT_IMPLEMENTED; //PDMCritSectRwLeaveShared(pDevIns->Internal.s.pGVM, pCritSect);
|
---|
| 935 | }
|
---|
| 936 |
|
---|
| 937 |
|
---|
| 938 | /** @interface_method_impl{PDMDEVHLPR0,pfnCritSectRwEnterExcl} */
|
---|
| 939 | static DECLCALLBACK(int) pdmR0DevHlp_CritSectRwEnterExcl(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect, int rcBusy)
|
---|
| 940 | {
|
---|
| 941 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 942 | AssertFailed();
|
---|
| 943 | return VERR_NOT_IMPLEMENTED; //PDMCritSectRwEnterExcl(pDevIns->Internal.s.pGVM, pCritSect, rcBusy);
|
---|
| 944 | }
|
---|
| 945 |
|
---|
| 946 |
|
---|
| 947 | /** @interface_method_impl{PDMDEVHLPR0,pfnCritSectRwEnterExclDebug} */
|
---|
| 948 | static DECLCALLBACK(int) pdmR0DevHlp_CritSectRwEnterExclDebug(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect, int rcBusy,
|
---|
| 949 | RTHCUINTPTR uId, RT_SRC_POS_DECL)
|
---|
| 950 | {
|
---|
| 951 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 952 | AssertFailed();
|
---|
| 953 | return VERR_NOT_IMPLEMENTED; //PDMCritSectRwEnterExclDebug(pDevIns->Internal.s.pGVM, pCritSect, rcBusy, uId, RT_SRC_POS_ARGS);
|
---|
| 954 | }
|
---|
| 955 |
|
---|
| 956 |
|
---|
| 957 | /** @interface_method_impl{PDMDEVHLPR0,pfnCritSectRwTryEnterExcl} */
|
---|
| 958 | static DECLCALLBACK(int) pdmR0DevHlp_CritSectRwTryEnterExcl(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect)
|
---|
| 959 | {
|
---|
| 960 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 961 | AssertFailed();
|
---|
| 962 | return VERR_NOT_IMPLEMENTED; //PDMCritSectRwTryEnterExcl(pDevIns->Internal.s.pGVM, pCritSect);
|
---|
| 963 | }
|
---|
| 964 |
|
---|
| 965 |
|
---|
| 966 | /** @interface_method_impl{PDMDEVHLPR0,pfnCritSectRwTryEnterExclDebug} */
|
---|
| 967 | static DECLCALLBACK(int) pdmR0DevHlp_CritSectRwTryEnterExclDebug(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect,
|
---|
| 968 | RTHCUINTPTR uId, RT_SRC_POS_DECL)
|
---|
| 969 | {
|
---|
| 970 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 971 | AssertFailed();
|
---|
| 972 | return VERR_NOT_IMPLEMENTED; //PDMCritSectRwTryEnterExclDebug(pDevIns->Internal.s.pGVM, pCritSect, uId, RT_SRC_POS_ARGS);
|
---|
| 973 | }
|
---|
| 974 |
|
---|
| 975 |
|
---|
| 976 | /** @interface_method_impl{PDMDEVHLPR0,pfnCritSectRwLeaveExcl} */
|
---|
| 977 | static DECLCALLBACK(int) pdmR0DevHlp_CritSectRwLeaveExcl(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect)
|
---|
| 978 | {
|
---|
| 979 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 980 | AssertFailed();
|
---|
| 981 | return VERR_NOT_IMPLEMENTED; //PDMCritSectRwLeaveExcl(pDevIns->Internal.s.pGVM, pCritSect);
|
---|
| 982 | }
|
---|
| 983 |
|
---|
| 984 |
|
---|
| 985 | /** @interface_method_impl{PDMDEVHLPR0,pfnCritSectRwIsWriteOwner} */
|
---|
| 986 | static DECLCALLBACK(bool) pdmR0DevHlp_CritSectRwIsWriteOwner(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect)
|
---|
| 987 | {
|
---|
| 988 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 989 | AssertFailed();
|
---|
| 990 | return false; //PDMCritSectRwIsWriteOwner(pDevIns->Internal.s.pGVM, pCritSect);
|
---|
| 991 | }
|
---|
| 992 |
|
---|
| 993 |
|
---|
| 994 | /** @interface_method_impl{PDMDEVHLPR0,pfnCritSectRwIsReadOwner} */
|
---|
| 995 | static DECLCALLBACK(bool) pdmR0DevHlp_CritSectRwIsReadOwner(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect, bool fWannaHear)
|
---|
| 996 | {
|
---|
| 997 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 998 | AssertFailed();
|
---|
| 999 | return false; //PDMCritSectRwIsReadOwner(pDevIns->Internal.s.pGVM, pCritSect, fWannaHear);
|
---|
| 1000 | }
|
---|
| 1001 |
|
---|
| 1002 |
|
---|
| 1003 | /** @interface_method_impl{PDMDEVHLPR0,pfnCritSectRwGetWriteRecursion} */
|
---|
| 1004 | static DECLCALLBACK(uint32_t) pdmR0DevHlp_CritSectRwGetWriteRecursion(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect)
|
---|
| 1005 | {
|
---|
| 1006 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 1007 | RT_NOREF(pDevIns);
|
---|
| 1008 | AssertFailed();
|
---|
| 1009 | return 0; //PDMCritSectRwGetWriteRecursion(pCritSect);
|
---|
| 1010 | }
|
---|
| 1011 |
|
---|
| 1012 |
|
---|
| 1013 | /** @interface_method_impl{PDMDEVHLPR0,pfnCritSectRwGetWriterReadRecursion} */
|
---|
| 1014 | static DECLCALLBACK(uint32_t) pdmR0DevHlp_CritSectRwGetWriterReadRecursion(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect)
|
---|
| 1015 | {
|
---|
| 1016 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 1017 | RT_NOREF(pDevIns);
|
---|
| 1018 | AssertFailed();
|
---|
| 1019 | return 0; //PDMCritSectRwGetWriterReadRecursion(pCritSect);
|
---|
| 1020 | }
|
---|
| 1021 |
|
---|
| 1022 |
|
---|
| 1023 | /** @interface_method_impl{PDMDEVHLPR0,pfnCritSectRwGetReadCount} */
|
---|
| 1024 | static DECLCALLBACK(uint32_t) pdmR0DevHlp_CritSectRwGetReadCount(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect)
|
---|
| 1025 | {
|
---|
| 1026 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 1027 | RT_NOREF(pDevIns);
|
---|
| 1028 | AssertFailed();
|
---|
| 1029 | return 0; //PDMCritSectRwGetReadCount(pCritSect);
|
---|
| 1030 | }
|
---|
| 1031 |
|
---|
| 1032 |
|
---|
| 1033 | /** @interface_method_impl{PDMDEVHLPR0,pfnCritSectRwIsInitialized} */
|
---|
| 1034 | static DECLCALLBACK(bool) pdmR0DevHlp_CritSectRwIsInitialized(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect)
|
---|
| 1035 | {
|
---|
| 1036 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 1037 | RT_NOREF(pDevIns);
|
---|
| 1038 | AssertFailed();
|
---|
| 1039 | return false; //PDMCritSectRwIsInitialized(pCritSect);
|
---|
| 1040 | }
|
---|
| 1041 |
|
---|
| 1042 |
|
---|
| 1043 | /** @interface_method_impl{PDMDEVHLPR0,pfnDBGFTraceBuf} */
|
---|
| 1044 | static DECLCALLBACK(RTTRACEBUF) pdmR0DevHlp_DBGFTraceBuf(PPDMDEVINS pDevIns)
|
---|
| 1045 | {
|
---|
| 1046 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 1047 | AssertFailed();
|
---|
| 1048 | RTTRACEBUF hTraceBuf = NULL; //pDevIns->Internal.s.pGVM->hTraceBufR0;
|
---|
| 1049 | LogFlow(("pdmR0DevHlp_DBGFTraceBuf: caller='%p'/%d: returns %p\n", pDevIns, pDevIns->iInstance, hTraceBuf));
|
---|
| 1050 | return hTraceBuf;
|
---|
| 1051 | }
|
---|
| 1052 |
|
---|
| 1053 |
|
---|
| 1054 | /** @interface_method_impl{PDMDEVHLPR0,pfnPCIBusSetUpContext} */
|
---|
| 1055 | static DECLCALLBACK(int) pdmR0DevHlp_PCIBusSetUpContext(PPDMDEVINS pDevIns, PPDMPCIBUSREGR0 pPciBusReg, PCPDMPCIHLPR0 *ppPciHlp)
|
---|
| 1056 | {
|
---|
| 1057 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 1058 | LogFlow(("pdmR0DevHlp_PCIBusSetUpContext: caller='%p'/%d: pPciBusReg=%p{.u32Version=%#x, .iBus=%#u, .pfnSetIrq=%p, u32EnvVersion=%#x} ppPciHlp=%p\n",
|
---|
| 1059 | pDevIns, pDevIns->iInstance, pPciBusReg, pPciBusReg->u32Version, pPciBusReg->iBus, pPciBusReg->pfnSetIrq,
|
---|
| 1060 | pPciBusReg->u32EndVersion, ppPciHlp));
|
---|
| 1061 | #if 0
|
---|
| 1062 | PGVM pGVM = pDevIns->Internal.s.pGVM;
|
---|
| 1063 |
|
---|
| 1064 | /*
|
---|
| 1065 | * Validate input.
|
---|
| 1066 | */
|
---|
| 1067 | AssertPtrReturn(pPciBusReg, VERR_INVALID_POINTER);
|
---|
| 1068 | AssertLogRelMsgReturn(pPciBusReg->u32Version == PDM_PCIBUSREGCC_VERSION,
|
---|
| 1069 | ("%#x vs %#x\n", pPciBusReg->u32Version, PDM_PCIBUSREGCC_VERSION), VERR_VERSION_MISMATCH);
|
---|
| 1070 | AssertPtrReturn(pPciBusReg->pfnSetIrq, VERR_INVALID_POINTER);
|
---|
| 1071 | AssertLogRelMsgReturn(pPciBusReg->u32EndVersion == PDM_PCIBUSREGCC_VERSION,
|
---|
| 1072 | ("%#x vs %#x\n", pPciBusReg->u32EndVersion, PDM_PCIBUSREGCC_VERSION), VERR_VERSION_MISMATCH);
|
---|
| 1073 |
|
---|
| 1074 | AssertPtrReturn(ppPciHlp, VERR_INVALID_POINTER);
|
---|
| 1075 |
|
---|
| 1076 | VM_ASSERT_STATE_RETURN(pGVM, VMSTATE_CREATING, VERR_WRONG_ORDER);
|
---|
| 1077 | VM_ASSERT_EMT0_RETURN(pGVM, VERR_VM_THREAD_NOT_EMT);
|
---|
| 1078 |
|
---|
| 1079 | /* Check the shared bus data (registered earlier from ring-3): */
|
---|
| 1080 | uint32_t iBus = pPciBusReg->iBus;
|
---|
| 1081 | ASMCompilerBarrier();
|
---|
| 1082 | AssertLogRelMsgReturn(iBus < RT_ELEMENTS(pGVM->pdm.s.aPciBuses), ("iBus=%#x\n", iBus), VERR_OUT_OF_RANGE);
|
---|
| 1083 | PPDMPCIBUS pPciBusShared = &pGVM->pdm.s.aPciBuses[iBus];
|
---|
| 1084 | AssertLogRelMsgReturn(pPciBusShared->iBus == iBus, ("%u vs %u\n", pPciBusShared->iBus, iBus), VERR_INVALID_PARAMETER);
|
---|
| 1085 | AssertLogRelMsgReturn(pPciBusShared->pDevInsR3 == pDevIns->pDevInsForR3,
|
---|
| 1086 | ("%p vs %p (iBus=%u)\n", pPciBusShared->pDevInsR3, pDevIns->pDevInsForR3, iBus), VERR_NOT_OWNER);
|
---|
| 1087 |
|
---|
| 1088 | /* Check that the bus isn't already registered in ring-0: */
|
---|
| 1089 | AssertCompile(RT_ELEMENTS(pGVM->pdm.s.aPciBuses) == RT_ELEMENTS(pGVM->pdmr0.s.aPciBuses));
|
---|
| 1090 | PPDMPCIBUSR0 pPciBusR0 = &pGVM->pdmr0.s.aPciBuses[iBus];
|
---|
| 1091 | AssertLogRelMsgReturn(pPciBusR0->pDevInsR0 == NULL,
|
---|
| 1092 | ("%p (caller pDevIns=%p, iBus=%u)\n", pPciBusR0->pDevInsR0, pDevIns, iBus),
|
---|
| 1093 | VERR_ALREADY_EXISTS);
|
---|
| 1094 |
|
---|
| 1095 | /*
|
---|
| 1096 | * Do the registering.
|
---|
| 1097 | */
|
---|
| 1098 | pPciBusR0->iBus = iBus;
|
---|
| 1099 | pPciBusR0->uPadding0 = 0xbeefbeef;
|
---|
| 1100 | pPciBusR0->pfnSetIrqR0 = pPciBusReg->pfnSetIrq;
|
---|
| 1101 | pPciBusR0->pDevInsR0 = pDevIns;
|
---|
| 1102 | #endif
|
---|
| 1103 |
|
---|
| 1104 | AssertFailed();
|
---|
| 1105 | *ppPciHlp = NULL; //&g_pdmR0PciHlp;
|
---|
| 1106 |
|
---|
| 1107 | LogFlow(("pdmR0DevHlp_PCIBusSetUpContext: caller='%p'/%d: returns VINF_SUCCESS\n", pDevIns, pDevIns->iInstance));
|
---|
| 1108 | return VINF_SUCCESS;
|
---|
| 1109 | }
|
---|
| 1110 |
|
---|
| 1111 |
|
---|
| 1112 | /** @interface_method_impl{PDMDEVHLPR0,pfnIommuSetUpContext} */
|
---|
| 1113 | static DECLCALLBACK(int) pdmR0DevHlp_IommuSetUpContext(PPDMDEVINS pDevIns, PPDMIOMMUREGR0 pIommuReg, PCPDMIOMMUHLPR0 *ppIommuHlp)
|
---|
| 1114 | {
|
---|
| 1115 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 1116 | LogFlow(("pdmR0DevHlp_IommuSetUpContext: caller='%p'/%d: pIommuReg=%p{.u32Version=%#x, u32TheEnd=%#x} ppIommuHlp=%p\n",
|
---|
| 1117 | pDevIns, pDevIns->iInstance, pIommuReg, pIommuReg->u32Version, pIommuReg->u32TheEnd, ppIommuHlp));
|
---|
| 1118 | #if 0
|
---|
| 1119 | PGVM pGVM = pDevIns->Internal.s.pGVM;
|
---|
| 1120 |
|
---|
| 1121 | /*
|
---|
| 1122 | * Validate input.
|
---|
| 1123 | */
|
---|
| 1124 | AssertPtrReturn(pIommuReg, VERR_INVALID_POINTER);
|
---|
| 1125 | AssertLogRelMsgReturn(pIommuReg->u32Version == PDM_IOMMUREGCC_VERSION,
|
---|
| 1126 | ("%#x vs %#x\n", pIommuReg->u32Version, PDM_IOMMUREGCC_VERSION), VERR_VERSION_MISMATCH);
|
---|
| 1127 | AssertPtrReturn(pIommuReg->pfnMemAccess, VERR_INVALID_POINTER);
|
---|
| 1128 | AssertPtrReturn(pIommuReg->pfnMemBulkAccess, VERR_INVALID_POINTER);
|
---|
| 1129 | AssertPtrReturn(pIommuReg->pfnMsiRemap, VERR_INVALID_POINTER);
|
---|
| 1130 | AssertLogRelMsgReturn(pIommuReg->u32TheEnd == PDM_IOMMUREGCC_VERSION,
|
---|
| 1131 | ("%#x vs %#x\n", pIommuReg->u32TheEnd, PDM_IOMMUREGCC_VERSION), VERR_VERSION_MISMATCH);
|
---|
| 1132 |
|
---|
| 1133 | AssertPtrReturn(ppIommuHlp, VERR_INVALID_POINTER);
|
---|
| 1134 |
|
---|
| 1135 | VM_ASSERT_STATE_RETURN(pGVM, VMSTATE_CREATING, VERR_WRONG_ORDER);
|
---|
| 1136 | VM_ASSERT_EMT0_RETURN(pGVM, VERR_VM_THREAD_NOT_EMT);
|
---|
| 1137 |
|
---|
| 1138 | /* Check the IOMMU shared data (registered earlier from ring-3). */
|
---|
| 1139 | uint32_t const idxIommu = pIommuReg->idxIommu;
|
---|
| 1140 | ASMCompilerBarrier();
|
---|
| 1141 | AssertLogRelMsgReturn(idxIommu < RT_ELEMENTS(pGVM->pdm.s.aIommus), ("idxIommu=%#x\n", idxIommu), VERR_OUT_OF_RANGE);
|
---|
| 1142 | PPDMIOMMUR3 pIommuShared = &pGVM->pdm.s.aIommus[idxIommu];
|
---|
| 1143 | AssertLogRelMsgReturn(pIommuShared->idxIommu == idxIommu, ("%u vs %u\n", pIommuShared->idxIommu, idxIommu), VERR_INVALID_PARAMETER);
|
---|
| 1144 | AssertLogRelMsgReturn(pIommuShared->pDevInsR3 == pDevIns->pDevInsForR3,
|
---|
| 1145 | ("%p vs %p (idxIommu=%u)\n", pIommuShared->pDevInsR3, pDevIns->pDevInsForR3, idxIommu), VERR_NOT_OWNER);
|
---|
| 1146 |
|
---|
| 1147 | /* Check that the IOMMU isn't already registered in ring-0. */
|
---|
| 1148 | AssertCompile(RT_ELEMENTS(pGVM->pdm.s.aIommus) == RT_ELEMENTS(pGVM->pdmr0.s.aIommus));
|
---|
| 1149 | PPDMIOMMUR0 pIommuR0 = &pGVM->pdmr0.s.aIommus[idxIommu];
|
---|
| 1150 | AssertLogRelMsgReturn(pIommuR0->pDevInsR0 == NULL,
|
---|
| 1151 | ("%p (caller pDevIns=%p, idxIommu=%u)\n", pIommuR0->pDevInsR0, pDevIns, idxIommu),
|
---|
| 1152 | VERR_ALREADY_EXISTS);
|
---|
| 1153 |
|
---|
| 1154 | /*
|
---|
| 1155 | * Register.
|
---|
| 1156 | */
|
---|
| 1157 | pIommuR0->idxIommu = idxIommu;
|
---|
| 1158 | pIommuR0->uPadding0 = 0xdeaddead;
|
---|
| 1159 | pIommuR0->pDevInsR0 = pDevIns;
|
---|
| 1160 | pIommuR0->pfnMemAccess = pIommuReg->pfnMemAccess;
|
---|
| 1161 | pIommuR0->pfnMemBulkAccess = pIommuReg->pfnMemBulkAccess;
|
---|
| 1162 | pIommuR0->pfnMsiRemap = pIommuReg->pfnMsiRemap;
|
---|
| 1163 | #endif
|
---|
| 1164 |
|
---|
| 1165 | AssertFailed();
|
---|
| 1166 | *ppIommuHlp = NULL; //&g_pdmR0IommuHlp;
|
---|
| 1167 |
|
---|
| 1168 | LogFlow(("pdmR0DevHlp_IommuSetUpContext: caller='%p'/%d: returns VINF_SUCCESS\n", pDevIns, pDevIns->iInstance));
|
---|
| 1169 | return VINF_SUCCESS;
|
---|
| 1170 | }
|
---|
| 1171 |
|
---|
| 1172 |
|
---|
| 1173 | /** @interface_method_impl{PDMDEVHLPR0,pfnPICSetUpContext} */
|
---|
| 1174 | static DECLCALLBACK(int) pdmR0DevHlp_PICSetUpContext(PPDMDEVINS pDevIns, PPDMPICREG pPicReg, PCPDMPICHLP *ppPicHlp)
|
---|
| 1175 | {
|
---|
| 1176 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 1177 | LogFlow(("pdmR0DevHlp_PICSetUpContext: caller='%s'/%d: pPicReg=%p:{.u32Version=%#x, .pfnSetIrq=%p, .pfnGetInterrupt=%p, .u32TheEnd=%#x } ppPicHlp=%p\n",
|
---|
| 1178 | pDevIns->pReg->szName, pDevIns->iInstance, pPicReg, pPicReg->u32Version, pPicReg->pfnSetIrq, pPicReg->pfnGetInterrupt, pPicReg->u32TheEnd, ppPicHlp));
|
---|
| 1179 | #if 0
|
---|
| 1180 | PGVM pGVM = pDevIns->Internal.s.pGVM;
|
---|
| 1181 |
|
---|
| 1182 | /*
|
---|
| 1183 | * Validate input.
|
---|
| 1184 | */
|
---|
| 1185 | AssertMsgReturn(pPicReg->u32Version == PDM_PICREG_VERSION,
|
---|
| 1186 | ("%s/%d: u32Version=%#x expected %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, pPicReg->u32Version, PDM_PICREG_VERSION),
|
---|
| 1187 | VERR_VERSION_MISMATCH);
|
---|
| 1188 | AssertPtrReturn(pPicReg->pfnSetIrq, VERR_INVALID_POINTER);
|
---|
| 1189 | AssertPtrReturn(pPicReg->pfnGetInterrupt, VERR_INVALID_POINTER);
|
---|
| 1190 | AssertMsgReturn(pPicReg->u32TheEnd == PDM_PICREG_VERSION,
|
---|
| 1191 | ("%s/%d: u32TheEnd=%#x expected %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, pPicReg->u32TheEnd, PDM_PICREG_VERSION),
|
---|
| 1192 | VERR_VERSION_MISMATCH);
|
---|
| 1193 | AssertPtrReturn(ppPicHlp, VERR_INVALID_POINTER);
|
---|
| 1194 |
|
---|
| 1195 | VM_ASSERT_STATE_RETURN(pGVM, VMSTATE_CREATING, VERR_WRONG_ORDER);
|
---|
| 1196 | VM_ASSERT_EMT0_RETURN(pGVM, VERR_VM_THREAD_NOT_EMT);
|
---|
| 1197 |
|
---|
| 1198 | /* Check that it's the same device as made the ring-3 registrations: */
|
---|
| 1199 | AssertLogRelMsgReturn(pGVM->pdm.s.Pic.pDevInsR3 == pDevIns->pDevInsForR3,
|
---|
| 1200 | ("%p vs %p\n", pGVM->pdm.s.Pic.pDevInsR3, pDevIns->pDevInsForR3), VERR_NOT_OWNER);
|
---|
| 1201 |
|
---|
| 1202 | /* Check that it isn't already registered in ring-0: */
|
---|
| 1203 | AssertLogRelMsgReturn(pGVM->pdm.s.Pic.pDevInsR0 == NULL, ("%p (caller pDevIns=%p)\n", pGVM->pdm.s.Pic.pDevInsR0, pDevIns),
|
---|
| 1204 | VERR_ALREADY_EXISTS);
|
---|
| 1205 |
|
---|
| 1206 | /*
|
---|
| 1207 | * Take down the callbacks and instance.
|
---|
| 1208 | */
|
---|
| 1209 | pGVM->pdm.s.Pic.pDevInsR0 = pDevIns;
|
---|
| 1210 | pGVM->pdm.s.Pic.pfnSetIrqR0 = pPicReg->pfnSetIrq;
|
---|
| 1211 | pGVM->pdm.s.Pic.pfnGetInterruptR0 = pPicReg->pfnGetInterrupt;
|
---|
| 1212 | #endif
|
---|
| 1213 | Log(("PDM: Registered PIC device '%s'/%d pDevIns=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, pDevIns));
|
---|
| 1214 |
|
---|
| 1215 | /* set the helper pointer and return. */
|
---|
| 1216 | AssertFailed();
|
---|
| 1217 | *ppPicHlp = NULL; //&g_pdmR0PicHlp;
|
---|
| 1218 | LogFlow(("pdmR0DevHlp_PICSetUpContext: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, VINF_SUCCESS));
|
---|
| 1219 | return VINF_SUCCESS;
|
---|
| 1220 | }
|
---|
| 1221 |
|
---|
| 1222 |
|
---|
| 1223 | /** @interface_method_impl{PDMDEVHLPR0,pfnApicSetUpContext} */
|
---|
| 1224 | static DECLCALLBACK(int) pdmR0DevHlp_ApicSetUpContext(PPDMDEVINS pDevIns)
|
---|
| 1225 | {
|
---|
| 1226 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 1227 | LogFlow(("pdmR0DevHlp_ApicSetUpContext: caller='%s'/%d:\n", pDevIns->pReg->szName, pDevIns->iInstance));
|
---|
| 1228 | #if 0
|
---|
| 1229 | PGVM pGVM = pDevIns->Internal.s.pGVM;
|
---|
| 1230 |
|
---|
| 1231 | /*
|
---|
| 1232 | * Validate input.
|
---|
| 1233 | */
|
---|
| 1234 | VM_ASSERT_STATE_RETURN(pGVM, VMSTATE_CREATING, VERR_WRONG_ORDER);
|
---|
| 1235 | VM_ASSERT_EMT0_RETURN(pGVM, VERR_VM_THREAD_NOT_EMT);
|
---|
| 1236 |
|
---|
| 1237 | /* Check that it's the same device as made the ring-3 registrations: */
|
---|
| 1238 | AssertLogRelMsgReturn(pGVM->pdm.s.Apic.pDevInsR3 == pDevIns->pDevInsForR3,
|
---|
| 1239 | ("%p vs %p\n", pGVM->pdm.s.Apic.pDevInsR3, pDevIns->pDevInsForR3), VERR_NOT_OWNER);
|
---|
| 1240 |
|
---|
| 1241 | /* Check that it isn't already registered in ring-0: */
|
---|
| 1242 | AssertLogRelMsgReturn(pGVM->pdm.s.Apic.pDevInsR0 == NULL, ("%p (caller pDevIns=%p)\n", pGVM->pdm.s.Apic.pDevInsR0, pDevIns),
|
---|
| 1243 | VERR_ALREADY_EXISTS);
|
---|
| 1244 |
|
---|
| 1245 | /*
|
---|
| 1246 | * Take down the instance.
|
---|
| 1247 | */
|
---|
| 1248 | pGVM->pdm.s.Apic.pDevInsR0 = pDevIns;
|
---|
| 1249 | #endif
|
---|
| 1250 | Log(("PDM: Registered APIC device '%s'/%d pDevIns=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, pDevIns));
|
---|
| 1251 |
|
---|
| 1252 | /* set the helper pointer and return. */
|
---|
| 1253 | LogFlow(("pdmR0DevHlp_ApicSetUpContext: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, VINF_SUCCESS));
|
---|
| 1254 | return VINF_SUCCESS;
|
---|
| 1255 | }
|
---|
| 1256 |
|
---|
| 1257 |
|
---|
| 1258 | /** @interface_method_impl{PDMDEVHLPR0,pfnIoApicSetUpContext} */
|
---|
| 1259 | static DECLCALLBACK(int) pdmR0DevHlp_IoApicSetUpContext(PPDMDEVINS pDevIns, PPDMIOAPICREG pIoApicReg, PCPDMIOAPICHLP *ppIoApicHlp)
|
---|
| 1260 | {
|
---|
| 1261 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 1262 | LogFlow(("pdmR0DevHlp_IoApicSetUpContext: caller='%s'/%d: pIoApicReg=%p:{.u32Version=%#x, .pfnSetIrq=%p, .pfnSendMsi=%p, .pfnSetEoi=%p, .u32TheEnd=%#x } ppIoApicHlp=%p\n",
|
---|
| 1263 | pDevIns->pReg->szName, pDevIns->iInstance, pIoApicReg, pIoApicReg->u32Version, pIoApicReg->pfnSetIrq, pIoApicReg->pfnSendMsi, pIoApicReg->pfnSetEoi, pIoApicReg->u32TheEnd, ppIoApicHlp));
|
---|
| 1264 | #if 0
|
---|
| 1265 | PGVM pGVM = pDevIns->Internal.s.pGVM;
|
---|
| 1266 |
|
---|
| 1267 | /*
|
---|
| 1268 | * Validate input.
|
---|
| 1269 | */
|
---|
| 1270 | AssertMsgReturn(pIoApicReg->u32Version == PDM_IOAPICREG_VERSION,
|
---|
| 1271 | ("%s/%d: u32Version=%#x expected %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, pIoApicReg->u32Version, PDM_IOAPICREG_VERSION),
|
---|
| 1272 | VERR_VERSION_MISMATCH);
|
---|
| 1273 | AssertPtrReturn(pIoApicReg->pfnSetIrq, VERR_INVALID_POINTER);
|
---|
| 1274 | AssertPtrReturn(pIoApicReg->pfnSendMsi, VERR_INVALID_POINTER);
|
---|
| 1275 | AssertPtrReturn(pIoApicReg->pfnSetEoi, VERR_INVALID_POINTER);
|
---|
| 1276 | AssertMsgReturn(pIoApicReg->u32TheEnd == PDM_IOAPICREG_VERSION,
|
---|
| 1277 | ("%s/%d: u32TheEnd=%#x expected %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, pIoApicReg->u32TheEnd, PDM_IOAPICREG_VERSION),
|
---|
| 1278 | VERR_VERSION_MISMATCH);
|
---|
| 1279 | AssertPtrReturn(ppIoApicHlp, VERR_INVALID_POINTER);
|
---|
| 1280 |
|
---|
| 1281 | VM_ASSERT_STATE_RETURN(pGVM, VMSTATE_CREATING, VERR_WRONG_ORDER);
|
---|
| 1282 | VM_ASSERT_EMT0_RETURN(pGVM, VERR_VM_THREAD_NOT_EMT);
|
---|
| 1283 |
|
---|
| 1284 | /* Check that it's the same device as made the ring-3 registrations: */
|
---|
| 1285 | AssertLogRelMsgReturn(pGVM->pdm.s.IoApic.pDevInsR3 == pDevIns->pDevInsForR3,
|
---|
| 1286 | ("%p vs %p\n", pGVM->pdm.s.IoApic.pDevInsR3, pDevIns->pDevInsForR3), VERR_NOT_OWNER);
|
---|
| 1287 |
|
---|
| 1288 | /* Check that it isn't already registered in ring-0: */
|
---|
| 1289 | AssertLogRelMsgReturn(pGVM->pdm.s.IoApic.pDevInsR0 == NULL, ("%p (caller pDevIns=%p)\n", pGVM->pdm.s.IoApic.pDevInsR0, pDevIns),
|
---|
| 1290 | VERR_ALREADY_EXISTS);
|
---|
| 1291 |
|
---|
| 1292 | /*
|
---|
| 1293 | * Take down the callbacks and instance.
|
---|
| 1294 | */
|
---|
| 1295 | pGVM->pdm.s.IoApic.pDevInsR0 = pDevIns;
|
---|
| 1296 | pGVM->pdm.s.IoApic.pfnSetIrqR0 = pIoApicReg->pfnSetIrq;
|
---|
| 1297 | pGVM->pdm.s.IoApic.pfnSendMsiR0 = pIoApicReg->pfnSendMsi;
|
---|
| 1298 | pGVM->pdm.s.IoApic.pfnSetEoiR0 = pIoApicReg->pfnSetEoi;
|
---|
| 1299 | #endif
|
---|
| 1300 | Log(("PDM: Registered IOAPIC device '%s'/%d pDevIns=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, pDevIns));
|
---|
| 1301 |
|
---|
| 1302 | /* set the helper pointer and return. */
|
---|
| 1303 | AssertFailed();
|
---|
| 1304 | *ppIoApicHlp = NULL; //&g_pdmR0IoApicHlp;
|
---|
| 1305 | LogFlow(("pdmR0DevHlp_IoApicSetUpContext: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, VINF_SUCCESS));
|
---|
| 1306 | return VINF_SUCCESS;
|
---|
| 1307 | }
|
---|
| 1308 |
|
---|
| 1309 |
|
---|
| 1310 | /** @interface_method_impl{PDMDEVHLPR0,pfnHpetSetUpContext} */
|
---|
| 1311 | static DECLCALLBACK(int) pdmR0DevHlp_HpetSetUpContext(PPDMDEVINS pDevIns, PPDMHPETREG pHpetReg, PCPDMHPETHLPR0 *ppHpetHlp)
|
---|
| 1312 | {
|
---|
| 1313 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 1314 | LogFlow(("pdmR0DevHlp_HpetSetUpContext: caller='%s'/%d: pHpetReg=%p:{.u32Version=%#x, } ppHpetHlp=%p\n",
|
---|
| 1315 | pDevIns->pReg->szName, pDevIns->iInstance, pHpetReg, pHpetReg->u32Version, ppHpetHlp));
|
---|
| 1316 | #if 0
|
---|
| 1317 | PGVM pGVM = pDevIns->Internal.s.pGVM;
|
---|
| 1318 |
|
---|
| 1319 | /*
|
---|
| 1320 | * Validate input.
|
---|
| 1321 | */
|
---|
| 1322 | AssertMsgReturn(pHpetReg->u32Version == PDM_HPETREG_VERSION,
|
---|
| 1323 | ("%s/%d: u32Version=%#x expected %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, pHpetReg->u32Version, PDM_HPETREG_VERSION),
|
---|
| 1324 | VERR_VERSION_MISMATCH);
|
---|
| 1325 | AssertPtrReturn(ppHpetHlp, VERR_INVALID_POINTER);
|
---|
| 1326 |
|
---|
| 1327 | VM_ASSERT_STATE_RETURN(pGVM, VMSTATE_CREATING, VERR_WRONG_ORDER);
|
---|
| 1328 | VM_ASSERT_EMT0_RETURN(pGVM, VERR_VM_THREAD_NOT_EMT);
|
---|
| 1329 |
|
---|
| 1330 | /* Check that it's the same device as made the ring-3 registrations: */
|
---|
| 1331 | AssertLogRelMsgReturn(pGVM->pdm.s.pHpet == pDevIns->pDevInsForR3, ("%p vs %p\n", pGVM->pdm.s.pHpet, pDevIns->pDevInsForR3),
|
---|
| 1332 | VERR_NOT_OWNER);
|
---|
| 1333 |
|
---|
| 1334 | ///* Check that it isn't already registered in ring-0: */
|
---|
| 1335 | //AssertLogRelMsgReturn(pGVM->pdm.s.Hpet.pDevInsR0 == NULL, ("%p (caller pDevIns=%p)\n", pGVM->pdm.s.Hpet.pDevInsR0, pDevIns),
|
---|
| 1336 | // VERR_ALREADY_EXISTS);
|
---|
| 1337 | #endif
|
---|
| 1338 | /*
|
---|
| 1339 | * Nothing to take down here at present.
|
---|
| 1340 | */
|
---|
| 1341 | Log(("PDM: Registered HPET device '%s'/%d pDevIns=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, pDevIns));
|
---|
| 1342 |
|
---|
| 1343 | /* set the helper pointer and return. */
|
---|
| 1344 | AssertFailed();
|
---|
| 1345 | *ppHpetHlp = NULL; //&g_pdmR0HpetHlp;
|
---|
| 1346 | LogFlow(("pdmR0DevHlp_HpetSetUpContext: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, VINF_SUCCESS));
|
---|
| 1347 | return VINF_SUCCESS;
|
---|
| 1348 | }
|
---|
| 1349 |
|
---|
| 1350 |
|
---|
| 1351 | /** @interface_method_impl{PDMDEVHLPR0,pfnPGMHandlerPhysicalPageTempOff} */
|
---|
| 1352 | static DECLCALLBACK(int) pdmR0DevHlp_PGMHandlerPhysicalPageTempOff(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, RTGCPHYS GCPhysPage)
|
---|
| 1353 | {
|
---|
| 1354 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 1355 | LogFlow(("pdmR0DevHlp_PGMHandlerPhysicalPageTempOff: caller='%s'/%d: GCPhys=%RGp\n", pDevIns->pReg->szName, pDevIns->iInstance, GCPhys));
|
---|
| 1356 |
|
---|
| 1357 | AssertFailed();
|
---|
| 1358 | int rc = VERR_NOT_IMPLEMENTED; //PGMHandlerPhysicalPageTempOff(pDevIns->Internal.s.pGVM, GCPhys, GCPhysPage);
|
---|
| 1359 |
|
---|
| 1360 | Log(("pdmR0DevHlp_PGMHandlerPhysicalPageTempOff: caller='%s'/%d: returns %Rrc\n",
|
---|
| 1361 | pDevIns->pReg->szName, pDevIns->iInstance, rc));
|
---|
| 1362 | return rc;
|
---|
| 1363 | }
|
---|
| 1364 |
|
---|
| 1365 |
|
---|
| 1366 | /** @interface_method_impl{PDMDEVHLPR0,pfnMmioMapMmio2Page} */
|
---|
| 1367 | static DECLCALLBACK(int) pdmR0DevHlp_MmioMapMmio2Page(PPDMDEVINS pDevIns, IOMMMIOHANDLE hRegion, RTGCPHYS offRegion,
|
---|
| 1368 | uint64_t hMmio2, RTGCPHYS offMmio2, uint64_t fPageFlags)
|
---|
| 1369 | {
|
---|
| 1370 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 1371 | LogFlow(("pdmR0DevHlp_MmioMapMmio2Page: caller='%s'/%d: hRegion=%RX64 offRegion=%RGp hMmio2=%RX64 offMmio2=%RGp fPageFlags=%RX64\n",
|
---|
| 1372 | pDevIns->pReg->szName, pDevIns->iInstance, hRegion, offRegion, hMmio2, offMmio2, fPageFlags));
|
---|
| 1373 |
|
---|
| 1374 | AssertFailed();
|
---|
| 1375 | int rc = VERR_NOT_IMPLEMENTED; //IOMMmioMapMmio2Page(pDevIns->Internal.s.pGVM, pDevIns, hRegion, offRegion, hMmio2, offMmio2, fPageFlags);
|
---|
| 1376 |
|
---|
| 1377 | Log(("pdmR0DevHlp_MmioMapMmio2Page: caller='%s'/%d: returns %Rrc\n",
|
---|
| 1378 | pDevIns->pReg->szName, pDevIns->iInstance, rc));
|
---|
| 1379 | return rc;
|
---|
| 1380 | }
|
---|
| 1381 |
|
---|
| 1382 |
|
---|
| 1383 | /** @interface_method_impl{PDMDEVHLPR0,pfnMmioResetRegion} */
|
---|
| 1384 | static DECLCALLBACK(int) pdmR0DevHlp_MmioResetRegion(PPDMDEVINS pDevIns, IOMMMIOHANDLE hRegion)
|
---|
| 1385 | {
|
---|
| 1386 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 1387 | LogFlow(("pdmR0DevHlp_MmioResetRegion: caller='%s'/%d: hRegion=%RX64\n",
|
---|
| 1388 | pDevIns->pReg->szName, pDevIns->iInstance, hRegion));
|
---|
| 1389 |
|
---|
| 1390 | AssertFailed();
|
---|
| 1391 | int rc = VERR_NOT_IMPLEMENTED; //IOMMmioResetRegion(pDevIns->Internal.s.pGVM, pDevIns, hRegion);
|
---|
| 1392 |
|
---|
| 1393 | Log(("pdmR0DevHlp_MmioResetRegion: caller='%s'/%d: returns %Rrc\n",
|
---|
| 1394 | pDevIns->pReg->szName, pDevIns->iInstance, rc));
|
---|
| 1395 | return rc;
|
---|
| 1396 | }
|
---|
| 1397 |
|
---|
| 1398 |
|
---|
| 1399 | /** @interface_method_impl{PDMDEVHLPR0,pfnGIMGetMmio2Regions} */
|
---|
| 1400 | static DECLCALLBACK(PGIMMMIO2REGION) pdmR0DevHlp_GIMGetMmio2Regions(PPDMDEVINS pDevIns, uint32_t *pcRegions)
|
---|
| 1401 | {
|
---|
| 1402 | PDMDEV_ASSERT_DEVINS(pDevIns);
|
---|
| 1403 |
|
---|
| 1404 | LogFlow(("pdmR0DevHlp_GIMGetMmio2Regions: caller='%s'/%d: pcRegions=%p\n",
|
---|
| 1405 | pDevIns->pReg->szName, pDevIns->iInstance, pcRegions));
|
---|
| 1406 |
|
---|
| 1407 | AssertFailed();
|
---|
| 1408 | PGIMMMIO2REGION pRegion = NULL; //GIMGetMmio2Regions(pDevIns->Internal.s.pGVM, pcRegions);
|
---|
| 1409 |
|
---|
| 1410 | LogFlow(("pdmR0DevHlp_GIMGetMmio2Regions: caller='%s'/%d: returns %p\n", pDevIns->pReg->szName, pDevIns->iInstance, pRegion));
|
---|
| 1411 | return pRegion;
|
---|
| 1412 | }
|
---|
| 1413 |
|
---|
| 1414 |
|
---|
| 1415 | /**
|
---|
| 1416 | * The Ring-0 Device Helper Callbacks.
|
---|
| 1417 | */
|
---|
| 1418 | const PDMDEVHLPR0 g_tstDevPdmDevHlpR0 =
|
---|
| 1419 | {
|
---|
| 1420 | PDM_DEVHLPR0_VERSION,
|
---|
| 1421 | pdmR0DevHlp_IoPortSetUpContextEx,
|
---|
| 1422 | pdmR0DevHlp_MmioSetUpContextEx,
|
---|
| 1423 | pdmR0DevHlp_Mmio2SetUpContext,
|
---|
| 1424 | pdmR0DevHlp_PCIPhysRead,
|
---|
| 1425 | pdmR0DevHlp_PCIPhysWrite,
|
---|
| 1426 | pdmR0DevHlp_PCISetIrq,
|
---|
| 1427 | pdmR0DevHlp_ISASetIrq,
|
---|
| 1428 | pdmR0DevHlp_PhysRead,
|
---|
| 1429 | pdmR0DevHlp_PhysWrite,
|
---|
| 1430 | pdmR0DevHlp_A20IsEnabled,
|
---|
| 1431 | pdmR0DevHlp_VMState,
|
---|
| 1432 | pdmR0DevHlp_GetVM,
|
---|
| 1433 | pdmR0DevHlp_GetVMCPU,
|
---|
| 1434 | pdmR0DevHlp_GetCurrentCpuId,
|
---|
[93110] | 1435 | pdmR0DevHlp_GetMainExecutionEngine,
|
---|
[92079] | 1436 | pdmR0DevHlp_TimerFromMicro,
|
---|
| 1437 | pdmR0DevHlp_TimerFromMilli,
|
---|
| 1438 | pdmR0DevHlp_TimerFromNano,
|
---|
| 1439 | pdmR0DevHlp_TimerGet,
|
---|
| 1440 | pdmR0DevHlp_TimerGetFreq,
|
---|
| 1441 | pdmR0DevHlp_TimerGetNano,
|
---|
| 1442 | pdmR0DevHlp_TimerIsActive,
|
---|
| 1443 | pdmR0DevHlp_TimerIsLockOwner,
|
---|
| 1444 | pdmR0DevHlp_TimerLockClock,
|
---|
| 1445 | pdmR0DevHlp_TimerLockClock2,
|
---|
| 1446 | pdmR0DevHlp_TimerSet,
|
---|
| 1447 | pdmR0DevHlp_TimerSetFrequencyHint,
|
---|
| 1448 | pdmR0DevHlp_TimerSetMicro,
|
---|
| 1449 | pdmR0DevHlp_TimerSetMillies,
|
---|
| 1450 | pdmR0DevHlp_TimerSetNano,
|
---|
| 1451 | pdmR0DevHlp_TimerSetRelative,
|
---|
| 1452 | pdmR0DevHlp_TimerStop,
|
---|
| 1453 | pdmR0DevHlp_TimerUnlockClock,
|
---|
| 1454 | pdmR0DevHlp_TimerUnlockClock2,
|
---|
| 1455 | pdmR0DevHlp_TMTimeVirtGet,
|
---|
| 1456 | pdmR0DevHlp_TMTimeVirtGetFreq,
|
---|
| 1457 | pdmR0DevHlp_TMTimeVirtGetNano,
|
---|
| 1458 | pdmR0DevHlp_QueueAlloc,
|
---|
| 1459 | pdmR0DevHlp_QueueInsert,
|
---|
| 1460 | pdmR0DevHlp_QueueFlushIfNecessary,
|
---|
| 1461 | pdmR0DevHlp_TaskTrigger,
|
---|
| 1462 | pdmR0DevHlp_SUPSemEventSignal,
|
---|
| 1463 | pdmR0DevHlp_SUPSemEventWaitNoResume,
|
---|
| 1464 | pdmR0DevHlp_SUPSemEventWaitNsAbsIntr,
|
---|
| 1465 | pdmR0DevHlp_SUPSemEventWaitNsRelIntr,
|
---|
| 1466 | pdmR0DevHlp_SUPSemEventGetResolution,
|
---|
| 1467 | pdmR0DevHlp_SUPSemEventMultiSignal,
|
---|
| 1468 | pdmR0DevHlp_SUPSemEventMultiReset,
|
---|
| 1469 | pdmR0DevHlp_SUPSemEventMultiWaitNoResume,
|
---|
| 1470 | pdmR0DevHlp_SUPSemEventMultiWaitNsAbsIntr,
|
---|
| 1471 | pdmR0DevHlp_SUPSemEventMultiWaitNsRelIntr,
|
---|
| 1472 | pdmR0DevHlp_SUPSemEventMultiGetResolution,
|
---|
| 1473 | pdmR0DevHlp_CritSectGetNop,
|
---|
| 1474 | pdmR0DevHlp_SetDeviceCritSect,
|
---|
| 1475 | pdmR0DevHlp_CritSectEnter,
|
---|
| 1476 | pdmR0DevHlp_CritSectEnterDebug,
|
---|
| 1477 | pdmR0DevHlp_CritSectTryEnter,
|
---|
| 1478 | pdmR0DevHlp_CritSectTryEnterDebug,
|
---|
| 1479 | pdmR0DevHlp_CritSectLeave,
|
---|
| 1480 | pdmR0DevHlp_CritSectIsOwner,
|
---|
| 1481 | pdmR0DevHlp_CritSectIsInitialized,
|
---|
| 1482 | pdmR0DevHlp_CritSectHasWaiters,
|
---|
| 1483 | pdmR0DevHlp_CritSectGetRecursion,
|
---|
| 1484 | pdmR0DevHlp_CritSectScheduleExitEvent,
|
---|
| 1485 | pdmR0DevHlp_CritSectRwEnterShared,
|
---|
| 1486 | pdmR0DevHlp_CritSectRwEnterSharedDebug,
|
---|
| 1487 | pdmR0DevHlp_CritSectRwTryEnterShared,
|
---|
| 1488 | pdmR0DevHlp_CritSectRwTryEnterSharedDebug,
|
---|
| 1489 | pdmR0DevHlp_CritSectRwLeaveShared,
|
---|
| 1490 | pdmR0DevHlp_CritSectRwEnterExcl,
|
---|
| 1491 | pdmR0DevHlp_CritSectRwEnterExclDebug,
|
---|
| 1492 | pdmR0DevHlp_CritSectRwTryEnterExcl,
|
---|
| 1493 | pdmR0DevHlp_CritSectRwTryEnterExclDebug,
|
---|
| 1494 | pdmR0DevHlp_CritSectRwLeaveExcl,
|
---|
| 1495 | pdmR0DevHlp_CritSectRwIsWriteOwner,
|
---|
| 1496 | pdmR0DevHlp_CritSectRwIsReadOwner,
|
---|
| 1497 | pdmR0DevHlp_CritSectRwGetWriteRecursion,
|
---|
| 1498 | pdmR0DevHlp_CritSectRwGetWriterReadRecursion,
|
---|
| 1499 | pdmR0DevHlp_CritSectRwGetReadCount,
|
---|
| 1500 | pdmR0DevHlp_CritSectRwIsInitialized,
|
---|
| 1501 | pdmR0DevHlp_DBGFTraceBuf,
|
---|
| 1502 | pdmR0DevHlp_PCIBusSetUpContext,
|
---|
| 1503 | pdmR0DevHlp_IommuSetUpContext,
|
---|
| 1504 | pdmR0DevHlp_PICSetUpContext,
|
---|
| 1505 | pdmR0DevHlp_ApicSetUpContext,
|
---|
| 1506 | pdmR0DevHlp_IoApicSetUpContext,
|
---|
| 1507 | pdmR0DevHlp_HpetSetUpContext,
|
---|
| 1508 | pdmR0DevHlp_PGMHandlerPhysicalPageTempOff,
|
---|
| 1509 | pdmR0DevHlp_MmioMapMmio2Page,
|
---|
| 1510 | pdmR0DevHlp_MmioResetRegion,
|
---|
| 1511 | pdmR0DevHlp_GIMGetMmio2Regions,
|
---|
| 1512 | NULL /*pfnReserved1*/,
|
---|
| 1513 | NULL /*pfnReserved2*/,
|
---|
| 1514 | NULL /*pfnReserved3*/,
|
---|
| 1515 | NULL /*pfnReserved4*/,
|
---|
| 1516 | NULL /*pfnReserved5*/,
|
---|
| 1517 | NULL /*pfnReserved6*/,
|
---|
| 1518 | NULL /*pfnReserved7*/,
|
---|
| 1519 | NULL /*pfnReserved8*/,
|
---|
| 1520 | NULL /*pfnReserved9*/,
|
---|
| 1521 | NULL /*pfnReserved10*/,
|
---|
| 1522 | PDM_DEVHLPR0_VERSION
|
---|
| 1523 | };
|
---|