Commit 40021f08 authored by Anthony Liguori's avatar Anthony Liguori
Browse files

pci: convert to QEMU Object Model 



Signed-off-by: default avatarAnthony Liguori <aliguori@us.ibm.com>
parent 6e4ec3f9

hw/9pfs/virtio-9p-device.c

+26 −17
Original line number Diff line number Diff line
@@ -163,23 +163,32 @@ static int virtio_9p_init_pci(PCIDevice *pci_dev) 
    return 0;

}



static PCIDeviceInfo virtio_9p_info = {

    .qdev.name = "virtio-9p-pci",

    .qdev.size = sizeof(VirtIOPCIProxy),

    .init      = virtio_9p_init_pci,

    .vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET,

    .device_id = 0x1009,

    .revision  = VIRTIO_PCI_ABI_VERSION,

    .class_id  = 0x2,

    .qdev.props = (Property[]) {

static Property virtio_9p_properties[] = {

    DEFINE_PROP_BIT("ioeventfd", VirtIOPCIProxy, flags, VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT, true),

    DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy, nvectors, 2),

    DEFINE_VIRTIO_COMMON_FEATURES(VirtIOPCIProxy, host_features),

    DEFINE_PROP_STRING("mount_tag", VirtIOPCIProxy, fsconf.tag),

    DEFINE_PROP_STRING("fsdev", VirtIOPCIProxy, fsconf.fsdev_id),

    DEFINE_PROP_END_OF_LIST(),

    },

    .qdev.reset = virtio_pci_reset,

};



static void virtio_9p_class_init(ObjectClass *klass, void *data)

{

    PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);



    k->init = virtio_9p_init_pci;

    k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;

    k->device_id = 0x1009;

    k->revision = VIRTIO_PCI_ABI_VERSION;

    k->class_id = 0x2;

}



static DeviceInfo virtio_9p_info = {

    .name = "virtio-9p-pci",

    .size = sizeof(VirtIOPCIProxy),

    .props = virtio_9p_properties,

    .class_init = virtio_9p_class_init,

    .reset = virtio_pci_reset,

};



static void virtio_9p_register_devices(void)

hw/ac97.c

+24 −15
Original line number Diff line number Diff line
@@ -1344,21 +1344,30 @@ int ac97_init (PCIBus *bus) 
    return 0;

}



static PCIDeviceInfo ac97_info = {

    .qdev.name    = "AC97",

    .qdev.desc    = "Intel 82801AA AC97 Audio",

    .qdev.size    = sizeof (AC97LinkState),

    .qdev.vmsd    = &vmstate_ac97,

    .init         = ac97_initfn,

    .exit         = ac97_exitfn,

    .vendor_id    = PCI_VENDOR_ID_INTEL,

    .device_id    = PCI_DEVICE_ID_INTEL_82801AA_5,

    .revision     = 0x01,

    .class_id     = PCI_CLASS_MULTIMEDIA_AUDIO,

    .qdev.props   = (Property[]) {

static Property ac97_properties[] = {

    DEFINE_PROP_UINT32("use_broken_id", AC97LinkState, use_broken_id, 0),

    DEFINE_PROP_END_OF_LIST(),

    }

};



static void ac97_class_init(ObjectClass *klass, void *data)

{

    PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);



    k->init = ac97_initfn;

    k->exit = ac97_exitfn;

    k->vendor_id = PCI_VENDOR_ID_INTEL;

    k->device_id = PCI_DEVICE_ID_INTEL_82801AA_5;

    k->revision = 0x01;

    k->class_id = PCI_CLASS_MULTIMEDIA_AUDIO;

}



static DeviceInfo ac97_info = {

    .name = "AC97",

    .desc = "Intel 82801AA AC97 Audio",

    .size = sizeof (AC97LinkState),

    .vmsd = &vmstate_ac97,

    .props = ac97_properties,

    .class_init = ac97_class_init,

};



static void ac97_register (void)

hw/acpi_piix4.c

