hw/pci-bridge/pcie_pci_bridge.c

   1 /*
   2  * QEMU Generic PCIE-PCI Bridge
   3  *
   4  * Copyright (c) 2017 Aleksandr Bezzubikov
   5  *
   6  * This work is licensed under the terms of the GNU GPL, version 2 or later.
   7  * See the COPYING file in the top-level directory.
   8  */
   9
  10 #include "qemu/osdep.h"
  11 #include "qapi/error.h"
  12 #include "hw/pci/pci.h"
  13 #include "hw/pci/pci_bus.h"
  14 #include "hw/pci/pci_bridge.h"
  15 #include "hw/pci/msi.h"
  16 #include "hw/pci/shpc.h"
  17 #include "hw/pci/slotid_cap.h"
  18
  19 typedef struct PCIEPCIBridge {
  20     /*< private >*/
  21     PCIBridge parent_obj;
  22
  23     OnOffAuto msi;
  24     MemoryRegion shpc_bar;
  25     /*< public >*/
  26 } PCIEPCIBridge;
  27
  28 #define TYPE_PCIE_PCI_BRIDGE_DEV "pcie-pci-bridge"
  29 #define PCIE_PCI_BRIDGE_DEV(obj) \
  30         OBJECT_CHECK(PCIEPCIBridge, (obj), TYPE_PCIE_PCI_BRIDGE_DEV)
  31
  32 static void pcie_pci_bridge_realize(PCIDevice *d, Error **errp)
  33 {
  34     PCIBridge *br = PCI_BRIDGE(d);
  35     PCIEPCIBridge *pcie_br = PCIE_PCI_BRIDGE_DEV(d);
  36     int rc, pos;
  37
  38     pci_bridge_initfn(d, TYPE_PCI_BUS);
  39
  40     d->config[PCI_INTERRUPT_PIN] = 0x1;
  41     memory_region_init(&pcie_br->shpc_bar, OBJECT(d), "shpc-bar",
  42                        shpc_bar_size(d));
  43     rc = shpc_init(d, &br->sec_bus, &pcie_br->shpc_bar, 0, errp);
  44     if (rc) {
  45         goto error;
  46     }
  47
  48     rc = pcie_cap_init(d, 0, PCI_EXP_TYPE_PCI_BRIDGE, 0, errp);
  49     if (rc < 0) {
  50         goto cap_error;
  51     }
  52
  53     pos = pci_add_capability(d, PCI_CAP_ID_PM, 0, PCI_PM_SIZEOF, errp);
  54     if (pos < 0) {
  55         goto pm_error;
  56     }
  57     d->exp.pm_cap = pos;
  58     pci_set_word(d->config + pos + PCI_PM_PMC, 0x3);
  59
  60     pcie_cap_arifwd_init(d);
  61     pcie_cap_deverr_init(d);
  62
  63     rc = pcie_aer_init(d, PCI_ERR_VER, 0x100, PCI_ERR_SIZEOF, errp);
  64     if (rc < 0) {
  65         goto aer_error;
  66     }
  67
  68     Error *local_err = NULL;
  69     if (pcie_br->msi != ON_OFF_AUTO_OFF) {
  70         rc = msi_init(d, 0, 1, true, true, &local_err);
  71         if (rc < 0) {
  72             assert(rc == -ENOTSUP);
  73             if (pcie_br->msi != ON_OFF_AUTO_ON) {
  74                 error_free(local_err);
  75             } else {
  76                 /* failed to satisfy user's explicit request for MSI */
  77                 error_propagate(errp, local_err);
  78                 goto msi_error;
  79             }
  80         }
  81     }
  82     pci_register_bar(d, 0, PCI_BASE_ADDRESS_SPACE_MEMORY |
  83                      PCI_BASE_ADDRESS_MEM_TYPE_64, &pcie_br->shpc_bar);
  84     return;
  85
  86 msi_error:
  87     pcie_aer_exit(d);
  88 aer_error:
  89 pm_error:
  90     pcie_cap_exit(d);
  91 cap_error:
  92     shpc_cleanup(d, &pcie_br->shpc_bar);
  93 error:
  94     pci_bridge_exitfn(d);
  95 }
  96
  97 static void pcie_pci_bridge_exit(PCIDevice *d)
  98 {
  99     PCIEPCIBridge *bridge_dev = PCIE_PCI_BRIDGE_DEV(d);
 100     pcie_cap_exit(d);
 101     shpc_cleanup(d, &bridge_dev->shpc_bar);
 102     pci_bridge_exitfn(d);
 103 }
 104
 105 static void pcie_pci_bridge_reset(DeviceState *qdev)
 106 {
 107     PCIDevice *d = PCI_DEVICE(qdev);
 108     pci_bridge_reset(qdev);
 109     if (msi_present(d)) {
 110         msi_reset(d);
 111     }
 112     shpc_reset(d);
 113 }
 114
 115 static void pcie_pci_bridge_write_config(PCIDevice *d,
 116         uint32_t address, uint32_t val, int len)
 117 {
 118     pci_bridge_write_config(d, address, val, len);
 119     if (msi_present(d)) {
 120         msi_write_config(d, address, val, len);
 121     }
 122     shpc_cap_write_config(d, address, val, len);
 123 }
 124
 125 static Property pcie_pci_bridge_dev_properties[] = {
 126         DEFINE_PROP_ON_OFF_AUTO("msi", PCIEPCIBridge, msi, ON_OFF_AUTO_AUTO),
 127         DEFINE_PROP_END_OF_LIST(),
 128 };
 129
 130 static const VMStateDescription pcie_pci_bridge_dev_vmstate = {
 131         .name = TYPE_PCIE_PCI_BRIDGE_DEV,
 132         .fields = (VMStateField[]) {
 133             VMSTATE_PCI_DEVICE(parent_obj, PCIBridge),
 134             SHPC_VMSTATE(shpc, PCIDevice, NULL),
 135             VMSTATE_END_OF_LIST()
 136         }
 137 };
 138
 139 static void pcie_pci_bridge_hotplug_cb(HotplugHandler *hotplug_dev,
 140                                       DeviceState *dev, Error **errp)
 141 {
 142     PCIDevice *pci_hotplug_dev = PCI_DEVICE(hotplug_dev);
 143
 144     if (!shpc_present(pci_hotplug_dev)) {
 145         error_setg(errp, "standard hotplug controller has been disabled for "
 146                    "this %s", TYPE_PCIE_PCI_BRIDGE_DEV);
 147         return;
 148     }
 149     shpc_device_hotplug_cb(hotplug_dev, dev, errp);
 150 }
 151
 152 static void pcie_pci_bridge_hot_unplug_request_cb(HotplugHandler *hotplug_dev,
 153                                                  DeviceState *dev,
 154                                                  Error **errp)
 155 {
 156     PCIDevice *pci_hotplug_dev = PCI_DEVICE(hotplug_dev);
 157
 158     if (!shpc_present(pci_hotplug_dev)) {
 159         error_setg(errp, "standard hotplug controller has been disabled for "
 160                    "this %s", TYPE_PCIE_PCI_BRIDGE_DEV);
 161         return;
 162     }
 163     shpc_device_hot_unplug_request_cb(hotplug_dev, dev, errp);
 164 }
 165
 166 static void pcie_pci_bridge_class_init(ObjectClass *klass, void *data)
 167 {
 168     PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);
 169     DeviceClass *dc = DEVICE_CLASS(klass);
 170     HotplugHandlerClass *hc = HOTPLUG_HANDLER_CLASS(klass);
 171
 172     k->is_express = 1;
 173     k->is_bridge = 1;
 174     k->vendor_id = PCI_VENDOR_ID_REDHAT;
 175     k->device_id = PCI_DEVICE_ID_REDHAT_PCIE_BRIDGE;
 176     k->realize = pcie_pci_bridge_realize;
 177     k->exit = pcie_pci_bridge_exit;
 178     k->config_write = pcie_pci_bridge_write_config;
 179     dc->vmsd = &pcie_pci_bridge_dev_vmstate;
 180     dc->props = pcie_pci_bridge_dev_properties;
 181     dc->vmsd = &pcie_pci_bridge_dev_vmstate;
 182     dc->reset = &pcie_pci_bridge_reset;
 183     set_bit(DEVICE_CATEGORY_BRIDGE, dc->categories);
 184     hc->plug = pcie_pci_bridge_hotplug_cb;
 185     hc->unplug_request = pcie_pci_bridge_hot_unplug_request_cb;
 186 }
 187
 188 static const TypeInfo pcie_pci_bridge_info = {
 189         .name = TYPE_PCIE_PCI_BRIDGE_DEV,
 190         .parent = TYPE_PCI_BRIDGE,
 191         .instance_size = sizeof(PCIEPCIBridge),
 192         .class_init = pcie_pci_bridge_class_init,
 193         .interfaces = (InterfaceInfo[]) {
 194             { TYPE_HOTPLUG_HANDLER },
 195             { INTERFACE_PCIE_DEVICE },
 196             { },
 197         }
 198 };
 199
 200 static void pciepci_register(void)
 201 {
 202     type_register_static(&pcie_pci_bridge_info);
 203 }
 204
 205 type_init(pciepci_register);