1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26#include "qemu/osdep.h"
27#include "qapi/error.h"
28#include "cpu.h"
29#include "hw/irq.h"
30#include "hw/sysbus.h"
31#include "migration/vmstate.h"
32#include "hw/pci/pci.h"
33#include "hw/pci/msi.h"
34#include "hw/pci/msix.h"
35#include "hw/pci/pci_host.h"
36#include "hw/ppc/spapr.h"
37#include "hw/pci-host/spapr.h"
38#include "exec/address-spaces.h"
39#include "exec/ram_addr.h"
40#include <libfdt.h>
41#include "trace.h"
42#include "qemu/error-report.h"
43#include "qemu/module.h"
44#include "qapi/qmp/qerror.h"
45#include "hw/ppc/fdt.h"
46#include "hw/pci/pci_bridge.h"
47#include "hw/pci/pci_bus.h"
48#include "hw/pci/pci_ids.h"
49#include "hw/ppc/spapr_drc.h"
50#include "hw/qdev-properties.h"
51#include "sysemu/device_tree.h"
52#include "sysemu/kvm.h"
53#include "sysemu/hostmem.h"
54#include "sysemu/numa.h"
55
56
57#define RTAS_QUERY_FN 0
58#define RTAS_CHANGE_FN 1
59#define RTAS_RESET_FN 2
60#define RTAS_CHANGE_MSI_FN 3
61#define RTAS_CHANGE_MSIX_FN 4
62
63
64#define RTAS_TYPE_MSI 1
65#define RTAS_TYPE_MSIX 2
66
67SpaprPhbState *spapr_pci_find_phb(SpaprMachineState *spapr, uint64_t buid)
68{
69 SpaprPhbState *sphb;
70
71 QLIST_FOREACH(sphb, &spapr->phbs, list) {
72 if (sphb->buid != buid) {
73 continue;
74 }
75 return sphb;
76 }
77
78 return NULL;
79}
80
81PCIDevice *spapr_pci_find_dev(SpaprMachineState *spapr, uint64_t buid,
82 uint32_t config_addr)
83{
84 SpaprPhbState *sphb = spapr_pci_find_phb(spapr, buid);
85 PCIHostState *phb = PCI_HOST_BRIDGE(sphb);
86 int bus_num = (config_addr >> 16) & 0xFF;
87 int devfn = (config_addr >> 8) & 0xFF;
88
89 if (!phb) {
90 return NULL;
91 }
92
93 return pci_find_device(phb->bus, bus_num, devfn);
94}
95
96static uint32_t rtas_pci_cfgaddr(uint32_t arg)
97{
98
99 return ((arg >> 20) & 0xf00) | (arg & 0xff);
100}
101
102static void finish_read_pci_config(SpaprMachineState *spapr, uint64_t buid,
103 uint32_t addr, uint32_t size,
104 target_ulong rets)
105{
106 PCIDevice *pci_dev;
107 uint32_t val;
108
109 if ((size != 1) && (size != 2) && (size != 4)) {
110
111 rtas_st(rets, 0, RTAS_OUT_HW_ERROR);
112 return;
113 }
114
115 pci_dev = spapr_pci_find_dev(spapr, buid, addr);
116 addr = rtas_pci_cfgaddr(addr);
117
118 if (!pci_dev || (addr % size) || (addr >= pci_config_size(pci_dev))) {
119
120
121 rtas_st(rets, 0, RTAS_OUT_HW_ERROR);
122 return;
123 }
124
125 val = pci_host_config_read_common(pci_dev, addr,
126 pci_config_size(pci_dev), size);
127
128 rtas_st(rets, 0, RTAS_OUT_SUCCESS);
129 rtas_st(rets, 1, val);
130}
131
132static void rtas_ibm_read_pci_config(PowerPCCPU *cpu, SpaprMachineState *spapr,
133 uint32_t token, uint32_t nargs,
134 target_ulong args,
135 uint32_t nret, target_ulong rets)
136{
137 uint64_t buid;
138 uint32_t size, addr;
139
140 if ((nargs != 4) || (nret != 2)) {
141 rtas_st(rets, 0, RTAS_OUT_HW_ERROR);
142 return;
143 }
144
145 buid = rtas_ldq(args, 1);
146 size = rtas_ld(args, 3);
147 addr = rtas_ld(args, 0);
148
149 finish_read_pci_config(spapr, buid, addr, size, rets);
150}
151
152static void rtas_read_pci_config(PowerPCCPU *cpu, SpaprMachineState *spapr,
153 uint32_t token, uint32_t nargs,
154 target_ulong args,
155 uint32_t nret, target_ulong rets)
156{
157 uint32_t size, addr;
158
159 if ((nargs != 2) || (nret != 2)) {
160 rtas_st(rets, 0, RTAS_OUT_HW_ERROR);
161 return;
162 }
163
164 size = rtas_ld(args, 1);
165 addr = rtas_ld(args, 0);
166
167 finish_read_pci_config(spapr, 0, addr, size, rets);
168}
169
170static void finish_write_pci_config(SpaprMachineState *spapr, uint64_t buid,
171 uint32_t addr, uint32_t size,
172 uint32_t val, target_ulong rets)
173{
174 PCIDevice *pci_dev;
175
176 if ((size != 1) && (size != 2) && (size != 4)) {
177
178 rtas_st(rets, 0, RTAS_OUT_HW_ERROR);
179 return;
180 }
181
182 pci_dev = spapr_pci_find_dev(spapr, buid, addr);
183 addr = rtas_pci_cfgaddr(addr);
184
185 if (!pci_dev || (addr % size) || (addr >= pci_config_size(pci_dev))) {
186
187
188 rtas_st(rets, 0, RTAS_OUT_HW_ERROR);
189 return;
190 }
191
192 pci_host_config_write_common(pci_dev, addr, pci_config_size(pci_dev),
193 val, size);
194
195 rtas_st(rets, 0, RTAS_OUT_SUCCESS);
196}
197
198static void rtas_ibm_write_pci_config(PowerPCCPU *cpu, SpaprMachineState *spapr,
199 uint32_t token, uint32_t nargs,
200 target_ulong args,
201 uint32_t nret, target_ulong rets)
202{
203 uint64_t buid;
204 uint32_t val, size, addr;
205
206 if ((nargs != 5) || (nret != 1)) {
207 rtas_st(rets, 0, RTAS_OUT_HW_ERROR);
208 return;
209 }
210
211 buid = rtas_ldq(args, 1);
212 val = rtas_ld(args, 4);
213 size = rtas_ld(args, 3);
214 addr = rtas_ld(args, 0);
215
216 finish_write_pci_config(spapr, buid, addr, size, val, rets);
217}
218
219static void rtas_write_pci_config(PowerPCCPU *cpu, SpaprMachineState *spapr,
220 uint32_t token, uint32_t nargs,
221 target_ulong args,
222 uint32_t nret, target_ulong rets)
223{
224 uint32_t val, size, addr;
225
226 if ((nargs != 3) || (nret != 1)) {
227 rtas_st(rets, 0, RTAS_OUT_HW_ERROR);
228 return;
229 }
230
231
232 val = rtas_ld(args, 2);
233 size = rtas_ld(args, 1);
234 addr = rtas_ld(args, 0);
235
236 finish_write_pci_config(spapr, 0, addr, size, val, rets);
237}
238
239
240
241
242
243
244
245
246
247static void spapr_msi_setmsg(PCIDevice *pdev, hwaddr addr, bool msix,
248 unsigned first_irq, unsigned req_num)
249{
250 unsigned i;
251 MSIMessage msg = { .address = addr, .data = first_irq };
252
253 if (!msix) {
254 msi_set_message(pdev, msg);
255 trace_spapr_pci_msi_setup(pdev->name, 0, msg.address);
256 return;
257 }
258
259 for (i = 0; i < req_num; ++i) {
260 msix_set_message(pdev, i, msg);
261 trace_spapr_pci_msi_setup(pdev->name, i, msg.address);
262 if (addr) {
263 ++msg.data;
264 }
265 }
266}
267
268static void rtas_ibm_change_msi(PowerPCCPU *cpu, SpaprMachineState *spapr,
269 uint32_t token, uint32_t nargs,
270 target_ulong args, uint32_t nret,
271 target_ulong rets)
272{
273 SpaprMachineClass *smc = SPAPR_MACHINE_GET_CLASS(spapr);
274 uint32_t config_addr = rtas_ld(args, 0);
275 uint64_t buid = rtas_ldq(args, 1);
276 unsigned int func = rtas_ld(args, 3);
277 unsigned int req_num = rtas_ld(args, 4);
278 unsigned int seq_num = rtas_ld(args, 5);
279 unsigned int ret_intr_type;
280 unsigned int irq, max_irqs = 0;
281 SpaprPhbState *phb = NULL;
282 PCIDevice *pdev = NULL;
283 SpaprPciMsi *msi;
284 int *config_addr_key;
285 Error *err = NULL;
286 int i;
287
288
289 phb = spapr_pci_find_phb(spapr, buid);
290 if (phb) {
291 pdev = spapr_pci_find_dev(spapr, buid, config_addr);
292 }
293 if (!phb || !pdev) {
294 rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
295 return;
296 }
297
298 switch (func) {
299 case RTAS_CHANGE_FN:
300 if (msi_present(pdev)) {
301 ret_intr_type = RTAS_TYPE_MSI;
302 } else if (msix_present(pdev)) {
303 ret_intr_type = RTAS_TYPE_MSIX;
304 } else {
305 rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
306 return;
307 }
308 break;
309 case RTAS_CHANGE_MSI_FN:
310 if (msi_present(pdev)) {
311 ret_intr_type = RTAS_TYPE_MSI;
312 } else {
313 rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
314 return;
315 }
316 break;
317 case RTAS_CHANGE_MSIX_FN:
318 if (msix_present(pdev)) {
319 ret_intr_type = RTAS_TYPE_MSIX;
320 } else {
321 rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
322 return;
323 }
324 break;
325 default:
326 error_report("rtas_ibm_change_msi(%u) is not implemented", func);
327 rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
328 return;
329 }
330
331 msi = (SpaprPciMsi *) g_hash_table_lookup(phb->msi, &config_addr);
332
333
334 if (!req_num) {
335 if (!msi) {
336 trace_spapr_pci_msi("Releasing wrong config", config_addr);
337 rtas_st(rets, 0, RTAS_OUT_HW_ERROR);
338 return;
339 }
340
341 if (msi_present(pdev)) {
342 spapr_msi_setmsg(pdev, 0, false, 0, 0);
343 }
344 if (msix_present(pdev)) {
345 spapr_msi_setmsg(pdev, 0, true, 0, 0);
346 }
347 g_hash_table_remove(phb->msi, &config_addr);
348
349 trace_spapr_pci_msi("Released MSIs", config_addr);
350 rtas_st(rets, 0, RTAS_OUT_SUCCESS);
351 rtas_st(rets, 1, 0);
352 return;
353 }
354
355
356
357
358 if (ret_intr_type == RTAS_TYPE_MSI) {
359 max_irqs = msi_nr_vectors_allocated(pdev);
360 } else if (ret_intr_type == RTAS_TYPE_MSIX) {
361 max_irqs = pdev->msix_entries_nr;
362 }
363 if (!max_irqs) {
364 error_report("Requested interrupt type %d is not enabled for device %x",
365 ret_intr_type, config_addr);
366 rtas_st(rets, 0, -1);
367 return;
368 }
369
370 if (req_num > max_irqs) {
371 trace_spapr_pci_msi_retry(config_addr, req_num, max_irqs);
372 req_num = max_irqs;
373 irq = 0;
374 goto out;
375 }
376
377
378 if (smc->legacy_irq_allocation) {
379 irq = spapr_irq_find(spapr, req_num, ret_intr_type == RTAS_TYPE_MSI,
380 &err);
381 } else {
382 irq = spapr_irq_msi_alloc(spapr, req_num,
383 ret_intr_type == RTAS_TYPE_MSI, &err);
384 }
385 if (err) {
386 error_reportf_err(err, "Can't allocate MSIs for device %x: ",
387 config_addr);
388 rtas_st(rets, 0, RTAS_OUT_HW_ERROR);
389 return;
390 }
391
392 for (i = 0; i < req_num; i++) {
393 spapr_irq_claim(spapr, irq + i, false, &err);
394 if (err) {
395 if (i) {
396 spapr_irq_free(spapr, irq, i);
397 }
398 if (!smc->legacy_irq_allocation) {
399 spapr_irq_msi_free(spapr, irq, req_num);
400 }
401 error_reportf_err(err, "Can't allocate MSIs for device %x: ",
402 config_addr);
403 rtas_st(rets, 0, RTAS_OUT_HW_ERROR);
404 return;
405 }
406 }
407
408
409 if (msi) {
410 g_hash_table_remove(phb->msi, &config_addr);
411 }
412
413
414 spapr_msi_setmsg(pdev, SPAPR_PCI_MSI_WINDOW, ret_intr_type == RTAS_TYPE_MSIX,
415 irq, req_num);
416
417
418 msi = g_new(SpaprPciMsi, 1);
419 msi->first_irq = irq;
420 msi->num = req_num;
421 config_addr_key = g_new(int, 1);
422 *config_addr_key = config_addr;
423 g_hash_table_insert(phb->msi, config_addr_key, msi);
424
425out:
426 rtas_st(rets, 0, RTAS_OUT_SUCCESS);
427 rtas_st(rets, 1, req_num);
428 rtas_st(rets, 2, ++seq_num);
429 if (nret > 3) {
430 rtas_st(rets, 3, ret_intr_type);
431 }
432
433 trace_spapr_pci_rtas_ibm_change_msi(config_addr, func, req_num, irq);
434}
435
436static void rtas_ibm_query_interrupt_source_number(PowerPCCPU *cpu,
437 SpaprMachineState *spapr,
438 uint32_t token,
439 uint32_t nargs,
440 target_ulong args,
441 uint32_t nret,
442 target_ulong rets)
443{
444 uint32_t config_addr = rtas_ld(args, 0);
445 uint64_t buid = rtas_ldq(args, 1);
446 unsigned int intr_src_num = -1, ioa_intr_num = rtas_ld(args, 3);
447 SpaprPhbState *phb = NULL;
448 PCIDevice *pdev = NULL;
449 SpaprPciMsi *msi;
450
451
452 phb = spapr_pci_find_phb(spapr, buid);
453 if (phb) {
454 pdev = spapr_pci_find_dev(spapr, buid, config_addr);
455 }
456 if (!phb || !pdev) {
457 rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
458 return;
459 }
460
461
462 msi = (SpaprPciMsi *) g_hash_table_lookup(phb->msi, &config_addr);
463 if (!msi || !msi->first_irq || !msi->num || (ioa_intr_num >= msi->num)) {
464 trace_spapr_pci_msi("Failed to return vector", config_addr);
465 rtas_st(rets, 0, RTAS_OUT_HW_ERROR);
466 return;
467 }
468 intr_src_num = msi->first_irq + ioa_intr_num;
469 trace_spapr_pci_rtas_ibm_query_interrupt_source_number(ioa_intr_num,
470 intr_src_num);
471
472 rtas_st(rets, 0, RTAS_OUT_SUCCESS);
473 rtas_st(rets, 1, intr_src_num);
474 rtas_st(rets, 2, 1);
475}
476
477static void rtas_ibm_set_eeh_option(PowerPCCPU *cpu,
478 SpaprMachineState *spapr,
479 uint32_t token, uint32_t nargs,
480 target_ulong args, uint32_t nret,
481 target_ulong rets)
482{
483 SpaprPhbState *sphb;
484 uint32_t addr, option;
485 uint64_t buid;
486 int ret;
487
488 if ((nargs != 4) || (nret != 1)) {
489 goto param_error_exit;
490 }
491
492 buid = rtas_ldq(args, 1);
493 addr = rtas_ld(args, 0);
494 option = rtas_ld(args, 3);
495
496 sphb = spapr_pci_find_phb(spapr, buid);
497 if (!sphb) {
498 goto param_error_exit;
499 }
500
501 if (!spapr_phb_eeh_available(sphb)) {
502 goto param_error_exit;
503 }
504
505 ret = spapr_phb_vfio_eeh_set_option(sphb, addr, option);
506 rtas_st(rets, 0, ret);
507 return;
508
509param_error_exit:
510 rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
511}
512
513static void rtas_ibm_get_config_addr_info2(PowerPCCPU *cpu,
514 SpaprMachineState *spapr,
515 uint32_t token, uint32_t nargs,
516 target_ulong args, uint32_t nret,
517 target_ulong rets)
518{
519 SpaprPhbState *sphb;
520 PCIDevice *pdev;
521 uint32_t addr, option;
522 uint64_t buid;
523
524 if ((nargs != 4) || (nret != 2)) {
525 goto param_error_exit;
526 }
527
528 buid = rtas_ldq(args, 1);
529 sphb = spapr_pci_find_phb(spapr, buid);
530 if (!sphb) {
531 goto param_error_exit;
532 }
533
534 if (!spapr_phb_eeh_available(sphb)) {
535 goto param_error_exit;
536 }
537
538
539
540
541
542 option = rtas_ld(args, 3);
543 switch (option) {
544 case RTAS_GET_PE_ADDR:
545 addr = rtas_ld(args, 0);
546 pdev = spapr_pci_find_dev(spapr, buid, addr);
547 if (!pdev) {
548 goto param_error_exit;
549 }
550
551 rtas_st(rets, 1, (pci_bus_num(pci_get_bus(pdev)) << 16) + 1);
552 break;
553 case RTAS_GET_PE_MODE:
554 rtas_st(rets, 1, RTAS_PE_MODE_SHARED);
555 break;
556 default:
557 goto param_error_exit;
558 }
559
560 rtas_st(rets, 0, RTAS_OUT_SUCCESS);
561 return;
562
563param_error_exit:
564 rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
565}
566
567static void rtas_ibm_read_slot_reset_state2(PowerPCCPU *cpu,
568 SpaprMachineState *spapr,
569 uint32_t token, uint32_t nargs,
570 target_ulong args, uint32_t nret,
571 target_ulong rets)
572{
573 SpaprPhbState *sphb;
574 uint64_t buid;
575 int state, ret;
576
577 if ((nargs != 3) || (nret != 4 && nret != 5)) {
578 goto param_error_exit;
579 }
580
581 buid = rtas_ldq(args, 1);
582 sphb = spapr_pci_find_phb(spapr, buid);
583 if (!sphb) {
584 goto param_error_exit;
585 }
586
587 if (!spapr_phb_eeh_available(sphb)) {
588 goto param_error_exit;
589 }
590
591 ret = spapr_phb_vfio_eeh_get_state(sphb, &state);
592 rtas_st(rets, 0, ret);
593 if (ret != RTAS_OUT_SUCCESS) {
594 return;
595 }
596
597 rtas_st(rets, 1, state);
598 rtas_st(rets, 2, RTAS_EEH_SUPPORT);
599 rtas_st(rets, 3, RTAS_EEH_PE_UNAVAIL_INFO);
600 if (nret >= 5) {
601 rtas_st(rets, 4, RTAS_EEH_PE_RECOVER_INFO);
602 }
603 return;
604
605param_error_exit:
606 rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
607}
608
609static void rtas_ibm_set_slot_reset(PowerPCCPU *cpu,
610 SpaprMachineState *spapr,
611 uint32_t token, uint32_t nargs,
612 target_ulong args, uint32_t nret,
613 target_ulong rets)
614{
615 SpaprPhbState *sphb;
616 uint32_t option;
617 uint64_t buid;
618 int ret;
619
620 if ((nargs != 4) || (nret != 1)) {
621 goto param_error_exit;
622 }
623
624 buid = rtas_ldq(args, 1);
625 option = rtas_ld(args, 3);
626 sphb = spapr_pci_find_phb(spapr, buid);
627 if (!sphb) {
628 goto param_error_exit;
629 }
630
631 if (!spapr_phb_eeh_available(sphb)) {
632 goto param_error_exit;
633 }
634
635 ret = spapr_phb_vfio_eeh_reset(sphb, option);
636 rtas_st(rets, 0, ret);
637 return;
638
639param_error_exit:
640 rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
641}
642
643static void rtas_ibm_configure_pe(PowerPCCPU *cpu,
644 SpaprMachineState *spapr,
645 uint32_t token, uint32_t nargs,
646 target_ulong args, uint32_t nret,
647 target_ulong rets)
648{
649 SpaprPhbState *sphb;
650 uint64_t buid;
651 int ret;
652
653 if ((nargs != 3) || (nret != 1)) {
654 goto param_error_exit;
655 }
656
657 buid = rtas_ldq(args, 1);
658 sphb = spapr_pci_find_phb(spapr, buid);
659 if (!sphb) {
660 goto param_error_exit;
661 }
662
663 if (!spapr_phb_eeh_available(sphb)) {
664 goto param_error_exit;
665 }
666
667 ret = spapr_phb_vfio_eeh_configure(sphb);
668 rtas_st(rets, 0, ret);
669 return;
670
671param_error_exit:
672 rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
673}
674
675
676static void rtas_ibm_slot_error_detail(PowerPCCPU *cpu,
677 SpaprMachineState *spapr,
678 uint32_t token, uint32_t nargs,
679 target_ulong args, uint32_t nret,
680 target_ulong rets)
681{
682 SpaprPhbState *sphb;
683 int option;
684 uint64_t buid;
685
686 if ((nargs != 8) || (nret != 1)) {
687 goto param_error_exit;
688 }
689
690 buid = rtas_ldq(args, 1);
691 sphb = spapr_pci_find_phb(spapr, buid);
692 if (!sphb) {
693 goto param_error_exit;
694 }
695
696 if (!spapr_phb_eeh_available(sphb)) {
697 goto param_error_exit;
698 }
699
700 option = rtas_ld(args, 7);
701 switch (option) {
702 case RTAS_SLOT_TEMP_ERR_LOG:
703 case RTAS_SLOT_PERM_ERR_LOG:
704 break;
705 default:
706 goto param_error_exit;
707 }
708
709
710 rtas_st(rets, 0, RTAS_OUT_NO_ERRORS_FOUND);
711 return;
712
713param_error_exit:
714 rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
715}
716
717static void pci_spapr_set_irq(void *opaque, int irq_num, int level)
718{
719
720
721
722
723 SpaprPhbState *phb = opaque;
724 SpaprMachineState *spapr = SPAPR_MACHINE(qdev_get_machine());
725
726 trace_spapr_pci_lsi_set(phb->dtbusname, irq_num, phb->lsi_table[irq_num].irq);
727 qemu_set_irq(spapr_qirq(spapr, phb->lsi_table[irq_num].irq), level);
728}
729
730static PCIINTxRoute spapr_route_intx_pin_to_irq(void *opaque, int pin)
731{
732 SpaprPhbState *sphb = SPAPR_PCI_HOST_BRIDGE(opaque);
733 PCIINTxRoute route;
734
735 route.mode = PCI_INTX_ENABLED;
736 route.irq = sphb->lsi_table[pin].irq;
737
738 return route;
739}
740
741
742
743
744
745
746static void spapr_msi_write(void *opaque, hwaddr addr,
747 uint64_t data, unsigned size)
748{
749 SpaprMachineState *spapr = SPAPR_MACHINE(qdev_get_machine());
750 uint32_t irq = data;
751
752 trace_spapr_pci_msi_write(addr, data, irq);
753
754 qemu_irq_pulse(spapr_qirq(spapr, irq));
755}
756
757static const MemoryRegionOps spapr_msi_ops = {
758
759 .read = NULL,
760 .write = spapr_msi_write,
761 .endianness = DEVICE_LITTLE_ENDIAN
762};
763
764
765
766
767static AddressSpace *spapr_pci_dma_iommu(PCIBus *bus, void *opaque, int devfn)
768{
769 SpaprPhbState *phb = opaque;
770
771 return &phb->iommu_as;
772}
773
774static char *spapr_phb_vfio_get_loc_code(SpaprPhbState *sphb, PCIDevice *pdev)
775{
776 char *path = NULL, *buf = NULL, *host = NULL;
777
778
779 host = object_property_get_str(OBJECT(pdev), "host", NULL);
780 if (!host) {
781 goto err_out;
782 }
783
784
785 path = g_strdup_printf("/sys/bus/pci/devices/%s/devspec", host);
786 g_free(host);
787 if (!g_file_get_contents(path, &buf, NULL, NULL)) {
788 goto err_out;
789 }
790 g_free(path);
791
792
793 path = g_strdup_printf("/proc/device-tree%s/ibm,loc-code", buf);
794 g_free(buf);
795 if (!g_file_get_contents(path, &buf, NULL, NULL)) {
796 goto err_out;
797 }
798 return buf;
799
800err_out:
801 g_free(path);
802 return NULL;
803}
804
805static char *spapr_phb_get_loc_code(SpaprPhbState *sphb, PCIDevice *pdev)
806{
807 char *buf;
808 const char *devtype = "qemu";
809 uint32_t busnr = pci_bus_num(PCI_BUS(qdev_get_parent_bus(DEVICE(pdev))));
810
811 if (object_dynamic_cast(OBJECT(pdev), "vfio-pci")) {
812 buf = spapr_phb_vfio_get_loc_code(sphb, pdev);
813 if (buf) {
814 return buf;
815 }
816 devtype = "vfio";
817 }
818
819
820
821
822 buf = g_strdup_printf("%s_%s:%04x:%02x:%02x.%x",
823 devtype, pdev->name, sphb->index, busnr,
824 PCI_SLOT(pdev->devfn), PCI_FUNC(pdev->devfn));
825 return buf;
826}
827
828
829#define b_x(x, p, l) (((x) & ((1<<(l))-1)) << (p))
830#define b_n(x) b_x((x), 31, 1)
831#define b_p(x) b_x((x), 30, 1)
832#define b_t(x) b_x((x), 29, 1)
833#define b_ss(x) b_x((x), 24, 2)
834#define b_bbbbbbbb(x) b_x((x), 16, 8)
835#define b_ddddd(x) b_x((x), 11, 5)
836#define b_fff(x) b_x((x), 8, 3)
837#define b_rrrrrrrr(x) b_x((x), 0, 8)
838
839
840#define RESOURCE_CELLS_SIZE 2
841#define RESOURCE_CELLS_ADDRESS 3
842
843typedef struct ResourceFields {
844 uint32_t phys_hi;
845 uint32_t phys_mid;
846 uint32_t phys_lo;
847 uint32_t size_hi;
848 uint32_t size_lo;
849} QEMU_PACKED ResourceFields;
850
851typedef struct ResourceProps {
852 ResourceFields reg[8];
853 uint32_t reg_len;
854} ResourceProps;
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897static void populate_resource_props(PCIDevice *d, ResourceProps *rp)
898{
899 int bus_num = pci_bus_num(PCI_BUS(qdev_get_parent_bus(DEVICE(d))));
900 uint32_t dev_id = (b_bbbbbbbb(bus_num) |
901 b_ddddd(PCI_SLOT(d->devfn)) |
902 b_fff(PCI_FUNC(d->devfn)));
903 ResourceFields *reg;
904 int i, reg_idx = 0;
905
906
907 reg = &rp->reg[reg_idx++];
908 reg->phys_hi = cpu_to_be32(dev_id);
909 reg->phys_mid = 0;
910 reg->phys_lo = 0;
911 reg->size_hi = 0;
912 reg->size_lo = 0;
913
914 for (i = 0; i < PCI_NUM_REGIONS; i++) {
915 if (!d->io_regions[i].size) {
916 continue;
917 }
918
919 reg = &rp->reg[reg_idx++];
920
921 reg->phys_hi = cpu_to_be32(dev_id | b_rrrrrrrr(pci_bar(d, i)));
922 if (d->io_regions[i].type & PCI_BASE_ADDRESS_SPACE_IO) {
923 reg->phys_hi |= cpu_to_be32(b_ss(1));
924 } else if (d->io_regions[i].type & PCI_BASE_ADDRESS_MEM_TYPE_64) {
925 reg->phys_hi |= cpu_to_be32(b_ss(3));
926 } else {
927 reg->phys_hi |= cpu_to_be32(b_ss(2));
928 }
929 reg->phys_mid = 0;
930 reg->phys_lo = 0;
931 reg->size_hi = cpu_to_be32(d->io_regions[i].size >> 32);
932 reg->size_lo = cpu_to_be32(d->io_regions[i].size);
933 }
934
935 rp->reg_len = reg_idx * sizeof(ResourceFields);
936}
937
938typedef struct PCIClass PCIClass;
939typedef struct PCISubClass PCISubClass;
940typedef struct PCIIFace PCIIFace;
941
942struct PCIIFace {
943 int iface;
944 const char *name;
945};
946
947struct PCISubClass {
948 int subclass;
949 const char *name;
950 const PCIIFace *iface;
951};
952
953struct PCIClass {
954 const char *name;
955 const PCISubClass *subc;
956};
957
958static const PCISubClass undef_subclass[] = {
959 { PCI_CLASS_NOT_DEFINED_VGA, "display", NULL },
960 { 0xFF, NULL, NULL },
961};
962
963static const PCISubClass mass_subclass[] = {
964 { PCI_CLASS_STORAGE_SCSI, "scsi", NULL },
965 { PCI_CLASS_STORAGE_IDE, "ide", NULL },
966 { PCI_CLASS_STORAGE_FLOPPY, "fdc", NULL },
967 { PCI_CLASS_STORAGE_IPI, "ipi", NULL },
968 { PCI_CLASS_STORAGE_RAID, "raid", NULL },
969 { PCI_CLASS_STORAGE_ATA, "ata", NULL },
970 { PCI_CLASS_STORAGE_SATA, "sata", NULL },
971 { PCI_CLASS_STORAGE_SAS, "sas", NULL },
972 { 0xFF, NULL, NULL },
973};
974
975static const PCISubClass net_subclass[] = {
976 { PCI_CLASS_NETWORK_ETHERNET, "ethernet", NULL },
977 { PCI_CLASS_NETWORK_TOKEN_RING, "token-ring", NULL },
978 { PCI_CLASS_NETWORK_FDDI, "fddi", NULL },
979 { PCI_CLASS_NETWORK_ATM, "atm", NULL },
980 { PCI_CLASS_NETWORK_ISDN, "isdn", NULL },
981 { PCI_CLASS_NETWORK_WORLDFIP, "worldfip", NULL },
982 { PCI_CLASS_NETWORK_PICMG214, "picmg", NULL },
983 { 0xFF, NULL, NULL },
984};
985
986static const PCISubClass displ_subclass[] = {
987 { PCI_CLASS_DISPLAY_VGA, "vga", NULL },
988 { PCI_CLASS_DISPLAY_XGA, "xga", NULL },
989 { PCI_CLASS_DISPLAY_3D, "3d-controller", NULL },
990 { 0xFF, NULL, NULL },
991};
992
993static const PCISubClass media_subclass[] = {
994 { PCI_CLASS_MULTIMEDIA_VIDEO, "video", NULL },
995 { PCI_CLASS_MULTIMEDIA_AUDIO, "sound", NULL },
996 { PCI_CLASS_MULTIMEDIA_PHONE, "telephony", NULL },
997 { 0xFF, NULL, NULL },
998};
999
1000static const PCISubClass mem_subclass[] = {
1001 { PCI_CLASS_MEMORY_RAM, "memory", NULL },
1002 { PCI_CLASS_MEMORY_FLASH, "flash", NULL },
1003 { 0xFF, NULL, NULL },
1004};
1005
1006static const PCISubClass bridg_subclass[] = {
1007 { PCI_CLASS_BRIDGE_HOST, "host", NULL },
1008 { PCI_CLASS_BRIDGE_ISA, "isa", NULL },
1009 { PCI_CLASS_BRIDGE_EISA, "eisa", NULL },
1010 { PCI_CLASS_BRIDGE_MC, "mca", NULL },
1011 { PCI_CLASS_BRIDGE_PCI, "pci", NULL },
1012 { PCI_CLASS_BRIDGE_PCMCIA, "pcmcia", NULL },
1013 { PCI_CLASS_BRIDGE_NUBUS, "nubus", NULL },
1014 { PCI_CLASS_BRIDGE_CARDBUS, "cardbus", NULL },
1015 { PCI_CLASS_BRIDGE_RACEWAY, "raceway", NULL },
1016 { PCI_CLASS_BRIDGE_PCI_SEMITP, "semi-transparent-pci", NULL },
1017 { PCI_CLASS_BRIDGE_IB_PCI, "infiniband", NULL },
1018 { 0xFF, NULL, NULL },
1019};
1020
1021static const PCISubClass comm_subclass[] = {
1022 { PCI_CLASS_COMMUNICATION_SERIAL, "serial", NULL },
1023 { PCI_CLASS_COMMUNICATION_PARALLEL, "parallel", NULL },
1024 { PCI_CLASS_COMMUNICATION_MULTISERIAL, "multiport-serial", NULL },
1025 { PCI_CLASS_COMMUNICATION_MODEM, "modem", NULL },
1026 { PCI_CLASS_COMMUNICATION_GPIB, "gpib", NULL },
1027 { PCI_CLASS_COMMUNICATION_SC, "smart-card", NULL },
1028 { 0xFF, NULL, NULL, },
1029};
1030
1031static const PCIIFace pic_iface[] = {
1032 { PCI_CLASS_SYSTEM_PIC_IOAPIC, "io-apic" },
1033 { PCI_CLASS_SYSTEM_PIC_IOXAPIC, "io-xapic" },
1034 { 0xFF, NULL },
1035};
1036
1037static const PCISubClass sys_subclass[] = {
1038 { PCI_CLASS_SYSTEM_PIC, "interrupt-controller", pic_iface },
1039 { PCI_CLASS_SYSTEM_DMA, "dma-controller", NULL },
1040 { PCI_CLASS_SYSTEM_TIMER, "timer", NULL },
1041 { PCI_CLASS_SYSTEM_RTC, "rtc", NULL },
1042 { PCI_CLASS_SYSTEM_PCI_HOTPLUG, "hot-plug-controller", NULL },
1043 { PCI_CLASS_SYSTEM_SDHCI, "sd-host-controller", NULL },
1044 { 0xFF, NULL, NULL },
1045};
1046
1047static const PCISubClass inp_subclass[] = {
1048 { PCI_CLASS_INPUT_KEYBOARD, "keyboard", NULL },
1049 { PCI_CLASS_INPUT_PEN, "pen", NULL },
1050 { PCI_CLASS_INPUT_MOUSE, "mouse", NULL },
1051 { PCI_CLASS_INPUT_SCANNER, "scanner", NULL },
1052 { PCI_CLASS_INPUT_GAMEPORT, "gameport", NULL },
1053 { 0xFF, NULL, NULL },
1054};
1055
1056static const PCISubClass dock_subclass[] = {
1057 { PCI_CLASS_DOCKING_GENERIC, "dock", NULL },
1058 { 0xFF, NULL, NULL },
1059};
1060
1061static const PCISubClass cpu_subclass[] = {
1062 { PCI_CLASS_PROCESSOR_PENTIUM, "pentium", NULL },
1063 { PCI_CLASS_PROCESSOR_POWERPC, "powerpc", NULL },
1064 { PCI_CLASS_PROCESSOR_MIPS, "mips", NULL },
1065 { PCI_CLASS_PROCESSOR_CO, "co-processor", NULL },
1066 { 0xFF, NULL, NULL },
1067};
1068
1069static const PCIIFace usb_iface[] = {
1070 { PCI_CLASS_SERIAL_USB_UHCI, "usb-uhci" },
1071 { PCI_CLASS_SERIAL_USB_OHCI, "usb-ohci", },
1072 { PCI_CLASS_SERIAL_USB_EHCI, "usb-ehci" },
1073 { PCI_CLASS_SERIAL_USB_XHCI, "usb-xhci" },
1074 { PCI_CLASS_SERIAL_USB_UNKNOWN, "usb-unknown" },
1075 { PCI_CLASS_SERIAL_USB_DEVICE, "usb-device" },
1076 { 0xFF, NULL },
1077};
1078
1079static const PCISubClass ser_subclass[] = {
1080 { PCI_CLASS_SERIAL_FIREWIRE, "firewire", NULL },
1081 { PCI_CLASS_SERIAL_ACCESS, "access-bus", NULL },
1082 { PCI_CLASS_SERIAL_SSA, "ssa", NULL },
1083 { PCI_CLASS_SERIAL_USB, "usb", usb_iface },
1084 { PCI_CLASS_SERIAL_FIBER, "fibre-channel", NULL },
1085 { PCI_CLASS_SERIAL_SMBUS, "smb", NULL },
1086 { PCI_CLASS_SERIAL_IB, "infiniband", NULL },
1087 { PCI_CLASS_SERIAL_IPMI, "ipmi", NULL },
1088 { PCI_CLASS_SERIAL_SERCOS, "sercos", NULL },
1089 { PCI_CLASS_SERIAL_CANBUS, "canbus", NULL },
1090 { 0xFF, NULL, NULL },
1091};
1092
1093static const PCISubClass wrl_subclass[] = {
1094 { PCI_CLASS_WIRELESS_IRDA, "irda", NULL },
1095 { PCI_CLASS_WIRELESS_CIR, "consumer-ir", NULL },
1096 { PCI_CLASS_WIRELESS_RF_CONTROLLER, "rf-controller", NULL },
1097 { PCI_CLASS_WIRELESS_BLUETOOTH, "bluetooth", NULL },
1098 { PCI_CLASS_WIRELESS_BROADBAND, "broadband", NULL },
1099 { 0xFF, NULL, NULL },
1100};
1101
1102static const PCISubClass sat_subclass[] = {
1103 { PCI_CLASS_SATELLITE_TV, "satellite-tv", NULL },
1104 { PCI_CLASS_SATELLITE_AUDIO, "satellite-audio", NULL },
1105 { PCI_CLASS_SATELLITE_VOICE, "satellite-voice", NULL },
1106 { PCI_CLASS_SATELLITE_DATA, "satellite-data", NULL },
1107 { 0xFF, NULL, NULL },
1108};
1109
1110static const PCISubClass crypt_subclass[] = {
1111 { PCI_CLASS_CRYPT_NETWORK, "network-encryption", NULL },
1112 { PCI_CLASS_CRYPT_ENTERTAINMENT,
1113 "entertainment-encryption", NULL },
1114 { 0xFF, NULL, NULL },
1115};
1116
1117static const PCISubClass spc_subclass[] = {
1118 { PCI_CLASS_SP_DPIO, "dpio", NULL },
1119 { PCI_CLASS_SP_PERF, "counter", NULL },
1120 { PCI_CLASS_SP_SYNCH, "measurement", NULL },
1121 { PCI_CLASS_SP_MANAGEMENT, "management-card", NULL },
1122 { 0xFF, NULL, NULL },
1123};
1124
1125static const PCIClass pci_classes[] = {
1126 { "legacy-device", undef_subclass },
1127 { "mass-storage", mass_subclass },
1128 { "network", net_subclass },
1129 { "display", displ_subclass, },
1130 { "multimedia-device", media_subclass },
1131 { "memory-controller", mem_subclass },
1132 { "unknown-bridge", bridg_subclass },
1133 { "communication-controller", comm_subclass},
1134 { "system-peripheral", sys_subclass },
1135 { "input-controller", inp_subclass },
1136 { "docking-station", dock_subclass },
1137 { "cpu", cpu_subclass },
1138 { "serial-bus", ser_subclass },
1139 { "wireless-controller", wrl_subclass },
1140 { "intelligent-io", NULL },
1141 { "satellite-device", sat_subclass },
1142 { "encryption", crypt_subclass },
1143 { "data-processing-controller", spc_subclass },
1144};
1145
1146static const char *dt_name_from_class(uint8_t class, uint8_t subclass,
1147 uint8_t iface)
1148{
1149 const PCIClass *pclass;
1150 const PCISubClass *psubclass;
1151 const PCIIFace *piface;
1152 const char *name;
1153
1154 if (class >= ARRAY_SIZE(pci_classes)) {
1155 return "pci";
1156 }
1157
1158 pclass = pci_classes + class;
1159 name = pclass->name;
1160
1161 if (pclass->subc == NULL) {
1162 return name;
1163 }
1164
1165 psubclass = pclass->subc;
1166 while ((psubclass->subclass & 0xff) != 0xff) {
1167 if ((psubclass->subclass & 0xff) == subclass) {
1168 name = psubclass->name;
1169 break;
1170 }
1171 psubclass++;
1172 }
1173
1174 piface = psubclass->iface;
1175 if (piface == NULL) {
1176 return name;
1177 }
1178 while ((piface->iface & 0xff) != 0xff) {
1179 if ((piface->iface & 0xff) == iface) {
1180 name = piface->name;
1181 break;
1182 }
1183 piface++;
1184 }
1185
1186 return name;
1187}
1188
1189
1190
1191
1192
1193static uint32_t drc_id_from_devfn(SpaprPhbState *phb,
1194 uint8_t chassis, int32_t devfn)
1195{
1196 return (phb->index << 16) | (chassis << 8) | devfn;
1197}
1198
1199static SpaprDrc *drc_from_devfn(SpaprPhbState *phb,
1200 uint8_t chassis, int32_t devfn)
1201{
1202 return spapr_drc_by_id(TYPE_SPAPR_DRC_PCI,
1203 drc_id_from_devfn(phb, chassis, devfn));
1204}
1205
1206static uint8_t chassis_from_bus(PCIBus *bus, Error **errp)
1207{
1208 if (pci_bus_is_root(bus)) {
1209 return 0;
1210 } else {
1211 PCIDevice *bridge = pci_bridge_get_device(bus);
1212
1213 return object_property_get_uint(OBJECT(bridge), "chassis_nr", errp);
1214 }
1215}
1216
1217static SpaprDrc *drc_from_dev(SpaprPhbState *phb, PCIDevice *dev)
1218{
1219 Error *local_err = NULL;
1220 uint8_t chassis = chassis_from_bus(pci_get_bus(dev), &local_err);
1221
1222 if (local_err) {
1223 error_report_err(local_err);
1224 return NULL;
1225 }
1226
1227 return drc_from_devfn(phb, chassis, dev->devfn);
1228}
1229
1230static void add_drcs(SpaprPhbState *phb, PCIBus *bus, Error **errp)
1231{
1232 Object *owner;
1233 int i;
1234 uint8_t chassis;
1235 Error *local_err = NULL;
1236
1237 if (!phb->dr_enabled) {
1238 return;
1239 }
1240
1241 chassis = chassis_from_bus(bus, &local_err);
1242 if (local_err) {
1243 error_propagate(errp, local_err);
1244 return;
1245 }
1246
1247 if (pci_bus_is_root(bus)) {
1248 owner = OBJECT(phb);
1249 } else {
1250 owner = OBJECT(pci_bridge_get_device(bus));
1251 }
1252
1253 for (i = 0; i < PCI_SLOT_MAX * PCI_FUNC_MAX; i++) {
1254 spapr_dr_connector_new(owner, TYPE_SPAPR_DRC_PCI,
1255 drc_id_from_devfn(phb, chassis, i));
1256 }
1257}
1258
1259static void remove_drcs(SpaprPhbState *phb, PCIBus *bus, Error **errp)
1260{
1261 int i;
1262 uint8_t chassis;
1263 Error *local_err = NULL;
1264
1265 if (!phb->dr_enabled) {
1266 return;
1267 }
1268
1269 chassis = chassis_from_bus(bus, &local_err);
1270 if (local_err) {
1271 error_propagate(errp, local_err);
1272 return;
1273 }
1274
1275 for (i = PCI_SLOT_MAX * PCI_FUNC_MAX - 1; i >= 0; i--) {
1276 SpaprDrc *drc = drc_from_devfn(phb, chassis, i);
1277
1278 if (drc) {
1279 object_unparent(OBJECT(drc));
1280 }
1281 }
1282}
1283
1284typedef struct PciWalkFdt {
1285 void *fdt;
1286 int offset;
1287 SpaprPhbState *sphb;
1288 int err;
1289} PciWalkFdt;
1290
1291static int spapr_dt_pci_device(SpaprPhbState *sphb, PCIDevice *dev,
1292 void *fdt, int parent_offset);
1293
1294static void spapr_dt_pci_device_cb(PCIBus *bus, PCIDevice *pdev,
1295 void *opaque)
1296{
1297 PciWalkFdt *p = opaque;
1298 int err;
1299
1300 if (p->err) {
1301
1302 return;
1303 }
1304
1305 err = spapr_dt_pci_device(p->sphb, pdev, p->fdt, p->offset);
1306 if (err < 0) {
1307 p->err = err;
1308 }
1309}
1310
1311
1312static int spapr_dt_pci_bus(SpaprPhbState *sphb, PCIBus *bus,
1313 void *fdt, int offset)
1314{
1315 Object *owner;
1316 PciWalkFdt cbinfo = {
1317 .fdt = fdt,
1318 .offset = offset,
1319 .sphb = sphb,
1320 .err = 0,
1321 };
1322 int ret;
1323
1324 _FDT(fdt_setprop_cell(fdt, offset, "#address-cells",
1325 RESOURCE_CELLS_ADDRESS));
1326 _FDT(fdt_setprop_cell(fdt, offset, "#size-cells",
1327 RESOURCE_CELLS_SIZE));
1328
1329 assert(bus);
1330 pci_for_each_device_reverse(bus, pci_bus_num(bus),
1331 spapr_dt_pci_device_cb, &cbinfo);
1332 if (cbinfo.err) {
1333 return cbinfo.err;
1334 }
1335
1336 if (pci_bus_is_root(bus)) {
1337 owner = OBJECT(sphb);
1338 } else {
1339 owner = OBJECT(pci_bridge_get_device(bus));
1340 }
1341
1342 ret = spapr_dt_drc(fdt, offset, owner,
1343 SPAPR_DR_CONNECTOR_TYPE_PCI);
1344 if (ret) {
1345 return ret;
1346 }
1347
1348 return offset;
1349}
1350
1351
1352static int spapr_dt_pci_device(SpaprPhbState *sphb, PCIDevice *dev,
1353 void *fdt, int parent_offset)
1354{
1355 int offset;
1356 const gchar *basename;
1357 gchar *nodename;
1358 int slot = PCI_SLOT(dev->devfn);
1359 int func = PCI_FUNC(dev->devfn);
1360 PCIDeviceClass *pc = PCI_DEVICE_GET_CLASS(dev);
1361 ResourceProps rp;
1362 SpaprDrc *drc = drc_from_dev(sphb, dev);
1363 uint32_t vendor_id = pci_default_read_config(dev, PCI_VENDOR_ID, 2);
1364 uint32_t device_id = pci_default_read_config(dev, PCI_DEVICE_ID, 2);
1365 uint32_t revision_id = pci_default_read_config(dev, PCI_REVISION_ID, 1);
1366 uint32_t ccode = pci_default_read_config(dev, PCI_CLASS_PROG, 3);
1367 uint32_t irq_pin = pci_default_read_config(dev, PCI_INTERRUPT_PIN, 1);
1368 uint32_t subsystem_id = pci_default_read_config(dev, PCI_SUBSYSTEM_ID, 2);
1369 uint32_t subsystem_vendor_id =
1370 pci_default_read_config(dev, PCI_SUBSYSTEM_VENDOR_ID, 2);
1371 uint32_t cache_line_size =
1372 pci_default_read_config(dev, PCI_CACHE_LINE_SIZE, 1);
1373 uint32_t pci_status = pci_default_read_config(dev, PCI_STATUS, 2);
1374 gchar *loc_code;
1375
1376 basename = dt_name_from_class((ccode >> 16) & 0xff, (ccode >> 8) & 0xff,
1377 ccode & 0xff);
1378
1379 if (func != 0) {
1380 nodename = g_strdup_printf("%s@%x,%x", basename, slot, func);
1381 } else {
1382 nodename = g_strdup_printf("%s@%x", basename, slot);
1383 }
1384
1385 _FDT(offset = fdt_add_subnode(fdt, parent_offset, nodename));
1386
1387 g_free(nodename);
1388
1389
1390 _FDT(fdt_setprop_cell(fdt, offset, "vendor-id", vendor_id));
1391 _FDT(fdt_setprop_cell(fdt, offset, "device-id", device_id));
1392 _FDT(fdt_setprop_cell(fdt, offset, "revision-id", revision_id));
1393
1394 _FDT(fdt_setprop_cell(fdt, offset, "class-code", ccode));
1395 if (irq_pin) {
1396 _FDT(fdt_setprop_cell(fdt, offset, "interrupts", irq_pin));
1397 }
1398
1399 if (subsystem_id) {
1400 _FDT(fdt_setprop_cell(fdt, offset, "subsystem-id", subsystem_id));
1401 }
1402
1403 if (subsystem_vendor_id) {
1404 _FDT(fdt_setprop_cell(fdt, offset, "subsystem-vendor-id",
1405 subsystem_vendor_id));
1406 }
1407
1408 _FDT(fdt_setprop_cell(fdt, offset, "cache-line-size", cache_line_size));
1409
1410
1411
1412 _FDT(fdt_setprop_cell(fdt, offset, "devsel-speed",
1413 PCI_STATUS_DEVSEL_MASK & pci_status));
1414
1415 if (pci_status & PCI_STATUS_FAST_BACK) {
1416 _FDT(fdt_setprop(fdt, offset, "fast-back-to-back", NULL, 0));
1417 }
1418 if (pci_status & PCI_STATUS_66MHZ) {
1419 _FDT(fdt_setprop(fdt, offset, "66mhz-capable", NULL, 0));
1420 }
1421 if (pci_status & PCI_STATUS_UDF) {
1422 _FDT(fdt_setprop(fdt, offset, "udf-supported", NULL, 0));
1423 }
1424
1425 loc_code = spapr_phb_get_loc_code(sphb, dev);
1426 _FDT(fdt_setprop_string(fdt, offset, "ibm,loc-code", loc_code));
1427 g_free(loc_code);
1428
1429 if (drc) {
1430 _FDT(fdt_setprop_cell(fdt, offset, "ibm,my-drc-index",
1431 spapr_drc_index(drc)));
1432 }
1433
1434 if (msi_present(dev)) {
1435 uint32_t max_msi = msi_nr_vectors_allocated(dev);
1436 if (max_msi) {
1437 _FDT(fdt_setprop_cell(fdt, offset, "ibm,req#msi", max_msi));
1438 }
1439 }
1440 if (msix_present(dev)) {
1441 uint32_t max_msix = dev->msix_entries_nr;
1442 if (max_msix) {
1443 _FDT(fdt_setprop_cell(fdt, offset, "ibm,req#msi-x", max_msix));
1444 }
1445 }
1446
1447 populate_resource_props(dev, &rp);
1448 _FDT(fdt_setprop(fdt, offset, "reg", (uint8_t *)rp.reg, rp.reg_len));
1449
1450 if (sphb->pcie_ecs && pci_is_express(dev)) {
1451 _FDT(fdt_setprop_cell(fdt, offset, "ibm,pci-config-space-type", 0x1));
1452 }
1453
1454 spapr_phb_nvgpu_populate_pcidev_dt(dev, fdt, offset, sphb);
1455
1456 if (!pc->is_bridge) {
1457
1458 uint32_t min_grant = pci_default_read_config(dev, PCI_MIN_GNT, 1);
1459 uint32_t max_latency = pci_default_read_config(dev, PCI_MAX_LAT, 1);
1460 _FDT(fdt_setprop_cell(fdt, offset, "min-grant", min_grant));
1461 _FDT(fdt_setprop_cell(fdt, offset, "max-latency", max_latency));
1462 return offset;
1463 } else {
1464 PCIBus *sec_bus = pci_bridge_get_sec_bus(PCI_BRIDGE(dev));
1465
1466 return spapr_dt_pci_bus(sphb, sec_bus, fdt, offset);
1467 }
1468}
1469
1470
1471void spapr_phb_remove_pci_device_cb(DeviceState *dev)
1472{
1473 HotplugHandler *hotplug_ctrl = qdev_get_hotplug_handler(dev);
1474
1475 hotplug_handler_unplug(hotplug_ctrl, dev, &error_abort);
1476 object_unparent(OBJECT(dev));
1477}
1478
1479int spapr_pci_dt_populate(SpaprDrc *drc, SpaprMachineState *spapr,
1480 void *fdt, int *fdt_start_offset, Error **errp)
1481{
1482 HotplugHandler *plug_handler = qdev_get_hotplug_handler(drc->dev);
1483 SpaprPhbState *sphb = SPAPR_PCI_HOST_BRIDGE(plug_handler);
1484 PCIDevice *pdev = PCI_DEVICE(drc->dev);
1485
1486 *fdt_start_offset = spapr_dt_pci_device(sphb, pdev, fdt, 0);
1487 return 0;
1488}
1489
1490static void spapr_pci_bridge_plug(SpaprPhbState *phb,
1491 PCIBridge *bridge,
1492 Error **errp)
1493{
1494 Error *local_err = NULL;
1495 PCIBus *bus = pci_bridge_get_sec_bus(bridge);
1496
1497 add_drcs(phb, bus, &local_err);
1498 if (local_err) {
1499 error_propagate(errp, local_err);
1500 return;
1501 }
1502}
1503
1504static void spapr_pci_plug(HotplugHandler *plug_handler,
1505 DeviceState *plugged_dev, Error **errp)
1506{
1507 SpaprPhbState *phb = SPAPR_PCI_HOST_BRIDGE(DEVICE(plug_handler));
1508 PCIDevice *pdev = PCI_DEVICE(plugged_dev);
1509 PCIDeviceClass *pc = PCI_DEVICE_GET_CLASS(plugged_dev);
1510 SpaprDrc *drc = drc_from_dev(phb, pdev);
1511 Error *local_err = NULL;
1512 PCIBus *bus = PCI_BUS(qdev_get_parent_bus(DEVICE(pdev)));
1513 uint32_t slotnr = PCI_SLOT(pdev->devfn);
1514
1515
1516
1517
1518 if (!phb->dr_enabled) {
1519
1520
1521
1522 if (plugged_dev->hotplugged) {
1523 error_setg(&local_err, QERR_BUS_NO_HOTPLUG,
1524 object_get_typename(OBJECT(phb)));
1525 }
1526 goto out;
1527 }
1528
1529 g_assert(drc);
1530
1531 if (pc->is_bridge) {
1532 spapr_pci_bridge_plug(phb, PCI_BRIDGE(plugged_dev), &local_err);
1533 if (local_err) {
1534 error_propagate(errp, local_err);
1535 return;
1536 }
1537 }
1538
1539
1540
1541
1542
1543 if (plugged_dev->hotplugged && bus->devices[PCI_DEVFN(slotnr, 0)] &&
1544 PCI_FUNC(pdev->devfn) != 0) {
1545 error_setg(&local_err, "PCI: slot %d function 0 already ocuppied by %s,"
1546 " additional functions can no longer be exposed to guest.",
1547 slotnr, bus->devices[PCI_DEVFN(slotnr, 0)]->name);
1548 goto out;
1549 }
1550
1551 spapr_drc_attach(drc, DEVICE(pdev), &local_err);
1552 if (local_err) {
1553 goto out;
1554 }
1555
1556
1557
1558
1559 if (!spapr_drc_hotplugged(plugged_dev)) {
1560 spapr_drc_reset(drc);
1561 } else if (PCI_FUNC(pdev->devfn) == 0) {
1562 int i;
1563 uint8_t chassis = chassis_from_bus(pci_get_bus(pdev), &local_err);
1564
1565 if (local_err) {
1566 error_propagate(errp, local_err);
1567 return;
1568 }
1569
1570 for (i = 0; i < 8; i++) {
1571 SpaprDrc *func_drc;
1572 SpaprDrcClass *func_drck;
1573 SpaprDREntitySense state;
1574
1575 func_drc = drc_from_devfn(phb, chassis, PCI_DEVFN(slotnr, i));
1576 func_drck = SPAPR_DR_CONNECTOR_GET_CLASS(func_drc);
1577 state = func_drck->dr_entity_sense(func_drc);
1578
1579 if (state == SPAPR_DR_ENTITY_SENSE_PRESENT) {
1580 spapr_hotplug_req_add_by_index(func_drc);
1581 }
1582 }
1583 }
1584
1585out:
1586 error_propagate(errp, local_err);
1587}
1588
1589static void spapr_pci_bridge_unplug(SpaprPhbState *phb,
1590 PCIBridge *bridge,
1591 Error **errp)
1592{
1593 Error *local_err = NULL;
1594 PCIBus *bus = pci_bridge_get_sec_bus(bridge);
1595
1596 remove_drcs(phb, bus, &local_err);
1597 if (local_err) {
1598 error_propagate(errp, local_err);
1599 return;
1600 }
1601}
1602
1603static void spapr_pci_unplug(HotplugHandler *plug_handler,
1604 DeviceState *plugged_dev, Error **errp)
1605{
1606 PCIDeviceClass *pc = PCI_DEVICE_GET_CLASS(plugged_dev);
1607 SpaprPhbState *phb = SPAPR_PCI_HOST_BRIDGE(DEVICE(plug_handler));
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619 pci_device_reset(PCI_DEVICE(plugged_dev));
1620
1621 if (pc->is_bridge) {
1622 Error *local_err = NULL;
1623 spapr_pci_bridge_unplug(phb, PCI_BRIDGE(plugged_dev), &local_err);
1624 if (local_err) {
1625 error_propagate(errp, local_err);
1626 }
1627 return;
1628 }
1629
1630 object_property_set_bool(OBJECT(plugged_dev), false, "realized", NULL);
1631}
1632
1633static void spapr_pci_unplug_request(HotplugHandler *plug_handler,
1634 DeviceState *plugged_dev, Error **errp)
1635{
1636 SpaprPhbState *phb = SPAPR_PCI_HOST_BRIDGE(DEVICE(plug_handler));
1637 PCIDevice *pdev = PCI_DEVICE(plugged_dev);
1638 SpaprDrc *drc = drc_from_dev(phb, pdev);
1639
1640 if (!phb->dr_enabled) {
1641 error_setg(errp, QERR_BUS_NO_HOTPLUG,
1642 object_get_typename(OBJECT(phb)));
1643 return;
1644 }
1645
1646 g_assert(drc);
1647 g_assert(drc->dev == plugged_dev);
1648
1649 if (!spapr_drc_unplug_requested(drc)) {
1650 PCIDeviceClass *pc = PCI_DEVICE_GET_CLASS(plugged_dev);
1651 uint32_t slotnr = PCI_SLOT(pdev->devfn);
1652 SpaprDrc *func_drc;
1653 SpaprDrcClass *func_drck;
1654 SpaprDREntitySense state;
1655 int i;
1656 Error *local_err = NULL;
1657 uint8_t chassis = chassis_from_bus(pci_get_bus(pdev), &local_err);
1658
1659 if (local_err) {
1660 error_propagate(errp, local_err);
1661 return;
1662 }
1663
1664 if (pc->is_bridge) {
1665 error_setg(errp, "PCI: Hot unplug of PCI bridges not supported");
1666 }
1667
1668
1669 if (PCI_FUNC(pdev->devfn) == 0) {
1670 for (i = 1; i < 8; i++) {
1671 func_drc = drc_from_devfn(phb, chassis, PCI_DEVFN(slotnr, i));
1672 func_drck = SPAPR_DR_CONNECTOR_GET_CLASS(func_drc);
1673 state = func_drck->dr_entity_sense(func_drc);
1674 if (state == SPAPR_DR_ENTITY_SENSE_PRESENT
1675 && !spapr_drc_unplug_requested(func_drc)) {
1676
1677
1678
1679
1680
1681
1682 spapr_drc_detach(func_drc);
1683 }
1684 }
1685 }
1686
1687 spapr_drc_detach(drc);
1688
1689
1690
1691
1692 if (PCI_FUNC(pdev->devfn) == 0) {
1693 for (i = 7; i >= 0; i--) {
1694 func_drc = drc_from_devfn(phb, chassis, PCI_DEVFN(slotnr, i));
1695 func_drck = SPAPR_DR_CONNECTOR_GET_CLASS(func_drc);
1696 state = func_drck->dr_entity_sense(func_drc);
1697 if (state == SPAPR_DR_ENTITY_SENSE_PRESENT) {
1698 spapr_hotplug_req_remove_by_index(func_drc);
1699 }
1700 }
1701 }
1702 }
1703}
1704
1705static void spapr_phb_finalizefn(Object *obj)
1706{
1707 SpaprPhbState *sphb = SPAPR_PCI_HOST_BRIDGE(obj);
1708
1709 g_free(sphb->dtbusname);
1710 sphb->dtbusname = NULL;
1711}
1712
1713static void spapr_phb_unrealize(DeviceState *dev, Error **errp)
1714{
1715 SpaprMachineState *spapr = SPAPR_MACHINE(qdev_get_machine());
1716 SysBusDevice *s = SYS_BUS_DEVICE(dev);
1717 PCIHostState *phb = PCI_HOST_BRIDGE(s);
1718 SpaprPhbState *sphb = SPAPR_PCI_HOST_BRIDGE(phb);
1719 SpaprTceTable *tcet;
1720 int i;
1721 const unsigned windows_supported = spapr_phb_windows_supported(sphb);
1722 Error *local_err = NULL;
1723
1724 spapr_phb_nvgpu_free(sphb);
1725
1726 if (sphb->msi) {
1727 g_hash_table_unref(sphb->msi);
1728 sphb->msi = NULL;
1729 }
1730
1731
1732
1733
1734
1735 for (i = windows_supported - 1; i >= 0; i--) {
1736 tcet = spapr_tce_find_by_liobn(sphb->dma_liobn[i]);
1737 if (tcet) {
1738 memory_region_del_subregion(&sphb->iommu_root,
1739 spapr_tce_get_iommu(tcet));
1740 }
1741 }
1742
1743 remove_drcs(sphb, phb->bus, &local_err);
1744 if (local_err) {
1745 error_propagate(errp, local_err);
1746 return;
1747 }
1748
1749 for (i = PCI_NUM_PINS - 1; i >= 0; i--) {
1750 if (sphb->lsi_table[i].irq) {
1751 spapr_irq_free(spapr, sphb->lsi_table[i].irq, 1);
1752 sphb->lsi_table[i].irq = 0;
1753 }
1754 }
1755
1756 QLIST_REMOVE(sphb, list);
1757
1758 memory_region_del_subregion(&sphb->iommu_root, &sphb->msiwindow);
1759
1760
1761
1762
1763
1764
1765 address_space_remove_listeners(&sphb->iommu_as);
1766 address_space_destroy(&sphb->iommu_as);
1767
1768 qbus_set_hotplug_handler(BUS(phb->bus), NULL, &error_abort);
1769 pci_unregister_root_bus(phb->bus);
1770
1771 memory_region_del_subregion(get_system_memory(), &sphb->iowindow);
1772 if (sphb->mem64_win_pciaddr != (hwaddr)-1) {
1773 memory_region_del_subregion(get_system_memory(), &sphb->mem64window);
1774 }
1775 memory_region_del_subregion(get_system_memory(), &sphb->mem32window);
1776}
1777
1778static void spapr_phb_destroy_msi(gpointer opaque)
1779{
1780 SpaprMachineState *spapr = SPAPR_MACHINE(qdev_get_machine());
1781 SpaprMachineClass *smc = SPAPR_MACHINE_GET_CLASS(spapr);
1782 SpaprPciMsi *msi = opaque;
1783
1784 if (!smc->legacy_irq_allocation) {
1785 spapr_irq_msi_free(spapr, msi->first_irq, msi->num);
1786 }
1787 spapr_irq_free(spapr, msi->first_irq, msi->num);
1788 g_free(msi);
1789}
1790
1791static void spapr_phb_realize(DeviceState *dev, Error **errp)
1792{
1793
1794
1795
1796 SpaprMachineState *spapr =
1797 (SpaprMachineState *) object_dynamic_cast(qdev_get_machine(),
1798 TYPE_SPAPR_MACHINE);
1799 SpaprMachineClass *smc = spapr ? SPAPR_MACHINE_GET_CLASS(spapr) : NULL;
1800 SysBusDevice *s = SYS_BUS_DEVICE(dev);
1801 SpaprPhbState *sphb = SPAPR_PCI_HOST_BRIDGE(s);
1802 PCIHostState *phb = PCI_HOST_BRIDGE(s);
1803 MachineState *ms = MACHINE(spapr);
1804 char *namebuf;
1805 int i;
1806 PCIBus *bus;
1807 uint64_t msi_window_size = 4096;
1808 SpaprTceTable *tcet;
1809 const unsigned windows_supported = spapr_phb_windows_supported(sphb);
1810 Error *local_err = NULL;
1811
1812 if (!spapr) {
1813 error_setg(errp, TYPE_SPAPR_PCI_HOST_BRIDGE " needs a pseries machine");
1814 return;
1815 }
1816
1817 assert(sphb->index != (uint32_t)-1);
1818
1819 if (sphb->mem64_win_size != 0) {
1820 if (sphb->mem_win_size > SPAPR_PCI_MEM32_WIN_SIZE) {
1821 error_setg(errp, "32-bit memory window of size 0x%"HWADDR_PRIx
1822 " (max 2 GiB)", sphb->mem_win_size);
1823 return;
1824 }
1825
1826
1827 sphb->mem64_win_pciaddr = sphb->mem64_win_addr;
1828 } else if (sphb->mem_win_size > SPAPR_PCI_MEM32_WIN_SIZE) {
1829
1830
1831
1832
1833
1834
1835
1836 sphb->mem64_win_size = sphb->mem_win_size - SPAPR_PCI_MEM32_WIN_SIZE;
1837 sphb->mem64_win_addr = sphb->mem_win_addr + SPAPR_PCI_MEM32_WIN_SIZE;
1838 sphb->mem64_win_pciaddr =
1839 SPAPR_PCI_MEM_WIN_BUS_OFFSET + SPAPR_PCI_MEM32_WIN_SIZE;
1840 sphb->mem_win_size = SPAPR_PCI_MEM32_WIN_SIZE;
1841 }
1842
1843 if (spapr_pci_find_phb(spapr, sphb->buid)) {
1844 SpaprPhbState *s;
1845
1846 error_setg(errp, "PCI host bridges must have unique indexes");
1847 error_append_hint(errp, "The following indexes are already in use:");
1848 QLIST_FOREACH(s, &spapr->phbs, list) {
1849 error_append_hint(errp, " %d", s->index);
1850 }
1851 error_append_hint(errp, "\nTry another value for the index property\n");
1852 return;
1853 }
1854
1855 if (sphb->numa_node != -1 &&
1856 (sphb->numa_node >= MAX_NODES ||
1857 !ms->numa_state->nodes[sphb->numa_node].present)) {
1858 error_setg(errp, "Invalid NUMA node ID for PCI host bridge");
1859 return;
1860 }
1861
1862 sphb->dtbusname = g_strdup_printf("pci@%" PRIx64, sphb->buid);
1863
1864
1865 namebuf = g_strdup_printf("%s.mmio", sphb->dtbusname);
1866 memory_region_init(&sphb->memspace, OBJECT(sphb), namebuf, UINT64_MAX);
1867 g_free(namebuf);
1868
1869 namebuf = g_strdup_printf("%s.mmio32-alias", sphb->dtbusname);
1870 memory_region_init_alias(&sphb->mem32window, OBJECT(sphb),
1871 namebuf, &sphb->memspace,
1872 SPAPR_PCI_MEM_WIN_BUS_OFFSET, sphb->mem_win_size);
1873 g_free(namebuf);
1874 memory_region_add_subregion(get_system_memory(), sphb->mem_win_addr,
1875 &sphb->mem32window);
1876
1877 if (sphb->mem64_win_size != 0) {
1878 namebuf = g_strdup_printf("%s.mmio64-alias", sphb->dtbusname);
1879 memory_region_init_alias(&sphb->mem64window, OBJECT(sphb),
1880 namebuf, &sphb->memspace,
1881 sphb->mem64_win_pciaddr, sphb->mem64_win_size);
1882 g_free(namebuf);
1883
1884 memory_region_add_subregion(get_system_memory(),
1885 sphb->mem64_win_addr,
1886 &sphb->mem64window);
1887 }
1888
1889
1890 namebuf = g_strdup_printf("%s.io", sphb->dtbusname);
1891 memory_region_init(&sphb->iospace, OBJECT(sphb),
1892 namebuf, SPAPR_PCI_IO_WIN_SIZE);
1893 g_free(namebuf);
1894
1895 namebuf = g_strdup_printf("%s.io-alias", sphb->dtbusname);
1896 memory_region_init_alias(&sphb->iowindow, OBJECT(sphb), namebuf,
1897 &sphb->iospace, 0, SPAPR_PCI_IO_WIN_SIZE);
1898 g_free(namebuf);
1899 memory_region_add_subregion(get_system_memory(), sphb->io_win_addr,
1900 &sphb->iowindow);
1901
1902 bus = pci_register_root_bus(dev, NULL,
1903 pci_spapr_set_irq, pci_swizzle_map_irq_fn, sphb,
1904 &sphb->memspace, &sphb->iospace,
1905 PCI_DEVFN(0, 0), PCI_NUM_PINS,
1906 TYPE_PCI_BUS);
1907
1908
1909
1910
1911
1912
1913 if (sphb->pcie_ecs) {
1914 bus->flags |= PCI_BUS_EXTENDED_CONFIG_SPACE;
1915 }
1916 phb->bus = bus;
1917 qbus_set_hotplug_handler(BUS(phb->bus), OBJECT(sphb), NULL);
1918
1919
1920
1921
1922
1923
1924
1925
1926 namebuf = g_strdup_printf("%s.iommu-root", sphb->dtbusname);
1927 memory_region_init(&sphb->iommu_root, OBJECT(sphb),
1928 namebuf, UINT64_MAX);
1929 g_free(namebuf);
1930 address_space_init(&sphb->iommu_as, &sphb->iommu_root,
1931 sphb->dtbusname);
1932
1933
1934
1935
1936
1937
1938
1939
1940
1941
1942
1943
1944 if (kvm_enabled()) {
1945 msi_window_size = qemu_real_host_page_size;
1946 }
1947
1948 memory_region_init_io(&sphb->msiwindow, OBJECT(sphb), &spapr_msi_ops, spapr,
1949 "msi", msi_window_size);
1950 memory_region_add_subregion(&sphb->iommu_root, SPAPR_PCI_MSI_WINDOW,
1951 &sphb->msiwindow);
1952
1953 pci_setup_iommu(bus, spapr_pci_dma_iommu, sphb);
1954
1955 pci_bus_set_route_irq_fn(bus, spapr_route_intx_pin_to_irq);
1956
1957 QLIST_INSERT_HEAD(&spapr->phbs, sphb, list);
1958
1959
1960 for (i = 0; i < PCI_NUM_PINS; i++) {
1961 uint32_t irq = SPAPR_IRQ_PCI_LSI + sphb->index * PCI_NUM_PINS + i;
1962
1963 if (smc->legacy_irq_allocation) {
1964 irq = spapr_irq_findone(spapr, &local_err);
1965 if (local_err) {
1966 error_propagate_prepend(errp, local_err,
1967 "can't allocate LSIs: ");
1968
1969
1970
1971
1972 return;
1973 }
1974 }
1975
1976 spapr_irq_claim(spapr, irq, true, &local_err);
1977 if (local_err) {
1978 error_propagate_prepend(errp, local_err, "can't allocate LSIs: ");
1979 goto unrealize;
1980 }
1981
1982 sphb->lsi_table[i].irq = irq;
1983 }
1984
1985
1986 add_drcs(sphb, phb->bus, &local_err);
1987 if (local_err) {
1988 error_propagate(errp, local_err);
1989 goto unrealize;
1990 }
1991
1992
1993 for (i = 0; i < windows_supported; ++i) {
1994 tcet = spapr_tce_new_table(DEVICE(sphb), sphb->dma_liobn[i]);
1995 if (!tcet) {
1996 error_setg(errp, "Creating window#%d failed for %s",
1997 i, sphb->dtbusname);
1998 goto unrealize;
1999 }
2000 memory_region_add_subregion(&sphb->iommu_root, 0,
2001 spapr_tce_get_iommu(tcet));
2002 }
2003
2004 sphb->msi = g_hash_table_new_full(g_int_hash, g_int_equal, g_free,
2005 spapr_phb_destroy_msi);
2006 return;
2007
2008unrealize:
2009 spapr_phb_unrealize(dev, NULL);
2010}
2011
2012static int spapr_phb_children_reset(Object *child, void *opaque)
2013{
2014 DeviceState *dev = (DeviceState *) object_dynamic_cast(child, TYPE_DEVICE);
2015
2016 if (dev) {
2017 device_reset(dev);
2018 }
2019
2020 return 0;
2021}
2022
2023void spapr_phb_dma_reset(SpaprPhbState *sphb)
2024{
2025 int i;
2026 SpaprTceTable *tcet;
2027
2028 for (i = 0; i < SPAPR_PCI_DMA_MAX_WINDOWS; ++i) {
2029 tcet = spapr_tce_find_by_liobn(sphb->dma_liobn[i]);
2030
2031 if (tcet && tcet->nb_table) {
2032 spapr_tce_table_disable(tcet);
2033 }
2034 }
2035
2036
2037 tcet = spapr_tce_find_by_liobn(sphb->dma_liobn[0]);
2038 spapr_tce_table_enable(tcet, SPAPR_TCE_PAGE_SHIFT, sphb->dma_win_addr,
2039 sphb->dma_win_size >> SPAPR_TCE_PAGE_SHIFT);
2040}
2041
2042static void spapr_phb_reset(DeviceState *qdev)
2043{
2044 SpaprPhbState *sphb = SPAPR_PCI_HOST_BRIDGE(qdev);
2045 Error *errp = NULL;
2046
2047 spapr_phb_dma_reset(sphb);
2048 spapr_phb_nvgpu_free(sphb);
2049 spapr_phb_nvgpu_setup(sphb, &errp);
2050 if (errp) {
2051 error_report_err(errp);
2052 }
2053
2054
2055 object_child_foreach(OBJECT(qdev), spapr_phb_children_reset, NULL);
2056
2057 if (spapr_phb_eeh_available(SPAPR_PCI_HOST_BRIDGE(qdev))) {
2058 spapr_phb_vfio_reset(qdev);
2059 }
2060
2061 g_hash_table_remove_all(sphb->msi);
2062}
2063
2064static Property spapr_phb_properties[] = {
2065 DEFINE_PROP_UINT32("index", SpaprPhbState, index, -1),
2066 DEFINE_PROP_UINT64("mem_win_size", SpaprPhbState, mem_win_size,
2067 SPAPR_PCI_MEM32_WIN_SIZE),
2068 DEFINE_PROP_UINT64("mem64_win_size", SpaprPhbState, mem64_win_size,
2069 SPAPR_PCI_MEM64_WIN_SIZE),
2070 DEFINE_PROP_UINT64("io_win_size", SpaprPhbState, io_win_size,
2071 SPAPR_PCI_IO_WIN_SIZE),
2072 DEFINE_PROP_BOOL("dynamic-reconfiguration", SpaprPhbState, dr_enabled,
2073 true),
2074
2075 DEFINE_PROP_UINT64("dma_win_addr", SpaprPhbState, dma_win_addr, 0),
2076 DEFINE_PROP_UINT64("dma_win_size", SpaprPhbState, dma_win_size, 0x40000000),
2077 DEFINE_PROP_UINT64("dma64_win_addr", SpaprPhbState, dma64_win_addr,
2078 0x800000000000000ULL),
2079 DEFINE_PROP_BOOL("ddw", SpaprPhbState, ddw_enabled, true),
2080 DEFINE_PROP_UINT64("pgsz", SpaprPhbState, page_size_mask,
2081 (1ULL << 12) | (1ULL << 16)
2082 | (1ULL << 21) | (1ULL << 24)),
2083 DEFINE_PROP_UINT32("numa_node", SpaprPhbState, numa_node, -1),
2084 DEFINE_PROP_BOOL("pre-2.8-migration", SpaprPhbState,
2085 pre_2_8_migration, false),
2086 DEFINE_PROP_BOOL("pcie-extended-configuration-space", SpaprPhbState,
2087 pcie_ecs, true),
2088 DEFINE_PROP_UINT64("gpa", SpaprPhbState, nv2_gpa_win_addr, 0),
2089 DEFINE_PROP_UINT64("atsd", SpaprPhbState, nv2_atsd_win_addr, 0),
2090 DEFINE_PROP_END_OF_LIST(),
2091};
2092
2093static const VMStateDescription vmstate_spapr_pci_lsi = {
2094 .name = "spapr_pci/lsi",
2095 .version_id = 1,
2096 .minimum_version_id = 1,
2097 .fields = (VMStateField[]) {
2098 VMSTATE_UINT32_EQUAL(irq, SpaprPciLsi, NULL),
2099
2100 VMSTATE_END_OF_LIST()
2101 },
2102};
2103
2104static const VMStateDescription vmstate_spapr_pci_msi = {
2105 .name = "spapr_pci/msi",
2106 .version_id = 1,
2107 .minimum_version_id = 1,
2108 .fields = (VMStateField []) {
2109 VMSTATE_UINT32(key, SpaprPciMsiMig),
2110 VMSTATE_UINT32(value.first_irq, SpaprPciMsiMig),
2111 VMSTATE_UINT32(value.num, SpaprPciMsiMig),
2112 VMSTATE_END_OF_LIST()
2113 },
2114};
2115
2116static int spapr_pci_pre_save(void *opaque)
2117{
2118 SpaprPhbState *sphb = opaque;
2119 GHashTableIter iter;
2120 gpointer key, value;
2121 int i;
2122
2123 if (sphb->pre_2_8_migration) {
2124 sphb->mig_liobn = sphb->dma_liobn[0];
2125 sphb->mig_mem_win_addr = sphb->mem_win_addr;
2126 sphb->mig_mem_win_size = sphb->mem_win_size;
2127 sphb->mig_io_win_addr = sphb->io_win_addr;
2128 sphb->mig_io_win_size = sphb->io_win_size;
2129
2130 if ((sphb->mem64_win_size != 0)
2131 && (sphb->mem64_win_addr
2132 == (sphb->mem_win_addr + sphb->mem_win_size))) {
2133 sphb->mig_mem_win_size += sphb->mem64_win_size;
2134 }
2135 }
2136
2137 g_free(sphb->msi_devs);
2138 sphb->msi_devs = NULL;
2139 sphb->msi_devs_num = g_hash_table_size(sphb->msi);
2140 if (!sphb->msi_devs_num) {
2141 return 0;
2142 }
2143 sphb->msi_devs = g_new(SpaprPciMsiMig, sphb->msi_devs_num);
2144
2145 g_hash_table_iter_init(&iter, sphb->msi);
2146 for (i = 0; g_hash_table_iter_next(&iter, &key, &value); ++i) {
2147 sphb->msi_devs[i].key = *(uint32_t *) key;
2148 sphb->msi_devs[i].value = *(SpaprPciMsi *) value;
2149 }
2150
2151 return 0;
2152}
2153
2154static int spapr_pci_post_load(void *opaque, int version_id)
2155{
2156 SpaprPhbState *sphb = opaque;
2157 gpointer key, value;
2158 int i;
2159
2160 for (i = 0; i < sphb->msi_devs_num; ++i) {
2161 key = g_memdup(&sphb->msi_devs[i].key,
2162 sizeof(sphb->msi_devs[i].key));
2163 value = g_memdup(&sphb->msi_devs[i].value,
2164 sizeof(sphb->msi_devs[i].value));
2165 g_hash_table_insert(sphb->msi, key, value);
2166 }
2167 g_free(sphb->msi_devs);
2168 sphb->msi_devs = NULL;
2169 sphb->msi_devs_num = 0;
2170
2171 return 0;
2172}
2173
2174static bool pre_2_8_migration(void *opaque, int version_id)
2175{
2176 SpaprPhbState *sphb = opaque;
2177
2178 return sphb->pre_2_8_migration;
2179}
2180
2181static const VMStateDescription vmstate_spapr_pci = {
2182 .name = "spapr_pci",
2183 .version_id = 2,
2184 .minimum_version_id = 2,
2185 .pre_save = spapr_pci_pre_save,
2186 .post_load = spapr_pci_post_load,
2187 .fields = (VMStateField[]) {
2188 VMSTATE_UINT64_EQUAL(buid, SpaprPhbState, NULL),
2189 VMSTATE_UINT32_TEST(mig_liobn, SpaprPhbState, pre_2_8_migration),
2190 VMSTATE_UINT64_TEST(mig_mem_win_addr, SpaprPhbState, pre_2_8_migration),
2191 VMSTATE_UINT64_TEST(mig_mem_win_size, SpaprPhbState, pre_2_8_migration),
2192 VMSTATE_UINT64_TEST(mig_io_win_addr, SpaprPhbState, pre_2_8_migration),
2193 VMSTATE_UINT64_TEST(mig_io_win_size, SpaprPhbState, pre_2_8_migration),
2194 VMSTATE_STRUCT_ARRAY(lsi_table, SpaprPhbState, PCI_NUM_PINS, 0,
2195 vmstate_spapr_pci_lsi, SpaprPciLsi),
2196 VMSTATE_INT32(msi_devs_num, SpaprPhbState),
2197 VMSTATE_STRUCT_VARRAY_ALLOC(msi_devs, SpaprPhbState, msi_devs_num, 0,
2198 vmstate_spapr_pci_msi, SpaprPciMsiMig),
2199 VMSTATE_END_OF_LIST()
2200 },
2201};
2202
2203static const char *spapr_phb_root_bus_path(PCIHostState *host_bridge,
2204 PCIBus *rootbus)
2205{
2206 SpaprPhbState *sphb = SPAPR_PCI_HOST_BRIDGE(host_bridge);
2207
2208 return sphb->dtbusname;
2209}
2210
2211static void spapr_phb_class_init(ObjectClass *klass, void *data)
2212{
2213 PCIHostBridgeClass *hc = PCI_HOST_BRIDGE_CLASS(klass);
2214 DeviceClass *dc = DEVICE_CLASS(klass);
2215 HotplugHandlerClass *hp = HOTPLUG_HANDLER_CLASS(klass);
2216
2217 hc->root_bus_path = spapr_phb_root_bus_path;
2218 dc->realize = spapr_phb_realize;
2219 dc->unrealize = spapr_phb_unrealize;
2220 dc->props = spapr_phb_properties;
2221 dc->reset = spapr_phb_reset;
2222 dc->vmsd = &vmstate_spapr_pci;
2223
2224 dc->user_creatable = true;
2225 set_bit(DEVICE_CATEGORY_BRIDGE, dc->categories);
2226 hp->plug = spapr_pci_plug;
2227 hp->unplug = spapr_pci_unplug;
2228 hp->unplug_request = spapr_pci_unplug_request;
2229}
2230
2231static const TypeInfo spapr_phb_info = {
2232 .name = TYPE_SPAPR_PCI_HOST_BRIDGE,
2233 .parent = TYPE_PCI_HOST_BRIDGE,
2234 .instance_size = sizeof(SpaprPhbState),
2235 .instance_finalize = spapr_phb_finalizefn,
2236 .class_init = spapr_phb_class_init,
2237 .interfaces = (InterfaceInfo[]) {
2238 { TYPE_HOTPLUG_HANDLER },
2239 { }
2240 }
2241};
2242
2243static void spapr_phb_pci_enumerate_bridge(PCIBus *bus, PCIDevice *pdev,
2244 void *opaque)
2245{
2246 unsigned int *bus_no = opaque;
2247 PCIBus *sec_bus = NULL;
2248
2249 if ((pci_default_read_config(pdev, PCI_HEADER_TYPE, 1) !=
2250 PCI_HEADER_TYPE_BRIDGE)) {
2251 return;
2252 }
2253
2254 (*bus_no)++;
2255 pci_default_write_config(pdev, PCI_PRIMARY_BUS, pci_dev_bus_num(pdev), 1);
2256 pci_default_write_config(pdev, PCI_SECONDARY_BUS, *bus_no, 1);
2257 pci_default_write_config(pdev, PCI_SUBORDINATE_BUS, *bus_no, 1);
2258
2259 sec_bus = pci_bridge_get_sec_bus(PCI_BRIDGE(pdev));
2260 if (!sec_bus) {
2261 return;
2262 }
2263
2264 pci_for_each_device(sec_bus, pci_bus_num(sec_bus),
2265 spapr_phb_pci_enumerate_bridge, bus_no);
2266 pci_default_write_config(pdev, PCI_SUBORDINATE_BUS, *bus_no, 1);
2267}
2268
2269static void spapr_phb_pci_enumerate(SpaprPhbState *phb)
2270{
2271 PCIBus *bus = PCI_HOST_BRIDGE(phb)->bus;
2272 unsigned int bus_no = 0;
2273
2274 pci_for_each_device(bus, pci_bus_num(bus),
2275 spapr_phb_pci_enumerate_bridge,
2276 &bus_no);
2277
2278}
2279
2280int spapr_dt_phb(SpaprMachineState *spapr, SpaprPhbState *phb,
2281 uint32_t intc_phandle, void *fdt, int *node_offset)
2282{
2283 int bus_off, i, j, ret;
2284 uint32_t bus_range[] = { cpu_to_be32(0), cpu_to_be32(0xff) };
2285 struct {
2286 uint32_t hi;
2287 uint64_t child;
2288 uint64_t parent;
2289 uint64_t size;
2290 } QEMU_PACKED ranges[] = {
2291 {
2292 cpu_to_be32(b_ss(1)), cpu_to_be64(0),
2293 cpu_to_be64(phb->io_win_addr),
2294 cpu_to_be64(memory_region_size(&phb->iospace)),
2295 },
2296 {
2297 cpu_to_be32(b_ss(2)), cpu_to_be64(SPAPR_PCI_MEM_WIN_BUS_OFFSET),
2298 cpu_to_be64(phb->mem_win_addr),
2299 cpu_to_be64(phb->mem_win_size),
2300 },
2301 {
2302 cpu_to_be32(b_ss(3)), cpu_to_be64(phb->mem64_win_pciaddr),
2303 cpu_to_be64(phb->mem64_win_addr),
2304 cpu_to_be64(phb->mem64_win_size),
2305 },
2306 };
2307 const unsigned sizeof_ranges =
2308 (phb->mem64_win_size ? 3 : 2) * sizeof(ranges[0]);
2309 uint64_t bus_reg[] = { cpu_to_be64(phb->buid), 0 };
2310 uint32_t interrupt_map_mask[] = {
2311 cpu_to_be32(b_ddddd(-1)|b_fff(0)), 0x0, 0x0, cpu_to_be32(-1)};
2312 uint32_t interrupt_map[PCI_SLOT_MAX * PCI_NUM_PINS][7];
2313 uint32_t ddw_applicable[] = {
2314 cpu_to_be32(RTAS_IBM_QUERY_PE_DMA_WINDOW),
2315 cpu_to_be32(RTAS_IBM_CREATE_PE_DMA_WINDOW),
2316 cpu_to_be32(RTAS_IBM_REMOVE_PE_DMA_WINDOW)
2317 };
2318 uint32_t ddw_extensions[] = {
2319 cpu_to_be32(1),
2320 cpu_to_be32(RTAS_IBM_RESET_PE_DMA_WINDOW)
2321 };
2322 uint32_t associativity[] = {cpu_to_be32(0x4),
2323 cpu_to_be32(0x0),
2324 cpu_to_be32(0x0),
2325 cpu_to_be32(0x0),
2326 cpu_to_be32(phb->numa_node)};
2327 SpaprTceTable *tcet;
2328 SpaprDrc *drc;
2329 Error *errp = NULL;
2330
2331
2332 _FDT(bus_off = fdt_add_subnode(fdt, 0, phb->dtbusname));
2333 if (node_offset) {
2334 *node_offset = bus_off;
2335 }
2336
2337
2338 _FDT(fdt_setprop_string(fdt, bus_off, "device_type", "pci"));
2339 _FDT(fdt_setprop_string(fdt, bus_off, "compatible", "IBM,Logical_PHB"));
2340 _FDT(fdt_setprop_cell(fdt, bus_off, "#interrupt-cells", 0x1));
2341 _FDT(fdt_setprop(fdt, bus_off, "used-by-rtas", NULL, 0));
2342 _FDT(fdt_setprop(fdt, bus_off, "bus-range", &bus_range, sizeof(bus_range)));
2343 _FDT(fdt_setprop(fdt, bus_off, "ranges", &ranges, sizeof_ranges));
2344 _FDT(fdt_setprop(fdt, bus_off, "reg", &bus_reg, sizeof(bus_reg)));
2345 _FDT(fdt_setprop_cell(fdt, bus_off, "ibm,pci-config-space-type", 0x1));
2346 _FDT(fdt_setprop_cell(fdt, bus_off, "ibm,pe-total-#msi",
2347 spapr_irq_nr_msis(spapr)));
2348
2349
2350 if (phb->ddw_enabled) {
2351 _FDT(fdt_setprop(fdt, bus_off, "ibm,ddw-applicable", &ddw_applicable,
2352 sizeof(ddw_applicable)));
2353 _FDT(fdt_setprop(fdt, bus_off, "ibm,ddw-extensions",
2354 &ddw_extensions, sizeof(ddw_extensions)));
2355 }
2356
2357
2358 if (phb->numa_node != -1) {
2359 _FDT(fdt_setprop(fdt, bus_off, "ibm,associativity", associativity,
2360 sizeof(associativity)));
2361 }
2362
2363
2364
2365
2366 _FDT(fdt_setprop(fdt, bus_off, "interrupt-map-mask",
2367 &interrupt_map_mask, sizeof(interrupt_map_mask)));
2368 for (i = 0; i < PCI_SLOT_MAX; i++) {
2369 for (j = 0; j < PCI_NUM_PINS; j++) {
2370 uint32_t *irqmap = interrupt_map[i*PCI_NUM_PINS + j];
2371 int lsi_num = pci_swizzle(i, j);
2372
2373 irqmap[0] = cpu_to_be32(b_ddddd(i)|b_fff(0));
2374 irqmap[1] = 0;
2375 irqmap[2] = 0;
2376 irqmap[3] = cpu_to_be32(j+1);
2377 irqmap[4] = cpu_to_be32(intc_phandle);
2378 spapr_dt_irq(&irqmap[5], phb->lsi_table[lsi_num].irq, true);
2379 }
2380 }
2381
2382 _FDT(fdt_setprop(fdt, bus_off, "interrupt-map", &interrupt_map,
2383 sizeof(interrupt_map)));
2384
2385 tcet = spapr_tce_find_by_liobn(phb->dma_liobn[0]);
2386 if (!tcet) {
2387 return -1;
2388 }
2389 spapr_dma_dt(fdt, bus_off, "ibm,dma-window",
2390 tcet->liobn, tcet->bus_offset,
2391 tcet->nb_table << tcet->page_shift);
2392
2393 drc = spapr_drc_by_id(TYPE_SPAPR_DRC_PHB, phb->index);
2394 if (drc) {
2395 uint32_t drc_index = cpu_to_be32(spapr_drc_index(drc));
2396
2397 _FDT(fdt_setprop(fdt, bus_off, "ibm,my-drc-index", &drc_index,
2398 sizeof(drc_index)));
2399 }
2400
2401
2402 spapr_phb_pci_enumerate(phb);
2403 _FDT(fdt_setprop_cell(fdt, bus_off, "qemu,phb-enumerated", 0x1));
2404
2405
2406 ret = spapr_dt_pci_bus(phb, PCI_HOST_BRIDGE(phb)->bus, fdt, bus_off);
2407 if (ret < 0) {
2408 return ret;
2409 }
2410
2411 spapr_phb_nvgpu_populate_dt(phb, fdt, bus_off, &errp);
2412 if (errp) {
2413 error_report_err(errp);
2414 }
2415 spapr_phb_nvgpu_ram_populate_dt(phb, fdt);
2416
2417 return 0;
2418}
2419
2420void spapr_pci_rtas_init(void)
2421{
2422 spapr_rtas_register(RTAS_READ_PCI_CONFIG, "read-pci-config",
2423 rtas_read_pci_config);
2424 spapr_rtas_register(RTAS_WRITE_PCI_CONFIG, "write-pci-config",
2425 rtas_write_pci_config);
2426 spapr_rtas_register(RTAS_IBM_READ_PCI_CONFIG, "ibm,read-pci-config",
2427 rtas_ibm_read_pci_config);
2428 spapr_rtas_register(RTAS_IBM_WRITE_PCI_CONFIG, "ibm,write-pci-config",
2429 rtas_ibm_write_pci_config);
2430 if (msi_nonbroken) {
2431 spapr_rtas_register(RTAS_IBM_QUERY_INTERRUPT_SOURCE_NUMBER,
2432 "ibm,query-interrupt-source-number",
2433 rtas_ibm_query_interrupt_source_number);
2434 spapr_rtas_register(RTAS_IBM_CHANGE_MSI, "ibm,change-msi",
2435 rtas_ibm_change_msi);
2436 }
2437
2438 spapr_rtas_register(RTAS_IBM_SET_EEH_OPTION,
2439 "ibm,set-eeh-option",
2440 rtas_ibm_set_eeh_option);
2441 spapr_rtas_register(RTAS_IBM_GET_CONFIG_ADDR_INFO2,
2442 "ibm,get-config-addr-info2",
2443 rtas_ibm_get_config_addr_info2);
2444 spapr_rtas_register(RTAS_IBM_READ_SLOT_RESET_STATE2,
2445 "ibm,read-slot-reset-state2",
2446 rtas_ibm_read_slot_reset_state2);
2447 spapr_rtas_register(RTAS_IBM_SET_SLOT_RESET,
2448 "ibm,set-slot-reset",
2449 rtas_ibm_set_slot_reset);
2450 spapr_rtas_register(RTAS_IBM_CONFIGURE_PE,
2451 "ibm,configure-pe",
2452 rtas_ibm_configure_pe);
2453 spapr_rtas_register(RTAS_IBM_SLOT_ERROR_DETAIL,
2454 "ibm,slot-error-detail",
2455 rtas_ibm_slot_error_detail);
2456}
2457
2458static void spapr_pci_register_types(void)
2459{
2460 type_register_static(&spapr_phb_info);
2461}
2462
2463type_init(spapr_pci_register_types)
2464
2465static int spapr_switch_one_vga(DeviceState *dev, void *opaque)
2466{
2467 bool be = *(bool *)opaque;
2468
2469 if (object_dynamic_cast(OBJECT(dev), "VGA")
2470 || object_dynamic_cast(OBJECT(dev), "secondary-vga")) {
2471 object_property_set_bool(OBJECT(dev), be, "big-endian-framebuffer",
2472 &error_abort);
2473 }
2474 return 0;
2475}
2476
2477void spapr_pci_switch_vga(bool big_endian)
2478{
2479 SpaprMachineState *spapr = SPAPR_MACHINE(qdev_get_machine());
2480 SpaprPhbState *sphb;
2481
2482
2483
2484
2485
2486
2487 QLIST_FOREACH(sphb, &spapr->phbs, list) {
2488 BusState *bus = &PCI_HOST_BRIDGE(sphb)->bus->qbus;
2489 qbus_walk_children(bus, spapr_switch_one_vga, NULL, NULL, NULL,
2490 &big_endian);
2491 }
2492}
2493