Merge branch 'pci/peer-to-peer'

  - Add "pci=disable_acs_redir=" parameter to disable ACS redirection for
    peer-to-peer DMA support (we don't have the peer-to-peer support yet;
    this is just one piece) (Logan Gunthorpe)

* pci/peer-to-peer:
  PCI: Add ACS Redirect disable quirk for Intel Sunrise Point
  PCI: Add device-specific ACS Redirect disable infrastructure
  PCI: Convert device-specific ACS quirks from NULL termination to ARRAY_SIZE
  PCI: Add "pci=disable_acs_redir=" parameter for peer-to-peer support
  PCI: Allow specifying devices using a base bus and path of devfns
  PCI: Make specifying PCI devices in kernel parameters reusable
  PCI: Hide ACS quirk declarations inside PCI core

5 files changed, 373 insertions, 85 deletions

diff --git a/Documentation/admin-guide/kernel-parameters.txt b/Documentation/admin-guide/kernel-parameters.txt
index efc7aa7a0670..d5c27d947c2e 100644
--- a/Documentation/admin-guide/kernel-parameters.txt
+++ b/Documentation/admin-guide/kernel-parameters.txt
@@ -2994,7 +2994,30 @@
                         See header of drivers/block/paride/pcd.c.
                         See also Documentation/blockdev/paride.txt.
 
-        pci=option[,option...]  [PCI] various PCI subsystem options:
+        pci=option[,option...]  [PCI] various PCI subsystem options.
+
+                                Some options herein operate on a specific device
+                                or a set of devices (<pci_dev>). These are
+                                specified in one of the following formats:
+
+                                [<domain>:]<bus>:<dev>.<func>[/<dev>.<func>]*
+                                pci:<vendor>:<device>[:<subvendor>:<subdevice>]
+
+                                Note: the first format specifies a PCI
+                                bus/device/function address which may change
+                                if new hardware is inserted, if motherboard
+                                firmware changes, or due to changes caused
+                                by other kernel parameters. If the
+                                domain is left unspecified, it is
+                                taken to be zero. Optionally, a path
+                                to a device through multiple device/function
+                                addresses can be specified after the base
+                                address (this is more robust against
+                                renumbering issues).  The second format
+                                selects devices using IDs from the
+                                configuration space which may match multiple
+                                devices in the system.
+
                 earlydump       [X86] dump PCI config space before the kernel
                                 changes anything
                 off             [X86] don't probe for the PCI bus
@@ -3123,11 +3146,10 @@
                                 window. The default value is 64 megabytes.
                 resource_alignment=
                                 Format:
-                                [<order of align>@][<domain>:]<bus>:<slot>.<func>[; ...]
-                                [<order of align>@]pci:<vendor>:<device>\
-                                                [:<subvendor>:<subdevice>][; ...]
+                                [<order of align>@]<pci_dev>[; ...]
                                 Specifies alignment and device to reassign
-                                aligned memory resources.
+                                aligned memory resources. How to
+                                specify the device is described above.
                                 If <order of align> is not specified,
                                 PAGE_SIZE is used as alignment.
                                 PCI-PCI bridge can be specified, if resource
@@ -3170,6 +3192,15 @@
                                 Adding the window is slightly risky (it may
                                 conflict with unreported devices), so this
                                 taints the kernel.
+                disable_acs_redir=<pci_dev>[; ...]
+                                Specify one or more PCI devices (in the format
+                                specified above) separated by semicolons.
+                                Each device specified will have the PCI ACS
+                                redirect capabilities forced off which will
+                                allow P2P traffic between devices through
+                                bridges without forcing it upstream. Note:
+                                this removes isolation between devices and
+                                may put more devices in an IOMMU group.
 
         pcie_aspm=      [PCIE] Forcibly enable or disable PCIe Active State Power
                         Management.
