/ - Diff - qemu - Greek Research and Technology Network's projects

     #include "hw/pci/pci_bus.h"
     #include "hw/pci/pcie_regs.h"
     #include "qemu/range.h"
     #include "qapi/qmp/qerror.h"
     //#define DEBUG_PCIE
     #ifdef DEBUG_PCIE
-...
         hotplug_event_notify(dev);
+    }
     static int pcie_cap_slot_hotplug(DeviceState *qdev,
                                      PCIDevice *pci_dev, PCIHotplugState state)
     static void pcie_cap_slot_hotplug_common(PCIDevice *hotplug_dev,
                                              DeviceState *dev,
                                              uint8_t **exp_cap, Error **errp)
+    {
         PCIDevice *d = PCI_DEVICE(qdev);
         uint8_t *exp_cap = d->config + d->exp.exp_cap;
         uint16_t sltsta = pci_get_word(exp_cap + PCI_EXP_SLTSTA);
         /* 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
          * event when the device is disabled later. */
         if (state == PCI_COLDPLUG_ENABLED) {
             pci_word_test_and_set_mask(exp_cap + PCI_EXP_SLTSTA,
                                        PCI_EXP_SLTSTA_PDS);
             return 0;
+        }
         PCIDevice *pci_dev = PCI_DEVICE(dev);
         *exp_cap = hotplug_dev->config + hotplug_dev->exp.exp_cap;
         uint16_t sltsta = pci_get_word(*exp_cap + PCI_EXP_SLTSTA);
         PCIE_DEV_PRINTF(pci_dev, "hotplug state: %d\n", state);
         if (sltsta & PCI_EXP_SLTSTA_EIS) {
             /* the slot is electromechanically locked.
              * This error is propagated up to qdev and then to HMP/QMP.
              */
             return -EBUSY;
             error_setg_errno(errp, -EBUSY, "slot is electromechanically locked");
+        }
         /* TODO: multifunction hot-plug.
-...
          * hot plugged/unplugged.
          */
         assert(PCI_FUNC(pci_dev->devfn) == 0);
+    }
         if (state == PCI_HOTPLUG_ENABLED) {
     void pcie_cap_slot_hotplug_cb(HotplugHandler *hotplug_dev, DeviceState *dev,
                                   Error **errp)
+    {
         uint8_t *exp_cap;
         pcie_cap_slot_hotplug_common(PCI_DEVICE(hotplug_dev), dev, &exp_cap, errp);
         /* 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
          * event when the device is disabled later. */
         if (!dev->hotplugged) {
             pci_word_test_and_set_mask(exp_cap + PCI_EXP_SLTSTA,
                                        PCI_EXP_SLTSTA_PDS);
             pcie_cap_slot_event(d, PCI_EXP_HP_EV_PDC);
         } else {
             object_unparent(OBJECT(pci_dev));
             pci_word_test_and_clear_mask(exp_cap + PCI_EXP_SLTSTA,
                                          PCI_EXP_SLTSTA_PDS);
             pcie_cap_slot_event(d, PCI_EXP_HP_EV_PDC);
             return;
+        }
         return 0;
         pci_word_test_and_set_mask(exp_cap + PCI_EXP_SLTSTA,
                                    PCI_EXP_SLTSTA_PDS);
         pcie_cap_slot_event(PCI_DEVICE(hotplug_dev), PCI_EXP_HP_EV_PDC);
+    }
     void pcie_cap_slot_hot_unplug_cb(HotplugHandler *hotplug_dev, DeviceState *dev,
                                      Error **errp)
+    {
         uint8_t *exp_cap;
         pcie_cap_slot_hotplug_common(PCI_DEVICE(hotplug_dev), dev, &exp_cap, errp);
         object_unparent(OBJECT(dev));
         pci_word_test_and_clear_mask(exp_cap + PCI_EXP_SLTSTA,
                                      PCI_EXP_SLTSTA_PDS);
         pcie_cap_slot_event(PCI_DEVICE(hotplug_dev), PCI_EXP_HP_EV_PDC);
+    }
     /* pci express slot for pci express root/downstream port
-...
         dev->exp.hpev_notified = false;
         pci_bus_hotplug(pci_bridge_get_sec_bus(PCI_BRIDGE(dev)),
                         pcie_cap_slot_hotplug, &dev->qdev);
         qbus_set_hotplug_handler(BUS(pci_bridge_get_sec_bus(PCI_BRIDGE(dev))),
                                  DEVICE(dev), NULL);
+    }
     void pcie_cap_slot_reset(PCIDevice *dev)

      */
     #include "hw/pci/pcie_port.h"
     #include "hw/hotplug.h"
     void pcie_port_init_reg(PCIDevice *d)
+    {
-...
     static void pcie_slot_class_init(ObjectClass *oc, void *data)
+    {
         DeviceClass *dc = DEVICE_CLASS(oc);
         HotplugHandlerClass *hc = HOTPLUG_HANDLER_CLASS(oc);
         dc->props = pcie_slot_props;
         hc->plug = pcie_cap_slot_hotplug_cb;
         hc->unplug = pcie_cap_slot_hot_unplug_cb;
+    }
     static const TypeInfo pcie_slot_type_info = {
-...
         .instance_size = sizeof(PCIESlot),
         .abstract = true,
         .class_init = pcie_slot_class_init,
         .interfaces = (InterfaceInfo[]) {
             { TYPE_HOTPLUG_HANDLER },
             { }
+        }
     };
     static void pcie_port_register_types(void)

     #include "hw/pci/pci_regs.h"
     #include "hw/pci/pcie_regs.h"
     #include "hw/pci/pcie_aer.h"
     #include "hw/hotplug.h"
     typedef enum {
         /* for attention and power indicator */
-...
         .offset     = vmstate_offset_value(_state, _field, PCIDevice),   \
+    }
     void pcie_cap_slot_hotplug_cb(HotplugHandler *hotplug_dev, DeviceState *dev,
                                   Error **errp);
     void pcie_cap_slot_hot_unplug_cb(HotplugHandler *hotplug_dev, DeviceState *dev,
                                      Error **errp);
     #endif /* QEMU_PCIE_H */

Archipelago » qemu

Revision a66e657e