VirtualBox

Changeset 93601 in vbox for trunk/src/VBox/Devices


Ignore:
Timestamp:
Feb 4, 2022 9:01:01 AM (3 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
149739
Message:

Dev3C501/DevDP8390: Reworked code to split R3/R0 data.

Location:
trunk/src/VBox/Devices/Network
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/VBox/Devices/Network/Dev3C501.cpp

    r93567 r93601  
    188188#define MAX_FRAME                       1536
    189189
    190 #define ELNKSTATE_2_DEVINS(pThis)       ((pThis)->CTX_SUFF(pDevIns))
    191 #define ELNK_INSTANCE                   (ELNKSTATE_2_DEVINS(pThis)->iInstance)
    192 
    193190/* Size of the packet buffer. */
    194191#define ELNK_BUF_SIZE       2048u
     
    323320/**
    324321 * EtherLink 3C501 state.
    325  *
    326  * @extends     PDMPCIDEV
    327  * @implements  PDMIBASE
    328  * @implements  PDMINETWORKDOWN
    329  * @implements  PDMINETWORKCONFIG
    330  * @implements  PDMILEDPORTS
    331322 */
    332323typedef struct ELNKSTATE
    333324{
    334     /** Pointer to the device instance - R3. */
    335     PPDMDEVINSR3                        pDevInsR3;
    336     /** Pointer to the connector of the attached network driver - R3. */
    337     PPDMINETWORKUPR3                    pDrvR3;
    338     /** Pointer to the attached network driver. */
    339     R3PTRTYPE(PPDMIBASE)                pDrvBase;
    340     /** LUN\#0 + status LUN: The base interface. */
    341     PDMIBASE                            IBase;
    342     /** LUN\#0: The network port interface. */
    343     PDMINETWORKDOWN                     INetworkDown;
    344     /** LUN\#0: The network config port interface. */
    345     PDMINETWORKCONFIG                   INetworkConfig;
    346325    /** Restore timer.
    347326     *  This is used to disconnect and reconnect the link after a restore. */
    348327    TMTIMERHANDLE                       hTimerRestore;
    349 
    350     /** Pointer to the device instance - R0. */
    351     PPDMDEVINSR0                        pDevInsR0;
    352     /** Pointer to the connector of the attached network driver - R0. */
    353     PPDMINETWORKUPR0                    pDrvR0;
    354 
    355     /** Pointer to the device instance - RC. */
    356     PPDMDEVINSRC                        pDevInsRC;
    357     /** Pointer to the connector of the attached network driver - RC. */
    358     PPDMINETWORKUPRC                    pDrvRC;
    359328
    360329    /** Transmit signaller. */
     
    432401    };
    433402
     403    /** Set if ELNKSTATER3::pDrv is not NULL. */
     404    bool                                fDriverAttached;
    434405    /** The LED. */
    435406    PDMLED                              Led;
     
    489460
    490461
     462/**
     463 * EtherLink state for ring-3.
     464 *
     465 * @implements  PDMIBASE
     466 * @implements  PDMINETWORKDOWN
     467 * @implements  PDMINETWORKCONFIG
     468 * @implements  PDMILEDPORTS
     469 */
     470typedef struct ELNKSTATER3
     471{
     472    /** Pointer to the device instance. */
     473    PPDMDEVINSR3                        pDevIns;
     474    /** Pointer to the connector of the attached network driver. */
     475    PPDMINETWORKUPR3                    pDrv;
     476    /** Pointer to the attached network driver. */
     477    R3PTRTYPE(PPDMIBASE)                pDrvBase;
     478    /** LUN\#0 + status LUN: The base interface. */
     479    PDMIBASE                            IBase;
     480    /** LUN\#0: The network port interface. */
     481    PDMINETWORKDOWN                     INetworkDown;
     482    /** LUN\#0: The network config port interface. */
     483    PDMINETWORKCONFIG                   INetworkConfig;
     484
     485    /** Status LUN: The LED ports. */
     486    PDMILEDPORTS                        ILeds;
     487    /** Partner of ILeds. */
     488    R3PTRTYPE(PPDMILEDCONNECTORS)       pLedsConnector;
     489} ELNKSTATER3;
     490/** Pointer to an EtherLink state structure for ring-3. */
     491typedef ELNKSTATER3 *PELNKSTATER3;
     492
     493
     494/**
     495 * EtherLink state for ring-0.
     496 */
     497typedef struct ELNKSTATER0
     498{
     499    /** Pointer to the connector of the attached network driver. */
     500    PPDMINETWORKUPR0                    pDrv;
     501} ELNKSTATER0;
     502/** Pointer to an EtherLink state structure for ring-0. */
     503typedef ELNKSTATER0 *PELNKSTATER0;
     504
     505
     506/**
     507 * EtherLink state for raw-mode.
     508 */
     509typedef struct ELNKSTATERC
     510{
     511    /** Pointer to the connector of the attached network driver. */
     512    PPDMINETWORKUPRC                    pDrv;
     513} ELNKSTATERC;
     514/** Pointer to an EtherLink state structure for raw-mode. */
     515typedef ELNKSTATERC *PELNKSTATERC;
     516
     517
     518/** The EtherLink state structure for the current context. */
     519typedef CTX_SUFF(ELNKSTATE) ELNKSTATECC;
     520/** Pointer to an EtherLink state structure for the current
     521 *  context. */
     522typedef CTX_SUFF(PELNKSTATE) PELNKSTATECC;
     523
     524
    491525#ifndef VBOX_DEVICE_STRUCT_TESTCASE
    492526
     
    496530*********************************************************************************************************************************/
    497531
    498 static int elnkAsyncTransmit(PPDMDEVINS pDevIns, PELNKSTATE pThis, bool fOnWorkerThread);
     532static int elnkAsyncTransmit(PPDMDEVINS pDevIns, PELNKSTATE pThis, PELNKSTATECC pThisCC, bool fOnWorkerThread);
    499533
    500534/**
     
    505539DECLINLINE(bool) elnkIsLinkUp(PELNKSTATE pThis)
    506540{
    507     return pThis->pDrvR3 && !pThis->fLinkTempDown && pThis->fLinkUp;
     541    return pThis->fDriverAttached && !pThis->fLinkTempDown && pThis->fLinkUp;
    508542}
    509543
     
    566600 * Update the device IRQ line based on internal state.
    567601 */
    568 static void elnkUpdateIrq(PELNKSTATE pThis)
     602static void elnkUpdateIrq(PPDMDEVINS pDevIns, PELNKSTATE pThis)
    569603{
    570604    bool     fISR = false;
     
    578612        fISR = true;
    579613
    580     Log2(("#%d set irq fISR=%d\n", ELNK_INSTANCE, fISR));
     614    Log2(("#%d set irq fISR=%d\n", pThis->iInstance, fISR));
    581615
    582616    /* The IRQ line typically does not change. */
    583617    if (RT_UNLIKELY(fISR != pThis->fISR))
    584618    {
    585         Log(("#%d IRQ=%d, state=%d\n", ELNK_INSTANCE, pThis->uIsaIrq, fISR));
    586         PDMDevHlpISASetIrq(ELNKSTATE_2_DEVINS(pThis), pThis->uIsaIrq, fISR);
     619        Log(("#%d IRQ=%d, state=%d\n", pThis->iInstance, pThis->uIsaIrq, fISR));
     620        PDMDevHlpISASetIrq(pDevIns, pThis->uIsaIrq, fISR);
    587621        pThis->fISR = fISR;
    588622    }
     
    594628 * Perform a software reset of the NIC.
    595629 */
    596 static void elnkSoftReset(PELNKSTATE pThis)
    597 {
    598     LogFlow(("#%d elnkSoftReset:\n", ELNK_INSTANCE));
     630static void elnkSoftReset(PPDMDEVINS pDevIns, PELNKSTATE pThis)
     631{
     632    LogFlowFunc(("#%d:\n", pThis->iInstance));
    599633
    600634    /* Clear some of the user-visible register state. */
     
    614648    /* Clear internal interrupt state. */
    615649    pThis->IntrStateReg = 0;
    616     elnkUpdateIrq(pThis);
     650    elnkUpdateIrq(pDevIns, pThis);
    617651
    618652    /* Note that a soft reset does not clear the packet buffer; software often
     
    630664static DECLCALLBACK(void) elnkR3WakeupReceive(PPDMDEVINS pDevIns)
    631665{
    632     PELNKSTATE pThis = PDMINS_2_DATA(pDevIns, PELNKSTATE);
     666    PELNKSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE);
    633667    STAM_COUNTER_INC(&pThis->StatRxOverflowWakeup);
    634668    if (pThis->hEventOutOfRxSpace != NIL_RTSEMEVENT)
     
    652686 * Write incoming data into the packet buffer.
    653687 */
    654 static void elnkReceiveLocked(PELNKSTATE pThis, const uint8_t *src, size_t cbToRecv, bool fLoopback)
    655 {
    656     PPDMDEVINS pDevIns = ELNKSTATE_2_DEVINS(pThis);
     688static void elnkReceiveLocked(PPDMDEVINS pDevIns, PELNKSTATE pThis, const uint8_t *src, size_t cbToRecv, bool fLoopback)
     689{
    657690    int is_padr = 0, is_bcast = 0, is_mcast = 0;
    658691    union {
     
    704737    }
    705738
    706     LogFlowFunc(("#%d: size on wire=%d, RCV ptr=%u\n", ELNK_INSTANCE, cbToRecv, pThis->uRCVBufPtr));
     739    LogFlowFunc(("#%d: size on wire=%d, RCV ptr=%u\n", pThis->iInstance, cbToRecv, pThis->uRCVBufPtr));
    707740
    708741    /*
     
    718751        uint8_t     *dst = pThis->abPacketBuf + pThis->uRCVBufPtr;
    719752
    720         Log2Func(("#%d Packet passed address filter (is_padr=%d, is_bcast=%d, is_mcast=%d), size=%d\n", ELNK_INSTANCE, cbToRecv, is_padr, is_bcast, is_mcast));
     753        Log2Func(("#%d Packet passed address filter (is_padr=%d, is_bcast=%d, is_mcast=%d), size=%d\n", pThis->iInstance, cbToRecv, is_padr, is_bcast, is_mcast));
    721754
    722755        /* Receive status is evaluated from scratch. The stale bit must remain set until we know better. */
     
    752785            else
    753786            {
    754                 LogFunc(("#%d runt, size=%d\n", ELNK_INSTANCE, cbToRecv));
     787                LogFunc(("#%d runt, size=%d\n", pThis->iInstance, cbToRecv));
    755788                RcvStatNew.runt = 1;
    756789            }
     
    767800        else
    768801        {
    769             LogFunc(("#%d overflow, size=%d\n", ELNK_INSTANCE, cbToRecv));
     802            LogFunc(("#%d overflow, size=%d\n", pThis->iInstance, cbToRecv));
    770803            RcvStatNew.oflow = 1;
    771804        }
     
    773806        if (fLoopback && pThis->AuxCmd.xmit_bf)
    774807        {
    775             LogFunc(("#%d bad FCS\n", ELNK_INSTANCE));
     808            LogFunc(("#%d bad FCS\n", pThis->iInstance));
    776809            RcvStatNew.fcs = 1;
    777810        }
     
    817850        pThis->RcvStat = RcvStatNew;
    818851
    819         LogFlowFunc(("#%d: RcvCmd=%02X, RcvStat=%02X, RCVBufPtr=%u\n", ELNK_INSTANCE, pThis->RcvCmdReg, pThis->RcvStatReg, pThis->uRCVBufPtr));
    820         elnkUpdateIrq(pThis);
     852        LogFlowFunc(("#%d: RcvCmd=%02X, RcvStat=%02X, RCVBufPtr=%u\n", pThis->iInstance, pThis->RcvCmdReg, pThis->RcvStatReg, pThis->uRCVBufPtr));
     853        elnkUpdateIrq(pDevIns, pThis);
    821854    }
    822855}
     
    828861 * @returns VBox status code.  VERR_TRY_AGAIN is returned if we're busy.
    829862 *
    830  * @param   pThis               The device instance data.
     863 * @param   pDevIns             The device instance.
     864 * @param   pThis               The EtherLink shared instance
     865 *                              data.
     866 * @param   pThisCC             The EtherLink state data for the
     867 *                              current context.
    831868 * @param   fOnWorkerThread     Whether we're on a worker thread or on an EMT.
    832869 */
    833 static int elnkXmitBuffer(PELNKSTATE pThis, bool fOnWorkerThread)
     870static int elnkXmitBuffer(PPDMDEVINS pDevIns, PELNKSTATE pThis, PELNKSTATECC pThisCC, bool fOnWorkerThread)
    834871{
    835872    RT_NOREF_PV(fOnWorkerThread);
     
    839876     * Grab the xmit lock of the driver as well as the 3C501 device state.
    840877     */
    841     PPDMINETWORKUP pDrv = pThis->CTX_SUFF(pDrv);
     878    PPDMINETWORKUP pDrv = pThisCC->pDrv;
    842879    if (pDrv)
    843880    {
     
    846883            return rc;
    847884    }
    848     PPDMDEVINS pDevIns = ELNKSTATE_2_DEVINS(pThis);
    849885    rc = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY);
    850886    if (RT_SUCCESS(rc))
     
    854890         * Do the transmitting.
    855891         */
    856         int rc2 = elnkAsyncTransmit(pDevIns, pThis, false /*fOnWorkerThread*/);
     892        int rc2 = elnkAsyncTransmit(pDevIns, pThis, pThisCC, false /*fOnWorkerThread*/);
    857893        AssertReleaseRC(rc2);
    858894
     
    879915static DECLCALLBACK(void) elnkR3XmitTaskCallback(PPDMDEVINS pDevIns, void *pvUser)
    880916{
    881     PELNKSTATE pThis = PDMINS_2_DATA(pDevIns, PELNKSTATE);
     917    PELNKSTATE      pThis   = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE);
     918    PELNKSTATECC    pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PELNKSTATECC);
    882919    NOREF(pvUser);
    883920
     
    885922     * Transmit if we can.
    886923     */
    887     elnkXmitBuffer(pThis, true /*fOnWorkerThread*/);
     924    elnkXmitBuffer(pDevIns, pThis, pThisCC, true /*fOnWorkerThread*/);
    888925}
    889926#endif /* IN_RING3 */
     
    894931 *
    895932 * @returns See PPDMINETWORKUP::pfnAllocBuf.
    896  * @param   pThis       The device instance.
     933 * @param   pThis       The shared state data.
     934 * @param   pThisCC     The current context state data.
    897935 * @param   cbMin       The minimum buffer size.
    898936 * @param   fLoopback   Set if we're in loopback mode.
     
    901939 *                      Always set.
    902940 */
    903 DECLINLINE(int) elnkXmitAllocBuf(PELNKSTATE pThis, size_t cbMin, bool fLoopback,
     941DECLINLINE(int) elnkXmitAllocBuf(PELNKSTATE pThis, PELNKSTATECC pThisCC, size_t cbMin, bool fLoopback,
    904942                                 PPDMSCATTERGATHER pSgLoop, PPPDMSCATTERGATHER ppSgBuf)
    905943{
     
    908946    if (!fLoopback)
    909947    {
    910         PPDMINETWORKUP pDrv = pThis->CTX_SUFF(pDrv);
     948        PPDMINETWORKUP pDrv = pThisCC->pDrv;
    911949        if (RT_LIKELY(pDrv))
    912950        {
     
    946984 *
    947985 * @returns See PDMINETWORKUP::pfnSendBuf.
    948  * @param   pThis           The device instance.
     986 * @param   pDevIns         The device instance.
     987 * @param   pThis           The shared EtherLink state data.
     988 * @param   pThisCC         The current context state data.
    949989 * @param   fLoopback       Set if we're in loopback mode.
    950990 * @param   pSgBuf          The SG to send.
     
    952992 *                          if an EMT.
    953993 */
    954 DECLINLINE(int) elnkXmitSendBuf(PELNKSTATE pThis, bool fLoopback, PPDMSCATTERGATHER pSgBuf, bool fOnWorkerThread)
     994DECLINLINE(int) elnkXmitSendBuf(PPDMDEVINS pDevIns, PELNKSTATE pThis, PELNKSTATECC pThisCC, bool fLoopback, PPDMSCATTERGATHER pSgBuf, bool fOnWorkerThread)
    955995{
    956996    int rc;
     
    9621002            pThis->Led.Asserted.s.fWriting = pThis->Led.Actual.s.fWriting = 1;
    9631003
    964         PPDMINETWORKUP pDrv = pThis->CTX_SUFF(pDrv);
     1004        PPDMINETWORKUP pDrv = pThisCC->pDrv;
    9651005        if (RT_LIKELY(pDrv))
    9661006        {
     
    9801020        pThis->Led.Asserted.s.fReading = pThis->Led.Actual.s.fReading = 1;
    9811021
    982         LogFlowFunc(("#%d: loopback (%u bytes)\n", ELNK_INSTANCE, pSgBuf->cbUsed));
    983         elnkReceiveLocked(pThis, pThis->abLoopBuf, pSgBuf->cbUsed, fLoopback);
     1022        LogFlowFunc(("#%d: loopback (%u bytes)\n", pThis->iInstance, pSgBuf->cbUsed));
     1023        elnkReceiveLocked(pDevIns, pThis, pThis->abLoopBuf, pSgBuf->cbUsed, fLoopback);
    9841024        pThis->Led.Actual.s.fReading = 0;
    9851025        rc = VINF_SUCCESS;
     
    10041044 * Try to transmit a frame.
    10051045 */
    1006 static void elnkTransmit(PELNKSTATE pThis)
    1007 {
     1046static void elnkTransmit(PPDMDEVINS pDevIns, PELNKSTATE pThis)
     1047{
     1048    PELNKSTATECC    pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PELNKSTATECC);
     1049
    10081050    /*
    10091051     * Transmit the packet if possible, defer it if we cannot do it
     
    10111053     */
    10121054#if defined(IN_RING0) || defined(IN_RC)
    1013     if (!pThis->CTX_SUFF(pDrv))
    1014     {
    1015         int rc = PDMDevHlpTaskTrigger(pThis->CTX_SUFF(pDevIns), pThis->hXmitTask);
     1055    if (!pThisCC->pDrv)
     1056    {
     1057        int rc = PDMDevHlpTaskTrigger(pDevIns, pThis->hXmitTask);
    10161058        AssertRC(rc);
    10171059    }
     
    10191061#endif
    10201062    {
    1021         int rc = elnkXmitBuffer(pThis, false /*fOnWorkerThread*/);
     1063        int rc = elnkXmitBuffer(pDevIns, pThis, pThisCC, false /*fOnWorkerThread*/);
    10221064        if (rc == VERR_TRY_AGAIN)
    10231065            rc = VINF_SUCCESS;
     
    10321074 * @threads EMT.
    10331075 */
    1034 static void elnkKickReceive(PELNKSTATE pThis)
     1076static void elnkKickReceive(PPDMDEVINS pDevIns, PELNKSTATE pThis)
    10351077{
    10361078    /* Some drivers (e.g. NetWare IPX shell/ODI drivers) first go to receive mode through
     
    10421084        {
    10431085#ifdef IN_RING3
    1044             elnkR3WakeupReceive(ELNKSTATE_2_DEVINS(pThis));
     1086            elnkR3WakeupReceive(pDevIns);
    10451087#else
    1046             int rc = PDMDevHlpTaskTrigger(pThis->CTX_SUFF(pDevIns), pThis->hCanRxTask);
     1088            int rc = PDMDevHlpTaskTrigger(pDevIns, pThis->hCanRxTask);
    10471089            AssertRC(rc);
    10481090#endif
     
    10571099 * @threads TX or EMT.
    10581100 */
    1059 static int elnkAsyncTransmit(PPDMDEVINS pDevIns, PELNKSTATE pThis, bool fOnWorkerThread)
     1101static int elnkAsyncTransmit(PPDMDEVINS pDevIns, PELNKSTATE pThis, PELNKSTATECC pThisCC, bool fOnWorkerThread)
    10601102{
    10611103    Assert(PDMDevHlpCritSectIsOwner(pDevIns, &pThis->CritSect));
     
    10671109    if (RT_UNLIKELY(!pThis->AuxStat.xmit_bsy))
    10681110    {
    1069         LogFunc(("#%d: Nope, xmit disabled (fOnWorkerThread=%RTbool)\n", ELNK_INSTANCE, fOnWorkerThread));
     1111        LogFunc(("#%d: Nope, xmit disabled (fOnWorkerThread=%RTbool)\n", pThis->iInstance, fOnWorkerThread));
    10701112        return VINF_SUCCESS;
    10711113    }
     
    10731115    if (RT_UNLIKELY((pThis->AuxCmd.buf_ctl != EL_BCTL_XMT_RCV) && (pThis->AuxCmd.buf_ctl != EL_BCTL_LOOPBACK)))
    10741116    {
    1075         LogFunc(("#%d: Nope, not in xmit-then-receive or loopback state (fOnWorkerThread=%RTbool)\n", ELNK_INSTANCE, fOnWorkerThread));
     1117        LogFunc(("#%d: Nope, not in xmit-then-receive or loopback state (fOnWorkerThread=%RTbool)\n", pThis->iInstance, fOnWorkerThread));
    10761118        return VINF_SUCCESS;
    10771119    }
     
    10991141         */
    11001142        const unsigned cb = ELNK_BUF_SIZE - ELNK_GP(pThis); /* Packet size. */
    1101         Log(("#%d elnkAsyncTransmit: cb=%d\n", ELNK_INSTANCE, cb));
     1143        LogFunc(("#%d: cb=%d\n", pThis->iInstance, cb));
    11021144
    11031145        pThis->XmitStatReg = 0; /* Clear transmit status before filling it out. */
     
    11071149            if (RT_LIKELY(cb <= MAX_FRAME))
    11081150            {
    1109                 rc = elnkXmitAllocBuf(pThis, cb, fLoopback, &SgLoop, &pSgBuf);
     1151                rc = elnkXmitAllocBuf(pThis, pThisCC, cb, fLoopback, &SgLoop, &pSgBuf);
    11101152                if (RT_SUCCESS(rc))
    11111153                {
    11121154                    elnkXmitRead(pDevIns, pThis, cb, pSgBuf);
    1113                     rc = elnkXmitSendBuf(pThis, fLoopback, pSgBuf, fOnWorkerThread);
    1114                     Log2(("#%d elnkAsyncTransmit: rc=%Rrc\n", ELNK_INSTANCE, rc));
     1155                    rc = elnkXmitSendBuf(pDevIns, pThis, pThisCC, fLoopback, pSgBuf, fOnWorkerThread);
     1156                    Log2Func(("#%d: rc=%Rrc\n", pThis->iInstance, rc));
    11151157                }
    11161158                else if (rc == VERR_TRY_AGAIN)
    11171159                {
    11181160                    STAM_PROFILE_ADV_STOP(&pThis->CTX_SUFF_Z(StatTransmit), a);
    1119                     Log(("#%d elnkAsyncTransmit: rc=%Rrc\n", ELNK_INSTANCE, rc));
     1161                    LogFunc(("#%d: rc=%Rrc\n", pThis->iInstance, rc));
    11201162                    return VINF_SUCCESS;
    11211163                }
     
    11291171                /* Signal error, as this violates the Ethernet specs. */
    11301172                /** @todo check if the correct error is generated. */
    1131                 LogRel(("3C501#%d: elnkAsyncTransmit: illegal giant frame (%u bytes) -> signalling error\n", ELNK_INSTANCE, cb));
     1173                LogRel(("3C501#%d: illegal giant frame (%u bytes) -> signalling error\n", pThis->iInstance, cb));
    11321174            }
    11331175        }
     
    11351177        {
    11361178            /* Signal a transmit error pretending there was a collision. */
     1179            pThis->cLinkDownReported++;
    11371180            pThis->XmitStat.coll = 1;
    11381181        }
     
    11401183        pThis->AuxStat.xmit_bsy    = 0;
    11411184        pThis->IntrState.xmit_intr = !!(pThis->XmitCmdReg & pThis->XmitStatReg);
    1142         LogFlowFunc(("#%d: XmitCmd=%02X, XmitStat=%02X\n", ELNK_INSTANCE, pThis->XmitCmdReg, pThis->XmitStatReg));
     1185        LogFlowFunc(("#%d: XmitCmd=%02X, XmitStat=%02X\n", pThis->iInstance, pThis->XmitCmdReg, pThis->XmitStatReg));
    11431186
    11441187        /* NB: After a transmit, the GP Buffer Pointer points just past
    11451188         * the end of the packet buffer (3C501 diagnostics).
    11461189         */
    1147         pThis->uGPBufPtr           = ELNK_BUF_SIZE;
     1190        pThis->uGPBufPtr = ELNK_BUF_SIZE;
    11481191
    11491192        /* NB: The buffer control does *not* change to Receive and stays the way it was. */
     
    11511194        {
    11521195            pThis->AuxStat.recv_bsy = 1;    /* Receive Busy now set until a packet is received. */
    1153             elnkKickReceive(pThis);
     1196            elnkKickReceive(pDevIns, pThis);
    11541197        }
    11551198    } while (0);    /* No loop, because there isn't ever more than one packet to transmit. */
    11561199
    1157     elnkUpdateIrq(pThis);
     1200    elnkUpdateIrq(pDevIns, pThis);
    11581201
    11591202    STAM_PROFILE_ADV_STOP(&pThis->CTX_SUFF_Z(StatTransmit), a);
     
    11651208
    11661209
    1167 static int elnkCsrWrite(PELNKSTATE pThis, uint8_t data)
     1210static int elnkCsrWrite(PPDMDEVINS pDevIns, PELNKSTATE pThis, uint8_t data)
    11681211{
    11691212    int         rc = VINF_SUCCESS;
     
    11871230             * effect and will be overwritten when the card is taken out of reset.
    11881231             */
    1189             Log(("#%d elnkCsrWrite: Card going into reset\n", ELNK_INSTANCE));
     1232            LogFunc(("#%d: Card going into reset\n", pThis->iInstance));
    11901233            pThis->fInReset = true;
    11911234
     
    11991242        {
    12001243            /* Card is being taken out of reset. */
    1201             Log(("#%d elnkCsrWrite: Card going out of reset\n", ELNK_INSTANCE));
     1244            LogFunc(("#%d: Card going out of reset\n", pThis->iInstance));
    12021245            STAM_COUNTER_INC(&pThis->StatResets);
    1203             elnkSoftReset(pThis);
     1246            elnkSoftReset(pDevIns, pThis);
    12041247        }
    12051248        pThis->AuxCmd.reset = val.reset;    /* Update the reset bit, if nothing else. */
     
    12171260        /* Start/stop DMA as requested. */
    12181261        pThis->fDMA = fDMAR;
    1219         PDMDevHlpDMASetDREQ(pThis->CTX_SUFF(pDevIns), pThis->uIsaDma, fDMAR);
     1262        PDMDevHlpDMASetDREQ(pDevIns, pThis->uIsaDma, fDMAR);
    12201263        if (fDMAR)
    1221             PDMDevHlpDMASchedule(pThis->CTX_SUFF(pDevIns));
    1222         Log(("3C501#%d: DMARQ for channel %u set to %u\n", ELNK_INSTANCE, pThis->uIsaDma, fDMAR));
     1264            PDMDevHlpDMASchedule(pDevIns);
     1265        Log(("3C501#%d: DMARQ for channel %u set to %u\n", pThis->iInstance, pThis->uIsaDma, fDMAR));
    12231266    }
    12241267#else
     
    12501293#ifdef LOG_ENABLED
    12511294        static const char   *apszBuffCntrl[4] = { "System", "Xmit then Recv", "Receive", "Loopback" };
    1252         Log(("3C501#%d: Packet buffer control `%s' -> `%s'\n", ELNK_INSTANCE, apszBuffCntrl[pThis->AuxCmd.buf_ctl], apszBuffCntrl[val.buf_ctl]));
     1295        Log(("3C501#%d: Packet buffer control `%s' -> `%s'\n", pThis->iInstance, apszBuffCntrl[pThis->AuxCmd.buf_ctl], apszBuffCntrl[val.buf_ctl]));
    12531296#endif
    12541297        if (val.buf_ctl == EL_BCTL_XMT_RCV)
    12551298        {
    12561299            /* Transmit, then receive. */
    1257             Log2(("3C501#%d: Transmit %u bytes\n%Rhxs\nxmit_bsy=%u\n", ELNK_INSTANCE, ELNK_BUF_SIZE - pThis->uGPBufPtr, &pThis->abPacketBuf[pThis->uGPBufPtr], pThis->AuxStat.xmit_bsy));
     1300            Log2(("3C501#%d: Transmit %u bytes\n%Rhxs\nxmit_bsy=%u\n", pThis->iInstance, ELNK_BUF_SIZE - pThis->uGPBufPtr, &pThis->abPacketBuf[pThis->uGPBufPtr], pThis->AuxStat.xmit_bsy));
    12581301            fTransmit = true;
    12591302            pThis->AuxStat.recv_bsy = 0;
     
    12901333
    12911334    /* There are multiple bits that affect interrupt state. Handle them now. */
    1292     elnkUpdateIrq(pThis);
     1335    elnkUpdateIrq(pDevIns, pThis);
    12931336
    12941337    /* After fully updating register state, do a transmit (including loopback) or receive. */
    12951338    if (fTransmit)
    1296         elnkTransmit(pThis);
     1339        elnkTransmit(pDevIns, pThis);
    12971340    else if (fReceive)
    12981341    {
    12991342        pThis->AuxStat.recv_bsy = 1;    /* Receive Busy now set until a packet is received. */
    1300         elnkKickReceive(pThis);
     1343        elnkKickReceive(pDevIns, pThis);
    13011344    }
    13021345
     
    13041347}
    13051348
    1306 static int elIoWrite(PELNKSTATE pThis, uint32_t addr, uint32_t val)
     1349static int elIoWrite(PPDMDEVINS pDevIns, PELNKSTATE pThis, uint32_t addr, uint32_t val)
    13071350{
    13081351    int     reg = addr & 0xf;
    13091352    int     rc = VINF_SUCCESS;
    13101353
    1311     Log2(("#%d elIoWrite: addr=%#06x val=%#04x\n", ELNK_INSTANCE, addr, val & 0xff));
     1354    Log2Func(("#%d: addr=%#06x val=%#04x\n", pThis->iInstance, addr, val & 0xff));
    13121355
    13131356    switch (reg)
     
    13291372            /* If address filter just got enabled, receive may need a kick. */
    13301373            if (OldRcvCmd.adr_match == EL_ADRM_DISABLED && pThis->RcvCmd.adr_match != EL_ADRM_DISABLED)
    1331                 elnkKickReceive(pThis);
     1374                elnkKickReceive(pDevIns, pThis);
    13321375            Log2(("Receive Command register set to %02X\n", pThis->RcvCmdReg));
    13331376            break;
     
    13611404
    13621405        case 0x0e:  /* Auxiliary Command (CSR). */
    1363             rc = elnkCsrWrite(pThis, val);
     1406            rc = elnkCsrWrite(pDevIns, pThis, val);
    13641407            break;
    13651408
     
    13801423}
    13811424
    1382 static uint32_t elIoRead(PELNKSTATE pThis, uint32_t addr, int *pRC)
     1425static uint32_t elIoRead(PPDMDEVINS pDevIns, PELNKSTATE pThis, uint32_t addr, int *pRC)
    13831426{
    13841427    uint32_t val = UINT32_MAX;
     
    13951438            pThis->RcvStat.stale = 1;       /* Allows further reception. */
    13961439            pThis->IntrState.recv_intr = 0; /* Reading clears receive interrupt. */
    1397             elnkUpdateIrq(pThis);
     1440            elnkUpdateIrq(pDevIns, pThis);
    13981441            break;
    13991442
     
    14041447            val = pThis->XmitStatReg;
    14051448            pThis->IntrState.xmit_intr = 0; /* Reading clears transmit interrupt. */
    1406             elnkUpdateIrq(pThis);
     1449            elnkUpdateIrq(pDevIns, pThis);
    14071450            break;
    14081451
     
    14401483    }
    14411484
    1442     elnkUpdateIrq(pThis);
    1443 
    1444     Log2(("#%d elIoRead: addr=%#06x val=%#04x\n", ELNK_INSTANCE, addr, val & 0xff));
     1485    elnkUpdateIrq(pDevIns, pThis);
     1486
     1487    Log2Func(("#%d: addr=%#06x val=%#04x\n", pThis->iInstance, addr, val & 0xff));
    14451488    return val;
    14461489}
     
    14531496elnkIOPortRead(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t *pu32, unsigned cb)
    14541497{
    1455     PELNKSTATE pThis = PDMINS_2_DATA(pDevIns, PELNKSTATE);
     1498    PELNKSTATE  pThis = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE);
    14561499    int         rc    = VINF_SUCCESS;
    14571500    uint8_t     u8Lo, u8Hi;
     
    14631506    {
    14641507        case 1:
    1465             *pu32 = elIoRead(pThis, Port, &rc);
     1508            *pu32 = elIoRead(pDevIns, pThis, Port, &rc);
    14661509            break;
    14671510        case 2:
    14681511            /* Manually split word access. */
    1469             u8Lo = elIoRead(pThis, Port + 0, &rc);
     1512            u8Lo = elIoRead(pDevIns, pThis, Port + 0, &rc);
    14701513            Assert(RT_SUCCESS(rc));
    1471             u8Hi = elIoRead(pThis, Port + 1, &rc);
     1514            u8Hi = elIoRead(pDevIns, pThis, Port + 1, &rc);
    14721515            Assert(RT_SUCCESS(rc));
    14731516            *pu32 = RT_MAKE_U16(u8Lo, u8Hi);
    14741517            break;
    14751518        default:
    1476             rc = PDMDevHlpDBGFStop(pThis->CTX_SUFF(pDevIns), RT_SRC_POS,
     1519            rc = PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS,
    14771520                                   "elnkIOPortRead: unsupported operation size: offset=%#10x cb=%u\n",
    14781521                                   Port, cb);
    14791522    }
    14801523
    1481     Log2(("#%d elnkIOPortRead: Port=%RTiop *pu32=%#RX32 cb=%d rc=%Rrc\n", ELNK_INSTANCE, Port, *pu32, cb, rc));
     1524    Log2Func(("#%d: Port=%RTiop *pu32=%#RX32 cb=%d rc=%Rrc\n", pThis->iInstance, Port, *pu32, cb, rc));
    14821525    STAM_PROFILE_ADV_STOP(&pThis->CTX_SUFF_Z(StatIORead), a);
    14831526    return rc;
     
    14911534elnkIOPortWrite(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
    14921535{
    1493     PELNKSTATE  pThis = PDMINS_2_DATA(pDevIns, PELNKSTATE);
     1536    PELNKSTATE  pThis = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE);
    14941537    int         rc    = VINF_SUCCESS;
    14951538    STAM_PROFILE_ADV_START(&pThis->CTX_SUFF_Z(StatIOWrite), a);
     
    15001543    {
    15011544        case 1:
    1502             rc = elIoWrite(pThis, Port, RT_LOBYTE(u32));
     1545            rc = elIoWrite(pDevIns, pThis, Port, RT_LOBYTE(u32));
    15031546            break;
    15041547        case 2:
    15051548            /* Manually split word access. */
    1506             rc = elIoWrite(pThis, Port + 0, RT_LOBYTE(u32));
     1549            rc = elIoWrite(pDevIns, pThis, Port + 0, RT_LOBYTE(u32));
    15071550            if (!RT_SUCCESS(rc))
    15081551                break;
    1509             rc = elIoWrite(pThis, Port + 1, RT_HIBYTE(u32));
     1552            rc = elIoWrite(pDevIns, pThis, Port + 1, RT_HIBYTE(u32));
    15101553            break;
    15111554        default:
    1512             rc = PDMDevHlpDBGFStop(pThis->CTX_SUFF(pDevIns), RT_SRC_POS,
     1555            rc = PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS,
    15131556                                   "elnkIOPortWrite: unsupported operation size: offset=%#10x cb=%u\n",
    15141557                                   Port, cb);
    15151558    }
    15161559
    1517     Log2(("#%d elnkIOPortWrite: Port=%RTiop u32=%#RX32 cb=%d rc=%Rrc\n", ELNK_INSTANCE, Port, u32, cb, rc));
     1560    Log2Func(("#%d: Port=%RTiop u32=%#RX32 cb=%d rc=%Rrc\n", pThis->iInstance, Port, u32, cb, rc));
    15181561    STAM_PROFILE_ADV_STOP(&pThis->CTX_SUFF_Z(StatIOWrite), a);
    15191562    return rc;
     
    15661609     * reading from the buffer.
    15671610     */
    1568     dma_mode = PDMDevHlpDMAGetChannelMode(pThis->CTX_SUFF(pDevIns), pThis->uIsaDma);
     1611    dma_mode = PDMDevHlpDMAGetChannelMode(pDevIns, pThis->uIsaDma);
    15691612    dma_type = GET_MODE_XTYP(dma_mode);
    15701613    LogFlowFunc(("dma_mode=%d, dma_type=%d, dma_pos=%u, dma_len=%u, GPBP=%u\n", dma_mode, dma_type, dma_pos, dma_len, pThis->uGPBufPtr));
     
    15751618    {
    15761619        /* Write transfer type. Reading from device, writing to memory. */
    1577         rc = PDMDevHlpDMAWriteMemory(pThis->CTX_SUFF(pDevIns), nchan,
     1620        rc = PDMDevHlpDMAWriteMemory(pDevIns, nchan,
    15781621                                     &pThis->abPacketBuf[ELNK_GP(pThis)],
    15791622                                     dma_pos, cbToXfer, &cbXferred);
     
    15841627    {
    15851628        /* Read of Verify transfer type. Reading from memory, writing to device. */
    1586         rc = PDMDevHlpDMAReadMemory(pThis->CTX_SUFF(pDevIns), nchan,
     1629        rc = PDMDevHlpDMAReadMemory(pDevIns, nchan,
    15871630                                    &pThis->abPacketBuf[ELNK_GP(pThis)],
    15881631                                    dma_pos, cbToXfer, &cbXferred);
     
    15971640    {
    15981641        Log2(("DMA completed\n"));
    1599         PDMDevHlpDMASetDREQ(pThis->CTX_SUFF(pDevIns), pThis->uIsaDma, 0);
     1642        PDMDevHlpDMASetDREQ(pDevIns, pThis->uIsaDma, 0);
    16001643        pThis->IntrState.dma_intr = 1;
    16011644        pThis->AuxStat.dma_done   = 1;
    1602         elnkUpdateIrq(pThis);
     1645        elnkUpdateIrq(pDevIns, pThis);
    16031646    }
    16041647    else
    16051648    {
    16061649        Log(("DMA continuing: GPBufPtr=%u, lastpos=%u, cbXferred=%u\n", pThis->uGPBufPtr, uLastPos, cbXferred));
    1607         PDMDevHlpDMASchedule(pThis->CTX_SUFF(pDevIns));
     1650        PDMDevHlpDMASchedule(pDevIns);
    16081651    }
    16091652
     
    16251668{
    16261669    RT_NOREF(pvUser);
    1627     PELNKSTATE pThis = PDMINS_2_DATA(pDevIns, PELNKSTATE);
     1670    PELNKSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE);
    16281671    int         rc = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY);
    16291672    AssertReleaseRC(rc);
     
    16381681        {
    16391682            LogRel(("3C501#%d: The link is back up again after the restore.\n",
    1640                     pDevIns->iInstance));
    1641             Log(("#%d elnkTimerRestore: Clearing ERR and CERR after load. cLinkDownReported=%d\n",
    1642                  pDevIns->iInstance, pThis->cLinkDownReported));
     1683                    pThis->iInstance));
     1684            LogFunc(("#%d: Clearing ERR and CERR after load. cLinkDownReported=%d\n",
     1685                 pThis->iInstance, pThis->cLinkDownReported));
    16431686            pThis->Led.Actual.s.fError = 0;
    16441687        }
     
    16461689    else
    16471690        Log(("#%d elnkTimerRestore: cLinkDownReported=%d, wait another 1500ms...\n",
    1648              pDevIns->iInstance, pThis->cLinkDownReported));
     1691             pThis->iInstance, pThis->cLinkDownReported));
    16491692
    16501693    PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect);
     
    16591702static DECLCALLBACK(void) elnkInfo(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs)
    16601703{
    1661     PELNKSTATE          pThis = PDMINS_2_DATA(pDevIns, PELNKSTATE);
     1704    PELNKSTATE          pThis = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE);
    16621705    bool                fStationAddr = false;
    16631706    bool                fRecvBuffer  = false;
     
    16791722     */
    16801723    pHlp->pfnPrintf(pHlp,
    1681                     "3C501 #%d: port=%RTiop IRQ=%u DMA=%u mac-cfg=%RTmac %s%s\n",
    1682                     pDevIns->iInstance,
     1724                    "3C501 #%d: port=%RTiop IRQ=%u DMA=%u mac-cfg=%RTmac%s%s %s\n",
     1725                    pThis->iInstance,
    16831726                    pThis->IOPortBase, pThis->uIsaIrq, pThis->uIsaDma, &pThis->MacConfigured,
    1684                     pDevIns->fRCEnabled ? " RC" : "", pDevIns->fR0Enabled ? " R0" : "");
     1727                    pDevIns->fRCEnabled ? " RC" : "", pDevIns->fR0Enabled ? " RZ" : "",
     1728                    pThis->fDriverAttached ? "attached" : "unattached!");
    16851729
    16861730    int const rcLock = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_INTERNAL_ERROR); /* Take it here so we know why we're hanging... */
     
    16891733    pHlp->pfnPrintf(pHlp, "  GP Buf Ptr : %u (masked %u)\n", pThis->uGPBufPtr, ELNK_GP(pThis));
    16901734    pHlp->pfnPrintf(pHlp, "  RCV Buf Ptr: %u\n", pThis->uRCVBufPtr);
    1691     pHlp->pfnPrintf(pHlp, "  Recv Command: %02X   Recv Status: %02X\n", pThis->RcvCmdReg,  pThis->RcvStatReg);
    1692     pHlp->pfnPrintf(pHlp, "  Xmit Command: %02X   Xmit Status: %02X\n", pThis->XmitCmdReg, pThis->XmitStatReg);
    1693     pHlp->pfnPrintf(pHlp, "  Aux  Command: %02X   Aux  Status: %02X\n", pThis->AuxCmdReg,  pThis->AuxStatReg);
     1735    pHlp->pfnPrintf(pHlp, "  Recv Command: %02X  Recv Status: %02X\n", pThis->RcvCmdReg,  pThis->RcvStatReg);
     1736    pHlp->pfnPrintf(pHlp, "  Xmit Command: %02X  Xmit Status: %02X\n", pThis->XmitCmdReg, pThis->XmitStatReg);
     1737    pHlp->pfnPrintf(pHlp, "  Aux  Command: %02X  Aux  Status: %02X\n", pThis->AuxCmdReg,  pThis->AuxStatReg);
    16941738
    16951739    pHlp->pfnPrintf(pHlp, "  Address matching: %s\n", apszAddrMatch[pThis->RcvCmd.adr_match]);
    16961740    pHlp->pfnPrintf(pHlp, "  Buffer control  : %s\n", apszBuffCntrl[pThis->AuxCmd.buf_ctl]);
    16971741    pHlp->pfnPrintf(pHlp, "  Interrupt state : xmit=%u recv=%u dma=%u\n", pThis->IntrState.xmit_intr, pThis->IntrState.recv_intr, pThis->IntrState.dma_intr);
     1742    if (pThis->cLinkDownReported)
     1743        pHlp->pfnPrintf(pHlp, "  Link down count : %d\n", pThis->cLinkDownReported);
    16981744
    16991745    /* Dump the station address. */
     
    17301776
    17311777
    1732 static void elnkR3HardReset(PELNKSTATE pThis)
    1733 {
    1734     LogFlow(("#%d elnkHardReset:\n", ELNK_INSTANCE));
     1778static void elnkR3HardReset(PPDMDEVINS pDevIns, PELNKSTATE pThis)
     1779{
     1780    LogFlowFunc(("#%d:\n", pThis->iInstance));
    17351781
    17361782    /* Initialize the PROM */
     
    17471793    pThis->uRCVBufPtr = 0;
    17481794
    1749     elnkSoftReset(pThis);
     1795    elnkSoftReset(pDevIns, pThis);
    17501796}
    17511797
     
    17591805 * renegotiate any DHCP lease.
    17601806 *
     1807 * @param  pDevIns      The device instance.
    17611808 * @param  pThis        The device instance data.
    17621809 */
    1763 static void elnkTempLinkDown(PELNKSTATE pThis)
     1810static void elnkTempLinkDown(PPDMDEVINS pDevIns, PELNKSTATE pThis)
    17641811{
    17651812    if (pThis->fLinkUp)
     
    17681815        pThis->cLinkDownReported = 0;
    17691816        pThis->Led.Asserted.s.fError = pThis->Led.Actual.s.fError = 1;
    1770         int rc = PDMDevHlpTimerSetMillies(ELNKSTATE_2_DEVINS(pThis), pThis->hTimerRestore, pThis->cMsLinkUpDelay);
     1817        int rc = PDMDevHlpTimerSetMillies(pDevIns, pThis->hTimerRestore, pThis->cMsLinkUpDelay);
    17711818        AssertRC(rc);
    17721819    }
     
    17821829{
    17831830    RT_NOREF(uPass);
    1784     PELNKSTATE pThis = PDMINS_2_DATA(pDevIns, PELNKSTATE);
     1831    PELNKSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE);
    17851832    pDevIns->pHlpR3->pfnSSMPutMem(pSSM, &pThis->MacConfigured, sizeof(pThis->MacConfigured));
    17861833    return VINF_SSM_DONT_CALL_AGAIN;
     
    17951842{
    17961843    RT_NOREF(pSSM);
    1797     PELNKSTATE pThis = PDMINS_2_DATA(pDevIns, PELNKSTATE);
     1844    PELNKSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE);
    17981845
    17991846    int rc = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY);
     
    18101857static DECLCALLBACK(int) elnkSaveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
    18111858{
    1812     PELNKSTATE      pThis = PDMINS_2_DATA(pDevIns, PELNKSTATE);
     1859    PELNKSTATE      pThis = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE);
    18131860    PCPDMDEVHLPR3   pHlp  = pDevIns->pHlpR3;
    18141861
     
    18381885static DECLCALLBACK(int) elnkLoadPrep(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
    18391886{
    1840     PELNKSTATE pThis = PDMINS_2_DATA(pDevIns, PELNKSTATE);
     1887    PELNKSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE);
    18411888    RT_NOREF(pSSM);
    18421889
     
    18551902static DECLCALLBACK(int) elnkLoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
    18561903{
    1857     PELNKSTATE      pThis = PDMINS_2_DATA(pDevIns, PELNKSTATE);
    1858     PCPDMDEVHLPR3   pHlp  = pDevIns->pHlpR3;
     1904    PELNKSTATE      pThis   = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE);
     1905    PELNKSTATECC    pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PELNKSTATECC);
     1906    PCPDMDEVHLPR3   pHlp    = pDevIns->pHlpR3;
    18591907
    18601908    if (   SSM_VERSION_MAJOR_CHANGED(uVersion, ELNK_SAVEDSTATE_VERSION)
     
    18871935    if (    memcmp(&Mac, &pThis->MacConfigured, sizeof(Mac))
    18881936        && (uPass == 0 || !PDMDevHlpVMTeleportedAndNotFullyResumedYet(pDevIns)) )
    1889         LogRel(("3C501#%u: The mac address differs: config=%RTmac saved=%RTmac\n", ELNK_INSTANCE, &pThis->MacConfigured, &Mac));
     1937        LogRel(("3C501#%u: The mac address differs: config=%RTmac saved=%RTmac\n", pThis->iInstance, &pThis->MacConfigured, &Mac));
    18901938
    18911939    if (uPass == SSM_PASS_FINAL)
    18921940    {
    18931941        /* update promiscuous mode. */
    1894         if (pThis->pDrvR3)
    1895             pThis->pDrvR3->pfnSetPromiscuousMode(pThis->pDrvR3, 0 /* promiscuous enabled */);
     1942        if (pThisCC->pDrv)
     1943            pThisCC->pDrv->pfnSetPromiscuousMode(pThisCC->pDrv, 0 /* promiscuous enabled */);
    18961944
    18971945        /* Indicate link down to the guest OS that all network connections have
    18981946           been lost, unless we've been teleported here. */
    18991947        if (!PDMDevHlpVMTeleportedAndNotFullyResumedYet(pDevIns))
    1900             elnkTempLinkDown(pThis);
     1948            elnkTempLinkDown(pDevIns, pThis);
    19011949    }
    19021950
     
    19141962 *
    19151963 * @returns VBox status code.
    1916  * @param   pThis           The device instance data.
    1917  */
    1918 static int elnkCanReceive(PELNKSTATE pThis)
    1919 {
    1920     PPDMDEVINS pDevIns = ELNKSTATE_2_DEVINS(pThis);
     1964 * @param   pDevIns         The device instance data.
     1965 * @param   pThis           The shared instance data.
     1966 */
     1967static int elnkCanReceive(PPDMDEVINS pDevIns, PELNKSTATE pThis)
     1968{
    19211969    int rc = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY);
    19221970    AssertReleaseRC(rc);
     
    19592007static DECLCALLBACK(int) elnkNet_WaitReceiveAvail(PPDMINETWORKDOWN pInterface, RTMSINTERVAL cMillies)
    19602008{
    1961     PELNKSTATE pThis = RT_FROM_MEMBER(pInterface, ELNKSTATE, INetworkDown);
    1962     PPDMDEVINS pDevIns = ELNKSTATE_2_DEVINS(pThis);
    1963 
    1964     int rc = elnkCanReceive(pThis);
     2009    PELNKSTATECC    pThisCC = RT_FROM_MEMBER(pInterface, ELNKSTATECC, INetworkDown);
     2010    PPDMDEVINS      pDevIns = pThisCC->pDevIns;
     2011    PELNKSTATE      pThis   = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE);
     2012
     2013    int rc = elnkCanReceive(pDevIns, pThis);
    19652014    if (RT_SUCCESS(rc))
    19662015        return VINF_SUCCESS;
     
    19722021    STAM_PROFILE_START(&pThis->StatRxOverflow, a);
    19732022    VMSTATE enmVMState;
    1974     while (RT_LIKELY(   (enmVMState = PDMDevHlpVMState(pThis->CTX_SUFF(pDevIns))) == VMSTATE_RUNNING
     2023    while (RT_LIKELY(   (enmVMState = PDMDevHlpVMState(pDevIns)) == VMSTATE_RUNNING
    19752024                     || enmVMState == VMSTATE_RUNNING_LS))
    19762025    {
    1977         int rc2 = elnkCanReceive(pThis);
     2026        int rc2 = elnkCanReceive(pDevIns, pThis);
    19782027        if (RT_SUCCESS(rc2))
    19792028        {
     
    19812030            break;
    19822031        }
    1983         LogFlow(("elnkNet_WaitReceiveAvail: waiting cMillies=%u...\n", cMillies));
     2032        LogFlowFunc(("waiting cMillies=%u...\n", cMillies));
    19842033
    19852034        /* Start the poll timer once which will remain active as long fMaybeOutOfSpace
     
    20022051static DECLCALLBACK(int) elnkNet_Receive(PPDMINETWORKDOWN pInterface, const void *pvBuf, size_t cb)
    20032052{
    2004     PELNKSTATE  pThis = RT_FROM_MEMBER(pInterface, ELNKSTATE, INetworkDown);
    2005     PPDMDEVINS  pDevIns = ELNKSTATE_2_DEVINS(pThis);
    2006     int         rc;
     2053    PELNKSTATECC    pThisCC = RT_FROM_MEMBER(pInterface, ELNKSTATECC, INetworkDown);
     2054    PPDMDEVINS      pDevIns = pThisCC->pDevIns;
     2055    PELNKSTATE      pThis   = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE);
     2056    int             rc;
    20072057
    20082058    STAM_PROFILE_ADV_START(&pThis->StatReceive, a);
     
    20122062    if (cb > 50) /* unqualified guess */
    20132063        pThis->Led.Asserted.s.fReading = pThis->Led.Actual.s.fReading = 1;
    2014     elnkReceiveLocked(pThis, (const uint8_t *)pvBuf, cb, false);
     2064    elnkReceiveLocked(pDevIns, pThis, (const uint8_t *)pvBuf, cb, false);
    20152065    pThis->Led.Actual.s.fReading = 0;
    20162066
     
    20272077static DECLCALLBACK(void) elnkNet_XmitPending(PPDMINETWORKDOWN pInterface)
    20282078{
    2029     PELNKSTATE pThis = RT_FROM_MEMBER(pInterface, ELNKSTATE, INetworkDown);
    2030     elnkXmitBuffer(pThis, true /*fOnWorkerThread*/);
     2079    PELNKSTATECC    pThisCC = RT_FROM_MEMBER(pInterface, ELNKSTATECC, INetworkDown);
     2080    PPDMDEVINS      pDevIns = pThisCC->pDevIns;
     2081    PELNKSTATE      pThis   = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE);
     2082
     2083    elnkXmitBuffer(pDevIns, pThis, pThisCC, true /*fOnWorkerThread*/);
    20312084}
    20322085
     
    20392092static DECLCALLBACK(int) elnkGetMac(PPDMINETWORKCONFIG pInterface, PRTMAC pMac)
    20402093{
    2041     PELNKSTATE pThis = RT_FROM_MEMBER(pInterface, ELNKSTATE, INetworkConfig);
     2094    PELNKSTATECC    pThisCC = RT_FROM_MEMBER(pInterface, ELNKSTATECC, INetworkConfig);
     2095    PPDMDEVINS      pDevIns = pThisCC->pDevIns;
     2096    PELNKSTATE      pThis   = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE);
     2097
     2098    LogFlowFunc(("#%d\n", pThis->iInstance));
    20422099    /// @todo This is broken!! We can't properly get the MAC address set by the guest
    20432100#if 0
     
    20552112static DECLCALLBACK(PDMNETWORKLINKSTATE) elnkGetLinkState(PPDMINETWORKCONFIG pInterface)
    20562113{
    2057     PELNKSTATE pThis = RT_FROM_MEMBER(pInterface, ELNKSTATE, INetworkConfig);
     2114    PELNKSTATECC    pThisCC = RT_FROM_MEMBER(pInterface, ELNKSTATECC, INetworkConfig);
     2115    PPDMDEVINS      pDevIns = pThisCC->pDevIns;
     2116    PELNKSTATE      pThis   = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE);
     2117
    20582118    if (pThis->fLinkUp && !pThis->fLinkTempDown)
    20592119        return PDMNETWORKLINKSTATE_UP;
     
    20722132static DECLCALLBACK(int) elnkSetLinkState(PPDMINETWORKCONFIG pInterface, PDMNETWORKLINKSTATE enmState)
    20732133{
    2074     PELNKSTATE pThis = RT_FROM_MEMBER(pInterface, ELNKSTATE, INetworkConfig);
    2075     bool fLinkUp;
     2134    PELNKSTATECC    pThisCC = RT_FROM_MEMBER(pInterface, ELNKSTATECC, INetworkConfig);
     2135    PPDMDEVINS      pDevIns = pThisCC->pDevIns;
     2136    PELNKSTATE      pThis   = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE);
     2137    bool            fLinkUp;
    20762138
    20772139    AssertMsgReturn(enmState > PDMNETWORKLINKSTATE_INVALID && enmState <= PDMNETWORKLINKSTATE_DOWN_RESUME,
     
    20802142    if (enmState == PDMNETWORKLINKSTATE_DOWN_RESUME)
    20812143    {
    2082         elnkTempLinkDown(pThis);
     2144        elnkTempLinkDown(pDevIns, pThis);
    20832145        /*
    20842146         * Note that we do not notify the driver about the link state change because
     
    20992161            pThis->cLinkDownReported = 0;
    21002162            pThis->Led.Asserted.s.fError = pThis->Led.Actual.s.fError = 1;
    2101             int rc = PDMDevHlpTimerSetMillies(ELNKSTATE_2_DEVINS(pThis), pThis->hTimerRestore, pThis->cMsLinkUpDelay);
     2163            int rc = PDMDevHlpTimerSetMillies(pDevIns, pThis->hTimerRestore, pThis->cMsLinkUpDelay);
    21022164            AssertRC(rc);
    21032165        }
     
    21082170            pThis->Led.Asserted.s.fError = pThis->Led.Actual.s.fError = 1;
    21092171        }
    2110         Assert(!PDMDevHlpCritSectIsOwner(ELNKSTATE_2_DEVINS(pThis), &pThis->CritSect));
    2111         if (pThis->pDrvR3)
    2112             pThis->pDrvR3->pfnNotifyLinkChanged(pThis->pDrvR3, enmState);
     2172        Assert(!PDMDevHlpCritSectIsOwner(pDevIns, &pThis->CritSect));
     2173        if (pThisCC->pDrv)
     2174            pThisCC->pDrv->pfnNotifyLinkChanged(pThisCC->pDrv, enmState);
    21132175    }
    21142176    return VINF_SUCCESS;
     
    21232185static DECLCALLBACK(int) elnkQueryStatusLed(PPDMILEDPORTS pInterface, unsigned iLUN, PPDMLED *ppLed)
    21242186{
    2125     PELNKSTATE pThis = RT_FROM_MEMBER(pInterface, ELNKSTATE, ILeds);
     2187    PELNKSTATECC    pThisCC = RT_FROM_MEMBER(pInterface, ELNKSTATECC, ILeds);
     2188    PPDMDEVINS      pDevIns = pThisCC->pDevIns;
     2189    PELNKSTATE      pThis   = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE);
    21262190    if (iLUN == 0)
    21272191    {
     
    21402204static DECLCALLBACK(void *) elnkQueryInterface(struct PDMIBASE *pInterface, const char *pszIID)
    21412205{
    2142     PELNKSTATE pThis = RT_FROM_MEMBER(pInterface, ELNKSTATE, IBase);
    2143     Assert(&pThis->IBase == pInterface);
    2144     PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pThis->IBase);
    2145     PDMIBASE_RETURN_INTERFACE(pszIID, PDMINETWORKDOWN, &pThis->INetworkDown);
    2146     PDMIBASE_RETURN_INTERFACE(pszIID, PDMINETWORKCONFIG, &pThis->INetworkConfig);
    2147     PDMIBASE_RETURN_INTERFACE(pszIID, PDMILEDPORTS, &pThis->ILeds);
     2206    PELNKSTATECC pThisCC = RT_FROM_MEMBER(pInterface, ELNKSTATECC, IBase);
     2207    Assert(&pThisCC->IBase == pInterface);
     2208    PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pThisCC->IBase);
     2209    PDMIBASE_RETURN_INTERFACE(pszIID, PDMINETWORKDOWN, &pThisCC->INetworkDown);
     2210    PDMIBASE_RETURN_INTERFACE(pszIID, PDMINETWORKCONFIG, &pThisCC->INetworkConfig);
     2211    PDMIBASE_RETURN_INTERFACE(pszIID, PDMILEDPORTS, &pThisCC->ILeds);
    21482212    return NULL;
    21492213}
     
    21552219 * @interface_method_impl{PDMDEVREG,pfnPowerOff}
    21562220 */
    2157 static DECLCALLBACK(void) elnkPowerOff(PPDMDEVINS pDevIns)
     2221static DECLCALLBACK(void) elnkR3PowerOff(PPDMDEVINS pDevIns)
    21582222{
    21592223    /* Poke thread waiting for buffer space. */
     
    21672231 * One port on the network card has been disconnected from the network.
    21682232 */
    2169 static DECLCALLBACK(void) elnkDetach(PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags)
    2170 {
     2233static DECLCALLBACK(void) elnkR3Detach(PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags)
     2234{
     2235    PELNKSTATE      pThis   = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE);
     2236    PELNKSTATECC    pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PELNKSTATECC);
    21712237    RT_NOREF(fFlags);
    2172     PELNKSTATE pThis = PDMINS_2_DATA(pDevIns, PELNKSTATE);
    2173     Log(("#%d elnkDetach:\n", ELNK_INSTANCE));
     2238    LogFlowFunc(("#%d:\n", pThis->iInstance));
    21742239
    21752240    AssertLogRelReturnVoid(iLUN == 0);
     
    21812246     * Zero some important members.
    21822247     */
    2183     pThis->pDrvBase = NULL;
    2184     pThis->pDrvR3 = NULL;
    2185     pThis->pDrvR0 = NIL_RTR0PTR;
    2186     pThis->pDrvRC = NIL_RTRCPTR;
     2248    pThis->fDriverAttached = false;
     2249    pThisCC->pDrvBase = NULL;
     2250    pThisCC->pDrv     = NULL;
    21872251
    21882252    PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect);
     
    21942258 * One port on the network card has been connected to a network.
    21952259 */
    2196 static DECLCALLBACK(int) elnkAttach(PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags)
    2197 {
     2260static DECLCALLBACK(int) elnkR3Attach(PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags)
     2261{
     2262    PELNKSTATE      pThis   = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE);
     2263    PELNKSTATECC    pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PELNKSTATECC);
    21982264    RT_NOREF(fFlags);
    2199     PELNKSTATE pThis = PDMINS_2_DATA(pDevIns, PELNKSTATE);
    2200     LogFlow(("#%d elnkAttach:\n", ELNK_INSTANCE));
     2265    LogFlowFunc(("#%d:\n", pThis->iInstance));
    22012266
    22022267    AssertLogRelReturn(iLUN == 0, VERR_PDM_NO_SUCH_LUN);
     
    22082273     * Attach the driver.
    22092274     */
    2210     int rc = PDMDevHlpDriverAttach(pDevIns, 0, &pThis->IBase, &pThis->pDrvBase, "Network Port");
     2275    int rc = PDMDevHlpDriverAttach(pDevIns, 0, &pThisCC->IBase, &pThisCC->pDrvBase, "Network Port");
    22112276    if (RT_SUCCESS(rc))
    22122277    {
    2213         pThis->pDrvR3 = PDMIBASE_QUERY_INTERFACE(pThis->pDrvBase, PDMINETWORKUP);
    2214         AssertMsgStmt(pThis->pDrvR3, ("Failed to obtain the PDMINETWORKUP interface!\n"),
     2278        pThisCC->pDrv = PDMIBASE_QUERY_INTERFACE(pThisCC->pDrvBase, PDMINETWORKUP);
     2279        AssertMsgStmt(pThisCC->pDrv, ("Failed to obtain the PDMINETWORKUP interface!\n"),
    22152280                      rc = VERR_PDM_MISSING_INTERFACE_BELOW);
    2216         pThis->pDrvR0 = PDMIBASER0_QUERY_INTERFACE(PDMIBASE_QUERY_INTERFACE(pThis->pDrvBase, PDMIBASER0), PDMINETWORKUP);
    2217         pThis->pDrvRC = PDMIBASERC_QUERY_INTERFACE(PDMIBASE_QUERY_INTERFACE(pThis->pDrvBase, PDMIBASERC), PDMINETWORKUP);
     2281        pThis->fDriverAttached = true;
    22182282    }
    22192283    else if (   rc == VERR_PDM_NO_ATTACHED_DRIVER
     
    22222286        /* This should never happen because this function is not called
    22232287         * if there is no driver to attach! */
    2224         Log(("#%d No attached driver!\n", ELNK_INSTANCE));
     2288        Log(("#%d: No attached driver!\n", pThis->iInstance));
    22252289    }
    22262290
     
    22312295     */
    22322296    if (RT_SUCCESS(rc))
    2233         elnkTempLinkDown(pThis);
     2297        elnkTempLinkDown(pDevIns, pThis);
    22342298
    22352299    PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect);
     
    22412305 * @interface_method_impl{PDMDEVREG,pfnSuspend}
    22422306 */
    2243 static DECLCALLBACK(void) elnkSuspend(PPDMDEVINS pDevIns)
     2307static DECLCALLBACK(void) elnkR3Suspend(PPDMDEVINS pDevIns)
    22442308{
    22452309    /* Poke thread waiting for buffer space. */
     
    22512315 * @interface_method_impl{PDMDEVREG,pfnReset}
    22522316 */
    2253 static DECLCALLBACK(void) elnkReset(PPDMDEVINS pDevIns)
    2254 {
    2255     PELNKSTATE pThis = PDMINS_2_DATA(pDevIns, PELNKSTATE);
     2317static DECLCALLBACK(void) elnkR3Reset(PPDMDEVINS pDevIns)
     2318{
     2319    PELNKSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE);
    22562320    if (pThis->fLinkTempDown)
    22572321    {
     
    22622326
    22632327    /** @todo How to flush the queues? */
    2264     elnkR3HardReset(pThis);
     2328    elnkR3HardReset(pDevIns, pThis);
    22652329}
    22662330
     
    22692333 * @interface_method_impl{PDMDEVREG,pfnRelocate}
    22702334 */
    2271 static DECLCALLBACK(void) elnkRelocate(PPDMDEVINS pDevIns, RTGCINTPTR offDelta)
    2272 {
    2273     RT_NOREF(offDelta);
    2274     PELNKSTATE pThis = PDMINS_2_DATA(pDevIns, PELNKSTATE);
    2275     pThis->pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
     2335static DECLCALLBACK(void) elnkR3Relocate(PPDMDEVINS pDevIns, RTGCINTPTR offDelta)
     2336{
     2337    PELNKSTATERC pThisRC = PDMINS_2_DATA_RC(pDevIns, PELNKSTATERC);
     2338    pThisRC->pDrv += offDelta;
    22762339}
    22772340
     
    22802343 * @interface_method_impl{PDMDEVREG,pfnDestruct}
    22812344 */
    2282 static DECLCALLBACK(int) elnkDestruct(PPDMDEVINS pDevIns)
     2345static DECLCALLBACK(int) elnkR3Destruct(PPDMDEVINS pDevIns)
    22832346{
    22842347    PDMDEV_CHECK_VERSIONS_RETURN_QUIET(pDevIns);
    2285     PELNKSTATE pThis = PDMINS_2_DATA(pDevIns, PELNKSTATE);
     2348    PELNKSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE);
    22862349
    22872350    if (PDMDevHlpCritSectIsInitialized(pDevIns, &pThis->CritSect))
     
    22992362 * @interface_method_impl{PDMDEVREG,pfnConstruct}
    23002363 */
    2301 static DECLCALLBACK(int) elnkConstruct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfg)
     2364static DECLCALLBACK(int) elnkR3Construct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfg)
    23022365{
    23032366    PDMDEV_CHECK_VERSIONS_RETURN(pDevIns);
    2304     PELNKSTATE      pThis = PDMINS_2_DATA(pDevIns, PELNKSTATE);
    2305     PCPDMDEVHLPR3   pHlp  = pDevIns->pHlpR3;
     2367    PELNKSTATE      pThis   = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE);
     2368    PELNKSTATECC    pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PELNKSTATECC);
     2369    PCPDMDEVHLPR3   pHlp    = pDevIns->pHlpR3;
    23062370    PPDMIBASE       pBase;
    23072371    char            szTmp[128];
     
    23142378    pThis->hEventOutOfRxSpace   = NIL_RTSEMEVENT;
    23152379    pThis->hIoPortsIsa          = NIL_IOMIOPORTHANDLE;
     2380    pThisCC->pDevIns            = pDevIns;
    23162381
    23172382    /*
     
    23672432     * Initialize data (most of it anyway).
    23682433     */
    2369     pThis->pDevInsR3                        = pDevIns;
    2370     pThis->pDevInsR0                        = PDMDEVINS_2_R0PTR(pDevIns);
    2371     pThis->pDevInsRC                        = PDMDEVINS_2_RCPTR(pDevIns);
    2372     pThis->Led.u32Magic                     = PDMLED_MAGIC;
     2434    pThis->Led.u32Magic                       = PDMLED_MAGIC;
    23732435    /* IBase */
    2374     pThis->IBase.pfnQueryInterface          = elnkQueryInterface;
     2436    pThisCC->IBase.pfnQueryInterface          = elnkQueryInterface;
    23752437    /* INetworkPort */
    2376     pThis->INetworkDown.pfnWaitReceiveAvail = elnkNet_WaitReceiveAvail;
    2377     pThis->INetworkDown.pfnReceive          = elnkNet_Receive;
    2378     pThis->INetworkDown.pfnXmitPending      = elnkNet_XmitPending;
     2438    pThisCC->INetworkDown.pfnWaitReceiveAvail = elnkNet_WaitReceiveAvail;
     2439    pThisCC->INetworkDown.pfnReceive          = elnkNet_Receive;
     2440    pThisCC->INetworkDown.pfnXmitPending      = elnkNet_XmitPending;
    23792441    /* INetworkConfig */
    2380     pThis->INetworkConfig.pfnGetMac         = elnkGetMac;
    2381     pThis->INetworkConfig.pfnGetLinkState   = elnkGetLinkState;
    2382     pThis->INetworkConfig.pfnSetLinkState   = elnkSetLinkState;
     2442    pThisCC->INetworkConfig.pfnGetMac         = elnkGetMac;
     2443    pThisCC->INetworkConfig.pfnGetLinkState   = elnkGetLinkState;
     2444    pThisCC->INetworkConfig.pfnSetLinkState   = elnkSetLinkState;
    23832445    /* ILeds */
    2384     pThis->ILeds.pfnQueryStatusLed          = elnkQueryStatusLed;
     2446    pThisCC->ILeds.pfnQueryStatusLed          = elnkQueryStatusLed;
    23852447
    23862448    /*
     
    24452507     * Register the info item.
    24462508     */
    2447     RTStrPrintf(szTmp, sizeof(szTmp), "elnk%d", pDevIns->iInstance);
     2509    RTStrPrintf(szTmp, sizeof(szTmp), "elnk%d", pThis->iInstance);
    24482510    PDMDevHlpDBGFInfoRegister(pDevIns, szTmp, "3C501 info", elnkInfo);
    24492511
     
    24512513     * Attach status driver (optional).
    24522514     */
    2453     rc = PDMDevHlpDriverAttach(pDevIns, PDM_STATUS_LUN, &pThis->IBase, &pBase, "Status Port");
     2515    rc = PDMDevHlpDriverAttach(pDevIns, PDM_STATUS_LUN, &pThisCC->IBase, &pBase, "Status Port");
    24542516    if (RT_SUCCESS(rc))
    24552517        pThis->pLedsConnector = PDMIBASE_QUERY_INTERFACE(pBase, PDMILEDCONNECTORS);
     
    24642526     * Attach driver.
    24652527     */
    2466     rc = PDMDevHlpDriverAttach(pDevIns, 0, &pThis->IBase, &pThis->pDrvBase, "Network Port");
     2528    rc = PDMDevHlpDriverAttach(pDevIns, 0, &pThisCC->IBase, &pThisCC->pDrvBase, "Network Port");
    24672529    if (RT_SUCCESS(rc))
    24682530    {
    2469         pThis->pDrvR3 = PDMIBASE_QUERY_INTERFACE(pThis->pDrvBase, PDMINETWORKUP);
    2470         AssertMsgReturn(pThis->pDrvR3, ("Failed to obtain the PDMINETWORKUP interface!\n"),
     2531        pThisCC->pDrv = PDMIBASE_QUERY_INTERFACE(pThisCC->pDrvBase, PDMINETWORKUP);
     2532        AssertMsgReturn(pThisCC->pDrv, ("Failed to obtain the PDMINETWORKUP interface!\n"),
    24712533                        VERR_PDM_MISSING_INTERFACE_BELOW);
    2472         pThis->pDrvR0 = PDMIBASER0_QUERY_INTERFACE(PDMIBASE_QUERY_INTERFACE(pThis->pDrvBase, PDMIBASER0), PDMINETWORKUP);
    2473         pThis->pDrvRC = PDMIBASERC_QUERY_INTERFACE(PDMIBASE_QUERY_INTERFACE(pThis->pDrvBase, PDMIBASERC), PDMINETWORKUP);
     2534        pThis->fDriverAttached = true;
    24742535    }
    24752536    else if (   rc == VERR_PDM_NO_ATTACHED_DRIVER
     
    24852546     * Reset the device state. (Do after attaching.)
    24862547     */
    2487     elnkR3HardReset(pThis);
     2548    elnkR3HardReset(pDevIns, pThis);
    24882549
    24892550    /*
     
    25622623    /* .uSharedVersion = */         42,
    25632624    /* .cbInstanceShared = */       sizeof(ELNKSTATE),
    2564     /* .cbInstanceCC = */           0,
    2565     /* .cbInstanceRC = */           0,
     2625    /* .cbInstanceCC = */           sizeof(ELNKSTATECC),
     2626    /* .cbInstanceRC = */           sizeof(ELNKSTATERC),
    25662627    /* .cMaxPciDevices = */         0,
    25672628    /* .cMaxMsixVectors = */        0,
     
    25702631    /* .pszRCMod = */               "VBoxDDRC.rc",
    25712632    /* .pszR0Mod = */               "VBoxDDR0.r0",
    2572     /* .pfnConstruct = */           elnkConstruct,
    2573     /* .pfnDestruct = */            elnkDestruct,
    2574     /* .pfnRelocate = */            elnkRelocate,
     2633    /* .pfnConstruct = */           elnkR3Construct,
     2634    /* .pfnDestruct = */            elnkR3Destruct,
     2635    /* .pfnRelocate = */            elnkR3Relocate,
    25752636    /* .pfnMemSetup = */            NULL,
    25762637    /* .pfnPowerOn = */             NULL,
    2577     /* .pfnReset = */               elnkReset,
    2578     /* .pfnSuspend = */             elnkSuspend,
     2638    /* .pfnReset = */               elnkR3Reset,
     2639    /* .pfnSuspend = */             elnkR3Suspend,
    25792640    /* .pfnResume = */              NULL,
    2580     /* .pfnAttach = */              elnkAttach,
    2581     /* .pfnDetach = */              elnkDetach,
     2641    /* .pfnAttach = */              elnkR3Attach,
     2642    /* .pfnDetach = */              elnkR3Detach,
    25822643    /* .pfnQueryInterface = */      NULL,
    25832644    /* .pfnInitComplete = */        NULL,
    2584     /* .pfnPowerOff = */            elnkPowerOff,
     2645    /* .pfnPowerOff = */            elnkR3PowerOff,
    25852646    /* .pfnSoftReset = */           NULL,
    25862647    /* .pfnReserved0 = */           NULL,
  • trunk/src/VBox/Devices/Network/DevDP8390.cpp

    r93590 r93601  
    355355/** Maximum frame size we handle */
    356356#define MAX_FRAME                       1536
    357 
    358 #define DPNICSTATE_2_DEVINS(pThis)      ((pThis)->CTX_SUFF(pDevIns))
    359 #define DPNIC_INSTANCE                  (DPNICSTATE_2_DEVINS(pThis)->iInstance)
    360357
    361358/* Size of the local RAM. */
     
    831828/**
    832829 * DP8390-based card state.
    833  *
    834  * @extends     PDMPCIDEV
    835  * @implements  PDMIBASE
    836  * @implements  PDMINETWORKDOWN
    837  * @implements  PDMINETWORKCONFIG
    838  * @implements  PDMILEDPORTS
    839830 */
    840831typedef struct DPNICSTATE
    841832{
    842     /** Pointer to the device instance - R3. */
    843     PPDMDEVINSR3                        pDevInsR3;
    844     /** Pointer to the connector of the attached network driver - R3. */
    845     PPDMINETWORKUPR3                    pDrvR3;
    846     /** Pointer to the attached network driver. */
    847     R3PTRTYPE(PPDMIBASE)                pDrvBase;
    848     /** LUN\#0 + status LUN: The base interface. */
    849     PDMIBASE                            IBase;
    850     /** LUN\#0: The network port interface. */
    851     PDMINETWORKDOWN                     INetworkDown;
    852     /** LUN\#0: The network config port interface. */
    853     PDMINETWORKCONFIG                   INetworkConfig;
    854833    /** Restore timer.
    855834     *  This is used to disconnect and reconnect the link after a restore. */
    856835    TMTIMERHANDLE                       hTimerRestore;
    857 
    858     /** Pointer to the device instance - R0. */
    859     PPDMDEVINSR0                        pDevInsR0;
    860     /** Receive signaller - R0. */
    861     PPDMINETWORKUPR0                    pDrvR0;
    862 
    863     /** Pointer to the device instance - RC. */
    864     PPDMDEVINSRC                        pDevInsRC;
    865     /** Receive signaller - RC. */
    866     PPDMINETWORKUPRC                    pDrvRC;
    867836
    868837    /** Transmit signaller. */
     
    921890    RTMAC                               MacConfigured;
    922891
     892    /** Set if DPNICSTATER3::pDrv is not NULL. */
     893    bool                                fDriverAttached;
    923894    /** The LED. */
    924895    PDMLED                              Led;
     
    983954
    984955
     956/**
     957 * DP8390 state for ring-3.
     958 *
     959 * @implements  PDMIBASE
     960 * @implements  PDMINETWORKDOWN
     961 * @implements  PDMINETWORKCONFIG
     962 * @implements  PDMILEDPORTS
     963 */
     964typedef struct DPNICSTATER3
     965{
     966    /** Pointer to the device instance. */
     967    PPDMDEVINSR3                        pDevIns;
     968    /** Pointer to the connector of the attached network driver. */
     969    PPDMINETWORKUPR3                    pDrv;
     970    /** Pointer to the attached network driver. */
     971    R3PTRTYPE(PPDMIBASE)                pDrvBase;
     972    /** LUN\#0 + status LUN: The base interface. */
     973    PDMIBASE                            IBase;
     974    /** LUN\#0: The network port interface. */
     975    PDMINETWORKDOWN                     INetworkDown;
     976    /** LUN\#0: The network config port interface. */
     977    PDMINETWORKCONFIG                   INetworkConfig;
     978
     979    /** Status LUN: The LED ports. */
     980    PDMILEDPORTS                        ILeds;
     981    /** Partner of ILeds. */
     982    R3PTRTYPE(PPDMILEDCONNECTORS)       pLedsConnector;
     983} DPNICSTATER3;
     984/** Pointer to a DP8390 state structure for ring-3. */
     985typedef DPNICSTATER3 *PDPNICSTATER3;
     986
     987
     988/**
     989 * DP8390 state for ring-0.
     990 */
     991typedef struct DPNICSTATER0
     992{
     993    /** Pointer to the connector of the attached network driver. */
     994    PPDMINETWORKUPR0                    pDrv;
     995} DPNICSTATER0;
     996/** Pointer to a DP8390 state structure for ring-0. */
     997typedef DPNICSTATER0 *PDPNICSTATER0;
     998
     999
     1000/**
     1001 * DP8390 state for raw-mode.
     1002 */
     1003typedef struct DPNICSTATERC
     1004{
     1005    /** Pointer to the connector of the attached network driver. */
     1006    PPDMINETWORKUPRC                    pDrv;
     1007} DPNICSTATERC;
     1008/** Pointer to a DP8390 state structure for raw-mode. */
     1009typedef DPNICSTATERC *PDPNICSTATERC;
     1010
     1011
     1012/** The DP8390 state structure for the current context. */
     1013typedef CTX_SUFF(DPNICSTATE) DPNICSTATECC;
     1014/** Pointer to a DP8390 state structure for the current
     1015 *  context. */
     1016typedef CTX_SUFF(PDPNICSTATE) PDPNICSTATECC;
     1017
     1018
    9851019#ifndef VBOX_DEVICE_STRUCT_TESTCASE
    9861020
     
    9901024*********************************************************************************************************************************/
    9911025
    992 static int dp8390CoreAsyncXmitLocked(PDPNICSTATE pThis, bool fOnWorkerThread);
     1026static int dp8390CoreAsyncXmitLocked(PPDMDEVINS pDevIns, PDPNICSTATE pThis, PDPNICSTATECC pThisCC, bool fOnWorkerThread);
    9931027
    9941028/**
     
    9991033DECLINLINE(bool) dp8390IsLinkUp(PDPNICSTATE pThis)
    10001034{
    1001     return pThis->pDrvR3 && !pThis->fLinkTempDown && pThis->fLinkUp;
     1035    return pThis->fDriverAttached && !pThis->fLinkTempDown && pThis->fLinkUp;
    10021036}
    10031037
     
    11841218 * Update the device IRQ line based on internal state.
    11851219 */
    1186 static void dp8390CoreUpdateIrq(PDPNICSTATE pThis)
     1220static void dp8390CoreUpdateIrq(PPDMDEVINS pDevIns, PDPNICSTATE pThis)
    11871221{
    11881222    bool     fCoreIrqActive = false;
     
    12071241    fNicIrqActive = (fCoreIrqActive && !pThis->ga.gacfr.nim) || (pThis->ga.streg.dtc && !pThis->ga.gacfr.tcm);
    12081242
    1209     Log2Func(("#%d set irq fNicIrqActive=%d (fCoreIrqActive=%d, fGaIrq=%d)\n", DPNIC_INSTANCE, fNicIrqActive, fCoreIrqActive, pThis->ga.fGaIrq));
     1243    Log2Func(("#%d set irq fNicIrqActive=%d (fCoreIrqActive=%d, fGaIrq=%d)\n", pThis->iInstance, fNicIrqActive, fCoreIrqActive, pThis->ga.fGaIrq));
    12101244
    12111245    /* The IRQ line typically does not change. */
    12121246    if (RT_UNLIKELY(fNicIrqActive != pThis->fNicIrqActive))
    12131247    {
    1214         LogFunc(("#%d IRQ=%d, state=%d\n", DPNIC_INSTANCE, pThis->uIsaIrq, fNicIrqActive));
     1248        LogFunc(("#%d IRQ=%d, state=%d\n", pThis->iInstance, pThis->uIsaIrq, fNicIrqActive));
    12151249        /// @todo Handle IRQ 2/9 elsewhere
    1216         PDMDevHlpISASetIrq(DPNICSTATE_2_DEVINS(pThis), pThis->uIsaIrq == 2 ? 9 : pThis->uIsaIrq, fNicIrqActive);
     1250        PDMDevHlpISASetIrq(pDevIns, pThis->uIsaIrq == 2 ? 9 : pThis->uIsaIrq, fNicIrqActive);
    12171251        pThis->fNicIrqActive = fNicIrqActive;
    12181252    }
     
    12241258 * Perform a software reset of the NIC.
    12251259 */
    1226 static void dp8390CoreReset(PDPNICSTATE pThis)
    1227 {
    1228     LogFlowFunc(("#%d:\n", DPNIC_INSTANCE));
     1260static void dp8390CoreReset(PPDMDEVINS pDevIns, PDPNICSTATE pThis)
     1261{
     1262    LogFlowFunc(("#%d:\n", pThis->iInstance));
    12291263
    12301264    /* DP8390 or DP83901A datasheet, section 11.0. */
     
    12431277
    12441278    /* Make sure the IRQ line us updated. */
    1245     dp8390CoreUpdateIrq(pThis);
     1279    dp8390CoreUpdateIrq(pDevIns, pThis);
    12461280}
    12471281
    12481282#ifdef IN_RING3
    12491283
    1250 static DECLCALLBACK(void) dp8390WakeupReceive(PPDMDEVINS pDevIns)
    1251 {
    1252     PDPNICSTATE pThis = PDMINS_2_DATA(pDevIns, PDPNICSTATE);
    1253     LogFlowFunc(("#%d\n", DPNIC_INSTANCE));
     1284static DECLCALLBACK(void) dp8390R3WakeupReceive(PPDMDEVINS pDevIns)
     1285{
     1286    PDPNICSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE);
     1287    LogFlowFunc(("#%d\n", pThis->iInstance));
    12541288    STAM_COUNTER_INC(&pThis->StatRxOverflowWakeup);
    12551289    if (pThis->hEventOutOfRxSpace != NIL_RTSEMEVENT)
     
    12641298{
    12651299    RT_NOREF(pvUser);
    1266     dp8390WakeupReceive(pDevIns);
     1300    dp8390R3WakeupReceive(pDevIns);
    12671301}
    12681302
     
    12761310    if ((RT_LOBYTE(addr) + cb) > 256)
    12771311    {
    1278         LogFunc(("#%d: addr=%04X, cb=%X, cb!!\n", DPNIC_INSTANCE, addr, cb));
     1312        LogFunc(("#%d: addr=%04X, cb=%X, cb!!\n", pThis->iInstance, addr, cb));
    12791313        cb = 256 - RT_LOBYTE(addr);
    12801314    }
     
    12921326        }
    12931327        else
    1294             LogFunc(("#%d: Ignoring read at addr=%04X cb=%u!\n", DPNIC_INSTANCE, addr, cb));
     1328            LogFunc(("#%d: Ignoring read at addr=%04X cb=%u!\n", pThis->iInstance, addr, cb));
    12951329    }
    12961330    else if (pThis->uDevType == DEV_NE2000)
     
    13051339        }
    13061340        else
    1307             LogFunc(("#%d: Ignoring read at addr=%04X cb=%u!\n", DPNIC_INSTANCE, addr, cb));
     1341            LogFunc(("#%d: Ignoring read at addr=%04X cb=%u!\n", pThis->iInstance, addr, cb));
    13081342    }
    13091343    else if ((pThis->uDevType == DEV_WD8003) || (pThis->uDevType == DEV_WD8013))
     
    13141348            memcpy(pDst, &pThis->abLocalRAM[addr], cb);
    13151349        else
    1316             LogFunc(("#%d: Ignoring read at addr=%04X cb=%u!\n", DPNIC_INSTANCE, addr, cb));
     1350            LogFunc(("#%d: Ignoring read at addr=%04X cb=%u!\n", pThis->iInstance, addr, cb));
    13171351    }
    13181352    else if (pThis->uDevType == DEV_3C503)
     
    13281362        }
    13291363        else
    1330             LogFunc(("#%d: Ignoring read at addr=%04X cb=%u!\n", DPNIC_INSTANCE, addr, cb));
     1364            LogFunc(("#%d: Ignoring read at addr=%04X cb=%u!\n", pThis->iInstance, addr, cb));
    13311365    }
    13321366    else
     
    13461380    if ((RT_LOBYTE(addr) + cb) > 256)
    13471381    {
    1348         LogFunc(("#%d: addr=%04X, cb=%X, cb!!\n", DPNIC_INSTANCE, addr, cb));
     1382        LogFunc(("#%d: addr=%04X, cb=%X, cb!!\n", pThis->iInstance, addr, cb));
    13491383        cb = 256 - RT_LOBYTE(addr);
    13501384    }
     
    13621396        }
    13631397        else
    1364             LogFunc(("#%d: Ignoring write at addr=%04X cb=%u!\n", DPNIC_INSTANCE, addr, cb));
     1398            LogFunc(("#%d: Ignoring write at addr=%04X cb=%u!\n", pThis->iInstance, addr, cb));
    13651399    }
    13661400    else if (pThis->uDevType == DEV_NE2000)
     
    13751409        }
    13761410        else
    1377             LogFunc(("#%d: Ignoring write at addr=%04X cb=%u!\n", DPNIC_INSTANCE, addr, cb));
     1411            LogFunc(("#%d: Ignoring write at addr=%04X cb=%u!\n", pThis->iInstance, addr, cb));
    13781412    }
    13791413    else if ((pThis->uDevType == DEV_WD8003) || (pThis->uDevType == DEV_WD8013))
     
    13841418            memcpy(&pThis->abLocalRAM[addr], pSrc, cb);
    13851419        else
    1386             LogFunc(("#%d: Ignoring write at addr=%04X cb=%u!\n", DPNIC_INSTANCE, addr, cb));
     1420            LogFunc(("#%d: Ignoring write at addr=%04X cb=%u!\n", pThis->iInstance, addr, cb));
    13871421    }
    13881422    else if (pThis->uDevType == DEV_3C503)
     
    13981432        }
    13991433        else
    1400             LogFunc(("#%d: Ignoring write at addr=%04X cb=%u!\n", DPNIC_INSTANCE, addr, cb));
     1434            LogFunc(("#%d: Ignoring write at addr=%04X cb=%u!\n", pThis->iInstance, addr, cb));
    14011435    }
    14021436    else
     
    14131447static void dp8390CoreReceiveBuf(PDPNICSTATE pThis, DP_RSR *pRsr, const uint8_t *src, unsigned cbLeft, bool fLast)
    14141448{
    1415     LogFlow(("#%d: Initial CURR=%02X00 CLDA=%04X\n", DPNIC_INSTANCE, pThis->core.CURR, pThis->core.CLDA));
     1449    LogFlow(("#%d: Initial CURR=%02X00 CLDA=%04X\n", pThis->iInstance, pThis->core.CURR, pThis->core.CLDA));
    14161450
    14171451    while (cbLeft)
     
    14241458        if (cbWrite > cbLeft)
    14251459            cbWrite = cbLeft;
    1426         Log2Func(("#%d: cbLeft=%d CURR=%02X00 CLDA=%04X\n", DPNIC_INSTANCE, cbLeft, pThis->core.CURR, pThis->core.CLDA));
     1460        Log2Func(("#%d: cbLeft=%d CURR=%02X00 CLDA=%04X\n", pThis->iInstance, cbLeft, pThis->core.CURR, pThis->core.CLDA));
    14271461        dpLocalRAMWriteBuf(pThis, pThis->core.CLDA, cbWrite, src);
    14281462        src += cbWrite;
     
    14361470        if (fLast && (cbWrite == cbLeft))
    14371471        {
    1438             Log3Func(("#%d: Round up: CLDA=%04X cbPage=%X\n", DPNIC_INSTANCE, pThis->core.CLDA, cbPage));
     1472            Log3Func(("#%d: Round up: CLDA=%04X cbPage=%X\n", pThis->iInstance, pThis->core.CLDA, cbPage));
    14391473            pThis->core.CLDA += cbPage;
    14401474        }
     
    14421476            pThis->core.CLDA += cbWrite;
    14431477
    1444         Log3Func(("#%d: Final CURR=%02X00 CLDA=%04X\n", DPNIC_INSTANCE, pThis->core.CURR, pThis->core.CLDA));
     1478        Log3Func(("#%d: Final CURR=%02X00 CLDA=%04X\n", pThis->iInstance, pThis->core.CURR, pThis->core.CLDA));
    14451479        /* If at end of ring, wrap around. */
    14461480        if (pThis->core.clda.CLDA1 == pThis->core.PSTOP)
     
    14541488            pRsr->MPA = 1;  /* Indicates to caller that receive was aborted. */
    14551489            STAM_COUNTER_INC(&pThis->StatDropPktNoBuffer);
    1456             Log3Func(("#%d: PSTART=%02X00 PSTOP=%02X00 BNRY=%02X00 CURR=%02X00 -- overflow!\n", DPNIC_INSTANCE, pThis->core.PSTART, pThis->core.PSTOP, pThis->core.BNRY, pThis->core.CURR));
     1490            Log3Func(("#%d: PSTART=%02X00 PSTOP=%02X00 BNRY=%02X00 CURR=%02X00 -- overflow!\n", pThis->iInstance, pThis->core.PSTART, pThis->core.PSTOP, pThis->core.BNRY, pThis->core.CURR));
    14571491            break;
    14581492        }
     
    14641498 * Write incoming data into the packet buffer.
    14651499 */
    1466 static void dp8390CoreReceiveLocked(PDPNICSTATE pThis, const uint8_t *src, size_t cbToRecv)
    1467 {
    1468     PPDMDEVINS pDevIns = DPNICSTATE_2_DEVINS(pThis);
     1500static void dp8390CoreReceiveLocked(PPDMDEVINS pDevIns, PDPNICSTATE pThis, const uint8_t *src, size_t cbToRecv)
     1501{
    14691502    int is_padr = 0, is_bcast = 0, is_mcast = 0, is_prom = 0;
    14701503    int mc_type = 0;
     
    15091542    }
    15101543
    1511     LogFlowFunc(("#%d: size on wire=%d\n", DPNIC_INSTANCE, cbToRecv));
     1544    LogFlowFunc(("#%d: size on wire=%d\n", pThis->iInstance, cbToRecv));
    15121545
    15131546    /*
     
    15271560
    15281561        nRSR = 0;
    1529         Log2Func(("#%d Packet passed address filter (is_padr=%d, is_bcast=%d, is_mcast=%d, is_prom=%d), size=%d\n", DPNIC_INSTANCE, is_padr, is_bcast, is_mcast, is_prom, cbToRecv));
     1562        Log2Func(("#%d Packet passed address filter (is_padr=%d, is_bcast=%d, is_mcast=%d, is_prom=%d), size=%d\n", pThis->iInstance, is_padr, is_bcast, is_mcast, is_prom, cbToRecv));
    15301563
    15311564        if (is_bcast || mc_type)
     
    15621595            }
    15631596
    1564             LogFlowFunc(("#%d: PSTART=%02X00 PSTOP=%02X00 BNRY=%02X00 CURR=%02X00\n", DPNIC_INSTANCE, pThis->core.PSTART, pThis->core.PSTOP, pThis->core.BNRY, pThis->core.CURR));
     1597            LogFlowFunc(("#%d: PSTART=%02X00 PSTOP=%02X00 BNRY=%02X00 CURR=%02X00\n", pThis->iInstance, pThis->core.PSTART, pThis->core.PSTOP, pThis->core.BNRY, pThis->core.CURR));
    15651598
    15661599            /* All packets that passed the address filter are copied to local RAM.
     
    16271660
    16281661        Log2Func(("Receive completed, size=%d, CURR=%02X00, RSR=%02X, ISR=%02X\n", cbToRecv, pThis->core.CURR, pThis->core.RSR, pThis->core.ISR));
    1629         dp8390CoreUpdateIrq(pThis);
     1662        dp8390CoreUpdateIrq(pDevIns, pThis);
    16301663    }
    16311664    else
    16321665    {
    1633         Log3Func(("#%d Packet did not pass address filter, size=%d\n", DPNIC_INSTANCE, cbToRecv));
     1666        Log3Func(("#%d Packet did not pass address filter, size=%d\n", pThis->iInstance, cbToRecv));
    16341667        STAM_COUNTER_INC(&pThis->StatDropPktNoMatch);
    16351668    }
     
    16441677 * @returns VBox status code.  VERR_TRY_AGAIN is returned if we're busy.
    16451678 *
    1646  * @param   pThis               The device instance data.
     1679 * @param   pDevIns             The device instance data.
     1680 * @param   pThis               The device state data.
    16471681 * @param   fOnWorkerThread     Whether we're on a worker thread or on an EMT.
    16481682 */
    1649 static int dp8390CoreXmitPacket(PDPNICSTATE pThis, bool fOnWorkerThread)
    1650 {
     1683static int dp8390CoreXmitPacket(PPDMDEVINS pDevIns, PDPNICSTATE pThis, bool fOnWorkerThread)
     1684{
     1685    PDPNICSTATECC   pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PDPNICSTATECC);
    16511686    RT_NOREF_PV(fOnWorkerThread);
    16521687    int rc;
     
    16551690     * Grab the xmit lock of the driver as well as the DP8390 device state.
    16561691     */
    1657     PPDMINETWORKUP pDrv = pThis->CTX_SUFF(pDrv);
     1692    PPDMINETWORKUP pDrv = pThisCC->pDrv;
    16581693    if (pDrv)
    16591694    {
     
    16621697            return rc;
    16631698    }
    1664     PPDMDEVINS pDevIns = DPNICSTATE_2_DEVINS(pThis);
    16651699    rc = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY);
    16661700    if (RT_SUCCESS(rc))
     
    16691703         * Do the transmitting.
    16701704         */
    1671         int rc2 = dp8390CoreAsyncXmitLocked(pThis, false /*fOnWorkerThread*/);
     1705        int rc2 = dp8390CoreAsyncXmitLocked(pDevIns, pThis, pThisCC, false /*fOnWorkerThread*/);
    16721706        AssertReleaseRC(rc2);
    16731707
     
    16941728static DECLCALLBACK(void) dpNicR3XmitTaskCallback(PPDMDEVINS pDevIns, void *pvUser)
    16951729{
    1696     PDPNICSTATE pThis = PDMINS_2_DATA(pDevIns, PDPNICSTATE);
     1730    PDPNICSTATE   pThis = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE);
    16971731    NOREF(pvUser);
    16981732
     
    17001734     * Transmit if we can.
    17011735     */
    1702     dp8390CoreXmitPacket(pThis, true /*fOnWorkerThread*/);
     1736    dp8390CoreXmitPacket(pDevIns, pThis, true /*fOnWorkerThread*/);
    17031737}
    17041738
     
    17111745 * @returns See PPDMINETWORKUP::pfnAllocBuf.
    17121746 * @param   pThis       The device instance.
     1747 * @param   pThisCC     The device state for current context.
    17131748 * @param   cbMin       The minimum buffer size.
    17141749 * @param   fLoopback   Set if we're in loopback mode.
     
    17171752 *                      Always set.
    17181753 */
    1719 DECLINLINE(int) dp8390XmitAllocBuf(PDPNICSTATE pThis, size_t cbMin, bool fLoopback,
     1754DECLINLINE(int) dp8390XmitAllocBuf(PDPNICSTATE pThis, PDPNICSTATECC pThisCC, size_t cbMin, bool fLoopback,
    17201755                                   PPDMSCATTERGATHER pSgLoop, PPPDMSCATTERGATHER ppSgBuf)
    17211756{
     
    17241759    if (!fLoopback)
    17251760    {
    1726         PPDMINETWORKUP pDrv = pThis->CTX_SUFF(pDrv);
     1761        PPDMINETWORKUP pDrv = pThisCC->pDrv;
    17271762        if (RT_LIKELY(pDrv))
    17281763        {
     
    17621797 *
    17631798 * @returns See PDMINETWORKUP::pfnSendBuf.
    1764  * @param   pThis           The device instance.
     1799 * @param   pDevIns         The device instance.
     1800 * @param   pThisCC         The current context device state.
    17651801 * @param   fLoopback       Set if we're in loopback mode.
    17661802 * @param   pSgBuf          The SG to send.
     
    17681804 *                          if an EMT.
    17691805 */
    1770 DECLINLINE(int) dp8390CoreXmitSendBuf(PDPNICSTATE pThis, bool fLoopback, PPDMSCATTERGATHER pSgBuf, bool fOnWorkerThread)
    1771 {
     1806DECLINLINE(int) dp8390CoreXmitSendBuf(PPDMDEVINS pDevIns, PDPNICSTATECC pThisCC, bool fLoopback, PPDMSCATTERGATHER pSgBuf, bool fOnWorkerThread)
     1807{
     1808    PDPNICSTATE     pThis = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE);
    17721809    int rc;
    17731810    STAM_REL_COUNTER_ADD(&pThis->StatTransmitBytes, pSgBuf->cbUsed);
     
    17781815            pThis->Led.Asserted.s.fWriting = pThis->Led.Actual.s.fWriting = 1;
    17791816
    1780         PPDMINETWORKUP pDrv = pThis->CTX_SUFF(pDrv);
     1817        PPDMINETWORKUP pDrv = pThisCC->pDrv;
    17811818        if (RT_LIKELY(pDrv))
    17821819        {
     
    18061843        pThis->Led.Asserted.s.fReading = pThis->Led.Actual.s.fReading = 1;
    18071844
    1808         LogFlowFunc(("#%d: loopback (DCR=%02X LB=%u TCR=%02X RCR=%02X, %u bytes)\n", DPNIC_INSTANCE, pCore->DCR, pCore->tcr.LB, pCore->TCR, pCore->RCR, pSgBuf->cbUsed));
     1845        LogFlowFunc(("#%d: loopback (DCR=%02X LB=%u TCR=%02X RCR=%02X, %u bytes)\n", pThis->iInstance, pCore->DCR, pCore->tcr.LB, pCore->TCR, pCore->RCR, pSgBuf->cbUsed));
    18091846        for (ofs = 0; ofs < pSgBuf->cbUsed; ofs += 16)
    18101847            Log(("  %04X: %.*Rhxs\n", ofs, ofs + 16 < pSgBuf->cbUsed ? 16 : pSgBuf->cbUsed - ofs, &pThis->abLoopBuf[ofs]));
     
    18861923                /* Receiving side checks the FCS. */
    18871924                fGoodFcs = !memcmp(&pktbuf[pktlen - 4], abFcs, sizeof(abFcs));
    1888                 Log2Func(("#%d: Address matched (is_padr=%d, is_bcast=%d, is_mcast=%d, is_prom=%d), checking FCS (fGoodFcs=%RTbool)\n", DPNIC_INSTANCE, is_padr, is_bcast, is_mcast, is_prom, fGoodFcs));
     1925                Log2Func(("#%d: Address matched (is_padr=%d, is_bcast=%d, is_mcast=%d, is_prom=%d), checking FCS (fGoodFcs=%RTbool)\n", pThis->iInstance, is_padr, is_bcast, is_mcast, is_prom, fGoodFcs));
    18891926
    18901927                /* Now we have to update the FIFO. Since only 8 bytes are visible
     
    18991936                nRsr.PRX = 1;   /* Weird but true, for non-matching address only! */
    19001937                fAddrMatched = false;
    1901                 Log3Func(("#%d: Address NOT matched, ignoring FCS errors.\n", DPNIC_INSTANCE));
     1938                Log3Func(("#%d: Address NOT matched, ignoring FCS errors.\n", pThis->iInstance));
    19021939            }
    19031940
     
    19541991 * Reads the entire frame into the scatter gather buffer.
    19551992 */
    1956 DECLINLINE(void) dp8390CoreXmitRead(PDPNICSTATE pThis, const unsigned uLocalAddr, const unsigned cbFrame, PPDMSCATTERGATHER pSgBuf, bool fLoopback)
    1957 {
    1958     unsigned    uOfs = 0;
    1959     Assert(PDMDevHlpCritSectIsOwner(DPNICSTATE_2_DEVINS(pThis), &pThis->CritSect));
     1993DECLINLINE(void) dp8390CoreXmitRead(PPDMDEVINS pDevIns, const unsigned uLocalAddr, const unsigned cbFrame, PPDMSCATTERGATHER pSgBuf, bool fLoopback)
     1994{
     1995    PDPNICSTATE     pThis = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE);
     1996    unsigned        uOfs = 0;
     1997    Assert(PDMDevHlpCritSectIsOwner(pDevIns, &pThis->CritSect));
    19601998    Assert(pSgBuf->cbAvailable >= cbFrame);
    19611999
    19622000    pSgBuf->cbUsed = cbFrame;
    19632001
    1964     LogFlowFunc(("#%d: uLocalAddr=%04X cbFrame=%d\n", DPNIC_INSTANCE, uLocalAddr, cbFrame));
     2002    LogFlowFunc(("#%d: uLocalAddr=%04X cbFrame=%d\n", pThis->iInstance, uLocalAddr, cbFrame));
    19652003    /* Have to figure out where the address is in local RAM. */
    19662004    if (pThis->uDevType == DEV_NE1000)
     
    19762014        {
    19772015            /// @todo What are we supposed to do?!
    1978             LogFunc(("#%d: uOfs=%u, don't know what to do!!\n", DPNIC_INSTANCE, uOfs));
     2016            LogFunc(("#%d: uOfs=%u, don't know what to do!!\n", pThis->iInstance, uOfs));
    19792017        }
    19802018    }
     
    19912029        {
    19922030            /// @todo What are we supposed to do?!
    1993             LogFunc(("#%d: uOfs=%u, don't know what to do!!\n", DPNIC_INSTANCE, uOfs));
     2031            LogFunc(("#%d: uOfs=%u, don't know what to do!!\n", pThis->iInstance, uOfs));
    19942032        }
    19952033    }
     
    20112049        {
    20122050            /// @todo What are we supposed to do?!
    2013             LogFunc(("#%d: uOfs=%u, don't know what to do!!\n", DPNIC_INSTANCE, uOfs));
     2051            LogFunc(("#%d: uOfs=%u, don't know what to do!!\n", pThis->iInstance, uOfs));
    20142052        }
    20152053    }
     
    20582096 * Try to transmit a frame.
    20592097 */
    2060 static void dp8390CoreStartTransmit(PDPNICSTATE pThis)
     2098static void dp8390CoreStartTransmit(PPDMDEVINS pDevIns, PDPNICSTATE pThis)
    20612099{
    20622100    /*
     
    20672105    pThis->core.NCR = 0;    /* Clear collision counter. */
    20682106#if defined(IN_RING0) || defined(IN_RC)
    2069     if (!pThis->CTX_SUFF(pDrv))
    2070     {
    2071         int rc = PDMDevHlpTaskTrigger(pThis->CTX_SUFF(pDevIns), pThis->hXmitTask);
     2107    PDPNICSTATECC   pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PDPNICSTATECC);
     2108    if (!pThisCC->pDrv)
     2109    {
     2110        int rc = PDMDevHlpTaskTrigger(pDevIns, pThis->hXmitTask);
    20722111        AssertRC(rc);
    20732112    }
     
    20752114#endif
    20762115    {
    2077         int rc = dp8390CoreXmitPacket(pThis, false /*fOnWorkerThread*/);
     2116        int rc = dp8390CoreXmitPacket(pDevIns, pThis, false /*fOnWorkerThread*/);
    20782117        if (rc == VERR_TRY_AGAIN)
    20792118            rc = VINF_SUCCESS;
     
    20882127 * @threads EMT.
    20892128 */
    2090 static void dp8390CoreKickReceive(PDPNICSTATE pThis)
     2129static void dp8390CoreKickReceive(PPDMDEVINS pDevIns, PDPNICSTATE pThis)
    20912130{
    20922131    if (pThis->fMaybeOutOfSpace)
     
    20942133        LogFlow(("Poking receive thread.\n"));
    20952134#ifdef IN_RING3
    2096         dp8390WakeupReceive(DPNICSTATE_2_DEVINS(pThis));
     2135        dp8390R3WakeupReceive(pDevIns);
    20972136#else
    2098         int rc = PDMDevHlpTaskTrigger(pThis->CTX_SUFF(pDevIns), pThis->hCanRxTask);
     2137        int rc = PDMDevHlpTaskTrigger(pDevIns, pThis->hCanRxTask);
    20992138        AssertRC(rc);
    21002139#endif
     
    21072146 * @threads TX or EMT.
    21082147 */
    2109 static int dp8390CoreAsyncXmitLocked(PDPNICSTATE pThis, bool fOnWorkerThread)
    2110 {
    2111     Assert(PDMDevHlpCritSectIsOwner(DPNICSTATE_2_DEVINS(pThis), &pThis->CritSect));
     2148static int dp8390CoreAsyncXmitLocked(PPDMDEVINS pDevIns, PDPNICSTATE pThis, PDPNICSTATECC pThisCC, bool fOnWorkerThread)
     2149{
     2150    Assert(PDMDevHlpCritSectIsOwner(pDevIns, &pThis->CritSect));
    21122151
    21132152    /*
     
    21172156    if (RT_UNLIKELY(!pThis->core.cr.TXP))
    21182157    {
    2119         LogFunc(("#%d: Nope, CR.TXP is off (fOnWorkerThread=%RTbool)\n", DPNIC_INSTANCE, fOnWorkerThread));
     2158        LogFunc(("#%d: Nope, CR.TXP is off (fOnWorkerThread=%RTbool)\n", pThis->iInstance, fOnWorkerThread));
    21202159        return VINF_SUCCESS;
    21212160    }
     
    21442183        unsigned    cb  = pThis->core.TBCR; /* Packet size. */
    21452184        const int   adr = RT_MAKE_U16(0, pThis->core.TPSR);
    2146         LogFunc(("#%d: cb=%d, adr=%04X\n", DPNIC_INSTANCE, cb, adr));
     2185        LogFunc(("#%d: cb=%d, adr=%04X\n", pThis->iInstance, cb, adr));
    21472186
    21482187        if (RT_LIKELY(dp8390IsLinkUp(pThis) || fLoopback))
     
    21572196                }
    21582197
    2159                 rc = dp8390XmitAllocBuf(pThis, cb, fLoopback, &SgLoop, &pSgBuf);
     2198                rc = dp8390XmitAllocBuf(pThis, pThisCC, cb, fLoopback, &SgLoop, &pSgBuf);
    21602199                if (RT_SUCCESS(rc))
    21612200                {
    2162                     dp8390CoreXmitRead(pThis, adr, cb, pSgBuf, fLoopback);
    2163                     rc = dp8390CoreXmitSendBuf(pThis, fLoopback, pSgBuf, fOnWorkerThread);
    2164                     Log2Func(("#%d: rc=%Rrc\n", DPNIC_INSTANCE, rc));
     2201                    dp8390CoreXmitRead(pDevIns, adr, cb, pSgBuf, fLoopback);
     2202                    rc = dp8390CoreXmitSendBuf(pDevIns, pThisCC, fLoopback, pSgBuf, fOnWorkerThread);
     2203                    Log2Func(("#%d: rc=%Rrc\n", pThis->iInstance, rc));
    21652204                }
    21662205                else if (rc == VERR_TRY_AGAIN)
    21672206                {
    21682207                    STAM_PROFILE_ADV_STOP(&pThis->CTX_SUFF_Z(StatTransmit), a);
    2169                     LogFunc(("#%d: rc=%Rrc\n", DPNIC_INSTANCE, rc));
     2208                    LogFunc(("#%d: rc=%Rrc\n", pThis->iInstance, rc));
    21702209                    return VINF_SUCCESS;
    21712210                }
     
    21862225                 * hardware does *not* limit the packet length.
    21872226                 */
    2188                 LogRel(("DPNIC#%d: Attempt to transmit illegal giant frame (%u bytes) -> signaling error\n", DPNIC_INSTANCE, cb));
     2227                LogRel(("DPNIC#%d: Attempt to transmit illegal giant frame (%u bytes) -> signaling error\n", pThis->iInstance, cb));
    21892228                pThis->core.tsr.OWC = 1;    /* Pretend there was an out-of-window collision. */
    21902229                pThis->core.isr.TXE = 1;
     
    22012240        pThis->core.cr.TXP = 0;
    22022241        pThis->core.TBCR   = 0;
    2203         LogFlowFunc(("#%d: TSR=%02X, ISR=%02X\n", DPNIC_INSTANCE, pThis->core.TSR, pThis->core.ISR));
     2242        LogFlowFunc(("#%d: TSR=%02X, ISR=%02X\n", pThis->iInstance, pThis->core.TSR, pThis->core.ISR));
    22042243
    22052244    } while (0);    /* No loop, because there isn't ever more than one packet to transmit. */
    22062245
    2207     dp8390CoreUpdateIrq(pThis);
     2246    dp8390CoreUpdateIrq(pDevIns, pThis);
    22082247
    22092248    /* If there's anything waiting, this should be a good time to recheck. */
    2210     dp8390CoreKickReceive(pThis);
     2249    dp8390CoreKickReceive(pDevIns, pThis);
    22112250
    22122251    STAM_PROFILE_ADV_STOP(&pThis->CTX_SUFF_Z(StatTransmit), a);
     
    22182257
    22192258
    2220 static uint32_t dp8390CoreRead(PDPNICSTATE pThis, int ofs)
     2259static uint32_t dp8390CoreRead(PPDMDEVINS pDevIns, PDPNICSTATE pThis, int ofs)
    22212260{
    22222261    uint8_t     val;
     
    22592298            val = pThis->core.CNTR0;
    22602299            pThis->core.CNTR0 = 0;  /* Cleared by reading. */
    2261             dp8390CoreUpdateIrq(pThis);
     2300            dp8390CoreUpdateIrq(pDevIns, pThis);
    22622301            return val;
    22632302        case DPR_P0_R_CNTR1:
    22642303            val = pThis->core.CNTR1;
    22652304            pThis->core.CNTR1 = 0;  /* Cleared by reading. */
    2266             dp8390CoreUpdateIrq(pThis);
     2305            dp8390CoreUpdateIrq(pDevIns, pThis);
    22672306            return val;
    22682307        case DPR_P0_R_CNTR2:
    22692308            val = pThis->core.CNTR2;
    22702309            pThis->core.CNTR2 = 0;  /* Cleared by reading. */
    2271             dp8390CoreUpdateIrq(pThis);
     2310            dp8390CoreUpdateIrq(pDevIns, pThis);
    22722311            return val;
    22732312        default:
     
    23242363
    23252364
    2326 static int dp8390CoreWriteCR(PDPNICSTATE pThis, uint32_t val)
     2365static int dp8390CoreWriteCR(PPDMDEVINS pDevIns, PDPNICSTATE pThis, uint32_t val)
    23272366{
    23282367    union {
     
    23562395
    23572396        /* Unblock receive thread if necessary, possibly drop any packets. */
    2358         dp8390CoreKickReceive(pThis);
     2397        dp8390CoreKickReceive(pDevIns, pThis);
    23592398    }
    23602399    if (nCr.STA && !pThis->core.cr.STA)
     
    23682407
    23692408        /* Unblock receive thread. */
    2370         dp8390CoreKickReceive(pThis);
     2409        dp8390CoreKickReceive(pDevIns, pThis);
    23712410    }
    23722411    if (nCr.TXP && !pThis->core.cr.TXP)
     
    23742413        /* Kick off a transmit. */
    23752414        pThis->core.cr.TXP = 1;     /* Indicate transmit in progress. */
    2376         dp8390CoreStartTransmit(pThis);
     2415        dp8390CoreStartTransmit(pDevIns, pThis);
    23772416    }
    23782417
     
    24152454}
    24162455
    2417 static int dp8390CoreWrite(PDPNICSTATE pThis, int ofs, uint32_t val)
     2456static int dp8390CoreWrite(PPDMDEVINS pDevIns, PDPNICSTATE pThis, int ofs, uint32_t val)
    24182457{
    24192458    int     rc = VINF_SUCCESS;
    24202459    bool    fUpdateIRQ = false;
    24212460
    2422     Log2Func(("#%d: page=%d reg=%X val=%02X\n", DPNIC_INSTANCE, pThis->core.cr.PS, ofs, val));
     2461    Log2Func(("#%d: page=%d reg=%X val=%02X\n", pThis->iInstance, pThis->core.cr.PS, ofs, val));
    24232462
    24242463    /* Command Register exists in all pages. */
    24252464    if (ofs == DPR_CR)
    24262465    {
    2427         rc = dp8390CoreWriteCR(pThis, val);
     2466        rc = dp8390CoreWriteCR(pDevIns, pThis, val);
    24282467    }
    24292468    else if (pThis->core.cr.PS == 0)
     
    24432482                pThis->core.BNRY = val;
    24442483                /* Probably made more room in receive ring. */
    2445                 dp8390CoreKickReceive(pThis);
     2484                dp8390CoreKickReceive(pDevIns, pThis);
    24462485            }
    24472486            break;
     
    25382577
    25392578    if (fUpdateIRQ)
    2540         dp8390CoreUpdateIrq(pThis);
     2579        dp8390CoreUpdateIrq(pDevIns, pThis);
    25412580
    25422581    return rc;
     
    26792718
    26802719
    2681 static int neDataPortWrite(PDPNICSTATE pThis, uint16_t val)
     2720static int neDataPortWrite(PPDMDEVINS pDevIns, PDPNICSTATE pThis, uint16_t val)
    26822721{
    26832722    /* Remote Write; ignored if Remote DMA command is not 'Write'. */
     
    27132752            pThis->core.isr.RDC = 1;
    27142753            pThis->core.cr.RD   = 0;
    2715             dp8390CoreUpdateIrq(pThis);
     2754            dp8390CoreUpdateIrq(pDevIns, pThis);
    27162755        }
    27172756    }
     
    27202759
    27212760
    2722 static uint16_t neDataPortRead(PDPNICSTATE pThis)
     2761static uint16_t neDataPortRead(PPDMDEVINS pDevIns, PDPNICSTATE pThis)
    27232762{
    27242763    uint16_t    val = 0x1234;
     
    27572796            pThis->core.isr.RDC = 1;
    27582797            pThis->core.cr.RD   = 0;
    2759             dp8390CoreUpdateIrq(pThis);
     2798            dp8390CoreUpdateIrq(pDevIns, pThis);
    27602799        }
    27612800    }
     
    27642803
    27652804
    2766 static int neResetPortWrite(PDPNICSTATE pThis)
     2805static int neResetPortWrite(PPDMDEVINS pDevIns, PDPNICSTATE pThis)
    27672806{
    27682807    LogFlowFunc(("\n"));
    2769     dp8390CoreReset(pThis);
     2808    dp8390CoreReset(pDevIns, pThis);
    27702809    return VINF_SUCCESS;
    27712810}
    27722811
    27732812
    2774 static int dpNeIoWrite(PDPNICSTATE pThis, uint32_t addr, uint32_t val)
     2813static int dpNeIoWrite(PPDMDEVINS pDevIns, PDPNICSTATE pThis, uint32_t addr, uint32_t val)
    27752814{
    27762815    int     reg = addr & 0x0f;
    27772816    int     rc = VINF_SUCCESS;
    27782817
    2779     Log2Func(("#%d: addr=%#06x val=%#04x\n", DPNIC_INSTANCE, addr, val & 0xff));
     2818    Log2Func(("#%d: addr=%#06x val=%#04x\n", pThis->iInstance, addr, val & 0xff));
    27802819
    27812820    /* The NE2000 has 8 bytes of data port followed by 8 bytes of reset port.
     
    27862825        reg >>= 1;
    27872826    if (reg & 0x04)
    2788         rc = neResetPortWrite(pThis);
     2827        rc = neResetPortWrite(pDevIns, pThis);
    27892828    else
    2790         rc = neDataPortWrite(pThis, val);
     2829        rc = neDataPortWrite(pDevIns, pThis, val);
    27912830
    27922831    return rc;
     
    27942833
    27952834
    2796 static uint32_t neIoRead(PDPNICSTATE pThis, uint32_t addr)
     2835static uint32_t neIoRead(PPDMDEVINS pDevIns, PDPNICSTATE pThis, uint32_t addr)
    27972836{
    27982837    uint32_t    val = UINT32_MAX;
     
    28082847        val = 0x52; /// @todo Check what really happens
    28092848    else
    2810         val = neDataPortRead(pThis);
    2811 
    2812     Log2Func(("#%d: addr=%#06x val=%#04x\n", DPNIC_INSTANCE, addr, val & 0xff));
     2849        val = neDataPortRead(pDevIns, pThis);
     2850
     2851    Log2Func(("#%d: addr=%#06x val=%#04x\n", pThis->iInstance, addr, val & 0xff));
    28132852    return val;
    28142853}
    28152854
    28162855
    2817 static int wdIoWrite(PDPNICSTATE pThis, uint32_t addr, uint32_t val)
     2856static int wdIoWrite(PPDMDEVINS pDevIns, PDPNICSTATE pThis, uint32_t addr, uint32_t val)
    28182857{
    28192858    int             reg = addr & 0xf;
     
    28282867    };
    28292868
    2830     Log2Func(("#%d: addr=%#06x val=%#04x\n", DPNIC_INSTANCE, addr, val & 0xff));
     2869    Log2Func(("#%d: addr=%#06x val=%#04x\n", pThis->iInstance, addr, val & 0xff));
    28312870
    28322871    switch (reg)
     
    28412880        if (nCtrl1.RESET)
    28422881        {
    2843             dp8390CoreReset(pThis);
     2882            dp8390CoreReset(pDevIns, pThis);
    28442883            pThis->CTRL1 = 0;
    28452884        }
     
    29192958    }
    29202959
    2921     Log2Func(("#%d: addr=%#06x val=%#04x\n", DPNIC_INSTANCE, addr, val & 0xff));
     2960    Log2Func(("#%d: addr=%#06x val=%#04x\n", pThis->iInstance, addr, val & 0xff));
    29222961    return val;
    29232962}
     
    29703009}
    29713010
    2972 static void elWriteIdcfr(PDPNICSTATE pThis, PEL_GA pGa, uint8_t val)
     3011static void elWriteIdcfr(PPDMDEVINS pDevIns, PDPNICSTATE pThis, PEL_GA pGa, uint8_t val)
    29733012{
    29743013    uint8_t     uOldIrq = pThis->uIsaIrq;
     
    29813020    if (uOldIrq != uNewIrq)
    29823021    {
    2983         LogFunc(("#%d Switching IRQ=%d -> IRQ=%d\n", DPNIC_INSTANCE, uOldIrq, uNewIrq));
     3022        LogFunc(("#%d Switching IRQ=%d -> IRQ=%d\n", pThis->iInstance, uOldIrq, uNewIrq));
    29843023        if (pThis->fNicIrqActive)
    29853024        {
    29863025            /* This probably isn't supposed to happen. */
    2987             LogFunc(("#%d Moving active IRQ!\n", DPNIC_INSTANCE));
     3026            LogFunc(("#%d Moving active IRQ!\n", pThis->iInstance));
    29883027            if (uOldIrq)
    2989                 PDMDevHlpISASetIrq(DPNICSTATE_2_DEVINS(pThis), uOldIrq, 0);
     3028                PDMDevHlpISASetIrq(pDevIns, uOldIrq, 0);
    29903029            if (uNewIrq)
    2991                 PDMDevHlpISASetIrq(DPNICSTATE_2_DEVINS(pThis), uNewIrq, 1);
     3030                PDMDevHlpISASetIrq(pDevIns, uNewIrq, 1);
    29923031        }
    29933032        pThis->uIsaIrq = uNewIrq;
     
    29993038    {
    30003039        /// @todo We can't really move the DRQ, what can we do?
    3001         LogFunc(("#%d Switching DRQ=%d -> DRQ=%d\n", DPNIC_INSTANCE, uOldDrq, uNewDrq));
     3040        LogFunc(("#%d Switching DRQ=%d -> DRQ=%d\n", pThis->iInstance, uOldDrq, uNewDrq));
    30023041        pThis->uElIsaDma = uNewDrq;
    30033042    }
     
    30073046
    30083047
    3009 static void elWriteGacfr(PDPNICSTATE pThis, PEL_GA pGa, uint8_t val)
     3048static void elWriteGacfr(PPDMDEVINS pDevIns, PDPNICSTATE pThis, PEL_GA pGa, uint8_t val)
    30103049{
    30113050    union {
     
    30213060        if (pThis->fNicIrqActive && !nGacfr.nim)
    30223061        {
    3023             LogFunc(("#%d: Unmasking active IRQ!\n", DPNIC_INSTANCE));
    3024             PDMDevHlpISASetIrq(DPNICSTATE_2_DEVINS(pThis), pThis->uIsaIrq, 1);
     3062            LogFunc(("#%d: Unmasking active IRQ!\n", pThis->iInstance));
     3063            PDMDevHlpISASetIrq(pDevIns, pThis->uIsaIrq, 1);
    30253064        }
    30263065        else if (pThis->fNicIrqActive && nGacfr.nim)
    30273066        {
    3028             LogFunc(("#%d: Masking active IRQ\n", DPNIC_INSTANCE));
    3029             PDMDevHlpISASetIrq(DPNICSTATE_2_DEVINS(pThis), pThis->uIsaIrq, 0);
     3067            LogFunc(("#%d: Masking active IRQ\n", pThis->iInstance));
     3068            PDMDevHlpISASetIrq(pDevIns, pThis->uIsaIrq, 0);
    30303069        }
    30313070    }
     
    30343073    if (nGacfr.rsel != pGa->gacfr.rsel)
    30353074    {
    3036         LogFunc(("#%d: rsel=%u mbs=%u\n", DPNIC_INSTANCE, nGacfr.rsel, nGacfr.mbs));
     3075        LogFunc(("#%d: rsel=%u mbs=%u\n", pThis->iInstance, nGacfr.rsel, nGacfr.mbs));
    30373076    }
    30383077
     
    30413080
    30423081
    3043 static void elSoftReset(PDPNICSTATE pThis)
     3082static void elSoftReset(PPDMDEVINS pDevIns, PDPNICSTATE pThis)
    30443083{
    30453084    PEL_GA      pGa = &pThis->ga;
     
    30493088    pGa->PSTR = pGa->PSPR = 0;
    30503089    pGa->DQTR = 0;
    3051     elWriteGacfr(pThis, pGa, 0);
     3090    elWriteGacfr(pDevIns, pThis, pGa, 0);
    30523091    pGa->STREG = ELNKII_GA_REV;
    30533092    pGa->VPTR0 = pGa->VPTR1 = pGa->VPTR2 = 0;
    30543093    pGa->DALSB = pGa->DAMSB = 0;
    3055     elWriteIdcfr(pThis, pGa, 0);
     3094    elWriteIdcfr(pDevIns, pThis, pGa, 0);
    30563095    pGa->GACR = 0x0B;   /* Low bit set = in reset state. */
    30573096    pGa->fGaIrq = false;
    30583097
    30593098    /* Reset the NIC core. */
    3060     dp8390CoreReset(pThis);
    3061 }
    3062 
    3063 
    3064 static int elWriteGacr(PDPNICSTATE pThis, PEL_GA pGa, uint8_t val)
     3099    dp8390CoreReset(pDevIns, pThis);
     3100}
     3101
     3102
     3103static int elWriteGacr(PPDMDEVINS pDevIns, PDPNICSTATE pThis, PEL_GA pGa, uint8_t val)
    30653104{
    30663105    union {
     
    30753114        /* When going out of reset, only clear the rst bit. 3C503 diagnostics checks for this. */
    30763115        if (nGacr.rst)
    3077             elSoftReset(pThis);
     3116            elSoftReset(pDevIns, pThis);
    30783117        else
    30793118            pGa->gacr.rst = 0;
     
    31073146        {
    31083147#ifdef IN_RING3
    3109             PDMDevHlpDMASetDREQ(pThis->CTX_SUFF(pDevIns), pThis->uIsaDma, pGa->streg.dprdy);
     3148            PDMDevHlpDMASetDREQ(pDevIns, pThis->uIsaDma, pGa->streg.dprdy);
    31103149            if (pGa->streg.dprdy)
    3111                 PDMDevHlpDMASchedule(pThis->CTX_SUFF(pDevIns));
    3112             LogFunc(("#%d: DREQ for channel %u set to %u\n", DPNIC_INSTANCE, pThis->uIsaDma, pGa->streg.dprdy));
     3150                PDMDevHlpDMASchedule(pDevIns);
     3151            LogFunc(("#%d: DREQ for channel %u set to %u\n", pThis->iInstance, pThis->uIsaDma, pGa->streg.dprdy));
    31133152#else
    31143153            /* Must not get here. */
     
    31803219
    31813220
    3182 static int elGaIoWrite(PDPNICSTATE pThis, uint32_t addr, uint32_t val)
     3221static int elGaIoWrite(PPDMDEVINS pDevIns, PDPNICSTATE pThis, uint32_t addr, uint32_t val)
    31833222{
    31843223    int         reg = addr & 0xf;
     
    31863225    PEL_GA      pGa = &pThis->ga;
    31873226
    3188     Log2Func(("#%d: addr=%#06x val=%#04x\n", DPNIC_INSTANCE, addr, val & 0xff));
     3227    Log2Func(("#%d: addr=%#06x val=%#04x\n", pThis->iInstance, addr, val & 0xff));
    31893228
    31903229    switch (reg)
     
    32003239        break;
    32013240    case GAR_GACFR:
    3202         elWriteGacfr(pThis, pGa, val);
     3241        elWriteGacfr(pDevIns, pThis, pGa, val);
    32033242        break;
    32043243    case GAR_GACR:
    3205         rc = elWriteGacr(pThis, pGa, val);
     3244        rc = elWriteGacr(pDevIns, pThis, pGa, val);
    32063245        break;
    32073246    case GAR_STREG:
     
    32093248        pThis->ga.streg.dtc = 0;
    32103249        pThis->ga.fGaIrq    = false;
    3211         dp8390CoreUpdateIrq(pThis);
     3250        dp8390CoreUpdateIrq(pDevIns, pThis);
    32123251        break;
    32133252    case GAR_IDCFR:
    3214         elWriteIdcfr(pThis, pGa, val);
     3253        elWriteIdcfr(pDevIns, pThis, pGa, val);
    32153254        break;
    32163255    case GAR_DAMSB:
     
    33053344    }
    33063345
    3307     Log2Func(("#%d: addr=%#06x val=%#04x\n", DPNIC_INSTANCE, addr, val & 0xff));
     3346    Log2Func(("#%d: addr=%#06x val=%#04x\n", pThis->iInstance, addr, val & 0xff));
    33083347    return val;
    33093348}
     
    33163355neIOPortRead(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t *pu32, unsigned cb)
    33173356{
    3318     PDPNICSTATE     pThis = PDMINS_2_DATA(pDevIns, PDPNICSTATE);
     3357    PDPNICSTATE     pThis = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE);
    33193358    int             rc    = VINF_SUCCESS;
    33203359    int             reg   = Port & 0xf;
     
    33273366    {
    33283367        case 1:
    3329             *pu32 = neIoRead(pThis, reg);
     3368            *pu32 = neIoRead(pDevIns, pThis, reg);
    33303369            break;
    33313370        case 2:
     
    33333372            if (pThis->uDevType == DEV_NE1000)
    33343373            {
    3335                 u8Lo = neIoRead(pThis, reg);
     3374                u8Lo = neIoRead(pDevIns, pThis, reg);
    33363375                if (reg < 0xf)  // This logic is not entirely accurate (wraparound).
    3337                     u8Hi = neIoRead(pThis, reg + 1);
     3376                    u8Hi = neIoRead(pDevIns, pThis, reg + 1);
    33383377                *pu32 = RT_MAKE_U16(u8Lo, u8Hi);
    33393378            }
    33403379            else
    3341                 *pu32 = neIoRead(pThis, reg);
     3380                *pu32 = neIoRead(pDevIns, pThis, reg);
    33423381            break;
    33433382        default:
    3344             rc = PDMDevHlpDBGFStop(pThis->CTX_SUFF(pDevIns), RT_SRC_POS,
     3383            rc = PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS,
    33453384                                   "neIOPortRead: unsupported operation size: offset=%#10x cb=%u\n",
    33463385                                   Port, cb);
    33473386    }
    33483387
    3349     Log2Func(("#%d: NE Port=%RTiop *pu32=%#RX32 cb=%d rc=%Rrc\n", DPNIC_INSTANCE, Port, *pu32, cb, rc));
     3388    Log2Func(("#%d: NE Port=%RTiop *pu32=%#RX32 cb=%d rc=%Rrc\n", pThis->iInstance, Port, *pu32, cb, rc));
    33503389    STAM_PROFILE_ADV_STOP(&pThis->CTX_SUFF_Z(StatIORead), a);
    33513390    return rc;
     
    33593398wdIOPortRead(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t *pu32, unsigned cb)
    33603399{
    3361     PDPNICSTATE     pThis = PDMINS_2_DATA(pDevIns, PDPNICSTATE);
     3400    PDPNICSTATE     pThis = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE);
    33623401    int             rc    = VINF_SUCCESS;
    33633402    int             reg   = Port & 0xf;
     
    33803419            break;
    33813420        default:
    3382             rc = PDMDevHlpDBGFStop(pThis->CTX_SUFF(pDevIns), RT_SRC_POS,
     3421            rc = PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS,
    33833422                                   "wdIOPortRead: unsupported operation size: offset=%#10x cb=%u\n",
    33843423                                   Port, cb);
    33853424    }
    33863425
    3387     Log2Func(("#%d: WD Port=%RTiop *pu32=%#RX32 cb=%d rc=%Rrc\n", DPNIC_INSTANCE, Port, *pu32, cb, rc));
     3426    Log2Func(("#%d: WD Port=%RTiop *pu32=%#RX32 cb=%d rc=%Rrc\n", pThis->iInstance, Port, *pu32, cb, rc));
    33883427    STAM_PROFILE_ADV_STOP(&pThis->CTX_SUFF_Z(StatIORead), a);
    33893428    return rc;
     
    33973436elIOPortRead(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t *pu32, unsigned cb)
    33983437{
    3399     PDPNICSTATE     pThis = PDMINS_2_DATA(pDevIns, PDPNICSTATE);
     3438    PDPNICSTATE     pThis = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE);
    34003439    int             rc    = VINF_SUCCESS;
    34013440    int             reg   = Port & 0xf;
     
    34183457            break;
    34193458        default:
    3420             rc = PDMDevHlpDBGFStop(pThis->CTX_SUFF(pDevIns), RT_SRC_POS,
     3459            rc = PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS,
    34213460                                   "elIOPortRead: unsupported operation size: offset=%#10x cb=%u\n",
    34223461                                   Port, cb);
    34233462    }
    34243463
    3425     Log2Func(("#%d: EL Port=%RTiop *pu32=%#RX32 cb=%d rc=%Rrc\n", DPNIC_INSTANCE, Port, *pu32, cb, rc));
     3464    Log2Func(("#%d: EL Port=%RTiop *pu32=%#RX32 cb=%d rc=%Rrc\n", pThis->iInstance, Port, *pu32, cb, rc));
    34263465    STAM_PROFILE_ADV_STOP(&pThis->CTX_SUFF_Z(StatIORead), a);
    34273466    return rc;
     
    34353474dp8390CoreIOPortRead(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t *pu32, unsigned cb)
    34363475{
    3437     PDPNICSTATE     pThis = PDMINS_2_DATA(pDevIns, PDPNICSTATE);
     3476    PDPNICSTATE     pThis = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE);
    34383477    int             rc    = VINF_SUCCESS;
    34393478    int             reg   = Port & 0xf;
     
    34463485    {
    34473486        case 1:
    3448             *pu32 = dp8390CoreRead(pThis, reg);
     3487            *pu32 = dp8390CoreRead(pDevIns, pThis, reg);
    34493488            break;
    34503489        case 2:
    34513490            /* Manually split word access. */
    3452             u8Lo = dp8390CoreRead(pThis, reg + 0);
     3491            u8Lo = dp8390CoreRead(pDevIns, pThis, reg + 0);
    34533492            /* This logic is not entirely accurate. */
    34543493            if (reg < 0xf)
    3455                 u8Hi = dp8390CoreRead(pThis, reg + 1);
     3494                u8Hi = dp8390CoreRead(pDevIns, pThis, reg + 1);
    34563495            else
    34573496                u8Hi = 0;
     
    34593498            break;
    34603499        default:
    3461             rc = PDMDevHlpDBGFStop(pThis->CTX_SUFF(pDevIns), RT_SRC_POS,
     3500            rc = PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS,
    34623501                                   "dp8390CoreIOPortRead: unsupported operation size: offset=%#10x cb=%u\n",
    34633502                                   Port, cb);
    34643503    }
    34653504
    3466     Log2Func(("#%d: Port=%RTiop *pu32=%#RX32 cb=%d rc=%Rrc\n", DPNIC_INSTANCE, Port, *pu32, cb, rc));
     3505    Log2Func(("#%d: Port=%RTiop *pu32=%#RX32 cb=%d rc=%Rrc\n", pThis->iInstance, Port, *pu32, cb, rc));
    34673506    STAM_PROFILE_ADV_STOP(&pThis->CTX_SUFF_Z(StatIORead), a);
    34683507    return rc;
     
    34763515neIOPortWrite(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
    34773516{
    3478     PDPNICSTATE     pThis = PDMINS_2_DATA(pDevIns, PDPNICSTATE);
     3517    PDPNICSTATE     pThis = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE);
    34793518    int             rc    = VINF_SUCCESS;
    34803519    int             reg   = Port & 0xf;
     
    34863525    {
    34873526        case 1:
    3488             rc = dpNeIoWrite(pThis, Port, RT_LOBYTE(u32));
     3527            rc = dpNeIoWrite(pDevIns, pThis, Port, RT_LOBYTE(u32));
    34893528            break;
    34903529        case 2:
     
    34923531            if (pThis->uDevType == DEV_NE2000)
    34933532            {
    3494                 rc = dpNeIoWrite(pThis, Port, RT_LOWORD(u32));
     3533                rc = dpNeIoWrite(pDevIns, pThis, Port, RT_LOWORD(u32));
    34953534            }
    34963535            else
    34973536            {
    3498                 rc = dpNeIoWrite(pThis, reg + 0, RT_LOBYTE(u32));
     3537                rc = dpNeIoWrite(pDevIns, pThis, reg + 0, RT_LOBYTE(u32));
    34993538                if (RT_SUCCESS(rc) && (reg < 0xf))
    3500                     rc = dpNeIoWrite(pThis, reg + 1, RT_HIBYTE(u32));
     3539                    rc = dpNeIoWrite(pDevIns, pThis, reg + 1, RT_HIBYTE(u32));
    35013540            }
    35023541            break;
    35033542        default:
    3504             rc = PDMDevHlpDBGFStop(pThis->CTX_SUFF(pDevIns), RT_SRC_POS,
     3543            rc = PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS,
    35053544                                   "neIOPortWrite: unsupported operation size: offset=%#10x cb=%u\n",
    35063545                                   Port, cb);
    35073546    }
    35083547
    3509     Log2Func(("#%d: NE Port=%RTiop u32=%#RX32 cb=%d rc=%Rrc\n", DPNIC_INSTANCE, Port, u32, cb, rc));
     3548    Log2Func(("#%d: NE Port=%RTiop u32=%#RX32 cb=%d rc=%Rrc\n", pThis->iInstance, Port, u32, cb, rc));
    35103549    STAM_PROFILE_ADV_STOP(&pThis->CTX_SUFF_Z(StatIOWrite), a);
    35113550    return rc;
     
    35193558wdIOPortWrite(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
    35203559{
    3521     PDPNICSTATE     pThis = PDMINS_2_DATA(pDevIns, PDPNICSTATE);
     3560    PDPNICSTATE     pThis = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE);
    35223561    int             rc    = VINF_SUCCESS;
    35233562    int             reg   = Port & 0xf;
     
    35293568    {
    35303569        case 1:
    3531             rc = wdIoWrite(pThis, Port, RT_LOBYTE(u32));
     3570            rc = wdIoWrite(pDevIns, pThis, Port, RT_LOBYTE(u32));
    35323571            break;
    35333572        case 2:
    35343573            /* Manually split word access. */
    3535             rc = wdIoWrite(pThis, reg + 0, RT_LOBYTE(u32));
     3574            rc = wdIoWrite(pDevIns, pThis, reg + 0, RT_LOBYTE(u32));
    35363575            if (RT_SUCCESS(rc) && (reg < 0xf))
    3537                 rc = wdIoWrite(pThis, reg + 1, RT_HIBYTE(u32));
     3576                rc = wdIoWrite(pDevIns, pThis, reg + 1, RT_HIBYTE(u32));
    35383577            break;
    35393578        default:
    3540             rc = PDMDevHlpDBGFStop(pThis->CTX_SUFF(pDevIns), RT_SRC_POS,
     3579            rc = PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS,
    35413580                                   "wdIOPortWrite: unsupported operation size: offset=%#10x cb=%u\n",
    35423581                                   Port, cb);
    35433582    }
    35443583
    3545     Log2Func(("#%d: WD Port=%RTiop u32=%#RX32 cb=%d rc=%Rrc\n", DPNIC_INSTANCE, Port, u32, cb, rc));
     3584    Log2Func(("#%d: WD Port=%RTiop u32=%#RX32 cb=%d rc=%Rrc\n", pThis->iInstance, Port, u32, cb, rc));
    35463585    STAM_PROFILE_ADV_STOP(&pThis->CTX_SUFF_Z(StatIOWrite), a);
    35473586    return rc;
     
    35553594elIOPortWrite(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
    35563595{
    3557     PDPNICSTATE     pThis = PDMINS_2_DATA(pDevIns, PDPNICSTATE);
     3596    PDPNICSTATE     pThis = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE);
    35583597    int             rc    = VINF_SUCCESS;
    35593598    int             reg   = Port & 0xf;
     
    35653604    {
    35663605        case 1:
    3567             rc = elGaIoWrite(pThis, Port, RT_LOBYTE(u32));
     3606            rc = elGaIoWrite(pDevIns, pThis, Port, RT_LOBYTE(u32));
    35683607            break;
    35693608        case 2:
    35703609            /* Manually split word access. */
    3571             rc = elGaIoWrite(pThis, reg + 0, RT_LOBYTE(u32));
     3610            rc = elGaIoWrite(pDevIns, pThis, reg + 0, RT_LOBYTE(u32));
    35723611            if (RT_SUCCESS(rc) && (reg < 0xf))
    3573                 rc = elGaIoWrite(pThis, reg + 1, RT_HIBYTE(u32));
     3612                rc = elGaIoWrite(pDevIns, pThis, reg + 1, RT_HIBYTE(u32));
    35743613            break;
    35753614        default:
    3576             rc = PDMDevHlpDBGFStop(pThis->CTX_SUFF(pDevIns), RT_SRC_POS,
     3615            rc = PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS,
    35773616                                   "elIOPortWrite: unsupported operation size: offset=%#10x cb=%u\n",
    35783617                                   Port, cb);
    35793618    }
    35803619
    3581     Log2Func(("#%d: EL Port=%RTiop u32=%#RX32 cb=%d rc=%Rrc\n", DPNIC_INSTANCE, Port, u32, cb, rc));
     3620    Log2Func(("#%d: EL Port=%RTiop u32=%#RX32 cb=%d rc=%Rrc\n", pThis->iInstance, Port, u32, cb, rc));
    35823621    STAM_PROFILE_ADV_STOP(&pThis->CTX_SUFF_Z(StatIOWrite), a);
    35833622    return rc;
     
    35913630dp8390CoreIOPortWrite(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
    35923631{
    3593     PDPNICSTATE     pThis = PDMINS_2_DATA(pDevIns, PDPNICSTATE);
     3632    PDPNICSTATE     pThis = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE);
    35943633    int             rc    = VINF_SUCCESS;
    35953634    int             reg   = Port & 0xf;
     
    36013640    {
    36023641        case 1:
    3603             rc = dp8390CoreWrite(pThis, reg, RT_LOBYTE(u32));
     3642            rc = dp8390CoreWrite(pDevIns, pThis, reg, RT_LOBYTE(u32));
    36043643            break;
    36053644        case 2:
    36063645            /* Manually split word access. */
    3607             rc = dp8390CoreWrite(pThis, reg + 0, RT_LOBYTE(u32));
     3646            rc = dp8390CoreWrite(pDevIns, pThis, reg + 0, RT_LOBYTE(u32));
    36083647            if (!RT_SUCCESS(rc))
    36093648                break;
    3610             rc = dp8390CoreWrite(pThis, reg + 1, RT_HIBYTE(u32));
     3649            rc = dp8390CoreWrite(pDevIns, pThis, reg + 1, RT_HIBYTE(u32));
    36113650            break;
    36123651        default:
    3613             rc = PDMDevHlpDBGFStop(pThis->CTX_SUFF(pDevIns), RT_SRC_POS,
     3652            rc = PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS,
    36143653                                   "dp8390CoreIOPortWrite: unsupported operation size: offset=%#10x cb=%u\n",
    36153654                                   Port, cb);
    36163655    }
    36173656
    3618     Log2Func(("#%d: Port=%RTiop u32=%#RX32 cb=%d rc=%Rrc\n", DPNIC_INSTANCE, Port, u32, cb, rc));
     3657    Log2Func(("#%d: Port=%RTiop u32=%#RX32 cb=%d rc=%Rrc\n", pThis->iInstance, Port, u32, cb, rc));
    36193658    STAM_PROFILE_ADV_STOP(&pThis->CTX_SUFF_Z(StatIOWrite), a);
    36203659    return rc;
     
    36313670dpWdMmioFill(PPDMDEVINS pDevIns, void *pvUser, RTGCPHYS off, uint32_t u32Item, unsigned cbItem, unsigned cItems)
    36323671{
    3633     PDPNICSTATE     pThis = PDMINS_2_DATA(pDevIns, PDPNICSTATE);
     3672    PDPNICSTATE     pThis = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE);
    36343673    Assert(PDMDevHlpCritSectIsOwner(pDevIns, pDevIns->CTX_SUFF(pCritSectRo)));
    36353674
     
    36463685static DECLCALLBACK(VBOXSTRICTRC) wdMemRead(PPDMDEVINS pDevIns, void *pvUser, RTGCPHYS off, void *pv, unsigned cb)
    36473686{
    3648     PDPNICSTATE     pThis   = PDMINS_2_DATA(pDevIns, PDPNICSTATE);
     3687    PDPNICSTATE     pThis   = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE);
    36493688    uint8_t         *pbData = (uint8_t *)pv;
    36503689    NOREF(pvUser);
     
    36553694    if (pThis->ctrl1.MEME)
    36563695    {
    3657         Log3Func(("#%d: Reading %u bytes from address %X: [%.*Rhxs]\n", pDevIns->iInstance, cb, off, cb, &pThis->abLocalRAM[off & DPNIC_MEM_MASK]));
     3696        Log3Func(("#%d: Reading %u bytes from address %X: [%.*Rhxs]\n", pThis->iInstance, cb, off, cb, &pThis->abLocalRAM[off & DPNIC_MEM_MASK]));
    36583697        while (cb-- > 0)
    36593698            *pbData++ = pThis->abLocalRAM[off++ & DPNIC_MEM_MASK];
     
    36723711static DECLCALLBACK(VBOXSTRICTRC) wdMemWrite(PPDMDEVINS pDevIns, void *pvUser, RTGCPHYS off, void const *pv, unsigned cb)
    36733712{
    3674     PDPNICSTATE     pThis  = PDMINS_2_DATA(pDevIns, PDPNICSTATE);
     3713    PDPNICSTATE     pThis  = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE);
    36753714    uint8_t const   *pbSrc = (uint8_t const *)pv;
    36763715    NOREF(pvUser);
     
    36813720    if (pThis->ctrl1.MEME)
    36823721    {
    3683         Log3Func(("#%d: Writing %u bytes to address %X: [%.*Rhxs]\n", pDevIns->iInstance, cb, off, cb, pbSrc));
     3722        Log3Func(("#%d: Writing %u bytes to address %X: [%.*Rhxs]\n", pThis->iInstance, cb, off, cb, pbSrc));
    36843723        while (cb-- > 0)
    36853724            pThis->abLocalRAM[off++ & DPNIC_MEM_MASK] = *pbSrc++;
     
    36973736static DECLCALLBACK(VBOXSTRICTRC) elMemRead(PPDMDEVINS pDevIns, void *pvUser, RTGCPHYS off, void *pv, unsigned cb)
    36983737{
    3699     PDPNICSTATE     pThis   = PDMINS_2_DATA(pDevIns, PDPNICSTATE);
     3738    PDPNICSTATE     pThis   = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE);
    37003739    uint8_t         *pbData = (uint8_t *)pv;
    37013740    NOREF(pvUser);
     
    37053744    if (pThis->ga.gacfr.rsel)
    37063745    {
    3707         Log3Func(("#%d: Reading %u bytes from address %X\n", pDevIns->iInstance, cb, off));
     3746        Log3Func(("#%d: Reading %u bytes from address %X\n", pThis->iInstance, cb, off));
    37083747        while (cb-- > 0)
    37093748            *pbData++ = pThis->abLocalRAM[off++ & DPNIC_MEM_MASK];
     
    37113750    else
    37123751    {
    3713         Log3Func(("#%d: Ignoring read of %u bytes from address %X\n", pDevIns->iInstance, cb, off));
     3752        Log3Func(("#%d: Ignoring read of %u bytes from address %X\n", pThis->iInstance, cb, off));
    37143753        memset(pv, 0xff, cb);
    37153754    }
     
    37243763static DECLCALLBACK(VBOXSTRICTRC) elMemWrite(PPDMDEVINS pDevIns, void *pvUser, RTGCPHYS off, void const *pv, unsigned cb)
    37253764{
    3726     PDPNICSTATE     pThis  = PDMINS_2_DATA(pDevIns, PDPNICSTATE);
     3765    PDPNICSTATE     pThis  = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE);
    37273766    uint8_t const   *pbSrc = (uint8_t const *)pv;
    37283767    NOREF(pvUser);
     
    37323771    if (pThis->ga.gacfr.rsel)
    37333772    {
    3734         Log3Func(("#%d: Writing %u bytes to address %X\n", pDevIns->iInstance, cb, off));
     3773        Log3Func(("#%d: Writing %u bytes to address %X\n", pThis->iInstance, cb, off));
    37353774        while (cb-- > 0)
    37363775            pThis->abLocalRAM[off++ & DPNIC_MEM_MASK] = *pbSrc++;
     
    37383777    else
    37393778    {
    3740         Log3Func(("#%d: Ignoring write of %u bytes to address %X\n", pDevIns->iInstance, cb, off));
     3779        Log3Func(("#%d: Ignoring write of %u bytes to address %X\n", pThis->iInstance, cb, off));
    37413780    }
    37423781    return VINF_SUCCESS;
     
    38783917        pThis->ga.streg.dtc = 1;
    38793918        pThis->ga.fGaIrq    = true;
    3880         dp8390CoreUpdateIrq(pThis);
     3919        dp8390CoreUpdateIrq(pDevIns, pThis);
    38813920    }
    38823921    else
     
    39033942{
    39043943    RT_NOREF(pvUser);
    3905     PDPNICSTATE     pThis = PDMINS_2_DATA(pDevIns, PDPNICSTATE);
     3944    PDPNICSTATE     pThis = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE);
    39063945    int             rc = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY);
    39073946    AssertReleaseRC(rc);
     
    39163955        {
    39173956            LogRel(("DPNIC#%d: The link is back up again after the restore.\n",
    3918                     pDevIns->iInstance));
    3919             LogFunc(("#%d: cLinkDownReported=%d\n", pDevIns->iInstance, pThis->cLinkDownReported));
     3957                    pThis->iInstance));
     3958            LogFunc(("#%d: cLinkDownReported=%d\n", pThis->iInstance, pThis->cLinkDownReported));
    39203959            pThis->Led.Actual.s.fError = 0;
    39213960        }
    39223961    }
    39233962    else
    3924         LogFunc(("#%d: cLinkDownReported=%d, wait another 1500ms...\n", pDevIns->iInstance, pThis->cLinkDownReported));
     3963        LogFunc(("#%d: cLinkDownReported=%d, wait another 1500ms...\n", pThis->iInstance, pThis->cLinkDownReported));
    39253964
    39263965    PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect);
     
    39353974static DECLCALLBACK(void) dpNicInfo(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs)
    39363975{
    3937     PDPNICSTATE     pThis = PDMINS_2_DATA(pDevIns, PDPNICSTATE);
     3976    PDPNICSTATE     pThis = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE);
    39383977    bool            fRecvBuffer  = false;
    39393978    bool            fSendBuffer  = false;
     
    39553994     */
    39563995    pHlp->pfnPrintf(pHlp, "DPNIC #%d: %s port=%RTiop IRQ=%u",
    3957                     pDevIns->iInstance,
     3996                    pThis->iInstance,
    39583997                    aszModels[pThis->uDevType],
    39593998                    pThis->IOPortBase,
     
    39634002    if (pThis->uIsaDma)
    39644003        pHlp->pfnPrintf(pHlp, " DMA=%u", pThis->uIsaDma);
    3965     pHlp->pfnPrintf(pHlp, " mac-cfg=%RTmac %s\n",
     4004    pHlp->pfnPrintf(pHlp, " mac-cfg=%RTmac%s %s\n",
    39664005                    &pThis->MacConfigured,
    3967                     pDevIns->fR0Enabled ? "RZ" : "");
     4006                    pDevIns->fR0Enabled ? " RZ" : "",
     4007                    pThis->fDriverAttached ? "attached" : "unattached!");
    39684008
    39694009    int const rcLock = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_INTERNAL_ERROR); /* Take it here so we know why we're hanging... */
     
    40664106    if (pThis->fMaybeOutOfSpace)
    40674107        pHlp->pfnPrintf(pHlp, "  Waiting for receive space\n");
     4108    if (pThis->cLinkDownReported)
     4109        pHlp->pfnPrintf(pHlp, "  Link down count %d\n", pThis->cLinkDownReported);
    40684110
    40694111    if ((pThis->uDevType == DEV_WD8003) || (pThis->uDevType == DEV_WD8013))
     
    41514193
    41524194
    4153 static void dpNicR3HardReset(PDPNICSTATE pThis)
    4154 {
    4155     LogFlowFunc(("#%d:\n", DPNIC_INSTANCE));
     4195static void dpNicR3HardReset(PPDMDEVINS pDevIns, PDPNICSTATE pThis)
     4196{
     4197    LogFlowFunc(("#%d:\n", pThis->iInstance));
    41564198
    41574199    /* Initialize the PROM. Covers both NE1000 and NE2000. */
     
    42234265    memset(&pThis->core, 0, sizeof(pThis->core));
    42244266
    4225     dp8390CoreReset(pThis);
     4267    dp8390CoreReset(pDevIns, pThis);
    42264268}
    42274269
     
    42354277 * renegotiate any DHCP lease.
    42364278 *
    4237  * @param  pThis        The device instance data.
    4238  */
    4239 static void dp8390TempLinkDown(PDPNICSTATE pThis)
     4279 * @param  pDevIns      The device instance data.
     4280 * @param  pThis        The device state.
     4281 */
     4282static void dp8390TempLinkDown(PPDMDEVINS pDevIns, PDPNICSTATE pThis)
    42404283{
    42414284    if (pThis->fLinkUp)
     
    42444287        pThis->cLinkDownReported = 0;
    42454288        pThis->Led.Asserted.s.fError = pThis->Led.Actual.s.fError = 1;
    4246         int rc = PDMDevHlpTimerSetMillies(DPNICSTATE_2_DEVINS(pThis), pThis->hTimerRestore, pThis->cMsLinkUpDelay);
     4289        int rc = PDMDevHlpTimerSetMillies(pDevIns, pThis->hTimerRestore, pThis->cMsLinkUpDelay);
    42474290        AssertRC(rc);
    42484291    }
     
    42584301{
    42594302    RT_NOREF(uPass);
    4260     PDPNICSTATE pThis = PDMINS_2_DATA(pDevIns, PDPNICSTATE);
     4303    PDPNICSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE);
    42614304    pDevIns->pHlpR3->pfnSSMPutMem(pSSM, &pThis->MacConfigured, sizeof(pThis->MacConfigured));
    42624305    return VINF_SSM_DONT_CALL_AGAIN;
     
    42714314{
    42724315    RT_NOREF(pSSM);
    4273     PDPNICSTATE pThis = PDMINS_2_DATA(pDevIns, PDPNICSTATE);
     4316    PDPNICSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE);
    42744317
    42754318    int rc = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY);
     
    42864329static DECLCALLBACK(int) dpNicSaveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
    42874330{
    4288     PDPNICSTATE     pThis = PDMINS_2_DATA(pDevIns, PDPNICSTATE);
     4331    PDPNICSTATE     pThis = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE);
    42894332    PCPDMDEVHLPR3   pHlp  = pDevIns->pHlpR3;
    42904333
     
    43594402static DECLCALLBACK(int) dpNicLoadPrep(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
    43604403{
    4361     PDPNICSTATE pThis = PDMINS_2_DATA(pDevIns, PDPNICSTATE);
     4404    PDPNICSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE);
    43624405    RT_NOREF(pSSM);
    43634406
     
    43764419static DECLCALLBACK(int) dpNicLoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
    43774420{
    4378     PDPNICSTATE     pThis = PDMINS_2_DATA(pDevIns, PDPNICSTATE);
    4379     PCPDMDEVHLPR3   pHlp  = pDevIns->pHlpR3;
     4421    PDPNICSTATE     pThis   = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE);
     4422    PDPNICSTATECC   pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PDPNICSTATECC);
     4423    PCPDMDEVHLPR3   pHlp    = pDevIns->pHlpR3;
    43804424
    43814425    if (SSM_VERSION_MAJOR_CHANGED(uVersion, DPNIC_SAVEDSTATE_VERSION))
     
    44524496    if (    memcmp(&Mac, &pThis->MacConfigured, sizeof(Mac))
    44534497        && (uPass == 0 || !PDMDevHlpVMTeleportedAndNotFullyResumedYet(pDevIns)) )
    4454         LogRel(("DPNIC#%u: The mac address differs: config=%RTmac saved=%RTmac\n", DPNIC_INSTANCE, &pThis->MacConfigured, &Mac));
     4498        LogRel(("DPNIC#%u: The mac address differs: config=%RTmac saved=%RTmac\n", pThis->iInstance, &pThis->MacConfigured, &Mac));
    44554499
    44564500    if (uPass == SSM_PASS_FINAL)
    44574501    {
    44584502        /* update promiscuous mode. */
    4459         if (pThis->pDrvR3)
    4460             pThis->pDrvR3->pfnSetPromiscuousMode(pThis->pDrvR3, 0 /* promiscuous enabled */);
     4503        if (pThisCC->pDrv)
     4504            pThisCC->pDrv->pfnSetPromiscuousMode(pThisCC->pDrv, 0 /* promiscuous enabled */);
    44614505
    44624506        /* Indicate link down to the guest OS that all network connections have
    44634507           been lost, unless we've been teleported here. */
    44644508        if (!PDMDevHlpVMTeleportedAndNotFullyResumedYet(pDevIns))
    4465             dp8390TempLinkDown(pThis);
     4509            dp8390TempLinkDown(pDevIns, pThis);
    44664510    }
    44674511
     
    45254569                free_pages = pCore->BNRY - pCore->CURR;
    45264570            }
    4527             Log2Func(("#%d: %u free pages (%u bytes)\n", DPNIC_INSTANCE, free_pages, free_pages * 256));
     4571            Log2Func(("#%d: %u free pages (%u bytes)\n", pThis->iInstance, free_pages, free_pages * 256));
    45284572
    45294573            /* Six pages (1,536 bytes) is enough for the longest standard Ethernet frame
     
    45334577            {
    45344578                rc = VERR_NET_NO_BUFFER_SPACE;
    4535                 Log2Func(("#%d: Buffer space low, returning %Rrc!\n", DPNIC_INSTANCE, rc));
     4579                Log2Func(("#%d: Buffer space low, returning %Rrc!\n", pThis->iInstance, rc));
    45364580            }
    45374581        }
     
    45484592static DECLCALLBACK(int) dpNicNet_WaitReceiveAvail(PPDMINETWORKDOWN pInterface, RTMSINTERVAL cMillies)
    45494593{
    4550     PDPNICSTATE pThis = RT_FROM_MEMBER(pInterface, DPNICSTATE, INetworkDown);
    4551     PPDMDEVINS pDevIns = DPNICSTATE_2_DEVINS(pThis);
     4594    PDPNICSTATECC   pThisCC = RT_FROM_MEMBER(pInterface, DPNICSTATECC, INetworkDown);
     4595    PPDMDEVINS      pDevIns = pThisCC->pDevIns;
     4596    PDPNICSTATE     pThis   = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE);
    45524597
    45534598    int rc = dp8390CanReceive(pDevIns, pThis);
     
    45674612    STAM_PROFILE_START(&pThis->StatRxOverflow, a);
    45684613    VMSTATE enmVMState;
    4569     while (RT_LIKELY(   (enmVMState = PDMDevHlpVMState(pThis->CTX_SUFF(pDevIns))) == VMSTATE_RUNNING
     4614    while (RT_LIKELY(   (enmVMState = PDMDevHlpVMState(pDevIns)) == VMSTATE_RUNNING
    45704615                     || enmVMState == VMSTATE_RUNNING_LS))
    45714616    {
     
    45974642static DECLCALLBACK(int) dpNicNet_Receive(PPDMINETWORKDOWN pInterface, const void *pvBuf, size_t cb)
    45984643{
    4599     PDPNICSTATE     pThis = RT_FROM_MEMBER(pInterface, DPNICSTATE, INetworkDown);
    4600     PPDMDEVINS      pDevIns = DPNICSTATE_2_DEVINS(pThis);
     4644    PDPNICSTATECC   pThisCC = RT_FROM_MEMBER(pInterface, DPNICSTATECC, INetworkDown);
     4645    PPDMDEVINS      pDevIns = pThisCC->pDevIns;
     4646    PDPNICSTATE     pThis   = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE);
    46014647    int             rc;
    46024648
     
    46074653    if (cb > 50) /* unqualified guess */
    46084654        pThis->Led.Asserted.s.fReading = pThis->Led.Actual.s.fReading = 1;
    4609     dp8390CoreReceiveLocked(pThis, (const uint8_t *)pvBuf, cb);
     4655    dp8390CoreReceiveLocked(pDevIns, pThis, (const uint8_t *)pvBuf, cb);
    46104656    pThis->Led.Actual.s.fReading = 0;
    46114657
     
    46224668static DECLCALLBACK(void) dpNicNet_XmitPending(PPDMINETWORKDOWN pInterface)
    46234669{
    4624     PDPNICSTATE pThis = RT_FROM_MEMBER(pInterface, DPNICSTATE, INetworkDown);
    4625     dp8390CoreXmitPacket(pThis, true /*fOnWorkerThread*/);
     4670    PDPNICSTATECC   pThisCC = RT_FROM_MEMBER(pInterface, DPNICSTATECC, INetworkDown);
     4671    PPDMDEVINS      pDevIns = pThisCC->pDevIns;
     4672    PDPNICSTATE     pThis   = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE);
     4673    dp8390CoreXmitPacket(pDevIns, pThis, true /*fOnWorkerThread*/);
    46264674}
    46274675
     
    46344682static DECLCALLBACK(int) dpNicGetMac(PPDMINETWORKCONFIG pInterface, PRTMAC pMac)
    46354683{
    4636     PDPNICSTATE pThis = RT_FROM_MEMBER(pInterface, DPNICSTATE, INetworkConfig);
     4684    PDPNICSTATECC   pThisCC = RT_FROM_MEMBER(pInterface, DPNICSTATECC, INetworkConfig);
     4685    PPDMDEVINS      pDevIns = pThisCC->pDevIns;
     4686    PDPNICSTATE     pThis   = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE);
     4687
     4688    LogFlowFunc(("#%d\n", pThis->iInstance));
    46374689    /// @todo This is broken!! We can't properly get the MAC address set by the guest
    46384690#if 0
    4639     memcpy(pMac, pThis->aStationAddr, sizeof(*pMac));
     4691    memcpy(pMac, pThis->core.pg1.PAR, sizeof(*pMac));
    46404692#else
    46414693    memcpy(pMac, pThis->aPROM, sizeof(*pMac));
     
    46504702static DECLCALLBACK(PDMNETWORKLINKSTATE) dpNicGetLinkState(PPDMINETWORKCONFIG pInterface)
    46514703{
    4652     PDPNICSTATE pThis = RT_FROM_MEMBER(pInterface, DPNICSTATE, INetworkConfig);
     4704    PDPNICSTATECC   pThisCC = RT_FROM_MEMBER(pInterface, DPNICSTATECC, INetworkConfig);
     4705    PPDMDEVINS      pDevIns = pThisCC->pDevIns;
     4706    PDPNICSTATE     pThis   = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE);
     4707
    46534708    if (pThis->fLinkUp && !pThis->fLinkTempDown)
    46544709        return PDMNETWORKLINKSTATE_UP;
     
    46674722static DECLCALLBACK(int) dpNicSetLinkState(PPDMINETWORKCONFIG pInterface, PDMNETWORKLINKSTATE enmState)
    46684723{
    4669     PDPNICSTATE pThis = RT_FROM_MEMBER(pInterface, DPNICSTATE, INetworkConfig);
    4670     bool fLinkUp;
    4671 
    4672     LogFlowFunc(("#%d\n", DPNIC_INSTANCE));
     4724    PDPNICSTATECC   pThisCC = RT_FROM_MEMBER(pInterface, DPNICSTATECC, INetworkConfig);
     4725    PPDMDEVINS      pDevIns = pThisCC->pDevIns;
     4726    PDPNICSTATE     pThis   = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE);
     4727    bool            fLinkUp;
     4728
     4729    LogFlowFunc(("#%d\n", pThis->iInstance));
    46734730    AssertMsgReturn(enmState > PDMNETWORKLINKSTATE_INVALID && enmState <= PDMNETWORKLINKSTATE_DOWN_RESUME,
    46744731                    ("Invalid link state: enmState=%d\n", enmState), VERR_INVALID_PARAMETER);
     
    46764733    if (enmState == PDMNETWORKLINKSTATE_DOWN_RESUME)
    46774734    {
    4678         dp8390TempLinkDown(pThis);
     4735        dp8390TempLinkDown(pDevIns, pThis);
    46794736        /*
    46804737         * Note that we do not notify the driver about the link state change because
     
    46954752            pThis->cLinkDownReported = 0;
    46964753            pThis->Led.Asserted.s.fError = pThis->Led.Actual.s.fError = 1;
    4697             int rc = PDMDevHlpTimerSetMillies(DPNICSTATE_2_DEVINS(pThis), pThis->hTimerRestore, pThis->cMsLinkUpDelay);
     4754            int rc = PDMDevHlpTimerSetMillies(pDevIns, pThis->hTimerRestore, pThis->cMsLinkUpDelay);
    46984755            AssertRC(rc);
    46994756        }
     
    47044761            pThis->Led.Asserted.s.fError = pThis->Led.Actual.s.fError = 1;
    47054762        }
    4706         Assert(!PDMDevHlpCritSectIsOwner(DPNICSTATE_2_DEVINS(pThis), &pThis->CritSect));
    4707         if (pThis->pDrvR3)
    4708             pThis->pDrvR3->pfnNotifyLinkChanged(pThis->pDrvR3, enmState);
     4763        Assert(!PDMDevHlpCritSectIsOwner(pDevIns, &pThis->CritSect));
     4764        if (pThisCC->pDrv)
     4765            pThisCC->pDrv->pfnNotifyLinkChanged(pThisCC->pDrv, enmState);
    47094766    }
    47104767    return VINF_SUCCESS;
     
    47194776static DECLCALLBACK(int) dpNicQueryStatusLed(PPDMILEDPORTS pInterface, unsigned iLUN, PPDMLED *ppLed)
    47204777{
    4721     PDPNICSTATE pThis = RT_FROM_MEMBER(pInterface, DPNICSTATE, ILeds);
     4778    PDPNICSTATECC   pThisCC = RT_FROM_MEMBER(pInterface, DPNICSTATECC, ILeds);
     4779    PPDMDEVINS      pDevIns = pThisCC->pDevIns;
     4780    PDPNICSTATE     pThis   = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE);
    47224781    if (iLUN == 0)
    47234782    {
     
    47364795static DECLCALLBACK(void *) dpNicQueryInterface(struct PDMIBASE *pInterface, const char *pszIID)
    47374796{
    4738     PDPNICSTATE pThis = RT_FROM_MEMBER(pInterface, DPNICSTATE, IBase);
    4739     Assert(&pThis->IBase == pInterface);
    4740     PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pThis->IBase);
    4741     PDMIBASE_RETURN_INTERFACE(pszIID, PDMINETWORKDOWN, &pThis->INetworkDown);
    4742     PDMIBASE_RETURN_INTERFACE(pszIID, PDMINETWORKCONFIG, &pThis->INetworkConfig);
    4743     PDMIBASE_RETURN_INTERFACE(pszIID, PDMILEDPORTS, &pThis->ILeds);
     4797    PDPNICSTATECC pThisCC = RT_FROM_MEMBER(pInterface, DPNICSTATECC, IBase);
     4798    Assert(&pThisCC->IBase == pInterface);
     4799    PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pThisCC->IBase);
     4800    PDMIBASE_RETURN_INTERFACE(pszIID, PDMINETWORKDOWN, &pThisCC->INetworkDown);
     4801    PDMIBASE_RETURN_INTERFACE(pszIID, PDMINETWORKCONFIG, &pThisCC->INetworkConfig);
     4802    PDMIBASE_RETURN_INTERFACE(pszIID, PDMILEDPORTS, &pThisCC->ILeds);
    47444803    return NULL;
    47454804}
     
    47514810 * @interface_method_impl{PDMDEVREG,pfnPowerOff}
    47524811 */
    4753 static DECLCALLBACK(void) dpNicPowerOff(PPDMDEVINS pDevIns)
     4812static DECLCALLBACK(void) dpNicR3PowerOff(PPDMDEVINS pDevIns)
    47544813{
    47554814    /* Poke thread waiting for buffer space. */
    4756     dp8390WakeupReceive(pDevIns);
     4815    dp8390R3WakeupReceive(pDevIns);
    47574816}
    47584817
     
    47634822 * One port on the network card has been disconnected from the network.
    47644823 */
    4765 static DECLCALLBACK(void) dpNicDetach(PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags)
    4766 {
     4824static DECLCALLBACK(void) dpNicR3Detach(PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags)
     4825{
     4826    PDPNICSTATE     pThis   = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE);
     4827    PDPNICSTATECC   pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PDPNICSTATECC);
    47674828    RT_NOREF(fFlags);
    4768     PDPNICSTATE pThis = PDMINS_2_DATA(pDevIns, PDPNICSTATE);
    4769     LogFlowFunc(("#%d\n", DPNIC_INSTANCE));
     4829    LogFlowFunc(("#%d\n", pThis->iInstance));
    47704830
    47714831    AssertLogRelReturnVoid(iLUN == 0);
     
    47774837     * Zero some important members.
    47784838     */
    4779     pThis->pDrvBase = NULL;
    4780     pThis->pDrvR3 = NULL;
    4781     pThis->pDrvR0 = NIL_RTR0PTR;
    4782     pThis->pDrvRC = NIL_RTRCPTR;
     4839    pThis->fDriverAttached = false;
     4840    pThisCC->pDrvBase = NULL;
     4841    pThisCC->pDrv     = NULL;
    47834842
    47844843    PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect);
     
    47904849 * One port on the network card has been connected to a network.
    47914850 */
    4792 static DECLCALLBACK(int) dpNicAttach(PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags)
    4793 {
     4851static DECLCALLBACK(int) dpNicR3Attach(PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags)
     4852{
     4853    PDPNICSTATE      pThis   = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE);
     4854    PDPNICSTATECC    pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PDPNICSTATECC);
    47944855    RT_NOREF(fFlags);
    4795     PDPNICSTATE pThis = PDMINS_2_DATA(pDevIns, PDPNICSTATE);
    4796     LogFlowFunc(("#%d\n", DPNIC_INSTANCE));
     4856    LogFlowFunc(("#%d\n", pThis->iInstance));
    47974857
    47984858    AssertLogRelReturn(iLUN == 0, VERR_PDM_NO_SUCH_LUN);
     
    48044864     * Attach the driver.
    48054865     */
    4806     int rc = PDMDevHlpDriverAttach(pDevIns, 0, &pThis->IBase, &pThis->pDrvBase, "Network Port");
     4866    int rc = PDMDevHlpDriverAttach(pDevIns, 0, &pThisCC->IBase, &pThisCC->pDrvBase, "Network Port");
    48074867    if (RT_SUCCESS(rc))
    48084868    {
    4809         pThis->pDrvR3 = PDMIBASE_QUERY_INTERFACE(pThis->pDrvBase, PDMINETWORKUP);
    4810         AssertMsgStmt(pThis->pDrvR3, ("Failed to obtain the PDMINETWORKUP interface!\n"),
     4869        pThisCC->pDrv = PDMIBASE_QUERY_INTERFACE(pThisCC->pDrvBase, PDMINETWORKUP);
     4870        AssertMsgStmt(pThisCC->pDrv, ("Failed to obtain the PDMINETWORKUP interface!\n"),
    48114871                      rc = VERR_PDM_MISSING_INTERFACE_BELOW);
    4812         pThis->pDrvR0 = PDMIBASER0_QUERY_INTERFACE(PDMIBASE_QUERY_INTERFACE(pThis->pDrvBase, PDMIBASER0), PDMINETWORKUP);
    4813         pThis->pDrvRC = PDMIBASERC_QUERY_INTERFACE(PDMIBASE_QUERY_INTERFACE(pThis->pDrvBase, PDMIBASERC), PDMINETWORKUP);
     4872        pThis->fDriverAttached = true;
    48144873    }
    48154874    else if (   rc == VERR_PDM_NO_ATTACHED_DRIVER
     
    48184877        /* This should never happen because this function is not called
    48194878         * if there is no driver to attach! */
    4820         LogFunc(("#%d No attached driver!\n", DPNIC_INSTANCE));
     4879        LogFunc(("#%d No attached driver!\n", pThis->iInstance));
    48214880    }
    48224881
     
    48274886     */
    48284887    if (RT_SUCCESS(rc))
    4829         dp8390TempLinkDown(pThis);
     4888        dp8390TempLinkDown(pDevIns, pThis);
    48304889
    48314890    PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect);
     
    48374896 * @interface_method_impl{PDMDEVREG,pfnSuspend}
    48384897 */
    4839 static DECLCALLBACK(void) dpNicSuspend(PPDMDEVINS pDevIns)
     4898static DECLCALLBACK(void) dpNicR3Suspend(PPDMDEVINS pDevIns)
    48404899{
    48414900    /* Poke thread waiting for buffer space. */
    4842     dp8390WakeupReceive(pDevIns);
     4901    dp8390R3WakeupReceive(pDevIns);
    48434902}
    48444903
     
    48474906 * @interface_method_impl{PDMDEVREG,pfnReset}
    48484907 */
    4849 static DECLCALLBACK(void) dpNicReset(PPDMDEVINS pDevIns)
    4850 {
    4851     PDPNICSTATE pThis = PDMINS_2_DATA(pDevIns, PDPNICSTATE);
    4852     LogFlowFunc(("#%d\n", DPNIC_INSTANCE));
     4908static DECLCALLBACK(void) dpNicR3Reset(PPDMDEVINS pDevIns)
     4909{
     4910    PDPNICSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE);
     4911    LogFlowFunc(("#%d\n", pThis->iInstance));
    48534912    if (pThis->fLinkTempDown)
    48544913    {
     
    48584917    }
    48594918
    4860     dpNicR3HardReset(pThis);
     4919    dpNicR3HardReset(pDevIns, pThis);
    48614920}
    48624921
     
    48654924 * @interface_method_impl{PDMDEVREG,pfnRelocate}
    48664925 */
    4867 static DECLCALLBACK(void) dpNicRelocate(PPDMDEVINS pDevIns, RTGCINTPTR offDelta)
    4868 {
    4869     RT_NOREF(offDelta);
    4870     PDPNICSTATE pThis   = PDMINS_2_DATA(pDevIns, PDPNICSTATE);
    4871     pThis->pDevInsRC    = PDMDEVINS_2_RCPTR(pDevIns);
     4926static DECLCALLBACK(void) dpNicR3Relocate(PPDMDEVINS pDevIns, RTGCINTPTR offDelta)
     4927{
     4928    PDPNICSTATERC pThisRC = PDMINS_2_DATA_RC(pDevIns, PDPNICSTATERC);
     4929    pThisRC->pDrv += offDelta;
    48724930}
    48734931
     
    48764934 * @interface_method_impl{PDMDEVREG,pfnDestruct}
    48774935 */
    4878 static DECLCALLBACK(int) dpNicDestruct(PPDMDEVINS pDevIns)
     4936static DECLCALLBACK(int) dpNicR3Destruct(PPDMDEVINS pDevIns)
    48794937{
    48804938    PDMDEV_CHECK_VERSIONS_RETURN_QUIET(pDevIns);
    4881     PDPNICSTATE pThis = PDMINS_2_DATA(pDevIns, PDPNICSTATE);
     4939    PDPNICSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE);
    48824940
    48834941    if (PDMDevHlpCritSectIsInitialized(pDevIns, &pThis->CritSect))
     
    48954953 * @interface_method_impl{PDMDEVREG,pfnConstruct}
    48964954 */
    4897 static DECLCALLBACK(int) dpNicConstruct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfg)
     4955static DECLCALLBACK(int) dpNicR3Construct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfg)
    48984956{
    48994957    PDMDEV_CHECK_VERSIONS_RETURN(pDevIns);
    4900     PDPNICSTATE     pThis = PDMINS_2_DATA(pDevIns, PDPNICSTATE);
     4958    PDPNICSTATE     pThis   = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE);
     4959    PDPNICSTATECC   pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PDPNICSTATECC);
    49014960    PCPDMDEVHLPR3   pHlp  = pDevIns->pHlpR3;
    49024961    PPDMIBASE       pBase;
     
    49114970    pThis->hIoPortsNic          = NIL_IOMIOPORTHANDLE;
    49124971    pThis->hIoPortsCore         = NIL_IOMIOPORTHANDLE;
     4972    pThisCC->pDevIns            = pDevIns;
    49134973
    49144974    /*
     
    50265086     * Initialize data (most of it anyway).
    50275087     */
    5028     pThis->pDevInsR3                        = pDevIns;
    5029     pThis->pDevInsR0                        = PDMDEVINS_2_R0PTR(pDevIns);
    5030     pThis->pDevInsRC                        = PDMDEVINS_2_RCPTR(pDevIns);
    5031     pThis->Led.u32Magic                     = PDMLED_MAGIC;
     5088    pThis->Led.u32Magic                       = PDMLED_MAGIC;
    50325089    /* IBase */
    5033     pThis->IBase.pfnQueryInterface          = dpNicQueryInterface;
     5090    pThisCC->IBase.pfnQueryInterface          = dpNicQueryInterface;
    50345091    /* INetworkPort */
    5035     pThis->INetworkDown.pfnWaitReceiveAvail = dpNicNet_WaitReceiveAvail;
    5036     pThis->INetworkDown.pfnReceive          = dpNicNet_Receive;
    5037     pThis->INetworkDown.pfnXmitPending      = dpNicNet_XmitPending;
     5092    pThisCC->INetworkDown.pfnWaitReceiveAvail = dpNicNet_WaitReceiveAvail;
     5093    pThisCC->INetworkDown.pfnReceive          = dpNicNet_Receive;
     5094    pThisCC->INetworkDown.pfnXmitPending      = dpNicNet_XmitPending;
    50385095    /* INetworkConfig */
    5039     pThis->INetworkConfig.pfnGetMac         = dpNicGetMac;
    5040     pThis->INetworkConfig.pfnGetLinkState   = dpNicGetLinkState;
    5041     pThis->INetworkConfig.pfnSetLinkState   = dpNicSetLinkState;
     5096    pThisCC->INetworkConfig.pfnGetMac         = dpNicGetMac;
     5097    pThisCC->INetworkConfig.pfnGetLinkState   = dpNicGetLinkState;
     5098    pThisCC->INetworkConfig.pfnSetLinkState   = dpNicSetLinkState;
    50425099    /* ILeds */
    5043     pThis->ILeds.pfnQueryStatusLed          = dpNicQueryStatusLed;
     5100    pThisCC->ILeds.pfnQueryStatusLed          = dpNicQueryStatusLed;
    50445101
    50455102    pThis->hIoPortsCore = NIL_IOMIOPORTHANDLE;
     
    51765233     * Register the info item.
    51775234     */
    5178     RTStrPrintf(szTmp, sizeof(szTmp), "dpnic%d", pDevIns->iInstance);
     5235    RTStrPrintf(szTmp, sizeof(szTmp), "dpnic%d", pThis->iInstance);
    51795236    PDMDevHlpDBGFInfoRegister(pDevIns, szTmp, "dpnic info", dpNicInfo);
    51805237
     
    51825239     * Attach status driver (optional).
    51835240     */
    5184     rc = PDMDevHlpDriverAttach(pDevIns, PDM_STATUS_LUN, &pThis->IBase, &pBase, "Status Port");
     5241    rc = PDMDevHlpDriverAttach(pDevIns, PDM_STATUS_LUN, &pThisCC->IBase, &pBase, "Status Port");
    51855242    if (RT_SUCCESS(rc))
    5186         pThis->pLedsConnector = PDMIBASE_QUERY_INTERFACE(pBase, PDMILEDCONNECTORS);
     5243        pThisCC->pLedsConnector = PDMIBASE_QUERY_INTERFACE(pBase, PDMILEDCONNECTORS);
    51875244    else if (   rc != VERR_PDM_NO_ATTACHED_DRIVER
    51885245             && rc != VERR_PDM_CFG_MISSING_DRIVER_NAME)
     
    51955252     * Attach driver.
    51965253     */
    5197     rc = PDMDevHlpDriverAttach(pDevIns, 0, &pThis->IBase, &pThis->pDrvBase, "Network Port");
     5254    rc = PDMDevHlpDriverAttach(pDevIns, 0, &pThisCC->IBase, &pThisCC->pDrvBase, "Network Port");
    51985255    if (RT_SUCCESS(rc))
    51995256    {
    5200         pThis->pDrvR3 = PDMIBASE_QUERY_INTERFACE(pThis->pDrvBase, PDMINETWORKUP);
    5201         AssertMsgReturn(pThis->pDrvR3, ("Failed to obtain the PDMINETWORKUP interface!\n"),
     5257        pThisCC->pDrv = PDMIBASE_QUERY_INTERFACE(pThisCC->pDrvBase, PDMINETWORKUP);
     5258        AssertMsgReturn(pThisCC->pDrv, ("Failed to obtain the PDMINETWORKUP interface!\n"),
    52025259                        VERR_PDM_MISSING_INTERFACE_BELOW);
    5203         pThis->pDrvR0 = PDMIBASER0_QUERY_INTERFACE(PDMIBASE_QUERY_INTERFACE(pThis->pDrvBase, PDMIBASER0), PDMINETWORKUP);
    5204         pThis->pDrvRC = PDMIBASERC_QUERY_INTERFACE(PDMIBASE_QUERY_INTERFACE(pThis->pDrvBase, PDMIBASERC), PDMINETWORKUP);
     5260        pThis->fDriverAttached = true;
    52055261    }
    52065262    else if (   rc == VERR_PDM_NO_ATTACHED_DRIVER
     
    52165272     * Reset the device state. (Do after attaching.)
    52175273     */
    5218     dpNicR3HardReset(pThis);
     5274    dpNicR3HardReset(pDevIns, pThis);
    52195275
    52205276    /*
     
    53435399    /* .uSharedVersion = */         42,
    53445400    /* .cbInstanceShared = */       sizeof(DPNICSTATE),
    5345     /* .cbInstanceCC = */           0,
    5346     /* .cbInstanceRC = */           0,
     5401    /* .cbInstanceCC = */           sizeof(DPNICSTATECC),
     5402    /* .cbInstanceRC = */           sizeof(DPNICSTATERC),
    53475403    /* .cMaxPciDevices = */         0,
    53485404    /* .cMaxMsixVectors = */        0,
     
    53515407    /* .pszRCMod = */               "VBoxDDRC.rc",
    53525408    /* .pszR0Mod = */               "VBoxDDR0.r0",
    5353     /* .pfnConstruct = */           dpNicConstruct,
    5354     /* .pfnDestruct = */            dpNicDestruct,
    5355     /* .pfnRelocate = */            dpNicRelocate,
     5409    /* .pfnConstruct = */           dpNicR3Construct,
     5410    /* .pfnDestruct = */            dpNicR3Destruct,
     5411    /* .pfnRelocate = */            dpNicR3Relocate,
    53565412    /* .pfnMemSetup = */            NULL,
    53575413    /* .pfnPowerOn = */             NULL,
    5358     /* .pfnReset = */               dpNicReset,
    5359     /* .pfnSuspend = */             dpNicSuspend,
     5414    /* .pfnReset = */               dpNicR3Reset,
     5415    /* .pfnSuspend = */             dpNicR3Suspend,
    53605416    /* .pfnResume = */              NULL,
    5361     /* .pfnAttach = */              dpNicAttach,
    5362     /* .pfnDetach = */              dpNicDetach,
     5417    /* .pfnAttach = */              dpNicR3Attach,
     5418    /* .pfnDetach = */              dpNicR3Detach,
    53635419    /* .pfnQueryInterface = */      NULL,
    53645420    /* .pfnInitComplete = */        NULL,
    5365     /* .pfnPowerOff = */            dpNicPowerOff,
     5421    /* .pfnPowerOff = */            dpNicR3PowerOff,
    53665422    /* .pfnSoftReset = */           NULL,
    53675423    /* .pfnReserved0 = */           NULL,
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