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