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)
383