Archipelago » qemu

#include "hw.h"

#include "pci.h"

#include "qemu-timer.h"

#include "net.h"

#include "loader.h"

/* Clears all tally counters */

static void RTL8139TallyCounters_clear(RTL8139TallyCounters* counters);

typedef struct RTL8139State {

    PCIDevice dev;

    uint8_t phys[8]; /* mac address */

    int rtl8139_mmio_io_addr_dummy;

} RTL8139State;

static void rtl8139_set_next_tctr_time(RTL8139State *s, int64_t current_time);

static void prom9346_decode_command(EEprom9346 *eeprom, uint8_t command)

            if (size > wrapped)

            {

            }

            /* reset buffer pointer */

            s->RxBufAddr = 0;

            s->RxBufAddr = wrapped;

    }

    /* non-wrapping path or overwrapping enabled */

    s->RxBufAddr += size;

}

#define MIN_BUF_SIZE 60

{

#if TARGET_PHYS_ADDR_BITS > 32

    return low | ((target_phys_addr_t)high << 32);

/* w3 high 32bit of Rx buffer ptr */

        int descriptor = s->currCPlusRxDesc;

        cplus_rx_ring_desc = rtl8139_addr64(s->RxRingAddrLO, s->RxRingAddrHI);

        cplus_rx_ring_desc += 16 * descriptor;

        DPRINTF("+++ C+ mode reading RX descriptor %d from host memory at "

            s->RxRingAddrLO, cplus_rx_ring_desc);

        uint32_t val, rxdw0,rxdw1,rxbufLO,rxbufHI;

        rxdw0 = le32_to_cpu(val);

        rxdw1 = le32_to_cpu(val);

        rxbufLO = le32_to_cpu(val);

        rxbufHI = le32_to_cpu(val);

        DPRINTF("+++ C+ mode RX descriptor %d %08x %08x %08x %08x\n",

            return size_;

        }

        /* receive/copy to target memory */

        if (dot1q_buf) {

        } else {

        }

        if (s->CpCmd & CPlusRxChkSum)

        /* write checksum */

        val = cpu_to_le32(crc32(0, buf, size_));

/* first segment of received packet flag */

#define CP_RX_STATUS_FS (1<<29)

        /* update ring data */

        val = cpu_to_le32(rxdw0);

        val = cpu_to_le32(rxdw1);

        /* update tally counter */

        ++s->tally_counters.RxOk;

    counters->TxUndrn = 0;

}

{

    uint16_t val16;

    uint32_t val32;

    uint64_t val64;

    val64 = cpu_to_le64(tally_counters->TxOk);

    val64 = cpu_to_le64(tally_counters->RxOk);

    val64 = cpu_to_le64(tally_counters->TxERR);

    val32 = cpu_to_le32(tally_counters->RxERR);

    val16 = cpu_to_le16(tally_counters->MissPkt);

    val16 = cpu_to_le16(tally_counters->FAE);

    val32 = cpu_to_le32(tally_counters->Tx1Col);

    val32 = cpu_to_le32(tally_counters->TxMCol);

    val64 = cpu_to_le64(tally_counters->RxOkPhy);

    val64 = cpu_to_le64(tally_counters->RxOkBrd);

    val32 = cpu_to_le32(tally_counters->RxOkMul);

    val16 = cpu_to_le16(tally_counters->TxAbt);

    val16 = cpu_to_le16(tally_counters->TxUndrn);

}

/* Loads values of tally counters from VM state file */

    DPRINTF("+++ transmit reading %d bytes from host memory at 0x%08x\n",

        txsize, s->TxAddr[descriptor]);

    /* Mark descriptor as transferred */

    s->TxStatus[descriptor] |= TxHostOwns;

    int descriptor = s->currCPlusTxDesc;

    /* Normal priority ring */

    cplus_tx_ring_desc += 16 * descriptor;

    DPRINTF("+++ C+ mode reading TX descriptor %d from host memory at "

        s->TxAddr[0], cplus_tx_ring_desc);

    uint32_t val, txdw0,txdw1,txbufLO,txbufHI;

    txdw0 = le32_to_cpu(val);

    txdw1 = le32_to_cpu(val);

    txbufLO = le32_to_cpu(val);

    txbufHI = le32_to_cpu(val);

    DPRINTF("+++ C+ mode TX descriptor %d %08x %08x %08x %08x\n", descriptor,

    }

    int txsize = txdw0 & CP_TX_BUFFER_SIZE_MASK;

    /* make sure we have enough space to assemble the packet */

    if (!s->cplus_txbuffer)

    /* append more data to the packet */

    DPRINTF("+++ C+ mode transmit reading %d bytes from host memory at "

    s->cplus_txbuffer_offset += txsize;

    /* seek to next Rx descriptor */

    /* update ring data */

    val = cpu_to_le32(txdw0);

    /* Now decide if descriptor being processed is holding the last segment of packet */

    if (txdw0 & CP_TX_LS)

            target_phys_addr_t tc_addr = rtl8139_addr64(s->TxStatus[0] & ~0x3f, s->TxStatus[1]);

            /* dump tally counters to specified memory location */

            /* mark dump completed */

            s->TxStatus[0] &= ~0x8;