static void etsec_instance_init(Object *obj) { eTSEC *etsec = ETSEC_COMMON(obj); SysBusDevice *sbd = SYS_BUS_DEVICE(obj); memory_region_init_io(&etsec->io_area, OBJECT(etsec), &etsec_ops, etsec, "eTSEC", 0x1000); sysbus_init_mmio(sbd, &etsec->io_area); sysbus_init_irq(sbd, &etsec->tx_irq); sysbus_init_irq(sbd, &etsec->rx_irq); sysbus_init_irq(sbd, &etsec->err_irq); } static Property etsec_properties[] = { DEFINE_NIC_PROPERTIES(eTSEC, conf), DEFINE_PROP_END_OF_LIST(), }; static void etsec_class_init(ObjectClass *klass, void *data) { DeviceClass *dc = DEVICE_CLASS(klass); dc->realize = etsec_realize; dc->reset = etsec_reset; dc->props = etsec_properties; } static TypeInfo etsec_info = { .name = "eTSEC", .parent = TYPE_SYS_BUS_DEVICE,
static target_ulong h_multicast_ctrl(PowerPCCPU *cpu, sPAPREnvironment *spapr, target_ulong opcode, target_ulong *args) { target_ulong reg = args[0]; VIOsPAPRDevice *dev = spapr_vio_find_by_reg(spapr->vio_bus, reg); if (!dev) { return H_PARAMETER; } return H_SUCCESS; } static Property spapr_vlan_properties[] = { DEFINE_SPAPR_PROPERTIES(VIOsPAPRVLANDevice, sdev), DEFINE_NIC_PROPERTIES(VIOsPAPRVLANDevice, nicconf), DEFINE_PROP_END_OF_LIST(), }; static void spapr_vlan_class_init(ObjectClass *klass, void *data) { DeviceClass *dc = DEVICE_CLASS(klass); VIOsPAPRDeviceClass *k = VIO_SPAPR_DEVICE_CLASS(klass); k->init = spapr_vlan_init; k->reset = spapr_vlan_reset; k->devnode = spapr_vlan_devnode; k->dt_name = "l-lan"; k->dt_type = "network"; k->dt_compatible = "IBM,l-lan"; k->signal_mask = 0x1;
s->nic = qemu_new_nic(&net_mipsnet_info, &s->conf, object_get_typename(OBJECT(dev)), dev->qdev.id, s); qemu_format_nic_info_str(&s->nic->nc, s->conf.macaddr.a); return 0; } static void mipsnet_sysbus_reset(DeviceState *dev) { MIPSnetState *s = DO_UPCAST(MIPSnetState, busdev.qdev, dev); mipsnet_reset(s); } static Property mipsnet_properties[] = { DEFINE_NIC_PROPERTIES(MIPSnetState, conf), DEFINE_PROP_END_OF_LIST(), }; static void mipsnet_class_init(ObjectClass *klass, void *data) { DeviceClass *dc = DEVICE_CLASS(klass); SysBusDeviceClass *k = SYS_BUS_DEVICE_CLASS(klass); k->init = mipsnet_sysbus_init; dc->desc = "MIPS Simulator network device"; dc->reset = mipsnet_sysbus_reset; dc->vmsd = &vmstate_mipsnet; dc->props = mipsnet_properties; }
s->phys_mem_read = ledma_memory_read; s->phys_mem_write = ledma_memory_write; return pcnet_common_init(&dev->qdev, s, &net_lance_info); } static void lance_reset(DeviceState *dev) { SysBusPCNetState *d = DO_UPCAST(SysBusPCNetState, busdev.qdev, dev); pcnet_h_reset(&d->state); } static SysBusDeviceInfo lance_info = { .init = lance_init, .qdev.name = "lance", .qdev.size = sizeof(SysBusPCNetState), .qdev.reset = lance_reset, .qdev.vmsd = &vmstate_lance, .qdev.props = (Property[]) { DEFINE_PROP_PTR("dma", SysBusPCNetState, state.dma_opaque), DEFINE_NIC_PROPERTIES(SysBusPCNetState, state.conf), DEFINE_PROP_END_OF_LIST(), } }; static void lance_register_devices(void) { sysbus_register_withprop(&lance_info); } device_init(lance_register_devices)
return pcnet_common_init(&pci_dev->qdev, s, &net_pci_pcnet_info); } static void pci_reset(DeviceState *dev) { PCIPCNetState *d = DO_UPCAST(PCIPCNetState, pci_dev.qdev, dev); pcnet_h_reset(&d->state); } static PCIDeviceInfo pcnet_info = { .qdev.name = "pcnet", .qdev.size = sizeof(PCIPCNetState), .qdev.reset = pci_reset, .qdev.vmsd = &vmstate_pci_pcnet, .init = pci_pcnet_init, .exit = pci_pcnet_uninit, .qdev.props = (Property[]) { DEFINE_NIC_PROPERTIES(PCIPCNetState, state.conf), DEFINE_PROP_END_OF_LIST(), } }; static void pci_pcnet_register_devices(void) { pci_qdev_register(&pcnet_info); } device_init(pci_pcnet_register_devices)
qemu_macaddr_default_if_unset(&s->conf.macaddr); s->nic = qemu_new_nic(&net_etraxfs_info, &s->conf, object_get_typename(OBJECT(s)), dev->id, s); qemu_format_nic_info_str(qemu_get_queue(s->nic), s->conf.macaddr.a); tdk_init(&s->phy); mdio_attach(&s->mdio_bus, &s->phy, s->phyaddr); return 0; } static Property etraxfs_eth_properties[] = { DEFINE_PROP_UINT32("phyaddr", ETRAXFSEthState, phyaddr, 1), DEFINE_PROP_PTR("dma_out", ETRAXFSEthState, vdma_out), DEFINE_PROP_PTR("dma_in", ETRAXFSEthState, vdma_in), DEFINE_NIC_PROPERTIES(ETRAXFSEthState, conf), DEFINE_PROP_END_OF_LIST(), }; static void etraxfs_eth_class_init(ObjectClass *klass, void *data) { DeviceClass *dc = DEVICE_CLASS(klass); SysBusDeviceClass *k = SYS_BUS_DEVICE_CLASS(klass); k->init = fs_eth_init; dc->props = etraxfs_eth_properties; /* Reason: pointer properties "dma_out", "dma_in" */ dc->user_creatable = false; } static const TypeInfo etraxfs_eth_info = {
static int syborg_virtio_net_init(SysBusDevice *dev) { VirtIODevice *vdev; SyborgVirtIOProxy *proxy = FROM_SYSBUS(SyborgVirtIOProxy, dev); vdev = virtio_net_init(&dev->qdev, &proxy->nic, &proxy->net); return syborg_virtio_init(proxy, vdev); } static SysBusDeviceInfo syborg_virtio_net_info = { .init = syborg_virtio_net_init, .qdev.name = "syborg,virtio-net", .qdev.size = sizeof(SyborgVirtIOProxy), .qdev.props = (Property[]) { DEFINE_NIC_PROPERTIES(SyborgVirtIOProxy, nic), DEFINE_VIRTIO_NET_FEATURES(SyborgVirtIOProxy, host_features), DEFINE_PROP_UINT32("x-txtimer", SyborgVirtIOProxy, net.txtimer, TX_TIMER_INTERVAL), DEFINE_PROP_INT32("x-txburst", SyborgVirtIOProxy, net.txburst, TX_BURST), DEFINE_PROP_STRING("tx", SyborgVirtIOProxy, net.tx), DEFINE_PROP_END_OF_LIST(), } }; static void syborg_virtio_register_devices(void) { sysbus_register_withprop(&syborg_virtio_net_info); }
E1000E_MSIX_VEC_NUM), VMSTATE_UINT16(core.vet, E1000EState), VMSTATE_STRUCT_ARRAY(core.tx, E1000EState, E1000E_NUM_QUEUES, 0, e1000e_vmstate_tx, struct e1000e_tx), VMSTATE_END_OF_LIST() } }; static PropertyInfo e1000e_prop_disable_vnet, e1000e_prop_subsys_ven, e1000e_prop_subsys; static Property e1000e_properties[] = { DEFINE_NIC_PROPERTIES(E1000EState, conf), DEFINE_PROP_DEFAULT("disable_vnet_hdr", E1000EState, disable_vnet, false, e1000e_prop_disable_vnet, bool), DEFINE_PROP_DEFAULT("subsys_ven", E1000EState, subsys_ven, PCI_VENDOR_ID_INTEL, e1000e_prop_subsys_ven, uint16_t), DEFINE_PROP_DEFAULT("subsys", E1000EState, subsys, 0, e1000e_prop_subsys, uint16_t), DEFINE_PROP_END_OF_LIST(), }; static void e1000e_class_init(ObjectClass *class, void *data) { DeviceClass *dc = DEVICE_CLASS(class); PCIDeviceClass *c = PCI_DEVICE_CLASS(class);
{ smc91c111_state *s = FROM_SYSBUS(smc91c111_state, dev); memory_region_init_io(&s->mmio, &smc91c111_mem_ops, s, "smc91c111-mmio", 16); sysbus_init_mmio(dev, &s->mmio); sysbus_init_irq(dev, &s->irq); qemu_macaddr_default_if_unset(&s->conf.macaddr); s->nic = qemu_new_nic(&net_smc91c111_info, &s->conf, object_get_typename(OBJECT(dev)), dev->qdev.id, s); qemu_format_nic_info_str(&s->nic->nc, s->conf.macaddr.a); /* ??? Save/restore. */ return 0; } static Property smc91c111_properties[] = { DEFINE_NIC_PROPERTIES(smc91c111_state, conf), DEFINE_PROP_END_OF_LIST(), }; static void smc91c111_class_init(ObjectClass *klass, void *data) { DeviceClass *dc = DEVICE_CLASS(klass); SysBusDeviceClass *k = SYS_BUS_DEVICE_CLASS(klass); k->init = smc91c111_init1; dc->reset = smc91c111_reset; dc->vmsd = &vmstate_smc91c111; dc->props = smc91c111_properties; } static const TypeInfo smc91c111_info = {
prom[7] = 0xff - checksum; } static const VMStateDescription vmstate_dp8393x = { .name = "dp8393x", .version_id = 0, .minimum_version_id = 0, .fields = (VMStateField []) { VMSTATE_BUFFER_UNSAFE(cam, dp8393xState, 0, 16 * 6), VMSTATE_UINT16_ARRAY(regs, dp8393xState, 0x40), VMSTATE_END_OF_LIST() } }; static Property dp8393x_properties[] = { DEFINE_NIC_PROPERTIES(dp8393xState, conf), DEFINE_PROP_PTR("dma_mr", dp8393xState, dma_mr), DEFINE_PROP_UINT8("it_shift", dp8393xState, it_shift, 0), DEFINE_PROP_END_OF_LIST(), }; static void dp8393x_class_init(ObjectClass *klass, void *data) { DeviceClass *dc = DEVICE_CLASS(klass); set_bit(DEVICE_CATEGORY_NETWORK, dc->categories); dc->realize = dp8393x_realize; dc->reset = dp8393x_reset; dc->vmsd = &vmstate_dp8393x; dc->props = dp8393x_properties; /* Reason: dma_mr property can't be set */
VMSTATE_UINT32(phycr, Ftgmac100State), VMSTATE_UINT32(phydata, Ftgmac100State), VMSTATE_UINT32(aptcr, Ftgmac100State), VMSTATE_UINT32(phy_status, Ftgmac100State), VMSTATE_UINT32(phy_control, Ftgmac100State), VMSTATE_UINT32(phy_advertise, Ftgmac100State), VMSTATE_UINT32(phy_int, Ftgmac100State), VMSTATE_UINT32(phy_int_mask, Ftgmac100State), VMSTATE_END_OF_LIST() } }; static Property ftgmac100_properties[] = { DEFINE_PROP_BOOL("aspeed", Ftgmac100State, aspeed, false), DEFINE_NIC_PROPERTIES(Ftgmac100State, conf), DEFINE_PROP_END_OF_LIST(), }; static void ftgmac100_class_init(ObjectClass *klass, void *data) { DeviceClass *dc = DEVICE_CLASS(klass); dc->vmsd = &vmstate_ftgmac100; dc->reset = ftgmac100_reset; dc->props = ftgmac100_properties; set_bit(DEVICE_CATEGORY_NETWORK, dc->categories); dc->realize = ftgmac100_realize; dc->desc = "Faraday FTGMAC100 Gigabit Ethernet emulation"; }
virtio_reset(dev->vdev); css_reset_sch(dev->sch); } /**************** Virtio-ccw Bus Device Descriptions *******************/ static const VirtIOBindings virtio_ccw_bindings = { .notify = virtio_ccw_notify, .get_features = virtio_ccw_get_features, }; static Property virtio_ccw_net_properties[] = { DEFINE_PROP_STRING("devno", VirtioCcwDevice, bus_id), DEFINE_VIRTIO_NET_FEATURES(VirtioCcwDevice, host_features[0]), DEFINE_NIC_PROPERTIES(VirtioCcwDevice, nic), DEFINE_PROP_UINT32("x-txtimer", VirtioCcwDevice, net.txtimer, TX_TIMER_INTERVAL), DEFINE_PROP_INT32("x-txburst", VirtioCcwDevice, net.txburst, TX_BURST), DEFINE_PROP_STRING("tx", VirtioCcwDevice, net.tx), DEFINE_PROP_END_OF_LIST(), }; static void virtio_ccw_net_class_init(ObjectClass *klass, void *data) { DeviceClass *dc = DEVICE_CLASS(klass); VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_CLASS(klass); k->init = virtio_ccw_net_init; k->exit = virtio_ccw_net_exit;
//~ VMSTATE_UINT32(mac_reg[TOTH], E1000State), //~ VMSTATE_UINT32(mac_reg[TOTL], E1000State), //~ VMSTATE_UINT32(mac_reg[TPR], E1000State), //~ VMSTATE_UINT32(mac_reg[TPT], E1000State), //~ VMSTATE_UINT32(mac_reg[TXDCTL], E1000State), //~ VMSTATE_UINT32(mac_reg[WUFC], E1000State), //~ VMSTATE_UINT32(mac_reg[VET], E1000State), //~ VMSTATE_UINT32_SUB_ARRAY(mac_reg, E1000State, RA, 32), //~ VMSTATE_UINT32_SUB_ARRAY(mac_reg, E1000State, MTA, 128), //~ VMSTATE_UINT32_SUB_ARRAY(mac_reg, E1000State, VFTA, 128), VMSTATE_END_OF_LIST() } }; static Property tnetw1130_properties[] = { DEFINE_NIC_PROPERTIES(TNETW1130State, tnetw1130.conf), DEFINE_PROP_END_OF_LIST(), }; static void tnetw1130_class_init(ObjectClass *klass, void *data) { DeviceClass *dc = DEVICE_CLASS(klass); PCIDeviceClass *k = PCI_DEVICE_CLASS(klass); dc->desc = "Texas Instruments TNETW1130"; dc->props = tnetw1130_properties; //~ dc->reset = qdev_tnetw1130_reset; dc->vmsd = &vmstate_pci_tnetw1130; //~ k->romfile = "pxe-tnetw1130.rom"; k->init = pci_tnetw1130_init; k->exit = pci_tnetw1130_uninit;
isa_init_irq(dev, &s->irq, isa->isairq); qemu_macaddr_default_if_unset(&s->c.macaddr); ne2000_reset(s); s->nic = qemu_new_nic(&net_ne2000_isa_info, &s->c, object_get_typename(OBJECT(dev)), dev->qdev.id, s); qemu_format_nic_info_str(&s->nic->nc, s->c.macaddr.a); return 0; } static Property ne2000_isa_properties[] = { DEFINE_PROP_HEX32("iobase", ISANE2000State, iobase, 0x300), DEFINE_PROP_UINT32("irq", ISANE2000State, isairq, 9), DEFINE_NIC_PROPERTIES(ISANE2000State, ne2000.c), DEFINE_PROP_END_OF_LIST(), }; static void isa_ne2000_class_initfn(ObjectClass *klass, void *data) { DeviceClass *dc = DEVICE_CLASS(klass); ISADeviceClass *ic = ISA_DEVICE_CLASS(klass); ic->init = isa_ne2000_initfn; dc->props = ne2000_isa_properties; } static TypeInfo ne2000_isa_info = { .name = "ne2k_isa", .parent = TYPE_ISA_DEVICE, .instance_size = sizeof(ISANE2000State),
return 0; assign_error: while (--n >= 0) { virtio_ccw_set_guest_notifier(dev, n, !assigned, false); } return r; } /**************** Virtio-ccw Bus Device Descriptions *******************/ static Property virtio_ccw_net_properties[] = { DEFINE_PROP_STRING("devno", VirtioCcwDevice, bus_id), DEFINE_VIRTIO_NET_FEATURES(VirtioCcwDevice, host_features[0]), DEFINE_VIRTIO_NET_PROPERTIES(VirtIONetCcw, vdev.net_conf), DEFINE_NIC_PROPERTIES(VirtIONetCcw, vdev.nic_conf), DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice, flags, VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT, true), DEFINE_PROP_END_OF_LIST(), }; static void virtio_ccw_net_class_init(ObjectClass *klass, void *data) { DeviceClass *dc = DEVICE_CLASS(klass); VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_CLASS(klass); k->init = virtio_ccw_net_init; k->exit = virtio_ccw_exit; dc->reset = virtio_ccw_reset; dc->props = virtio_ccw_net_properties; }