Archipelago » qemu

        if (s->regs[SONIC_RCR] & (SONIC_RCR_LB1 | SONIC_RCR_LB0)) {

            /* Loopback */

            s->regs[SONIC_TCR] |= SONIC_TCR_CRSL;

                s->loopback_packet = 1;

            }

        } else {

            /* Transmit packet */

    dp8393x_writel,

};

{

    if (!(s->regs[SONIC_CR] & SONIC_CR_RXEN))

        return 0;

    return -1;

}

{

    uint16_t data[10];

    int packet_type;

    uint32_t available, address;

    int width, rx_len = size;

}

static int

{

    return (s->mac_reg[RCTL] & E1000_RCTL_EN);

}

static void

{

    struct e1000_rx_desc desc;

    target_phys_addr_t base;

    unsigned int n, rdt;

    }

}

{

    logout("%p\n", s);

    return get_ru_state(s) == ru_ready;

    //~ return !eepro100_buffer_full(s);

}

{

    /* TODO:

     * - Magic packets should set bit 30 in power management driver register.

     * - Interesting packets should set bit 29 in power management driver register.

     */

    uint16_t rfd_status = 0xa000;

    static const uint8_t broadcast_macaddr[6] =

        { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };

	return match;

}

{

	return 1;

}

{

	unsigned char sa_bcast[6] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff };

	int use_ma0 = eth->regs[RW_REC_CTRL] & 1;

	int use_ma1 = eth->regs[RW_REC_CTRL] & 2;

	int r_bcast = eth->regs[RW_REC_CTRL] & 8;

    mcf_fec_update(s);

}

{

    return s->rx_enabled;

}

{

    mcf_fec_bd bd;

    uint32_t flags = 0;

    uint32_t addr;

    return 0;

}

{

    if (s->busy)

        return 0;

    return !mipsnet_buffer_full(s);

}

{

#ifdef DEBUG_MIPSNET_RECEIVE

    printf("mipsnet: receiving len=%d\n", size);

#endif

        return;

    s->busy = 1;

    le32_to_cpus(&desc->next);

}

{

    return 1;

}

{

    uint32_t desc_addr;

    mv88w8618_rx_desc desc;

    int i;

    return 0;

}

{

    if (s->cmd & E8390_STOP)

        return 1;

#define MIN_BUF_SIZE 60

{

    uint8_t *p;

    unsigned int total_len, next, avail, len, index, mcast_idx;

    uint8_t buf1[60];

    return !!(CSR_CXST(s) & 0x8000);

}

{

    if (CSR_STOP(s) || CSR_SPND(s))

        return 0;

#define MIN_BUF_SIZE 60

{

    int is_padr = 0, is_bcast = 0, is_ladr = 0;

    uint8_t buf1[60];

    int remaining;

                if (BCR_SWSTYLE(s) == 1)

                    add_crc = !GET_FIELD(tmd.status, TMDS, NOFCS);

                s->looptest = add_crc ? PCNET_LOOPTEST_CRC : PCNET_LOOPTEST_NOCRC;

                s->looptest = 0;

            } else

                if (s->vc)

#endif

}

{

    int avail;

    /* Receive (drop) packets if card is disabled.  */

    }

}

{

    uint32_t packet_header = 0;

    }

}

{

}

static void rtl8139_reset_rxring(RTL8139State *s, uint32_t bufferSize)

    if (TxLoopBack == (s->TxConfig & TxLoopBack))

    {

        DEBUG_PRINT(("RTL8139: +++ transmit loopback mode\n"));

    }

    else

    {

    return val;

}

{

    if ((s->rcr & RCR_RXEN) == 0 || (s->rcr & RCR_SOFT_RST))

        return 1;

    return 1;

}

{

    int status;

    int packetsize;

    uint32_t crc;

}

/* TODO: Implement MAC address filtering.  */

{

    int n;

    uint8_t *p;

    uint32_t crc;

    stellaris_enet_update(s);

}

{

    if ((s->rctl & SE_RCTL_RXEN) == 0)

        return 1;

    return (s->np < 31);

}

{

    uint32_t val;

    switch (offset) {

    return ret;

}

{

    struct rndis_packet_msg_type *msg;

    if (s->rndis) {

    s->in_ptr = 0;

}

{

    if (s->rndis && !s->rndis_state == RNDIS_DATA_INITIALIZED)

        return 1;

    return 1;

}

{

    return do_virtio_net_can_receive(n, VIRTIO_NET_MAX_BUFSIZE);

}

    return 0;

}

{

    struct virtio_net_hdr_mrg_rxbuf *mhdr = NULL;

    size_t hdr_len, offset, i;

#define NET_IP_ALIGN 2

{

    RING_IDX rc, rp;

    if (netdev->xendev.be_state != XenbusStateConnected)

    return 1;

}

{

    netif_rx_request_t rxreq;

    RING_IDX rc, rp;

    void *page;

        }

        /* no can_receive() handler, they can always receive */

            return 1;

        }

    }

    for (vc = sender->vlan->first_client; vc != NULL; vc = vc->next) {

        if (vc != sender && !vc->link_down) {

        }

    }

}

        offset += len;

    }

    return offset;

}

            if (vc->link_down) {

                len = calc_iov_length(iov, iovcnt);

            } else if (vc->receive_iov) {

            } else if (vc->receive) {

                len = vc_sendv_compat(vc, iov, iovcnt);

            }

    return slirp_inited;

}

{

#ifdef DEBUG_SLIRP

    printf("slirp input:\n");

static int launch_script(const char *setup_script, const char *ifname, int fd);

                               int iovcnt)

{

    ssize_t len;

    do {

    return len;

}

{

    int ret;

    for(;;) {

        ret = write(s->fd, buf, size);

    }

}

{

    int ret;

    for(;;) {

        ret = vde_send(s->vde, (const char *)buf, size, 0);

        free(s);

        return -1;

    }

                                 NULL, vde_cleanup, s);

    qemu_set_fd_handler(vde_datafd(s->vde), vde_to_qemu, NULL, s);

    snprintf(s->vc->info_str, sizeof(s->vc->info_str), "sock=%s,fd=%d",

} NetSocketListenState;

/* XXX: we consider we can send the whole packet without blocking */

{

    uint32_t len;

    len = htonl(size);

    send_all(s->fd, buf, size);

}

{

    sendto(s->fd, buf, size, 0,

           (struct sockaddr *)&s->dgram_dst, sizeof(s->dgram_dst));

}

    uint32_t len;

};

{

    struct pcap_sf_pkthdr hdr;

    int64_t ts;

    int caplen;

typedef struct VLANClientState VLANClientState;

typedef void (NetCleanup) (VLANClientState *);

typedef void (LinkStatusChanged)(VLANClientState *);

        len = announce_self_create(buf, nd_table[i].macaddr);

        vlan = nd_table[i].vlan;

	for(vc = vlan->first_client; vc != NULL; vc = vc->next) {

        }

    }

    if (count--) {

    qemu_free(s);

}

{

    TAPState *s = opaque;