VirtualBox

Changeset 11199 in vbox for trunk/src/VBox


Ignore:
Timestamp:
Aug 6, 2008 11:02:45 PM (17 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
34235
Message:

#1865: DevPCNet.

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

Legend:

Unmodified
Added
Removed

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

    r11163 r11199  
    11/* $Id$ */
    22/** @file
    3  * AMD PCnet-PCI II / PCnet-FAST III (Am79C970A / Am79C973) Ethernet Controller Emulation.
     3 * DevPCNet - AMD PCnet-PCI II / PCnet-FAST III (Am79C970A / Am79C973) Ethernet Controller Emulation.
     4 *
     5 * This software was written to be compatible with the specifications:
     6 *      AMD Am79C970A PCnet-PCI II Ethernet Controller Data-Sheet
     7 *      AMD Publication# 19436  Rev:E  Amendment/0  Issue Date: June 2000
     8 * and
     9 *      todo
    410 */
    511
    … …  
    4349 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
    4450 * THE SOFTWARE.
    45  */
    46 
    47 /* This software was written to be compatible with the specification:
    48  * AMD Am79C970A PCnet-PCI II Ethernet Controller Data-Sheet
    49  * AMD Publication# 19436  Rev:E  Amendment/0  Issue Date: June 2000
    5051 */
    5152
    … …  
    6869#endif
    6970
    70 #include "Builtins.h"
     71#include "../Builtins.h"
    7172
    7273/* Enable this to catch writes to the ring descriptors instead of using excessive polling */
    … …  
    111112    PCIDEVICE                           PciDev;
    112113#ifndef PCNET_NO_POLLING
    113     /** Poll timer (address for host context) */
    114     R3R0PTRTYPE(PTMTIMER)               pTimerPollHC;
    115     /** Poll timer (address for guest context) */
    116     RCPTRTYPE(PTMTIMER)                 pTimerPollGC;
     114    /** Poll timer - R3. */
     115    PTMTIMERR3                          pTimerPollR3;
     116    /** Poll timer - R0. */
     117    PTMTIMERR0                          pTimerPollR0;
     118    /** Poll timer - RC. */
     119    PTMTIMERRC                          pTimerPollRC;
    117120#endif
    118121
    … …  
    121124#endif
    122125
    123     /** Software Interrupt timer (address for host context) */
    124     R3R0PTRTYPE(PTMTIMER)               pTimerSoftIntHC;
    125     /** Software Interrupt timer (address for guest context) */
    126     RCPTRTYPE(PTMTIMER)                 pTimerSoftIntGC;
     126    /** Software Interrupt timer - R3. */
     127    PTMTIMERR3                          pTimerSoftIntR3;
     128    /** Software Interrupt timer - R0. */
     129    PTMTIMERR0                          pTimerSoftIntR0;
     130    /** Software Interrupt timer - RC. */
     131    PTMTIMERRC                          pTimerSoftIntRC;
    127132
    128133    /** Register Address Pointer */
    … …  
    165170    RTGCPHYS32                          GCUpperPhys;
    166171
    167     /** Transmit signaller */
    168     RCPTRTYPE(PPDMQUEUE)                pXmitQueueGC;
    169     R3R0PTRTYPE(PPDMQUEUE)              pXmitQueueHC;
    170 
    171     /** Receive signaller */
    172     R3R0PTRTYPE(PPDMQUEUE)              pCanRxQueueHC;
    173     RCPTRTYPE(PPDMQUEUE)                pCanRxQueueGC;
    174     /** Pointer to the device instance. */
    175     RCPTRTYPE(PPDMDEVINS)               pDevInsGC;
    176     /** Pointer to the device instance. */
    177     R3R0PTRTYPE(PPDMDEVINS)             pDevInsHC;
     172    /** Transmit signaller - RC. */
     173    RCPTRTYPE(PPDMQUEUE)                pXmitQueueRC;
     174    /** Transmit signaller - R3. */
     175    R3PTRTYPE(PPDMQUEUE)                pXmitQueueR3;
     176    /** Transmit signaller - R0. */
     177    R0PTRTYPE(PPDMQUEUE)                pXmitQueueR0;
     178
     179    /** Receive signaller - R3. */
     180    R3PTRTYPE(PPDMQUEUE)                pCanRxQueueR3;
     181    /** Receive signaller - R0. */
     182    R0PTRTYPE(PPDMQUEUE)                pCanRxQueueR0;
     183    /** Receive signaller - RC. */
     184    RCPTRTYPE(PPDMQUEUE)                pCanRxQueueRC;
     185    /** Pointer to the device instance - RC. */
     186    PPDMDEVINSRC                        pDevInsRC;
     187    /** Pointer to the device instance - R3. */
     188    PPDMDEVINSR3                        pDevInsR3;
     189    /** Pointer to the device instance - R0. */
     190    PPDMDEVINSR0                        pDevInsR0;
    178191    /** Restore timer.
    179192     *  This is used to disconnect and reconnect the link after a restore. */
    … …  
    234247    uint32_t                            cbRDRAOld;
    235248
    236     DECLGCCALLBACKMEMBER(int, pfnEMInterpretInstructionGC, (PVM pVM, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize));
     249    DECLRCCALLBACKMEMBER(int, pfnEMInterpretInstructionRC, (PVM pVM, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize));
    237250    DECLR0CALLBACKMEMBER(int, pfnEMInterpretInstructionR0, (PVM pVM, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize));
    238251#endif
    239252
    240     /** The host context of the shared memory used for the private interface. */
    241     R3R0PTRTYPE(PPCNETGUESTSHAREDMEMORY) pSharedMMIOHC;
    242     /** The hypervisor/guest context of the shared memory used for the private interface. */
    243     RCPTRTYPE(PPCNETGUESTSHAREDMEMORY)  pSharedMMIOGC;
     253    /** The shared memory used for the private interface - R3. */
     254    R3PTRTYPE(PPCNETGUESTSHAREDMEMORY)  pSharedMMIOR3;
     255    /** The shared memory used for the private interface - R0. */
     256    R0PTRTYPE(PPCNETGUESTSHAREDMEMORY)  pSharedMMIOR0;
     257    /** The shared memory used for the private interface - RC. */
     258    RCPTRTYPE(PPCNETGUESTSHAREDMEMORY)  pSharedMMIORC;
    244259
    245260#if HC_ARCH_BITS == 64
    … …  
    255270
    256271#ifdef PCNET_QUEUE_SEND_PACKETS
    257     #define PCNET_MAX_XMIT_SLOTS         128
    258     #define PCNET_MAX_XMIT_SLOTS_MASK    (PCNET_MAX_XMIT_SLOTS-1)
     272# define PCNET_MAX_XMIT_SLOTS           128
     273# define PCNET_MAX_XMIT_SLOTS_MASK      (PCNET_MAX_XMIT_SLOTS - 1)
    259274
    260275    uint32_t                            iXmitRingBufProd;
    261276    uint32_t                            iXmitRingBufCons;
    262     /* XXX currently atomic operations on this variable are overkill */
     277    /** @todo XXX currently atomic operations on this variable are overkill */
    263278    volatile int32_t                    cXmitRingBufPending;
    264279    uint16_t                            cbXmitRingBuffer[PCNET_MAX_XMIT_SLOTS];
    … …  
    315330};
    316331
    317 #define PCNETSTATE_2_DEVINS(pPCNet)            ((pPCNet)->CTXSUFF(pDevIns))
     332#define PCNETSTATE_2_DEVINS(pPCNet)            ((pPCNet)->CTX_SUFF(pDevIns))
    318333#define PCIDEV_2_PCNETSTATE(pPciDev)           ((PCNetState *)(pPciDev))
    319334#define PCNET_INST_NR                          (PCNETSTATE_2_DEVINS(pData)->iInstance)
    … …  
    619634    {
    620635        /* RX/TX descriptors shared between host and guest => direct copy */
    621         uint8_t *pv = (uint8_t*)pData->CTXSUFF(pSharedMMIO)
     636        uint8_t *pv = (uint8_t*)pData->CTX_SUFF(pSharedMMIO)
    622637                    + (addr - pData->GCTDRA)
    623                     + pData->CTXSUFF(pSharedMMIO)->V.V1.offTxDescriptors;
     638                    + pData->CTX_SUFF(pSharedMMIO)->V.V1.offTxDescriptors;
    624639        if (!(pv[7] & 0x80) && fRetIfNotOwn)
    625640            return false;
    … …  
    681696    {
    682697        /* RX/TX descriptors shared between host and guest => direct copy */
    683         uint8_t *pv = (uint8_t*)pData->CTXSUFF(pSharedMMIO)
     698        uint8_t *pv = (uint8_t*)pData->CTX_SUFF(pSharedMMIO)
    684699                    + (addr - pData->GCTDRA)
    685                     + pData->CTXSUFF(pSharedMMIO)->V.V1.offTxDescriptors;
     700                    + pData->CTX_SUFF(pSharedMMIO)->V.V1.offTxDescriptors;
    686701        memcpy(pv, tmd, 16);
    687702        pv[7] &= ~0x80;
    … …  
    738753    {
    739754        /* RX/TX descriptors shared between host and guest => direct copy */
    740         uint8_t *pb = (uint8_t*)pData->CTXSUFF(pSharedMMIO)
     755        uint8_t *pb = (uint8_t*)pData->CTX_SUFF(pSharedMMIO)
    741756                    + (addr - pData->GCRDRA)
    742                     + pData->CTXSUFF(pSharedMMIO)->V.V1.offRxDescriptors;
     757                    + pData->CTX_SUFF(pSharedMMIO)->V.V1.offRxDescriptors;
    743758        if (!(pb[7] & 0x80) && fRetIfNotOwn)
    744759            return false;
    … …  
    798813    {
    799814        /* RX/TX descriptors shared between host and guest => direct copy */
    800         uint8_t *pv = (uint8_t*)pData->CTXSUFF(pSharedMMIO)
     815        uint8_t *pv = (uint8_t*)pData->CTX_SUFF(pSharedMMIO)
    801816                    + (addr - pData->GCRDRA)
    802                     + pData->CTXSUFF(pSharedMMIO)->V.V1.offRxDescriptors;
     817                    + pData->CTX_SUFF(pSharedMMIO)->V.V1.offRxDescriptors;
    803818        memcpy(pv, rmd, 16);
    804819        pv[7] &= ~0x80;
    … …  
    853868#define ETH_ALEN 6
    854869#pragma pack(1)
    855 struct ether_header
     870struct ether_header /** @todo Use RTNETETHERHDR */
    856871{
    857872    uint8_t  ether_dhost[ETH_ALEN]; /**< destination ethernet address */
    … …  
    885900{
    886901    /* Clear the entire block for pcnetReset usage. */
    887     memset(pData->pSharedMMIOHC, 0, PCNET_GUEST_SHARED_MEMORY_SIZE);
    888 
    889     pData->pSharedMMIOHC->u32Version = PCNET_GUEST_INTERFACE_VERSION;
     902    memset(pData->pSharedMMIOR3, 0, PCNET_GUEST_SHARED_MEMORY_SIZE);
     903
     904    pData->pSharedMMIOR3->u32Version = PCNET_GUEST_INTERFACE_VERSION;
    890905    uint32_t off = 2048; /* Leave some space for more fields within the header */
    891906
    … …  
    893908     * The Descriptor arrays.
    894909     */
    895     pData->pSharedMMIOHC->V.V1.offTxDescriptors = off;
     910    pData->pSharedMMIOR3->V.V1.offTxDescriptors = off;
    896911    off = RT_ALIGN(off + PCNET_GUEST_TX_DESCRIPTOR_SIZE * PCNET_GUEST_MAX_TX_DESCRIPTORS, 32);
    897912
    898     pData->pSharedMMIOHC->V.V1.offRxDescriptors = off;
     913    pData->pSharedMMIOR3->V.V1.offRxDescriptors = off;
    899914    off = RT_ALIGN(off + PCNET_GUEST_RX_DESCRIPTOR_SIZE * PCNET_GUEST_MAX_RX_DESCRIPTORS, 32);
    900915
    … …  
    908923#if 0
    909924    /* Don't allocate TX buffers since Windows guests cannot use it */
    910     pData->pSharedMMIOHC->V.V1.offTxBuffers = off;
     925    pData->pSharedMMIOR3->V.V1.offTxBuffers = off;
    911926    off = RT_ALIGN(off + PCNET_GUEST_NIC_BUFFER_SIZE * PCNET_GUEST_MAX_TX_DESCRIPTORS, 32);
    912927#endif
    913928
    914     pData->pSharedMMIOHC->V.V1.offRxBuffers = off;
    915     pData->pSharedMMIOHC->fFlags = PCNET_GUEST_FLAGS_ADMIT_HOST;
     929    pData->pSharedMMIOR3->V.V1.offRxBuffers = off;
     930    pData->pSharedMMIOR3->fFlags = PCNET_GUEST_FLAGS_ADMIT_HOST;
    916931    off = RT_ALIGN(off + PCNET_GUEST_NIC_BUFFER_SIZE * PCNET_GUEST_MAX_RX_DESCRIPTORS, 32);
    917932    AssertRelease(off <= PCNET_GUEST_SHARED_MEMORY_SIZE);
    918933
    919934    /* Update the header with the final size. */
    920     pData->pSharedMMIOHC->cbUsed = off;
     935    pData->pSharedMMIOR3->cbUsed = off;
    921936}
    922937
    … …  
    13801395static void pcnetEnablePrivateIf(PCNetState *pData)
    13811396{
    1382     bool fPrivIfEnabled =       pData->pSharedMMIOHC
    1383                           && !!(pData->CTXSUFF(pSharedMMIO)->fFlags & PCNET_GUEST_FLAGS_ADMIT_GUEST);
     1397    bool fPrivIfEnabled =       pData->pSharedMMIOR3
     1398                          && !!(pData->CTX_SUFF(pSharedMMIO)->fFlags & PCNET_GUEST_FLAGS_ADMIT_GUEST);
    13841399    if (fPrivIfEnabled != pData->fPrivIfEnabled)
    13851400    {
    … …  
    16621677                    pcnetWakeupReceive(PCNETSTATE_2_DEVINS(pData));
    16631678#else
    1664                     PPDMQUEUEITEMCORE pItem = PDMQueueAlloc(CTXSUFF(pData->pCanRxQueue));
     1679                    PPDMQUEUEITEMCORE pItem = PDMQueueAlloc(pData->CTX_SUFF(pCanRxQueue));
    16651680                    if (pItem)
    1666                         PDMQueueInsert(CTXSUFF(pData->pCanRxQueue), pItem);
     1681                        PDMQueueInsert(pData->CTX_SUFF(pCanRxQueue), pItem);
    16671682#endif
    16681683                }
    … …  
    18571872            if (pData->fPrivIfEnabled)
    18581873            {
    1859                 uint8_t *pb = (uint8_t*)pData->CTXSUFF(pSharedMMIO)
    1860                             + rbadr - pData->GCRDRA + pData->CTXSUFF(pSharedMMIO)->V.V1.offRxDescriptors;
     1874                uint8_t *pb = (uint8_t*)pData->CTX_SUFF(pSharedMMIO)
     1875                            + rbadr - pData->GCRDRA + pData->CTX_SUFF(pSharedMMIO)->V.V1.offRxDescriptors;
    18611876                memcpy(pb, src, count);
    18621877            }
    … …  
    18961911                if (pData->fPrivIfEnabled)
    18971912                {
    1898                     uint8_t *pb = (uint8_t*)pData->CTXSUFF(pSharedMMIO)
    1899                                 + rbadr - pData->GCRDRA + pData->CTXSUFF(pSharedMMIO)->V.V1.offRxDescriptors;
     1913                    uint8_t *pb = (uint8_t*)pData->CTX_SUFF(pSharedMMIO)
     1914                                + rbadr - pData->GCRDRA + pData->CTX_SUFF(pSharedMMIO)->V.V1.offRxDescriptors;
    19001915                    memcpy(pb, src, count);
    19011916                }
    … …  
    20212036    pData->pvSendFrame = pData->abSendBuf;
    20222037#endif
    2023     PDMDevHlpPhysRead(pData->CTXSUFF(pDevIns), GCPhysFrame, pData->pvSendFrame, cbFrame);
     2038    PDMDevHlpPhysRead(pData->CTX_SUFF(pDevIns), GCPhysFrame, pData->pvSendFrame, cbFrame);
    20242039    pData->cbSendFrame = cbFrame;
    20252040}
    … …  
    20322047{
    20332048    Assert(pData->cbSendFrame + cbFrame <= MAX_FRAME);
    2034     PDMDevHlpPhysRead(pData->CTXSUFF(pDevIns), GCPhysFrame, pData->pvSendFrame + pData->cbSendFrame, cbFrame);
     2049    PDMDevHlpPhysRead(pData->CTX_SUFF(pDevIns), GCPhysFrame, pData->pvSendFrame + pData->cbSendFrame, cbFrame);
    20352050    pData->cbSendFrame += cbFrame;
    20362051}
    … …  
    21232138DECLINLINE(void) pcnetXmitFlushFrames(PCNetState *pData)
    21242139{
    2125     pcnetXmitQueueConsumer(CTXSUFF(pData->pDevIns), NULL);
     2140    pcnetXmitQueueConsumer(pData->CTX_SUFF(pDevIns), NULL);
    21262141}
    21272142
    … …  
    21602175#else
    21612176# if 1
    2162     PPDMQUEUEITEMCORE pItem = PDMQueueAlloc(CTXSUFF(pData->pXmitQueue));
     2177    PPDMQUEUEITEMCORE pItem = PDMQueueAlloc(pData->CTX_SUFF(pXmitQueue));
    21632178    if (RT_UNLIKELY(pItem))
    2164         PDMQueueInsert(CTXSUFF(pData->pXmitQueue), pItem);
     2179        PDMQueueInsert(pData->CTX_SUFF(pXmitQueue), pItem);
    21652180# else
    21662181    if (ASMAtomicIncU32(&pData->cPendingSends) < 16)
    21672182    {
    2168         PPDMQUEUEITEMCORE pItem = PDMQueueAlloc(CTXSUFF(pData->pXmitQueue));
     2183        PPDMQUEUEITEMCORE pItem = PDMQueueAlloc(pData->CTX_SUFF(pXmitQueue));
    21692184        if (RT_UNLIKELY(pItem))
    2170             PDMQueueInsert(CTXSUFF(pData->pXmitQueue), pItem);
     2185            PDMQueueInsert(pData->CTX_SUFF(pXmitQueue), pItem);
    21712186    }
    21722187    else
    2173         PDMQueueFlush(CTXSUFF(pData->pXmitQueue));
     2188        PDMQueueFlush(pData->CTX_SUFF(pXmitQueue));
    21742189# endif
    21752190#endif
    … …  
    25402555static void pcnetPollTimerStart(PCNetState *pData)
    25412556{
    2542     TMTimerSetMillies(pData->CTXSUFF(pTimerPoll), 2);
     2557    TMTimerSetMillies(pData->CTX_SUFF(pTimerPoll), 2);
    25432558}
    25442559
    … …  
    25952610        pcnetPollRxTx(pData);
    25962611#else
    2597         uint64_t u64Now = TMTimerGet(pData->CTXSUFF(pTimerPoll));
     2612        uint64_t u64Now = TMTimerGet(pData->CTX_SUFF(pTimerPoll));
    25982613        if (RT_UNLIKELY(u64Now - pData->u64LastPoll > 200000))
    25992614        {
    … …  
    26012616            pcnetPollRxTx(pData);
    26022617        }
    2603         if (!TMTimerIsActive(pData->CTXSUFF(pTimerPoll)))
     2618        if (!TMTimerIsActive(pData->CTX_SUFF(pTimerPoll)))
    26042619            pcnetPollTimerStart(pData);
    26052620#endif
    … …  
    29102925            pData->aBCR[BCR_STVAL] = val;
    29112926            if (pData->fAm79C973)
    2912                 TMTimerSetNano(pData->CTXSUFF(pTimerSoftInt), 12800U * val);
     2927                TMTimerSetNano(pData->CTX_SUFF(pTimerSoftInt), 12800U * val);
    29132928            break;
    29142929
    … …  
    37033718    pData->aCSR[7] |= 0x0800; /* STINT */
    37043719    pcnetUpdateIrq(pData);
    3705     TMTimerSetNano(pData->CTXSUFF(pTimerSoftInt), 12800U * (pData->aBCR[BCR_STVAL] & 0xffff));
     3720    TMTimerSetNano(pData->CTX_SUFF(pTimerSoftInt), 12800U * (pData->aBCR[BCR_STVAL] & 0xffff));
    37063721}
    37073722
    … …  
    41394154    return VINF_SUCCESS;
    41404155#else
    4141     rc = TMR3TimerSave(pData->CTXSUFF(pTimerPoll), pSSMHandle);
     4156    rc = TMR3TimerSave(pData->CTX_SUFF(pTimerPoll), pSSMHandle);
    41424157    if (VBOX_FAILURE(rc))
    41434158        return rc;
    41444159#endif
    41454160    if (pData->fAm79C973)
    4146         rc = TMR3TimerSave(pData->CTXSUFF(pTimerSoftInt), pSSMHandle);
     4161        rc = TMR3TimerSave(pData->CTX_SUFF(pTimerSoftInt), pSSMHandle);
    41474162    return rc;
    41484163}
    … …  
    42154230    SSMR3GetU32(pSSMHandle, &pData->u32LinkSpeed);
    42164231#ifndef PCNET_NO_POLLING
    4217     TMR3TimerLoad(pData->CTXSUFF(pTimerPoll), pSSMHandle);
     4232    TMR3TimerLoad(pData->CTX_SUFF(pTimerPoll), pSSMHandle);
    42184233#endif
    42194234    if (pData->fAm79C973)
    … …  
    42214236        if (   SSM_VERSION_MAJOR(u32Version) >  0
    42224237            || SSM_VERSION_MINOR(u32Version) >= 8)
    4223             TMR3TimerLoad(pData->CTXSUFF(pTimerSoftInt), pSSMHandle);
     4238            TMR3TimerLoad(pData->CTX_SUFF(pTimerSoftInt), pSSMHandle);
    42244239    }
    42254240
    … …  
    43344349    ASMAtomicXchgBool(&pData->fMaybeOutOfSpace, true);
    43354350    STAM_PROFILE_START(&pData->StatRxOverflow, a);
    4336     while (RT_LIKELY(PDMDevHlpVMState(pData->CTXSUFF(pDevIns)) == VMSTATE_RUNNING))
     4351    while (RT_LIKELY(PDMDevHlpVMState(pData->CTX_SUFF(pDevIns)) == VMSTATE_RUNNING))
    43374352    {
    43384353        int rc2 = pcnetCanReceive(pData);
    … …  
    45244539        pcnetTimerRestore(pDevIns, pData->pTimerRestore);
    45254540    }
    4526     if (pData->pSharedMMIOHC)
     4541    if (pData->pSharedMMIOR3)
    45274542        pcnetInitSharedMemory(pData);
    45284543
    … …  
    45384553{
    45394554    PCNetState *pData = PDMINS2DATA(pDevIns, PCNetState *);
    4540     pData->pDevInsGC     = PDMDEVINS_2_GCPTR(pDevIns);
    4541     pData->pXmitQueueGC  = PDMQueueGCPtr(pData->pXmitQueueHC);
    4542     pData->pCanRxQueueGC = PDMQueueGCPtr(pData->pCanRxQueueHC);
    4543     if (pData->pSharedMMIOHC)
    4544         pData->pSharedMMIOGC += offDelta;
     4555    pData->pDevInsRC     = PDMDEVINS_2_RCPTR(pDevIns);
     4556    pData->pXmitQueueRC  = PDMQueueRCPtr(pData->pXmitQueueR3);
     4557    pData->pCanRxQueueRC = PDMQueueRCPtr(pData->pCanRxQueueR3);
     4558    if (pData->pSharedMMIOR3)
     4559        pData->pSharedMMIORC += offDelta;
    45454560#ifdef PCNET_NO_POLLING
    4546     *(RTHCUINTPTR *)&pData->pfnEMInterpretInstructionGC += offDelta;
     4561    pData->pfnEMInterpretInstructionRC += offDelta;
    45474562#else
    4548     pData->pTimerPollGC  = TMTimerGCPtr(pData->pTimerPollHC);
     4563    pData->pTimerPollRC  = TMTimerRCPtr(pData->pTimerPollR3);
    45494564#endif
    45504565    if (pData->fAm79C973)
    4551         pData->pTimerSoftIntGC = TMTimerGCPtr(pData->pTimerSoftIntHC);
     4566        pData->pTimerSoftIntRC = TMTimerRCPtr(pData->pTimerSoftIntR3);
    45524567}
    45534568
    … …  
    46164631
    46174632    /*
     4633     * Init what's required to make the destructor safe.
     4634     */
     4635    pData->hEventOutOfRxSpace = NIL_RTSEMEVENT;
     4636    pData->hSendEventSem = NIL_RTSEMEVENT;
     4637
     4638    /*
    46184639     * Validate configuration.
    46194640     */
    4620     if (!CFGMR3AreValuesValid(pCfgHandle, "MAC\0CableConnected\0Am79C973\0LineSpeed\0GCEnabled\0R0Enabled\0PrivIfEnabled\0"))
     4641    if (!CFGMR3AreValuesValid(pCfgHandle, "MAC\0" "CableConnected\0" "Am79C973\0" "LineSpeed\0" "GCEnabled\0" "R0Enabled\0" "PrivIfEnabled\0"))
    46214642        return PDMDEV_SET_ERROR(pDevIns, VERR_PDM_DEVINS_UNKNOWN_CFG_VALUES,
    46224643                                N_("Invalid configuraton for pcnet device"));
    … …  
    46294650        return PDMDEV_SET_ERROR(pDevIns, rc,
    46304651                                N_("Configuration error: Failed to get the \"MAC\" value"));
    4631     rc = CFGMR3QueryBool(pCfgHandle, "CableConnected", &pData->fLinkUp);
    4632     if (rc == VERR_CFGM_VALUE_NOT_FOUND)
    4633         pData->fLinkUp = true;
    4634     else if (VBOX_FAILURE(rc))
     4652    rc = CFGMR3QueryBoolDef(pCfgHandle, "CableConnected", &pData->fLinkUp, true);
     4653    if (VBOX_FAILURE(rc))
    46354654        return PDMDEV_SET_ERROR(pDevIns, rc,
    46364655                                N_("Configuration error: Failed to get the \"CableConnected\" value"));
    46374656
    4638     rc = CFGMR3QueryBool(pCfgHandle, "Am79C973", &pData->fAm79C973);
    4639     if (rc == VERR_CFGM_VALUE_NOT_FOUND)
    4640         pData->fAm79C973 = false;
    4641     else if (VBOX_FAILURE(rc))
     4657    rc = CFGMR3QueryBoolDef(pCfgHandle, "Am79C973", &pData->fAm79C973, false);
     4658    if (VBOX_FAILURE(rc))
    46424659        return PDMDEV_SET_ERROR(pDevIns, rc,
    46434660                                N_("Configuration error: Failed to get the \"Am79C973\" value"));
    46444661
    4645     rc = CFGMR3QueryU32(pCfgHandle, "LineSpeed", &pData->u32LinkSpeed);
    4646     if (rc == VERR_CFGM_VALUE_NOT_FOUND)
    4647         pData->u32LinkSpeed = 1000000;    /* 1GBit/s (in kbps units)*/
    4648     else if (VBOX_FAILURE(rc))
     4662    rc = CFGMR3QueryU32Def(pCfgHandle, "LineSpeed", &pData->u32LinkSpeed, 1000000); /* 1GBit/s (in kbps units)*/
     4663    if (VBOX_FAILURE(rc))
    46494664        return PDMDEV_SET_ERROR(pDevIns, rc,
    46504665                                N_("Configuration error: Failed to get the \"LineSpeed\" value"));
    46514666
    46524667#ifdef PCNET_GC_ENABLED
    4653     rc = CFGMR3QueryBool(pCfgHandle, "GCEnabled", &pData->fGCEnabled);
    4654     if (rc == VERR_CFGM_VALUE_NOT_FOUND)
    4655         pData->fGCEnabled = true;
    4656     else if (VBOX_FAILURE(rc))
     4668    rc = CFGMR3QueryBoolDef(pCfgHandle, "GCEnabled", &pData->fGCEnabled, true);
     4669    if (VBOX_FAILURE(rc))
    46574670        return PDMDEV_SET_ERROR(pDevIns, rc,
    46584671                                N_("Configuration error: Failed to get the \"GCEnabled\" value"));
    46594672
    4660     rc = CFGMR3QueryBool(pCfgHandle, "R0Enabled", &pData->fR0Enabled);
    4661     if (rc == VERR_CFGM_VALUE_NOT_FOUND)
    4662         pData->fR0Enabled = true;
    4663     else if (VBOX_FAILURE(rc))
     4673    rc = CFGMR3QueryBoolDef(pCfgHandle, "R0Enabled", &pData->fR0Enabled, true);
     4674    if (VBOX_FAILURE(rc))
    46644675        return PDMDEV_SET_ERROR(pDevIns, rc,
    46654676                                N_("Configuration error: Failed to get the \"R0Enabled\" value"));
    … …  
    46744685     * Initialize data (most of it anyway).
    46754686     */
    4676     pData->pDevInsHC                        = pDevIns;
    4677     pData->pDevInsGC                        = PDMDEVINS_2_GCPTR(pDevIns);
     4687    pData->pDevInsR3                        = pDevIns;
     4688    pData->pDevInsR0                        = PDMDEVINS_2_R0PTR(pDevIns);
     4689    pData->pDevInsRC                        = PDMDEVINS_2_RCPTR(pDevIns);
    46784690    pData->Led.u32Magic                     = PDMLED_MAGIC;
    46794691    /* IBase */
    … …  
    47454757    if (fPrivIfEnabled)
    47464758    {
    4747         RTRCPTR pRCMapping;
    4748 
    47494759        /*
    47504760         * Initialize shared memory between host and guest for descriptors and RX buffers. Most guests
    47514761         * should not care if there is an additional PCI ressource but just in case we made this configurable.
    47524762         */
    4753         rc = PDMDevHlpMMIO2Register(pDevIns, 2, PCNET_GUEST_SHARED_MEMORY_SIZE, 0, (void **)&pData->pSharedMMIOHC, "PCNetShMem");
     4763        rc = PDMDevHlpMMIO2Register(pDevIns, 2, PCNET_GUEST_SHARED_MEMORY_SIZE, 0, (void **)&pData->pSharedMMIOR3, "PCNetShMem");
    47544764        if (VBOX_FAILURE(rc))
    47554765            return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
    47564766                                       N_("Failed to allocate %u bytes of memory for the PCNet device"), PCNET_GUEST_SHARED_MEMORY_SIZE);
    4757         rc = PDMDevHlpMMHyperMapMMIO2(pDevIns, 2, 0, 8192, "PCNetShMem", &pRCMapping);
     4767        rc = PDMDevHlpMMHyperMapMMIO2(pDevIns, 2, 0, 8192, "PCNetShMem", &pData->pSharedMMIORC);
    47584768        if (VBOX_FAILURE(rc))
    47594769            return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
    47604770                                       N_("Failed to map 8192 bytes of memory for the PCNet device into the hyper memory"));
    4761         pData->pSharedMMIOGC = pRCMapping;
     4771        pData->pSharedMMIOR0 = (uintptr_t)pData->pSharedMMIOR3; /** @todo #1865: Map MMIO2 into ring-0. */
     4772
    47624773        pcnetInitSharedMemory(pData);
    47634774        rc = PDMDevHlpPCIIORegionRegister(pDevIns, 2, PCNET_GUEST_SHARED_MEMORY_SIZE,
    … …  
    47684779
    47694780#ifdef PCNET_NO_POLLING
     4781    /*
     4782     * Resolve the R0 and RC handlers.
     4783     */
    47704784    rc = PDMR3GetSymbolR0Lazy(PDMDevHlpGetVM(pDevIns), NULL, "EMInterpretInstruction", &pData->pfnEMInterpretInstructionR0);
    47714785    if (VBOX_SUCCESS(rc))
    4772     {
    4773         /*
    4774          * Resolve the GC handler.
    4775          */
    4776         RTGCPTR pfnHandlerGC;
    4777         rc = PDMR3GetSymbolGCLazy(PDMDevHlpGetVM(pDevIns), NULL, "EMInterpretInstruction", (RTGCPTR *)&pData->pfnEMInterpretInstructionGC);
    4778     }
    4779     if (VBOX_FAILURE(rc))
    4780     {
    4781         AssertMsgFailed(("PDMR3GetSymbolGCLazy -> %Vrc\n", rc));
    4782         return rc;
    4783     }
     4786        rc = PDMR3GetSymbolGCLazy(PDMDevHlpGetVM(pDevIns), NULL, "EMInterpretInstruction", (RTGCPTR *)&pData->pfnEMInterpretInstructionRC);
     4787    AssertLogRelMsgRCReturn(rc, ("PDMR3GetSymbolGCLazy(EMInterpretInstruction) -> %Vrc\n", rc), rc);
    47844788#else
    47854789    rc = PDMDevHlpTMTimerCreate(pDevIns, TMCLOCK_VIRTUAL, pcnetTimer,
    4786                                 "PCNet Poll Timer", &pData->pTimerPollHC);
     4790                                "PCNet Poll Timer", &pData->pTimerPollR3);
    47874791    if (VBOX_FAILURE(rc))
    4788     {
    4789         AssertMsgFailed(("pfnTMTimerCreate pcnetTimer -> %Vrc\n", rc));
    47904792        return rc;
    4791     }
     4793    pData->pTimerPollR0 = TMTimerR0Ptr(pData->pTimerPollR3);
     4794    pData->pTimerPollRC = TMTimerRCPtr(pData->pTimerPollR3);
    47924795#endif
    47934796    if (pData->fAm79C973)
    … …  
    47954798        /* Software Interrupt timer */
    47964799        rc = PDMDevHlpTMTimerCreate(pDevIns, TMCLOCK_VIRTUAL, pcnetTimerSoftInt,
    4797                                     "PCNet SoftInt Timer", &pData->pTimerSoftIntHC);
    4798         if (VBOX_FAILURE(rc))
    4799         {
    4800             AssertMsgFailed(("pfnTMTimerCreate pcnetTimerSoftInt -> %Vrc\n", rc));
     4800                                    "PCNet SoftInt Timer", &pData->pTimerSoftIntR3);
     4801        if (RT_FAILURE(rc))
    48014802            return rc;
    4802         }
     4803        pData->pTimerSoftIntR0 = TMTimerR0Ptr(pData->pTimerSoftIntR3);
     4804        pData->pTimerSoftIntRC = TMTimerRCPtr(pData->pTimerSoftIntR3);
    48034805    }
    48044806    rc = PDMDevHlpTMTimerCreate(pDevIns, TMCLOCK_VIRTUAL, pcnetTimerRestore,
    48054807                                "PCNet Restore Timer", &pData->pTimerRestore);
    4806     if (VBOX_FAILURE(rc))
    4807     {
    4808         AssertMsgFailed(("pfnTMTimerCreate pcnetTimerRestore -> %Vrc\n", rc));
     4808    if (RT_FAILURE(rc))
    48094809        return rc;
    4810     }
     4810
    48114811    rc = PDMDevHlpSSMRegister(pDevIns, pDevIns->pDevReg->szDeviceName, iInstance,
    48124812                              PCNET_SAVEDSTATE_VERSION, sizeof(*pData),
    … …  
    48184818    /*
    48194819     * Initialize critical section.
    4820      * This must of course be done before attaching drivers or anything else which can call us back..
     4820     * This must of course be done before attaching drivers or anything else which can call us back.
    48214821     */
    48224822    char szName[24];
    … …  
    48334833     */
    48344834    rc = PDMDevHlpPDMQueueCreate(pDevIns, sizeof(PDMQUEUEITEMCORE), 1, 0,
    4835                                  pcnetXmitQueueConsumer, true, &pData->pXmitQueueHC);
     4835                                 pcnetXmitQueueConsumer, true, &pData->pXmitQueueR3);
    48364836    if (VBOX_FAILURE(rc))
    48374837        return rc;
    4838     pData->pXmitQueueGC = PDMQueueGCPtr(pData->pXmitQueueHC);
     4838    pData->pXmitQueueR0 = PDMQueueR0Ptr(pData->pXmitQueueR3);
     4839    pData->pXmitQueueRC = PDMQueueRCPtr(pData->pXmitQueueR3);
    48394840
    48404841    /*
    … …  
    48424843     */
    48434844    rc = PDMDevHlpPDMQueueCreate(pDevIns, sizeof(PDMQUEUEITEMCORE), 1, 0,
    4844                                  pcnetCanRxQueueConsumer, true, &pData->pCanRxQueueHC);
     4845                                 pcnetCanRxQueueConsumer, true, &pData->pCanRxQueueR3);
    48454846    if (VBOX_FAILURE(rc))
    48464847        return rc;
    4847     pData->pCanRxQueueGC = PDMQueueGCPtr(pData->pCanRxQueueHC);
     4848    pData->pCanRxQueueR0 = PDMQueueR0Ptr(pData->pCanRxQueueR3);
     4849    pData->pCanRxQueueRC = PDMQueueRCPtr(pData->pCanRxQueueR3);
    48484850
    48494851    /*
    … …  
    49084910    AssertRCReturn(rc, rc);
    49094911
    4910     unsigned i;
    4911     NOREF(i);
    4912 
    49134912#ifdef PCNET_QUEUE_SEND_PACKETS
    49144913    pData->apXmitRingBuffer[0] = (uint8_t *)RTMemAlloc(PCNET_MAX_XMIT_SLOTS * MAX_FRAME);
    4915     for (i = 1; i < PCNET_MAX_XMIT_SLOTS; i++)
     4914    for (unsigned i = 1; i < PCNET_MAX_XMIT_SLOTS; i++)
    49164915        pData->apXmitRingBuffer[i] = pData->apXmitRingBuffer[0] + i*MAX_FRAME;
    49174916#endif
    … …  
    49484947    PDMDevHlpSTAMRegisterF(pDevIns, &pData->StatTmdStoreHC,         STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling PCNet TmdStore in HC",     "/Devices/PCNet%d/TmdStoreHC", iInstance);
    49494948
    4950     for (i = 0; i < ELEMENTS(pData->aStatXmitFlush) - 1; i++)
     4949    unsigned i;
     4950    for (i = 0; i < RT_ELEMENTS(pData->aStatXmitFlush) - 1; i++)
    49514951        PDMDevHlpSTAMRegisterF(pDevIns, &pData->aStatXmitFlush[i],  STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_OCCURENCES,       "",                                   "/Devices/PCNet%d/XmitFlushIrq/%d", iInstance, i + 1);
    49524952    PDMDevHlpSTAMRegisterF(pDevIns, &pData->aStatXmitFlush[i],      STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_OCCURENCES,       "",                                   "/Devices/PCNet%d/XmitFlushIrq/%d+", iInstance, i + 1);
    49534953
    4954     for (i = 0; i < ELEMENTS(pData->aStatXmitChainCounts) - 1; i++)
     4954    for (i = 0; i < RT_ELEMENTS(pData->aStatXmitChainCounts) - 1; i++)
    49554955        PDMDevHlpSTAMRegisterF(pDevIns, &pData->aStatXmitChainCounts[i], STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_OCCURENCES,  "",                                   "/Devices/PCNet%d/XmitChainCounts/%d", iInstance, i + 1);
    49564956    PDMDevHlpSTAMRegisterF(pDevIns, &pData->aStatXmitChainCounts[i], STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_OCCURENCES,      "",                                   "/Devices/PCNet%d/XmitChainCounts/%d+", iInstance, i + 1);

  • trunk/src/VBox/Devices/testcase/tstDeviceStructSizeGC.cpp

    r11197 r11199  
    321321    GEN_CHECK_OFF(PCNetState, PciDev);
    322322#ifndef PCNET_NO_POLLING
    323     GEN_CHECK_OFF(PCNetState, pTimerPollHC);
    324     GEN_CHECK_OFF(PCNetState, pTimerPollGC);
    325 #endif
    326     GEN_CHECK_OFF(PCNetState, pTimerSoftIntHC);
    327     GEN_CHECK_OFF(PCNetState, pTimerSoftIntGC);
     323    GEN_CHECK_OFF(PCNetState, pTimerPollR3);
     324    GEN_CHECK_OFF(PCNetState, pTimerPollR0);
     325    GEN_CHECK_OFF(PCNetState, pTimerPollRC);
     326#endif
     327    GEN_CHECK_OFF(PCNetState, pTimerSoftIntR3);
     328    GEN_CHECK_OFF(PCNetState, pTimerSoftIntR0);
     329    GEN_CHECK_OFF(PCNetState, pTimerSoftIntRC);
    328330    GEN_CHECK_OFF(PCNetState, u32RAP);
    329331    GEN_CHECK_OFF(PCNetState, iISR);
    … …  
    348350    GEN_CHECK_OFF(PCNetState, iLog2DescSize);
    349351    GEN_CHECK_OFF(PCNetState, GCUpperPhys);
    350     GEN_CHECK_OFF(PCNetState, pXmitQueueHC);
    351     GEN_CHECK_OFF(PCNetState, pXmitQueueGC);
    352     GEN_CHECK_OFF(PCNetState, pCanRxQueueHC);
    353     GEN_CHECK_OFF(PCNetState, pCanRxQueueGC);
     352    GEN_CHECK_OFF(PCNetState, pXmitQueueR3);
     353    GEN_CHECK_OFF(PCNetState, pXmitQueueR0);
     354    GEN_CHECK_OFF(PCNetState, pXmitQueueRC);
     355    GEN_CHECK_OFF(PCNetState, pCanRxQueueR3);
     356    GEN_CHECK_OFF(PCNetState, pCanRxQueueR0);
     357    GEN_CHECK_OFF(PCNetState, pCanRxQueueRC);
    354358    GEN_CHECK_OFF(PCNetState, pTimerRestore);
    355     GEN_CHECK_OFF(PCNetState, pDevInsHC);
    356     GEN_CHECK_OFF(PCNetState, pDevInsGC);
     359    GEN_CHECK_OFF(PCNetState, pDevInsR3);
     360    GEN_CHECK_OFF(PCNetState, pDevInsR0);
     361    GEN_CHECK_OFF(PCNetState, pDevInsRC);
    357362    GEN_CHECK_OFF(PCNetState, pDrv);
    358363    GEN_CHECK_OFF(PCNetState, pDrvBase);
    … …  
    381386    GEN_CHECK_OFF(PCNetState, pfnEMInterpretInstructionR0
    382387#endif
    383     GEN_CHECK_OFF(PCNetState, pSharedMMIOHC);
    384     GEN_CHECK_OFF(PCNetState, pSharedMMIOGC);
     388    GEN_CHECK_OFF(PCNetState, pSharedMMIOR3);
     389    GEN_CHECK_OFF(PCNetState, pSharedMMIOR0);
     390    GEN_CHECK_OFF(PCNetState, pSharedMMIORC);
    385391    GEN_CHECK_OFF(PCNetState, fPrivIfEnabled);
    386392    GEN_CHECK_OFF(PCNetState, fGCEnabled);
Note: See TracChangeset for help on using the changeset viewer.

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