2 * QEMU PowerPC PowerNV (POWER9) PHB4 model
4 * Copyright (c) 2018-2020, IBM Corporation.
6 * This code is licensed under the GPL version 2 or later. See the
7 * COPYING file in the top-level directory.
9 #include "qemu/osdep.h"
11 #include "qapi/visitor.h"
12 #include "qapi/error.h"
13 #include "qemu-common.h"
14 #include "monitor/monitor.h"
15 #include "target/ppc/cpu.h"
16 #include "hw/pci-host/pnv_phb4_regs.h"
17 #include "hw/pci-host/pnv_phb4.h"
18 #include "hw/pci/pcie_host.h"
19 #include "hw/pci/pcie_port.h"
20 #include "hw/ppc/pnv.h"
21 #include "hw/ppc/pnv_xscom.h"
23 #include "hw/qdev-properties.h"
24 #include "qom/object.h"
25 #include "sysemu/sysemu.h"
28 #define phb_error(phb, fmt, ...) \
29 qemu_log_mask(LOG_GUEST_ERROR, "phb4[%d:%d]: " fmt "\n", \
30 (phb)->chip_id, (phb)->phb_id, ## __VA_ARGS__)
32 #define phb_pec_error(pec, fmt, ...) \
33 qemu_log_mask(LOG_GUEST_ERROR, "phb4_pec[%d:%d]: " fmt "\n", \
34 (pec)->chip_id, (pec)->index, ## __VA_ARGS__)
37 * QEMU version of the GETFIELD/SETFIELD macros
39 * These are common with the PnvXive model.
41 static inline uint64_t GETFIELD(uint64_t mask
, uint64_t word
)
43 return (word
& mask
) >> ctz64(mask
);
46 static inline uint64_t SETFIELD(uint64_t mask
, uint64_t word
,
49 return (word
& ~mask
) | ((value
<< ctz64(mask
)) & mask
);
52 static PCIDevice
*pnv_phb4_find_cfg_dev(PnvPHB4
*phb
)
54 PCIHostState
*pci
= PCI_HOST_BRIDGE(phb
);
55 uint64_t addr
= phb
->regs
[PHB_CONFIG_ADDRESS
>> 3];
61 bus
= (addr
>> 52) & 0xff;
62 devfn
= (addr
>> 44) & 0xff;
64 /* We don't access the root complex this way */
65 if (bus
== 0 && devfn
== 0) {
68 return pci_find_device(pci
->bus
, bus
, devfn
);
72 * The CONFIG_DATA register expects little endian accesses, but as the
73 * region is big endian, we have to swap the value.
75 static void pnv_phb4_config_write(PnvPHB4
*phb
, unsigned off
,
76 unsigned size
, uint64_t val
)
78 uint32_t cfg_addr
, limit
;
81 pdev
= pnv_phb4_find_cfg_dev(phb
);
85 cfg_addr
= (phb
->regs
[PHB_CONFIG_ADDRESS
>> 3] >> 32) & 0xffc;
87 limit
= pci_config_size(pdev
);
88 if (limit
<= cfg_addr
) {
90 * conventional pci device can be behind pcie-to-pci bridge.
91 * 256 <= addr < 4K has no effects.
105 g_assert_not_reached();
107 pci_host_config_write_common(pdev
, cfg_addr
, limit
, val
, size
);
110 static uint64_t pnv_phb4_config_read(PnvPHB4
*phb
, unsigned off
,
113 uint32_t cfg_addr
, limit
;
117 pdev
= pnv_phb4_find_cfg_dev(phb
);
121 cfg_addr
= (phb
->regs
[PHB_CONFIG_ADDRESS
>> 3] >> 32) & 0xffc;
123 limit
= pci_config_size(pdev
);
124 if (limit
<= cfg_addr
) {
126 * conventional pci device can be behind pcie-to-pci bridge.
127 * 256 <= addr < 4K has no effects.
131 val
= pci_host_config_read_common(pdev
, cfg_addr
, limit
, size
);
140 g_assert_not_reached();
145 * Root complex register accesses are memory mapped.
147 static void pnv_phb4_rc_config_write(PnvPHB4
*phb
, unsigned off
,
148 unsigned size
, uint64_t val
)
150 PCIHostState
*pci
= PCI_HOST_BRIDGE(phb
);
154 phb_error(phb
, "rc_config_write invalid size %d\n", size
);
158 pdev
= pci_find_device(pci
->bus
, 0, 0);
160 phb_error(phb
, "rc_config_write device not found\n");
164 pci_host_config_write_common(pdev
, off
, PHB_RC_CONFIG_SIZE
,
168 static uint64_t pnv_phb4_rc_config_read(PnvPHB4
*phb
, unsigned off
,
171 PCIHostState
*pci
= PCI_HOST_BRIDGE(phb
);
176 phb_error(phb
, "rc_config_read invalid size %d\n", size
);
180 pdev
= pci_find_device(pci
->bus
, 0, 0);
182 phb_error(phb
, "rc_config_read device not found\n");
186 val
= pci_host_config_read_common(pdev
, off
, PHB_RC_CONFIG_SIZE
, 4);
190 static void pnv_phb4_check_mbt(PnvPHB4
*phb
, uint32_t index
)
192 uint64_t base
, start
, size
, mbe0
, mbe1
;
193 MemoryRegion
*parent
;
197 if (memory_region_is_mapped(&phb
->mr_mmio
[index
])) {
198 /* Should we destroy it in RCU friendly way... ? */
199 memory_region_del_subregion(phb
->mr_mmio
[index
].container
,
200 &phb
->mr_mmio
[index
]);
203 /* Get table entry */
204 mbe0
= phb
->ioda_MBT
[(index
<< 1)];
205 mbe1
= phb
->ioda_MBT
[(index
<< 1) + 1];
207 if (!(mbe0
& IODA3_MBT0_ENABLE
)) {
211 /* Grab geometry from registers */
212 base
= GETFIELD(IODA3_MBT0_BASE_ADDR
, mbe0
) << 12;
213 size
= GETFIELD(IODA3_MBT1_MASK
, mbe1
) << 12;
214 size
|= 0xff00000000000000ull
;
217 /* Calculate PCI side start address based on M32/M64 window type */
218 if (mbe0
& IODA3_MBT0_TYPE_M32
) {
219 start
= phb
->regs
[PHB_M32_START_ADDR
>> 3];
220 if ((start
+ size
) > 0x100000000ull
) {
221 phb_error(phb
, "M32 set beyond 4GB boundary !");
222 size
= 0x100000000 - start
;
225 start
= base
| (phb
->regs
[PHB_M64_UPPER_BITS
>> 3]);
228 /* TODO: Figure out how to implemet/decode AOMASK */
230 /* Check if it matches an enabled MMIO region in the PEC stack */
231 if (memory_region_is_mapped(&phb
->stack
->mmbar0
) &&
232 base
>= phb
->stack
->mmio0_base
&&
233 (base
+ size
) <= (phb
->stack
->mmio0_base
+ phb
->stack
->mmio0_size
)) {
234 parent
= &phb
->stack
->mmbar0
;
235 base
-= phb
->stack
->mmio0_base
;
236 } else if (memory_region_is_mapped(&phb
->stack
->mmbar1
) &&
237 base
>= phb
->stack
->mmio1_base
&&
238 (base
+ size
) <= (phb
->stack
->mmio1_base
+ phb
->stack
->mmio1_size
)) {
239 parent
= &phb
->stack
->mmbar1
;
240 base
-= phb
->stack
->mmio1_base
;
242 phb_error(phb
, "PHB MBAR %d out of parent bounds", index
);
246 /* Create alias (better name ?) */
247 snprintf(name
, sizeof(name
), "phb4-mbar%d", index
);
248 memory_region_init_alias(&phb
->mr_mmio
[index
], OBJECT(phb
), name
,
249 &phb
->pci_mmio
, start
, size
);
250 memory_region_add_subregion(parent
, base
, &phb
->mr_mmio
[index
]);
253 static void pnv_phb4_check_all_mbt(PnvPHB4
*phb
)
256 uint32_t num_windows
= phb
->big_phb
? PNV_PHB4_MAX_MMIO_WINDOWS
:
257 PNV_PHB4_MIN_MMIO_WINDOWS
;
259 for (i
= 0; i
< num_windows
; i
++) {
260 pnv_phb4_check_mbt(phb
, i
);
264 static uint64_t *pnv_phb4_ioda_access(PnvPHB4
*phb
,
265 unsigned *out_table
, unsigned *out_idx
)
267 uint64_t adreg
= phb
->regs
[PHB_IODA_ADDR
>> 3];
268 unsigned int index
= GETFIELD(PHB_IODA_AD_TADR
, adreg
);
269 unsigned int table
= GETFIELD(PHB_IODA_AD_TSEL
, adreg
);
271 uint64_t *tptr
= NULL
;
275 tptr
= phb
->ioda_LIST
;
279 tptr
= phb
->ioda_MIST
;
280 mask
= phb
->big_phb
? PNV_PHB4_MAX_MIST
: (PNV_PHB4_MAX_MIST
>> 1);
284 mask
= phb
->big_phb
? 127 : 63;
287 mask
= phb
->big_phb
? 15 : 7;
289 case IODA3_TBL_PESTA
:
290 case IODA3_TBL_PESTB
:
291 mask
= phb
->big_phb
? PNV_PHB4_MAX_PEs
: (PNV_PHB4_MAX_PEs
>> 1);
295 tptr
= phb
->ioda_TVT
;
296 mask
= phb
->big_phb
? PNV_PHB4_MAX_TVEs
: (PNV_PHB4_MAX_TVEs
>> 1);
301 mask
= phb
->big_phb
? 1023 : 511;
304 tptr
= phb
->ioda_MBT
;
305 mask
= phb
->big_phb
? PNV_PHB4_MAX_MBEs
: (PNV_PHB4_MAX_MBEs
>> 1);
309 tptr
= phb
->ioda_MDT
;
310 mask
= phb
->big_phb
? PNV_PHB4_MAX_PEs
: (PNV_PHB4_MAX_PEs
>> 1);
314 tptr
= phb
->ioda_PEEV
;
315 mask
= phb
->big_phb
? PNV_PHB4_MAX_PEEVs
: (PNV_PHB4_MAX_PEEVs
>> 1);
319 phb_error(phb
, "invalid IODA table %d", table
);
332 if (adreg
& PHB_IODA_AD_AUTOINC
) {
333 index
= (index
+ 1) & mask
;
334 adreg
= SETFIELD(PHB_IODA_AD_TADR
, adreg
, index
);
337 phb
->regs
[PHB_IODA_ADDR
>> 3] = adreg
;
341 static uint64_t pnv_phb4_ioda_read(PnvPHB4
*phb
)
346 tptr
= pnv_phb4_ioda_access(phb
, &table
, &idx
);
348 /* Special PESTA case */
349 if (table
== IODA3_TBL_PESTA
) {
350 return ((uint64_t)(phb
->ioda_PEST_AB
[idx
] & 1)) << 63;
351 } else if (table
== IODA3_TBL_PESTB
) {
352 return ((uint64_t)(phb
->ioda_PEST_AB
[idx
] & 2)) << 62;
354 /* Return 0 on unsupported tables, not ff's */
360 static void pnv_phb4_ioda_write(PnvPHB4
*phb
, uint64_t val
)
365 tptr
= pnv_phb4_ioda_access(phb
, &table
, &idx
);
367 /* Special PESTA case */
368 if (table
== IODA3_TBL_PESTA
) {
369 phb
->ioda_PEST_AB
[idx
] &= ~1;
370 phb
->ioda_PEST_AB
[idx
] |= (val
>> 63) & 1;
371 } else if (table
== IODA3_TBL_PESTB
) {
372 phb
->ioda_PEST_AB
[idx
] &= ~2;
373 phb
->ioda_PEST_AB
[idx
] |= (val
>> 62) & 2;
378 /* Handle side effects */
382 case IODA3_TBL_MIST
: {
383 /* Special mask for MIST partial write */
384 uint64_t adreg
= phb
->regs
[PHB_IODA_ADDR
>> 3];
385 uint32_t mmask
= GETFIELD(PHB_IODA_AD_MIST_PWV
, adreg
);
391 v
&= 0x0000ffffffffffffull
;
392 v
|= 0xcfff000000000000ull
& val
;
395 v
&= 0xffff0000ffffffffull
;
396 v
|= 0x0000cfff00000000ull
& val
;
399 v
&= 0xffffffff0000ffffull
;
400 v
|= 0x00000000cfff0000ull
& val
;
403 v
&= 0xffffffffffff0000ull
;
404 v
|= 0x000000000000cfffull
& val
;
412 /* Copy accross the valid bit to the other half */
413 phb
->ioda_MBT
[idx
^ 1] &= 0x7fffffffffffffffull
;
414 phb
->ioda_MBT
[idx
^ 1] |= 0x8000000000000000ull
& val
;
416 /* Update mappings */
417 pnv_phb4_check_mbt(phb
, idx
>> 1);
424 static void pnv_phb4_rtc_invalidate(PnvPHB4
*phb
, uint64_t val
)
428 /* Always invalidate all for now ... */
429 QLIST_FOREACH(ds
, &phb
->dma_spaces
, list
) {
430 ds
->pe_num
= PHB_INVALID_PE
;
434 static void pnv_phb4_update_msi_regions(PnvPhb4DMASpace
*ds
)
436 uint64_t cfg
= ds
->phb
->regs
[PHB_PHB4_CONFIG
>> 3];
438 if (cfg
& PHB_PHB4C_32BIT_MSI_EN
) {
439 if (!memory_region_is_mapped(MEMORY_REGION(&ds
->msi32_mr
))) {
440 memory_region_add_subregion(MEMORY_REGION(&ds
->dma_mr
),
441 0xffff0000, &ds
->msi32_mr
);
444 if (memory_region_is_mapped(MEMORY_REGION(&ds
->msi32_mr
))) {
445 memory_region_del_subregion(MEMORY_REGION(&ds
->dma_mr
),
450 if (cfg
& PHB_PHB4C_64BIT_MSI_EN
) {
451 if (!memory_region_is_mapped(MEMORY_REGION(&ds
->msi64_mr
))) {
452 memory_region_add_subregion(MEMORY_REGION(&ds
->dma_mr
),
453 (1ull << 60), &ds
->msi64_mr
);
456 if (memory_region_is_mapped(MEMORY_REGION(&ds
->msi64_mr
))) {
457 memory_region_del_subregion(MEMORY_REGION(&ds
->dma_mr
),
463 static void pnv_phb4_update_all_msi_regions(PnvPHB4
*phb
)
467 QLIST_FOREACH(ds
, &phb
->dma_spaces
, list
) {
468 pnv_phb4_update_msi_regions(ds
);
472 static void pnv_phb4_update_xsrc(PnvPHB4
*phb
)
474 int shift
, flags
, i
, lsi_base
;
475 XiveSource
*xsrc
= &phb
->xsrc
;
477 /* The XIVE source characteristics can be set at run time */
478 if (phb
->regs
[PHB_CTRLR
>> 3] & PHB_CTRLR_IRQ_PGSZ_64K
) {
479 shift
= XIVE_ESB_64K
;
483 if (phb
->regs
[PHB_CTRLR
>> 3] & PHB_CTRLR_IRQ_STORE_EOI
) {
484 flags
= XIVE_SRC_STORE_EOI
;
489 phb
->xsrc
.esb_shift
= shift
;
490 phb
->xsrc
.esb_flags
= flags
;
492 lsi_base
= GETFIELD(PHB_LSI_SRC_ID
, phb
->regs
[PHB_LSI_SOURCE_ID
>> 3]);
495 /* TODO: handle reset values of PHB_LSI_SRC_ID */
500 /* TODO: need a xive_source_irq_reset_lsi() */
501 bitmap_zero(xsrc
->lsi_map
, xsrc
->nr_irqs
);
503 for (i
= 0; i
< xsrc
->nr_irqs
; i
++) {
504 bool msi
= (i
< lsi_base
|| i
>= (lsi_base
+ 8));
506 xive_source_irq_set_lsi(xsrc
, i
);
511 static void pnv_phb4_reg_write(void *opaque
, hwaddr off
, uint64_t val
,
514 PnvPHB4
*phb
= PNV_PHB4(opaque
);
517 /* Special case outbound configuration data */
518 if ((off
& 0xfffc) == PHB_CONFIG_DATA
) {
519 pnv_phb4_config_write(phb
, off
& 0x3, size
, val
);
523 /* Special case RC configuration space */
524 if ((off
& 0xf800) == PHB_RC_CONFIG_BASE
) {
525 pnv_phb4_rc_config_write(phb
, off
& 0x7ff, size
, val
);
529 /* Other registers are 64-bit only */
530 if (size
!= 8 || off
& 0x7) {
531 phb_error(phb
, "Invalid register access, offset: 0x%"PRIx64
" size: %d",
538 case PHB_LSI_SOURCE_ID
:
539 val
&= PHB_LSI_SRC_ID
;
541 case PHB_M64_UPPER_BITS
:
542 val
&= 0xff00000000000000ull
;
546 /* Clear top 3 bits which HW does to indicate successful queuing */
547 val
&= ~(PHB_TCE_KILL_ALL
| PHB_TCE_KILL_PE
| PHB_TCE_KILL_ONE
);
551 * This is enough logic to make SW happy but we aren't
552 * actually quiescing the DMAs
554 if (val
& PHB_Q_DMA_R_AUTORESET
) {
557 val
&= PHB_Q_DMA_R_QUIESCE_DMA
;
561 case PHB_LEM_FIR_AND_MASK
:
562 phb
->regs
[PHB_LEM_FIR_ACCUM
>> 3] &= val
;
564 case PHB_LEM_FIR_OR_MASK
:
565 phb
->regs
[PHB_LEM_FIR_ACCUM
>> 3] |= val
;
567 case PHB_LEM_ERROR_AND_MASK
:
568 phb
->regs
[PHB_LEM_ERROR_MASK
>> 3] &= val
;
570 case PHB_LEM_ERROR_OR_MASK
:
571 phb
->regs
[PHB_LEM_ERROR_MASK
>> 3] |= val
;
576 /* TODO: More regs ..., maybe create a table with masks... */
578 /* Read only registers */
579 case PHB_CPU_LOADSTORE_STATUS
:
580 case PHB_ETU_ERR_SUMMARY
:
581 case PHB_PHB4_GEN_CAP
:
582 case PHB_PHB4_TCE_CAP
:
583 case PHB_PHB4_IRQ_CAP
:
584 case PHB_PHB4_EEH_CAP
:
588 /* Record whether it changed */
589 changed
= phb
->regs
[off
>> 3] != val
;
591 /* Store in register cache first */
592 phb
->regs
[off
>> 3] = val
;
594 /* Handle side effects */
596 case PHB_PHB4_CONFIG
:
598 pnv_phb4_update_all_msi_regions(phb
);
601 case PHB_M32_START_ADDR
:
602 case PHB_M64_UPPER_BITS
:
604 pnv_phb4_check_all_mbt(phb
);
608 /* IODA table accesses */
610 pnv_phb4_ioda_write(phb
, val
);
613 /* RTC invalidation */
614 case PHB_RTC_INVALIDATE
:
615 pnv_phb4_rtc_invalidate(phb
, val
);
618 /* PHB Control (Affects XIVE source) */
620 case PHB_LSI_SOURCE_ID
:
621 pnv_phb4_update_xsrc(phb
);
624 /* Silent simple writes */
626 case PHB_CONFIG_ADDRESS
:
629 case PHB_TCE_SPEC_CTL
:
633 case PHB_LEM_FIR_ACCUM
:
634 case PHB_LEM_ERROR_MASK
:
635 case PHB_LEM_ACTION0
:
636 case PHB_LEM_ACTION1
:
637 case PHB_TCE_TAG_ENABLE
:
638 case PHB_INT_NOTIFY_ADDR
:
639 case PHB_INT_NOTIFY_INDEX
:
643 /* Noise on anything else */
645 qemu_log_mask(LOG_UNIMP
, "phb4: reg_write 0x%"PRIx64
"=%"PRIx64
"\n",
650 static uint64_t pnv_phb4_reg_read(void *opaque
, hwaddr off
, unsigned size
)
652 PnvPHB4
*phb
= PNV_PHB4(opaque
);
655 if ((off
& 0xfffc) == PHB_CONFIG_DATA
) {
656 return pnv_phb4_config_read(phb
, off
& 0x3, size
);
659 /* Special case RC configuration space */
660 if ((off
& 0xf800) == PHB_RC_CONFIG_BASE
) {
661 return pnv_phb4_rc_config_read(phb
, off
& 0x7ff, size
);
664 /* Other registers are 64-bit only */
665 if (size
!= 8 || off
& 0x7) {
666 phb_error(phb
, "Invalid register access, offset: 0x%"PRIx64
" size: %d",
671 /* Default read from cache */
672 val
= phb
->regs
[off
>> 3];
679 case PHB_PHB4_GEN_CAP
:
680 return 0xe4b8000000000000ull
;
681 case PHB_PHB4_TCE_CAP
:
682 return phb
->big_phb
? 0x4008440000000400ull
: 0x2008440000000200ull
;
683 case PHB_PHB4_IRQ_CAP
:
684 return phb
->big_phb
? 0x0800000000001000ull
: 0x0800000000000800ull
;
685 case PHB_PHB4_EEH_CAP
:
686 return phb
->big_phb
? 0x2000000000000000ull
: 0x1000000000000000ull
;
688 /* IODA table accesses */
690 return pnv_phb4_ioda_read(phb
);
692 /* Link training always appears trained */
693 case PHB_PCIE_DLP_TRAIN_CTL
:
694 /* TODO: Do something sensible with speed ? */
695 return PHB_PCIE_DLP_INBAND_PRESENCE
| PHB_PCIE_DLP_TL_LINKACT
;
697 /* DMA read sync: make it look like it's complete */
699 return PHB_DMARD_SYNC_COMPLETE
;
701 /* Silent simple reads */
702 case PHB_LSI_SOURCE_ID
:
703 case PHB_CPU_LOADSTORE_STATUS
:
705 case PHB_PHB4_CONFIG
:
706 case PHB_M32_START_ADDR
:
707 case PHB_CONFIG_ADDRESS
:
709 case PHB_RTC_INVALIDATE
:
711 case PHB_TCE_SPEC_CTL
:
715 case PHB_M64_UPPER_BITS
:
717 case PHB_LEM_FIR_ACCUM
:
718 case PHB_LEM_ERROR_MASK
:
719 case PHB_LEM_ACTION0
:
720 case PHB_LEM_ACTION1
:
721 case PHB_TCE_TAG_ENABLE
:
722 case PHB_INT_NOTIFY_ADDR
:
723 case PHB_INT_NOTIFY_INDEX
:
725 case PHB_ETU_ERR_SUMMARY
:
728 /* Noise on anything else */
730 qemu_log_mask(LOG_UNIMP
, "phb4: reg_read 0x%"PRIx64
"=%"PRIx64
"\n",
736 static const MemoryRegionOps pnv_phb4_reg_ops
= {
737 .read
= pnv_phb4_reg_read
,
738 .write
= pnv_phb4_reg_write
,
739 .valid
.min_access_size
= 1,
740 .valid
.max_access_size
= 8,
741 .impl
.min_access_size
= 1,
742 .impl
.max_access_size
= 8,
743 .endianness
= DEVICE_BIG_ENDIAN
,
746 static uint64_t pnv_phb4_xscom_read(void *opaque
, hwaddr addr
, unsigned size
)
748 PnvPHB4
*phb
= PNV_PHB4(opaque
);
749 uint32_t reg
= addr
>> 3;
754 case PHB_SCOM_HV_IND_ADDR
:
755 return phb
->scom_hv_ind_addr_reg
;
757 case PHB_SCOM_HV_IND_DATA
:
758 if (!(phb
->scom_hv_ind_addr_reg
& PHB_SCOM_HV_IND_ADDR_VALID
)) {
759 phb_error(phb
, "Invalid indirect address");
762 size
= (phb
->scom_hv_ind_addr_reg
& PHB_SCOM_HV_IND_ADDR_4B
) ? 4 : 8;
763 offset
= GETFIELD(PHB_SCOM_HV_IND_ADDR_ADDR
, phb
->scom_hv_ind_addr_reg
);
764 val
= pnv_phb4_reg_read(phb
, offset
, size
);
765 if (phb
->scom_hv_ind_addr_reg
& PHB_SCOM_HV_IND_ADDR_AUTOINC
) {
768 phb
->scom_hv_ind_addr_reg
= SETFIELD(PHB_SCOM_HV_IND_ADDR_ADDR
,
769 phb
->scom_hv_ind_addr_reg
,
773 case PHB_SCOM_ETU_LEM_FIR
:
774 case PHB_SCOM_ETU_LEM_FIR_AND
:
775 case PHB_SCOM_ETU_LEM_FIR_OR
:
776 case PHB_SCOM_ETU_LEM_FIR_MSK
:
777 case PHB_SCOM_ETU_LEM_ERR_MSK_AND
:
778 case PHB_SCOM_ETU_LEM_ERR_MSK_OR
:
779 case PHB_SCOM_ETU_LEM_ACT0
:
780 case PHB_SCOM_ETU_LEM_ACT1
:
781 case PHB_SCOM_ETU_LEM_WOF
:
782 offset
= ((reg
- PHB_SCOM_ETU_LEM_FIR
) << 3) + PHB_LEM_FIR_ACCUM
;
783 return pnv_phb4_reg_read(phb
, offset
, size
);
784 case PHB_SCOM_ETU_PMON_CONFIG
:
785 case PHB_SCOM_ETU_PMON_CTR0
:
786 case PHB_SCOM_ETU_PMON_CTR1
:
787 case PHB_SCOM_ETU_PMON_CTR2
:
788 case PHB_SCOM_ETU_PMON_CTR3
:
789 offset
= ((reg
- PHB_SCOM_ETU_PMON_CONFIG
) << 3) + PHB_PERFMON_CONFIG
;
790 return pnv_phb4_reg_read(phb
, offset
, size
);
793 qemu_log_mask(LOG_UNIMP
, "phb4: xscom_read 0x%"HWADDR_PRIx
"\n", addr
);
798 static void pnv_phb4_xscom_write(void *opaque
, hwaddr addr
,
799 uint64_t val
, unsigned size
)
801 PnvPHB4
*phb
= PNV_PHB4(opaque
);
802 uint32_t reg
= addr
>> 3;
806 case PHB_SCOM_HV_IND_ADDR
:
807 phb
->scom_hv_ind_addr_reg
= val
& 0xe000000000001fff;
809 case PHB_SCOM_HV_IND_DATA
:
810 if (!(phb
->scom_hv_ind_addr_reg
& PHB_SCOM_HV_IND_ADDR_VALID
)) {
811 phb_error(phb
, "Invalid indirect address");
814 size
= (phb
->scom_hv_ind_addr_reg
& PHB_SCOM_HV_IND_ADDR_4B
) ? 4 : 8;
815 offset
= GETFIELD(PHB_SCOM_HV_IND_ADDR_ADDR
, phb
->scom_hv_ind_addr_reg
);
816 pnv_phb4_reg_write(phb
, offset
, val
, size
);
817 if (phb
->scom_hv_ind_addr_reg
& PHB_SCOM_HV_IND_ADDR_AUTOINC
) {
820 phb
->scom_hv_ind_addr_reg
= SETFIELD(PHB_SCOM_HV_IND_ADDR_ADDR
,
821 phb
->scom_hv_ind_addr_reg
,
825 case PHB_SCOM_ETU_LEM_FIR
:
826 case PHB_SCOM_ETU_LEM_FIR_AND
:
827 case PHB_SCOM_ETU_LEM_FIR_OR
:
828 case PHB_SCOM_ETU_LEM_FIR_MSK
:
829 case PHB_SCOM_ETU_LEM_ERR_MSK_AND
:
830 case PHB_SCOM_ETU_LEM_ERR_MSK_OR
:
831 case PHB_SCOM_ETU_LEM_ACT0
:
832 case PHB_SCOM_ETU_LEM_ACT1
:
833 case PHB_SCOM_ETU_LEM_WOF
:
834 offset
= ((reg
- PHB_SCOM_ETU_LEM_FIR
) << 3) + PHB_LEM_FIR_ACCUM
;
835 pnv_phb4_reg_write(phb
, offset
, val
, size
);
837 case PHB_SCOM_ETU_PMON_CONFIG
:
838 case PHB_SCOM_ETU_PMON_CTR0
:
839 case PHB_SCOM_ETU_PMON_CTR1
:
840 case PHB_SCOM_ETU_PMON_CTR2
:
841 case PHB_SCOM_ETU_PMON_CTR3
:
842 offset
= ((reg
- PHB_SCOM_ETU_PMON_CONFIG
) << 3) + PHB_PERFMON_CONFIG
;
843 pnv_phb4_reg_write(phb
, offset
, val
, size
);
846 qemu_log_mask(LOG_UNIMP
, "phb4: xscom_write 0x%"HWADDR_PRIx
847 "=%"PRIx64
"\n", addr
, val
);
851 const MemoryRegionOps pnv_phb4_xscom_ops
= {
852 .read
= pnv_phb4_xscom_read
,
853 .write
= pnv_phb4_xscom_write
,
854 .valid
.min_access_size
= 8,
855 .valid
.max_access_size
= 8,
856 .impl
.min_access_size
= 8,
857 .impl
.max_access_size
= 8,
858 .endianness
= DEVICE_BIG_ENDIAN
,
861 static uint64_t pnv_pec_stk_nest_xscom_read(void *opaque
, hwaddr addr
,
864 PnvPhb4PecStack
*stack
= PNV_PHB4_PEC_STACK(opaque
);
865 uint32_t reg
= addr
>> 3;
867 /* TODO: add list of allowed registers and error out if not */
868 return stack
->nest_regs
[reg
];
871 static void pnv_phb4_update_regions(PnvPhb4PecStack
*stack
)
873 PnvPHB4
*phb
= stack
->phb
;
875 /* Unmap first always */
876 if (memory_region_is_mapped(&phb
->mr_regs
)) {
877 memory_region_del_subregion(&phb
->phbbar
, &phb
->mr_regs
);
879 if (memory_region_is_mapped(&phb
->xsrc
.esb_mmio
)) {
880 memory_region_del_subregion(&phb
->intbar
, &phb
->xsrc
.esb_mmio
);
883 /* Map registers if enabled */
884 if (memory_region_is_mapped(&phb
->phbbar
)) {
885 memory_region_add_subregion(&phb
->phbbar
, 0, &phb
->mr_regs
);
888 /* Map ESB if enabled */
889 if (memory_region_is_mapped(&phb
->intbar
)) {
890 memory_region_add_subregion(&phb
->intbar
, 0, &phb
->xsrc
.esb_mmio
);
893 /* Check/update m32 */
894 pnv_phb4_check_all_mbt(phb
);
897 static void pnv_pec_stk_update_map(PnvPhb4PecStack
*stack
)
899 PnvPhb4PecState
*pec
= stack
->pec
;
900 PnvPHB4
*phb
= stack
->phb
;
901 MemoryRegion
*sysmem
= get_system_memory();
902 uint64_t bar_en
= stack
->nest_regs
[PEC_NEST_STK_BAR_EN
];
903 uint64_t bar
, mask
, size
;
907 * NOTE: This will really not work well if those are remapped
908 * after the PHB has created its sub regions. We could do better
909 * if we had a way to resize regions but we don't really care
910 * that much in practice as the stuff below really only happens
911 * once early during boot
915 if (memory_region_is_mapped(&stack
->mmbar0
) &&
916 !(bar_en
& PEC_NEST_STK_BAR_EN_MMIO0
)) {
917 memory_region_del_subregion(sysmem
, &stack
->mmbar0
);
919 if (memory_region_is_mapped(&stack
->mmbar1
) &&
920 !(bar_en
& PEC_NEST_STK_BAR_EN_MMIO1
)) {
921 memory_region_del_subregion(sysmem
, &stack
->mmbar1
);
923 if (memory_region_is_mapped(&phb
->phbbar
) &&
924 !(bar_en
& PEC_NEST_STK_BAR_EN_PHB
)) {
925 memory_region_del_subregion(sysmem
, &phb
->phbbar
);
927 if (memory_region_is_mapped(&phb
->intbar
) &&
928 !(bar_en
& PEC_NEST_STK_BAR_EN_INT
)) {
929 memory_region_del_subregion(sysmem
, &phb
->intbar
);
933 pnv_phb4_update_regions(stack
);
936 if (!memory_region_is_mapped(&stack
->mmbar0
) &&
937 (bar_en
& PEC_NEST_STK_BAR_EN_MMIO0
)) {
938 bar
= stack
->nest_regs
[PEC_NEST_STK_MMIO_BAR0
] >> 8;
939 mask
= stack
->nest_regs
[PEC_NEST_STK_MMIO_BAR0_MASK
];
940 size
= ((~mask
) >> 8) + 1;
941 snprintf(name
, sizeof(name
), "pec-%d.%d-stack-%d-mmio0",
942 pec
->chip_id
, pec
->index
, stack
->stack_no
);
943 memory_region_init(&stack
->mmbar0
, OBJECT(stack
), name
, size
);
944 memory_region_add_subregion(sysmem
, bar
, &stack
->mmbar0
);
945 stack
->mmio0_base
= bar
;
946 stack
->mmio0_size
= size
;
948 if (!memory_region_is_mapped(&stack
->mmbar1
) &&
949 (bar_en
& PEC_NEST_STK_BAR_EN_MMIO1
)) {
950 bar
= stack
->nest_regs
[PEC_NEST_STK_MMIO_BAR1
] >> 8;
951 mask
= stack
->nest_regs
[PEC_NEST_STK_MMIO_BAR1_MASK
];
952 size
= ((~mask
) >> 8) + 1;
953 snprintf(name
, sizeof(name
), "pec-%d.%d-stack-%d-mmio1",
954 pec
->chip_id
, pec
->index
, stack
->stack_no
);
955 memory_region_init(&stack
->mmbar1
, OBJECT(stack
), name
, size
);
956 memory_region_add_subregion(sysmem
, bar
, &stack
->mmbar1
);
957 stack
->mmio1_base
= bar
;
958 stack
->mmio1_size
= size
;
960 if (!memory_region_is_mapped(&phb
->phbbar
) &&
961 (bar_en
& PEC_NEST_STK_BAR_EN_PHB
)) {
962 bar
= stack
->nest_regs
[PEC_NEST_STK_PHB_REGS_BAR
] >> 8;
963 size
= PNV_PHB4_NUM_REGS
<< 3;
964 snprintf(name
, sizeof(name
), "pec-%d.%d-phb-%d",
965 pec
->chip_id
, pec
->index
, stack
->stack_no
);
966 memory_region_init(&phb
->phbbar
, OBJECT(phb
), name
, size
);
967 memory_region_add_subregion(sysmem
, bar
, &phb
->phbbar
);
969 if (!memory_region_is_mapped(&phb
->intbar
) &&
970 (bar_en
& PEC_NEST_STK_BAR_EN_INT
)) {
971 bar
= stack
->nest_regs
[PEC_NEST_STK_INT_BAR
] >> 8;
972 size
= PNV_PHB4_MAX_INTs
<< 16;
973 snprintf(name
, sizeof(name
), "pec-%d.%d-phb-%d-int",
974 stack
->pec
->chip_id
, stack
->pec
->index
, stack
->stack_no
);
975 memory_region_init(&phb
->intbar
, OBJECT(phb
), name
, size
);
976 memory_region_add_subregion(sysmem
, bar
, &phb
->intbar
);
980 pnv_phb4_update_regions(stack
);
983 static void pnv_pec_stk_nest_xscom_write(void *opaque
, hwaddr addr
,
984 uint64_t val
, unsigned size
)
986 PnvPhb4PecStack
*stack
= PNV_PHB4_PEC_STACK(opaque
);
987 PnvPhb4PecState
*pec
= stack
->pec
;
988 uint32_t reg
= addr
>> 3;
991 case PEC_NEST_STK_PCI_NEST_FIR
:
992 stack
->nest_regs
[PEC_NEST_STK_PCI_NEST_FIR
] = val
;
994 case PEC_NEST_STK_PCI_NEST_FIR_CLR
:
995 stack
->nest_regs
[PEC_NEST_STK_PCI_NEST_FIR
] &= val
;
997 case PEC_NEST_STK_PCI_NEST_FIR_SET
:
998 stack
->nest_regs
[PEC_NEST_STK_PCI_NEST_FIR
] |= val
;
1000 case PEC_NEST_STK_PCI_NEST_FIR_MSK
:
1001 stack
->nest_regs
[PEC_NEST_STK_PCI_NEST_FIR_MSK
] = val
;
1003 case PEC_NEST_STK_PCI_NEST_FIR_MSKC
:
1004 stack
->nest_regs
[PEC_NEST_STK_PCI_NEST_FIR_MSK
] &= val
;
1006 case PEC_NEST_STK_PCI_NEST_FIR_MSKS
:
1007 stack
->nest_regs
[PEC_NEST_STK_PCI_NEST_FIR_MSK
] |= val
;
1009 case PEC_NEST_STK_PCI_NEST_FIR_ACT0
:
1010 case PEC_NEST_STK_PCI_NEST_FIR_ACT1
:
1011 stack
->nest_regs
[reg
] = val
;
1013 case PEC_NEST_STK_PCI_NEST_FIR_WOF
:
1014 stack
->nest_regs
[reg
] = 0;
1016 case PEC_NEST_STK_ERR_REPORT_0
:
1017 case PEC_NEST_STK_ERR_REPORT_1
:
1018 case PEC_NEST_STK_PBCQ_GNRL_STATUS
:
1021 case PEC_NEST_STK_PBCQ_MODE
:
1022 stack
->nest_regs
[reg
] = val
& 0xff00000000000000ull
;
1024 case PEC_NEST_STK_MMIO_BAR0
:
1025 case PEC_NEST_STK_MMIO_BAR0_MASK
:
1026 case PEC_NEST_STK_MMIO_BAR1
:
1027 case PEC_NEST_STK_MMIO_BAR1_MASK
:
1028 if (stack
->nest_regs
[PEC_NEST_STK_BAR_EN
] &
1029 (PEC_NEST_STK_BAR_EN_MMIO0
|
1030 PEC_NEST_STK_BAR_EN_MMIO1
)) {
1031 phb_pec_error(pec
, "Changing enabled BAR unsupported\n");
1033 stack
->nest_regs
[reg
] = val
& 0xffffffffff000000ull
;
1035 case PEC_NEST_STK_PHB_REGS_BAR
:
1036 if (stack
->nest_regs
[PEC_NEST_STK_BAR_EN
] & PEC_NEST_STK_BAR_EN_PHB
) {
1037 phb_pec_error(pec
, "Changing enabled BAR unsupported\n");
1039 stack
->nest_regs
[reg
] = val
& 0xffffffffffc00000ull
;
1041 case PEC_NEST_STK_INT_BAR
:
1042 if (stack
->nest_regs
[PEC_NEST_STK_BAR_EN
] & PEC_NEST_STK_BAR_EN_INT
) {
1043 phb_pec_error(pec
, "Changing enabled BAR unsupported\n");
1045 stack
->nest_regs
[reg
] = val
& 0xfffffff000000000ull
;
1047 case PEC_NEST_STK_BAR_EN
:
1048 stack
->nest_regs
[reg
] = val
& 0xf000000000000000ull
;
1049 pnv_pec_stk_update_map(stack
);
1051 case PEC_NEST_STK_DATA_FRZ_TYPE
:
1052 case PEC_NEST_STK_PBCQ_TUN_BAR
:
1053 /* Not used for now */
1054 stack
->nest_regs
[reg
] = val
;
1057 qemu_log_mask(LOG_UNIMP
, "phb4_pec: nest_xscom_write 0x%"HWADDR_PRIx
1058 "=%"PRIx64
"\n", addr
, val
);
1062 static const MemoryRegionOps pnv_pec_stk_nest_xscom_ops
= {
1063 .read
= pnv_pec_stk_nest_xscom_read
,
1064 .write
= pnv_pec_stk_nest_xscom_write
,
1065 .valid
.min_access_size
= 8,
1066 .valid
.max_access_size
= 8,
1067 .impl
.min_access_size
= 8,
1068 .impl
.max_access_size
= 8,
1069 .endianness
= DEVICE_BIG_ENDIAN
,
1072 static uint64_t pnv_pec_stk_pci_xscom_read(void *opaque
, hwaddr addr
,
1075 PnvPHB4
*phb
= PNV_PHB4(opaque
);
1076 uint32_t reg
= addr
>> 3;
1078 /* TODO: add list of allowed registers and error out if not */
1079 return phb
->pci_regs
[reg
];
1082 static void pnv_pec_stk_pci_xscom_write(void *opaque
, hwaddr addr
,
1083 uint64_t val
, unsigned size
)
1085 PnvPHB4
*phb
= PNV_PHB4(opaque
);
1086 uint32_t reg
= addr
>> 3;
1089 case PEC_PCI_STK_PCI_FIR
:
1090 phb
->pci_regs
[reg
] = val
;
1092 case PEC_PCI_STK_PCI_FIR_CLR
:
1093 phb
->pci_regs
[PEC_PCI_STK_PCI_FIR
] &= val
;
1095 case PEC_PCI_STK_PCI_FIR_SET
:
1096 phb
->pci_regs
[PEC_PCI_STK_PCI_FIR
] |= val
;
1098 case PEC_PCI_STK_PCI_FIR_MSK
:
1099 phb
->pci_regs
[reg
] = val
;
1101 case PEC_PCI_STK_PCI_FIR_MSKC
:
1102 phb
->pci_regs
[PEC_PCI_STK_PCI_FIR_MSK
] &= val
;
1104 case PEC_PCI_STK_PCI_FIR_MSKS
:
1105 phb
->pci_regs
[PEC_PCI_STK_PCI_FIR_MSK
] |= val
;
1107 case PEC_PCI_STK_PCI_FIR_ACT0
:
1108 case PEC_PCI_STK_PCI_FIR_ACT1
:
1109 phb
->pci_regs
[reg
] = val
;
1111 case PEC_PCI_STK_PCI_FIR_WOF
:
1112 phb
->pci_regs
[reg
] = 0;
1114 case PEC_PCI_STK_ETU_RESET
:
1115 phb
->pci_regs
[reg
] = val
& 0x8000000000000000ull
;
1116 /* TODO: Implement reset */
1118 case PEC_PCI_STK_PBAIB_ERR_REPORT
:
1120 case PEC_PCI_STK_PBAIB_TX_CMD_CRED
:
1121 case PEC_PCI_STK_PBAIB_TX_DAT_CRED
:
1122 phb
->pci_regs
[reg
] = val
;
1125 qemu_log_mask(LOG_UNIMP
, "phb4_pec_stk: pci_xscom_write 0x%"HWADDR_PRIx
1126 "=%"PRIx64
"\n", addr
, val
);
1130 static const MemoryRegionOps pnv_pec_stk_pci_xscom_ops
= {
1131 .read
= pnv_pec_stk_pci_xscom_read
,
1132 .write
= pnv_pec_stk_pci_xscom_write
,
1133 .valid
.min_access_size
= 8,
1134 .valid
.max_access_size
= 8,
1135 .impl
.min_access_size
= 8,
1136 .impl
.max_access_size
= 8,
1137 .endianness
= DEVICE_BIG_ENDIAN
,
1140 static int pnv_phb4_map_irq(PCIDevice
*pci_dev
, int irq_num
)
1142 /* Check that out properly ... */
1146 static void pnv_phb4_set_irq(void *opaque
, int irq_num
, int level
)
1148 PnvPHB4
*phb
= PNV_PHB4(opaque
);
1153 phb_error(phb
, "IRQ %x is not an LSI", irq_num
);
1155 lsi_base
= GETFIELD(PHB_LSI_SRC_ID
, phb
->regs
[PHB_LSI_SOURCE_ID
>> 3]);
1157 qemu_set_irq(phb
->qirqs
[lsi_base
+ irq_num
], level
);
1160 static bool pnv_phb4_resolve_pe(PnvPhb4DMASpace
*ds
)
1167 /* Already resolved ? */
1168 if (ds
->pe_num
!= PHB_INVALID_PE
) {
1172 /* We need to lookup the RTT */
1173 rtt
= ds
->phb
->regs
[PHB_RTT_BAR
>> 3];
1174 if (!(rtt
& PHB_RTT_BAR_ENABLE
)) {
1175 phb_error(ds
->phb
, "DMA with RTT BAR disabled !");
1176 /* Set error bits ? fence ? ... */
1181 bus_num
= pci_bus_num(ds
->bus
);
1182 addr
= rtt
& PHB_RTT_BASE_ADDRESS_MASK
;
1183 addr
+= 2 * PCI_BUILD_BDF(bus_num
, ds
->devfn
);
1184 if (dma_memory_read(&address_space_memory
, addr
, &rte
,
1185 sizeof(rte
), MEMTXATTRS_UNSPECIFIED
)) {
1186 phb_error(ds
->phb
, "Failed to read RTT entry at 0x%"PRIx64
, addr
);
1187 /* Set error bits ? fence ? ... */
1190 rte
= be16_to_cpu(rte
);
1192 /* Fail upon reading of invalid PE# */
1193 num_PEs
= ds
->phb
->big_phb
? PNV_PHB4_MAX_PEs
: (PNV_PHB4_MAX_PEs
>> 1);
1194 if (rte
>= num_PEs
) {
1195 phb_error(ds
->phb
, "RTE for RID 0x%x invalid (%04x", ds
->devfn
, rte
);
1202 static void pnv_phb4_translate_tve(PnvPhb4DMASpace
*ds
, hwaddr addr
,
1203 bool is_write
, uint64_t tve
,
1206 uint64_t tta
= GETFIELD(IODA3_TVT_TABLE_ADDR
, tve
);
1207 int32_t lev
= GETFIELD(IODA3_TVT_NUM_LEVELS
, tve
);
1208 uint32_t tts
= GETFIELD(IODA3_TVT_TCE_TABLE_SIZE
, tve
);
1209 uint32_t tps
= GETFIELD(IODA3_TVT_IO_PSIZE
, tve
);
1211 /* Invalid levels */
1213 phb_error(ds
->phb
, "Invalid #levels in TVE %d", lev
);
1219 phb_error(ds
->phb
, "Access to invalid TVE");
1223 /* IO Page Size of 0 means untranslated, else use TCEs */
1225 /* TODO: Handle boundaries */
1227 /* Use 4k pages like q35 ... for now */
1228 tlb
->iova
= addr
& 0xfffffffffffff000ull
;
1229 tlb
->translated_addr
= addr
& 0x0003fffffffff000ull
;
1230 tlb
->addr_mask
= 0xfffull
;
1231 tlb
->perm
= IOMMU_RW
;
1233 uint32_t tce_shift
, tbl_shift
, sh
;
1234 uint64_t base
, taddr
, tce
, tce_mask
;
1236 /* Address bits per bottom level TCE entry */
1237 tce_shift
= tps
+ 11;
1239 /* Address bits per table level */
1240 tbl_shift
= tts
+ 8;
1242 /* Top level table base address */
1245 /* Total shift to first level */
1246 sh
= tbl_shift
* lev
+ tce_shift
;
1248 /* TODO: Limit to support IO page sizes */
1250 /* TODO: Multi-level untested */
1251 while ((lev
--) >= 0) {
1252 /* Grab the TCE address */
1253 taddr
= base
| (((addr
>> sh
) & ((1ul << tbl_shift
) - 1)) << 3);
1254 if (dma_memory_read(&address_space_memory
, taddr
, &tce
,
1255 sizeof(tce
), MEMTXATTRS_UNSPECIFIED
)) {
1256 phb_error(ds
->phb
, "Failed to read TCE at 0x%"PRIx64
, taddr
);
1259 tce
= be64_to_cpu(tce
);
1261 /* Check permission for indirect TCE */
1262 if ((lev
>= 0) && !(tce
& 3)) {
1263 phb_error(ds
->phb
, "Invalid indirect TCE at 0x%"PRIx64
, taddr
);
1264 phb_error(ds
->phb
, " xlate %"PRIx64
":%c TVE=%"PRIx64
, addr
,
1265 is_write
? 'W' : 'R', tve
);
1266 phb_error(ds
->phb
, " tta=%"PRIx64
" lev=%d tts=%d tps=%d",
1267 tta
, lev
, tts
, tps
);
1271 base
= tce
& ~0xfffull
;
1274 /* We exit the loop with TCE being the final TCE */
1275 tce_mask
= ~((1ull << tce_shift
) - 1);
1276 tlb
->iova
= addr
& tce_mask
;
1277 tlb
->translated_addr
= tce
& tce_mask
;
1278 tlb
->addr_mask
= ~tce_mask
;
1279 tlb
->perm
= tce
& 3;
1280 if ((is_write
& !(tce
& 2)) || ((!is_write
) && !(tce
& 1))) {
1281 phb_error(ds
->phb
, "TCE access fault at 0x%"PRIx64
, taddr
);
1282 phb_error(ds
->phb
, " xlate %"PRIx64
":%c TVE=%"PRIx64
, addr
,
1283 is_write
? 'W' : 'R', tve
);
1284 phb_error(ds
->phb
, " tta=%"PRIx64
" lev=%d tts=%d tps=%d",
1285 tta
, lev
, tts
, tps
);
1290 static IOMMUTLBEntry
pnv_phb4_translate_iommu(IOMMUMemoryRegion
*iommu
,
1292 IOMMUAccessFlags flag
,
1295 PnvPhb4DMASpace
*ds
= container_of(iommu
, PnvPhb4DMASpace
, dma_mr
);
1298 IOMMUTLBEntry ret
= {
1299 .target_as
= &address_space_memory
,
1301 .translated_addr
= 0,
1302 .addr_mask
= ~(hwaddr
)0,
1307 if (!pnv_phb4_resolve_pe(ds
)) {
1308 phb_error(ds
->phb
, "Failed to resolve PE# for bus @%p (%d) devfn 0x%x",
1309 ds
->bus
, pci_bus_num(ds
->bus
), ds
->devfn
);
1313 /* Check top bits */
1314 switch (addr
>> 60) {
1316 /* DMA or 32-bit MSI ? */
1317 cfg
= ds
->phb
->regs
[PHB_PHB4_CONFIG
>> 3];
1318 if ((cfg
& PHB_PHB4C_32BIT_MSI_EN
) &&
1319 ((addr
& 0xffffffffffff0000ull
) == 0xffff0000ull
)) {
1320 phb_error(ds
->phb
, "xlate on 32-bit MSI region");
1323 /* Choose TVE XXX Use PHB4 Control Register */
1324 tve_sel
= (addr
>> 59) & 1;
1325 tve
= ds
->phb
->ioda_TVT
[ds
->pe_num
* 2 + tve_sel
];
1326 pnv_phb4_translate_tve(ds
, addr
, flag
& IOMMU_WO
, tve
, &ret
);
1329 phb_error(ds
->phb
, "xlate on 64-bit MSI region");
1332 phb_error(ds
->phb
, "xlate on unsupported address 0x%"PRIx64
, addr
);
1337 #define TYPE_PNV_PHB4_IOMMU_MEMORY_REGION "pnv-phb4-iommu-memory-region"
1338 DECLARE_INSTANCE_CHECKER(IOMMUMemoryRegion
, PNV_PHB4_IOMMU_MEMORY_REGION
,
1339 TYPE_PNV_PHB4_IOMMU_MEMORY_REGION
)
1341 static void pnv_phb4_iommu_memory_region_class_init(ObjectClass
*klass
,
1344 IOMMUMemoryRegionClass
*imrc
= IOMMU_MEMORY_REGION_CLASS(klass
);
1346 imrc
->translate
= pnv_phb4_translate_iommu
;
1349 static const TypeInfo pnv_phb4_iommu_memory_region_info
= {
1350 .parent
= TYPE_IOMMU_MEMORY_REGION
,
1351 .name
= TYPE_PNV_PHB4_IOMMU_MEMORY_REGION
,
1352 .class_init
= pnv_phb4_iommu_memory_region_class_init
,
1356 * Return the index/phb-id of a PHB4 that belongs to a
1357 * pec->stacks[stack_index] stack.
1359 int pnv_phb4_pec_get_phb_id(PnvPhb4PecState
*pec
, int stack_index
)
1361 PnvPhb4PecClass
*pecc
= PNV_PHB4_PEC_GET_CLASS(pec
);
1362 int index
= pec
->index
;
1366 offset
+= pecc
->num_stacks
[index
];
1369 return offset
+ stack_index
;
1373 * MSI/MSIX memory region implementation.
1374 * The handler handles both MSI and MSIX.
1376 static void pnv_phb4_msi_write(void *opaque
, hwaddr addr
,
1377 uint64_t data
, unsigned size
)
1379 PnvPhb4DMASpace
*ds
= opaque
;
1380 PnvPHB4
*phb
= ds
->phb
;
1382 uint32_t src
= ((addr
>> 4) & 0xffff) | (data
& 0x1f);
1385 if (!pnv_phb4_resolve_pe(ds
)) {
1386 phb_error(phb
, "Failed to resolve PE# for bus @%p (%d) devfn 0x%x",
1387 ds
->bus
, pci_bus_num(ds
->bus
), ds
->devfn
);
1391 /* TODO: Check it doesn't collide with LSIs */
1392 if (src
>= phb
->xsrc
.nr_irqs
) {
1393 phb_error(phb
, "MSI %d out of bounds", src
);
1397 /* TODO: check PE/MSI assignement */
1399 qemu_irq_pulse(phb
->qirqs
[src
]);
1402 /* There is no .read as the read result is undefined by PCI spec */
1403 static uint64_t pnv_phb4_msi_read(void *opaque
, hwaddr addr
, unsigned size
)
1405 PnvPhb4DMASpace
*ds
= opaque
;
1407 phb_error(ds
->phb
, "Invalid MSI read @ 0x%" HWADDR_PRIx
, addr
);
1411 static const MemoryRegionOps pnv_phb4_msi_ops
= {
1412 .read
= pnv_phb4_msi_read
,
1413 .write
= pnv_phb4_msi_write
,
1414 .endianness
= DEVICE_LITTLE_ENDIAN
1417 static PnvPhb4DMASpace
*pnv_phb4_dma_find(PnvPHB4
*phb
, PCIBus
*bus
, int devfn
)
1419 PnvPhb4DMASpace
*ds
;
1421 QLIST_FOREACH(ds
, &phb
->dma_spaces
, list
) {
1422 if (ds
->bus
== bus
&& ds
->devfn
== devfn
) {
1429 static AddressSpace
*pnv_phb4_dma_iommu(PCIBus
*bus
, void *opaque
, int devfn
)
1431 PnvPHB4
*phb
= opaque
;
1432 PnvPhb4DMASpace
*ds
;
1435 ds
= pnv_phb4_dma_find(phb
, bus
, devfn
);
1438 ds
= g_malloc0(sizeof(PnvPhb4DMASpace
));
1441 ds
->pe_num
= PHB_INVALID_PE
;
1443 snprintf(name
, sizeof(name
), "phb4-%d.%d-iommu", phb
->chip_id
,
1445 memory_region_init_iommu(&ds
->dma_mr
, sizeof(ds
->dma_mr
),
1446 TYPE_PNV_PHB4_IOMMU_MEMORY_REGION
,
1447 OBJECT(phb
), name
, UINT64_MAX
);
1448 address_space_init(&ds
->dma_as
, MEMORY_REGION(&ds
->dma_mr
),
1450 memory_region_init_io(&ds
->msi32_mr
, OBJECT(phb
), &pnv_phb4_msi_ops
,
1451 ds
, "msi32", 0x10000);
1452 memory_region_init_io(&ds
->msi64_mr
, OBJECT(phb
), &pnv_phb4_msi_ops
,
1453 ds
, "msi64", 0x100000);
1454 pnv_phb4_update_msi_regions(ds
);
1456 QLIST_INSERT_HEAD(&phb
->dma_spaces
, ds
, list
);
1461 static void pnv_phb4_xscom_realize(PnvPHB4
*phb
)
1463 PnvPhb4PecStack
*stack
= phb
->stack
;
1464 PnvPhb4PecState
*pec
= stack
->pec
;
1465 PnvPhb4PecClass
*pecc
= PNV_PHB4_PEC_GET_CLASS(pec
);
1466 uint32_t pec_nest_base
;
1467 uint32_t pec_pci_base
;
1472 /* Initialize the XSCOM regions for the stack registers */
1473 snprintf(name
, sizeof(name
), "xscom-pec-%d.%d-nest-stack-%d",
1474 pec
->chip_id
, pec
->index
, stack
->stack_no
);
1475 pnv_xscom_region_init(&stack
->nest_regs_mr
, OBJECT(stack
),
1476 &pnv_pec_stk_nest_xscom_ops
, stack
, name
,
1477 PHB4_PEC_NEST_STK_REGS_COUNT
);
1479 snprintf(name
, sizeof(name
), "xscom-pec-%d.%d-pci-phb-%d",
1480 pec
->chip_id
, pec
->index
, stack
->stack_no
);
1481 pnv_xscom_region_init(&phb
->pci_regs_mr
, OBJECT(phb
),
1482 &pnv_pec_stk_pci_xscom_ops
, phb
, name
,
1483 PHB4_PEC_PCI_STK_REGS_COUNT
);
1485 /* PHB pass-through */
1486 snprintf(name
, sizeof(name
), "xscom-pec-%d.%d-pci-stack-%d-phb",
1487 pec
->chip_id
, pec
->index
, stack
->stack_no
);
1488 pnv_xscom_region_init(&stack
->phb_regs_mr
, OBJECT(phb
),
1489 &pnv_phb4_xscom_ops
, phb
, name
, 0x40);
1491 pec_nest_base
= pecc
->xscom_nest_base(pec
);
1492 pec_pci_base
= pecc
->xscom_pci_base(pec
);
1494 /* Populate the XSCOM address space. */
1495 pnv_xscom_add_subregion(pec
->chip
,
1496 pec_nest_base
+ 0x40 * (stack
->stack_no
+ 1),
1497 &stack
->nest_regs_mr
);
1498 pnv_xscom_add_subregion(pec
->chip
,
1499 pec_pci_base
+ 0x40 * (stack
->stack_no
+ 1),
1501 pnv_xscom_add_subregion(pec
->chip
,
1502 pec_pci_base
+ PNV9_XSCOM_PEC_PCI_STK0
+
1503 0x40 * stack
->stack_no
,
1504 &stack
->phb_regs_mr
);
1507 static void pnv_phb4_instance_init(Object
*obj
)
1509 PnvPHB4
*phb
= PNV_PHB4(obj
);
1511 QLIST_INIT(&phb
->dma_spaces
);
1513 /* XIVE interrupt source object */
1514 object_initialize_child(obj
, "source", &phb
->xsrc
, TYPE_XIVE_SOURCE
);
1517 static PnvPhb4PecStack
*pnv_phb4_get_stack(PnvChip
*chip
, PnvPHB4
*phb
,
1520 Pnv9Chip
*chip9
= PNV9_CHIP(chip
);
1521 int chip_id
= phb
->chip_id
;
1522 int index
= phb
->phb_id
;
1525 for (i
= 0; i
< chip
->num_pecs
; i
++) {
1527 * For each PEC, check the amount of stacks it supports
1528 * and see if the given phb4 index matches a stack.
1530 PnvPhb4PecState
*pec
= &chip9
->pecs
[i
];
1532 for (j
= 0; j
< pec
->num_stacks
; j
++) {
1533 if (index
== pnv_phb4_pec_get_phb_id(pec
, j
)) {
1534 return &pec
->stacks
[j
];
1540 "pnv-phb4 chip-id %d index %d didn't match any existing PEC",
1546 static void pnv_phb4_realize(DeviceState
*dev
, Error
**errp
)
1548 PnvPHB4
*phb
= PNV_PHB4(dev
);
1549 PCIHostState
*pci
= PCI_HOST_BRIDGE(dev
);
1550 XiveSource
*xsrc
= &phb
->xsrc
;
1551 Error
*local_err
= NULL
;
1555 /* User created PHB */
1557 PnvMachineState
*pnv
= PNV_MACHINE(qdev_get_machine());
1558 PnvChip
*chip
= pnv_get_chip(pnv
, phb
->chip_id
);
1559 PnvPhb4PecClass
*pecc
;
1563 error_setg(errp
, "invalid chip id: %d", phb
->chip_id
);
1567 phb
->stack
= pnv_phb4_get_stack(chip
, phb
, &local_err
);
1569 error_propagate(errp
, local_err
);
1573 /* All other phb properties but 'version' are already set */
1574 pecc
= PNV_PHB4_PEC_GET_CLASS(phb
->stack
->pec
);
1575 object_property_set_int(OBJECT(phb
), "version", pecc
->version
,
1579 * Assign stack->phb since pnv_phb4_update_regions() uses it
1580 * to access the phb.
1582 phb
->stack
->phb
= phb
;
1585 * Reparent user created devices to the chip to build
1586 * correctly the device tree.
1588 pnv_chip_parent_fixup(chip
, OBJECT(phb
), phb
->phb_id
);
1590 s
= qdev_get_parent_bus(DEVICE(chip
));
1591 if (!qdev_set_parent_bus(DEVICE(phb
), s
, &local_err
)) {
1592 error_propagate(errp
, local_err
);
1597 /* Set the "big_phb" flag */
1598 phb
->big_phb
= phb
->phb_id
== 0 || phb
->phb_id
== 3;
1600 /* Controller Registers */
1601 snprintf(name
, sizeof(name
), "phb4-%d.%d-regs", phb
->chip_id
,
1603 memory_region_init_io(&phb
->mr_regs
, OBJECT(phb
), &pnv_phb4_reg_ops
, phb
,
1607 * PHB4 doesn't support IO space. However, qemu gets very upset if
1608 * we don't have an IO region to anchor IO BARs onto so we just
1609 * initialize one which we never hook up to anything
1612 snprintf(name
, sizeof(name
), "phb4-%d.%d-pci-io", phb
->chip_id
,
1614 memory_region_init(&phb
->pci_io
, OBJECT(phb
), name
, 0x10000);
1616 snprintf(name
, sizeof(name
), "phb4-%d.%d-pci-mmio", phb
->chip_id
,
1618 memory_region_init(&phb
->pci_mmio
, OBJECT(phb
), name
,
1619 PCI_MMIO_TOTAL_SIZE
);
1621 pci
->bus
= pci_register_root_bus(dev
, dev
->id
,
1622 pnv_phb4_set_irq
, pnv_phb4_map_irq
, phb
,
1623 &phb
->pci_mmio
, &phb
->pci_io
,
1624 0, 4, TYPE_PNV_PHB4_ROOT_BUS
);
1625 pci_setup_iommu(pci
->bus
, pnv_phb4_dma_iommu
, phb
);
1626 pci
->bus
->flags
|= PCI_BUS_EXTENDED_CONFIG_SPACE
;
1628 /* Add a single Root port if running with defaults */
1629 if (defaults_enabled()) {
1630 pnv_phb_attach_root_port(PCI_HOST_BRIDGE(phb
),
1631 TYPE_PNV_PHB4_ROOT_PORT
);
1634 /* Setup XIVE Source */
1636 nr_irqs
= PNV_PHB4_MAX_INTs
;
1638 nr_irqs
= PNV_PHB4_MAX_INTs
>> 1;
1640 object_property_set_int(OBJECT(xsrc
), "nr-irqs", nr_irqs
, &error_fatal
);
1641 object_property_set_link(OBJECT(xsrc
), "xive", OBJECT(phb
), &error_fatal
);
1642 if (!qdev_realize(DEVICE(xsrc
), NULL
, errp
)) {
1646 pnv_phb4_update_xsrc(phb
);
1648 phb
->qirqs
= qemu_allocate_irqs(xive_source_set_irq
, xsrc
, xsrc
->nr_irqs
);
1650 pnv_phb4_xscom_realize(phb
);
1653 static const char *pnv_phb4_root_bus_path(PCIHostState
*host_bridge
,
1656 PnvPHB4
*phb
= PNV_PHB4(host_bridge
);
1658 snprintf(phb
->bus_path
, sizeof(phb
->bus_path
), "00%02x:%02x",
1659 phb
->chip_id
, phb
->phb_id
);
1660 return phb
->bus_path
;
1663 static void pnv_phb4_xive_notify(XiveNotifier
*xf
, uint32_t srcno
)
1665 PnvPHB4
*phb
= PNV_PHB4(xf
);
1666 uint64_t notif_port
= phb
->regs
[PHB_INT_NOTIFY_ADDR
>> 3];
1667 uint32_t offset
= phb
->regs
[PHB_INT_NOTIFY_INDEX
>> 3];
1668 uint64_t data
= XIVE_TRIGGER_PQ
| offset
| srcno
;
1671 trace_pnv_phb4_xive_notify(notif_port
, data
);
1673 address_space_stq_be(&address_space_memory
, notif_port
, data
,
1674 MEMTXATTRS_UNSPECIFIED
, &result
);
1675 if (result
!= MEMTX_OK
) {
1676 phb_error(phb
, "trigger failed @%"HWADDR_PRIx
"\n", notif_port
);
1681 static Property pnv_phb4_properties
[] = {
1682 DEFINE_PROP_UINT32("index", PnvPHB4
, phb_id
, 0),
1683 DEFINE_PROP_UINT32("chip-id", PnvPHB4
, chip_id
, 0),
1684 DEFINE_PROP_UINT64("version", PnvPHB4
, version
, 0),
1685 DEFINE_PROP_LINK("stack", PnvPHB4
, stack
, TYPE_PNV_PHB4_PEC_STACK
,
1687 DEFINE_PROP_END_OF_LIST(),
1690 static void pnv_phb4_class_init(ObjectClass
*klass
, void *data
)
1692 PCIHostBridgeClass
*hc
= PCI_HOST_BRIDGE_CLASS(klass
);
1693 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1694 XiveNotifierClass
*xfc
= XIVE_NOTIFIER_CLASS(klass
);
1696 hc
->root_bus_path
= pnv_phb4_root_bus_path
;
1697 dc
->realize
= pnv_phb4_realize
;
1698 device_class_set_props(dc
, pnv_phb4_properties
);
1699 set_bit(DEVICE_CATEGORY_BRIDGE
, dc
->categories
);
1700 dc
->user_creatable
= true;
1702 xfc
->notify
= pnv_phb4_xive_notify
;
1705 static const TypeInfo pnv_phb4_type_info
= {
1706 .name
= TYPE_PNV_PHB4
,
1707 .parent
= TYPE_PCIE_HOST_BRIDGE
,
1708 .instance_init
= pnv_phb4_instance_init
,
1709 .instance_size
= sizeof(PnvPHB4
),
1710 .class_init
= pnv_phb4_class_init
,
1711 .interfaces
= (InterfaceInfo
[]) {
1712 { TYPE_XIVE_NOTIFIER
},
1717 static void pnv_phb4_root_bus_class_init(ObjectClass
*klass
, void *data
)
1719 BusClass
*k
= BUS_CLASS(klass
);
1722 * PHB4 has only a single root complex. Enforce the limit on the
1728 static const TypeInfo pnv_phb4_root_bus_info
= {
1729 .name
= TYPE_PNV_PHB4_ROOT_BUS
,
1730 .parent
= TYPE_PCIE_BUS
,
1731 .class_init
= pnv_phb4_root_bus_class_init
,
1732 .interfaces
= (InterfaceInfo
[]) {
1733 { INTERFACE_PCIE_DEVICE
},
1738 static void pnv_phb4_root_port_reset(DeviceState
*dev
)
1740 PCIERootPortClass
*rpc
= PCIE_ROOT_PORT_GET_CLASS(dev
);
1741 PCIDevice
*d
= PCI_DEVICE(dev
);
1742 uint8_t *conf
= d
->config
;
1744 rpc
->parent_reset(dev
);
1746 pci_byte_test_and_set_mask(conf
+ PCI_IO_BASE
,
1747 PCI_IO_RANGE_MASK
& 0xff);
1748 pci_byte_test_and_clear_mask(conf
+ PCI_IO_LIMIT
,
1749 PCI_IO_RANGE_MASK
& 0xff);
1750 pci_set_word(conf
+ PCI_MEMORY_BASE
, 0);
1751 pci_set_word(conf
+ PCI_MEMORY_LIMIT
, 0xfff0);
1752 pci_set_word(conf
+ PCI_PREF_MEMORY_BASE
, 0x1);
1753 pci_set_word(conf
+ PCI_PREF_MEMORY_LIMIT
, 0xfff1);
1754 pci_set_long(conf
+ PCI_PREF_BASE_UPPER32
, 0x1); /* Hack */
1755 pci_set_long(conf
+ PCI_PREF_LIMIT_UPPER32
, 0xffffffff);
1758 static void pnv_phb4_root_port_realize(DeviceState
*dev
, Error
**errp
)
1760 PCIERootPortClass
*rpc
= PCIE_ROOT_PORT_GET_CLASS(dev
);
1761 PCIDevice
*pci
= PCI_DEVICE(dev
);
1762 PCIBus
*bus
= pci_get_bus(pci
);
1763 PnvPHB4
*phb
= NULL
;
1764 Error
*local_err
= NULL
;
1766 phb
= (PnvPHB4
*) object_dynamic_cast(OBJECT(bus
->qbus
.parent
),
1770 error_setg(errp
, "%s must be connected to pnv-phb4 buses", dev
->id
);
1774 /* Set unique chassis/slot values for the root port */
1775 qdev_prop_set_uint8(&pci
->qdev
, "chassis", phb
->chip_id
);
1776 qdev_prop_set_uint16(&pci
->qdev
, "slot", phb
->phb_id
);
1778 rpc
->parent_realize(dev
, &local_err
);
1780 error_propagate(errp
, local_err
);
1785 static void pnv_phb4_root_port_class_init(ObjectClass
*klass
, void *data
)
1787 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1788 PCIDeviceClass
*k
= PCI_DEVICE_CLASS(klass
);
1789 PCIERootPortClass
*rpc
= PCIE_ROOT_PORT_CLASS(klass
);
1791 dc
->desc
= "IBM PHB4 PCIE Root Port";
1792 dc
->user_creatable
= true;
1794 device_class_set_parent_realize(dc
, pnv_phb4_root_port_realize
,
1795 &rpc
->parent_realize
);
1796 device_class_set_parent_reset(dc
, pnv_phb4_root_port_reset
,
1797 &rpc
->parent_reset
);
1799 k
->vendor_id
= PCI_VENDOR_ID_IBM
;
1800 k
->device_id
= PNV_PHB4_DEVICE_ID
;
1803 rpc
->exp_offset
= 0x48;
1804 rpc
->aer_offset
= 0x100;
1806 dc
->reset
= &pnv_phb4_root_port_reset
;
1809 static const TypeInfo pnv_phb4_root_port_info
= {
1810 .name
= TYPE_PNV_PHB4_ROOT_PORT
,
1811 .parent
= TYPE_PCIE_ROOT_PORT
,
1812 .instance_size
= sizeof(PnvPHB4RootPort
),
1813 .class_init
= pnv_phb4_root_port_class_init
,
1816 static void pnv_phb4_register_types(void)
1818 type_register_static(&pnv_phb4_root_bus_info
);
1819 type_register_static(&pnv_phb4_root_port_info
);
1820 type_register_static(&pnv_phb4_type_info
);
1821 type_register_static(&pnv_phb4_iommu_memory_region_info
);
1824 type_init(pnv_phb4_register_types
);
1826 void pnv_phb4_pic_print_info(PnvPHB4
*phb
, Monitor
*mon
)
1828 uint32_t offset
= phb
->regs
[PHB_INT_NOTIFY_INDEX
>> 3];
1830 monitor_printf(mon
, "PHB4[%x:%x] Source %08x .. %08x\n",
1831 phb
->chip_id
, phb
->phb_id
,
1832 offset
, offset
+ phb
->xsrc
.nr_irqs
- 1);
1833 xive_source_pic_print_info(&phb
->xsrc
, 0, mon
);