VirtualBox

Changeset 81961 in vbox


Ignore:
Timestamp:
Nov 18, 2019 7:06:25 PM (5 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
134758
Message:

DevHPET,PDM: Split structures and refactored registration. bugref:9218

Location:
trunk
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/vmm/pdmdev.h

    r81950 r81961  
    15561556    /** Struct version+magic number (PDM_HPETREG_VERSION). */
    15571557    uint32_t            u32Version;
    1558 
    15591558} PDMHPETREG;
    15601559/** Pointer to an HPET registration structure. */
    … …  
    16181617    /** Structure version. PDM_HPETHLP_VERSION defines the current version. */
    16191618    uint32_t                u32Version;
    1620 
    1621     /**
    1622      * Gets the address of the RC HPET helpers.
    1623      *
    1624      * This should be called at both construction and relocation time
    1625      * to obtain the correct address of the RC helpers.
    1626      *
    1627      * @returns RC pointer to the HPET helpers.
    1628      * @param   pDevIns         Device instance of the HPET.
    1629      */
    1630     DECLR3CALLBACKMEMBER(PCPDMHPETHLPRC, pfnGetRCHelpers,(PPDMDEVINS pDevIns));
    1631 
    1632     /**
    1633      * Gets the address of the R0 HPET helpers.
    1634      *
    1635      * This should be called at both construction and relocation time
    1636      * to obtain the correct address of the R0 helpers.
    1637      *
    1638      * @returns R0 pointer to the HPET helpers.
    1639      * @param   pDevIns         Device instance of the HPET.
    1640      */
    1641     DECLR3CALLBACKMEMBER(PCPDMHPETHLPR0, pfnGetR0Helpers,(PPDMDEVINS pDevIns));
    16421619
    16431620    /**
    … …  
    16731650
    16741651/** Current PDMHPETHLPR3 version number. */
    1675 #define PDM_HPETHLPR3_VERSION                   PDM_VERSION_MAKE(0xffec, 2, 0)
     1652#define PDM_HPETHLPR3_VERSION                   PDM_VERSION_MAKE(0xffec, 3, 0)
    16761653
    16771654
    … …  
    37873764     *                              helpers.
    37883765     */
    3789     DECLR3CALLBACKMEMBER(int, pfnHPETRegister,(PPDMDEVINS pDevIns, PPDMHPETREG pHpetReg, PCPDMHPETHLPR3 *ppHpetHlpR3));
     3766    DECLR3CALLBACKMEMBER(int, pfnHpetRegister,(PPDMDEVINS pDevIns, PPDMHPETREG pHpetReg, PCPDMHPETHLPR3 *ppHpetHlpR3));
    37903767
    37913768    /**
    … …  
    46884665     * @param   ppPicHlp    Where to return the ring-0 PIC helpers.
    46894666     */
    4690     DECLR0CALLBACKMEMBER(int, pfnPICSetUpContext,(PPDMDEVINS pDevIns, PPDMPICREG pPicReg, PCPDMPICHLP *ppPicHlp));
     4667    DECLRCCALLBACKMEMBER(int, pfnPICSetUpContext,(PPDMDEVINS pDevIns, PPDMPICREG pPicReg, PCPDMPICHLP *ppPicHlp));
    46914668
    46924669    /**
    … …  
    47024679     * @param   ppIoApicHlp Where to return the ring-0 IOAPIC helpers.
    47034680     */
    4704     DECLR0CALLBACKMEMBER(int, pfnIoApicSetUpContext,(PPDMDEVINS pDevIns, PPDMIOAPICREG pIoApicReg, PCPDMIOAPICHLP *ppIoApicHlp));
     4681    DECLRCCALLBACKMEMBER(int, pfnIoApicSetUpContext,(PPDMDEVINS pDevIns, PPDMIOAPICREG pIoApicReg, PCPDMIOAPICHLP *ppIoApicHlp));
     4682
     4683    /**
     4684     * Sets up the HPET for the raw-mode context.
     4685     *
     4686     * This must be called after ring-3 has registered the PIC using
     4687     * PDMDevHlpHpetRegister().
     4688     *
     4689     * @returns VBox status code.
     4690     * @param   pDevIns     The device instance.
     4691     * @param   pHpetReg    The PIC registration information for raw-mode,
     4692     *                      considered volatile and copied.
     4693     * @param   ppHpetHlp   Where to return the raw-mode HPET helpers.
     4694     */
     4695    DECLRCCALLBACKMEMBER(int, pfnHpetSetUpContext,(PPDMDEVINS pDevIns, PPDMHPETREG pHpetReg, PCPDMHPETHLPRC *ppHpetHlp));
    47054696
    47064697    /** Space reserved for future members.
    … …  
    47274718
    47284719/** Current PDMDEVHLP version number. */
    4729 #define PDM_DEVHLPRC_VERSION                    PDM_VERSION_MAKE(0xffe6, 12, 0)
     4720#define PDM_DEVHLPRC_VERSION                    PDM_VERSION_MAKE(0xffe6, 13, 0)
    47304721
    47314722
    … …  
    51975188    DECLR0CALLBACKMEMBER(int, pfnIoApicSetUpContext,(PPDMDEVINS pDevIns, PPDMIOAPICREG pIoApicReg, PCPDMIOAPICHLP *ppIoApicHlp));
    51985189
     5190    /**
     5191     * Sets up the HPET for the ring-0 context.
     5192     *
     5193     * This must be called after ring-3 has registered the PIC using
     5194     * PDMDevHlpHpetRegister().
     5195     *
     5196     * @returns VBox status code.
     5197     * @param   pDevIns     The device instance.
     5198     * @param   pHpetReg    The PIC registration information for ring-0,
     5199     *                      considered volatile and copied.
     5200     * @param   ppHpetHlp   Where to return the ring-0 HPET helpers.
     5201     */
     5202    DECLR0CALLBACKMEMBER(int, pfnHpetSetUpContext,(PPDMDEVINS pDevIns, PPDMHPETREG pHpetReg, PCPDMHPETHLPR0 *ppHpetHlp));
     5203
    51995204    /** Space reserved for future members.
    52005205     * @{ */
    … …  
    52205225
    52215226/** Current PDMDEVHLP version number. */
    5222 #define PDM_DEVHLPR0_VERSION                    PDM_VERSION_MAKE(0xffe5, 13, 0)
     5227#define PDM_DEVHLPR0_VERSION                    PDM_VERSION_MAKE(0xffe5, 14, 0)
    52235228
    52245229
    … …  
    77157720
    77167721/**
    7717  * @copydoc PDMDEVHLPR3::pfnHPETRegister
    7718  */
    7719 DECLINLINE(int) PDMDevHlpHPETRegister(PPDMDEVINS pDevIns, PPDMHPETREG pHpetReg, PCPDMHPETHLPR3 *ppHpetHlpR3)
    7720 {
    7721     return pDevIns->pHlpR3->pfnHPETRegister(pDevIns, pHpetReg, ppHpetHlpR3);
     7722 * @copydoc PDMDEVHLPR3::pfnHpetRegister
     7723 */
     7724DECLINLINE(int) PDMDevHlpHpetRegister(PPDMDEVINS pDevIns, PPDMHPETREG pHpetReg, PCPDMHPETHLPR3 *ppHpetHlpR3)
     7725{
     7726    return pDevIns->pHlpR3->pfnHpetRegister(pDevIns, pHpetReg, ppHpetHlpR3);
    77227727}
    77237728
    … …  
    78607865{
    78617866    return pDevIns->CTX_SUFF(pHlp)->pfnIoApicSetUpContext(pDevIns, pIoApicReg, ppIoApicHlp);
     7867}
     7868
     7869/**
     7870 * @copydoc PDMDEVHLPR0::pfnHpetSetUpContext
     7871 */
     7872DECLINLINE(int) PDMDevHlpHpetSetUpContext(PPDMDEVINS pDevIns, PPDMHPETREG pHpetReg, CTX_SUFF(PCPDMHPETHLP) *ppHpetHlp)
     7873{
     7874    return pDevIns->CTX_SUFF(pHlp)->pfnHpetSetUpContext(pDevIns, pHpetReg, ppHpetHlp);
    78627875}
    78637876

  • trunk/src/VBox/Devices/PC/DevHPET.cpp

    r81959 r81961  
    239239
    240240/**
    241  * The shared HPET state.
     241 * The shared HPET device state.
    242242 */
    243243typedef struct HPET
    244244{
    245     /** The HPET helpers - R3 Ptr. */
    246     PCPDMHPETHLPR3              pHpetHlpR3;
    247     /** The HPET helpers - R0 Ptr. */
    248     PCPDMHPETHLPR0              pHpetHlpR0;
    249     /** The HPET helpers - RC Ptr. */
    250     PCPDMHPETHLPRC              pHpetHlpRC;
    251     uint32_t                    u32Padding;
    252 
    253245    /** Timer structures. */
    254246    HPETTIMER                   aTimers[RT_MAX(HPET_NUM_TIMERS_PIIX, HPET_NUM_TIMERS_ICH9)];
    … …  
    288280
    289281
     282/**
     283 * The ring-3 specific HPET device state.
     284 */
     285typedef struct HPETR3
     286{
     287    /** The HPET helpers. */
     288    PCPDMHPETHLPR3              pHpetHlp;
     289} HPETR3;
     290/** Pointer to the ring-3 specific HPET device state. */
     291typedef HPETR3 *PHPETR3;
     292
     293
     294/**
     295 * The ring-0 specific HPET device state.
     296 */
     297typedef struct HPETR0
     298{
     299    /** The HPET helpers. */
     300    PCPDMHPETHLPR0              pHpetHlp;
     301} HPETR0;
     302/** Pointer to the ring-0 specific HPET device state. */
     303typedef HPETR0 *PHPETR0;
     304
     305
     306/**
     307 * The raw-mode specific HPET device state.
     308 */
     309typedef struct HPETRC
     310{
     311    /** The HPET helpers. */
     312    PCPDMHPETHLPRC              pHpetHlp;
     313} HPETRC;
     314/** Pointer to the raw-mode specific HPET device state. */
     315typedef HPETRC *PHPETRC;
     316
     317
     318/** The HPET device state specific to the current context. */
     319typedef CTX_SUFF(HPET) HPETCC;
     320/** Pointer to the HPET device state specific to the current context. */
     321typedef CTX_SUFF(PHPET) PHPETCC;
     322
     323
    290324#ifndef VBOX_DEVICE_STRUCT_TESTCASE
    291325
    … …  
    754788             * may request retry in R3 - so we must keep state intact.
    755789             */
    756             if (   ((iOldValue ^ u32NewValue) & HPET_CFG_LEGACY)
    757                 && pThis->pHpetHlpR3 != NIL_RTR3PTR)
     790            if ((iOldValue ^ u32NewValue) & HPET_CFG_LEGACY)
    758791            {
    759792#ifdef IN_RING3
    760                 rc = pThis->pHpetHlpR3->pfnSetLegacyMode(pDevIns, RT_BOOL(u32NewValue & HPET_CFG_LEGACY));
    761                 if (rc != VINF_SUCCESS)
     793                PHPETCC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PHPETCC);
     794                if (pThisCC->pHpetHlp != NULL)
     795                {
     796                    rc = pThisCC->pHpetHlp->pfnSetLegacyMode(pDevIns, RT_BOOL(u32NewValue & HPET_CFG_LEGACY));
     797                    if (rc != VINF_SUCCESS)
     798                    {
     799                        DEVHPET_UNLOCK_BOTH(pDevIns, pThis);
     800                        break;
     801                    }
     802                }
    762803#else
    763804                rc = VINF_IOM_R3_MMIO_WRITE;
     805                DEVHPET_UNLOCK_BOTH(pDevIns, pThis);
     806                break;
    764807#endif
    765                 {
    766                     DEVHPET_UNLOCK_BOTH(pDevIns, pThis);
    767                     break;
    768                 }
    769808            }
    770809
    … …  
    10411080           level-triggered mode yet. */
    10421081        if ((pHpetTimer->u64Config & HPET_TN_INT_TYPE) == HPET_TIMER_TYPE_EDGE)
    1043             pThis->pHpetHlpR3->pfnSetIrq(pDevIns, irq, PDM_IRQ_LEVEL_FLIP_FLOP);
     1082        {
     1083            PHPETCC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PHPETCC);
     1084            AssertReturnVoid(pThisCC);
     1085            pThisCC->pHpetHlp->pfnSetIrq(pDevIns, irq, PDM_IRQ_LEVEL_FLIP_FLOP);
     1086        }
    10441087        else
    10451088            AssertFailed();
    … …  
    12681311static DECLCALLBACK(void) hpetR3Relocate(PPDMDEVINS pDevIns, RTGCINTPTR offDelta)
    12691312{
    1270     PHPET pThis = PDMDEVINS_2_DATA(pDevIns, PHPET);
     1313    PHPETRC pThisRC = PDMINS_2_DATA_RC(pDevIns, PHPETRC);
    12711314    LogFlow(("hpetR3Relocate:\n"));
    1272     NOREF(offDelta);
    1273 
    1274     pThis->pHpetHlpRC   = pThis->pHpetHlpR3->pfnGetRCHelpers(pDevIns);
     1315
     1316    pThisRC->pHpetHlp += offDelta;
    12751317}
    12761318
    … …  
    12811323static DECLCALLBACK(void) hpetR3Reset(PPDMDEVINS pDevIns)
    12821324{
    1283     PHPET pThis = PDMDEVINS_2_DATA(pDevIns, PHPET);
     1325    PHPET   pThis   = PDMDEVINS_2_DATA(pDevIns, PHPET);
     1326    PHPETCC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PHPETCC);
    12841327    LogFlow(("hpetR3Reset:\n"));
    12851328
    … …  
    13351378     * Notify the PIT/RTC devices.
    13361379     */
    1337     if (pThis->pHpetHlpR3)
    1338         pThis->pHpetHlpR3->pfnSetLegacyMode(pDevIns, false /*fActive*/);
     1380    if (pThisCC->pHpetHlp)
     1381        pThisCC->pHpetHlp->pfnSetLegacyMode(pDevIns, false /*fActive*/);
    13391382}
    13401383
    … …  
    13471390    PDMDEV_CHECK_VERSIONS_RETURN(pDevIns);
    13481391    PHPET           pThis   = PDMDEVINS_2_DATA(pDevIns, PHPET);
     1392    PHPETCC         pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PHPETCC);
    13491393    PCPDMDEVHLPR3   pHlp    = pDevIns->pHlpR3;
    13501394
    … …  
    14091453    PDMHPETREG HpetReg;
    14101454    HpetReg.u32Version = PDM_HPETREG_VERSION;
    1411     rc = PDMDevHlpHPETRegister(pDevIns, &HpetReg, &pThis->pHpetHlpR3);
     1455    rc = PDMDevHlpHpetRegister(pDevIns, &HpetReg, &pThisCC->pHpetHlp);
    14121456    AssertRCReturn(rc, rc);
    14131457
    … …  
    14211465    AssertRCReturn(rc, rc);
    14221466
    1423     if (pDevIns->fRCEnabled)
    1424     {
    1425         pThis->pHpetHlpRC = pThis->pHpetHlpR3->pfnGetRCHelpers(pDevIns);
    1426     }
    1427 
    1428     if (pDevIns->fR0Enabled)
    1429     {
    1430         pThis->pHpetHlpR0 = pThis->pHpetHlpR3->pfnGetR0Helpers(pDevIns);
    1431         AssertReturn(pThis->pHpetHlpR0 != NIL_RTR0PTR, VERR_INTERNAL_ERROR);
    1432     }
    1433 
    14341467    /*
    14351468     * Register SSM state and info item.
    … …  
    14521485    PDMDEV_CHECK_VERSIONS_RETURN(pDevIns);
    14531486    PHPET   pThis   = PDMDEVINS_2_DATA(pDevIns, PHPET);
    1454     //PHPETCC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PHPETCC);
     1487    PHPETCC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PHPETCC);
    14551488
    14561489    int rc = PDMDevHlpSetDeviceCritSect(pDevIns, PDMDevHlpCritSectGetNop(pDevIns));
     1490    AssertRCReturn(rc, rc);
     1491
     1492    PDMHPETREG HpetReg;
     1493    HpetReg.u32Version = PDM_HPETREG_VERSION;
     1494    rc = PDMDevHlpHpetSetUpContext(pDevIns, &HpetReg, &pThisCC->pHpetHlp);
    14571495    AssertRCReturn(rc, rc);
    14581496
    … …  
    14731511    /* .uReserved0 = */             0,
    14741512    /* .szName = */                 "hpet",
    1475     /* .fFlags = */                 PDM_DEVREG_FLAGS_DEFAULT_BITS | PDM_DEVREG_FLAGS_RZ,
     1513    /* .fFlags = */                 PDM_DEVREG_FLAGS_DEFAULT_BITS | PDM_DEVREG_FLAGS_RZ | PDM_DEVREG_FLAGS_NEW_STYLE,
    14761514    /* .fClass = */                 PDM_DEVREG_CLASS_PIT,
    14771515    /* .cMaxInstances = */          1,
    14781516    /* .uSharedVersion = */         42,
    14791517    /* .cbInstanceShared = */       sizeof(HPET),
    1480     /* .cbInstanceCC = */           0,
    1481     /* .cbInstanceRC = */           0,
     1518    /* .cbInstanceCC = */           sizeof(HPETCC),
     1519    /* .cbInstanceRC = */           sizeof(HPETRC),
    14821520    /* .cMaxPciDevices = */         0,
    14831521    /* .cMaxMsixVectors = */        0,

  • trunk/src/VBox/VMM/VMMR0/PDMR0Device.cpp

    r81938 r81961  
    11891189    *ppIoApicHlp = &g_pdmR0IoApicHlp;
    11901190    LogFlow(("pdmR0DevHlp_IoApicSetUpContext: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, VINF_SUCCESS));
     1191    return VINF_SUCCESS;
     1192}
     1193
     1194
     1195/** @interface_method_impl{PDMDEVHLPR0,pfnHpetSetUpContext} */
     1196static DECLCALLBACK(int) pdmR0DevHlp_HpetSetUpContext(PPDMDEVINS pDevIns, PPDMHPETREG pHpetReg, PCPDMHPETHLPR0 *ppHpetHlp)
     1197{
     1198    PDMDEV_ASSERT_DEVINS(pDevIns);
     1199    LogFlow(("pdmR0DevHlp_HpetSetUpContext: caller='%s'/%d: pHpetReg=%p:{.u32Version=%#x, } ppHpetHlp=%p\n",
     1200             pDevIns->pReg->szName, pDevIns->iInstance, pHpetReg, pHpetReg->u32Version, ppHpetHlp));
     1201    PGVM pGVM = pDevIns->Internal.s.pGVM;
     1202
     1203    /*
     1204     * Validate input.
     1205     */
     1206    AssertMsgReturn(pHpetReg->u32Version == PDM_HPETREG_VERSION,
     1207                    ("%s/%d: u32Version=%#x expected %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, pHpetReg->u32Version, PDM_HPETREG_VERSION),
     1208                    VERR_VERSION_MISMATCH);
     1209    AssertPtrReturn(ppHpetHlp, VERR_INVALID_POINTER);
     1210
     1211    VM_ASSERT_STATE_RETURN(pGVM, VMSTATE_CREATING, VERR_WRONG_ORDER);
     1212    VM_ASSERT_EMT0_RETURN(pGVM, VERR_VM_THREAD_NOT_EMT);
     1213
     1214    /* Check that it's the same device as made the ring-3 registrations: */
     1215    AssertLogRelMsgReturn(pGVM->pdm.s.pHpet == pDevIns->pDevInsForR3, ("%p vs %p\n", pGVM->pdm.s.pHpet, pDevIns->pDevInsForR3),
     1216                          VERR_NOT_OWNER);
     1217
     1218    ///* Check that it isn't already registered in ring-0: */
     1219    //AssertLogRelMsgReturn(pGVM->pdm.s.Hpet.pDevInsR0 == NULL, ("%p (caller pDevIns=%p)\n", pGVM->pdm.s.Hpet.pDevInsR0, pDevIns),
     1220    //                      VERR_ALREADY_EXISTS);
     1221
     1222    /*
     1223     * Nothing to take down here at present.
     1224     */
     1225    Log(("PDM: Registered HPET device '%s'/%d pDevIns=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, pDevIns));
     1226
     1227    /* set the helper pointer and return. */
     1228    *ppHpetHlp = &g_pdmR0HpetHlp;
     1229    LogFlow(("pdmR0DevHlp_HpetSetUpContext: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, VINF_SUCCESS));
    11911230    return VINF_SUCCESS;
    11921231}
    … …  
    12721311    pdmR0DevHlp_PICSetUpContext,
    12731312    pdmR0DevHlp_IoApicSetUpContext,
     1313    pdmR0DevHlp_HpetSetUpContext,
    12741314    NULL /*pfnReserved1*/,
    12751315    NULL /*pfnReserved2*/,

  • trunk/src/VBox/VMM/VMMR3/PDMDevHlp.cpp

    r81951 r81961  
    37423742{
    37433743    PDMDEV_ASSERT_DEVINS(pDevIns);
    3744     VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
    37453744    LogFlow(("pdmR3DevHlp_IoApicRegister: caller='%s'/%d: pIoApicReg=%p:{.u32Version=%#x, .pfnSetIrq=%p, .pfnSendMsi=%p, .pfnSetEoi=%p, .u32TheEnd=%#x } ppIoApicHlp=%p\n",
    37463745             pDevIns->pReg->szName, pDevIns->iInstance, pIoApicReg, pIoApicReg->u32Version, pIoApicReg->pfnSetIrq, pIoApicReg->pfnSendMsi, pIoApicReg->pfnSetEoi, pIoApicReg->u32TheEnd, ppIoApicHlp));
     3746    PVM pVM = pDevIns->Internal.s.pVMR3;
    37473747
    37483748    /*
    … …  
    37593759                    VERR_VERSION_MISMATCH);
    37603760    AssertPtrReturn(ppIoApicHlp, VERR_INVALID_POINTER);
     3761    VM_ASSERT_STATE_RETURN(pVM, VMSTATE_CREATING, VERR_WRONG_ORDER);
     3762    VM_ASSERT_EMT0_RETURN(pVM, VERR_VM_THREAD_NOT_EMT);
    37613763
    37623764    /*
    … …  
    37643766     * If the I/O APIC does GC stuff so must the APIC.
    37653767     */
    3766     PVM pVM = pDevIns->Internal.s.pVMR3;
    37673768    AssertMsgReturn(pVM->pdm.s.Apic.pDevInsR3 != NULL, ("Configuration error / Init order error! No APIC!\n"), VERR_WRONG_ORDER);
    37683769
    … …  
    37713772     */
    37723773    AssertMsgReturn(pVM->pdm.s.IoApic.pDevInsR3 == NULL,
    3773                     ("Only one ioapic device is supported! (caller %s/%d)\n", pDevIns->pReg->szName, pDevIns->iInstance),
     3774                    ("Only one IOAPIC device is supported! (caller %s/%d)\n", pDevIns->pReg->szName, pDevIns->iInstance),
    37743775                    VERR_ALREADY_EXISTS);
    37753776
    … …  
    37903791
    37913792
    3792 /** @interface_method_impl{PDMDEVHLPR3,pfnHPETRegister} */
    3793 static DECLCALLBACK(int) pdmR3DevHlp_HPETRegister(PPDMDEVINS pDevIns, PPDMHPETREG pHpetReg, PCPDMHPETHLPR3 *ppHpetHlpR3)
    3794 {
    3795     PDMDEV_ASSERT_DEVINS(pDevIns); RT_NOREF_PV(pDevIns);
    3796     VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
    3797     LogFlow(("pdmR3DevHlp_HPETRegister: caller='%s'/%d:\n", pDevIns->pReg->szName, pDevIns->iInstance));
     3793/** @interface_method_impl{PDMDEVHLPR3,pfnHpetRegister} */
     3794static DECLCALLBACK(int) pdmR3DevHlp_HpetRegister(PPDMDEVINS pDevIns, PPDMHPETREG pHpetReg, PCPDMHPETHLPR3 *ppHpetHlpR3)
     3795{
     3796    PDMDEV_ASSERT_DEVINS(pDevIns);
     3797    LogFlow(("pdmR3DevHlp_HpetRegister: caller='%s'/%d:\n", pDevIns->pReg->szName, pDevIns->iInstance));
     3798    PVM pVM = pDevIns->Internal.s.pVMR3;
    37983799
    37993800    /*
    38003801     * Validate input.
    38013802     */
    3802     if (pHpetReg->u32Version != PDM_HPETREG_VERSION)
    3803     {
    3804         AssertMsgFailed(("u32Version=%#x expected %#x\n", pHpetReg->u32Version, PDM_HPETREG_VERSION));
    3805         LogFlow(("pdmR3DevHlp_HPETRegister: caller='%s'/%d: returns %Rrc (version)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    3806         return VERR_INVALID_PARAMETER;
    3807     }
    3808 
    3809     if (!ppHpetHlpR3)
    3810     {
    3811         Assert(ppHpetHlpR3);
    3812         LogFlow(("pdmR3DevHlp_HPETRegister: caller='%s'/%d: returns %Rrc (ppApicHlpR3)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    3813         return VERR_INVALID_PARAMETER;
    3814     }
    3815 
    3816     /* set the helper pointer and return. */
     3803    AssertMsgReturn(pHpetReg->u32Version == PDM_HPETREG_VERSION,
     3804                    ("%s/%u: u32Version=%#x expected %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, pHpetReg->u32Version, PDM_HPETREG_VERSION),
     3805                    VERR_VERSION_MISMATCH);
     3806    AssertPtrReturn(ppHpetHlpR3, VERR_INVALID_POINTER);
     3807    VM_ASSERT_STATE_RETURN(pVM, VMSTATE_CREATING, VERR_WRONG_ORDER);
     3808    VM_ASSERT_EMT0_RETURN(pVM, VERR_VM_THREAD_NOT_EMT);
     3809
     3810    /*
     3811     * Only one HPET device.
     3812     */
     3813    AssertMsgReturn(pVM->pdm.s.pHpet == NULL,
     3814                    ("Only one HPET device is supported! (caller %s/%d)\n", pDevIns->pReg->szName, pDevIns->iInstance),
     3815                    VERR_ALREADY_EXISTS);
     3816
     3817    /*
     3818     * Do the job (what there is of it).
     3819     */
     3820    pVM->pdm.s.pHpet = pDevIns;
    38173821    *ppHpetHlpR3 = &g_pdmR3DevHpetHlp;
    3818     LogFlow(("pdmR3DevHlp_HPETRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, VINF_SUCCESS));
     3822
     3823    LogFlow(("pdmR3DevHlp_HpetRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, VINF_SUCCESS));
    38193824    return VINF_SUCCESS;
    38203825}
    … …  
    45404545    pdmR3DevHlp_APICRegister,
    45414546    pdmR3DevHlp_IoApicRegister,
    4542     pdmR3DevHlp_HPETRegister,
     4547    pdmR3DevHlp_HpetRegister,
    45434548    pdmR3DevHlp_PciRawRegister,
    45444549    pdmR3DevHlp_DMACRegister,
    … …  
    50365041    pdmR3DevHlp_APICRegister,
    50375042    pdmR3DevHlp_IoApicRegister,
    5038     pdmR3DevHlp_HPETRegister,
     5043    pdmR3DevHlp_HpetRegister,
    50395044    pdmR3DevHlp_PciRawRegister,
    50405045    pdmR3DevHlp_DMACRegister,

  • trunk/src/VBox/VMM/VMMR3/PDMDevMiscHlp.cpp

    r81938 r81961  
    317317
    318318
    319 /** @interface_method_impl{PDMHPETHLPR3,pfnGetRCHelpers} */
    320 static DECLCALLBACK(PCPDMHPETHLPRC) pdmR3HpetHlp_GetRCHelpers(PPDMDEVINS pDevIns)
    321 {
    322     PDMDEV_ASSERT_DEVINS(pDevIns);
    323     PVM pVM = pDevIns->Internal.s.pVMR3;
    324     VM_ASSERT_EMT(pVM);
    325 
    326     RTRCPTR pRCHelpers = NIL_RTRCPTR;
    327     if (VM_IS_RAW_MODE_ENABLED(pVM))
    328     {
    329         int rc = PDMR3LdrGetSymbolRC(pVM, NULL, "g_pdmRCHpetHlp", &pRCHelpers);
    330         AssertReleaseRC(rc);
    331         AssertRelease(pRCHelpers);
    332     }
    333 
    334     LogFlow(("pdmR3HpetHlp_GetGCHelpers: caller='%s'/%d: returns %RRv\n",
    335              pDevIns->pReg->szName, pDevIns->iInstance, pRCHelpers));
    336     return pRCHelpers;
    337 }
    338 
    339 
    340 /** @interface_method_impl{PDMHPETHLPR3,pfnGetR0Helpers} */
    341 static DECLCALLBACK(PCPDMHPETHLPR0) pdmR3HpetHlp_GetR0Helpers(PPDMDEVINS pDevIns)
    342 {
    343     PDMDEV_ASSERT_DEVINS(pDevIns);
    344     PVM pVM = pDevIns->Internal.s.pVMR3;
    345     VM_ASSERT_EMT(pVM);
    346     PCPDMHPETHLPR0 pR0Helpers = 0;
    347     int rc = PDMR3LdrGetSymbolR0(pVM, NULL, "g_pdmR0HpetHlp", &pR0Helpers);
    348     AssertReleaseRC(rc);
    349     AssertRelease(pR0Helpers);
    350     LogFlow(("pdmR3HpetHlp_GetR0Helpers: caller='%s'/%d: returns %RHv\n",
    351              pDevIns->pReg->szName, pDevIns->iInstance, pR0Helpers));
    352     return pR0Helpers;
    353 }
    354 
    355 
    356319/**
    357320 * HPET Device Helpers.
    … …  
    360323{
    361324    PDM_HPETHLPR3_VERSION,
    362     pdmR3HpetHlp_GetRCHelpers,
    363     pdmR3HpetHlp_GetR0Helpers,
    364325    pdmR3HpetHlp_SetLegacyMode,
    365326    pdmR3HpetHlp_SetIrq,

  • trunk/src/VBox/VMM/include/PDMInternal.h

    r81948 r81961  
    12311231    /** The registered I/O APIC device. */
    12321232    PDMIOAPIC                       IoApic;
     1233    /** The registered HPET device. */
     1234    PPDMDEVINSR3                    pHpet;
    12331235
    12341236    /** List of registered devices. (FIFO) */
Note: See TracChangeset for help on using the changeset viewer.

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