diff --git a/drivers/pci/pci.c b/drivers/pci/pci.c
index 0306fa44653a..f68217abc1ef 100644
--- a/drivers/pci/pci.c
+++ b/drivers/pci/pci.c
@@ -190,6 +190,168 @@ void __iomem *pci_ioremap_wc_bar(struct pci_dev *pdev, int bar)
 EXPORT_SYMBOL_GPL(pci_ioremap_wc_bar);
 #endif
 
+/**
+ * pci_dev_str_match_path - test if a path string matches a device
+ * @dev:    the PCI device to test
+ * @p:      string to match the device against
+ * @endptr: pointer to the string after the match
+ *
+ * Test if a string (typically from a kernel parameter) formatted as a
+ * path of device/function addresses matches a PCI device. The string must
+ * be of the form:
+ *
+ *   [<domain>:]<bus>:<device>.<func>[/<device>.<func>]*
+ *
+ * A path for a device can be obtained using 'lspci -t'.  Using a path
+ * is more robust against bus renumbering than using only a single bus,
+ * device and function address.
+ *
+ * Returns 1 if the string matches the device, 0 if it does not and
+ * a negative error code if it fails to parse the string.
+ */
+static int pci_dev_str_match_path(struct pci_dev *dev, const char *path,
+                                  const char **endptr)
+{
+        int ret;
+        int seg, bus, slot, func;
+        char *wpath, *p;
+        char end;
+
+        *endptr = strchrnul(path, ';');
+
+        wpath = kmemdup_nul(path, *endptr - path, GFP_KERNEL);
+        if (!wpath)
+                return -ENOMEM;
+
+        while (1) {
+                p = strrchr(wpath, '/');
+                if (!p)
+                        break;
+                ret = sscanf(p, "/%x.%x%c", &slot, &func, &end);
+                if (ret != 2) {
+                        ret = -EINVAL;
+                        goto free_and_exit;
+                }
+
+                if (dev->devfn != PCI_DEVFN(slot, func)) {
+                        ret = 0;
+                        goto free_and_exit;
+                }
+
+                /*
+                 * Note: we don't need to get a reference to the upstream
+                 * bridge because we hold a reference to the top level
+                 * device which should hold a reference to the bridge,
+                 * and so on.
+                 */
+                dev = pci_upstream_bridge(dev);
+                if (!dev) {
+                        ret = 0;
+                        goto free_and_exit;
+                }
+
+                *p = 0;
+        }
+
+        ret = sscanf(wpath, "%x:%x:%x.%x%c", &seg, &bus, &slot,
+                     &func, &end);
+        if (ret != 4) {
+                seg = 0;
+                ret = sscanf(wpath, "%x:%x.%x%c", &bus, &slot, &func, &end);
+                if (ret != 3) {
+                        ret = -EINVAL;
+                        goto free_and_exit;
+                }
+        }
+
+        ret = (seg == pci_domain_nr(dev->bus) &&
+               bus == dev->bus->number &&
+               dev->devfn == PCI_DEVFN(slot, func));
+
+free_and_exit:
+        kfree(wpath);
+        return ret;
+}
+
+/**
+ * pci_dev_str_match - test if a string matches a device
+ * @dev:    the PCI device to test
+ * @p:      string to match the device against
+ * @endptr: pointer to the string after the match
+ *
+ * Test if a string (typically from a kernel parameter) matches a specified
+ * PCI device. The string may be of one of the following formats:
+ *
+ *   [<domain>:]<bus>:<device>.<func>[/<device>.<func>]*
+ *   pci:<vendor>:<device>[:<subvendor>:<subdevice>]
+ *
+ * The first format specifies a PCI bus/device/function address which
+ * may change if new hardware is inserted, if motherboard firmware changes,
+ * or due to changes caused in kernel parameters. If the domain is
+ * left unspecified, it is taken to be 0.  In order to be robust against
+ * bus renumbering issues, a path of PCI device/function numbers may be used
+ * to address the specific device.  The path for a device can be determined
+ * through the use of 'lspci -t'.
+ *
+ * The second format matches devices using IDs in the configuration
+ * space which may match multiple devices in the system. A value of 0
+ * for any field will match all devices. (Note: this differs from
+ * in-kernel code that uses PCI_ANY_ID which is ~0; this is for
+ * legacy reasons and convenience so users don't have to specify
+ * FFFFFFFFs on the command line.)
+ *
+ * Returns 1 if the string matches the device, 0 if it does not and
+ * a negative error code if the string cannot be parsed.
+ */
+static int pci_dev_str_match(struct pci_dev *dev, const char *p,
+                             const char **endptr)
+{
+        int ret;
+        int count;
+        unsigned short vendor, device, subsystem_vendor, subsystem_device;
+
+        if (strncmp(p, "pci:", 4) == 0) {
+                /* PCI vendor/device (subvendor/subdevice) IDs are specified */
+                p += 4;
+                ret = sscanf(p, "%hx:%hx:%hx:%hx%n", &vendor, &device,
+                             &subsystem_vendor, &subsystem_device, &count);
+                if (ret != 4) {
+                        ret = sscanf(p, "%hx:%hx%n", &vendor, &device, &count);
+                        if (ret != 2)
+                                return -EINVAL;
+
+                        subsystem_vendor = 0;
+                        subsystem_device = 0;
+                }
+
+                p += count;
+
+                if ((!vendor || vendor == dev->vendor) &&
+                    (!device || device == dev->device) &&
+                    (!subsystem_vendor ||
+                            subsystem_vendor == dev->subsystem_vendor) &&
+                    (!subsystem_device ||
+                            subsystem_device == dev->subsystem_device))
+                        goto found;
+        } else {
+                /*
+                 * PCI Bus, Device, Function IDs are specified
+                 *  (optionally, may include a path of devfns following it)
+                 */
+                ret = pci_dev_str_match_path(dev, p, &p);
+                if (ret < 0)
+                        return ret;
+                else if (ret)
+                        goto found;
+        }
+
+        *endptr = p;
+        return 0;
+
+found:
+        *endptr = p;
+        return 1;
+}
 
 static int __pci_find_next_cap_ttl(struct pci_bus *bus, unsigned int devfn,
                                    u8 pos, int cap, int *ttl)
