powernv/pci: Add pci_bus_to_pnvhb() helper
PATCH v2 1/16 powernv/pci: Add pci_bus_to_pnvhb() helper
Add a helper to go from a pci_bus structure to the pnv_phb that hosts that bus. There's a lot of instances of the following pattern:
struct pci_controller *hose = pci_bus_to_host(pdev->bus); struct pnv_phb *phb = hose->private_data;
Without any other uses of the pci_controller inside the function. This is hard to read since it requires you to memorise the contents of the private data fields and kind of error prone since it involves blindly assigning a void pointer. Add a helper to make it more concise and explicit.
---
v2: no change
--- arch/powerpc/platforms/powernv/pci-ioda.c | 88 +++++++---------------- arch/powerpc/platforms/powernv/pci.c | 14 ++-- arch/powerpc/platforms/powernv/pci.h | 10 +++ 3 files changed, 38 insertions(+), 74 deletions(-)
arch/powerpc/platforms/powernv/pci-ioda.c +24 -64
@@ -252,8 +252,7 @@ static int pnv_ioda2_init_m64(struct pnv_phb *phb)static void pnv_ioda_reserve_dev_m64_pe (struct pci_dev *pdev,unsigned long *pe_bitmap) { -struct pci_controller *hose =pci_bus_to_host (pdev->bus); -struct pnv_phb *phb = hose->private_data; +struct pnv_phb *phb =pci_bus_to_pnvhb (pdev->bus);struct resource *r;resource_size_t base, sgsz, start, end;int segno, i;
@@ -351,8 +350,7 @@ static void pnv_ioda_reserve_m64_pe(struct pci_bus *bus,static struct pnv_ioda_pe *pnv_ioda_pick_m64_pe (struct pci_bus *bus,bool all) { -struct pci_controller *hose =pci_bus_to_host (bus); -struct pnv_phb *phb = hose->private_data; +struct pnv_phb *phb =pci_bus_to_pnvhb (bus);struct pnv_ioda_pe *master_pe, *pe;unsigned long size, *pe_alloc;int i;
@@ -673,8 +671,7 @@ struct pnv_ioda_pe *pnv_pci_bdfn_to_pe(struct pnv_phb *phb, u16 bdfn)struct pnv_ioda_pe *pnv_ioda_get_pe (struct pci_dev *dev) { -struct pci_controller *hose =pci_bus_to_host (dev->bus); -struct pnv_phb *phb = hose->private_data; +struct pnv_phb *phb =pci_bus_to_pnvhb (dev->bus);struct pci_dn *pdn =pci_get_pdn (dev);if (!pdn)
@@ -1069,8 +1066,7 @@ static int pnv_pci_vf_resource_shift(struct pci_dev *dev, int offset)static struct pnv_ioda_pe *pnv_ioda_setup_dev_PE (struct pci_dev *dev) { -struct pci_controller *hose =pci_bus_to_host (dev->bus); -struct pnv_phb *phb = hose->private_data; +struct pnv_phb *phb =pci_bus_to_pnvhb (dev->bus);struct pci_dn *pdn =pci_get_pdn (dev);struct pnv_ioda_pe *pe;
@@ -1129,8 +1125,7 @@ static struct pnv_ioda_pe *pnv_ioda_setup_dev_PE(struct pci_dev *dev)*/ static struct pnv_ioda_pe *pnv_ioda_setup_bus_PE (struct pci_bus *bus,bool all) { -struct pci_controller *hose =pci_bus_to_host (bus); -struct pnv_phb *phb = hose->private_data; +struct pnv_phb *phb =pci_bus_to_pnvhb (bus);struct pnv_ioda_pe *pe =NULL ;unsigned int pe_num;
@@ -1196,8 +1191,7 @@ static struct pnv_ioda_pe *pnv_ioda_setup_npu_PE(struct pci_dev *npu_pdev)struct pnv_ioda_pe *pe;struct pci_dev *gpu_pdev;struct pci_dn *npu_pdn; -struct pci_controller *hose =pci_bus_to_host (npu_pdev->bus); -struct pnv_phb *phb = hose->private_data; +struct pnv_phb *phb =pci_bus_to_pnvhb (npu_pdev->bus);/* * Intentionally leak a reference on the npu device (for
@@ -1300,16 +1294,12 @@ static void pnv_pci_ioda_setup_nvlink(void)#ifdef CONFIG_PCI_IOV static int pnv_pci_vf_release_m64 (struct pci_dev *pdev,u16 num_vfs) { -struct pci_bus *bus; -struct pci_controller *hose;struct pnv_phb *phb;struct pci_dn *pdn;int i, j;int m64_bars; - bus = pdev->bus; - hose =pci_bus_to_host (bus); - phb = hose->private_data; + phb =pci_bus_to_pnvhb (pdev->bus); pdn =pci_get_pdn (pdev);if (pdn->m64_single_mode)
@@ -1333,8 +1323,6 @@ static int pnv_pci_vf_release_m64(struct pci_dev *pdev, u16 num_vfs)static int pnv_pci_vf_assign_m64 (struct pci_dev *pdev,u16 num_vfs) { -struct pci_bus *bus; -struct pci_controller *hose;struct pnv_phb *phb;struct pci_dn *pdn;unsigned int win;
@@ -1346,9 +1334,7 @@ static int pnv_pci_vf_assign_m64(struct pci_dev *pdev, u16 num_vfs)int pe_num;int m64_bars; - bus = pdev->bus; - hose =pci_bus_to_host (bus); - phb = hose->private_data; + phb =pci_bus_to_pnvhb (pdev->bus); pdn =pci_get_pdn (pdev); total_vfs =pci_sriov_get_totalvfs (pdev);
@@ -1459,15 +1445,11 @@ static void pnv_pci_ioda2_release_dma_pe(struct pci_dev *dev, struct pnv_ioda_pestatic void pnv_ioda_release_vf_PE (struct pci_dev *pdev) { -struct pci_bus *bus; -struct pci_controller *hose;struct pnv_phb *phb;struct pnv_ioda_pe *pe, *pe_n;struct pci_dn *pdn; - bus = pdev->bus; - hose =pci_bus_to_host (bus); - phb = hose->private_data; + phb =pci_bus_to_pnvhb (pdev->bus); pdn =pci_get_pdn (pdev);if (!pdev->is_physfn)
@@ -1492,16 +1474,12 @@ static void pnv_ioda_release_vf_PE(struct pci_dev *pdev)static void pnv_pci_sriov_disable (struct pci_dev *pdev) { -struct pci_bus *bus; -struct pci_controller *hose;struct pnv_phb *phb;struct pnv_ioda_pe *pe;struct pci_dn *pdn;u16 num_vfs, i; - bus = pdev->bus; - hose =pci_bus_to_host (bus); - phb = hose->private_data; + phb =pci_bus_to_pnvhb (pdev->bus); pdn =pci_get_pdn (pdev); num_vfs = pdn->num_vfs;
@@ -1535,17 +1513,13 @@ static void pnv_pci_ioda2_setup_dma_pe(struct pnv_phb *phb, struct pnv_ioda_pe *pe);static void pnv_ioda_setup_vf_PE (struct pci_dev *pdev,u16 num_vfs) { -struct pci_bus *bus; -struct pci_controller *hose;struct pnv_phb *phb;struct pnv_ioda_pe *pe;int pe_num;u16 vf_index;struct pci_dn *pdn; - bus = pdev->bus; - hose =pci_bus_to_host (bus); - phb = hose->private_data; + phb =pci_bus_to_pnvhb (pdev->bus); pdn =pci_get_pdn (pdev);if (!pdev->is_physfn)
@@ -1572,7 +1546,7 @@ static void pnv_ioda_setup_vf_PE(struct pci_dev *pdev, u16 num_vfs) pe->rid = (vf_bus <<8 ) | vf_devfn;pe_info (pe,"VF %04d:%02d:%02d.%d associated with PE#%x\n" , - hose->global_number, pdev->bus->number, +pci_domain_nr (pdev->bus), pdev->bus->number,PCI_SLOT (vf_devfn),PCI_FUNC (vf_devfn), pe_num);if (pnv_ioda_configure_pe (phb, pe)) {
@@ -1602,17 +1576,13 @@ static void pnv_ioda_setup_vf_PE(struct pci_dev *pdev, u16 num_vfs)static int pnv_pci_sriov_enable (struct pci_dev *pdev,u16 num_vfs) { -struct pci_bus *bus; -struct pci_controller *hose;struct pnv_phb *phb;struct pnv_ioda_pe *pe;struct pci_dn *pdn;int ret;u16 i; - bus = pdev->bus; - hose =pci_bus_to_host (bus); - phb = hose->private_data; + phb =pci_bus_to_pnvhb (pdev->bus); pdn =pci_get_pdn (pdev);if (phb->type ==PNV_PHB_IODA2 ) {
@@ -1735,8 +1705,7 @@ static int pnv_pcibios_sriov_enable(struct pci_dev *pdev, u16 num_vfs)static void pnv_pci_ioda_dma_dev_setup (struct pci_dev *pdev) { -struct pci_controller *hose =pci_bus_to_host (pdev->bus); -struct pnv_phb *phb = hose->private_data; +struct pnv_phb *phb =pci_bus_to_pnvhb (pdev->bus);struct pci_dn *pdn =pci_get_pdn (pdev);struct pnv_ioda_pe *pe;
@@ -1847,8 +1816,7 @@ static int pnv_pci_ioda_dma_64bit_bypass(struct pnv_ioda_pe *pe)static bool pnv_pci_ioda_iommu_bypass_supported (struct pci_dev *pdev,u64 dma_mask) { -struct pci_controller *hose =pci_bus_to_host (pdev->bus); -struct pnv_phb *phb = hose->private_data; +struct pnv_phb *phb =pci_bus_to_pnvhb (pdev->bus);struct pci_dn *pdn =pci_get_pdn (pdev);struct pnv_ioda_pe *pe;
@@ -2766,8 +2734,7 @@ static void pnv_pci_init_ioda_msis(struct pnv_phb *phb)#ifdef CONFIG_PCI_IOV static void pnv_pci_ioda_fixup_iov_resources (struct pci_dev *pdev) { -struct pci_controller *hose =pci_bus_to_host (pdev->bus); -struct pnv_phb *phb = hose->private_data; +struct pnv_phb *phb =pci_bus_to_pnvhb (pdev->bus);const resource_size_t gate = phb->ioda.m64_segsize >>2 ;struct resource *res;int i;
@@ -3101,10 +3068,9 @@ static void pnv_pci_ioda_fixup(void)static resource_size_t pnv_pci_window_alignment (struct pci_bus *bus,unsigned long type) { -struct pci_dev *bridge; -struct pci_controller *hose =pci_bus_to_host (bus); -struct pnv_phb *phb = hose->private_data; +struct pnv_phb *phb =pci_bus_to_pnvhb (bus);int num_pci_bridges =0 ; +struct pci_dev *bridge; bridge = bus->self;while (bridge) {
@@ -3190,8 +3156,7 @@ static void pnv_pci_fixup_bridge_resources(struct pci_bus *bus,static void pnv_pci_configure_bus (struct pci_bus *bus) { -struct pci_controller *hose =pci_bus_to_host (bus); -struct pnv_phb *phb = hose->private_data; +struct pnv_phb *phb =pci_bus_to_pnvhb (bus);struct pci_dev *bridge = bus->self;struct pnv_ioda_pe *pe;bool all = (bridge &&pci_pcie_type (bridge) ==PCI_EXP_TYPE_PCI_BRIDGE );
@@ -3237,8 +3202,7 @@ static resource_size_t pnv_pci_default_alignment(void)static resource_size_t pnv_pci_iov_resource_alignment (struct pci_dev *pdev,int resno) { -struct pci_controller *hose =pci_bus_to_host (pdev->bus); -struct pnv_phb *phb = hose->private_data; +struct pnv_phb *phb =pci_bus_to_pnvhb (pdev->bus);struct pci_dn *pdn =pci_get_pdn (pdev);resource_size_t align;
@@ -3274,8 +3238,7 @@ static resource_size_t pnv_pci_iov_resource_alignment(struct pci_dev *pdev,*/ static bool pnv_pci_enable_device_hook (struct pci_dev *dev) { -struct pci_controller *hose =pci_bus_to_host (dev->bus); -struct pnv_phb *phb = hose->private_data; +struct pnv_phb *phb =pci_bus_to_pnvhb (dev->bus);struct pci_dn *pdn;/* The function is probably called while the PEs have
@@ -3488,8 +3451,7 @@ static void pnv_ioda_release_pe(struct pnv_ioda_pe *pe)static void pnv_pci_release_device (struct pci_dev *pdev) { -struct pci_controller *hose =pci_bus_to_host (pdev->bus); -struct pnv_phb *phb = hose->private_data; +struct pnv_phb *phb =pci_bus_to_pnvhb (pdev->bus);struct pci_dn *pdn =pci_get_pdn (pdev);struct pnv_ioda_pe *pe;
@@ -3534,8 +3496,7 @@ static void pnv_pci_ioda_shutdown(struct pci_controller *hose)static void pnv_pci_ioda_dma_bus_setup (struct pci_bus *bus) { -struct pci_controller *hose = bus->sysdata; -struct pnv_phb *phb = hose->private_data; +struct pnv_phb *phb =pci_bus_to_pnvhb (bus);struct pnv_ioda_pe *pe;list_for_each_entry (pe, &phb->ioda.pe_list, list) {
@@ -3873,8 +3834,7 @@ void __init pnv_pci_init_npu2_opencapi_phb(struct device_node *np)static void pnv_npu2_opencapi_cfg_size_fixup (struct pci_dev *dev) { -struct pci_controller *hose =pci_bus_to_host (dev->bus); -struct pnv_phb *phb = hose->private_data; +struct pnv_phb *phb =pci_bus_to_pnvhb (dev->bus);if (!machine_is (powernv))return ;
arch/powerpc/platforms/powernv/pci.c +4 -10
@@ -162,8 +162,7 @@ EXPORT_SYMBOL_GPL(pnv_pci_set_power_state);int pnv_setup_msi_irqs (struct pci_dev *pdev,int nvec,int type) { -struct pci_controller *hose =pci_bus_to_host (pdev->bus); -struct pnv_phb *phb = hose->private_data; +struct pnv_phb *phb =pci_bus_to_pnvhb (pdev->bus);struct msi_desc *entry;struct msi_msg msg;int hwirq;
@@ -211,8 +210,7 @@ int pnv_setup_msi_irqs(struct pci_dev *pdev, int nvec, int type)void pnv_teardown_msi_irqs (struct pci_dev *pdev) { -struct pci_controller *hose =pci_bus_to_host (pdev->bus); -struct pnv_phb *phb = hose->private_data; +struct pnv_phb *phb =pci_bus_to_pnvhb (pdev->bus);struct msi_desc *entry;irq_hw_number_t hwirq;
@@ -824,10 +822,9 @@ EXPORT_SYMBOL(pnv_pci_get_phb_node);int pnv_pci_set_tunnel_bar (struct pci_dev *dev,u64 addr,int enable) { -__be64 val; -struct pci_controller *hose; -struct pnv_phb *phb; +struct pnv_phb *phb =pci_bus_to_pnvhb (dev->bus);u64 tunnel_bar; +__be64 val;int rc;if (!opal_check_token (OPAL_PCI_GET_PBCQ_TUNNEL_BAR ))
@@ -835,9 +832,6 @@ int pnv_pci_set_tunnel_bar(struct pci_dev *dev, u64 addr, int enable)if (!opal_check_token (OPAL_PCI_SET_PBCQ_TUNNEL_BAR ))return -ENXIO ; - hose =pci_bus_to_host (dev->bus); - phb = hose->private_data; -mutex_lock (&tunnel_mutex); rc =opal_pci_get_pbcq_tunnel_bar (phb->opal_id, &val);if (rc !=OPAL_SUCCESS ) {
arch/powerpc/platforms/powernv/pci.h +10 -0
@@ -260,4 +260,14 @@ extern void pnv_pci_setup_iommu_table(struct iommu_table *tbl,extern unsigned long pnv_ioda_parse_tce_sizes (struct pnv_phb *phb); +static inline struct pnv_phb *pci_bus_to_pnvhb (struct pci_bus *bus) +{ +struct pci_controller *hose = bus->sysdata; + +if (hose) +return hose->private_data; + +return NULL ; +} +#endif /* __POWERNV_PCI_H */
Signature · 1 line
2.26.2
PATCH v2 2/16 powerpc/powernv/pci: Always tear down DMA windows on PE release
Currently we have these two functions:
pnv_pci_ioda2_release_dma_pe(), and pnv_pci_ioda2_release_pe_dma()
The first is used when tearing down VF PEs and the other is used for normal devices. There's very little difference between the two though. The latter (non-VF) will skip a call to pnv_pci_ioda2_unset_window() unless CONFIG_IOMMU_API=y is set. There's no real point in doing this so fold the two together.
---
v2: no change
--- arch/powerpc/platforms/powernv/pci-ioda.c | 30 +++-------------------- 1 file changed, 3 insertions(+), 27 deletions(-)
arch/powerpc/platforms/powernv/pci-ioda.c +3 -27
@@ -1422,26 +1422,7 @@ static int pnv_pci_vf_assign_m64(struct pci_dev *pdev, u16 num_vfs)return -EBUSY ; } -static long pnv_pci_ioda2_unset_window (struct iommu_table_group *table_group, -int num); - -static void pnv_pci_ioda2_release_dma_pe (struct pci_dev *dev,struct pnv_ioda_pe *pe) -{ -struct iommu_table *tbl; -int64_t rc; - - tbl = pe->table_group.tables[0 ]; - rc =pnv_pci_ioda2_unset_window (&pe->table_group,0 ); -if (rc) -pe_warn (pe,"OPAL error %lld release DMA window\n" , rc); - -pnv_pci_ioda2_set_bypass (pe, false); -if (pe->table_group.group) { -iommu_group_put (pe->table_group.group); -BUG_ON (pe->table_group.group); - } -iommu_tce_table_put (tbl); -} +static void pnv_pci_ioda2_release_pe_dma (struct pnv_ioda_pe *pe);static void pnv_ioda_release_vf_PE (struct pci_dev *pdev) {
@@ -1455,11 +1436,12 @@ static void pnv_ioda_release_vf_PE(struct pci_dev *pdev)if (!pdev->is_physfn)return ; +/* FIXME: Use pnv_ioda_release_pe()? */ list_for_each_entry_safe (pe, pe_n, &phb->ioda.pe_list, list) {if (pe->parent_dev != pdev)continue ; -pnv_pci_ioda2_release_dma_pe (pdev, pe); +pnv_pci_ioda2_release_pe_dma (pe);/* Remove from list */ mutex_lock (&phb->ioda.pe_list_mutex);
@@ -2429,7 +2411,6 @@ static long pnv_pci_ioda2_setup_default_config(struct pnv_ioda_pe *pe)return 0 ; } -#if defined(CONFIG_IOMMU_API ) || defined(CONFIG_PCI_IOV )static long pnv_pci_ioda2_unset_window (struct iommu_table_group *table_group,int num) {
@@ -2453,7 +2434,6 @@ static long pnv_pci_ioda2_unset_window(struct iommu_table_group *table_group,return ret; } -#endif #ifdef CONFIG_IOMMU_API unsigned long pnv_pci_ioda2_get_table_size(__u32 page_shift,
@@ -3334,18 +3314,14 @@ static void pnv_pci_ioda2_release_pe_dma(struct pnv_ioda_pe *pe) {struct iommu_table *tbl = pe->table_group.tables[0 ];unsigned int weight =pnv_pci_ioda_pe_dma_weight (pe); -#ifdef CONFIG_IOMMU_API int64_t rc; -#endif if (!weight)return ; -#ifdef CONFIG_IOMMU_API rc =pnv_pci_ioda2_unset_window (&pe->table_group,0 );if (rc)pe_warn (pe,"OPAL error %lld release DMA window\n" , rc); -#endif pnv_pci_ioda2_set_bypass (pe, false);if (pe->table_group.group) {
Signature · 1 line
2.26.2
PATCH v2 3/16 powerpc/powernv/pci: Add explicit tracking of the DMA setup state
In reply to Oliver O'HalloranThere's an optimisation in the PE setup which skips performing DMA setup for a PE if we only have bridges in a PE. The assumption being that only "real" devices will DMA to system memory, which is probably fair. However, if we start off with only bridge devices in a PE then add a non-bridge device the new device won't be able to use DMA because we never configured it.
Fix this (admittedly pretty weird) edge case by tracking whether we've done the DMA setup for the PE or not. If a non-bridge device is added to the PE (via rescan or hotplug, or whatever) we can set up DMA on demand.
This also means the only remaining user of the old "DMA Weight" code is the IODA1 DMA setup code that it was originally added for, which is good.
---
v2: no changes
--- arch/powerpc/platforms/powernv/pci-ioda.c | 48 ++++++++++++++--------- arch/powerpc/platforms/powernv/pci.h | 7 ++++ 2 files changed, 36 insertions(+), 19 deletions(-)
arch/powerpc/platforms/powernv/pci-ioda.c +29 -19
@@ -141,6 +141,7 @@ static struct pnv_ioda_pe *pnv_ioda_init_pe(struct pnv_phb *phb, int pe_no) phb->ioda.pe_array[pe_no].phb = phb; phb->ioda.pe_array[pe_no].pe_number = pe_no; + phb->ioda.pe_array[pe_no].dma_setup_done = false;/* * Clear the PE frozen state as it might be put into frozen state
@@ -1685,6 +1686,12 @@ static int pnv_pcibios_sriov_enable(struct pci_dev *pdev, u16 num_vfs) }#endif /* CONFIG_PCI_IOV */ +static void pnv_pci_ioda1_setup_dma_pe (struct pnv_phb *phb, +struct pnv_ioda_pe *pe); + +static void pnv_pci_ioda2_setup_dma_pe (struct pnv_phb *phb, +struct pnv_ioda_pe *pe); +static void pnv_pci_ioda_dma_dev_setup (struct pci_dev *pdev) {struct pnv_phb *phb =pci_bus_to_pnvhb (pdev->bus);
@@ -1713,6 +1720,24 @@ static void pnv_pci_ioda_dma_dev_setup(struct pci_dev *pdev)pci_info (pdev,"Added to existing PE#%x\n" , pe->pe_number); } +/* +* We assume that bridges *probably* don't need to do any DMA so we can +* skip allocating a TCE table, etc unless we get a non-bridge device. +*/ +if (!pe->dma_setup_done && !pci_is_bridge (pdev)) { +switch (phb->type) { +case PNV_PHB_IODA1 : +pnv_pci_ioda1_setup_dma_pe (phb, pe); +break ; +case PNV_PHB_IODA2 : +pnv_pci_ioda2_setup_dma_pe (phb, pe); +break ; +default : +pr_warn ("%s: No DMA for PHB#%x (type %d)\n" , + __func__, phb->hose->global_number, phb->type); + } + } +if (pdn) pdn->pe_number = pe->pe_number; pe->device_count++;
@@ -2222,6 +2247,7 @@ static void pnv_pci_ioda1_setup_dma_pe(struct pnv_phb *phb, pe->table_group.tce32_size = tbl->it_size << tbl->it_page_shift;iommu_init_table (tbl, phb->hose->node,0 ,0 ); + pe->dma_setup_done = true;return ; fail:/* XXX Failure: Try to fallback to 64-bit only ? */
@@ -2536,9 +2562,6 @@ static void pnv_pci_ioda2_setup_dma_pe(struct pnv_phb *phb, {int64_t rc; -if (!pnv_pci_ioda_pe_dma_weight (pe)) -return ; -/* TVE #1 is selected by PCI address bit 59 */ pe->tce_bypass_base =1ull <<59 ;
@@ -2563,6 +2586,7 @@ static void pnv_pci_ioda2_setup_dma_pe(struct pnv_phb *phb,iommu_register_group (&pe->table_group, phb->hose->global_number, pe->pe_number);#endif + pe->dma_setup_done = true; }int64_t pnv_opal_pci_msi_eoi (struct irq_chip *chip,unsigned int hw_irq)
@@ -3136,7 +3160,6 @@ static void pnv_pci_fixup_bridge_resources(struct pci_bus *bus,static void pnv_pci_configure_bus (struct pci_bus *bus) { -struct pnv_phb *phb =pci_bus_to_pnvhb (bus);struct pci_dev *bridge = bus->self;struct pnv_ioda_pe *pe;bool all = (bridge &&pci_pcie_type (bridge) ==PCI_EXP_TYPE_PCI_BRIDGE );
@@ -3160,17 +3183,6 @@ static void pnv_pci_configure_bus(struct pci_bus *bus)return ;pnv_ioda_setup_pe_seg (pe); -switch (phb->type) { -case PNV_PHB_IODA1 : -pnv_pci_ioda1_setup_dma_pe (phb, pe); -break ; -case PNV_PHB_IODA2 : -pnv_pci_ioda2_setup_dma_pe (phb, pe); -break ; -default : -pr_warn ("%s: No DMA for PHB#%x (type %d)\n" , - __func__, phb->hose->global_number, phb->type); - } }static resource_size_t pnv_pci_default_alignment (void )
@@ -3289,11 +3301,10 @@ static long pnv_pci_ioda1_unset_window(struct iommu_table_group *table_group,static void pnv_pci_ioda1_release_pe_dma (struct pnv_ioda_pe *pe) { -unsigned int weight =pnv_pci_ioda_pe_dma_weight (pe);struct iommu_table *tbl = pe->table_group.tables[0 ];int64_t rc; -if (!weight) +if (!pe->dma_setup_done)return ; rc =pnv_pci_ioda1_unset_window (&pe->table_group,0 );
@@ -3313,10 +3324,9 @@ static void pnv_pci_ioda1_release_pe_dma(struct pnv_ioda_pe *pe)static void pnv_pci_ioda2_release_pe_dma (struct pnv_ioda_pe *pe) {struct iommu_table *tbl = pe->table_group.tables[0 ]; -unsigned int weight =pnv_pci_ioda_pe_dma_weight (pe);int64_t rc; -if (!weight) +if (pe->dma_setup_done)return ; rc =pnv_pci_ioda2_unset_window (&pe->table_group,0 );
arch/powerpc/platforms/powernv/pci.h +7 -0
@@ -87,6 +87,13 @@ struct pnv_ioda_pe {bool tce_bypass_enabled;uint64_t tce_bypass_base; +/* +* Used to track whether we've done DMA setup for this PE or not. We +* want to defer allocating TCE tables, etc until we've added a +* non-bridge device to the PE. +*/ +bool dma_setup_done; +/* MSIs. MVE index is identical for for 32 and 64 bit MSI * and -1 if not supported. (It's actually identical to the * PE number)
Signature · 1 line
2.26.2
PATCH v2 4/16 powerpc/powernv/pci: Initialise M64 for IODA1 as a 1-1 window
In reply to Oliver O'HalloranWe pre-configure the m64 window for IODA1 as a 1-1 segment-PE mapping, similar to PHB3. Currently the actual mapping of segments occurs in pnv_ioda_pick_m64_pe(), but we can move it into pnv_ioda1_init_m64() and drop the IODA1 specific code paths in the PE setup / teardown.
---
v2: no changes
--- arch/powerpc/platforms/powernv/pci-ioda.c | 55 +++++++++++------------ 1 file changed, 25 insertions(+), 30 deletions(-)
arch/powerpc/platforms/powernv/pci-ioda.c +25 -30
@@ -311,6 +311,28 @@ static int pnv_ioda1_init_m64(struct pnv_phb *phb) } } +for (index =0 ; index < phb->ioda.total_pe_num; index++) { +int64_t rc; + +/* +* P7IOC supports M64DT, which helps mapping M64 segment +* to one particular PE#. However, PHB3 has fixed mapping +* between M64 segment and PE#. In order to have same logic +* for P7IOC and PHB3, we enforce fixed mapping between M64 +* segment and PE# on P7IOC. +*/ + rc =opal_pci_map_pe_mmio_window (phb->opal_id, + index,OPAL_M64_WINDOW_TYPE , + index /PNV_IODA1_M64_SEGS , + index %PNV_IODA1_M64_SEGS ); +if (rc !=OPAL_SUCCESS ) { +pr_warn ("%s: Error %lld mapping M64 for PHB#%x-PE#%x\n" , + __func__, rc, phb->hose->global_number, + index); + goto fail; + } + } +/* * Exclude the segments for reserved and root bus PE, which * are first or last two PEs.
@@ -402,26 +424,6 @@ static struct pnv_ioda_pe *pnv_ioda_pick_m64_pe(struct pci_bus *bus, bool all) pe->master = master_pe;list_add_tail (&pe->list, &master_pe->slaves); } - -/* -* P7IOC supports M64DT, which helps mapping M64 segment -* to one particular PE#. However, PHB3 has fixed mapping -* between M64 segment and PE#. In order to have same logic -* for P7IOC and PHB3, we enforce fixed mapping between M64 -* segment and PE# on P7IOC. -*/ -if (phb->type ==PNV_PHB_IODA1 ) { -int64_t rc; - - rc =opal_pci_map_pe_mmio_window (phb->opal_id, - pe->pe_number,OPAL_M64_WINDOW_TYPE , - pe->pe_number /PNV_IODA1_M64_SEGS , - pe->pe_number %PNV_IODA1_M64_SEGS ); -if (rc !=OPAL_SUCCESS ) -pr_warn ("%s: Error %lld mapping M64 for PHB#%x-PE#%x\n" , - __func__, rc, phb->hose->global_number, - pe->pe_number); - } }kfree (pe_alloc);
@@ -3354,14 +3356,8 @@ static void pnv_ioda_free_pe_seg(struct pnv_ioda_pe *pe,if (map[idx] != pe->pe_number)continue ; -if (win ==OPAL_M64_WINDOW_TYPE ) - rc =opal_pci_map_pe_mmio_window (phb->opal_id, - phb->ioda.reserved_pe_idx, win, - idx /PNV_IODA1_M64_SEGS , - idx %PNV_IODA1_M64_SEGS ); -else - rc =opal_pci_map_pe_mmio_window (phb->opal_id, - phb->ioda.reserved_pe_idx, win,0 , idx); + rc =opal_pci_map_pe_mmio_window (phb->opal_id, + phb->ioda.reserved_pe_idx, win,0 , idx);if (rc !=OPAL_SUCCESS ) pe_warn(pe, "Error %lld unmapping (%d) segment#%d\n",
@@ -3380,8 +3376,7 @@ static void pnv_ioda_release_pe_seg(struct pnv_ioda_pe *pe) phb->ioda.io_segmap);pnv_ioda_free_pe_seg (pe,OPAL_M32_WINDOW_TYPE , phb->ioda.m32_segmap); -pnv_ioda_free_pe_seg (pe,OPAL_M64_WINDOW_TYPE , - phb->ioda.m64_segmap); +/* M64 is pre-configured by pnv_ioda1_init_m64() */ }else if (phb->type ==PNV_PHB_IODA2 ) {pnv_ioda_free_pe_seg (pe,OPAL_M32_WINDOW_TYPE , phb->ioda.m32_segmap);
Signature · 1 line
2.26.2
PATCH v2 5/16 powerpc/powernv/sriov: Move SR-IOV into a separate file
In reply to Oliver O'Halloranpci-ioda.c is getting a bit unwieldly due to the amount of stuff jammed in there. The SR-IOV support can be extracted easily enough and is mostly standalone, so move it into a separate file.
This patch also moves the PowerNV SR-IOV specific fields from pci_dn and moves them into a platform specific structure. I'm not sure how they ended up in there in the first place, but leaking platform specifics into common code has proven to be a terrible idea so far so lets stop doing that.
---
v2: no changes
--- arch/powerpc/include/asm/device.h | 3 + arch/powerpc/platforms/powernv/Makefile | 1 + arch/powerpc/platforms/powernv/pci-ioda.c | 673 +-------------------- arch/powerpc/platforms/powernv/pci-sriov.c | 642 ++++++++++++++++++++ arch/powerpc/platforms/powernv/pci.h | 74 +++ 5 files changed, 738 insertions(+), 655 deletions(-) create mode 100644 arch/powerpc/platforms/powernv/pci-sriov.c
arch/powerpc/include/asm/device.h +3 -0
@@ -49,6 +49,9 @@ struct dev_archdata {#ifdef CONFIG_CXL_BASE struct cxl_context *cxl_ctx;#endif +#ifdef CONFIG_PCI_IOV +void *iov_data; +#endif };struct pdev_archdata {
arch/powerpc/platforms/powernv/Makefile +1 -0
@@ -11,6 +11,7 @@ obj-$(CONFIG_FA_DUMP) += opal-fadump.o obj-$(CONFIG_PRESERVE_FA_DUMP) += opal-fadump.o obj-$(CONFIG_OPAL_CORE) += opal-core.o obj-$(CONFIG_PCI) += pci.o pci-ioda.o npu-dma.o pci-ioda-tce.o +obj-$(CONFIG_PCI_IOV) += pci-sriov.o obj-$(CONFIG_CXL_BASE) += pci-cxl.o obj-$(CONFIG_EEH) += eeh-powernv.o obj-$(CONFIG_MEMORY_FAILURE) += opal-memory-errors.o
arch/powerpc/platforms/powernv/pci-ioda.c +18 -655
754 lines not on this page · raw message
arch/powerpc/platforms/powernv/pci-sriov.c new file +642 -0
642 lines not on this page · raw message
arch/powerpc/platforms/powernv/pci.h +74 -0
80 lines not on this page · raw message
Signature · 1 line
2.26.2
PATCH v2 6/16 powerpc/powernv/sriov: Explain how SR-IOV works on PowerNV
In reply to Oliver O'HalloranSR-IOV support on PowerNV is a byzantine maze of hooks. I have no idea how anyone is supposed to know how it works except through a lot of stuffering. Write up some docs about the overall story to help out the next sucker^Wperson who needs to tinker with it.
---
v2: no changes
--- arch/powerpc/platforms/powernv/pci-sriov.c | 130 +++++++++++++++++++++ 1 file changed, 130 insertions(+)
arch/powerpc/platforms/powernv/pci-sriov.c +130 -0
@@ -12,6 +12,136 @@/* for pci_dev_is_added() */ #include "../../../../drivers/pci/pci.h" +/* +* The majority of the complexity in supporting SR-IOV on PowerNV comes from +* the need to put the MMIO space for each VF into a separate PE. Internally +* the PHB maps MMIO addresses to a specific PE using the "Memory BAR Table". +* The MBT historically only applied to the 64bit MMIO window of the PHB +* so it's common to see it referred to as the "M64BT". +* +* An MBT entry stores the mapped range as an <base>,<mask> pair. This forces +* the address range that we want to map to be power-of-two sized and aligned. +* For conventional PCI devices this isn't really an issue since PCI device BARs +* have the same requirement. +* +* For a SR-IOV BAR things are a little more awkward since size and alignment +* are not coupled. The alignment is set based on the the per-VF BAR size, but +* the total BAR area is: number-of-vfs * per-vf-size. The number of VFs +* isn't necessarily a power of two, so neither is the total size. To fix that +* we need to finesse (read: hack) the Linux BAR allocator so that it will +* allocate the SR-IOV BARs in a way that lets us map them using the MBT. +* +* The changes to size and alignment that we need to do depend on the "mode" +* of MBT entry that we use. We only support SR-IOV on PHB3 (IODA2) and above, +* so as a baseline we can assume that we have the following BAR modes +* available: +* +* NB: $PE_COUNT is the number of PEs that the PHB supports. +* +* a) A segmented BAR that splits the mapped range into $PE_COUNT equally sized +* segments. The n'th segment is mapped to the n'th PE. +* b) An un-segmented BAR that maps the whole address range to a specific PE. +* +* +* We prefer to use mode a) since it only requires one MBT entry per SR-IOV BAR +* For comparison b) requires one entry per-VF per-BAR, or: +* (num-vfs * num-sriov-bars) in total. To use a) we need the size of each segment +* to equal the size of the per-VF BAR area. So: +* +* new_size = per-vf-size * number-of-PEs +* +* The alignment for the SR-IOV BAR also needs to be changed from per-vf-size +* to "new_size", calculated above. Implementing this is a convoluted process +* which requires several hooks in the PCI core: +* +* 1. In pcibios_add_device() we call pnv_pci_ioda_fixup_iov(). +* +* At this point the device has been probed and the device's BARs are sized, +* but no resource allocations have been done. The SR-IOV BARs are sized +* based on the maximum number of VFs supported by the device and we need +* to increase that to new_size. +* +* 2. Later, when Linux actually assigns resources it tries to make the resource +* allocations for each PCI bus as compact as possible. As a part of that it +* sorts the BARs on a bus by their required alignment, which is calculated +* using pci_resource_alignment(). +* +* For IOV resources this goes: +* pci_resource_alignment() +* pci_sriov_resource_alignment() +* pcibios_sriov_resource_alignment() +* pnv_pci_iov_resource_alignment() +* +* Our hook overrides the default alignment, equal to the per-vf-size, with +* new_size computed above. +* +* 3. When userspace enables VFs for a device: +* +* sriov_enable() +* pcibios_sriov_enable() +* pnv_pcibios_sriov_enable() +* +* This is where we actually allocate PE numbers for each VF and setup the +* MBT mapping for each SR-IOV BAR. In steps 1) and 2) we setup an "arena" +* where each MBT segment is equal in size to the VF BAR so we can shift +* around the actual SR-IOV BAR location within this arena. We need this +* ability because the PE space is shared by all devices on the same PHB. +* When using mode a) described above segment 0 in maps to PE#0 which might +* be already being used by another device on the PHB. +* +* As a result we need allocate a contigious range of PE numbers, then shift +* the address programmed into the SR-IOV BAR of the PF so that the address +* of VF0 matches up with the segment corresponding to the first allocated +* PE number. This is handled in pnv_pci_vf_resource_shift(). +* +* Once all that is done we return to the PCI core which then enables VFs, +* scans them and creates pci_devs for each. The init process for a VF is +* largely the same as a normal device, but the VF is inserted into the IODA +* PE that we allocated for it rather than the PE associated with the bus. +* +* 4. When userspace disables VFs we unwind the above in +* pnv_pcibios_sriov_disable(). Fortunately this is relatively simple since +* we don't need to validate anything, just tear down the mappings and +* move SR-IOV resource back to its "proper" location. +* +* That's how mode a) works. In theory mode b) (single PE mapping) is less work +* since we can map each individual VF with a separate BAR. However, there's a +* few limitations: +* +* 1) For IODA2 mode b) has a minimum alignment requirement of 32MB. This makes +* it only usable for devices with very large per-VF BARs. Such devices are +* similar to Big Foot. They definitely exist, but I've never seen one. +* +* 2) The number of MBT entries that we have is limited. PHB3 and PHB4 only +* 16 total and some are needed for. Most SR-IOV capable network cards can support +* more than 16 VFs on each port. +* +* We use b) when using a) would use more than 1/4 of the entire 64 bit MMIO +* window of the PHB. +* +* +* +* PHB4 (IODA3) added a few new features that would be useful for SR-IOV. It +* allowed the MBT to map 32bit MMIO space in addition to 64bit which allows +* us to support SR-IOV BARs in the 32bit MMIO window. This is useful since +* the Linux BAR allocation will place any BAR marked as non-prefetchable into +* the non-prefetchable bridge window, which is 32bit only. It also added two +* new modes: +* +* c) A segmented BAR similar to a), but each segment can be individually +* mapped to any PE. This is matches how the 32bit MMIO window worked on +* IODA1&2. +* +* d) A segmented BAR with 8, 64, or 128 segments. This works similarly to a), +* but with fewer segments and configurable base PE. +* +* i.e. The n'th segment maps to the (n + base)'th PE. +* +* The base PE is also required to be a multiple of the window size. +* +* Unfortunately, the OPAL API doesn't currently (as of skiboot v6.6) allow us +* to exploit any of the IODA3 features. +*/ static void pnv_pci_ioda_fixup_iov_resources (struct pci_dev *pdev) {
Signature · 1 line
2.26.2
PATCH v2 7/16 powerpc/powernv/sriov: Rename truncate_iov
In reply to Oliver O'HalloranThis prevents SR-IOV being used by making the SR-IOV BAR resources unallocatable. Rename it to reflect what it actually does.
---
v2: no changes
--- arch/powerpc/platforms/powernv/pci-sriov.c | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-)
arch/powerpc/platforms/powernv/pci-sriov.c +6 -5
@@ -155,7 +155,7 @@ static void pnv_pci_ioda_fixup_iov_resources(struct pci_dev *pdev) iov =kzalloc (sizeof (*iov),GFP_KERNEL );if (!iov) - goto truncate_iov; + goto disable_iov; pdev->dev.archdata.iov_data = iov; total_vfs =pci_sriov_get_totalvfs (pdev);
@@ -170,7 +170,7 @@ static void pnv_pci_ioda_fixup_iov_resources(struct pci_dev *pdev)dev_warn (&pdev->dev,"Don't support SR-IOV with" " non M64 VF BAR%d: %pR. \n" , i, res); - goto truncate_iov; + goto disable_iov; } total_vf_bar_sz += pci_iov_resource_size(pdev,
@@ -209,7 +209,8 @@ static void pnv_pci_ioda_fixup_iov_resources(struct pci_dev *pdev)* mode is 32MB. */ if (iov->m64_single_mode && (size <SZ_32M )) - goto truncate_iov; + goto disable_iov; +dev_dbg (&pdev->dev," Fixing VF BAR%d: %pR to\n" , i, res); res->end = res->start + size * mul -1 ;dev_dbg (&pdev->dev," %pR\n" , res);
@@ -220,8 +221,8 @@ static void pnv_pci_ioda_fixup_iov_resources(struct pci_dev *pdev)return ; -truncate_iov: -/* To save MMIO space, IOV BAR is truncated. */ +disable_iov: +/* Save ourselves some MMIO space by disabling the unusable BARs */ for (i =0 ; i <PCI_SRIOV_NUM_BARS ; i++) { res = &pdev->resource[i +PCI_IOV_RESOURCES ]; res->flags =0 ;
Signature · 1 line
2.26.2
PATCH v2 8/16 powerpc/powernv/sriov: Simplify used window tracking
In reply to Oliver O'HalloranNo need for the multi-dimensional arrays, just use a bitmap.
---
v2: Fixed license to GPL-2.0-or-later
Added MAX_M64_BARS for the size of the M64 allocation bitmap rather than open coding 64.
--- arch/powerpc/platforms/powernv/pci-sriov.c | 50 +++++++--------------- arch/powerpc/platforms/powernv/pci.h | 8 +++- 2 files changed, 22 insertions(+), 36 deletions(-)
arch/powerpc/platforms/powernv/pci-sriov.c +16 -34
@@ -1,4 +1,4 @@ -// SPDX-License-Identifier: GPL-2.0 +// SPDX-License-Identifier: GPL-2.0-or-later #include <linux/kernel.h> #include <linux/ioport.h>
@@ -303,28 +303,20 @@ static int pnv_pci_vf_release_m64(struct pci_dev *pdev, u16 num_vfs) {struct pnv_iov_data *iov;struct pnv_phb *phb; -int i, j; -int m64_bars; +int window_id; phb =pci_bus_to_pnvhb (pdev->bus); iov =pnv_iov_get (pdev); -if (iov->m64_single_mode) - m64_bars = num_vfs; -else - m64_bars =1 ; +for_each_set_bit (window_id, iov->used_m64_bar_mask,MAX_M64_BARS ) { +opal_pci_phb_mmio_enable (phb->opal_id, +OPAL_M64_WINDOW_TYPE , + window_id, +0 ); -for (i =0 ; i <PCI_SRIOV_NUM_BARS ; i++) -for (j =0 ; j < m64_bars; j++) { -if (iov->m64_map[j][i] ==IODA_INVALID_M64 ) -continue ; -opal_pci_phb_mmio_enable (phb->opal_id, -OPAL_M64_WINDOW_TYPE , iov->m64_map[j][i],0 ); -clear_bit (iov->m64_map[j][i], &phb->ioda.m64_bar_alloc); - iov->m64_map[j][i] =IODA_INVALID_M64 ; - } +clear_bit (window_id, &phb->ioda.m64_bar_alloc); + } -kfree (iov->m64_map);return 0 ; }
@@ -350,23 +342,14 @@ static int pnv_pci_vf_assign_m64(struct pci_dev *pdev, u16 num_vfs)else m64_bars =1 ; - iov->m64_map =kmalloc_array (m64_bars, -sizeof (*iov->m64_map), -GFP_KERNEL ); -if (!iov->m64_map) -return -ENOMEM ; -/* Initialize the m64_map to IODA_INVALID_M64 */ -for (i =0 ; i < m64_bars ; i++) -for (j =0 ; j <PCI_SRIOV_NUM_BARS ; j++) - iov->m64_map[i][j] =IODA_INVALID_M64 ; - -for (i =0 ; i <PCI_SRIOV_NUM_BARS ; i++) { res = &pdev->resource[i +PCI_IOV_RESOURCES ];if (!res->flags || !res->parent)continue ;for (j =0 ; j < m64_bars; j++) { + +/* allocate a window ID for this BAR */ do { win = find_next_zero_bit(&phb->ioda.m64_bar_alloc, phb->ioda.m64_bar_idx + 1, 0);
@@ -374,8 +357,7 @@ static int pnv_pci_vf_assign_m64(struct pci_dev *pdev, u16 num_vfs)if (win >= phb->ioda.m64_bar_idx +1 ) goto m64_failed; }while (test_and_set_bit (win, &phb->ioda.m64_bar_alloc)); - - iov->m64_map[j][i] = win; +set_bit (win, iov->used_m64_bar_mask);if (iov->m64_single_mode) { size = pci_iov_resource_size(pdev,
@@ -391,12 +373,12 @@ static int pnv_pci_vf_assign_m64(struct pci_dev *pdev, u16 num_vfs) pe_num = iov->pe_num_map[j]; rc =opal_pci_map_pe_mmio_window (phb->opal_id, pe_num,OPAL_M64_WINDOW_TYPE , - iov->m64_map[j][i],0 ); + win,0 ); } rc =opal_pci_set_phb_mem_window (phb->opal_id,OPAL_M64_WINDOW_TYPE , - iov->m64_map[j][i], + win, start,0 ,/* unused */ size);
@@ -410,10 +392,10 @@ static int pnv_pci_vf_assign_m64(struct pci_dev *pdev, u16 num_vfs)if (iov->m64_single_mode) rc =opal_pci_phb_mmio_enable (phb->opal_id, -OPAL_M64_WINDOW_TYPE , iov->m64_map[j][i],2 ); +OPAL_M64_WINDOW_TYPE , win,2 );else rc =opal_pci_phb_mmio_enable (phb->opal_id, -OPAL_M64_WINDOW_TYPE , iov->m64_map[j][i],1 ); +OPAL_M64_WINDOW_TYPE , win,1 );if (rc !=OPAL_SUCCESS ) { dev_err(&pdev->dev, "Failed to enable M64 window #%d: %llx\n",
arch/powerpc/platforms/powernv/pci.h +6 -2
@@ -154,6 +154,7 @@ struct pnv_phb {unsigned long m64_size;unsigned long m64_segsize;unsigned long m64_base; +#define MAX_M64_BARS 64unsigned long m64_bar_alloc;/* IO ports */
@@ -243,8 +244,11 @@ struct pnv_iov_data {/* Did we map the VF BARs with single-PE IODA BARs? */ bool m64_single_mode; -int (*m64_map)[PCI_SRIOV_NUM_BARS ]; -#define IODA_INVALID_M64 (-1) +/* +* Bit mask used to track which m64 windows are used to map the +* SR-IOV BARs for this device. +*/ +DECLARE_BITMAP (used_m64_bar_mask,MAX_M64_BARS );/* * If we map the SR-IOV BARs with a segmented window then
Signature · 1 line
2.26.2
PATCH v2 9/16 powerpc/powernv/sriov: Factor out M64 BAR setup
In reply to Oliver O'HalloranThe sequence required to use the single PE BAR mode is kinda janky and requires a little explanation. The API was designed with P7-IOC style windows where the setup process is something like:
1. Configure the window start / end address
2. Enable the window
3. Map the segments of each window to the PE
For Single PE BARs the process is:
1. Set the PE for segment zero on a disabled window
2. Set the range
3. Enable the window
Move the OPAL calls into their own helper functions where the quirks can be contained.
---
v2: renamed "accordion" window to "segmented"
--- arch/powerpc/platforms/powernv/pci-sriov.c | 129 ++++++++++++++++----- 1 file changed, 100 insertions(+), 29 deletions(-)
arch/powerpc/platforms/powernv/pci-sriov.c +100 -29
@@ -320,6 +320,99 @@ static int pnv_pci_vf_release_m64(struct pci_dev *pdev, u16 num_vfs)return 0 ; } + +/* +* PHB3 and beyond support segmented windows. The window's address range +* is subdivided into phb->ioda.total_pe_num segments and there's a 1-1 +* mapping between PEs and segments. +*/ +static int64_t pnv_ioda_map_m64_segmented (struct pnv_phb *phb, +int window_id, +resource_size_t start, +resource_size_t size) +{ +int64_t rc; + + rc =opal_pci_set_phb_mem_window (phb->opal_id, +OPAL_M64_WINDOW_TYPE , + window_id, + start, +0 ,/* unused */ + size); +if (rc) + goto out; + + rc =opal_pci_phb_mmio_enable (phb->opal_id, +OPAL_M64_WINDOW_TYPE , + window_id, +OPAL_ENABLE_M64_SPLIT ); +out: +if (rc) +pr_err ("Failed to map M64 window #%d: %lld\n" , window_id, rc); + +return rc; +} + +static int64_t pnv_ioda_map_m64_single (struct pnv_phb *phb, +int pe_num, +int window_id, +resource_size_t start, +resource_size_t size) +{ +int64_t rc; + +/* +* The API for setting up m64 mmio windows seems to have been designed +* with P7-IOC in mind. For that chip each M64 BAR (window) had a fixed +* split of 8 equally sized segments each of which could individually +* assigned to a PE. +* +* The problem with this is that the API doesn't have any way to +* communicate the number of segments we want on a BAR. This wasn't +* a problem for p7-ioc since you didn't have a choice, but the +* single PE windows added in PHB3 don't map cleanly to this API. +* +* As a result we've got this slightly awkward process where we +* call opal_pci_map_pe_mmio_window() to put the single in single +* PE mode, and set the PE for the window before setting the address +* bounds. We need to do it this way because the single PE windows +* for PHB3 have different alignment requirements on PHB3. +*/ + rc =opal_pci_map_pe_mmio_window (phb->opal_id, + pe_num, +OPAL_M64_WINDOW_TYPE , + window_id, +0 ); +if (rc) + goto out; + +/* +* NB: In single PE mode the window needs to be aligned to 32MB +*/ + rc =opal_pci_set_phb_mem_window (phb->opal_id, +OPAL_M64_WINDOW_TYPE , + window_id, + start, +0 ,/* ignored by FW, m64 is 1-1 */ + size); +if (rc) + goto out; + +/* +* Now actually enable it. We specified the BAR should be in "non-split" +* mode so FW will validate that the BAR is in single PE mode. +*/ + rc =opal_pci_phb_mmio_enable (phb->opal_id, +OPAL_M64_WINDOW_TYPE , + window_id, +OPAL_ENABLE_M64_NON_SPLIT ); +out: +if (rc) +pr_err ("Error mapping single PE BAR\n" ); + +return rc; +} +static int pnv_pci_vf_assign_m64 (struct pci_dev *pdev,u16 num_vfs) {struct pnv_iov_data *iov;
@@ -330,7 +423,6 @@ static int pnv_pci_vf_assign_m64(struct pci_dev *pdev, u16 num_vfs)int64_t rc;int total_vfs;resource_size_t size, start; -int pe_num;int m64_bars; phb =pci_bus_to_pnvhb (pdev->bus);
@@ -359,49 +451,28 @@ static int pnv_pci_vf_assign_m64(struct pci_dev *pdev, u16 num_vfs) }while (test_and_set_bit (win, &phb->ioda.m64_bar_alloc));set_bit (win, iov->used_m64_bar_mask); +if (iov->m64_single_mode) { size =pci_iov_resource_size (pdev,PCI_IOV_RESOURCES + i); start = res->start + size * j; + rc =pnv_ioda_map_m64_single (phb, win, + iov->pe_num_map[j], + start, + size); }else { size =resource_size (res); start = res->start; - } -/* Map the M64 here */ -if (iov->m64_single_mode) { - pe_num = iov->pe_num_map[j]; - rc =opal_pci_map_pe_mmio_window (phb->opal_id, - pe_num,OPAL_M64_WINDOW_TYPE , - win,0 ); + rc =pnv_ioda_map_m64_segmented (phb, win, start, + size); } - rc =opal_pci_set_phb_mem_window (phb->opal_id, -OPAL_M64_WINDOW_TYPE , - win, - start, -0 ,/* unused */ - size); - -if (rc !=OPAL_SUCCESS ) {dev_err (&pdev->dev,"Failed to map M64 window #%d: %lld\n" , win, rc); goto m64_failed; } - -if (iov->m64_single_mode) - rc =opal_pci_phb_mmio_enable (phb->opal_id, -OPAL_M64_WINDOW_TYPE , win,2 ); -else - rc =opal_pci_phb_mmio_enable (phb->opal_id, -OPAL_M64_WINDOW_TYPE , win,1 ); - -if (rc !=OPAL_SUCCESS ) { -dev_err (&pdev->dev,"Failed to enable M64 window #%d: %llx\n" , - win, rc); - goto m64_failed; - } } }return 0 ;
Signature · 1 line
2.26.2
PATCH v2 10/16 powerpc/powernv/pci: Refactor pnv_ioda_alloc_pe()
In reply to Oliver O'HalloranRework the PE allocation logic to allow allocating blocks of PEs rather than individually. We'll use this to allocate contigious blocks of PEs for the SR-IOVs.
This patch also adds code to pnv_ioda_alloc_pe() and pnv_ioda_reserve_pe() to use the existing, but unused, phb->pe_alloc_mutex. Currently these functions use atomic bit ops to release a currently allocated PE number. However, the pnv_ioda_alloc_pe() wants to have exclusive access to the bit map while scanning for hole large enough to accomodate the allocation size.
---
v2: Add some details about the pe_alloc mutex and why we're using it.
--- arch/powerpc/platforms/powernv/pci-ioda.c | 41 ++++++++++++++++++----- arch/powerpc/platforms/powernv/pci.h | 2 +- 2 files changed, 34 insertions(+), 9 deletions(-)
arch/powerpc/platforms/powernv/pci-ioda.c +33 -8
@@ -145,23 +145,45 @@ static void pnv_ioda_reserve_pe(struct pnv_phb *phb, int pe_no)return ; } +mutex_lock (&phb->ioda.pe_alloc_mutex);if (test_and_set_bit (pe_no, phb->ioda.pe_alloc))pr_debug ("%s: PE %x was reserved on PHB#%x\n" , __func__, pe_no, phb->hose->global_number); +mutex_unlock (&phb->ioda.pe_alloc_mutex);pnv_ioda_init_pe (phb, pe_no); } -struct pnv_ioda_pe *pnv_ioda_alloc_pe (struct pnv_phb *phb) +struct pnv_ioda_pe *pnv_ioda_alloc_pe (struct pnv_phb *phb,int count) { -long pe; +struct pnv_ioda_pe *ret =NULL ; +int run =0 , pe, i; +mutex_lock (&phb->ioda.pe_alloc_mutex); + +/* scan backwards for a run of @count cleared bits */ for (pe = phb->ioda.total_pe_num -1 ; pe >=0 ; pe--) { -if (!test_and_set_bit (pe, phb->ioda.pe_alloc)) -return pnv_ioda_init_pe (phb, pe); +if (test_bit (pe, phb->ioda.pe_alloc)) { + run =0 ; +continue ; + } + + run++; +if (run == count) +break ; } +if (run != count) + goto out; -return NULL ; +for (i = pe; i < pe + count; i++) { +set_bit (i, phb->ioda.pe_alloc); +pnv_ioda_init_pe (phb, i); + } + ret = &phb->ioda.pe_array[pe]; + +out: +mutex_unlock (&phb->ioda.pe_alloc_mutex); +return ret; }void pnv_ioda_free_pe (struct pnv_ioda_pe *pe)
@@ -173,7 +195,10 @@ void pnv_ioda_free_pe(struct pnv_ioda_pe *pe)WARN_ON (pe->npucomp);/* NPUs for nvlink are not supposed to be freed */ kfree (pe->npucomp);memset (pe,0 ,sizeof (struct pnv_ioda_pe )); + +mutex_lock (&phb->ioda.pe_alloc_mutex);clear_bit (pe_num, phb->ioda.pe_alloc); +mutex_unlock (&phb->ioda.pe_alloc_mutex); }/* The default M64 BAR is shared by all PEs */
@@ -976,7 +1001,7 @@ static struct pnv_ioda_pe *pnv_ioda_setup_dev_PE(struct pci_dev *dev)if (pdn->pe_number !=IODA_INVALID_PE )return NULL ; - pe =pnv_ioda_alloc_pe (phb); + pe =pnv_ioda_alloc_pe (phb,1 );if (!pe) {pr_warn ("%s: Not enough PE# available, disabling device\n" ,pci_name (dev));
@@ -1047,7 +1072,7 @@ static struct pnv_ioda_pe *pnv_ioda_setup_bus_PE(struct pci_bus *bus, bool all)/* The PE number isn't pinned by M64 */ if (!pe) - pe =pnv_ioda_alloc_pe (phb); + pe =pnv_ioda_alloc_pe (phb,1 );if (!pe) { pr_warn("%s: Not enough PE# available for PCI bus %04x:%02x\n",
@@ -3065,7 +3090,7 @@ static void __init pnv_pci_init_ioda_phb(struct device_node *np,pnv_ioda_reserve_pe (phb, phb->ioda.root_pe_idx); }else {/* otherwise just allocate one */ - root_pe =pnv_ioda_alloc_pe (phb); + root_pe =pnv_ioda_alloc_pe (phb,1 ); phb->ioda.root_pe_idx = root_pe->pe_number; }
arch/powerpc/platforms/powernv/pci.h +1 -1
@@ -224,7 +224,7 @@ int pnv_ioda_deconfigure_pe(struct pnv_phb *phb, struct pnv_ioda_pe *pe);void pnv_pci_ioda2_setup_dma_pe (struct pnv_phb *phb,struct pnv_ioda_pe *pe);void pnv_pci_ioda2_release_pe_dma (struct pnv_ioda_pe *pe); -struct pnv_ioda_pe *pnv_ioda_alloc_pe (struct pnv_phb *phb); +struct pnv_ioda_pe *pnv_ioda_alloc_pe (struct pnv_phb *phb,int count);void pnv_ioda_free_pe (struct pnv_ioda_pe *pe);#ifdef CONFIG_PCI_IOV
Signature · 1 line
2.26.2
Re: [PATCH v2 10/16] powerpc/powernv/pci: Refactor pnv_ioda_alloc_pe()
Quoted 10 lines · Oliver O'Halloran
Rework the PE allocation logic to allow allocating blocks of PEs rather than individually. We'll use this to allocate contigious blocks of PEs for the SR-IOVs.
This patch also adds code to
pnv_ioda_alloc_pe()andpnv_ioda_reserve_pe()to use the existing, but unused,phb->pe_alloc_mutex. Currently these functions use atomic bit ops to release a currently allocated PE number. However, thepnv_ioda_alloc_pe()wants to have exclusive access to the bit map while scanning for hole large enough to accomodate the allocation size.
Quoted 3 lines
Signed-off-by Oliver O'Halloran <[email protected]>---
v2: Add some details about thepe_allocmutex and why we're using it.
Quoted 112 lines
--- arch/powerpc/platforms/powernv/pci-ioda.c | 41 ++++++++++++++++++----- arch/powerpc/platforms/powernv/pci.h | 2 +- 2 files changed, 34 insertions(+), 9 deletions(-)arch/powerpc/platforms/powernv/pci-ioda.c +33
-8@@ -145,23 +145,45 @@ static void pnv_ioda_reserve_pe(struct pnv_phb *phb, int pe_no)return ; } +mutex_lock (&phb->ioda.pe_alloc_mutex);if (test_and_set_bit (pe_no, phb->ioda.pe_alloc))pr_debug ("%s: PE %x was reserved on PHB#%x\n" , __func__, pe_no, phb->hose->global_number); +mutex_unlock (&phb->ioda.pe_alloc_mutex);pnv_ioda_init_pe (phb, pe_no); } -struct pnv_ioda_pe *pnv_ioda_alloc_pe (struct pnv_phb *phb) +struct pnv_ioda_pe *pnv_ioda_alloc_pe (struct pnv_phb *phb,int count) { -long pe; +struct pnv_ioda_pe *ret =NULL ; +int run =0 , pe, i; +mutex_lock (&phb->ioda.pe_alloc_mutex); + +/* scan backwards for a run of @count cleared bits */ for (pe = phb->ioda.total_pe_num -1 ; pe >=0 ; pe--) { -if (!test_and_set_bit (pe, phb->ioda.pe_alloc)) -return pnv_ioda_init_pe (phb, pe); +if (test_bit (pe, phb->ioda.pe_alloc)) { + run =0 ; +continue ; + } + + run++; +if (run == count) +break ; } +if (run != count) + goto out; -return NULL ; +for (i = pe; i < pe + count; i++) { +set_bit (i, phb->ioda.pe_alloc); +pnv_ioda_init_pe (phb, i); + } + ret = &phb->ioda.pe_array[pe]; + +out: +mutex_unlock (&phb->ioda.pe_alloc_mutex); +return ret; }void pnv_ioda_free_pe (struct pnv_ioda_pe *pe)@@ -173,7 +195,10 @@ void pnv_ioda_free_pe(struct pnv_ioda_pe *pe)WARN_ON (pe->npucomp);/* NPUs for nvlink are not supposed to be freed */ kfree (pe->npucomp);memset (pe,0 ,sizeof (struct pnv_ioda_pe )); + +mutex_lock (&phb->ioda.pe_alloc_mutex);clear_bit (pe_num, phb->ioda.pe_alloc); +mutex_unlock (&phb->ioda.pe_alloc_mutex); }/* The default M64 BAR is shared by all PEs */ @@ -976,7 +1001,7 @@ static struct pnv_ioda_pe *pnv_ioda_setup_dev_PE(struct pci_dev *dev)if (pdn->pe_number !=IODA_INVALID_PE )return NULL ; - pe =pnv_ioda_alloc_pe (phb); + pe =pnv_ioda_alloc_pe (phb,1 );if (!pe) {pr_warn ("%s: Not enough PE# available, disabling device\n" ,pci_name (dev));@@ -1047,7 +1072,7 @@ static struct pnv_ioda_pe *pnv_ioda_setup_bus_PE(struct pci_bus *bus, bool all)/* The PE number isn't pinned by M64 */ if (!pe) - pe =pnv_ioda_alloc_pe (phb); + pe =pnv_ioda_alloc_pe (phb,1 );if (!pe) { pr_warn("%s: Not enough PE# available for PCI bus %04x:%02x\n",@@ -3065,7 +3090,7 @@ static void __init pnv_pci_init_ioda_phb(struct device_node *np,pnv_ioda_reserve_pe (phb, phb->ioda.root_pe_idx); }else {/* otherwise just allocate one */ - root_pe =pnv_ioda_alloc_pe (phb); + root_pe =pnv_ioda_alloc_pe (phb,1 ); phb->ioda.root_pe_idx = root_pe->pe_number; }arch/powerpc/platforms/powernv/pci.h +1
-1@@ -224,7 +224,7 @@ int pnv_ioda_deconfigure_pe(struct pnv_phb *phb, struct pnv_ioda_pe *pe);void pnv_pci_ioda2_setup_dma_pe (struct pnv_phb *phb,struct pnv_ioda_pe *pe);void pnv_pci_ioda2_release_pe_dma (struct pnv_ioda_pe *pe); -struct pnv_ioda_pe *pnv_ioda_alloc_pe (struct pnv_phb *phb); +struct pnv_ioda_pe *pnv_ioda_alloc_pe (struct pnv_phb *phb,int count);void pnv_ioda_free_pe (struct pnv_ioda_pe *pe);#ifdef CONFIG_PCI_IOV
Signature · 1 line
Alexey
PATCH v2 11/16 powerpc/powernv/sriov: Drop iov->pe_num_map[]
In reply to Oliver O'HalloranCurrently the iov->pe_num_map[] does one of two things depending on whether single PE mode is being used or not. When it is, this contains an array which maps a vf_index to the corresponding PE number. When single PE mode is not being used this contains a scalar which is the base PE for the set of enabled VFs (for for VFn is base + n).
The array was necessary because when calling pnv_ioda_alloc_pe() there is no guarantee that the allocated PEs would be contigious. We can now allocate contigious blocks of PEs so this is no longer an issue. This allows us to drop the if (single_mode) {} .. else {} block scattered through the SR-IOV code which is a nice clean up.
This also fixes a bug in pnv_pci_sriov_disable() which is the non-atomic bitmap_clear() to manipulate the PE allocation map. Other users of the map assume it will be accessed with atomic ops.
---
v2: Added a note to the commit message about bitmap_clear()
--- arch/powerpc/platforms/powernv/pci-sriov.c | 109 +++++---------------- arch/powerpc/platforms/powernv/pci.h | 7 +- 2 files changed, 28 insertions(+), 88 deletions(-)
arch/powerpc/platforms/powernv/pci-sriov.c +22 -87
@@ -453,11 +453,13 @@ static int pnv_pci_vf_assign_m64(struct pci_dev *pdev, u16 num_vfs)if (iov->m64_single_mode) { +int pe_num = iov->vf_pe_arr[j].pe_number; + size =pci_iov_resource_size (pdev,PCI_IOV_RESOURCES + i); start = res->start + size * j; rc =pnv_ioda_map_m64_single (phb, win, - iov->pe_num_map[j], + pe_num, start, size); }else {
@@ -596,38 +598,24 @@ static int pnv_pci_vf_resource_shift(struct pci_dev *dev, int offset)static void pnv_pci_sriov_disable (struct pci_dev *pdev) { +u16 num_vfs, base_pe;struct pnv_phb *phb; -struct pnv_ioda_pe *pe;struct pnv_iov_data *iov; -u16 num_vfs, i; phb =pci_bus_to_pnvhb (pdev->bus); iov =pnv_iov_get (pdev); num_vfs = iov->num_vfs; + base_pe = iov->vf_pe_arr[0 ].pe_number;/* Release VF PEs */ pnv_ioda_release_vf_PE (pdev);if (phb->type ==PNV_PHB_IODA2 ) {if (!iov->m64_single_mode) -pnv_pci_vf_resource_shift (pdev, -*iov->pe_num_map); +pnv_pci_vf_resource_shift (pdev, -base_pe);/* Release M64 windows */ pnv_pci_vf_release_m64 (pdev, num_vfs); - -/* Release PE numbers */ -if (iov->m64_single_mode) { -for (i =0 ; i < num_vfs; i++) { -if (iov->pe_num_map[i] ==IODA_INVALID_PE ) -continue ; - - pe = &phb->ioda.pe_array[iov->pe_num_map[i]]; -pnv_ioda_free_pe (pe); - } - }else -bitmap_clear (phb->ioda.pe_alloc, *iov->pe_num_map, num_vfs); -/* Releasing pe_num_map */ -kfree (iov->pe_num_map); } }
@@ -653,13 +641,7 @@ static void pnv_ioda_setup_vf_PE(struct pci_dev *pdev, u16 num_vfs)int vf_bus =pci_iov_virtfn_bus (pdev, vf_index);struct pci_dn *vf_pdn; -if (iov->m64_single_mode) - pe_num = iov->pe_num_map[vf_index]; -else - pe_num = *iov->pe_num_map + vf_index; - - pe = &phb->ioda.pe_array[pe_num]; - pe->pe_number = pe_num; + pe = &iov->vf_pe_arr[vf_index]; pe->phb = phb; pe->flags =PNV_IODA_PE_VF ; pe->pbus =NULL ;
@@ -667,6 +649,7 @@ static void pnv_ioda_setup_vf_PE(struct pci_dev *pdev, u16 num_vfs) pe->mve_number =-1 ; pe->rid = (vf_bus <<8 ) | vf_devfn; + pe_num = pe->pe_number;pe_info (pe,"VF %04d:%02d:%02d.%d associated with PE#%x\n" ,pci_domain_nr (pdev->bus), pdev->bus->number,PCI_SLOT (vf_devfn),PCI_FUNC (vf_devfn), pe_num);
@@ -698,9 +681,9 @@ static void pnv_ioda_setup_vf_PE(struct pci_dev *pdev, u16 num_vfs)static int pnv_pci_sriov_enable (struct pci_dev *pdev,u16 num_vfs) { +struct pnv_ioda_pe *base_pe;struct pnv_iov_data *iov;struct pnv_phb *phb; -struct pnv_ioda_pe *pe;int ret;u16 i;
@@ -714,55 +697,14 @@ static int pnv_pci_sriov_enable(struct pci_dev *pdev, u16 num_vfs)return -ENOSPC ; } -/* -* When M64 BARs functions in Single PE mode, the number of VFs -* could be enabled must be less than the number of M64 BARs. -*/ -if (iov->m64_single_mode && num_vfs > phb->ioda.m64_bar_idx) { -dev_info (&pdev->dev,"Not enough M64 BAR for VFs\n" ); +/* allocate a contigious block of PEs for our VFs */ + base_pe =pnv_ioda_alloc_pe (phb, num_vfs); +if (!base_pe) { +pci_err (pdev,"Unable to allocate PEs for %d VFs\n" , num_vfs);return -EBUSY ; } -/* Allocating pe_num_map */ -if (iov->m64_single_mode) - iov->pe_num_map =kmalloc_array (num_vfs, -sizeof (*iov->pe_num_map), -GFP_KERNEL ); -else - iov->pe_num_map =kmalloc (sizeof (*iov->pe_num_map),GFP_KERNEL ); - -if (!iov->pe_num_map) -return -ENOMEM ; - -if (iov->m64_single_mode) -for (i =0 ; i < num_vfs; i++) - iov->pe_num_map[i] =IODA_INVALID_PE ; - -/* Calculate available PE for required VFs */ -if (iov->m64_single_mode) { -for (i =0 ; i < num_vfs; i++) { - pe =pnv_ioda_alloc_pe (phb); -if (!pe) { - ret = -EBUSY ; - goto m64_failed; - } - - iov->pe_num_map[i] = pe->pe_number; - } - }else { -mutex_lock (&phb->ioda.pe_alloc_mutex); - *iov->pe_num_map =bitmap_find_next_zero_area ( - phb->ioda.pe_alloc, phb->ioda.total_pe_num, -0 , num_vfs,0 ); -if (*iov->pe_num_map >= phb->ioda.total_pe_num) { -mutex_unlock (&phb->ioda.pe_alloc_mutex); -dev_info (&pdev->dev,"Failed to enable VF%d\n" , num_vfs); -kfree (iov->pe_num_map); -return -EBUSY ; - } -bitmap_set (phb->ioda.pe_alloc, *iov->pe_num_map, num_vfs); -mutex_unlock (&phb->ioda.pe_alloc_mutex); - } + iov->vf_pe_arr = base_pe; iov->num_vfs = num_vfs;/* Assign M64 window accordingly */
@@ -778,9 +720,10 @@ static int pnv_pci_sriov_enable(struct pci_dev *pdev, u16 num_vfs)* Otherwise, the PE# for the VF will conflict with others. */ if (!iov->m64_single_mode) { - ret =pnv_pci_vf_resource_shift (pdev, *iov->pe_num_map); + ret =pnv_pci_vf_resource_shift (pdev, + base_pe->pe_number);if (ret) - goto m64_failed; + goto shift_failed; } }
@@ -789,20 +732,12 @@ static int pnv_pci_sriov_enable(struct pci_dev *pdev, u16 num_vfs)return 0 ; -m64_failed: -if (iov->m64_single_mode) { -for (i =0 ; i < num_vfs; i++) { -if (iov->pe_num_map[i] ==IODA_INVALID_PE ) -continue ; - - pe = &phb->ioda.pe_array[iov->pe_num_map[i]]; -pnv_ioda_free_pe (pe); - } - }else -bitmap_clear (phb->ioda.pe_alloc, *iov->pe_num_map, num_vfs); +shift_failed: +pnv_pci_vf_release_m64 (pdev, num_vfs); -/* Releasing pe_num_map */ -kfree (iov->pe_num_map); +m64_failed: +for (i =0 ; i < num_vfs; i++) +pnv_ioda_free_pe (&iov->vf_pe_arr[i]);return ret; }
arch/powerpc/platforms/powernv/pci.h +6 -1
@@ -239,7 +239,12 @@ struct pnv_iov_data {/* number of VFs enabled */ u16 num_vfs; -unsigned int *pe_num_map;/* PE# for the first VF PE or array */ + +/* +* Pointer to the IODA PE state of each VF. Note that this is a pointer +* into the PHB's PE array (phb->ioda.pe_array). +*/ +struct pnv_ioda_pe *vf_pe_arr;/* Did we map the VF BARs with single-PE IODA BARs? */ bool m64_single_mode;
Signature · 1 line
2.26.2
PATCH v2 12/16 powerpc/powernv/sriov: De-indent setup and teardown
In reply to Oliver O'HalloranRemove the IODA2 PHB checks. We already assume IODA2 in several places so there's not much point in wrapping most of the setup and teardown process in an if block.
---
v2: Added a note that iov->vf_pe_arr is a pointer into the PHB's PE array
rather than something we allocate.
--- arch/powerpc/platforms/powernv/pci-sriov.c | 86 ++++++++++++---------- arch/powerpc/platforms/powernv/pci.h | 5 +- 2 files changed, 50 insertions(+), 41 deletions(-)
arch/powerpc/platforms/powernv/pci-sriov.c +49 -37
@@ -607,16 +607,18 @@ static void pnv_pci_sriov_disable(struct pci_dev *pdev) num_vfs = iov->num_vfs; base_pe = iov->vf_pe_arr[0 ].pe_number; +if (WARN_ON (!iov)) +return ; +/* Release VF PEs */ pnv_ioda_release_vf_PE (pdev); -if (phb->type ==PNV_PHB_IODA2 ) { -if (!iov->m64_single_mode) -pnv_pci_vf_resource_shift (pdev, -base_pe); +/* Un-shift the IOV BAR resources */ +if (!iov->m64_single_mode) +pnv_pci_vf_resource_shift (pdev, -base_pe); -/* Release M64 windows */ -pnv_pci_vf_release_m64 (pdev, num_vfs); - } +/* Release M64 windows */ +pnv_pci_vf_release_m64 (pdev, num_vfs); }static void pnv_ioda_setup_vf_PE (struct pci_dev *pdev,u16 num_vfs)
@@ -690,41 +692,51 @@ static int pnv_pci_sriov_enable(struct pci_dev *pdev, u16 num_vfs) phb =pci_bus_to_pnvhb (pdev->bus); iov =pnv_iov_get (pdev); -if (phb->type ==PNV_PHB_IODA2 ) { -if (!iov->vfs_expanded) { -dev_info (&pdev->dev,"don't support this SRIOV device" -" with non 64bit-prefetchable IOV BAR\n" ); -return -ENOSPC ; - } +/* +* There's a calls to IODA2 PE setup code littered throughout. We could +* probably fix that, but we'd still have problems due to the +* restriction inherent on IODA1 PHBs. +* +* NB: We class IODA3 as IODA2 since they're very similar. +*/ +if (phb->type !=PNV_PHB_IODA2 ) { +pci_err (pdev,"SR-IOV is not supported on this PHB\n" ); +return -ENXIO ; + } -/* allocate a contigious block of PEs for our VFs */ - base_pe =pnv_ioda_alloc_pe (phb, num_vfs); -if (!base_pe) { -pci_err (pdev,"Unable to allocate PEs for %d VFs\n" , num_vfs); -return -EBUSY ; - } +if (!iov->vfs_expanded) { +dev_info (&pdev->dev,"don't support this SRIOV device" +" with non 64bit-prefetchable IOV BAR\n" ); +return -ENOSPC ; + } - iov->vf_pe_arr = base_pe; - iov->num_vfs = num_vfs; +/* allocate a contigious block of PEs for our VFs */ + base_pe =pnv_ioda_alloc_pe (phb, num_vfs); +if (!base_pe) { +pci_err (pdev,"Unable to allocate PEs for %d VFs\n" , num_vfs); +return -EBUSY ; + } -/* Assign M64 window accordingly */ - ret =pnv_pci_vf_assign_m64 (pdev, num_vfs); -if (ret) { -dev_info (&pdev->dev,"Not enough M64 window resources\n" ); - goto m64_failed; - } + iov->vf_pe_arr = base_pe; + iov->num_vfs = num_vfs; -/* -* When using one M64 BAR to map one IOV BAR, we need to shift -* the IOV BAR according to the PE# allocated to the VFs. -* Otherwise, the PE# for the VF will conflict with others. -*/ -if (!iov->m64_single_mode) { - ret =pnv_pci_vf_resource_shift (pdev, - base_pe->pe_number); -if (ret) - goto shift_failed; - } +/* Assign M64 window accordingly */ + ret =pnv_pci_vf_assign_m64 (pdev, num_vfs); +if (ret) { +dev_info (&pdev->dev,"Not enough M64 window resources\n" ); + goto m64_failed; + } + +/* +* When using one M64 BAR to map one IOV BAR, we need to shift +* the IOV BAR according to the PE# allocated to the VFs. +* Otherwise, the PE# for the VF will conflict with others. +*/ +if (!iov->m64_single_mode) { + ret =pnv_pci_vf_resource_shift (pdev, + base_pe->pe_number); +if (ret) + goto shift_failed; }/* Setup VF PEs */
arch/powerpc/platforms/powernv/pci.h +1 -4
@@ -240,10 +240,7 @@ struct pnv_iov_data {/* number of VFs enabled */ u16 num_vfs; -/* -* Pointer to the IODA PE state of each VF. Note that this is a pointer -* into the PHB's PE array (phb->ioda.pe_array). -*/ +/* pointer to the array of VF PEs. num_vfs long*/ struct pnv_ioda_pe *vf_pe_arr;/* Did we map the VF BARs with single-PE IODA BARs? */
Signature · 1 line
2.26.2
PATCH v2 13/16 powerpc/powernv/sriov: Move M64 BAR allocation into a helper
In reply to Oliver O'HalloranI want to refactor the loop this code is currently inside of. Hoist it on out.
---
v2: no change
--- arch/powerpc/platforms/powernv/pci-sriov.c | 31 ++++++++++++++-------- 1 file changed, 20 insertions(+), 11 deletions(-)
arch/powerpc/platforms/powernv/pci-sriov.c +20 -11
@@ -413,6 +413,23 @@ static int64_t pnv_ioda_map_m64_single(struct pnv_phb *phb,return rc; } +static int pnv_pci_alloc_m64_bar (struct pnv_phb *phb,struct pnv_iov_data *iov) +{ +int win; + +do { + win =find_next_zero_bit (&phb->ioda.m64_bar_alloc, + phb->ioda.m64_bar_idx +1 ,0 ); + +if (win >= phb->ioda.m64_bar_idx +1 ) +return -1 ; + }while (test_and_set_bit (win, &phb->ioda.m64_bar_alloc)); + +set_bit (win, iov->used_m64_bar_mask); + +return win; +} +static int pnv_pci_vf_assign_m64 (struct pci_dev *pdev,u16 num_vfs) {struct pnv_iov_data *iov;
@@ -440,17 +457,9 @@ static int pnv_pci_vf_assign_m64(struct pci_dev *pdev, u16 num_vfs)continue ;for (j =0 ; j < m64_bars; j++) { - -/* allocate a window ID for this BAR */ -do { - win =find_next_zero_bit (&phb->ioda.m64_bar_alloc, - phb->ioda.m64_bar_idx +1 ,0 ); - -if (win >= phb->ioda.m64_bar_idx +1 ) - goto m64_failed; - }while (test_and_set_bit (win, &phb->ioda.m64_bar_alloc)); -set_bit (win, iov->used_m64_bar_mask); - + win =pnv_pci_alloc_m64_bar (phb, iov); +if (win <0 ) + goto m64_failed;if (iov->m64_single_mode) {int pe_num = iov->vf_pe_arr[j].pe_number;
Signature · 1 line
2.26.2
PATCH v2 14/16 powerpc/powernv/sriov: Refactor M64 BAR setup
In reply to Oliver O'HalloranSplit up the logic so that we have one branch that handles setting up a segmented window and another that handles setting up single PE windows for each VF.
---
v2: no changes
--- arch/powerpc/platforms/powernv/pci-sriov.c | 57 ++++++++++------------ 1 file changed, 27 insertions(+), 30 deletions(-)
arch/powerpc/platforms/powernv/pci-sriov.c +27 -30
@@ -438,52 +438,49 @@ static int pnv_pci_vf_assign_m64(struct pci_dev *pdev, u16 num_vfs)struct resource *res;int i, j;int64_t rc; -int total_vfs;resource_size_t size, start; -int m64_bars; +int base_pe_num; phb =pci_bus_to_pnvhb (pdev->bus); iov =pnv_iov_get (pdev); - total_vfs =pci_sriov_get_totalvfs (pdev); - -if (iov->m64_single_mode) - m64_bars = num_vfs; -else - m64_bars =1 ;for (i =0 ; i <PCI_SRIOV_NUM_BARS ; i++) { res = &pdev->resource[i +PCI_IOV_RESOURCES ];if (!res->flags || !res->parent)continue ; -for (j =0 ; j < m64_bars; j++) { +/* don't need single mode? map everything in one go! */ +if (!iov->m64_single_mode) { win =pnv_pci_alloc_m64_bar (phb, iov);if (win <0 ) goto m64_failed; -if (iov->m64_single_mode) { -int pe_num = iov->vf_pe_arr[j].pe_number; - - size =pci_iov_resource_size (pdev, -PCI_IOV_RESOURCES + i); - start = res->start + size * j; - rc =pnv_ioda_map_m64_single (phb, win, - pe_num, - start, - size); - }else { - size =resource_size (res); - start = res->start; - - rc =pnv_ioda_map_m64_segmented (phb, win, start, - size); - } + size =resource_size (res); + start = res->start; -if (rc !=OPAL_SUCCESS ) { -dev_err (&pdev->dev,"Failed to map M64 window #%d: %lld\n" , - win, rc); + rc =pnv_ioda_map_m64_segmented (phb, win, start, size); +if (rc) + goto m64_failed; + +continue ; + } + +/* otherwise map each VF with single PE BARs */ + size =pci_iov_resource_size (pdev,PCI_IOV_RESOURCES + i); + base_pe_num = iov->vf_pe_arr[0 ].pe_number; + +for (j =0 ; j < num_vfs; j++) { + win =pnv_pci_alloc_m64_bar (phb, iov); +if (win <0 ) + goto m64_failed; + + start = res->start + size * j; + rc =pnv_ioda_map_m64_single (phb, win, + base_pe_num + j, + start, + size); +if (rc) goto m64_failed; - } } }return 0 ;
Signature · 1 line
2.26.2
PATCH v2 15/16 powerpc/powernv/sriov: Make single PE mode a per-BAR setting
In reply to Oliver O'HalloranUsing single PE BARs to map an SR-IOV BAR is really a choice about what strategy to use when mapping a BAR. It doesn't make much sense for this to be a global setting since a device might have one large BAR which needs to be mapped with single PE windows and another smaller BAR that can be mapped with a regular segmented window. Make the segmented vs single decision a per-BAR setting and clean up the logic that decides which mode to use.
---
v2: Dropped unused total_vfs variables in pnv_pci_ioda_fixup_iov_resources()
Dropped bar_no from pnv_pci_iov_resource_alignment()
Minor re-wording of comments.
--- arch/powerpc/platforms/powernv/pci-sriov.c | 131 ++++++++++----------- arch/powerpc/platforms/powernv/pci.h | 11 +- 2 files changed, 73 insertions(+), 69 deletions(-)
arch/powerpc/platforms/powernv/pci-sriov.c +64 -67
@@ -146,21 +146,17 @@static void pnv_pci_ioda_fixup_iov_resources (struct pci_dev *pdev) {struct pnv_phb *phb =pci_bus_to_pnvhb (pdev->bus); -const resource_size_t gate = phb->ioda.m64_segsize >>2 ;struct resource *res;int i; -resource_size_t size, total_vf_bar_sz; +resource_size_t vf_bar_sz;struct pnv_iov_data *iov; -int mul, total_vfs; +int mul; iov =kzalloc (sizeof (*iov),GFP_KERNEL );if (!iov) goto disable_iov; pdev->dev.archdata.iov_data = iov; - - total_vfs =pci_sriov_get_totalvfs (pdev); mul = phb->ioda.total_pe_num; - total_vf_bar_sz =0 ;for (i =0 ; i <PCI_SRIOV_NUM_BARS ; i++) { res = &pdev->resource[i +PCI_IOV_RESOURCES ];
@@ -173,50 +169,50 @@ static void pnv_pci_ioda_fixup_iov_resources(struct pci_dev *pdev) goto disable_iov; } - total_vf_bar_sz +=pci_iov_resource_size (pdev, - i +PCI_IOV_RESOURCES ); + vf_bar_sz =pci_iov_resource_size (pdev, i +PCI_IOV_RESOURCES );/* -* If bigger than quarter of M64 segment size, just round up -* power of two. +* Generally, one segmented M64 BAR maps one IOV BAR. However, +* if a VF BAR is too large we end up wasting a lot of space. +* If each VF needs more than 1/4 of the default m64 segment +* then each VF BAR should be mapped in single-PE mode to reduce +* the amount of space required. This does however limit the +* number of VFs we can support. * -* Generally, one M64 BAR maps one IOV BAR. To avoid conflict -* with other devices, IOV BAR size is expanded to be -* (total_pe * VF_BAR_size). When VF_BAR_size is half of M64 -* segment size , the expanded size would equal to half of the -* whole M64 space size, which will exhaust the M64 Space and -* limit the system flexibility. This is a design decision to -* set the boundary to quarter of the M64 segment size. +* The 1/4 limit is arbitrary and can be tweaked. */ -if (total_vf_bar_sz > gate) { - mul =roundup_pow_of_two (total_vfs); -dev_info (&pdev->dev, -"VF BAR Total IOV size %llx > %llx, roundup to %d VFs\n" , - total_vf_bar_sz, gate, mul); - iov->m64_single_mode = true; -break ; - } - } +if (vf_bar_sz > (phb->ioda.m64_segsize >>2 )) { +/* +* On PHB3, the minimum size alignment of M64 BAR in +* single mode is 32MB. If this VF BAR is smaller than +* 32MB, but still too large for a segmented window +* then we can't map it and need to disable SR-IOV for +* this device. +*/ +if (vf_bar_sz <SZ_32M ) { +pci_err (pdev,"VF BAR%d: %pR can't be mapped in single PE mode\n" , + i, res); + goto disable_iov; + } -for (i =0 ; i <PCI_SRIOV_NUM_BARS ; i++) { - res = &pdev->resource[i +PCI_IOV_RESOURCES ]; -if (!res->flags || res->parent) + iov->m64_single_mode[i] = true;continue ; + } - size =pci_iov_resource_size (pdev, i +PCI_IOV_RESOURCES );/* -* On PHB3, the minimum size alignment of M64 BAR in single -* mode is 32MB. +* This BAR can be mapped with one segmented window, so adjust +* te resource size to accommodate. */ -if (iov->m64_single_mode && (size <SZ_32M )) - goto disable_iov; +pci_dbg (pdev," Fixing VF BAR%d: %pR to\n" , i, res); + res->end = res->start + vf_bar_sz * mul -1 ; +pci_dbg (pdev," %pR\n" , res); -dev_dbg (&pdev->dev," Fixing VF BAR%d: %pR to\n" , i, res); - res->end = res->start + size * mul -1 ; -dev_dbg (&pdev->dev," %pR\n" , res); -dev_info (&pdev->dev,"VF BAR%d: %pR (expanded to %d VFs for PE alignment)" , +pci_info (pdev,"VF BAR%d: %pR (expanded to %d VFs for PE alignment)" , i, res, mul); + + iov->need_shift = true; } + iov->vfs_expanded = mul;return ;
@@ -260,42 +256,40 @@ void pnv_pci_ioda_fixup_iov(struct pci_dev *pdev)resource_size_t pnv_pci_iov_resource_alignment (struct pci_dev *pdev,int resno) { -struct pnv_phb *phb =pci_bus_to_pnvhb (pdev->bus);struct pnv_iov_data *iov =pnv_iov_get (pdev);resource_size_t align; +/* +* iov can be null if we have an SR-IOV device with IOV BAR that can't +* be placed in the m64 space (i.e. The BAR is 32bit or non-prefetch). +* In that case we don't allow VFs to be enabled since one of their +* BARs would not be placed in the correct PE. +*/ +if (!iov) +return align; +if (!iov->vfs_expanded) +return align; + + align =pci_iov_resource_size (pdev, resno); + +/* +* If we're using single mode then we can just use the native VF BAR +* alignment. We validated that it's possible to use a single PE +* window above when we did the fixup. +*/ +if (iov->m64_single_mode[resno -PCI_IOV_RESOURCES ]) +return align; +/* * On PowerNV platform, IOV BAR is mapped by M64 BAR to enable the * SR-IOV. While from hardware perspective, the range mapped by M64 * BAR should be size aligned. * -* When IOV BAR is mapped with M64 BAR in Single PE mode, the extra -* powernv-specific hardware restriction is gone. But if just use the -* VF BAR size as the alignment, PF BAR / VF BAR may be allocated with -* in one segment of M64 #15, which introduces the PE conflict between -* PF and VF. Based on this, the minimum alignment of an IOV BAR is -* m64_segsize. -* * This function returns the total IOV BAR size if M64 BAR is in * Shared PE mode or just VF BAR size if not. * If the M64 BAR is in Single PE mode, return the VF BAR size or * M64 segment size if IOV BAR size is less. */ - align =pci_iov_resource_size (pdev, resno); - -/* -* iov can be null if we have an SR-IOV device with IOV BAR that can't -* be placed in the m64 space (i.e. The BAR is 32bit or non-prefetch). -* In that case we don't allow VFs to be enabled so just return the -* default alignment. -*/ -if (!iov) -return align; -if (!iov->vfs_expanded) -return align; -if (iov->m64_single_mode) -return max (align, (resource_size_t )phb->ioda.m64_segsize); -return iov->vfs_expanded * align; }
@@ -450,7 +444,7 @@ static int pnv_pci_vf_assign_m64(struct pci_dev *pdev, u16 num_vfs)continue ;/* don't need single mode? map everything in one go! */ -if (!iov->m64_single_mode) { +if (!iov->m64_single_mode[i]) { win =pnv_pci_alloc_m64_bar (phb, iov);if (win <0 ) goto m64_failed;
@@ -543,6 +537,8 @@ static int pnv_pci_vf_resource_shift(struct pci_dev *dev, int offset) res = &dev->resource[i +PCI_IOV_RESOURCES ];if (!res->flags || !res->parent)continue ; +if (iov->m64_single_mode[i]) +continue ;/* * The actual IOV BAR range is determined by the start address
@@ -574,6 +570,8 @@ static int pnv_pci_vf_resource_shift(struct pci_dev *dev, int offset) res = &dev->resource[i +PCI_IOV_RESOURCES ];if (!res->flags || !res->parent)continue ; +if (iov->m64_single_mode[i]) +continue ; size =pci_iov_resource_size (dev, i +PCI_IOV_RESOURCES ); res2 = *res;
@@ -619,8 +617,8 @@ static void pnv_pci_sriov_disable(struct pci_dev *pdev)/* Release VF PEs */ pnv_ioda_release_vf_PE (pdev); -/* Un-shift the IOV BAR resources */ -if (!iov->m64_single_mode) +/* Un-shift the IOV BARs if we need to */ +if (iov->need_shift)pnv_pci_vf_resource_shift (pdev, -base_pe);/* Release M64 windows */
@@ -738,9 +736,8 @@ static int pnv_pci_sriov_enable(struct pci_dev *pdev, u16 num_vfs)* the IOV BAR according to the PE# allocated to the VFs. * Otherwise, the PE# for the VF will conflict with others. */ -if (!iov->m64_single_mode) { - ret =pnv_pci_vf_resource_shift (pdev, - base_pe->pe_number); +if (iov->need_shift) { + ret =pnv_pci_vf_resource_shift (pdev, base_pe->pe_number);if (ret) goto shift_failed; }
arch/powerpc/platforms/powernv/pci.h +9 -2
@@ -243,8 +243,15 @@ struct pnv_iov_data {/* pointer to the array of VF PEs. num_vfs long*/ struct pnv_ioda_pe *vf_pe_arr; -/* Did we map the VF BARs with single-PE IODA BARs? */ -bool m64_single_mode; +/* Did we map the VF BAR with single-PE IODA BARs? */ +bool m64_single_mode[PCI_SRIOV_NUM_BARS ]; + +/* +* True if we're using any segmented windows. In that case we need +* shift the start of the IOV resource the segment corresponding to +* the allocated PE. +*/ +bool need_shift;/* * Bit mask used to track which m64 windows are used to map the
Signature · 1 line
2.26.2
Re: [PATCH v2 15/16] powerpc/powernv/sriov: Make single PE mode a per-BAR setting
Quoted 138 lines · Oliver O'Halloran
Using single PE BARs to map an SR-IOV BAR is really a choice about what strategy to use when mapping a BAR. It doesn't make much sense for this to be a global setting since a device might have one large BAR which needs to be mapped with single PE windows and another smaller BAR that can be mapped with a regular segmented window. Make the segmented vs single decision a per-BAR setting and clean up the logic that decides which mode to use.
Signed-off-by Oliver O'Halloran <[email protected]>---
v2: Dropped unusedtotal_vfsvariables inpnv_pci_ioda_fixup_iov_resources()
Droppedbar_nofrompnv_pci_iov_resource_alignment()
Minor re-wording of comments.--- arch/powerpc/platforms/powernv/pci-sriov.c | 131 ++++++++++----------- arch/powerpc/platforms/powernv/pci.h | 11 +- 2 files changed, 73 insertions(+), 69 deletions(-)arch/powerpc/platforms/powernv/pci-sriov.c +36
-39@@ -146,21 +146,17 @@static void pnv_pci_ioda_fixup_iov_resources (struct pci_dev *pdev) {struct pnv_phb *phb =pci_bus_to_pnvhb (pdev->bus); -const resource_size_t gate = phb->ioda.m64_segsize >>2 ;struct resource *res;int i; -resource_size_t size, total_vf_bar_sz; +resource_size_t vf_bar_sz;struct pnv_iov_data *iov; -int mul, total_vfs; +int mul; iov =kzalloc (sizeof (*iov),GFP_KERNEL );if (!iov) goto disable_iov; pdev->dev.archdata.iov_data = iov; - - total_vfs =pci_sriov_get_totalvfs (pdev); mul = phb->ioda.total_pe_num; - total_vf_bar_sz =0 ;for (i =0 ; i <PCI_SRIOV_NUM_BARS ; i++) { res = &pdev->resource[i +PCI_IOV_RESOURCES ];@@ -173,50 +169,50 @@ static void pnv_pci_ioda_fixup_iov_resources(struct pci_dev *pdev) goto disable_iov; } - total_vf_bar_sz +=pci_iov_resource_size (pdev, - i +PCI_IOV_RESOURCES ); + vf_bar_sz =pci_iov_resource_size (pdev, i +PCI_IOV_RESOURCES );/* -* If bigger than quarter of M64 segment size, just round up -* power of two. +* Generally, one segmented M64 BAR maps one IOV BAR. However, +* if a VF BAR is too large we end up wasting a lot of space. +* If each VF needs more than 1/4 of the default m64 segment +* then each VF BAR should be mapped in single-PE mode to reduce +* the amount of space required. This does however limit the +* number of VFs we can support. * -* Generally, one M64 BAR maps one IOV BAR. To avoid conflict -* with other devices, IOV BAR size is expanded to be -* (total_pe * VF_BAR_size). When VF_BAR_size is half of M64 -* segment size , the expanded size would equal to half of the -* whole M64 space size, which will exhaust the M64 Space and -* limit the system flexibility. This is a design decision to -* set the boundary to quarter of the M64 segment size. +* The 1/4 limit is arbitrary and can be tweaked. */ -if (total_vf_bar_sz > gate) { - mul =roundup_pow_of_two (total_vfs); -dev_info (&pdev->dev, -"VF BAR Total IOV size %llx > %llx, roundup to %d VFs\n" , - total_vf_bar_sz, gate, mul); - iov->m64_single_mode = true; -break ; - } - } +if (vf_bar_sz > (phb->ioda.m64_segsize >>2 )) { +/* +* On PHB3, the minimum size alignment of M64 BAR in +* single mode is 32MB. If this VF BAR is smaller than +* 32MB, but still too large for a segmented window +* then we can't map it and need to disable SR-IOV for +* this device. +*/ +if (vf_bar_sz <SZ_32M ) { +pci_err (pdev,"VF BAR%d: %pR can't be mapped in single PE mode\n" , + i, res); + goto disable_iov; + } -for (i =0 ; i <PCI_SRIOV_NUM_BARS ; i++) { - res = &pdev->resource[i +PCI_IOV_RESOURCES ]; -if (!res->flags || res->parent) + iov->m64_single_mode[i] = true;continue ; + } - size =pci_iov_resource_size (pdev, i +PCI_IOV_RESOURCES );/* -* On PHB3, the minimum size alignment of M64 BAR in single -* mode is 32MB. +* This BAR can be mapped with one segmented window, so adjust +* te resource size to accommodate. */ -if (iov->m64_single_mode && (size <SZ_32M )) - goto disable_iov; +pci_dbg (pdev," Fixing VF BAR%d: %pR to\n" , i, res); + res->end = res->start + vf_bar_sz * mul -1 ; +pci_dbg (pdev," %pR\n" , res); -dev_dbg (&pdev->dev," Fixing VF BAR%d: %pR to\n" , i, res); - res->end = res->start + size * mul -1 ; -dev_dbg (&pdev->dev," %pR\n" , res); -dev_info (&pdev->dev,"VF BAR%d: %pR (expanded to %d VFs for PE alignment)" , +pci_info (pdev,"VF BAR%d: %pR (expanded to %d VFs for PE alignment)" , i, res, mul); + + iov->need_shift = true; } + iov->vfs_expanded = mul;return ;@@ -260,42 +256,40 @@ void pnv_pci_ioda_fixup_iov(struct pci_dev *pdev)resource_size_t pnv_pci_iov_resource_alignment (struct pci_dev *pdev,int resno) { -struct pnv_phb *phb =pci_bus_to_pnvhb (pdev->bus);struct pnv_iov_data *iov =pnv_iov_get (pdev);resource_size_t align; +/* +* iov can be null if we have an SR-IOV device with IOV BAR that can't
arch/powerpc/platforms/powernv/pci-sriov.c void pnv_pci_ioda_fixup_iov(struct pci_dev *pdev) · line 273
Quoted 10 lines
arch/powerpc/platforms/powernv/pci-sriov.c +10
-0+* be placed in the m64 space (i.e. The BAR is 32bit or non-prefetch). +* In that case we don't allow VFs to be enabled since one of their +* BARs would not be placed in the correct PE. +*/ +if (!iov) +return align; +if (!iov->vfs_expanded) +return align; + + align =pci_iov_resource_size (pdev, resno);
I am not sure if it has been reported yet but clang points out that align is initialized after its use:
arch/powerpc/platforms/powernv/pci-sriov.c:267:10: warning: variable 'align' is uninitialized when used here [-Wuninitialized]
return align;
^~~~~
arch/powerpc/platforms/powernv/pci-sriov.c:258:23: note: initialize the variable 'align' to silence this warning
resource_size_t align;
^
= 01 warning generated.
Quoted 118 lines
arch/powerpc/platforms/powernv/pci-sriov.c +17
-28+/* +* If we're using single mode then we can just use the native VF BAR +* alignment. We validated that it's possible to use a single PE +* window above when we did the fixup. +*/ +if (iov->m64_single_mode[resno -PCI_IOV_RESOURCES ]) +return align; +/* * On PowerNV platform, IOV BAR is mapped by M64 BAR to enable the * SR-IOV. While from hardware perspective, the range mapped by M64 * BAR should be size aligned. * -* When IOV BAR is mapped with M64 BAR in Single PE mode, the extra -* powernv-specific hardware restriction is gone. But if just use the -* VF BAR size as the alignment, PF BAR / VF BAR may be allocated with -* in one segment of M64 #15, which introduces the PE conflict between -* PF and VF. Based on this, the minimum alignment of an IOV BAR is -* m64_segsize. -* * This function returns the total IOV BAR size if M64 BAR is in * Shared PE mode or just VF BAR size if not. * If the M64 BAR is in Single PE mode, return the VF BAR size or * M64 segment size if IOV BAR size is less. */ - align =pci_iov_resource_size (pdev, resno); - -/* -* iov can be null if we have an SR-IOV device with IOV BAR that can't -* be placed in the m64 space (i.e. The BAR is 32bit or non-prefetch). -* In that case we don't allow VFs to be enabled so just return the -* default alignment. -*/ -if (!iov) -return align; -if (!iov->vfs_expanded) -return align; -if (iov->m64_single_mode) -return max (align, (resource_size_t )phb->ioda.m64_segsize); -return iov->vfs_expanded * align; }@@ -450,7 +444,7 @@ static int pnv_pci_vf_assign_m64(struct pci_dev *pdev, u16 num_vfs)continue ;/* don't need single mode? map everything in one go! */ -if (!iov->m64_single_mode) { +if (!iov->m64_single_mode[i]) { win =pnv_pci_alloc_m64_bar (phb, iov);if (win <0 ) goto m64_failed;@@ -543,6 +537,8 @@ static int pnv_pci_vf_resource_shift(struct pci_dev *dev, int offset) res = &dev->resource[i +PCI_IOV_RESOURCES ];if (!res->flags || !res->parent)continue ; +if (iov->m64_single_mode[i]) +continue ;/* * The actual IOV BAR range is determined by the start address @@ -574,6 +570,8 @@ static int pnv_pci_vf_resource_shift(struct pci_dev *dev, int offset) res = &dev->resource[i +PCI_IOV_RESOURCES ];if (!res->flags || !res->parent)continue ; +if (iov->m64_single_mode[i]) +continue ; size =pci_iov_resource_size (dev, i +PCI_IOV_RESOURCES ); res2 = *res;@@ -619,8 +617,8 @@ static void pnv_pci_sriov_disable(struct pci_dev *pdev)/* Release VF PEs */ pnv_ioda_release_vf_PE (pdev); -/* Un-shift the IOV BAR resources */ -if (!iov->m64_single_mode) +/* Un-shift the IOV BARs if we need to */ +if (iov->need_shift)pnv_pci_vf_resource_shift (pdev, -base_pe);/* Release M64 windows */ @@ -738,9 +736,8 @@ static int pnv_pci_sriov_enable(struct pci_dev *pdev, u16 num_vfs)* the IOV BAR according to the PE# allocated to the VFs. * Otherwise, the PE# for the VF will conflict with others. */ -if (!iov->m64_single_mode) { - ret =pnv_pci_vf_resource_shift (pdev, - base_pe->pe_number); +if (iov->need_shift) { + ret =pnv_pci_vf_resource_shift (pdev, base_pe->pe_number);if (ret) goto shift_failed; }arch/powerpc/platforms/powernv/pci.h +9
-2@@ -243,8 +243,15 @@ struct pnv_iov_data {/* pointer to the array of VF PEs. num_vfs long*/ struct pnv_ioda_pe *vf_pe_arr; -/* Did we map the VF BARs with single-PE IODA BARs? */ -bool m64_single_mode; +/* Did we map the VF BAR with single-PE IODA BARs? */ +bool m64_single_mode[PCI_SRIOV_NUM_BARS ]; + +/* +* True if we're using any segmented windows. In that case we need +* shift the start of the IOV resource the segment corresponding to +* the allocated PE. +*/ +bool need_shift;/* * Bit mask used to track which m64 windows are used to map the Signature · 1 line
2.26.2
Michael Ellerman
reviewerRe: [PATCH v2 15/16] powerpc/powernv/sriov: Make single PE mode a per-BAR setting
Quoted 30 lines · Nathan Chancellor
Quoted 29 lines · Oliver O'Halloran
Using single PE BARs to map an SR-IOV BAR is really a choice about what strategy to use when mapping a BAR. It doesn't make much sense for this to be a global setting since a device might have one large BAR which needs to be mapped with single PE windows and another smaller BAR that can be mapped with a regular segmented window. Make the segmented vs single decision a per-BAR setting and clean up the logic that decides which mode to use.
Signed-off-by Oliver O'Halloran <[email protected]>---
v2: Dropped unusedtotal_vfsvariables inpnv_pci_ioda_fixup_iov_resources()
Droppedbar_nofrompnv_pci_iov_resource_alignment()
Minor re-wording of comments.--- arch/powerpc/platforms/powernv/pci-sriov.c | 131 ++++++++++----------- arch/powerpc/platforms/powernv/pci.h | 11 +- 2 files changed, 73 insertions(+), 69 deletions(-)arch/powerpc/platforms/powernv/pci-sriov.c +0
-1@@ -260,42 +256,40 @@ void pnv_pci_ioda_fixup_iov(struct pci_dev *pdev)resource_size_t pnv_pci_iov_resource_alignment (struct pci_dev *pdev,int resno) { -struct pnv_phb *phb =pci_bus_to_pnvhb (pdev->bus);struct pnv_iov_data *iov =pnv_iov_get (pdev);resource_size_t align;
Quoted 12 lines
arch/powerpc/platforms/powernv/pci-sriov.c void pnv_pci_ioda_fixup_iov(struct pci_dev *pdev) · line 273
Quoted 12 lines
arch/powerpc/platforms/powernv/pci-sriov.c +12
-0+/* +* iov can be null if we have an SR-IOV device with IOV BAR that can't +* be placed in the m64 space (i.e. The BAR is 32bit or non-prefetch). +* In that case we don't allow VFs to be enabled since one of their +* BARs would not be placed in the correct PE. +*/ +if (!iov) +return align; +if (!iov->vfs_expanded) +return align; + + align =pci_iov_resource_size (pdev, resno);
That's, oof.
Quoted 11 lines
I am not sure if it has been reported yet but clang points out that align is initialized after its use:
arch/powerpc/platforms/powernv/pci-sriov.c:267:10: warning: variable 'align' is uninitialized when used here [-Wuninitialized]return align; ^~~~~ arch/powerpc/platforms/powernv/pci-sriov.c:258:23: note: initialize the variable 'align' to silence this warning resource_size_t align; ^ = 01 warning generated.
But I can't get gcc to warn about it?
It produces some code, so it's not like the whole function has been elided or something. I'm confused.
cheers
Re: [PATCH v2 15/16] powerpc/powernv/sriov: Make single PE mode a per-BAR setting
Quoted 58 lines · Michael Ellerman
Quoted 30 lines · Nathan Chancellor
Quoted 29 lines · Oliver O'Halloran
Using single PE BARs to map an SR-IOV BAR is really a choice about what strategy to use when mapping a BAR. It doesn't make much sense for this to be a global setting since a device might have one large BAR which needs to be mapped with single PE windows and another smaller BAR that can be mapped with a regular segmented window. Make the segmented vs single decision a per-BAR setting and clean up the logic that decides which mode to use.
Signed-off-by Oliver O'Halloran <[email protected]>---
v2: Dropped unusedtotal_vfsvariables inpnv_pci_ioda_fixup_iov_resources()
Droppedbar_nofrompnv_pci_iov_resource_alignment()
Minor re-wording of comments.--- arch/powerpc/platforms/powernv/pci-sriov.c | 131 ++++++++++----------- arch/powerpc/platforms/powernv/pci.h | 11 +- 2 files changed, 73 insertions(+), 69 deletions(-)arch/powerpc/platforms/powernv/pci-sriov.c +0
-1@@ -260,42 +256,40 @@ void pnv_pci_ioda_fixup_iov(struct pci_dev *pdev)resource_size_t pnv_pci_iov_resource_alignment (struct pci_dev *pdev,int resno) { -struct pnv_phb *phb =pci_bus_to_pnvhb (pdev->bus);struct pnv_iov_data *iov =pnv_iov_get (pdev);resource_size_t align;Quoted 12 lines
arch/powerpc/platforms/powernv/pci-sriov.c void pnv_pci_ioda_fixup_iov(struct pci_dev *pdev) · line 273
Quoted 12 lines
arch/powerpc/platforms/powernv/pci-sriov.c +12
-0+/* +* iov can be null if we have an SR-IOV device with IOV BAR that can't +* be placed in the m64 space (i.e. The BAR is 32bit or non-prefetch). +* In that case we don't allow VFs to be enabled since one of their +* BARs would not be placed in the correct PE. +*/ +if (!iov) +return align; +if (!iov->vfs_expanded) +return align; + + align =pci_iov_resource_size (pdev, resno);That's, oof.
Quoted 11 lines
I am not sure if it has been reported yet but clang points out that align is initialized after its use:
arch/powerpc/platforms/powernv/pci-sriov.c:267:10: warning: variable 'align' is uninitialized when used here [-Wuninitialized]return align; ^~~~~ arch/powerpc/platforms/powernv/pci-sriov.c:258:23: note: initialize the variable 'align' to silence this warning resource_size_t align; ^ = 01 warning generated.
Quoted 6 lines
But I can't get gcc to warn about it?
It produces some code, so it's not like the whole function has been elided or something. I'm confused.
cheers
-Wmaybe-uninitialized was disabled in commit 78a5255ffb6a ("Stop the ad-hoc games with -Wno-maybe-initialized") upstream so GCC won't warn on stuff like this anymore.
I would assume the function should still be generated since those checks are relevant, just the return value is bogus.
Cheers,
Nathan
Michael Ellerman
reviewerRe: [PATCH v2 15/16] powerpc/powernv/sriov: Make single PE mode a per-BAR setting
Quoted 59 lines · Nathan Chancellor
Quoted 58 lines · Michael Ellerman
Quoted 30 lines · Nathan Chancellor
Quoted 29 lines · Oliver O'Halloran
Using single PE BARs to map an SR-IOV BAR is really a choice about what strategy to use when mapping a BAR. It doesn't make much sense for this to be a global setting since a device might have one large BAR which needs to be mapped with single PE windows and another smaller BAR that can be mapped with a regular segmented window. Make the segmented vs single decision a per-BAR setting and clean up the logic that decides which mode to use.
Signed-off-by Oliver O'Halloran <[email protected]>---
v2: Dropped unusedtotal_vfsvariables inpnv_pci_ioda_fixup_iov_resources()
Droppedbar_nofrompnv_pci_iov_resource_alignment()
Minor re-wording of comments.--- arch/powerpc/platforms/powernv/pci-sriov.c | 131 ++++++++++----------- arch/powerpc/platforms/powernv/pci.h | 11 +- 2 files changed, 73 insertions(+), 69 deletions(-)arch/powerpc/platforms/powernv/pci-sriov.c +0
-1@@ -260,42 +256,40 @@ void pnv_pci_ioda_fixup_iov(struct pci_dev *pdev)resource_size_t pnv_pci_iov_resource_alignment (struct pci_dev *pdev,int resno) { -struct pnv_phb *phb =pci_bus_to_pnvhb (pdev->bus);struct pnv_iov_data *iov =pnv_iov_get (pdev);resource_size_t align;Quoted 12 lines
arch/powerpc/platforms/powernv/pci-sriov.c void pnv_pci_ioda_fixup_iov(struct pci_dev *pdev) · line 273
Quoted 12 lines
arch/powerpc/platforms/powernv/pci-sriov.c +12
-0+/* +* iov can be null if we have an SR-IOV device with IOV BAR that can't +* be placed in the m64 space (i.e. The BAR is 32bit or non-prefetch). +* In that case we don't allow VFs to be enabled since one of their +* BARs would not be placed in the correct PE. +*/ +if (!iov) +return align; +if (!iov->vfs_expanded) +return align; + + align =pci_iov_resource_size (pdev, resno);That's, oof.
Quoted 11 lines
I am not sure if it has been reported yet but clang points out that align is initialized after its use:
arch/powerpc/platforms/powernv/pci-sriov.c:267:10: warning: variable 'align' is uninitialized when used here [-Wuninitialized]return align; ^~~~~ arch/powerpc/platforms/powernv/pci-sriov.c:258:23: note: initialize the variable 'align' to silence this warning resource_size_t align; ^ = 01 warning generated.
Quoted 8 lines
Quoted 4 lines
But I can't get gcc to warn about it?
It produces some code, so it's not like the whole function has been elided or something. I'm confused.
-Wmaybe-uninitialized was disabled in commit
78a5255ffb6a("Stop the ad-hoc games with -Wno-maybe-initialized") upstream so GCC won't warn on stuff like this anymore.
Seems so. Just that there's no "maybe" here, it's very uninitialised.
Quoted 2 lines
I would assume the function should still be generated since those checks are relevant, just the return value is bogus.
Yeah, just sometimes missing warnings boil down to the compiler eliding whole sections of code, if it can convince itself they're unreachable.
AFAICS there's nothing weird going on here that should confuse GCC, it's about as straight forward as it gets.
Actually I can reproduce it with:
$ cat > test.c <<EOF
int foo(void *p)
{
unsigned align; if (!p)
return align;
return 0;
}EOF
$ gcc -Wall -Wno-maybe-uninitialized -c test.c $
No warning.
But I guess that's behaving as documented. The compiler can't prove that foo() will be called with p == NULL, so it doesn't warn.
cheers
Re: [PATCH v2 15/16] powerpc/powernv/sriov: Make single PE mode a per-BAR setting
Quoted 5 lines · Michael Ellerman
Quoted 2 lines
I would assume the function should still be generated since those checks are relevant, just the return value is bogus.
Yeah, just sometimes missing warnings boil down to the compiler eliding whole sections of code, if it can convince itself they're unreachable.
Including when the compiler considers they must be unreachable because they would perform undefined behaviour, like, act on uninitialised values. Such code is removed by cddce ("control dependence dead code elimination", enabled by -ftree-dce at -O2 or above).
Quoted 2 lines
AFAICS there's nothing weird going on here that should confuse GCC, it's about as straight forward as it gets.
Yes. Please open a bug?
Quoted 12 lines
Actually I can reproduce it with:
$ cat > test.c <<EOF int foo(void *p) { unsigned align;if (!p) return align; return 0; }
Quoted 6 lines
EOF
$ gcc -Wall -Wno-maybe-uninitialized -c test.c $No warning.
The whole if() is deleted pretty early.
===
static int foo(void *p)
{
unsigned align;
if (!p)
return align;
return 42;
}int bork(void) { return foo(0); }
===
doesn't warn either, although that always uses the uninitialised var (actually, that code is *removed*, and it always does that "return 42").
Quoted 2 lines
But I guess that's behaving as documented. The compiler can't prove that
foo()will be called with p == NULL, so it doesn't warn.
-Wmaybe-uninitialized doesn't warn for this either, btw.
Segher
PATCH v2 16/16 powerpc/powernv/sriov: Remove vfs_expanded
In reply to Oliver O'HalloranPreviously iov->vfs_expanded was used for two purposes.
1) To work out how much we need to multiple the per-VF BAR size to figure out the total space required for the IOV BAR.
2) To indicate that IOV is not usable with this device (vfs_expanded == 0).
We don't really need the field for either since the multiple in 1) is always the number PEs supported by the PHB. Similarly, we don't really need it in 2) either since the IOV data field will be NULL if we can't use IOV with the device.
---
v2: New
--- arch/powerpc/platforms/powernv/pci-sriov.c | 9 +++------ arch/powerpc/platforms/powernv/pci.h | 3 --- 2 files changed, 3 insertions(+), 9 deletions(-)
arch/powerpc/platforms/powernv/pci-sriov.c +3 -6
@@ -213,8 +213,6 @@ static void pnv_pci_ioda_fixup_iov_resources(struct pci_dev *pdev) iov->need_shift = true; } - iov->vfs_expanded = mul; -return ; disable_iov:
@@ -256,6 +254,7 @@ void pnv_pci_ioda_fixup_iov(struct pci_dev *pdev)resource_size_t pnv_pci_iov_resource_alignment (struct pci_dev *pdev,int resno) { +struct pnv_phb *phb =pci_bus_to_pnvhb (pdev->bus);struct pnv_iov_data *iov =pnv_iov_get (pdev);resource_size_t align;
@@ -267,8 +266,6 @@ resource_size_t pnv_pci_iov_resource_alignment(struct pci_dev *pdev,*/ if (!iov)return align; -if (!iov->vfs_expanded) -return align; align =pci_iov_resource_size (pdev, resno);
@@ -290,7 +287,7 @@ resource_size_t pnv_pci_iov_resource_alignment(struct pci_dev *pdev,* If the M64 BAR is in Single PE mode, return the VF BAR size or * M64 segment size if IOV BAR size is less. */ -return iov->vfs_expanded * align; +return phb->ioda.total_pe_num * align; }static int pnv_pci_vf_release_m64 (struct pci_dev *pdev,u16 num_vfs)
@@ -708,7 +705,7 @@ static int pnv_pci_sriov_enable(struct pci_dev *pdev, u16 num_vfs)return -ENXIO ; } -if (!iov->vfs_expanded) { +if (!iov) {dev_info (&pdev->dev,"don't support this SRIOV device" " with non 64bit-prefetchable IOV BAR\n" );return -ENOSPC ;
arch/powerpc/platforms/powernv/pci.h +0 -3
@@ -234,9 +234,6 @@ void pnv_ioda_free_pe(struct pnv_ioda_pe *pe);* and this structure is used to keep track of it all. */ struct pnv_iov_data { -/* number of VFs IOV BAR expanded. FIXME: rename this to something less bad */ -u16 vfs_expanded; -/* number of VFs enabled */ u16 num_vfs;
Signature · 1 line
2.26.2
Michael Ellerman
AppliedQuoted 11 lines · Oliver O'Halloran
Add a helper to go from a
pci_busstructure to thepnv_phbthat hosts that bus. There's a lot of instances of the following pattern:struct pci_controller *hose = pci_bus_to_host(pdev->bus); struct pnv_phb *phb = hose->private_data;Without any other uses of the
pci_controllerinside the function. This is hard to read since it requires you to memorise the contents of the private data fields and kind of error prone since it involves blindly assigning a void pointer. Add a helper to make it more concise and explicit.
Applied to powerpc/next.
[01/16] powerpc/powernv/pci: Add pci_bus_to_pnvhb() helper
https://git.kernel.org/powerpc/c/5609ffddd19dd52019d78b197e86b0331aeef8ae [02/16] powerpc/powernv/pci: Always tear down DMA windows on PE release https://git.kernel.org/powerpc/c/7a52ffabe867c0d93e47af113e5107340974047a [03/16] powerpc/powernv/pci: Add explicit tracking of the DMA setup state https://git.kernel.org/powerpc/c/01e12629af4e0e4864ed4d83e07783d7cb5b06be [04/16] powerpc/powernv/pci: Initialise M64 for IODA1 as a 1-1 window https://git.kernel.org/powerpc/c/369633654fcb9639cd4cd0e1a448ffde3533d776 [05/16] powerpc/powernv/sriov: Move SR-IOV into a separate file https://git.kernel.org/powerpc/c/37b59ef08c546c6f54cdc52eed749f494619a102 [06/16] powerpc/powernv/sriov: Explain how SR-IOV works on PowerNV https://git.kernel.org/powerpc/c/ff79e11af0979b25ecb38e4c843779d4a759a4e2 [07/16] powerpc/powernv/sriov: Rename truncate_iov https://git.kernel.org/powerpc/c/fac248f8119170e3f8f54900985498ff6ee560bf [08/16] powerpc/powernv/sriov: Simplify used window tracking https://git.kernel.org/powerpc/c/ad9add529d99d195195c27abf99e42d4965d35e2 [09/16] powerpc/powernv/sriov: Factor out M64 BAR setup https://git.kernel.org/powerpc/c/a610d35cc8780e781321ea8d002d5fef8484bf59 [10/16] powerpc/powernv/pci: Refactor pnv_ioda_alloc_pe() https://git.kernel.org/powerpc/c/a4bc676ed5c3f53781cc342b73097eb7e8d43fa5 [11/16] powerpc/powernv/sriov: Drop iov->pe_num_map[] https://git.kernel.org/powerpc/c/d29a2488d2c020032fdb1fe052347a6021e3591d [12/16] powerpc/powernv/sriov: De-indent setup and teardown https://git.kernel.org/powerpc/c/052da31d45fc71238ea8bed7e9a84648a1ee0bf3 [13/16] powerpc/powernv/sriov: Move M64 BAR allocation into a helper https://git.kernel.org/powerpc/c/39efc03e3ee8f41909b7542be70b4061b38ca277 [14/16] powerpc/powernv/sriov: Refactor M64 BAR setup https://git.kernel.org/powerpc/c/a0be516f8160fdb4836237cba037229e88a1de7d [15/16] powerpc/powernv/sriov: Make single PE mode a per-BAR setting https://git.kernel.org/powerpc/c/4c51f3e1e8702cbd0e53159fc3d1f54c20c70574 [16/16] powerpc/powernv/sriov: Remove vfs_expanded https://git.kernel.org/powerpc/c/84d8505ed1dafb2e62d49fca5e7aa7d96cfcec49
cheers