+33 −26
Original line number Diff line number Diff line
@@ -280,11 +280,11 @@ static void piix4_update_hotplug(PIIX4PMState *s) 
    s->pci0_hotplug_enable = ~0;



    QTAILQ_FOREACH_SAFE(qdev, &bus->children, sibling, next) {

        PCIDeviceInfo *info = container_of(qdev_get_info(qdev), PCIDeviceInfo, qdev);

        PCIDevice *pdev = DO_UPCAST(PCIDevice, qdev, qdev);

        PCIDevice *pdev = PCI_DEVICE(qdev);

        PCIDeviceClass *pc = PCI_DEVICE_GET_CLASS(pdev);

        int slot = PCI_SLOT(pdev->devfn);



        if (info->no_hotplug) {

        if (pc->no_hotplug) {

            s->pci0_hotplug_enable &= ~(1 << slot);

        }

    }
@@ -396,23 +396,32 @@ i2c_bus *piix4_pm_init(PCIBus *bus, int devfn, uint32_t smb_io_base, 
    return s->smb.smbus;

}



static PCIDeviceInfo piix4_pm_info = {

    .qdev.name          = "PIIX4_PM",

    .qdev.desc          = "PM",

    .qdev.size          = sizeof(PIIX4PMState),

    .qdev.vmsd          = &vmstate_acpi,

    .qdev.no_user       = 1,

    .no_hotplug         = 1,

    .init               = piix4_pm_initfn,

    .config_write       = pm_write_config,

    .vendor_id          = PCI_VENDOR_ID_INTEL,

    .device_id          = PCI_DEVICE_ID_INTEL_82371AB_3,

    .revision           = 0x03,

    .class_id           = PCI_CLASS_BRIDGE_OTHER,

    .qdev.props         = (Property[]) {

static Property piix4_pm_properties[] = {

    DEFINE_PROP_UINT32("smb_io_base", PIIX4PMState, smb_io_base, 0),

    DEFINE_PROP_END_OF_LIST(),

    }

};



static void piix4_pm_class_init(ObjectClass *klass, void *data)

{

    PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);



    k->no_hotplug = 1;

    k->init = piix4_pm_initfn;

    k->config_write = pm_write_config;

    k->vendor_id = PCI_VENDOR_ID_INTEL;

    k->device_id = PCI_DEVICE_ID_INTEL_82371AB_3;

    k->revision = 0x03;

    k->class_id = PCI_CLASS_BRIDGE_OTHER;

}



static DeviceInfo piix4_pm_info = {

    .name = "PIIX4_PM",

    .desc = "PM",

    .size = sizeof(PIIX4PMState),

    .vmsd = &vmstate_acpi,

    .no_user = 1,

    .props = piix4_pm_properties,

    .class_init = piix4_pm_class_init,

};



static void piix4_pm_register(void)
@@ -485,14 +494,12 @@ static void pciej_write(void *opaque, uint32_t addr, uint32_t val) 
{

    BusState *bus = opaque;

    DeviceState *qdev, *next;

    PCIDevice *dev;

    PCIDeviceInfo *info;

    int slot = ffs(val) - 1;



    QTAILQ_FOREACH_SAFE(qdev, &bus->children, sibling, next) {

        dev = DO_UPCAST(PCIDevice, qdev, qdev);

        info = container_of(qdev_get_info(qdev), PCIDeviceInfo, qdev);

        if (PCI_SLOT(dev->devfn) == slot && !info->no_hotplug) {

        PCIDevice *dev = PCI_DEVICE(qdev);

        PCIDeviceClass *pc = PCI_DEVICE_GET_CLASS(dev);

        if (PCI_SLOT(dev->devfn) == slot && !pc->no_hotplug) {

            qdev_free(qdev);

        }

    }
@@ -553,7 +560,7 @@ static int piix4_device_hotplug(DeviceState *qdev, PCIDevice *dev, 
{

    int slot = PCI_SLOT(dev->devfn);

    PIIX4PMState *s = DO_UPCAST(PIIX4PMState, dev,

                                DO_UPCAST(PCIDevice, qdev, qdev));

                                PCI_DEVICE(qdev));



    /* Don't send event when device is enabled during qemu machine creation:

     * it is present on boot, no hotplug event is necessary. We do send an

hw/apb_pci.c

+34 −20
Original line number Diff line number Diff line
@@ -436,14 +436,21 @@ static int pbm_pci_host_init(PCIDevice *d) 
    return 0;

}



static PCIDeviceInfo pbm_pci_host_info = {

    .qdev.name = "pbm",

    .qdev.size = sizeof(PCIDevice),

    .init      = pbm_pci_host_init,

    .vendor_id = PCI_VENDOR_ID_SUN,

    .device_id = PCI_DEVICE_ID_SUN_SABRE,

    .class_id  = PCI_CLASS_BRIDGE_HOST,

    .is_bridge = 1,

static void pbm_pci_host_class_init(ObjectClass *klass, void *data)

{

    PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);



    k->init = pbm_pci_host_init;

    k->vendor_id = PCI_VENDOR_ID_SUN;

    k->device_id = PCI_DEVICE_ID_SUN_SABRE;

    k->class_id = PCI_CLASS_BRIDGE_HOST;

    k->is_bridge = 1;

}



static DeviceInfo pbm_pci_host_info = {

    .name = "pbm",

    .size = sizeof(PCIDevice),

    .class_init = pbm_pci_host_class_init,

};



static SysBusDeviceInfo pbm_host_info = {
@@ -453,18 +460,25 @@ static SysBusDeviceInfo pbm_host_info = { 
    .init = pci_pbm_init_device,

};



static PCIDeviceInfo pbm_pci_bridge_info = {

    .qdev.name = "pbm-bridge",

    .qdev.size = sizeof(PCIBridge),

    .qdev.vmsd = &vmstate_pci_device,

    .qdev.reset = pci_bridge_reset,

    .init = apb_pci_bridge_initfn,

    .exit = pci_bridge_exitfn,

    .vendor_id = PCI_VENDOR_ID_SUN,

    .device_id = PCI_DEVICE_ID_SUN_SIMBA,

    .revision = 0x11,

    .config_write = pci_bridge_write_config,

    .is_bridge = 1,

static void pbm_pci_bridge_class_init(ObjectClass *klass, void *data)

{

    PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);



    k->init = apb_pci_bridge_initfn;

    k->exit = pci_bridge_exitfn;

    k->vendor_id = PCI_VENDOR_ID_SUN;

    k->device_id = PCI_DEVICE_ID_SUN_SIMBA;

    k->revision = 0x11;

    k->config_write = pci_bridge_write_config;

    k->is_bridge = 1;

}



static DeviceInfo pbm_pci_bridge_info = {

    .name = "pbm-bridge",

    .size = sizeof(PCIBridge),

    .vmsd = &vmstate_pci_device,

    .reset = pci_bridge_reset,

    .class_init = pbm_pci_bridge_class_init,

};



static void pbm_register_devices(void)

hw/bonito.c

+18 −12
Original line number Diff line number Diff line
@@ -766,18 +766,24 @@ PCIBus *bonito_init(qemu_irq *pic) 
    return b;

}



static PCIDeviceInfo bonito_info = {

    .qdev.name    = "Bonito",

    .qdev.desc    = "Host bridge",

    .qdev.size    = sizeof(PCIBonitoState),

    .qdev.vmsd    = &vmstate_bonito,

    .qdev.no_user = 1,

    .init         = bonito_initfn,

    /*Bonito North Bridge, built on FPGA, VENDOR_ID/DEVICE_ID are "undefined"*/

    .vendor_id    = 0xdf53,

    .device_id    = 0x00d5,

    .revision     = 0x01,

    .class_id     = PCI_CLASS_BRIDGE_HOST,

static void bonito_class_init(ObjectClass *klass, void *data)

{

    PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);



    k->init = bonito_initfn;

    k->vendor_id = 0xdf53;

    k->device_id = 0x00d5;

    k->revision = 0x01;

    k->class_id = PCI_CLASS_BRIDGE_HOST;

}



static DeviceInfo bonito_info = {

    .name = "Bonito",

    .desc = "Host bridge",

    .size = sizeof(PCIBonitoState),

    .vmsd = &vmstate_bonito,

    .no_user = 1,

    .class_init = bonito_class_init,

};



static SysBusDeviceInfo bonito_pcihost_info = {