@@ -2829,6 +2991,66 @@ void pci_request_acs(void)
         pci_acs_enable = 1;
 }
 
+static const char *disable_acs_redir_param;
+
+/**
+ * pci_disable_acs_redir - disable ACS redirect capabilities
+ * @dev: the PCI device
+ *
+ * For only devices specified in the disable_acs_redir parameter.
+ */
+static void pci_disable_acs_redir(struct pci_dev *dev)
+{
+        int ret = 0;
+        const char *p;
+        int pos;
+        u16 ctrl;
+
+        if (!disable_acs_redir_param)
+                return;
+
+        p = disable_acs_redir_param;
+        while (*p) {
+                ret = pci_dev_str_match(dev, p, &p);
+                if (ret < 0) {
+                        pr_info_once("PCI: Can't parse disable_acs_redir parameter: %s\n",
+                                     disable_acs_redir_param);
+
+                        break;
+                } else if (ret == 1) {
+                        /* Found a match */
+                        break;
+                }
+
+                if (*p != ';' && *p != ',') {
+                        /* End of param or invalid format */
+                        break;
+                }
+                p++;
+        }
+
+        if (ret != 1)
+                return;
+
+        if (!pci_dev_specific_disable_acs_redir(dev))
+                return;
+
+        pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ACS);
+        if (!pos) {
+                pci_warn(dev, "cannot disable ACS redirect for this hardware as it does not have ACS capabilities\n");
+                return;
+        }
+
+        pci_read_config_word(dev, pos + PCI_ACS_CTRL, &ctrl);
+
+        /* P2P Request & Completion Redirect */
+        ctrl &= ~(PCI_ACS_RR | PCI_ACS_CR | PCI_ACS_EC);
+
+        pci_write_config_word(dev, pos + PCI_ACS_CTRL, ctrl);
+
+        pci_info(dev, "disabled ACS redirect\n");
+}
+
 /**
  * pci_std_enable_acs - enable ACS on devices using standard ACS capabilites
  * @dev: the PCI device
@@ -2868,12 +3090,22 @@ static void pci_std_enable_acs(struct pci_dev *dev)
 void pci_enable_acs(struct pci_dev *dev)
 {
         if (!pci_acs_enable)
-                return;
+                goto disable_acs_redir;
 
         if (!pci_dev_specific_enable_acs(dev))
-                return;
+                goto disable_acs_redir;
 
         pci_std_enable_acs(dev);
+
+disable_acs_redir:
+        /*
+         * Note: pci_disable_acs_redir() must be called even if ACS was not
+         * enabled by the kernel because it may have been enabled by
+         * platform firmware.  So if we are told to disable it, we should
+         * always disable it after setting the kernel's default
+         * preferences.
+         */
+        pci_disable_acs_redir(dev);
 }
 
 static bool pci_acs_flags_enabled(struct pci_dev *pdev, u16 acs_flags)
