hw/pci-bridge/pci_expander_bridge.c

   1 /*
   2  * PCI Expander Bridge Device Emulation
   3  *
   4  * Copyright (C) 2015 Red Hat Inc
   5  *
   6  * Authors:
   7  *   Marcel Apfelbaum <marcel@redhat.com>
   8  *
   9  * This work is licensed under the terms of the GNU GPL, version 2 or later.
  10  * See the COPYING file in the top-level directory.
  11  */
  12
  13 #include "qemu/osdep.h"
  14 #include "qapi/error.h"
  15 #include "hw/pci/pci.h"
  16 #include "hw/pci/pci_bus.h"
  17 #include "hw/pci/pci_host.h"
  18 #include "hw/qdev-properties.h"
  19 #include "hw/pci/pci_bridge.h"
  20 #include "qemu/range.h"
  21 #include "qemu/error-report.h"
  22 #include "qemu/module.h"
  23 #include "sysemu/numa.h"
  24 #include "hw/boards.h"
  25 #include "qom/object.h"
  26
  27 #define TYPE_PXB_BUS "pxb-bus"
  28 typedef struct PXBBus PXBBus;
  29 DECLARE_INSTANCE_CHECKER(PXBBus, PXB_BUS,
  30                          TYPE_PXB_BUS)
  31
  32 #define TYPE_PXB_PCIE_BUS "pxb-pcie-bus"
  33 DECLARE_INSTANCE_CHECKER(PXBBus, PXB_PCIE_BUS,
  34                          TYPE_PXB_PCIE_BUS)
  35
  36 struct PXBBus {
  37     /*< private >*/
  38     PCIBus parent_obj;
  39     /*< public >*/
  40
  41     char bus_path[8];
  42 };
  43
  44 #define TYPE_PXB_DEVICE "pxb"
  45 typedef struct PXBDev PXBDev;
  46 DECLARE_INSTANCE_CHECKER(PXBDev, PXB_DEV,
  47                          TYPE_PXB_DEVICE)
  48
  49 #define TYPE_PXB_PCIE_DEVICE "pxb-pcie"
  50 DECLARE_INSTANCE_CHECKER(PXBDev, PXB_PCIE_DEV,
  51                          TYPE_PXB_PCIE_DEVICE)
  52
  53 struct PXBDev {
  54     /*< private >*/
  55     PCIDevice parent_obj;
  56     /*< public >*/
  57
  58     uint8_t bus_nr;
  59     uint16_t numa_node;
  60 };
  61
  62 static PXBDev *convert_to_pxb(PCIDevice *dev)
  63 {
  64     return pci_bus_is_express(pci_get_bus(dev))
  65         ? PXB_PCIE_DEV(dev) : PXB_DEV(dev);
  66 }
  67
  68 static GList *pxb_dev_list;
  69
  70 #define TYPE_PXB_HOST "pxb-host"
  71
  72 static int pxb_bus_num(PCIBus *bus)
  73 {
  74     PXBDev *pxb = convert_to_pxb(bus->parent_dev);
  75
  76     return pxb->bus_nr;
  77 }
  78
  79 static uint16_t pxb_bus_numa_node(PCIBus *bus)
  80 {
  81     PXBDev *pxb = convert_to_pxb(bus->parent_dev);
  82
  83     return pxb->numa_node;
  84 }
  85
  86 static void pxb_bus_class_init(ObjectClass *class, void *data)
  87 {
  88     PCIBusClass *pbc = PCI_BUS_CLASS(class);
  89
  90     pbc->bus_num = pxb_bus_num;
  91     pbc->numa_node = pxb_bus_numa_node;
  92 }
  93
  94 static const TypeInfo pxb_bus_info = {
  95     .name          = TYPE_PXB_BUS,
  96     .parent        = TYPE_PCI_BUS,
  97     .instance_size = sizeof(PXBBus),
  98     .class_init    = pxb_bus_class_init,
  99 };
 100
 101 static const TypeInfo pxb_pcie_bus_info = {
 102     .name          = TYPE_PXB_PCIE_BUS,
 103     .parent        = TYPE_PCIE_BUS,
 104     .instance_size = sizeof(PXBBus),
 105     .class_init    = pxb_bus_class_init,
 106 };
 107
 108 static const char *pxb_host_root_bus_path(PCIHostState *host_bridge,
 109                                           PCIBus *rootbus)
 110 {
 111     PXBBus *bus = pci_bus_is_express(rootbus) ?
 112                   PXB_PCIE_BUS(rootbus) : PXB_BUS(rootbus);
 113
 114     snprintf(bus->bus_path, 8, "0000:%02x", pxb_bus_num(rootbus));
 115     return bus->bus_path;
 116 }
 117
 118 static char *pxb_host_ofw_unit_address(const SysBusDevice *dev)
 119 {
 120     const PCIHostState *pxb_host;
 121     const PCIBus *pxb_bus;
 122     const PXBDev *pxb_dev;
 123     int position;
 124     const DeviceState *pxb_dev_base;
 125     const PCIHostState *main_host;
 126     const SysBusDevice *main_host_sbd;
 127
 128     pxb_host = PCI_HOST_BRIDGE(dev);
 129     pxb_bus = pxb_host->bus;
 130     pxb_dev = convert_to_pxb(pxb_bus->parent_dev);
 131     position = g_list_index(pxb_dev_list, pxb_dev);
 132     assert(position >= 0);
 133
 134     pxb_dev_base = DEVICE(pxb_dev);
 135     main_host = PCI_HOST_BRIDGE(pxb_dev_base->parent_bus->parent);
 136     main_host_sbd = SYS_BUS_DEVICE(main_host);
 137
 138     if (main_host_sbd->num_mmio > 0) {
 139         return g_strdup_printf(TARGET_FMT_plx ",%x",
 140                                main_host_sbd->mmio[0].addr, position + 1);
 141     }
 142     if (main_host_sbd->num_pio > 0) {
 143         return g_strdup_printf("i%04x,%x",
 144                                main_host_sbd->pio[0], position + 1);
 145     }
 146     return NULL;
 147 }
 148
 149 static void pxb_host_class_init(ObjectClass *class, void *data)
 150 {
 151     DeviceClass *dc = DEVICE_CLASS(class);
 152     SysBusDeviceClass *sbc = SYS_BUS_DEVICE_CLASS(class);
 153     PCIHostBridgeClass *hc = PCI_HOST_BRIDGE_CLASS(class);
 154
 155     dc->fw_name = "pci";
 156     /* Reason: Internal part of the pxb/pxb-pcie device, not usable by itself */
 157     dc->user_creatable = false;
 158     sbc->explicit_ofw_unit_address = pxb_host_ofw_unit_address;
 159     hc->root_bus_path = pxb_host_root_bus_path;
 160 }
 161
 162 static const TypeInfo pxb_host_info = {
 163     .name          = TYPE_PXB_HOST,
 164     .parent        = TYPE_PCI_HOST_BRIDGE,
 165     .class_init    = pxb_host_class_init,
 166 };
 167
 168 /*
 169  * Registers the PXB bus as a child of pci host root bus.
 170  */
 171 static void pxb_register_bus(PCIDevice *dev, PCIBus *pxb_bus, Error **errp)
 172 {
 173     PCIBus *bus = pci_get_bus(dev);
 174     int pxb_bus_num = pci_bus_num(pxb_bus);
 175
 176     if (bus->parent_dev) {
 177         error_setg(errp, "PXB devices can be attached only to root bus");
 178         return;
 179     }
 180
 181     QLIST_FOREACH(bus, &bus->child, sibling) {
 182         if (pci_bus_num(bus) == pxb_bus_num) {
 183             error_setg(errp, "Bus %d is already in use", pxb_bus_num);
 184             return;
 185         }
 186     }
 187     QLIST_INSERT_HEAD(&pci_get_bus(dev)->child, pxb_bus, sibling);
 188 }
 189
 190 static int pxb_map_irq_fn(PCIDevice *pci_dev, int pin)
 191 {
 192     PCIDevice *pxb = pci_get_bus(pci_dev)->parent_dev;
 193
 194     /*
 195      * The bios does not index the pxb slot number when
 196      * it computes the IRQ because it resides on bus 0
 197      * and not on the current bus.
 198      * However QEMU routes the irq through bus 0 and adds
 199      * the pxb slot to the IRQ computation of the PXB
 200      * device.
 201      *
 202      * Synchronize between bios and QEMU by canceling
 203      * pxb's effect.
 204      */
 205     return pin - PCI_SLOT(pxb->devfn);
 206 }
 207
 208 static gint pxb_compare(gconstpointer a, gconstpointer b)
 209 {
 210     const PXBDev *pxb_a = a, *pxb_b = b;
 211
 212     return pxb_a->bus_nr < pxb_b->bus_nr ? -1 :
 213            pxb_a->bus_nr > pxb_b->bus_nr ?  1 :
 214            0;
 215 }
 216
 217 static void pxb_dev_realize_common(PCIDevice *dev, bool pcie, Error **errp)
 218 {
 219     PXBDev *pxb = convert_to_pxb(dev);
 220     DeviceState *ds, *bds = NULL;
 221     PCIBus *bus;
 222     const char *dev_name = NULL;
 223     Error *local_err = NULL;
 224     MachineState *ms = MACHINE(qdev_get_machine());
 225
 226     if (ms->numa_state == NULL) {
 227         error_setg(errp, "NUMA is not supported by this machine-type");
 228         return;
 229     }
 230
 231     if (pxb->numa_node != NUMA_NODE_UNASSIGNED &&
 232         pxb->numa_node >= ms->numa_state->num_nodes) {
 233         error_setg(errp, "Illegal numa node %d", pxb->numa_node);
 234         return;
 235     }
 236
 237     if (dev->qdev.id && *dev->qdev.id) {
 238         dev_name = dev->qdev.id;
 239     }
 240
 241     ds = qdev_new(TYPE_PXB_HOST);
 242     if (pcie) {
 243         bus = pci_root_bus_new(ds, dev_name, NULL, NULL, 0, TYPE_PXB_PCIE_BUS);
 244     } else {
 245         bus = pci_root_bus_new(ds, "pxb-internal", NULL, NULL, 0, TYPE_PXB_BUS);
 246         bds = qdev_new("pci-bridge");
 247         bds->id = dev_name;
 248         qdev_prop_set_uint8(bds, PCI_BRIDGE_DEV_PROP_CHASSIS_NR, pxb->bus_nr);
 249         qdev_prop_set_bit(bds, PCI_BRIDGE_DEV_PROP_SHPC, false);
 250     }
 251
 252     bus->parent_dev = dev;
 253     bus->address_space_mem = pci_get_bus(dev)->address_space_mem;
 254     bus->address_space_io = pci_get_bus(dev)->address_space_io;
 255     bus->map_irq = pxb_map_irq_fn;
 256
 257     PCI_HOST_BRIDGE(ds)->bus = bus;
 258
 259     pxb_register_bus(dev, bus, &local_err);
 260     if (local_err) {
 261         error_propagate(errp, local_err);
 262         goto err_register_bus;
 263     }
 264
 265     sysbus_realize_and_unref(SYS_BUS_DEVICE(ds), &error_fatal);
 266     if (bds) {
 267         qdev_realize_and_unref(bds, &bus->qbus, &error_fatal);
 268     }
 269
 270     pci_word_test_and_set_mask(dev->config + PCI_STATUS,
 271                                PCI_STATUS_66MHZ | PCI_STATUS_FAST_BACK);
 272     pci_config_set_class(dev->config, PCI_CLASS_BRIDGE_HOST);
 273
 274     pxb_dev_list = g_list_insert_sorted(pxb_dev_list, pxb, pxb_compare);
 275     return;
 276
 277 err_register_bus:
 278     object_unref(OBJECT(bds));
 279     object_unparent(OBJECT(bus));
 280     object_unref(OBJECT(ds));
 281 }
 282
 283 static void pxb_dev_realize(PCIDevice *dev, Error **errp)
 284 {
 285     if (pci_bus_is_express(pci_get_bus(dev))) {
 286         error_setg(errp, "pxb devices cannot reside on a PCIe bus");
 287         return;
 288     }
 289
 290     pxb_dev_realize_common(dev, false, errp);
 291 }
 292
 293 static void pxb_dev_exitfn(PCIDevice *pci_dev)
 294 {
 295     PXBDev *pxb = convert_to_pxb(pci_dev);
 296
 297     pxb_dev_list = g_list_remove(pxb_dev_list, pxb);
 298 }
 299
 300 static Property pxb_dev_properties[] = {
 301     /* Note: 0 is not a legal PXB bus number. */
 302     DEFINE_PROP_UINT8("bus_nr", PXBDev, bus_nr, 0),
 303     DEFINE_PROP_UINT16("numa_node", PXBDev, numa_node, NUMA_NODE_UNASSIGNED),
 304     DEFINE_PROP_END_OF_LIST(),
 305 };
 306
 307 static void pxb_dev_class_init(ObjectClass *klass, void *data)
 308 {
 309     DeviceClass *dc = DEVICE_CLASS(klass);
 310     PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);
 311
 312     k->realize = pxb_dev_realize;
 313     k->exit = pxb_dev_exitfn;
 314     k->vendor_id = PCI_VENDOR_ID_REDHAT;
 315     k->device_id = PCI_DEVICE_ID_REDHAT_PXB;
 316     k->class_id = PCI_CLASS_BRIDGE_HOST;
 317
 318     dc->desc = "PCI Expander Bridge";
 319     device_class_set_props(dc, pxb_dev_properties);
 320     dc->hotpluggable = false;
 321     set_bit(DEVICE_CATEGORY_BRIDGE, dc->categories);
 322 }
 323
 324 static const TypeInfo pxb_dev_info = {
 325     .name          = TYPE_PXB_DEVICE,
 326     .parent        = TYPE_PCI_DEVICE,
 327     .instance_size = sizeof(PXBDev),
 328     .class_init    = pxb_dev_class_init,
 329     .interfaces = (InterfaceInfo[]) {
 330         { INTERFACE_CONVENTIONAL_PCI_DEVICE },
 331         { },
 332     },
 333 };
 334
 335 static void pxb_pcie_dev_realize(PCIDevice *dev, Error **errp)
 336 {
 337     if (!pci_bus_is_express(pci_get_bus(dev))) {
 338         error_setg(errp, "pxb-pcie devices cannot reside on a PCI bus");
 339         return;
 340     }
 341
 342     pxb_dev_realize_common(dev, true, errp);
 343 }
 344
 345 static void pxb_pcie_dev_class_init(ObjectClass *klass, void *data)
 346 {
 347     DeviceClass *dc = DEVICE_CLASS(klass);
 348     PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);
 349
 350     k->realize = pxb_pcie_dev_realize;
 351     k->exit = pxb_dev_exitfn;
 352     k->vendor_id = PCI_VENDOR_ID_REDHAT;
 353     k->device_id = PCI_DEVICE_ID_REDHAT_PXB_PCIE;
 354     k->class_id = PCI_CLASS_BRIDGE_HOST;
 355
 356     dc->desc = "PCI Express Expander Bridge";
 357     device_class_set_props(dc, pxb_dev_properties);
 358     dc->hotpluggable = false;
 359     set_bit(DEVICE_CATEGORY_BRIDGE, dc->categories);
 360 }
 361
 362 static const TypeInfo pxb_pcie_dev_info = {
 363     .name          = TYPE_PXB_PCIE_DEVICE,
 364     .parent        = TYPE_PCI_DEVICE,
 365     .instance_size = sizeof(PXBDev),
 366     .class_init    = pxb_pcie_dev_class_init,
 367     .interfaces = (InterfaceInfo[]) {
 368         { INTERFACE_CONVENTIONAL_PCI_DEVICE },
 369         { },
 370     },
 371 };
 372
 373 static void pxb_register_types(void)
 374 {
 375     type_register_static(&pxb_bus_info);
 376     type_register_static(&pxb_pcie_bus_info);
 377     type_register_static(&pxb_host_info);
 378     type_register_static(&pxb_dev_info);
 379     type_register_static(&pxb_pcie_dev_info);
 380 }
 381
 382 type_init(pxb_register_types)