Archipelago » qemu

    QEMUTimer *watchdog;

    int64_t wt_last_update;

    VLANClientState *vc;

    /* Registers */

    uint8_t cam[16][6];

    dp8393x_update_irq(s);

}

void dp83932_init(NICInfo *nd, target_phys_addr_t base, int it_shift,

                  qemu_irq irq, void* mem_opaque,

                  void (*memory_rw)(void *opaque, target_phys_addr_t addr, uint8_t *buf, int len, int is_write))

{

    dp8393xState *s;

    qemu_check_nic_model(nd, "dp83932");

    s->regs[SONIC_SR] = 0x0004; /* only revision recognized by Linux */

    s->vc = qemu_new_vlan_client(nd->vlan, nd->model, nd->name,

    qemu_format_nic_info_str(s->vc, nd->macaddr);

    qemu_register_reset(nic_reset, s);

    nic_reset(s);

}

                                     excluded_regs[i] - 4);

}

static int

pci_e1000_uninit(PCIDevice *dev)

{

    memset(&d->tx, 0, sizeof d->tx);

    d->vc = qemu_new_vlan_client(nd->vlan, nd->model, nd->name,

    d->vc->link_status_changed = e1000_set_link_status;

    qemu_format_nic_info_str(d->vc, nd->macaddr);

    qemu_put_buffer(f, s->configuration, sizeof(s->configuration));

}

static PCIDevice *nic_init(PCIBus * bus, NICInfo * nd, uint32_t device)

{

    PCIEEPRO100State *d;

    d = (PCIEEPRO100State *) pci_register_device(bus, nd->model,

                                                 sizeof(PCIEEPRO100State), -1,

                                                 NULL, NULL);

    s = &d->eepro100;

    s->device = device;

    nic_reset(s);

    s->vc = qemu_new_vlan_client(nd->vlan, nd->model, nd->name,

    qemu_format_nic_info_str(s->vc, s->macaddr);

	&eth_writel,

};

void *etraxfs_eth_init(NICInfo *nd, CPUState *env, 

		       qemu_irq *irq, target_phys_addr_t base, int phyaddr)

{

	cpu_register_physical_memory (base, 0x5c, eth->ethregs);

	eth->vc = qemu_new_vlan_client(nd->vlan, nd->model, nd->name,

	eth->vc->opaque = eth;

	eth->vc->link_status_changed = eth_set_link;

typedef struct {

    qemu_irq *irq;

    VLANClientState *vc;

    uint32_t irq_state;

    uint32_t eir;

   mcf_fec_write

};

void mcf_fec_init(NICInfo *nd, target_phys_addr_t base, qemu_irq *irq)

{

    mcf_fec_state *s;

    qemu_check_nic_model(nd, "mcf_fec");

    s = (mcf_fec_state *)qemu_mallocz(sizeof(mcf_fec_state));

    s->irq = irq;

    s->vc = qemu_new_vlan_client(nd->vlan, nd->model, nd->name,

    memcpy(s->macaddr, nd->macaddr, 6);

    qemu_format_nic_info_str(s->vc, s->macaddr);

}

    uint32_t intctl;

    uint8_t rx_buffer[MAX_ETH_FRAME_SIZE];

    uint8_t tx_buffer[MAX_ETH_FRAME_SIZE];

    qemu_irq irq;

    VLANClientState *vc;

} MIPSnetState;

    return 0;

}

void mipsnet_init (int base, qemu_irq irq, NICInfo *nd)

{

    MIPSnetState *s;

    register_ioport_write(base, 36, 4, mipsnet_ioport_write, s);

    register_ioport_read(base, 36, 4, mipsnet_ioport_read, s);

    s->irq = irq;

    if (nd && nd->vlan) {

        s->vc = qemu_new_vlan_client(nd->vlan, nd->model, nd->name,

    } else {

        s->vc = NULL;

    }

    uint32_t smir;

    uint32_t icr;

    uint32_t imr;

    int vlan_header;

    uint32_t tx_queue[2];

    uint32_t rx_queue[4];

    mv88w8618_eth_write

};

static void mv88w8618_eth_init(NICInfo *nd, uint32_t base, qemu_irq irq)

{

    mv88w8618_eth_state *s;

    qemu_check_nic_model(nd, "mv88w8618");

    s = qemu_mallocz(sizeof(mv88w8618_eth_state));

    s->irq = irq;

    s->vc = qemu_new_vlan_client(nd->vlan, nd->model, nd->name,

}

/* LCD register offsets */

    uint8_t curpag;

    uint8_t mult[8]; /* multicast mask array */

    qemu_irq irq;

    PCIDevice *pci_dev;

    VLANClientState *vc;

    uint8_t macaddr[6];

	return 0;

}

void isa_ne2000_init(int base, qemu_irq irq, NICInfo *nd)

{

    NE2000State *s;

    register_ioport_write(base + 0x1f, 1, 1, ne2000_reset_ioport_write, s);

    register_ioport_read(base + 0x1f, 1, 1, ne2000_reset_ioport_read, s);

    s->irq = irq;

    memcpy(s->macaddr, nd->macaddr, 6);

    ne2000_reset(s);

    s->vc = qemu_new_vlan_client(nd->vlan, nd->model, nd->name,

    qemu_format_nic_info_str(s->vc, s->macaddr);

    register_ioport_read(addr + 0x1f, 1, 1, ne2000_reset_ioport_read, s);

}

PCIDevice *pci_ne2000_init(PCIBus *bus, NICInfo *nd, int devfn)

{

    PCINE2000State *d;

    memcpy(s->macaddr, nd->macaddr, 6);

    ne2000_reset(s);

    s->vc = qemu_new_vlan_client(nd->vlan, nd->model, nd->name,

    qemu_format_nic_info_str(s->vc, s->macaddr);

    uint8_t buffer[4096];

    int tx_busy;

    qemu_irq irq;

    void (*phys_mem_read)(void *dma_opaque, target_phys_addr_t addr,

                         uint8_t *buf, int len, int do_bswap);

    void (*phys_mem_write)(void *dma_opaque, target_phys_addr_t addr,

    return 0;

}

{

    d->poll_timer = qemu_new_timer(vm_clock, pcnet_poll_timer, d);

    if (nd && nd->vlan) {

        d->vc = qemu_new_vlan_client(nd->vlan, nd->model, nd->name,

        qemu_format_nic_info_str(d->vc, d->nd->macaddr);

    } else {

    cpu_physical_memory_read(addr, buf, len);

}

PCIDevice *pci_pcnet_init(PCIBus *bus, NICInfo *nd, int devfn)

{

    PCNetState *d;

    d = (PCNetState *)pci_register_device(bus, "PCNet", sizeof(PCNetState),

                                          devfn, NULL, NULL);

    pci_conf = d->dev.config;

    pci_config_set_vendor_id(pci_conf, PCI_VENDOR_ID_AMD);

    d->phys_mem_write = pci_physical_memory_write;

    d->pci_dev = &d->dev;

    return (PCIDevice *)d;

}

    NULL,

};

void lance_init(NICInfo *nd, target_phys_addr_t leaddr, void *dma_opaque,

                qemu_irq irq, qemu_irq *reset)

{

    PCNetState *d;

    qemu_check_nic_model(nd, "lance");

    d = qemu_mallocz(sizeof(PCNetState));

        cpu_register_io_memory(0, lance_mem_read, lance_mem_write, d);

    d->dma_opaque = dma_opaque;

    d->irq = irq;

    d->phys_mem_read = ledma_memory_read;

    d->phys_mem_write = ledma_memory_write;

}

#endif /* TARGET_SPARC */

}

#endif /* RTL8139_ONBOARD_TIMER */

PCIDevice *pci_rtl8139_init(PCIBus *bus, NICInfo *nd, int devfn)

{

    PCIRTL8139State *d;

                                              "RTL8139", sizeof(PCIRTL8139State),

                                              devfn,

                                              NULL, NULL);

    pci_conf = d->dev.config;

    pci_config_set_vendor_id(pci_conf, PCI_VENDOR_ID_REALTEK);

    pci_config_set_device_id(pci_conf, PCI_DEVICE_ID_REALTEK_8139);

    memcpy(s->macaddr, nd->macaddr, 6);

    rtl8139_reset(s);

    s->vc = qemu_new_vlan_client(nd->vlan, nd->model, nd->name,

    qemu_format_nic_info_str(s->vc, s->macaddr);

    uint8_t int_level;

    uint8_t int_mask;

    uint8_t macaddr[6];

} smc91c111_state;

#define RCR_SOFT_RST  0x8000

    smc91c111_writel

};

void smc91c111_init(NICInfo *nd, uint32_t base, qemu_irq irq)

{

    smc91c111_state *s;

    qemu_check_nic_model(nd, "smc91c111");

    s = (smc91c111_state *)qemu_mallocz(sizeof(smc91c111_state));

    s->irq = irq;

    memcpy(s->macaddr, nd->macaddr, 6);

    smc91c111_reset(s);

    s->vc = qemu_new_vlan_client(nd->vlan, nd->model, nd->name,

    qemu_format_nic_info_str(s->vc, s->macaddr);

    /* ??? Save/restore.  */

}

    VLANClientState *vc;

    qemu_irq irq;

    uint8_t macaddr[6];

} stellaris_enet_state;

static void stellaris_enet_update(stellaris_enet_state *s)

    return 0;

}

void stellaris_enet_init(NICInfo *nd, uint32_t base, qemu_irq irq)

{

    stellaris_enet_state *s;

    qemu_check_nic_model(nd, "stellaris");

    s = (stellaris_enet_state *)qemu_mallocz(sizeof(stellaris_enet_state));

    s->irq = irq;

    memcpy(s->macaddr, nd->macaddr, 6);

    if (nd->vlan) {

        s->vc = qemu_new_vlan_client(nd->vlan, nd->model, nd->name,

        qemu_format_nic_info_str(s->vc, s->macaddr);

    }

    return !s->in_len;

}

static void usb_net_handle_destroy(USBDevice *dev)

{

    USBNetState *s = (USBNetState *) dev;

    /* TODO: remove the nd_table[] entry */

    qemu_del_vlan_client(s->vc);

}

USBDevice *usb_net_init(NICInfo *nd)

    pstrcpy(s->dev.devname, sizeof(s->dev.devname),

                    "QEMU USB Network Interface");

    s->vc = qemu_new_vlan_client(nd->vlan, nd->model, nd->name,

    qemu_format_nic_info_str(s->vc, s->mac);

    return 0;

}

PCIDevice *virtio_net_init(PCIBus *bus, NICInfo *nd, int devfn)

{

    VirtIONet *n;

    memcpy(n->mac, nd->macaddr, ETH_ALEN);

    n->status = VIRTIO_NET_S_LINK_UP;

    n->vc = qemu_new_vlan_client(nd->vlan, nd->model, nd->name,

    n->vc->link_status_changed = virtio_net_set_link_status;

    qemu_format_nic_info_str(n->vc, n->mac);

    virtio_update_irq(vdev);

}

VirtIODevice *virtio_init_pci(PCIBus *bus, const char *name,

                              uint16_t vendor, uint16_t device,

                              uint16_t subvendor, uint16_t subdevice,

void virtio_load(VirtIODevice *vdev, QEMUFile *f);

void virtio_notify_config(VirtIODevice *vdev);

void virtio_queue_set_notification(VirtQueue *vq, int enable);

                                      const char *name,

                                      IOReadHandler *fd_read,

                                      IOCanRWHandler *fd_can_read,

                                      void *opaque)

{

    VLANClientState *vc, **pvc;

        vc->name = assign_name(vc, model);

    vc->fd_read = fd_read;

    vc->fd_can_read = fd_can_read;

    vc->opaque = opaque;

    vc->vlan = vlan;

    while (*pvc != NULL)

        if (*pvc == vc) {

            *pvc = vc->next;

            free(vc->name);

            free(vc->model);

            free(vc);

        slirp_init(slirp_restrict, slirp_ip);

    }

    slirp_vc = qemu_new_vlan_client(vlan, model, name,

    slirp_vc->info_str[0] = '\0';

    return 0;

}

    char down_script_arg[128];

} TAPState;

static ssize_t tap_receive_iov(void *opaque, const struct iovec *iov,

                               int iovcnt)

{

    }

}

/* fd support */

static TAPState *net_tap_fd_init(VLANState *vlan,

    s = qemu_mallocz(sizeof(TAPState));

    s->fd = fd;

    s->vc->fd_readv = tap_receive_iov;

    qemu_set_fd_handler(s->fd, tap_send, NULL, s);

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

    }

}

static int net_vde_init(VLANState *vlan, const char *model,

                        const char *name, const char *sock,

                        int port, const char *group, int mode)

        free(s);

        return -1;

    }

    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",

             sock, vde_datafd(s->vde));

    return -1;

}

static NetSocketState *net_socket_fd_init_dgram(VLANState *vlan,

                                                const char *model,

                                                const char *name,

    s = qemu_mallocz(sizeof(NetSocketState));

    s->fd = fd;

    qemu_set_fd_handler(s->fd, net_socket_send_dgram, NULL, s);

    /* mcast: save bound address as dst */

    NetSocketState *s;

    s = qemu_mallocz(sizeof(NetSocketState));

    s->fd = fd;

    snprintf(s->vc->info_str, sizeof(s->vc->info_str),

             "socket: fd=%d", fd);

    if (is_connected) {

void net_cleanup(void)

{

    VLANState *vlan;

    /* close network clients */

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

        }

    }

}

void net_client_check(void)

typedef struct VLANClientState VLANClientState;

typedef void (LinkStatusChanged)(VLANClientState *);

struct VLANClientState {

    /* Packets may still be sent if this returns zero.  It's used to

       rate-limit the slirp code.  */

    IOCanRWHandler *fd_can_read;

    LinkStatusChanged *link_status_changed;

    int link_down;

    void *opaque;

                                      const char *name,

                                      IOReadHandler *fd_read,

                                      IOCanRWHandler *fd_can_read,

                                      void *opaque);

void qemu_del_vlan_client(VLANClientState *vc);

VLANClientState *qemu_find_vlan_client(VLANState *vlan, void *opaque);

     tap_win32_overlapped_t *handle;

 } TAPState;

static void tap_receive(void *opaque, const uint8_t *buf, int size)

{

    TAPState *s = opaque;

        return -1;

    }

    snprintf(s->vc->info_str, sizeof(s->vc->info_str),

             "tap: ifname=%s", ifname);