@@ -5514,10 +5746,10 @@ static DEFINE_SPINLOCK(resource_alignment_lock);
 static resource_size_t pci_specified_resource_alignment(struct pci_dev *dev,
                                                         bool *resize)
 {
-        int seg, bus, slot, func, align_order, count;
-        unsigned short vendor, device, subsystem_vendor, subsystem_device;
+        int align_order, count;
         resource_size_t align = pcibios_default_alignment();
-        char *p;
+        const char *p;
+        int ret;
 
         spin_lock(&resource_alignment_lock);
         p = resource_alignment_param;
@@ -5537,58 +5769,21 @@ static resource_size_t pci_specified_resource_alignment(struct pci_dev *dev,
                 } else {
                         align_order = -1;
                 }
-                if (strncmp(p, "pci:", 4) == 0) {
-                        /* PCI vendor/device (subvendor/subdevice) ids are specified */
-                        p += 4;
-                        if (sscanf(p, "%hx:%hx:%hx:%hx%n",
-                                &vendor, &device, &subsystem_vendor, &subsystem_device, &count) != 4) {
-                                if (sscanf(p, "%hx:%hx%n", &vendor, &device, &count) != 2) {
-                                        printk(KERN_ERR "PCI: Can't parse resource_alignment parameter: pci:%s\n",
-                                                p);
-                                        break;
-                                }
-                                subsystem_vendor = subsystem_device = 0;
-                        }
-                        p += count;
-                        if ((!vendor || (vendor == dev->vendor)) &&
-                                (!device || (device == dev->device)) &&
-                                (!subsystem_vendor || (subsystem_vendor == dev->subsystem_vendor)) &&
-                                (!subsystem_device || (subsystem_device == dev->subsystem_device))) {
-                                *resize = true;
-                                if (align_order == -1)
-                                        align = PAGE_SIZE;
-                                else
-                                        align = 1 << align_order;
-                                /* Found */
-                                break;
-                        }
-                }
-                else {
-                        if (sscanf(p, "%x:%x:%x.%x%n",
-                                &seg, &bus, &slot, &func, &count) != 4) {
-                                seg = 0;
-                                if (sscanf(p, "%x:%x.%x%n",
-                                                &bus, &slot, &func, &count) != 3) {
-                                        /* Invalid format */
-                                        printk(KERN_ERR "PCI: Can't parse resource_alignment parameter: %s\n",
-                                                p);
-                                        break;
-                                }
-                        }
-                        p += count;
-                        if (seg == pci_domain_nr(dev->bus) &&
-                                bus == dev->bus->number &&
-                                slot == PCI_SLOT(dev->devfn) &&
-                                func == PCI_FUNC(dev->devfn)) {
-                                *resize = true;
-                                if (align_order == -1)
-                                        align = PAGE_SIZE;
-                                else
-                                        align = 1 << align_order;
-                                /* Found */
-                                break;
-                        }
+
+                ret = pci_dev_str_match(dev, p, &p);
+                if (ret == 1) {
+                        *resize = true;
+                        if (align_order == -1)
+                                align = PAGE_SIZE;
+                        else
+                                align = 1 << align_order;
+                        break;
+                } else if (ret < 0) {
+                        pr_err("PCI: Can't parse resource_alignment parameter: %s\n",
+                               p);
+                        break;
                 }
+
                 if (*p != ';' && *p != ',') {
                         /* End of param or invalid format */
                         break;
@@ -5901,6 +6096,8 @@ static int __init pci_setup(char *str)
                                 pcie_bus_config = PCIE_BUS_PEER2PEER;
                         } else if (!strncmp(str, "pcie_scan_all", 13)) {
                                 pci_add_flags(PCI_SCAN_ALL_PCIE_DEVS);
+                        } else if (!strncmp(str, "disable_acs_redir=", 18)) {
+                                disable_acs_redir_param = str + 18;
                         } else {
                                 printk(KERN_ERR "PCI: Unknown option `%s'\n",
                                                 str);
diff --git a/drivers/pci/pci.h b/drivers/pci/pci.h
index ccb0537d5d89..8907ceb88233 100644
--- a/drivers/pci/pci.h
+++ b/drivers/pci/pci.h
@@ -400,6 +400,25 @@ static inline resource_size_t pci_resource_alignment(struct pci_dev *dev,
 }
 
 void pci_enable_acs(struct pci_dev *dev);
+#ifdef CONFIG_PCI_QUIRKS
+int pci_dev_specific_acs_enabled(struct pci_dev *dev, u16 acs_flags);
+int pci_dev_specific_enable_acs(struct pci_dev *dev);
+int pci_dev_specific_disable_acs_redir(struct pci_dev *dev);
+#else
+static inline int pci_dev_specific_acs_enabled(struct pci_dev *dev,
+                                               u16 acs_flags)
+{
+        return -ENOTTY;
+}
+static inline int pci_dev_specific_enable_acs(struct pci_dev *dev)
+{
+        return -ENOTTY;
+}
+static inline int pci_dev_specific_disable_acs_redir(struct pci_dev *dev)
+{
+        return -ENOTTY;
+}
+#endif
 
 /* PCI error reporting and recovery */
 void pcie_do_fatal_recovery(struct pci_dev *dev, u32 service);
diff --git a/drivers/pci/quirks.c b/drivers/pci/quirks.c
index 2c6d987c271f..eb57d8b610fe 100644
--- a/drivers/pci/quirks.c
+++ b/drivers/pci/quirks.c
@@ -4555,27 +4555,79 @@ static int pci_quirk_enable_intel_spt_pch_acs(struct pci_dev *dev)
         return 0;
 }
 
-static const struct pci_dev_enable_acs {
+static int pci_quirk_disable_intel_spt_pch_acs_redir(struct pci_dev *dev)
+{
+        int pos;
+        u32 cap, ctrl;
+
+        if (!pci_quirk_intel_spt_pch_acs_match(dev))
+                return -ENOTTY;
+
+        pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ACS);
+        if (!pos)
+                return -ENOTTY;
+
+        pci_read_config_dword(dev, pos + PCI_ACS_CAP, &cap);
+        pci_read_config_dword(dev, pos + INTEL_SPT_ACS_CTRL, &ctrl);
+
+        ctrl &= ~(PCI_ACS_RR | PCI_ACS_CR | PCI_ACS_EC);
+
+        pci_write_config_dword(dev, pos + INTEL_SPT_ACS_CTRL, ctrl);
+
+        pci_info(dev, "Intel SPT PCH root port workaround: disabled ACS redirect\n");
+
+        return 0;
+}
+
+static const struct pci_dev_acs_ops {
         u16 vendor;
         u16 device;
         int (*enable_acs)(struct pci_dev *dev);
-} pci_dev_enable_acs[] = {
-        { PCI_VENDOR_ID_INTEL, PCI_ANY_ID, pci_quirk_enable_intel_pch_acs },
-        { PCI_VENDOR_ID_INTEL, PCI_ANY_ID, pci_quirk_enable_intel_spt_pch_acs },
-        { 0 }
+        int (*disable_acs_redir)(struct pci_dev *dev);
+} pci_dev_acs_ops[] = {
+        { PCI_VENDOR_ID_INTEL, PCI_ANY_ID,
+            .enable_acs = pci_quirk_enable_intel_pch_acs,
+        },
+        { PCI_VENDOR_ID_INTEL, PCI_ANY_ID,
+            .enable_acs = pci_quirk_enable_intel_spt_pch_acs,
+            .disable_acs_redir = pci_quirk_disable_intel_spt_pch_acs_redir,
+        },
 };
 
 int pci_dev_specific_enable_acs(struct pci_dev *dev)
 {
-        const struct pci_dev_enable_acs *i;
-        int ret;
+        const struct pci_dev_acs_ops *p;
+        int i, ret;
+
+        for (i = 0; i < ARRAY_SIZE(pci_dev_acs_ops); i++) {
+                p = &pci_dev_acs_ops[i];
+                if ((p->vendor == dev->vendor ||
+                     p->vendor == (u16)PCI_ANY_ID) &&
+                    (p->device == dev->device ||
+                     p->device == (u16)PCI_ANY_ID) &&
+                    p->enable_acs) {
+                        ret = p->enable_acs(dev);
+                        if (ret >= 0)
+                                return ret;
+                }
+        }
 
-        for (i = pci_dev_enable_acs; i->enable_acs; i++) {
-                if ((i->vendor == dev->vendor ||
-                     i->vendor == (u16)PCI_ANY_ID) &&
-                    (i->device == dev->device ||
-                     i->device == (u16)PCI_ANY_ID)) {
-                        ret = i->enable_acs(dev);
+        return -ENOTTY;
+}
+
+int pci_dev_specific_disable_acs_redir(struct pci_dev *dev)
+{
+        const struct pci_dev_acs_ops *p;
+        int i, ret;
+
+        for (i = 0; i < ARRAY_SIZE(pci_dev_acs_ops); i++) {
+                p = &pci_dev_acs_ops[i];
+                if ((p->vendor == dev->vendor ||
+                     p->vendor == (u16)PCI_ANY_ID) &&
+                    (p->device == dev->device ||
+                     p->device == (u16)PCI_ANY_ID) &&
+                    p->disable_acs_redir) {
+                        ret = p->disable_acs_redir(dev);
                         if (ret >= 0)
                                 return ret;
                 }
diff --git a/include/linux/pci.h b/include/linux/pci.h
index b37f2734f9a2..3dd5b871b895 100644
--- a/include/linux/pci.h
+++ b/include/linux/pci.h
@@ -1890,20 +1890,9 @@ enum pci_fixup_pass {
 
 #ifdef CONFIG_PCI_QUIRKS
 void pci_fixup_device(enum pci_fixup_pass pass, struct pci_dev *dev);
-int pci_dev_specific_acs_enabled(struct pci_dev *dev, u16 acs_flags);
-int pci_dev_specific_enable_acs(struct pci_dev *dev);
 #else
 static inline void pci_fixup_device(enum pci_fixup_pass pass,
                                     struct pci_dev *dev) { }
-static inline int pci_dev_specific_acs_enabled(struct pci_dev *dev,
-                                               u16 acs_flags)
-{
-        return -ENOTTY;
-}
-static inline int pci_dev_specific_enable_acs(struct pci_dev *dev)
-{
-        return -ENOTTY;
-}
 #endif
 
 void __iomem *pcim_iomap(struct pci_dev *pdev, int bar, unsigned long maxlen);