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