Archipelago » qemu

    s->watchdog = qemu_new_timer(vm_clock, dp8393x_watchdog, s);

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

                                          nd->model, nd->name,

                                          nic_can_receive, nic_receive, NULL,

                                          nic_cleanup, s);

	eth->ethregs = cpu_register_io_memory(eth_read, eth_write, eth);

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

                                                nd->model, nd->name,

                                                eth_can_receive, eth_receive,

                                                NULL, eth_cleanup, eth);

                                           mcf_fec_writefn, s);

    cpu_register_physical_memory(base, 0x400, s->mmio_index);

                                          nd->model, nd->name,

                                          mcf_fec_can_receive, mcf_fec_receive,

                                          NULL, mcf_fec_cleanup, s);

    s->io_base = base;

    s->irq = irq;

    if (nd) {

                                              nd->model, nd->name,

                                              mipsnet_can_receive, mipsnet_receive,

                                              NULL, mipsnet_cleanup, s);

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

                                          nd->model, nd->name,

                                          usbnet_can_receive,

                                          usbnet_receive,

	return -1;

    vlan = qemu_find_vlan(netdev->xendev.dev, 1);

                                      net_rx_ok, net_rx_packet, NULL,

                                      NULL, netdev);

    snprintf(netdev->vs->info_str, sizeof(netdev->vs->info_str),

                                       int iovcnt,

                                       void *opaque);

                                      VLANClientState *peer,

                                      const char *model,

                                      const char *name,

    vc = qemu_mallocz(sizeof(VLANClientState));

    vc->model = qemu_strdup(model);

    if (name)

        vc->name = qemu_strdup(name);

    }

#endif

                                 slirp_receive, NULL,

                                 net_slirp_cleanup, s);

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

    s = qemu_mallocz(sizeof(TAPState));

    s->fd = fd;

    s->has_vnet_hdr = vnet_hdr != 0;

                                 tap_receive, tap_receive_iov,

                                 tap_cleanup, s);

    tap_read_poll(s, 1);

        free(s);

        return -1;

    }

                                 vde_receive, NULL,

                                 vde_cleanup, s);

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

    s = qemu_mallocz(sizeof(NetSocketState));

    s->fd = fd;

                                 net_socket_receive_dgram, NULL,

                                 net_socket_cleanup, s);

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

    NetSocketState *s;

    s = qemu_mallocz(sizeof(NetSocketState));

    s->fd = fd;

                                 net_socket_receive, NULL,

                                 net_socket_cleanup, s);

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

        return -1;

    }

                                      dump_receive, NULL,

                                      net_dump_cleanup, s);

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

/* VLANs support */

typedef int (NetCanReceive)(VLANClientState *);

typedef ssize_t (NetReceive)(VLANClientState *, const uint8_t *, size_t);

typedef ssize_t (NetReceiveIOV)(VLANClientState *, const struct iovec *, int);

typedef void (LinkStatusChanged)(VLANClientState *);

struct VLANClientState {

    NetReceive *receive;

    NetReceiveIOV *receive_iov;

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

        return -1;

    }

                                 NULL, tap_receive,

                                 NULL, tap_cleanup, s);