VirtualBox

Changeset 82146 in vbox for trunk/src/VBox/Devices/Network


Ignore:
Timestamp:
Nov 24, 2019 11:16:54 AM (5 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
134956
Message:

DevPCNet: Split the state structure. Set new-style flag. bugref:9218

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Devices/Network/DevPCNet.cpp

    r82144 r82146  
    107107#define MAX_FRAME                       1536
    108108
    109 #define PCNETSTATE_2_DEVINS(pPCnet)            ((pPCnet)->CTX_SUFF(pDevIns))
    110 #define PCNET_INST_NR                          (PCNETSTATE_2_DEVINS(pThis)->iInstance)
     109#define PCNET_INST_NR                   (pThis->iInstance)
    111110
    112111/** @name Bus configuration registers
    … …  
    309308typedef struct PCNETSTATE
    310309{
    311     /** Pointer to the device instance - R3. */
    312     PPDMDEVINSR3                        pDevInsR3;
    313     /** Pointer to the connector of the attached network driver - R3. */
    314     PPDMINETWORKUPR3                    pDrvR3;
    315     /** Pointer to the attached network driver. */
    316     R3PTRTYPE(PPDMIBASE)                pDrvBase;
    317     /** LUN\#0 + status LUN: The base interface. */
    318     PDMIBASE                            IBase;
    319     /** LUN\#0: The network port interface. */
    320     PDMINETWORKDOWN                     INetworkDown;
    321     /** LUN\#0: The network config port interface. */
    322     PDMINETWORKCONFIG                   INetworkConfig;
    323 
    324     /** Pointer to the device instance - R0. */
    325     PPDMDEVINSR0                        pDevInsR0;
    326     /** Pointer to the connector of the attached network driver - R0. */
    327     PPDMINETWORKUPR0                    pDrvR0;
    328 
    329     /** Pointer to the device instance - RC. */
    330     PPDMDEVINSRC                        pDevInsRC;
    331     /** Pointer to the connector of the attached network driver - RC. */
    332     PPDMINETWORKUPRC                    pDrvRC;
    333 
    334310    /** Software Interrupt timer - R3. */
    335311    TMTIMERHANDLE                       hTimerSoftInt;
    … …  
    359335    uint16_t                            aBCR[BCR_MAX_RAP];
    360336    uint16_t                            aMII[MII_MAX_REG];
     337
    361338    /** Holds the bits which were really seen by the guest. Relevant are bits
    362339     * 8..14 (IDON, TINT, RINT, MERR, MISS, CERR, BABL). We don't allow the
    … …  
    364341     * seen by the guest. */
    365342    uint16_t                            u16CSR0LastSeenByGuest;
    366     /** Last time we polled the queues */
    367     uint64_t                            u64LastPoll;
    368 
    369     /** The loopback transmit buffer (avoid stack allocations). */
    370     uint8_t                             abLoopBuf[4096];
    371     /** The recv buffer. */
    372     uint8_t                             abRecvBuf[4096];
    373 
    374343    /** The configured IRQ for ISA operation. */
    375344    uint8_t                             uIsaIrq;
    376345    /** Alignment padding. */
    377     uint8_t                             Alignment2[3];
     346    uint8_t                             Alignment2[1+4];
     347
     348    /** Last time we polled the queues */
     349    uint64_t                            u64LastPoll;
    378350
    379351    /** Size of a RX/TX descriptor (8 or 16 bytes according to SWSTYLE */
    … …  
    390362
    391363    /** Number of times we've reported the link down. */
    392     RTUINT                              cLinkDownReported;
     364    uint32_t                            cLinkDownReported;
    393365    /** The configured MAC address. */
    394366    RTMAC                               MacConfigured;
     367    /** Set if PCNETSTATER3::pDrvR3 is not NULL. */
     368    bool                                fDriverAttached;
    395369    /** Alignment padding. */
    396     uint8_t                             Alignment3[2];
     370    uint8_t                             bAlignment3;
    397371
    398372    /** The LED. */
    399373    PDMLED                              Led;
    400     /** Status LUN: The LED ports. */
    401     PDMILEDPORTS                        ILeds;
    402     /** Partner of ILeds. */
    403     R3PTRTYPE(PPDMILEDCONNECTORS)       pLedsConnector;
    404374
    405375    /** Access critical section. */
    … …  
    421391    RTGCPHYS32                          RDRAPhysOld;
    422392    uint32_t                            cbRDRAOld;
    423 
    424     DECLRCCALLBACKMEMBER(int, pfnEMInterpretInstructionRC, (PVM pVM, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize));
    425     DECLR0CALLBACKMEMBER(int, pfnEMInterpretInstructionR0, (PVM pVM, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize));
    426393#endif
    427394
    … …  
    437404    /** MS to wait before we enable the link. */
    438405    uint32_t                            cMsLinkUpDelay;
    439     /** Alignment padding. */
    440     uint32_t                            Alignment6;
     406    /** The device instance number (for logging). */
     407    uint32_t                            iInstance;
    441408
    442409    /** PCI Region \#0: I/O ports offset 0x10-0x1f. */
    … …  
    451418    /** ISA I/O ports offset 0x00-0x0f. */
    452419    IOMIOPORTHANDLE                     hIoPortsIsaAProm;
     420
     421    /** The loopback transmit buffer (avoid stack allocations). */
     422    uint8_t                             abLoopBuf[4096];
     423    /** The recv buffer. */
     424    uint8_t                             abRecvBuf[4096];
    453425
    454426    STAMCOUNTER                         StatReceiveBytes;
    … …  
    506478#endif /* VBOX_WITH_STATISTICS */
    507479} PCNETSTATE;
    508 //AssertCompileMemberAlignment(PCNETSTATE, StatReceiveBytes, 8);
    509 /** Pointer to a PCnet state structure. */
     480/** Pointer to a shared PCnet state structure. */
    510481typedef PCNETSTATE *PPCNETSTATE;
     482
     483
     484/**
     485 * PCNET state for ring-3.
     486 *
     487 * @implements  PDMIBASE
     488 * @implements  PDMINETWORKDOWN
     489 * @implements  PDMINETWORKCONFIG
     490 * @implements  PDMILEDPORTS
     491 */
     492typedef struct PCNETSTATER3
     493{
     494    /** Pointer to the device instance. */
     495    PPDMDEVINSR3                        pDevIns;
     496    /** Pointer to the connector of the attached network driver. */
     497    PPDMINETWORKUPR3                    pDrv;
     498    /** Pointer to the attached network driver. */
     499    R3PTRTYPE(PPDMIBASE)                pDrvBase;
     500    /** LUN\#0 + status LUN: The base interface. */
     501    PDMIBASE                            IBase;
     502    /** LUN\#0: The network port interface. */
     503    PDMINETWORKDOWN                     INetworkDown;
     504    /** LUN\#0: The network config port interface. */
     505    PDMINETWORKCONFIG                   INetworkConfig;
     506
     507    /** Status LUN: The LED ports. */
     508    PDMILEDPORTS                        ILeds;
     509    /** Partner of ILeds. */
     510    R3PTRTYPE(PPDMILEDCONNECTORS)       pLedsConnector;
     511} PCNETSTATER3;
     512/** Pointer to a PCnet state structure for ring-3. */
     513typedef PCNETSTATER3 *PPCNETSTATER3;
     514
     515
     516/**
     517 * PCNET state for ring-0.
     518 */
     519typedef struct PCNETSTATER0
     520{
     521    /** Pointer to the connector of the attached network driver. */
     522    PPDMINETWORKUPR0                    pDrv;
     523#ifdef PCNET_NO_POLLING
     524    DECLR0CALLBACKMEMBER(int, pfnEMInterpretInstructionR0, (PVM pVM, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize));
     525#endif
     526} PCNETSTATER0;
     527/** Pointer to a PCnet state structure for ring-0. */
     528typedef PCNETSTATER0 *PPCNETSTATER0;
     529
     530
     531/**
     532 * PCNET state for raw-mode.
     533 */
     534typedef struct PCNETSTATERC
     535{
     536    /** Pointer to the connector of the attached network driver. */
     537    PPDMINETWORKUPRC                    pDrv;
     538#ifdef PCNET_NO_POLLING
     539    DECLRCCALLBACKMEMBER(int, pfnEMInterpretInstructionRC, (PVM pVM, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize));
     540#endif
     541} PCNETSTATERC;
     542/** Pointer to a PCnet state structure for raw-mode. */
     543typedef PCNETSTATERC *PPCNETSTATERC;
     544
     545
     546/** The PCnet state structure for the current context. */
     547typedef CTX_SUFF(PCNETSTATE) PCNETSTATECC;
     548/** Pointer to a PCnet state structure for the current context. */
     549typedef CTX_SUFF(PPCNETSTATE) PPCNETSTATECC;
     550
    511551
    512552/** @todo All structs: big endian? */
    … …  
    641681*   Internal Functions                                                                                                           *
    642682*********************************************************************************************************************************/
     683static void     pcnetPollRxTx(PPDMDEVINS pDevIns, PPCNETSTATE pThis, PPCNETSTATECC pThisCC);
     684static void     pcnetPollTimer(PPDMDEVINS pDevIns, PPCNETSTATE pThis, PPCNETSTATECC pThisCC);
     685static void     pcnetUpdateIrq(PPDMDEVINS pDevIns, PPCNETSTATE pThis);
     686static uint32_t pcnetBCRReadU16(PPCNETSTATE pThis, uint32_t u32RAP);
     687static VBOXSTRICTRC pcnetBCRWriteU16(PPDMDEVINS pDevIns, PPCNETSTATE pThis, uint32_t u32RAP, uint32_t val);
     688#ifndef PCNET_NO_POLLING
     689static void     pcnetPollTimerStart(PPDMDEVINS pDevIns, PPCNETSTATE pThis);
     690#endif
     691static int      pcnetXmitPending(PPDMDEVINS pDevIns, PPCNETSTATE pThis, PPCNETSTATECC pThisCC, bool fOnWorkerThread);
     692#ifdef PCNET_NO_POLLING
     693# ifndef IN_RING3
     694RT_C_DECLS_BEGIN
     695DECLEXPORT(FNPGMRZPHYSPFHANDLER)    pcnetHandleRingWritePf;
     696RT_C_DECLS_END
     697# endif
     698#endif
     699
    643700#define PRINT_TMD(T) Log10((    \
    644701        "TMD0 : TBADR=%#010x\n" \
    … …  
    673730        (R)->rmd2.zeros))
    674731
    675 #ifndef PCNET_NO_POLLING
    676 static void pcnetPollTimerStart(PPDMDEVINS pDevIns, PPCNETSTATE pThis);
    677 #endif
    678 static int  pcnetXmitPending(PPCNETSTATE pThis, bool fOnWorkerThread);
    679 #ifdef PCNET_NO_POLLING
    680 # ifndef IN_RING3
    681 RT_C_DECLS_BEGIN
    682 DECLEXPORT(FNPGMRZPHYSPFHANDLER)    pcnetHandleRingWritePf;
    683 RT_C_DECLS_END
    684 # endif
    685 #endif
    686 
    687732
    688733
    … …  
    694739DECLINLINE(bool) pcnetIsLinkUp(PPCNETSTATE pThis)
    695740{
    696     return pThis->pDrvR3 && !pThis->fLinkTempDown && pThis->fLinkUp;
     741    return pThis->fDriverAttached && !pThis->fLinkTempDown && pThis->fLinkUp;
    697742}
    698743
    … …  
    701746 *
    702747 * @returns nothing.
    703  * @param   pThis       Pointer to the BusLogic device instance
     748 * @param   pDevIns     The device instance.
     749 * @param   pThis       Pointer to the PCNet device instance
    704750 * @param   GCPhys      Guest physical memory address
    705751 * @param   pvBuf       Host side buffer address
    706752 * @param   cbWrite     Number of bytes to write
    707753 */
    708 static void pcnetPhysWrite(PPCNETSTATE pThis, RTGCPHYS GCPhys, const void *pvBuf, size_t cbWrite)
     754static void pcnetPhysWrite(PPDMDEVINS pDevIns, PPCNETSTATE pThis, RTGCPHYS GCPhys, const void *pvBuf, size_t cbWrite)
    709755{
    710756    if (!PCNET_IS_ISA(pThis))
    711         PDMDevHlpPCIPhysWrite(pThis->CTX_SUFF(pDevIns), GCPhys, pvBuf, cbWrite);
     757        PDMDevHlpPCIPhysWrite(pDevIns, GCPhys, pvBuf, cbWrite);
    712758    else
    713         PDMDevHlpPhysWrite(pThis->CTX_SUFF(pDevIns), GCPhys, pvBuf, cbWrite);
     759        PDMDevHlpPhysWrite(pDevIns, GCPhys, pvBuf, cbWrite);
    714760}
    715761
    … …  
    718764 * Make sure we read the own flag first.
    719765 *
     766 * @param   pDevIns     The device instance.
    720767 * @param pThis         adapter private data
    721768 * @param addr          physical address of the descriptor
    … …  
    723770 * @return              true if we own the descriptor, false otherwise
    724771 */
    725 DECLINLINE(bool) pcnetTmdLoad(PPCNETSTATE pThis, TMD *tmd, RTGCPHYS32 addr, bool fRetIfNotOwn)
    726 {
    727     PPDMDEVINS pDevIns = PCNETSTATE_2_DEVINS(pThis);
     772DECLINLINE(bool) pcnetTmdLoad(PPDMDEVINS pDevIns, PPCNETSTATE pThis, TMD *tmd, RTGCPHYS32 addr, bool fRetIfNotOwn)
     773{
    728774    uint8_t    ownbyte;
    729775
    … …  
    775821 * Make sure that all data are transmitted before we clear the own flag.
    776822 */
    777 DECLINLINE(void) pcnetTmdStorePassHost(PPCNETSTATE pThis, TMD *tmd, RTGCPHYS32 addr)
     823DECLINLINE(void) pcnetTmdStorePassHost(PPDMDEVINS pDevIns, PPCNETSTATE pThis, TMD *tmd, RTGCPHYS32 addr)
    778824{
    779825    STAM_PROFILE_ADV_START(&pThis->CTX_SUFF_Z(StatTmdStore), a);
    … …  
    786832        xda[3] =   ((uint32_t *)tmd)[2] >> 16;
    787833        xda[1] |=  0x8000;
    788         pcnetPhysWrite(pThis, addr, (void*)&xda[0], sizeof(xda));
     834        pcnetPhysWrite(pDevIns, pThis, addr, (void*)&xda[0], sizeof(xda));
    789835        xda[1] &= ~0x8000;
    790         pcnetPhysWrite(pThis, addr+3, (uint8_t*)xda + 3, 1);
     836        pcnetPhysWrite(pDevIns, pThis, addr+3, (uint8_t*)xda + 3, 1);
    791837    }
    792838    else if (RT_LIKELY(BCR_SWSTYLE(pThis) != 3))
    793839    {
    794840        ((uint32_t*)tmd)[1] |=  0x80000000;
    795         pcnetPhysWrite(pThis, addr, (void*)tmd, 12);
     841        pcnetPhysWrite(pDevIns, pThis, addr, (void*)tmd, 12);
    796842        ((uint32_t*)tmd)[1] &= ~0x80000000;
    797         pcnetPhysWrite(pThis, addr+7, (uint8_t*)tmd + 7, 1);
     843        pcnetPhysWrite(pDevIns, pThis, addr+7, (uint8_t*)tmd + 7, 1);
    798844    }
    799845    else
    … …  
    804850        xda[2] = ((uint32_t *)tmd)[0];
    805851        xda[1] |=  0x80000000;
    806         pcnetPhysWrite(pThis, addr, (void*)&xda[0], sizeof(xda));
     852        pcnetPhysWrite(pDevIns, pThis, addr, (void*)&xda[0], sizeof(xda));
    807853        xda[1] &= ~0x80000000;
    808         pcnetPhysWrite(pThis, addr+7, (uint8_t*)xda + 7, 1);
     854        pcnetPhysWrite(pDevIns, pThis, addr+7, (uint8_t*)xda + 7, 1);
    809855    }
    810856    STAM_PROFILE_ADV_STOP(&pThis->CTX_SUFF_Z(StatTmdStore), a);
    … …  
    813859/**
    814860 * Load receive message descriptor
     861 *
    815862 * Make sure we read the own flag first.
    816863 *
    817  * @param pThis         adapter private data
    818  * @param addr          physical address of the descriptor
    819  * @param fRetIfNotOwn  return immediately after reading the own flag if we don't own the descriptor
    820  * @return              true if we own the descriptor, false otherwise
    821  */
    822 DECLINLINE(bool) pcnetRmdLoad(PPCNETSTATE pThis, RMD *rmd, RTGCPHYS32 addr, bool fRetIfNotOwn)
    823 {
    824     PPDMDEVINS pDevIns = PCNETSTATE_2_DEVINS(pThis);
     864 * @param   pDevIns         The device instance.
     865 * @param   pThis           Adapter private data.
     866 * @param   addr            Physical address of the descriptor.
     867 * @param   fRetIfNotOwn    Return immediately after reading the own flag if we
     868 *                          don't own the descriptor.
     869 * @returns true if we own the descriptor, false otherwise
     870 */
     871DECLINLINE(bool) pcnetRmdLoad(PPDMDEVINS pDevIns, PPCNETSTATE pThis, RMD *rmd, RTGCPHYS32 addr, bool fRetIfNotOwn)
     872{
    825873    uint8_t    ownbyte;
    826874
    … …  
    872920 * Make sure that all data are transmitted before we clear the own flag.
    873921 */
    874 DECLINLINE(void) pcnetRmdStorePassHost(PPCNETSTATE pThis, RMD *rmd, RTGCPHYS32 addr)
     922DECLINLINE(void) pcnetRmdStorePassHost(PPDMDEVINS pDevIns, PPCNETSTATE pThis, RMD *rmd, RTGCPHYS32 addr)
    875923{
    876924    if (RT_UNLIKELY(BCR_SWSTYLE(pThis) == 0))
    … …  
    882930        rda[3] =   ((uint32_t *)rmd)[2]      & 0xffff;
    883931        rda[1] |=  0x8000;
    884         pcnetPhysWrite(pThis, addr, (void*)&rda[0], sizeof(rda));
     932        pcnetPhysWrite(pDevIns, pThis, addr, (void*)&rda[0], sizeof(rda));
    885933        rda[1] &= ~0x8000;
    886         pcnetPhysWrite(pThis, addr+3, (uint8_t*)rda + 3, 1);
     934        pcnetPhysWrite(pDevIns, pThis, addr+3, (uint8_t*)rda + 3, 1);
    887935    }
    888936    else if (RT_LIKELY(BCR_SWSTYLE(pThis) != 3))
    889937    {
    890938        ((uint32_t*)rmd)[1] |=  0x80000000;
    891         pcnetPhysWrite(pThis, addr, (void*)rmd, 12);
     939        pcnetPhysWrite(pDevIns, pThis, addr, (void*)rmd, 12);
    892940        ((uint32_t*)rmd)[1] &= ~0x80000000;
    893         pcnetPhysWrite(pThis, addr+7, (uint8_t*)rmd + 7, 1);
     941        pcnetPhysWrite(pDevIns, pThis, addr+7, (uint8_t*)rmd + 7, 1);
    894942    }
    895943    else
    … …  
    900948        rda[2] = ((uint32_t *)rmd)[0];
    901949        rda[1] |=  0x80000000;
    902         pcnetPhysWrite(pThis, addr, (void*)&rda[0], sizeof(rda));
     950        pcnetPhysWrite(pDevIns, pThis, addr, (void*)&rda[0], sizeof(rda));
    903951        rda[1] &= ~0x80000000;
    904         pcnetPhysWrite(pThis, addr+7, (uint8_t*)rda + 7, 1);
     952        pcnetPhysWrite(pDevIns, pThis, addr+7, (uint8_t*)rda + 7, 1);
    905953    }
    906954}
    … …  
    911959 * pages later when we shouldn't schedule to EMT. Temporarily hack.
    912960 */
    913 static void pcnetDescTouch(PPCNETSTATE pThis, RTGCPHYS32 addr)
    914 {
    915     PPDMDEVINS pDevIns = PCNETSTATE_2_DEVINS(pThis);
     961static void pcnetDescTouch(PPDMDEVINS pDevIns, PPCNETSTATE pThis, RTGCPHYS32 addr)
     962{
    916963    uint8_t aBuf[16];
    917964    size_t cbDesc;
    … …  
    921968        cbDesc = 16;
    922969    PDMDevHlpPhysRead(pDevIns, addr, aBuf, cbDesc);
    923     pcnetPhysWrite(pThis, addr, aBuf, cbDesc);
     970    pcnetPhysWrite(pDevIns, pThis, addr, aBuf, cbDesc);
    924971}
    925972#endif /* IN_RING3 */
    … …  
    11441191#define htons(x)    ( (((x) & 0xff00) >> 8) | (((x) & 0x00ff) << 8) )
    11451192
    1146 static void     pcnetPollRxTx(PPCNETSTATE pThis);
    1147 static void     pcnetPollTimer(PPDMDEVINS pDevIns, PPCNETSTATE pThis);
    1148 static void     pcnetUpdateIrq(PPCNETSTATE pThis);
    1149 static uint32_t pcnetBCRReadU16(PPCNETSTATE pThis, uint32_t u32RAP);
    1150 static VBOXSTRICTRC pcnetBCRWriteU16(PPDMDEVINS pDevIns, PPCNETSTATE pThis, uint32_t u32RAP, uint32_t val);
    11511193
    11521194
    … …  
    11851227
    11861228                /* Check if we can do something now */
    1187                 pcnetPollRxTx(pThis);
    1188                 pcnetUpdateIrq(pThis);
     1229                pcnetPollRxTx(pDevIns, pThis, pThisCC);
     1230                pcnetUpdateIrq(pDevIns, pThis);
    11891231
    11901232                PDMCritSectLeave(&pThis->CritSect);
    … …  
    12371279            AssertReleaseRC(rc);
    12381280            /* Check if we can do something now */
    1239             pcnetPollRxTx(pThis);
    1240             pcnetUpdateIrq(pThis);
     1281            pcnetPollRxTx(pDevIns, pThis, pThisCC);
     1282            pcnetUpdateIrq(pDevIns, pThis);
    12411283            PDMCritSectLeave(&pThis->CritSect);
    12421284        }
    … …  
    13061348 * - csr5 (only written by pcnetSoftReset(), pcnetStop or by the driver guest)
    13071349 */
    1308 static void pcnetUpdateIrq(PPCNETSTATE pThis)
     1350static void pcnetUpdateIrq(PPDMDEVINS pDevIns, PPCNETSTATE pThis)
    13091351{
    13101352    int      iISR = 0;
    … …  
    13881430        {
    13891431            Log(("#%d INTA=%d\n", PCNET_INST_NR, iISR));
    1390             PDMDevHlpPCISetIrq(PCNETSTATE_2_DEVINS(pThis), 0, iISR);
     1432            PDMDevHlpPCISetIrq(pDevIns, 0, iISR);
    13911433        }
    13921434        else
    13931435        {
    13941436            Log(("#%d IRQ=%d, state=%d\n", PCNET_INST_NR, pThis->uIsaIrq, iISR));
    1395             PDMDevHlpISASetIrq(PCNETSTATE_2_DEVINS(pThis), pThis->uIsaIrq, iISR);
     1437            PDMDevHlpISASetIrq(pDevIns, pThis->uIsaIrq, iISR);
    13961438        }
    13971439        pThis->iISR = iISR;
    … …  
    14051447static void pcnetR3UpdateRingHandlers(PPCNETSTATE pThis)
    14061448{
    1407     PPDMDEVINS pDevIns = PCNETSTATE_2_DEVINS(pThis);
     1449    PPDMDEVINS pDevIns = pDevIns;
    14081450    int rc;
    14091451
    … …  
    14601502                                            RT_ALIGN(pcnetTdraAddr(pThis, 0), PAGE_SIZE) - 1,
    14611503                                            pThis->hNoPollingHandlerType,
    1462                                             pThis->CTX_SUFF(pDevIns)->pvInstanceDataR3,
    1463                                             pThis->CTX_SUFF(pDevIns)->pvInstanceDataR0,
    1464                                             pThis->CTX_SUFF(pDevIns)->pvInstanceDataRC,
     1504                                            pDevIns->pvInstanceDataR3,
     1505                                            pDevIns->pvInstanceDataR0,
     1506                                            pDevIns->pvInstanceDataRC,
    14651507                                            "PCnet transmit ring write access handler");
    14661508            AssertRC(rc);
    … …  
    14861528# endif /* PCNET_NO_POLLING */
    14871529
    1488 static void pcnetR3Init(PPCNETSTATE pThis)
    1489 {
    1490     PPDMDEVINS pDevIns = PCNETSTATE_2_DEVINS(pThis);
     1530static void pcnetR3Init(PPDMDEVINS pDevIns, PPCNETSTATE pThis, PPCNETSTATECC pThisCC)
     1531{
    14911532    Log(("#%d pcnetR3Init: init_addr=%#010x\n", PCNET_INST_NR, PHYSADDR(pThis, CSR_IADR(pThis))));
    14921533
    … …  
    15361577        RTGCPHYS32 rdaddr = PHYSADDR(pThis, pcnetRdraAddr(pThis, i));
    15371578
    1538         pcnetDescTouch(pThis, rdaddr);
     1579        pcnetDescTouch(pDevIns,  pThis, rdaddr);
    15391580        /* At this time it is not guaranteed that the buffers are already initialized. */
    1540         if (pcnetRmdLoad(pThis, &rmd, rdaddr, false))
     1581        if (pcnetRmdLoad(pDevIns, pThis, &rmd, rdaddr, false))
    15411582        {
    15421583            uint32_t cbBuf = 4096U-rmd.rmd1.bcnt;
    … …  
    15491590        RTGCPHYS32 tdaddr = PHYSADDR(pThis, pcnetTdraAddr(pThis, i));
    15501591
    1551         pcnetDescTouch(pThis, tdaddr);
     1592        pcnetDescTouch(pDevIns, pThis, tdaddr);
    15521593    }
    15531594
    … …  
    15621603    pThis->fSignalRxMiss = (cbRxBuffers == 0 || cbRxBuffers >= 32*_1K);
    15631604
    1564     if (pThis->pDrvR3)
    1565         pThis->pDrvR3->pfnSetPromiscuousMode(pThis->pDrvR3, CSR_PROM(pThis));
     1605    if (pThisCC->pDrv)
     1606        pThisCC->pDrv->pfnSetPromiscuousMode(pThisCC->pDrv, CSR_PROM(pThis));
    15661607
    15671608    CSR_RCVRC(pThis) = CSR_RCVRL(pThis);
    … …  
    16171658 * Stop RX/TX operation.
    16181659 */
    1619 static void pcnetStop(PPDMDEVINS pDevIns, PPCNETSTATE pThis)
     1660static void pcnetStop(PPDMDEVINS pDevIns, PPCNETSTATE pThis, PPCNETSTATECC pThisCC)
    16201661{
    16211662    Log(("#%d pcnetStop:\n", PCNET_INST_NR));
    … …  
    16231664    pThis->aCSR[4] &= ~0x02c2;
    16241665    pThis->aCSR[5] &= ~0x0011;
    1625     pcnetPollTimer(pDevIns, pThis);
     1666    pcnetPollTimer(pDevIns, pThis, pThisCC);
    16261667}
    16271668
    … …  
    16481689 *
    16491690 * @param   pDevIns         The device instance.
     1691 * @param   pThis           The shared PCnet state data.
    16501692 * @param   fSkipCurrent    if true, don't scan the current RDTE.
    16511693 */
    1652 static void pcnetRdtePoll(PPCNETSTATE pThis, bool fSkipCurrent=false)
     1694static void pcnetRdtePoll(PPDMDEVINS pDevIns, PPCNETSTATE pThis, bool fSkipCurrent=false)
    16531695{
    16541696    STAM_PROFILE_ADV_START(&pThis->CTX_SUFF_Z(StatRdtePoll), a);
    … …  
    16731715            CSR_CRDA(pThis) = CSR_CRBA(pThis) = 0;
    16741716            CSR_CRBC(pThis) = CSR_CRST(pThis) = 0;
    1675             if (!pcnetRmdLoad(pThis, &rmd, PHYSADDR(pThis, addr), true))
     1717            if (!pcnetRmdLoad(pDevIns, pThis, &rmd, PHYSADDR(pThis, addr), true))
    16761718            {
    16771719                STAM_PROFILE_ADV_STOP(&pThis->CTX_SUFF_Z(StatRdtePoll), a);
    … …  
    16851727                CSR_CRST(pThis) = ((uint32_t *)&rmd)[1] >> 16; /* Receive Status */
    16861728                if (pThis->fMaybeOutOfSpace)
    1687                     pcnetWakeupReceive(PCNETSTATE_2_DEVINS(pThis));
     1729                    pcnetWakeupReceive(pDevIns);
    16881730            }
    16891731            else
    … …  
    17091751        CSR_NRDA(pThis) = CSR_NRBA(pThis) = 0;
    17101752        CSR_NRBC(pThis) = 0;
    1711         if (!pcnetRmdLoad(pThis, &rmd, PHYSADDR(pThis, addr), true))
     1753        if (!pcnetRmdLoad(pDevIns, pThis, &rmd, PHYSADDR(pThis, addr), true))
    17121754        {
    17131755            STAM_PROFILE_ADV_STOP(&pThis->CTX_SUFF_Z(StatRdtePoll), a);
    … …  
    17501792 * @return true if transmit descriptors available
    17511793 */
    1752 static int pcnetTdtePoll(PPCNETSTATE pThis, TMD *tmd)
     1794static int pcnetTdtePoll(PPDMDEVINS pDevIns, PPCNETSTATE pThis, TMD *tmd)
    17531795{
    17541796    STAM_PROFILE_ADV_START(&pThis->CTX_SUFF_Z(StatTdtePoll), a);
    … …  
    17571799        RTGCPHYS32 cxda = pcnetTdraAddr(pThis, CSR_XMTRC(pThis));
    17581800
    1759         if (!pcnetTmdLoad(pThis, tmd, PHYSADDR(pThis, cxda), true))
     1801        if (!pcnetTmdLoad(pDevIns, pThis, tmd, PHYSADDR(pThis, cxda), true))
    17601802        {
    17611803            STAM_PROFILE_ADV_STOP(&pThis->CTX_SUFF_Z(StatTdtePoll), a);
    … …  
    17981840 * @return true if transmit descriptors available
    17991841 */
    1800 static int pcnetCalcPacketLen(PPCNETSTATE pThis, unsigned cb)
     1842static int pcnetCalcPacketLen(PPDMDEVINS pDevIns, PPCNETSTATE pThis, unsigned cb)
    18011843{
    18021844    TMD tmd;
    … …  
    18191861        RTGCPHYS32 addrDesc = pcnetTdraAddr(pThis, iDesc);
    18201862
    1821         if (!pcnetTmdLoad(pThis, &tmd, PHYSADDR(pThis, addrDesc), true))
     1863        if (!pcnetTmdLoad(pDevIns, pThis, &tmd, PHYSADDR(pThis, addrDesc), true))
    18221864        {
    18231865            STAM_PROFILE_ADV_STOP(&pThis->CTX_SUFF_Z(StatTxLenCalc), a);
    … …  
    18501892 * Write data into guest receive buffers.
    18511893 */
    1852 static void pcnetReceiveNoSync(PPCNETSTATE pThis, const uint8_t *buf, size_t cbToRecv, bool fAddFCS, bool fLoopback)
    1853 {
    1854     PPDMDEVINS pDevIns = PCNETSTATE_2_DEVINS(pThis);
    1855     int is_padr = 0, is_bcast = 0, is_ladr = 0;
     1894static void pcnetReceiveNoSync(PPDMDEVINS pDevIns, PPCNETSTATE pThis, PPCNETSTATECC pThisCC,
     1895                               const uint8_t *buf, size_t cbToRecv, bool fAddFCS, bool fLoopback)
     1896{
     1897    int is_padr  = 0;
     1898    int is_bcast = 0;
     1899    int is_ladr  = 0;
    18561900    unsigned iRxDesc;
    18571901    int cbPacket;
    … …  
    18851929    {
    18861930        if (HOST_IS_OWNER(CSR_CRST(pThis)))
    1887             pcnetRdtePoll(pThis);
     1931            pcnetRdtePoll(pDevIns, pThis);
    18881932        if (RT_UNLIKELY(HOST_IS_OWNER(CSR_CRST(pThis))))
    18891933        {
    … …  
    18981942            {
    18991943                RMD rmd;
    1900                 pcnetRmdLoad(pThis, &rmd, PHYSADDR(pThis, GCPhys), false);
     1944                pcnetRmdLoad(pDevIns, pThis, &rmd, PHYSADDR(pThis, GCPhys), false);
    19011945                LogRel(("  %#010x\n", rmd.rmd1));
    19021946                GCPhys += cb;
    … …  
    19622006#endif
    19632007
    1964             pcnetRmdLoad(pThis, &rmd, PHYSADDR(pThis, crda), false);
     2008            pcnetRmdLoad(pDevIns, pThis, &rmd, PHYSADDR(pThis, crda), false);
    19652009            /*if (!CSR_LAPPEN(pThis))*/
    19662010                rmd.rmd1.stp = 1;
    … …  
    19832027             */
    19842028            PDMCritSectLeave(&pThis->CritSect);
    1985             pcnetPhysWrite(pThis, rbadr, src, cbBuf);
     2029            pcnetPhysWrite(pDevIns, pThis, rbadr, src, cbBuf);
    19862030            int rc = PDMCritSectEnter(&pThis->CritSect, VERR_SEM_BUSY);
    19872031            AssertReleaseRC(rc);
    … …  
    20132057                 * to quit and write error status into the last descriptor we own.
    20142058                 */
    2015                 if (!pcnetRmdLoad(pThis, &next_rmd, PHYSADDR(pThis, next_crda), true))
     2059                if (!pcnetRmdLoad(pDevIns, pThis, &next_rmd, PHYSADDR(pThis, next_crda), true))
    20162060                    break;
    20172061
    20182062                /* Write back current descriptor, clear the own bit. */
    2019                 pcnetRmdStorePassHost(pThis, &rmd, PHYSADDR(pThis, crda));
     2063                pcnetRmdStorePassHost(pDevIns, pThis, &rmd, PHYSADDR(pThis, crda));
    20202064
    20212065                /* Switch to the next descriptor */
    … …  
    20302074                 * handler associated with it. See above for additional comments. */
    20312075                PDMCritSectLeave(&pThis->CritSect);
    2032                 pcnetPhysWrite(pThis, rbadr2, src, cbBuf);
     2076                pcnetPhysWrite(pDevIns, pThis, rbadr2, src, cbBuf);
    20332077                rc = PDMCritSectEnter(&pThis->CritSect, VERR_SEM_BUSY);
    20342078                AssertReleaseRC(rc);
    … …  
    20732117
    20742118            /* write back, clear the own bit */
    2075             pcnetRmdStorePassHost(pThis, &rmd, PHYSADDR(pThis, crda));
     2119            pcnetRmdStorePassHost(pDevIns, pThis, &rmd, PHYSADDR(pThis, crda));
    20762120
    20772121            pThis->aCSR[0] |= 0x0400;
    20782122
    2079             Log(("#%d RCVRC=%d CRDA=%#010x\n", PCNET_INST_NR,
    2080                  CSR_RCVRC(pThis), PHYSADDR(pThis, CSR_CRDA(pThis))));
     2123            Log(("#%d RCVRC=%d CRDA=%#010x\n", PCNET_INST_NR, CSR_RCVRC(pThis), PHYSADDR(pThis, CSR_CRDA(pThis))));
    20812124#ifdef LOG_ENABLED
    20822125            PRINT_RMD(&rmd);
    … …  
    20912134     * ``transmit polling will take place following receive activities'' */
    20922135    if (!fLoopback)
    2093         pcnetPollRxTx(pThis);
    2094     pcnetUpdateIrq(pThis);
     2136        pcnetPollRxTx(pDevIns, pThis, pThisCC);
     2137    pcnetUpdateIrq(pDevIns, pThis);
    20952138}
    20962139
    … …  
    21032146static DECLCALLBACK(void) pcnetR3XmitTaskCallback(PPDMDEVINS pDevIns, void *pvUser)
    21042147{
    2105     PPCNETSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PPCNETSTATE);
     2148    PPCNETSTATE   pThis   = PDMDEVINS_2_DATA(pDevIns, PPCNETSTATE);
     2149    PPCNETSTATECC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PPCNETSTATECC);
    21062150    NOREF(pvUser);
    21072151
    … …  
    21092153     * Transmit as much as we can.
    21102154     */
    2111     pcnetXmitPending(pThis, true /*fOnWorkerThread*/);
     2155    pcnetXmitPending(pDevIns, pThis, pThisCC, true /*fOnWorkerThread*/);
    21122156}
    21132157#endif /* IN_RING3 */
    … …  
    21182162 *
    21192163 * @returns See PPDMINETWORKUP::pfnAllocBuf.
    2120  * @param   pThis       The device instance.
     2164 * @param   pThis       The shared PCNet state data.
    21212165 * @param   cbMin       The minimum buffer size.
    21222166 * @param   fLoopback   Set if we're in loopback mode.
    … …  
    21252169 *                      Always set.
    21262170 */
    2127 DECLINLINE(int) pcnetXmitAllocBuf(PPCNETSTATE pThis, size_t cbMin, bool fLoopback,
     2171DECLINLINE(int) pcnetXmitAllocBuf(PPCNETSTATE pThis, PPCNETSTATECC pThisCC, size_t cbMin, bool fLoopback,
    21282172                                  PPDMSCATTERGATHER pSgLoop, PPPDMSCATTERGATHER ppSgBuf)
    21292173{
    … …  
    21452189    else
    21462190    {
    2147         PPDMINETWORKUP pDrv = pThis->CTX_SUFF(pDrv);
     2191        PPDMINETWORKUP pDrv = pThisCC->pDrv;
    21482192        if (RT_LIKELY(pDrv))
    21492193        {
    … …  
    21662210 * Frees an unsent buffer.
    21672211 *
    2168  * @param   pThis           The device instance.
     2212 * @param   pThisCC         The PCNet state data for the current context.
    21692213 * @param   fLoopback       Set if we're in loopback mode.
    21702214 * @param   pSgBuf          The SG to free.  Can be NULL.
    21712215 */
    2172 DECLINLINE(void) pcnetXmitFreeBuf(PPCNETSTATE pThis, bool fLoopback, PPDMSCATTERGATHER pSgBuf)
     2216DECLINLINE(void) pcnetXmitFreeBuf(PPCNETSTATECC pThisCC, bool fLoopback, PPDMSCATTERGATHER pSgBuf)
    21732217{
    21742218    if (pSgBuf)
    … …  
    21782222        else
    21792223        {
    2180             PPDMINETWORKUP pDrv = pThis->CTX_SUFF(pDrv);
     2224            PPDMINETWORKUP pDrv = pThisCC->pDrv;
    21812225            if (RT_LIKELY(pDrv))
    21822226                pDrv->pfnFreeBuf(pDrv, pSgBuf);
    … …  
    21922236 *
    21932237 * @returns See PDMINETWORKUP::pfnSendBuf.
    2194  * @param   pThis           The device instance.
     2238 * @param   pDevIns         The device instance.
     2239 * @param   pThis           The shared PCNet state data.
     2240 * @param   pThisCC         The PCNet state data for the current context.
    21952241 * @param   fLoopback       Set if we're in loopback mode.
    21962242 * @param   pSgBuf          The SG to send.
    … …  
    21982244 *                          if an EMT.
    21992245 */
    2200 DECLINLINE(int) pcnetXmitSendBuf(PPCNETSTATE pThis, bool fLoopback, PPDMSCATTERGATHER pSgBuf, bool fOnWorkerThread)
     2246DECLINLINE(int) pcnetXmitSendBuf(PPDMDEVINS pDevIns, PPCNETSTATE pThis, PPCNETSTATECC pThisCC, bool fLoopback,
     2247                                 PPDMSCATTERGATHER pSgBuf, bool fOnWorkerThread)
    22012248{
    22022249    int rc;
    … …  
    22072254        pThis->Led.Asserted.s.fReading = pThis->Led.Actual.s.fReading = 1;
    22082255        if (HOST_IS_OWNER(CSR_CRST(pThis)))
    2209             pcnetRdtePoll(pThis);
    2210 
    2211         pcnetReceiveNoSync(pThis, pThis->abLoopBuf, pSgBuf->cbUsed, true /* fAddFCS */, fLoopback);
     2256            pcnetRdtePoll(pDevIns, pThis);
     2257
     2258        pcnetReceiveNoSync(pDevIns, pThis, pThisCC, pThis->abLoopBuf, pSgBuf->cbUsed, true /* fAddFCS */, fLoopback);
    22122259        pThis->Led.Actual.s.fReading = 0;
    22132260        rc = VINF_SUCCESS;
    … …  
    22232270            pThis->Led.Asserted.s.fWriting = pThis->Led.Actual.s.fWriting = 1;
    22242271
    2225         PPDMINETWORKUP pDrv = pThis->CTX_SUFF(pDrv);
     2272        PPDMINETWORKUP pDrv = pThisCC->pDrv;
    22262273        if (RT_LIKELY(pDrv))
    22272274        {
    … …  
    22432290 * path.
    22442291 */
    2245 static void pcnetXmitRead1stSlow(PPCNETSTATE pThis, RTGCPHYS32 GCPhysFrame, unsigned cbFrame,
    2246                                  PPDMSCATTERGATHER pSgBuf)
     2292static void pcnetXmitRead1stSlow(PPDMDEVINS pDevIns, RTGCPHYS32 GCPhysFrame, unsigned cbFrame, PPDMSCATTERGATHER pSgBuf)
    22472293{
    22482294    AssertFailed(); /* This path is not supposed to be taken atm */
    … …  
    22532299        Assert(iSeg < pSgBuf->cSegs);
    22542300        uint32_t cbRead = (uint32_t)RT_MIN(cbFrame, pSgBuf->aSegs[iSeg].cbSeg);
    2255         PDMDevHlpPhysRead(pThis->CTX_SUFF(pDevIns), GCPhysFrame, pSgBuf->aSegs[iSeg].pvSeg, cbRead);
     2301        PDMDevHlpPhysRead(pDevIns, GCPhysFrame, pSgBuf->aSegs[iSeg].pvSeg, cbRead);
    22562302        cbFrame -= cbRead;
    22572303        if (!cbFrame)
    … …  
    22662312 * path.
    22672313 */
    2268 static void pcnetXmitReadMoreSlow(PPCNETSTATE pThis, RTGCPHYS32 GCPhysFrame, unsigned cbFrame,
    2269                                   PPDMSCATTERGATHER pSgBuf)
     2314static void pcnetXmitReadMoreSlow(PPDMDEVINS pDevIns, RTGCPHYS32 GCPhysFrame, unsigned cbFrame, PPDMSCATTERGATHER pSgBuf)
    22702315{
    22712316    AssertFailed(); /* This path is not supposed to be taken atm */
    … …  
    22902335        size_t   offIntoSeg = off - offSeg;
    22912336        uint32_t cbRead     = (uint32_t)RT_MIN(pSgBuf->aSegs[iSeg].cbSeg - offIntoSeg, cbFrame);
    2292         PDMDevHlpPhysRead(pThis->CTX_SUFF(pDevIns), GCPhysFrame,
     2337        PDMDevHlpPhysRead(pDevIns, GCPhysFrame,
    22932338                          (uint8_t *)pSgBuf->aSegs[iSeg].pvSeg + offIntoSeg, cbRead);
    22942339        cbFrame -= cbRead;
    … …  
    23052350
    23062351        uint32_t cbRead = (uint32_t)RT_MIN(pSgBuf->aSegs[iSeg].cbSeg, cbFrame);
    2307         PDMDevHlpPhysRead(pThis->CTX_SUFF(pDevIns), GCPhysFrame, pSgBuf->aSegs[iSeg].pvSeg, cbRead);
     2352        PDMDevHlpPhysRead(pDevIns, GCPhysFrame, pSgBuf->aSegs[iSeg].pvSeg, cbRead);
    23082353        cbFrame -= cbRead;
    23092354        if (!cbFrame)
    … …  
    23172362 * Reads the first part of a frame into the scatter gather buffer.
    23182363 */
    2319 DECLINLINE(void) pcnetXmitRead1st(PPCNETSTATE pThis, RTGCPHYS32 GCPhysFrame, const unsigned cbFrame,
     2364DECLINLINE(void) pcnetXmitRead1st(PPDMDEVINS pDevIns, PPCNETSTATE pThis, RTGCPHYS32 GCPhysFrame, const unsigned cbFrame,
    23202365                                  PPDMSCATTERGATHER pSgBuf)
    23212366{
    2322     Assert(PDMCritSectIsOwner(&pThis->CritSect));
     2367    Assert(PDMCritSectIsOwner(&pThis->CritSect)); RT_NOREF(pThis);
    23232368    Assert(pSgBuf->cbAvailable >= cbFrame);
    23242369
    … …  
    23262371    {
    23272372        pSgBuf->cbUsed = cbFrame;
    2328         PDMDevHlpPhysRead(pThis->CTX_SUFF(pDevIns), GCPhysFrame, pSgBuf->aSegs[0].pvSeg, cbFrame);
     2373        PDMDevHlpPhysRead(pDevIns, GCPhysFrame, pSgBuf->aSegs[0].pvSeg, cbFrame);
    23292374    }
    23302375    else
    2331         pcnetXmitRead1stSlow(pThis, GCPhysFrame, cbFrame, pSgBuf);
     2376        pcnetXmitRead1stSlow(pDevIns, GCPhysFrame, cbFrame, pSgBuf);
    23322377}
    23332378
    … …  
    23352380 * Reads more into the current frame.
    23362381 */
    2337 DECLINLINE(void) pcnetXmitReadMore(PPCNETSTATE pThis, RTGCPHYS32 GCPhysFrame, const unsigned cbFrame,
    2338                                    PPDMSCATTERGATHER pSgBuf)
     2382DECLINLINE(void) pcnetXmitReadMore(PPDMDEVINS pDevIns, RTGCPHYS32 GCPhysFrame, const unsigned cbFrame, PPDMSCATTERGATHER pSgBuf)
    23392383{
    23402384    size_t off = pSgBuf->cbUsed;
    … …  
    23442388    {
    23452389        pSgBuf->cbUsed = cbFrame + off;
    2346         PDMDevHlpPhysRead(pThis->CTX_SUFF(pDevIns), GCPhysFrame,
    2347                           (uint8_t *)pSgBuf->aSegs[0].pvSeg + off, cbFrame);
     2390        PDMDevHlpPhysRead(pDevIns, GCPhysFrame, (uint8_t *)pSgBuf->aSegs[0].pvSeg + off, cbFrame);
    23482391    }
    23492392    else
    2350         pcnetXmitReadMoreSlow(pThis, GCPhysFrame, cbFrame, pSgBuf);
     2393        pcnetXmitReadMoreSlow(pDevIns, GCPhysFrame, cbFrame, pSgBuf);
    23512394}
    23522395
    … …  
    23832426 * Try to transmit frames
    23842427 */
    2385 static void pcnetTransmit(PPCNETSTATE pThis)
     2428static void pcnetTransmit(PPDMDEVINS pDevIns, PPCNETSTATE pThis, PPCNETSTATECC pThisCC)
    23862429{
    23872430    if (RT_UNLIKELY(!CSR_TXON(pThis)))
    … …  
    23952438     */
    23962439    TMD tmd;
    2397     if (!pcnetTdtePoll(pThis, &tmd))
     2440    if (!pcnetTdtePoll(pDevIns, pThis, &tmd))
    23982441        return;
    23992442
    … …  
    24082451     */
    24092452#if defined(IN_RING0) || defined(IN_RC)
    2410     if (!pThis->CTX_SUFF(pDrv))
    2411     {
    2412         int rc = PDMDevHlpTaskTrigger(pThis->CTX_SUFF(pDevIns), pThis->hXmitTask);
     2453    if (!pThisCC->pDrv)
     2454    {
     2455        int rc = PDMDevHlpTaskTrigger(pDevIns, pThis->hXmitTask);
    24132456        AssertRC(rc);
    24142457    }
    … …  
    24162459#endif
    24172460    {
    2418         int rc = pcnetXmitPending(pThis, false /*fOnWorkerThread*/);
     2461        int rc = pcnetXmitPending(pDevIns, pThis, pThisCC, false /*fOnWorkerThread*/);
    24192462        if (rc == VERR_TRY_AGAIN)
    24202463            rc = VINF_SUCCESS;
    … …  
    24292472 * @threads TX or EMT.
    24302473 */
    2431 static int pcnetAsyncTransmit(PPCNETSTATE pThis, bool fOnWorkerThread)
     2474static int pcnetAsyncTransmit(PPDMDEVINS pDevIns, PPCNETSTATE pThis, PPCNETSTATECC pThisCC, bool fOnWorkerThread)
    24322475{
    24332476    Assert(PDMCritSectIsOwner(&pThis->CritSect));
    … …  
    24552498#endif
    24562499        TMD tmd;
    2457         if (!pcnetTdtePoll(pThis, &tmd))
     2500        if (!pcnetTdtePoll(pDevIns, pThis, &tmd))
    24582501            break;
    24592502
    … …  
    24892532                if (RT_LIKELY(cb <= MAX_FRAME))
    24902533                {
    2491                     rc = pcnetXmitAllocBuf(pThis, cb, fLoopback, &SgLoop, &pSgBuf);
     2534                    rc = pcnetXmitAllocBuf(pThis, pThisCC, cb, fLoopback, &SgLoop, &pSgBuf);
    24922535                    if (RT_SUCCESS(rc))
    24932536                    {
    2494                         pcnetXmitRead1st(pThis, PHYSADDR(pThis, tmd.tmd0.tbadr), cb, pSgBuf);
    2495                         rc = pcnetXmitSendBuf(pThis, fLoopback, pSgBuf, fOnWorkerThread);
     2537                        pcnetXmitRead1st(pDevIns, pThis, PHYSADDR(pThis, tmd.tmd0.tbadr), cb, pSgBuf);
     2538                        rc = pcnetXmitSendBuf(pDevIns, pThis, pThisCC, fLoopback, pSgBuf, fOnWorkerThread);
    24962539                    }
    24972540                    else if (rc == VERR_TRY_AGAIN)
    … …  
    25292572                     * in fact generally treat the length as a 16-bit quantity. */
    25302573                    LogRel(("PCnet#%d: pcnetAsyncTransmit: illegal 4kb frame -> ignoring\n", PCNET_INST_NR));
    2531                     pcnetTmdStorePassHost(pThis, &tmd, PHYSADDR(pThis, CSR_CXDA(pThis)));
     2574                    pcnetTmdStorePassHost(pDevIns, pThis, &tmd, PHYSADDR(pThis, CSR_CXDA(pThis)));
    25322575                    break;
    25332576                }
    … …  
    25452588
    25462589            /* Write back the TMD and pass it to the host (clear own bit). */
    2547             pcnetTmdStorePassHost(pThis, &tmd, PHYSADDR(pThis, CSR_CXDA(pThis)));
     2590            pcnetTmdStorePassHost(pDevIns, pThis, &tmd, PHYSADDR(pThis, CSR_CXDA(pThis)));
    25482591
    25492592            /* advance the ring counter register */
    … …  
    25652608             */
    25662609            unsigned cb = 4096 - tmd.tmd1.bcnt;
    2567             rc = pcnetXmitAllocBuf(pThis, pcnetCalcPacketLen(pThis, cb), fLoopback, &SgLoop, &pSgBuf);
     2610            rc = pcnetXmitAllocBuf(pThis, pThisCC, pcnetCalcPacketLen(pDevIns, pThis, cb), fLoopback, &SgLoop, &pSgBuf);
    25682611            if (rc == VERR_TRY_AGAIN)
    25692612            {
    … …  
    25742617            bool fDropFrame = RT_FAILURE(rc);
    25752618            if (!fDropFrame)
    2576                 pcnetXmitRead1st(pThis, PHYSADDR(pThis, tmd.tmd0.tbadr), cb, pSgBuf);
     2619                pcnetXmitRead1st(pDevIns, pThis, PHYSADDR(pThis, tmd.tmd0.tbadr), cb, pSgBuf);
    25772620
    25782621            for (;;)
    … …  
    25912634
    25922635                TMD dummy;
    2593                 if (!pcnetTdtePoll(pThis, &dummy))
     2636                if (!pcnetTdtePoll(pDevIns, pThis, &dummy))
    25942637                {
    25952638                    /*
    … …  
    26022645                    if (!CSR_DXSUFLO(pThis))         /* stop on xmit underflow */
    26032646                        pThis->aCSR[0] &= ~0x0010;   /* clear TXON */
    2604                     pcnetTmdStorePassHost(pThis, &tmd, GCPhysPrevTmd);
     2647                    pcnetTmdStorePassHost(pDevIns, pThis, &tmd, GCPhysPrevTmd);
    26052648                    AssertMsgFailed(("pcnetAsyncTransmit: Underflow!!!\n"));
    2606                     pcnetXmitFreeBuf(pThis, fLoopback, pSgBuf);
     2649                    pcnetXmitFreeBuf(pThisCC, fLoopback, pSgBuf);
    26072650                    break;
    26082651                }
    26092652
    26102653                /* release & save the previous tmd, pass it to the host */
    2611                 pcnetTmdStorePassHost(pThis, &tmd, GCPhysPrevTmd);
     2654                pcnetTmdStorePassHost(pDevIns, pThis, &tmd, GCPhysPrevTmd);
    26122655
    26132656                /*
    … …  
    26172660                cBuffers++;
    26182661#endif
    2619                 pcnetTmdLoad(pThis, &tmd, PHYSADDR(pThis, CSR_CXDA(pThis)), false);
     2662                pcnetTmdLoad(pDevIns, pThis, &tmd, PHYSADDR(pThis, CSR_CXDA(pThis)), false);
    26202663                cb = 4096 - tmd.tmd1.bcnt;
    26212664                if (   !fDropFrame
    26222665                    && pSgBuf->cbUsed + cb <= MAX_FRAME) /** @todo this used to be ... + cb < MAX_FRAME. */
    2623                     pcnetXmitReadMore(pThis, PHYSADDR(pThis, tmd.tmd0.tbadr), cb, pSgBuf);
     2666                    pcnetXmitReadMore(pDevIns, PHYSADDR(pThis, tmd.tmd0.tbadr), cb, pSgBuf);
    26242667                else
    26252668                {
    … …  
    26372680                    if (!fDropFrame && (pcnetIsLinkUp(pThis) || fLoopback))
    26382681                    {
    2639                         rc = pcnetXmitSendBuf(pThis, fLoopback, pSgBuf, fOnWorkerThread);
     2682                        rc = pcnetXmitSendBuf(pDevIns, pThis, pThisCC, fLoopback, pSgBuf, fOnWorkerThread);
    26402683                        fDropFrame = RT_FAILURE(rc);
    26412684                    }
    26422685                    else
    2643                         pcnetXmitFreeBuf(pThis, fLoopback, pSgBuf);
     2686                        pcnetXmitFreeBuf(pThisCC, fLoopback, pSgBuf);
    26442687                    if (fDropFrame)
    26452688                        pcnetXmitFailTMDLinkDown(pThis, &tmd);
    26462689
    26472690                    /* Write back the TMD, pass it to the host */
    2648                     pcnetTmdStorePassHost(pThis, &tmd, PHYSADDR(pThis, CSR_CXDA(pThis)));
     2691                    pcnetTmdStorePassHost(pDevIns, pThis, &tmd, PHYSADDR(pThis, CSR_CXDA(pThis)));
    26492692
    26502693                    /* advance the ring counter register */
    … …  
    26972740        /* Don't allow the guest to clear TINT before reading it */
    26982741        pThis->u16CSR0LastSeenByGuest &= ~0x0200;
    2699         pcnetUpdateIrq(pThis);
     2742        pcnetUpdateIrq(pDevIns, pThis);
    27002743    }
    27012744
    … …  
    27112754 * @returns VBox status code.  VERR_TRY_AGAIN is returned if we're busy.
    27122755 *
     2756 * @param   pDevIns             The device instance.
    27132757 * @param   pThis               The PCnet shared instance data.
     2758 * @param   pThisCC             The PCNet state data for the current context.
    27142759 * @param   fOnWorkerThread     Whether we're on a worker thread or on an EMT.
    27152760 */
    2716 static int pcnetXmitPending(PPCNETSTATE pThis, bool fOnWorkerThread)
     2761static int pcnetXmitPending(PPDMDEVINS pDevIns, PPCNETSTATE pThis, PPCNETSTATECC pThisCC, bool fOnWorkerThread)
    27172762{
    27182763    RT_NOREF_PV(fOnWorkerThread);
    … …  
    27222767     * Grab the xmit lock of the driver as well as the E1K device state.
    27232768     */
    2724     PPDMINETWORKUP pDrv = pThis->CTX_SUFF(pDrv);
     2769    PPDMINETWORKUP pDrv = pThisCC->pDrv;
    27252770    if (pDrv)
    27262771    {
    … …  
    27362781         * Do the transmitting.
    27372782         */
    2738         int rc2 = pcnetAsyncTransmit(pThis, false /*fOnWorkerThread*/);
     2783        int rc2 = pcnetAsyncTransmit(pDevIns, pThis, pThisCC, false /*fOnWorkerThread*/);
    27392784        AssertReleaseRC(rc2);
    27402785
    … …  
    27562801 * Poll for changes in RX and TX descriptor rings.
    27572802 */
    2758 static void pcnetPollRxTx(PPCNETSTATE pThis)
     2803static void pcnetPollRxTx(PPDMDEVINS pDevIns, PPCNETSTATE pThis, PPCNETSTATECC pThisCC)
    27592804{
    27602805    if (CSR_RXON(pThis))
    … …  
    27672812        if (   HOST_IS_OWNER(CSR_CRST(pThis))  /* only poll RDTEs if none available or ... */
    27682813            || pThis->fMaybeOutOfSpace)        /* ... for waking up pcnetWaitReceiveAvail() */
    2769             pcnetRdtePoll(pThis);
     2814            pcnetRdtePoll(pDevIns, pThis);
    27702815    }
    27712816
    27722817    if (CSR_TDMD(pThis) || (CSR_TXON(pThis) && !CSR_DPOLL(pThis)))
    2773         pcnetTransmit(pThis);
     2818        pcnetTransmit(pDevIns, pThis, pThisCC);
    27742819}
    27752820
    … …  
    27922837 * @thread EMT.
    27932838 */
    2794 static void pcnetPollTimer(PPDMDEVINS pDevIns, PPCNETSTATE pThis)
     2839static void pcnetPollTimer(PPDMDEVINS pDevIns, PPCNETSTATE pThis, PPCNETSTATECC pThisCC)
    27952840{
    27962841    STAM_PROFILE_ADV_START(&pThis->StatPollTimer, a);
    … …  
    28042849        Log2(("#%d pcnetPollTimer time=%#010llx TDMD=%d TXON=%d POLL=%d TDTE=%d TDRA=%#x\n",
    28052850             PCNET_INST_NR, RTTimeMilliTS(), CSR_TDMD(pThis), CSR_TXON(pThis),
    2806              !CSR_DPOLL(pThis), pcnetTdtePoll(pThis, &dummy), pThis->GCTDRA));
     2851             !CSR_DPOLL(pThis), pcnetTdtePoll(pDevIns, pThis, &dummy), pThis->GCTDRA));
    28072852    Log2(("#%d pcnetPollTimer: CSR_CXDA=%#x CSR_XMTRL=%d CSR_XMTRC=%d\n",
    28082853          PCNET_INST_NR, CSR_CXDA(pThis), CSR_XMTRL(pThis), CSR_XMTRC(pThis)));
    … …  
    28122857    {
    28132858        TMD tmd;
    2814         pcnetTmdLoad(pThis, &tmd, PHYSADDR(pThis, CSR_CXDA(pThis)), false);
     2859        pcnetTmdLoad(pDevIns, pThis, &tmd, PHYSADDR(pThis, CSR_CXDA(pThis)), false);
    28152860        Log10(("#%d pcnetPollTimer: TMDLOAD %#010x\n", PCNET_INST_NR, PHYSADDR(pThis, CSR_CXDA(pThis))));
    28162861        PRINT_TMD(&tmd);
    … …  
    28182863#endif
    28192864    if (CSR_TDMD(pThis))
    2820         pcnetTransmit(pThis);
    2821 
    2822     pcnetUpdateIrq(pThis);
     2865        pcnetTransmit(pDevIns, pThis, pThisCC);
     2866
     2867    pcnetUpdateIrq(pDevIns, pThis);
    28232868
    28242869    /* If the receive thread is waiting for new descriptors, poll TX/RX even if polling
    … …  
    28372882         * interval is the default polling interval of the PCnet card (65536/33MHz). */
    28382883#ifdef PCNET_NO_POLLING
    2839         pcnetPollRxTx(pThis);
     2884        pcnetPollRxTx(pDevIns, pThis, pThisCC);
    28402885#else
    28412886        uint64_t u64Now = PDMDevHlpTimerGet(pDevIns, pThis->hTimerPoll);
    … …  
    28432888        {
    28442889            pThis->u64LastPoll = u64Now;
    2845             pcnetPollRxTx(pThis);
     2890            pcnetPollRxTx(pDevIns, pThis, pThisCC);
    28462891        }
    28472892        if (!PDMDevHlpTimerIsActive(pDevIns, pThis->hTimerPoll))
    … …  
    28532898
    28542899
    2855 static VBOXSTRICTRC pcnetCSRWriteU16(PPDMDEVINS pDevIns, PPCNETSTATE pThis, uint32_t u32RAP, uint32_t val)
     2900static VBOXSTRICTRC pcnetCSRWriteU16(PPDMDEVINS pDevIns, PPCNETSTATE pThis, PPCNETSTATECC pThisCC, uint32_t u32RAP, uint32_t val)
    28562901{
    28572902    VBOXSTRICTRC rc  = VINF_SUCCESS;
    … …  
    28842929
    28852930                if (!CSR_STOP(pThis) && (val & 4))
    2886                     pcnetStop(pDevIns, pThis);
     2931                    pcnetStop(pDevIns, pThis, pThisCC);
    28872932
    28882933#ifdef IN_RING3
    28892934                if (!CSR_INIT(pThis) && (val & 1))
    2890                     pcnetR3Init(pThis);
     2935                    pcnetR3Init(pDevIns, pThis, pThisCC);
    28912936#endif
    28922937
    … …  
    28952940
    28962941                if (CSR_TDMD(pThis))
    2897                     pcnetTransmit(pThis);
     2942                    pcnetTransmit(pDevIns, pThis, pThisCC);
    28982943
    28992944                return rc;
    … …  
    29693014            }
    29703015        case 15: /* Mode */
    2971             if ((pThis->aCSR[15] & 0x8000) != (uint16_t)(val & 0x8000) && pThis->pDrvR3)
     3016            if ((pThis->aCSR[15] & 0x8000) != (uint16_t)(val & 0x8000) && pThis->fDriverAttached)
    29723017            {
    29733018                Log(("#%d: promiscuous mode changed to %d\n", PCNET_INST_NR, !!(val & 0x8000)));
    … …  
    29763021#else
    29773022                /* check for promiscuous mode change */
    2978                 if (pThis->pDrvR3)
    2979                     pThis->pDrvR3->pfnSetPromiscuousMode(pThis->pDrvR3, !!(val & 0x8000));
     3023                if (pThisCC->pDrv)
     3024                    pThisCC->pDrv->pfnSetPromiscuousMode(pThisCC->pDrv, !!(val & 0x8000));
    29803025#endif
    29813026            }
    29823027            break;
    29833028        case 16: /* IADRL */
    2984             return pcnetCSRWriteU16(pDevIns, pThis, 1, val);
     3029            return pcnetCSRWriteU16(pDevIns, pThis, pThisCC, 1, val);
    29853030        case 17: /* IADRH */
    2986             return pcnetCSRWriteU16(pDevIns, pThis, 2, val);
     3031            return pcnetCSRWriteU16(pDevIns, pThis, pThisCC, 2, val);
    29873032
    29883033        /*
    … …  
    30753120}
    30763121
    3077 static uint32_t pcnetCSRReadU16(PPCNETSTATE pThis, uint32_t u32RAP)
     3122static uint32_t pcnetCSRReadU16(PPDMDEVINS pDevIns, PPCNETSTATE pThis, uint32_t u32RAP)
    30783123{
    30793124    uint32_t val;
    … …  
    30813126    {
    30823127        case 0:
    3083             pcnetUpdateIrq(pThis);
     3128            pcnetUpdateIrq(pDevIns, pThis);
    30843129            val = pThis->aCSR[0];
    30853130            val |= (val & 0x7800) ? 0x8000 : 0;
    … …  
    30873132            break;
    30883133        case 16:
    3089             return pcnetCSRReadU16(pThis, 1);
     3134            return pcnetCSRReadU16(pDevIns, pThis, 1);
    30903135        case 17:
    3091             return pcnetCSRReadU16(pThis, 2);
     3136            return pcnetCSRReadU16(pDevIns, pThis, 2);
    30923137        case 58:
    30933138            return pcnetBCRReadU16(pThis, BCR_SWS);
    … …  
    33423387            val = pThis->aBCR[u32RAP] & ~0x8000;
    33433388            /* Clear LNKSTE if we're not connected or if we've just loaded a VM state. */
    3344             if (!pThis->pDrvR3 || pThis->fLinkTempDown || !pThis->fLinkUp)
     3389            if (!pThis->fDriverAttached || pThis->fLinkTempDown || !pThis->fLinkUp)
    33453390            {
    33463391                if (u32RAP == 4)
    … …  
    35473592}
    35483593
    3549 static uint32_t pcnetIoPortReadU8(PPCNETSTATE pThis, uint32_t addr)
     3594static uint32_t pcnetIoPortReadU8(PPDMDEVINS pDevIns, PPCNETSTATE pThis, uint32_t addr)
    35503595{
    35513596    uint32_t val = UINT32_MAX;
    … …  
    35643609        Log(("#%d pcnetIoPortReadU8: addr=%#010x val=%#06x BCR_DWIO !!\n", PCNET_INST_NR, addr, val & 0xff));
    35653610
    3566     pcnetUpdateIrq(pThis);
     3611    pcnetUpdateIrq(pDevIns, pThis);
    35673612
    35683613    Log6(("#%d pcnetIoPortReadU8: addr=%#010x val=%#06x\n", PCNET_INST_NR, addr, val & 0xff));
    … …  
    35703615}
    35713616
    3572 static VBOXSTRICTRC pcnetIoPortWriteU16(PPDMDEVINS pDevIns, PPCNETSTATE pThis, uint32_t addr, uint32_t val)
     3617static VBOXSTRICTRC pcnetIoPortWriteU16(PPDMDEVINS pDevIns, PPCNETSTATE pThis, PPCNETSTATECC pThisCC, uint32_t addr, uint32_t val)
    35733618{
    35743619    VBOXSTRICTRC rc = VINF_SUCCESS;
    … …  
    35803625        {
    35813626            case 0x00: /* RDP */
    3582                 pcnetPollTimer(pDevIns, pThis);
    3583                 rc = pcnetCSRWriteU16(pDevIns, pThis, pThis->u32RAP, val);
    3584                 pcnetUpdateIrq(pThis);
     3627                pcnetPollTimer(pDevIns, pThis, pThisCC);
     3628                rc = pcnetCSRWriteU16(pDevIns, pThis, pThisCC, pThis->u32RAP, val);
     3629                pcnetUpdateIrq(pDevIns, pThis);
    35853630                break;
    35863631            case 0x02: /* RAP */
    … …  
    35983643}
    35993644
    3600 static uint32_t pcnetIoPortReadU16(PPDMDEVINS pDevIns, PPCNETSTATE pThis, uint32_t addr)
     3645static uint32_t pcnetIoPortReadU16(PPDMDEVINS pDevIns, PPCNETSTATE pThis, PPCNETSTATECC pThisCC, uint32_t addr)
    36013646{
    36023647    uint32_t val = ~0U;
    … …  
    36103655                /** Polling is then useless here and possibly expensive. */
    36113656                if (!CSR_DPOLL(pThis))
    3612                     pcnetPollTimer(pDevIns, pThis);
    3613 
    3614                 val = pcnetCSRReadU16(pThis, pThis->u32RAP);
     3657                    pcnetPollTimer(pDevIns, pThis, pThisCC);
     3658
     3659                val = pcnetCSRReadU16(pDevIns, pThis, pThis->u32RAP);
    36153660                if (pThis->u32RAP == 0)  // pcnetUpdateIrq() already called by pcnetCSRReadU16()
    36163661                    goto skip_update_irq;
    … …  
    36313676        Log(("#%d pcnetIoPortReadU16: addr=%#010x val=%#06x BCR_DWIO !!\n", PCNET_INST_NR, addr, val & 0xffff));
    36323677
    3633     pcnetUpdateIrq(pThis);
     3678    pcnetUpdateIrq(pDevIns, pThis);
    36343679
    36353680skip_update_irq:
    … …  
    36383683}
    36393684
    3640 static VBOXSTRICTRC pcnetIoPortWriteU32(PPDMDEVINS pDevIns, PPCNETSTATE pThis, uint32_t addr, uint32_t val)
     3685static VBOXSTRICTRC pcnetIoPortWriteU32(PPDMDEVINS pDevIns, PPCNETSTATE pThis, PPCNETSTATECC pThisCC, uint32_t addr, uint32_t val)
    36413686{
    36423687    VBOXSTRICTRC rc = VINF_SUCCESS;
    … …  
    36483693        {
    36493694            case 0x00: /* RDP */
    3650                 pcnetPollTimer(pDevIns, pThis);
    3651                 rc = pcnetCSRWriteU16(pDevIns, pThis, pThis->u32RAP, val & 0xffff);
    3652                 pcnetUpdateIrq(pThis);
     3695                pcnetPollTimer(pDevIns, pThis, pThisCC);
     3696                rc = pcnetCSRWriteU16(pDevIns, pThis, pThisCC, pThis->u32RAP, val & 0xffff);
     3697                pcnetUpdateIrq(pDevIns, pThis);
    36533698                break;
    36543699            case 0x04: /* RAP */
    … …  
    36723717}
    36733718
    3674 static uint32_t pcnetIoPortReadU32(PPDMDEVINS pDevIns, PPCNETSTATE pThis, uint32_t addr)
     3719static uint32_t pcnetIoPortReadU32(PPDMDEVINS pDevIns, PPCNETSTATE pThis, PPCNETSTATECC pThisCC, uint32_t addr)
    36753720{
    36763721    uint32_t val = ~0U;
    … …  
    36843729                /** Polling is then useless here and possibly expensive. */
    36853730                if (!CSR_DPOLL(pThis))
    3686                     pcnetPollTimer(pDevIns, pThis);
    3687 
    3688                 val = pcnetCSRReadU16(pThis, pThis->u32RAP);
     3731                    pcnetPollTimer(pDevIns, pThis, pThisCC);
     3732
     3733                val = pcnetCSRReadU16(pDevIns, pThis, pThis->u32RAP);
    36893734                if (pThis->u32RAP == 0)  // pcnetUpdateIrq() already called by pcnetCSRReadU16()
    36903735                    goto skip_update_irq;
    … …  
    37043749    else
    37053750        Log(("#%d pcnetIoPortReadU32: addr=%#010x val=%#010x !BCR_DWIO !!\n", PCNET_INST_NR, addr, val));
    3706     pcnetUpdateIrq(pThis);
     3751    pcnetUpdateIrq(pDevIns, pThis);
    37073752
    37083753skip_update_irq:
    … …  
    37173762static DECLCALLBACK(VBOXSTRICTRC) pcnetIoPortRead(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT offPort, uint32_t *pu32, unsigned cb)
    37183763{
    3719     PPCNETSTATE     pThis = PDMDEVINS_2_DATA(pDevIns, PPCNETSTATE);
    3720     VBOXSTRICTRC    rc    = VINF_SUCCESS;
     3764    PPCNETSTATE     pThis   = PDMDEVINS_2_DATA(pDevIns, PPCNETSTATE);
     3765    PPCNETSTATECC   pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PPCNETSTATECC);
     3766    VBOXSTRICTRC    rc      = VINF_SUCCESS;
    37213767    STAM_PROFILE_ADV_START(&pThis->CTX_SUFF_Z(StatIORead), a);
    37223768    Assert(PDMCritSectIsOwner(&pThis->CritSect));
    … …  
    37253771    switch (cb)
    37263772    {
    3727         case 1: *pu32 = pcnetIoPortReadU8(pThis, offPort); break;
    3728         case 2: *pu32 = pcnetIoPortReadU16(pDevIns, pThis, offPort); break;
    3729         case 4: *pu32 = pcnetIoPortReadU32(pDevIns, pThis, offPort); break;
     3773        case 1: *pu32 = pcnetIoPortReadU8(pDevIns, pThis, offPort); break;
     3774        case 2: *pu32 = pcnetIoPortReadU16(pDevIns, pThis, pThisCC, offPort); break;
     3775        case 4: *pu32 = pcnetIoPortReadU32(pDevIns, pThis, pThisCC, offPort); break;
    37303776        default:
    37313777            rc = PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS, "pcnetIoPortRead: unsupported op size: offset=%#10x cb=%u\n", offPort, cb);
    … …  
    37433789static DECLCALLBACK(VBOXSTRICTRC) pcnetIoPortWrite(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT offPort, uint32_t u32, unsigned cb)
    37443790{
    3745     PPCNETSTATE     pThis = PDMDEVINS_2_DATA(pDevIns, PPCNETSTATE);
    3746     VBOXSTRICTRC    rc    = VINF_SUCCESS;
     3791    PPCNETSTATE     pThis   = PDMDEVINS_2_DATA(pDevIns, PPCNETSTATE);
     3792    PPCNETSTATECC   pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PPCNETSTATECC);
     3793    VBOXSTRICTRC    rc;
    37473794    STAM_PROFILE_ADV_START(&pThis->CTX_SUFF_Z(StatIOWrite), a);
    37483795    Assert(PDMCritSectIsOwner(&pThis->CritSect));
    … …  
    37523799    {
    37533800        case 1: rc = pcnetIoPortWriteU8(pThis, offPort, u32); break;
    3754         case 2: rc = pcnetIoPortWriteU16(pDevIns, pThis, offPort, u32); break;
    3755         case 4: rc = pcnetIoPortWriteU32(pDevIns, pThis, offPort, u32); break;
     3801        case 2: rc = pcnetIoPortWriteU16(pDevIns, pThis, pThisCC, offPort, u32); break;
     3802        case 4: rc = pcnetIoPortWriteU32(pDevIns, pThis, pThisCC, offPort, u32); break;
    37563803        default:
    37573804            rc = PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS, "pcnetIoPortWrite: unsupported op size: offset=%#10x cb=%u\n", offPort, cb);
    … …  
    37843831}
    37853832
    3786 static VBOXSTRICTRC pcnetR3MmioWriteU16(PPDMDEVINS pDevIns, PPCNETSTATE pThis, RTGCPHYS off, uint32_t val)
     3833static VBOXSTRICTRC pcnetR3MmioWriteU16(PPDMDEVINS pDevIns, PPCNETSTATE pThis, PPCNETSTATECC pThisCC, RTGCPHYS off, uint32_t val)
    37873834{
    37883835    VBOXSTRICTRC rcStrict;
    … …  
    37903837    if (off & 0x10)
    37913838    {
    3792         rcStrict = pcnetIoPortWriteU16(pDevIns, pThis, off & 0x0f, val);
     3839        rcStrict = pcnetIoPortWriteU16(pDevIns, pThis, pThisCC, off & 0x0f, val);
    37933840        if (rcStrict == VINF_IOM_R3_IOPORT_WRITE)
    37943841            rcStrict = VINF_IOM_R3_MMIO_WRITE;
    … …  
    38033850}
    38043851
    3805 static uint32_t pcnetR3MmioReadU16(PPDMDEVINS pDevIns, PPCNETSTATE pThis, RTGCPHYS addr)
     3852static uint32_t pcnetR3MmioReadU16(PPDMDEVINS pDevIns, PPCNETSTATE pThis, PPCNETSTATECC pThisCC, RTGCPHYS addr)
    38063853{
    38073854    uint32_t val = ~0U;
    38083855
    38093856    if (addr & 0x10)
    3810         val = pcnetIoPortReadU16(pDevIns, pThis, addr & 0x0f);
     3857        val = pcnetIoPortReadU16(pDevIns, pThis, pThisCC, addr & 0x0f);
    38113858    else
    38123859    {
    … …  
    38193866}
    38203867
    3821 static VBOXSTRICTRC pcnetR3MmioWriteU32(PPDMDEVINS pDevIns, PPCNETSTATE pThis, RTGCPHYS off, uint32_t val)
     3868static VBOXSTRICTRC pcnetR3MmioWriteU32(PPDMDEVINS pDevIns, PPCNETSTATE pThis, PPCNETSTATECC pThisCC, RTGCPHYS off, uint32_t val)
    38223869{
    38233870    VBOXSTRICTRC rcStrict;
    … …  
    38253872    if (off & 0x10)
    38263873    {
    3827         rcStrict = pcnetIoPortWriteU32(pDevIns, pThis, off & 0x0f, val);
     3874        rcStrict = pcnetIoPortWriteU32(pDevIns, pThis, pThisCC, off & 0x0f, val);
    38283875        if (rcStrict == VINF_IOM_R3_IOPORT_WRITE)
    38293876            rcStrict = VINF_IOM_R3_MMIO_WRITE;
    … …  
    38403887}
    38413888
    3842 static uint32_t pcnetR3MmioReadU32(PPDMDEVINS pDevIns, PPCNETSTATE pThis, RTGCPHYS addr)
     3889static uint32_t pcnetR3MmioReadU32(PPDMDEVINS pDevIns, PPCNETSTATE pThis, PPCNETSTATECC pThisCC, RTGCPHYS addr)
    38433890{
    38443891    uint32_t val;
    38453892
    38463893    if (addr & 0x10)
    3847         val = pcnetIoPortReadU32(pDevIns, pThis, addr & 0x0f);
     3894        val = pcnetIoPortReadU32(pDevIns, pThis, pThisCC, addr & 0x0f);
    38483895    else
    38493896    {
    … …  
    38663913static DECLCALLBACK(VBOXSTRICTRC) pcnetR3MmioRead(PPDMDEVINS pDevIns, void *pvUser, RTGCPHYS off, void *pv, unsigned cb)
    38673914{
    3868     PPCNETSTATE     pThis = PDMDEVINS_2_DATA(pDevIns, PPCNETSTATE);
    3869     VBOXSTRICTRC    rc    = VINF_SUCCESS;
     3915    PPCNETSTATE     pThis   = PDMDEVINS_2_DATA(pDevIns, PPCNETSTATE);
     3916    PPCNETSTATECC   pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PPCNETSTATECC);
     3917    VBOXSTRICTRC    rc      = VINF_SUCCESS;
    38703918    Assert(PDMCritSectIsOwner(&pThis->CritSect));
    38713919    RT_NOREF_PV(pvUser);
    … …  
    38803928        {
    38813929            case 1:  *(uint8_t  *)pv = pcnetR3MmioReadU8 (pThis, off); break;
    3882             case 2:  *(uint16_t *)pv = pcnetR3MmioReadU16(pDevIns, pThis, off); break;
    3883             case 4:  *(uint32_t *)pv = pcnetR3MmioReadU32(pDevIns, pThis, off); break;
     3930            case 2:  *(uint16_t *)pv = pcnetR3MmioReadU16(pDevIns, pThis, pThisCC, off); break;
     3931            case 4:  *(uint32_t *)pv = pcnetR3MmioReadU32(pDevIns, pThis, pThisCC, off); break;
    38843932            default:
    38853933                rc = PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS, "pcnetR3MmioRead: unsupported op size: address=%RGp cb=%u\n", off, cb);
    … …  
    39013949static DECLCALLBACK(VBOXSTRICTRC) pcnetR3MmioWrite(PPDMDEVINS pDevIns, void *pvUser, RTGCPHYS off, void const *pv, unsigned cb)
    39023950{
    3903     PPCNETSTATE     pThis = PDMDEVINS_2_DATA(pDevIns, PPCNETSTATE);
    3904     VBOXSTRICTRC    rc    = VINF_SUCCESS;
     3951    PPCNETSTATE     pThis   = PDMDEVINS_2_DATA(pDevIns, PPCNETSTATE);
     3952    PPCNETSTATECC   pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PPCNETSTATECC);
     3953    VBOXSTRICTRC    rc      = VINF_SUCCESS;
    39053954    Assert(PDMCritSectIsOwner(&pThis->CritSect));
    39063955    RT_NOREF_PV(pvUser);
    … …  
    39153964        {
    39163965            case 1:  pcnetR3MmioWriteU8(pThis, off, *(uint8_t  *)pv); break;
    3917             case 2:  rc = pcnetR3MmioWriteU16(pDevIns, pThis, off, *(uint16_t *)pv); break;
    3918             case 4:  rc = pcnetR3MmioWriteU32(pDevIns, pThis, off, *(uint32_t *)pv); break;
     3966            case 2:  rc = pcnetR3MmioWriteU16(pDevIns, pThis, pThisCC, off, *(uint16_t *)pv); break;
     3967            case 4:  rc = pcnetR3MmioWriteU32(pDevIns, pThis, pThisCC, off, *(uint32_t *)pv); break;
    39193968            default:
    39203969                rc = PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS, "pcnetR3MmioWrite: unsupported op size: address=%RGp cb=%u\n", off, cb);
    … …  
    39373986static DECLCALLBACK(void) pcnetR3Timer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
    39383987{
     3988    PPCNETSTATE   pThis   = PDMDEVINS_2_DATA(pDevIns, PPCNETSTATE);
     3989    PPCNETSTATECC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PPCNETSTATECC);
     3990    Assert(PDMCritSectIsOwner(&pThis->CritSect));
     3991    RT_NOREF(pvUser, pTimer);
     3992
     3993    STAM_PROFILE_ADV_START(&pThis->StatTimer, a);
     3994    pcnetPollTimer(pDevIns, pThis, pThisCC);
     3995    STAM_PROFILE_ADV_STOP(&pThis->StatTimer, a);
     3996}
     3997
     3998
     3999/**
     4000 * @callback_method_impl{FNTMTIMERDEV,
     4001 *      Software interrupt timer callback function.}
     4002 */
     4003static DECLCALLBACK(void) pcnetR3TimerSoftInt(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
     4004{
    39394005    PPCNETSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PPCNETSTATE);
    39404006    Assert(PDMCritSectIsOwner(&pThis->CritSect));
    39414007    RT_NOREF(pvUser, pTimer);
    39424008
    3943     STAM_PROFILE_ADV_START(&pThis->StatTimer, a);
    3944     pcnetPollTimer(pDevIns, pThis);
    3945     STAM_PROFILE_ADV_STOP(&pThis->StatTimer, a);
    3946 }
    3947 
    3948 
    3949 /**
    3950  * @callback_method_impl{FNTMTIMERDEV,
    3951  *      Software interrupt timer callback function.}
    3952  */
    3953 static DECLCALLBACK(void) pcnetR3TimerSoftInt(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
    3954 {
    3955     PPCNETSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PPCNETSTATE);
    3956     Assert(PDMCritSectIsOwner(&pThis->CritSect));
    3957     RT_NOREF(pvUser, pTimer);
    3958 
    39594009    pThis->aCSR[7] |= 0x0800; /* STINT */
    3960     pcnetUpdateIrq(pThis);
     4010    pcnetUpdateIrq(pDevIns, pThis);
    39614011    PDMDevHlpTimerSetNano(pDevIns, pThis->hTimerSoftInt, 12800U * (pThis->aBCR[BCR_STVAL] & 0xffff));
    39624012}
    … …  
    42194269        {
    42204270            RMD rmd;
    4221             pcnetRmdLoad(pThis, &rmd, PHYSADDR(pThis, GCPhys), false);
     4271            pcnetRmdLoad(pDevIns, pThis, &rmd, PHYSADDR(pThis, GCPhys), false);
    42224272            pHlp->pfnPrintf(pHlp,
    42234273                            "%04x %RX32:%c%c RBADR=%08RX32 BCNT=%03x MCNT=%03x "
    … …  
    42594309        {
    42604310            TMD tmd;
    4261             pcnetTmdLoad(pThis, &tmd, PHYSADDR(pThis, GCPhys), false);
     4311            pcnetTmdLoad(pDevIns, pThis, &tmd, PHYSADDR(pThis, GCPhys), false);
    42624312            pHlp->pfnPrintf(pHlp,
    42634313                            "%04x %RX32:%c%c TBADR=%08RX32 BCNT=%03x OWN=%d "
    … …  
    44524502static DECLCALLBACK(int) pcnetR3LoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
    44534503{
    4454     PPCNETSTATE     pThis = PDMDEVINS_2_DATA(pDevIns, PPCNETSTATE);
    4455     PCPDMDEVHLPR3   pHlp  = pDevIns->pHlpR3;
     4504    PPCNETSTATE     pThis   = PDMDEVINS_2_DATA(pDevIns, PPCNETSTATE);
     4505    PPCNETSTATECC   pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PPCNETSTATECC);
     4506    PCPDMDEVHLPR3   pHlp    = pDevIns->pHlpR3;
    44564507
    44574508    if (   SSM_VERSION_MAJOR_CHANGED(uVersion, PCNET_SAVEDSTATE_VERSION)
    … …  
    45354586
    45364587        /* update promiscuous mode. */
    4537         if (pThis->pDrvR3)
    4538             pThis->pDrvR3->pfnSetPromiscuousMode(pThis->pDrvR3, CSR_PROM(pThis));
     4588        if (pThisCC->pDrv)
     4589            pThisCC->pDrv->pfnSetPromiscuousMode(pThisCC->pDrv, CSR_PROM(pThis));
    45394590
    45404591#ifdef PCNET_NO_POLLING
    … …  
    45774628 *
    45784629 * @returns VBox status code.
    4579  * @param   pThis           The PCnet shared instance data.
    4580  */
    4581 static int pcnetR3CanReceive(PPCNETSTATE pThis)
     4630 * @param   pDevIns     The device instance.
     4631 * @param   pThis       The PCnet shared instance data.
     4632 */
     4633static int pcnetR3CanReceive(PPDMDEVINS pDevIns, PPCNETSTATE pThis)
    45824634{
    45834635    int rc = PDMCritSectEnter(&pThis->CritSect, VERR_SEM_BUSY);
    … …  
    45894641    {
    45904642        if (HOST_IS_OWNER(CSR_CRST(pThis)) && pThis->GCRDRA)
    4591             pcnetRdtePoll(pThis);
     4643            pcnetRdtePoll(pDevIns, pThis);
    45924644
    45934645        if (RT_UNLIKELY(HOST_IS_OWNER(CSR_CRST(pThis))))
    … …  
    46114663static DECLCALLBACK(int) pcnetR3NetworkDown_WaitReceiveAvail(PPDMINETWORKDOWN pInterface, RTMSINTERVAL cMillies)
    46124664{
    4613     PPCNETSTATE pThis = RT_FROM_MEMBER(pInterface, PCNETSTATE, INetworkDown);
    4614     PPDMDEVINS  pDevIns = pThis->pDevInsR3;
    4615 
    4616     int rc = pcnetR3CanReceive(pThis);
     4665    PPCNETSTATECC pThisCC = RT_FROM_MEMBER(pInterface, PCNETSTATECC, INetworkDown);
     4666    PPDMDEVINS    pDevIns = pThisCC->pDevIns;
     4667    PPCNETSTATE   pThis   = PDMDEVINS_2_DATA(pDevIns, PPCNETSTATE);
     4668
     4669    int rc = pcnetR3CanReceive(pDevIns, pThis);
    46174670    if (RT_SUCCESS(rc))
    46184671        return VINF_SUCCESS;
    … …  
    46244677    STAM_PROFILE_START(&pThis->StatRxOverflow, a);
    46254678    VMSTATE enmVMState;
    4626     while (RT_LIKELY(   (enmVMState = PDMDevHlpVMState(pThis->CTX_SUFF(pDevIns))) == VMSTATE_RUNNING
     4679    while (RT_LIKELY(   (enmVMState = PDMDevHlpVMState(pDevIns)) == VMSTATE_RUNNING
    46274680                     || enmVMState == VMSTATE_RUNNING_LS))
    46284681    {
    4629         int rc2 = pcnetR3CanReceive(pThis);
     4682        int rc2 = pcnetR3CanReceive(pDevIns, pThis);
    46304683        if (RT_SUCCESS(rc2))
    46314684        {
    … …  
    46564709static DECLCALLBACK(int) pcnetR3NetworkDown_Receive(PPDMINETWORKDOWN pInterface, const void *pvBuf, size_t cb)
    46574710{
    4658     PPCNETSTATE pThis = RT_FROM_MEMBER(pInterface, PCNETSTATE, INetworkDown);
    4659     int         rc;
     4711    PPCNETSTATECC pThisCC = RT_FROM_MEMBER(pInterface, PCNETSTATECC, INetworkDown);
     4712    PPDMDEVINS    pDevIns = pThisCC->pDevIns;
     4713    PPCNETSTATE   pThis   = PDMDEVINS_2_DATA(pDevIns, PPCNETSTATE);
    46604714
    46614715    STAM_PROFILE_ADV_START(&pThis->StatReceive, a);
    4662     rc = PDMCritSectEnter(&pThis->CritSect, VERR_SEM_BUSY);
     4716    int rc = PDMCritSectEnter(&pThis->CritSect, VERR_SEM_BUSY);
    46634717    AssertReleaseRC(rc);
    46644718
    … …  
    46774731        if (cb > 70) /* unqualified guess */
    46784732            pThis->Led.Asserted.s.fReading = pThis->Led.Actual.s.fReading = 1;
    4679         pcnetReceiveNoSync(pThis, (const uint8_t *)pvBuf, cb, fAddFCS, false);
     4733        pcnetReceiveNoSync(pDevIns, pThis, pThisCC, (const uint8_t *)pvBuf, cb, fAddFCS, false);
    46804734        pThis->Led.Actual.s.fReading = 0;
    46814735    }
    … …  
    47104764static DECLCALLBACK(void) pcnetR3NetworkDown_XmitPending(PPDMINETWORKDOWN pInterface)
    47114765{
    4712     PPCNETSTATE pThis = RT_FROM_MEMBER(pInterface, PCNETSTATE, INetworkDown);
    4713     pcnetXmitPending(pThis, true /*fOnWorkerThread*/);
     4766    PPCNETSTATECC pThisCC = RT_FROM_MEMBER(pInterface, PCNETSTATECC, INetworkDown);
     4767    PPDMDEVINS    pDevIns = pThisCC->pDevIns;
     4768    PPCNETSTATE   pThis   = PDMDEVINS_2_DATA(pDevIns, PPCNETSTATE);
     4769    pcnetXmitPending(pDevIns, pThis, pThisCC, true /*fOnWorkerThread*/);
    47144770}
    47154771
    … …  
    47224778static DECLCALLBACK(int) pcnetR3NetworkConfig_GetMac(PPDMINETWORKCONFIG pInterface, PRTMAC pMac)
    47234779{
    4724     PPCNETSTATE pThis = RT_FROM_MEMBER(pInterface, PCNETSTATE, INetworkConfig);
     4780    PPCNETSTATECC pThisCC = RT_FROM_MEMBER(pInterface, PCNETSTATECC, INetworkConfig);
     4781    PPDMDEVINS    pDevIns = pThisCC->pDevIns;
     4782    PPCNETSTATE   pThis   = PDMDEVINS_2_DATA(pDevIns, PPCNETSTATE);
    47254783    memcpy(pMac, pThis->aPROM, sizeof(*pMac));
    47264784    return VINF_SUCCESS;
    … …  
    47334791static DECLCALLBACK(PDMNETWORKLINKSTATE) pcnetR3NetworkConfig_GetLinkState(PPDMINETWORKCONFIG pInterface)
    47344792{
    4735     PPCNETSTATE pThis = RT_FROM_MEMBER(pInterface, PCNETSTATE, INetworkConfig);
     4793    PPCNETSTATECC pThisCC = RT_FROM_MEMBER(pInterface, PCNETSTATECC, INetworkConfig);
     4794    PPDMDEVINS    pDevIns = pThisCC->pDevIns;
     4795    PPCNETSTATE   pThis   = PDMDEVINS_2_DATA(pDevIns, PPCNETSTATE);
    47364796    if (pThis->fLinkUp && !pThis->fLinkTempDown)
    47374797        return PDMNETWORKLINKSTATE_UP;
    … …  
    47504810static DECLCALLBACK(int) pcnetR3NetworkConfig_SetLinkState(PPDMINETWORKCONFIG pInterface, PDMNETWORKLINKSTATE enmState)
    47514811{
    4752     PPCNETSTATE     pThis   = RT_FROM_MEMBER(pInterface, PCNETSTATE, INetworkConfig);
    4753     PPDMDEVINS      pDevIns = pThis->pDevInsR3;
     4812    PPCNETSTATECC pThisCC = RT_FROM_MEMBER(pInterface, PCNETSTATECC, INetworkConfig);
     4813    PPDMDEVINS    pDevIns = pThisCC->pDevIns;
     4814    PPCNETSTATE   pThis   = PDMDEVINS_2_DATA(pDevIns, PPCNETSTATE);
    47544815    bool fLinkUp;
    47554816
    … …  
    47904851        }
    47914852        Assert(!PDMCritSectIsOwner(&pThis->CritSect));
    4792         if (pThis->pDrvR3)
    4793             pThis->pDrvR3->pfnNotifyLinkChanged(pThis->pDrvR3, enmState);
     4853        if (pThisCC->pDrv)
     4854            pThisCC->pDrv->pfnNotifyLinkChanged(pThisCC->pDrv, enmState);
    47944855    }
    47954856    return VINF_SUCCESS;
    … …  
    48044865static DECLCALLBACK(int) pcnetQueryStatusLed(PPDMILEDPORTS pInterface, unsigned iLUN, PPDMLED *ppLed)
    48054866{
    4806     PPCNETSTATE pThis = RT_FROM_MEMBER(pInterface, PCNETSTATE, ILeds);
     4867    PPCNETSTATECC pThisCC = RT_FROM_MEMBER(pInterface, PCNETSTATECC, ILeds);
     4868    PPDMDEVINS    pDevIns = pThisCC->pDevIns;
     4869    PPCNETSTATE   pThis   = PDMDEVINS_2_DATA(pDevIns, PPCNETSTATE);
    48074870    if (iLUN == 0)
    48084871    {
    … …  
    48214884static DECLCALLBACK(void *) pcnetQueryInterface(struct PDMIBASE *pInterface, const char *pszIID)
    48224885{
    4823     PPCNETSTATE pThis = RT_FROM_MEMBER(pInterface, PCNETSTATE, IBase);
    4824     Assert(&pThis->IBase == pInterface);
    4825     PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pThis->IBase);
    4826     PDMIBASE_RETURN_INTERFACE(pszIID, PDMINETWORKDOWN, &pThis->INetworkDown);
    4827     PDMIBASE_RETURN_INTERFACE(pszIID, PDMINETWORKCONFIG, &pThis->INetworkConfig);
    4828     PDMIBASE_RETURN_INTERFACE(pszIID, PDMILEDPORTS, &pThis->ILeds);
     4886    PPCNETSTATECC pThisCC = RT_FROM_MEMBER(pInterface, PCNETSTATECC, IBase);
     4887    Assert(&pThisCC->IBase == pInterface);
     4888    PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pThisCC->IBase);
     4889    PDMIBASE_RETURN_INTERFACE(pszIID, PDMINETWORKDOWN, &pThisCC->INetworkDown);
     4890    PDMIBASE_RETURN_INTERFACE(pszIID, PDMINETWORKCONFIG, &pThisCC->INetworkConfig);
     4891    PDMIBASE_RETURN_INTERFACE(pszIID, PDMILEDPORTS, &pThisCC->ILeds);
    48294892    return NULL;
    48304893}
    … …  
    48504913static DECLCALLBACK(void) pcnetR3Detach(PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags)
    48514914{
     4915    PPCNETSTATE     pThis   = PDMDEVINS_2_DATA(pDevIns, PPCNETSTATE);
     4916    PPCNETSTATECC   pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PPCNETSTATECC);
     4917    Log(("#%d pcnetR3Detach:\n", PCNET_INST_NR));
    48524918    RT_NOREF(fFlags);
    4853     PPCNETSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PPCNETSTATE);
    4854     Log(("#%d pcnetR3Detach:\n", PCNET_INST_NR));
    48554919
    48564920    AssertLogRelReturnVoid(iLUN == 0);
    … …  
    48654929     * Zero some important members.
    48664930     */
    4867     pThis->pDrvBase = NULL;
    4868     pThis->pDrvR3 = NULL;
    4869     pThis->pDrvR0 = NIL_RTR0PTR;
    4870     pThis->pDrvRC = NIL_RTRCPTR;
     4931    pThis->fDriverAttached = false;
     4932    pThisCC->pDrvBase = NULL;
     4933    pThisCC->pDrv = NULL;
     4934    /// @todo figure this out
     4935    //pThis->pDrvR0 = NIL_RTR0PTR;
     4936    //pThis->pDrvRC = NIL_RTRCPTR;
    48714937
    48724938    PDMCritSectLeave(&pThis->CritSect);
    … …  
    48804946static DECLCALLBACK(int) pcnetR3Attach(PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags)
    48814947{
     4948    PPCNETSTATE     pThis   = PDMDEVINS_2_DATA(pDevIns, PPCNETSTATE);
     4949    PPCNETSTATECC   pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PPCNETSTATECC);
     4950    LogFlow(("#%d pcnetR3Attach:\n", PCNET_INST_NR));
    48824951    RT_NOREF(fFlags);
    4883     PPCNETSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PPCNETSTATE);
    4884     LogFlow(("#%d pcnetR3Attach:\n", PCNET_INST_NR));
    48854952
    48864953    AssertLogRelReturn(iLUN == 0, VERR_PDM_NO_SUCH_LUN);
    … …  
    48914958     * Attach the driver.
    48924959     */
    4893     int rc = PDMDevHlpDriverAttach(pDevIns, 0, &pThis->IBase, &pThis->pDrvBase, "Network Port");
     4960    int rc = PDMDevHlpDriverAttach(pDevIns, 0, &pThisCC->IBase, &pThisCC->pDrvBase, "Network Port");
    48944961    if (RT_SUCCESS(rc))
    48954962    {
    4896         pThis->pDrvR3 = PDMIBASE_QUERY_INTERFACE(pThis->pDrvBase, PDMINETWORKUP);
    4897         AssertMsgStmt(pThis->pDrvR3, ("Failed to obtain the PDMINETWORKUP interface!\n"),
     4963        pThisCC->pDrv = PDMIBASE_QUERY_INTERFACE(pThisCC->pDrvBase, PDMINETWORKUP);
     4964        AssertMsgStmt(pThisCC->pDrv, ("Failed to obtain the PDMINETWORKUP interface!\n"),
    48984965                      rc = VERR_PDM_MISSING_INTERFACE_BELOW);
    4899         pThis->pDrvR0 = PDMIBASER0_QUERY_INTERFACE(PDMIBASE_QUERY_INTERFACE(pThis->pDrvBase, PDMIBASER0), PDMINETWORKUP);
    4900         pThis->pDrvRC = PDMIBASERC_QUERY_INTERFACE(PDMIBASE_QUERY_INTERFACE(pThis->pDrvBase, PDMIBASERC), PDMINETWORKUP);
     4966        pThis->fDriverAttached = true;
     4967        /// @todo figoure out this
     4968        //pThis->pDrvR0 = PDMIBASER0_QUERY_INTERFACE(PDMIBASE_QUERY_INTERFACE(pThis->pDrvBase, PDMIBASER0), PDMINETWORKUP);
     4969        //pThis->pDrvRC = PDMIBASERC_QUERY_INTERFACE(PDMIBASE_QUERY_INTERFACE(pThis->pDrvBase, PDMIBASERC), PDMINETWORKUP);
    49014970    }
    49024971    else if (   rc == VERR_PDM_NO_ATTACHED_DRIVER
    … …  
    49555024static DECLCALLBACK(void) pcnetR3Relocate(PPDMDEVINS pDevIns, RTGCINTPTR offDelta)
    49565025{
    4957     RT_NOREF(offDelta);
    4958     PPCNETSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PPCNETSTATE);
    4959     pThis->pDevInsRC     = PDMDEVINS_2_RCPTR(pDevIns);
     5026    PPCNETSTATERC pThisRC = PDMINS_2_DATA_RC(pDevIns, PPCNETSTATERC);
     5027    pThisRC->pDrv += offDelta;
    49605028#ifdef PCNET_NO_POLLING
    4961     pThis->pfnEMInterpretInstructionRC += offDelta;
     5029    pThisRC->pfnEMInterpretInstructionRC += offDelta;
    49625030#endif
    49635031}
    … …  
    49915059{
    49925060    PDMDEV_CHECK_VERSIONS_RETURN(pDevIns);
    4993     PPCNETSTATE     pThis = PDMDEVINS_2_DATA(pDevIns, PPCNETSTATE);
    4994     PCPDMDEVHLPR3   pHlp  = pDevIns->pHlpR3;
     5061    PPCNETSTATE     pThis   = PDMDEVINS_2_DATA(pDevIns, PPCNETSTATE);
     5062    PPCNETSTATECC   pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PPCNETSTATECC);
     5063    PCPDMDEVHLPR3   pHlp    = pDevIns->pHlpR3;
    49955064    PPDMIBASE       pBase;
    49965065    char            szTmp[128];
    … …  
    50045073     * Init what's required to make the destructor safe.
    50055074     */
     5075    pThis->iInstance            = iInstance;
    50065076    pThis->hEventOutOfRxSpace   = NIL_SUPSEMEVENT;
    50075077    pThis->hIoPortsPci          = NIL_IOMIOPORTHANDLE;
    … …  
    50095079    pThis->hIoPortsIsa          = NIL_IOMIOPORTHANDLE;
    50105080    pThis->hIoPortsIsaAProm     = NIL_IOMIOPORTHANDLE;
     5081    pThisCC->pDevIns            = pDevIns;
    50115082
    50125083    /*
    … …  
    50965167     * Initialize data (most of it anyway).
    50975168     */
    5098     pThis->pDevInsR3                        = pDevIns;
    5099     pThis->pDevInsR0                        = PDMDEVINS_2_R0PTR(pDevIns);
    5100     pThis->pDevInsRC                        = PDMDEVINS_2_RCPTR(pDevIns);
    5101     pThis->Led.u32Magic                     = PDMLED_MAGIC;
     5169    pThis->Led.u32Magic                         = PDMLED_MAGIC;
    51025170    /* IBase */
    5103     pThis->IBase.pfnQueryInterface          = pcnetQueryInterface;
     5171    pThisCC->IBase.pfnQueryInterface            = pcnetQueryInterface;
    51045172    /* INeworkPort */
    5105     pThis->INetworkDown.pfnWaitReceiveAvail = pcnetR3NetworkDown_WaitReceiveAvail;
    5106     pThis->INetworkDown.pfnReceive          = pcnetR3NetworkDown_Receive;
    5107     pThis->INetworkDown.pfnXmitPending      = pcnetR3NetworkDown_XmitPending;
     5173    pThisCC->INetworkDown.pfnWaitReceiveAvail  = pcnetR3NetworkDown_WaitReceiveAvail;
     5174    pThisCC->INetworkDown.pfnReceive            = pcnetR3NetworkDown_Receive;
     5175    pThisCC->INetworkDown.pfnXmitPending        = pcnetR3NetworkDown_XmitPending;
    51085176    /* INetworkConfig */
    5109     pThis->INetworkConfig.pfnGetMac         = pcnetR3NetworkConfig_GetMac;
    5110     pThis->INetworkConfig.pfnGetLinkState   = pcnetR3NetworkConfig_GetLinkState;
    5111     pThis->INetworkConfig.pfnSetLinkState   = pcnetR3NetworkConfig_SetLinkState;
     5177    pThisCC->INetworkConfig.pfnGetMac           = pcnetR3NetworkConfig_GetMac;
     5178    pThisCC->INetworkConfig.pfnGetLinkState     = pcnetR3NetworkConfig_GetLinkState;
     5179    pThisCC->INetworkConfig.pfnSetLinkState     = pcnetR3NetworkConfig_SetLinkState;
    51125180    /* ILeds */
    5113     pThis->ILeds.pfnQueryStatusLed          = pcnetQueryStatusLed;
     5181    pThisCC->ILeds.pfnQueryStatusLed            = pcnetQueryStatusLed;
    51145182
    51155183    /* PCI Device */
    … …  
    52565324     * Attach status driver (optional).
    52575325     */
    5258     rc = PDMDevHlpDriverAttach(pDevIns, PDM_STATUS_LUN, &pThis->IBase, &pBase, "Status Port");
     5326    rc = PDMDevHlpDriverAttach(pDevIns, PDM_STATUS_LUN, &pThisCC->IBase, &pBase, "Status Port");
    52595327    if (RT_SUCCESS(rc))
    5260         pThis->pLedsConnector = PDMIBASE_QUERY_INTERFACE(pBase, PDMILEDCONNECTORS);
     5328        pThisCC->pLedsConnector = PDMIBASE_QUERY_INTERFACE(pBase, PDMILEDCONNECTORS);
    52615329    else
    52625330        AssertMsgReturn(   rc == VERR_PDM_NO_ATTACHED_DRIVER
    … …  
    52685336     * Attach driver.
    52695337     */
    5270     rc = PDMDevHlpDriverAttach(pDevIns, 0, &pThis->IBase, &pThis->pDrvBase, "Network Port");
     5338    rc = PDMDevHlpDriverAttach(pDevIns, 0, &pThisCC->IBase, &pThisCC->pDrvBase, "Network Port");
    52715339    if (RT_SUCCESS(rc))
    52725340    {
    5273         pThis->pDrvR3 = PDMIBASE_QUERY_INTERFACE(pThis->pDrvBase, PDMINETWORKUP);
    5274         AssertMsgReturn(pThis->pDrvR3, ("Failed to obtain the PDMINETWORKUP interface!\n"),
     5341        pThisCC->pDrv = PDMIBASE_QUERY_INTERFACE(pThisCC->pDrvBase, PDMINETWORKUP);
     5342        AssertMsgReturn(pThisCC->pDrv, ("Failed to obtain the PDMINETWORKUP interface!\n"),
    52755343                        VERR_PDM_MISSING_INTERFACE_BELOW);
    5276         pThis->pDrvR0 = PDMIBASER0_QUERY_INTERFACE(PDMIBASE_QUERY_INTERFACE(pThis->pDrvBase, PDMIBASER0), PDMINETWORKUP);
    5277         pThis->pDrvRC = PDMIBASERC_QUERY_INTERFACE(PDMIBASE_QUERY_INTERFACE(pThis->pDrvBase, PDMIBASERC), PDMINETWORKUP);
     5344        pThis->fDriverAttached = true;
     5345        /// @todo figure out this!
     5346        //pThis->pDrvR0 = PDMIBASER0_QUERY_INTERFACE(PDMIBASE_QUERY_INTERFACE(pThis->pDrvBase, PDMIBASER0), PDMINETWORKUP);
     5347        //pThis->pDrvRC = PDMIBASERC_QUERY_INTERFACE(PDMIBASE_QUERY_INTERFACE(pThis->pDrvBase, PDMIBASERC), PDMINETWORKUP);
    52785348    }
    52795349    else if (   rc == VERR_PDM_NO_ATTACHED_DRIVER
    … …  
    54295499    /* .szName = */                 "pcnet",
    54305500#ifdef PCNET_GC_ENABLED
    5431     /* .fFlags = */                 PDM_DEVREG_FLAGS_DEFAULT_BITS | PDM_DEVREG_FLAGS_RZ,
     5501    /* .fFlags = */                 PDM_DEVREG_FLAGS_DEFAULT_BITS | PDM_DEVREG_FLAGS_RZ | PDM_DEVREG_FLAGS_NEW_STYLE,
    54325502#else
    54335503    /* .fFlags = */                 PDM_DEVREG_FLAGS_DEFAULT_BITS,
    … …  
    54375507    /* .uSharedVersion = */         42,
    54385508    /* .cbInstanceShared = */       sizeof(PCNETSTATE),
    5439     /* .cbInstanceCC = */           0,
    5440     /* .cbInstanceRC = */           0,
     5509    /* .cbInstanceCC = */           sizeof(PCNETSTATECC),
     5510    /* .cbInstanceRC = */           sizeof(PCNETSTATERC),
    54415511    /* .cMaxPciDevices = */         1,
    54425512    /* .cMaxMsixVectors = */        0,
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