1 files changed, 53 insertions, 34 deletions

diff --git a/drivers/pci/pci.c b/drivers/pci/pci.c
index 1b27b5af3d55..e7982af9a5d8 100644
--- a/drivers/pci/pci.c
+++ b/drivers/pci/pci.c
@@ -890,8 +890,8 @@ static int pci_raw_set_power_state(struct pci_dev *dev, pci_power_t state)
 
         pci_read_config_word(dev, dev->pm_cap + PCI_PM_CTRL, &pmcsr);
         dev->current_state = (pmcsr & PCI_PM_CTRL_STATE_MASK);
-        if (dev->current_state != state && printk_ratelimit())
-                pci_info(dev, "Refused to change power state, currently in D%d\n",
+        if (dev->current_state != state)
+                pci_info_ratelimited(dev, "Refused to change power state, currently in D%d\n",
                          dev->current_state);
 
         /*
@@ -1443,7 +1443,7 @@ static void pci_restore_rebar_state(struct pci_dev *pdev)
                 pci_read_config_dword(pdev, pos + PCI_REBAR_CTRL, &ctrl);
                 bar_idx = ctrl & PCI_REBAR_CTRL_BAR_IDX;
                 res = pdev->resource + bar_idx;
-                size = order_base_2((resource_size(res) >> 20) | 1) - 1;
+                size = ilog2(resource_size(res)) - 20;
                 ctrl &= ~PCI_REBAR_CTRL_BAR_SIZE;
                 ctrl |= size << PCI_REBAR_CTRL_BAR_SHIFT;
                 pci_write_config_dword(pdev, pos + PCI_REBAR_CTRL, ctrl);
@@ -3581,7 +3581,7 @@ int pci_enable_atomic_ops_to_root(struct pci_dev *dev, u32 cap_mask)
                 }
 
                 /* Ensure upstream ports don't block AtomicOps on egress */
-                if (!bridge->has_secondary_link) {
+                if (pci_pcie_type(bridge) == PCI_EXP_TYPE_UPSTREAM) {
                         pcie_capability_read_dword(bridge, PCI_EXP_DEVCTL2,
                                                    &ctl2);
                         if (ctl2 & PCI_EXP_DEVCTL2_ATOMIC_EGRESS_BLOCK)
@@ -5923,8 +5923,19 @@ resource_size_t __weak pcibios_default_alignment(void)
         return 0;
 }
 
-#define RESOURCE_ALIGNMENT_PARAM_SIZE COMMAND_LINE_SIZE
-static char resource_alignment_param[RESOURCE_ALIGNMENT_PARAM_SIZE] = {0};
+/*
+ * Arches that don't want to expose struct resource to userland as-is in
+ * sysfs and /proc can implement their own pci_resource_to_user().
+ */
+void __weak pci_resource_to_user(const struct pci_dev *dev, int bar,
+                                 const struct resource *rsrc,
+                                 resource_size_t *start, resource_size_t *end)
+{
+        *start = rsrc->start;
+        *end = rsrc->end;
+}
+
+static char *resource_alignment_param;
 static DEFINE_SPINLOCK(resource_alignment_lock);
 
 /**
@@ -5945,7 +5956,7 @@ static resource_size_t pci_specified_resource_alignment(struct pci_dev *dev,
 
         spin_lock(&resource_alignment_lock);
         p = resource_alignment_param;
-        if (!*p && !align)
+        if (!p || !*p)
                 goto out;
         if (pci_has_flag(PCI_PROBE_ONLY)) {
                 align = 0;
@@ -6109,35 +6120,41 @@ void pci_reassigndev_resource_alignment(struct pci_dev *dev)
         }
 }
 
-static ssize_t pci_set_resource_alignment_param(const char *buf, size_t count)
+static ssize_t resource_alignment_show(struct bus_type *bus, char *buf)
 {
-        if (count > RESOURCE_ALIGNMENT_PARAM_SIZE - 1)
-                count = RESOURCE_ALIGNMENT_PARAM_SIZE - 1;
-        spin_lock(&resource_alignment_lock);
-        strncpy(resource_alignment_param, buf, count);
-        resource_alignment_param[count] = '\0';
-        spin_unlock(&resource_alignment_lock);
-        return count;
-}
+        size_t count = 0;
 
-static ssize_t pci_get_resource_alignment_param(char *buf, size_t size)
-{
-        size_t count;
         spin_lock(&resource_alignment_lock);
-        count = snprintf(buf, size, "%s", resource_alignment_param);
+        if (resource_alignment_param)
+                count = snprintf(buf, PAGE_SIZE, "%s", resource_alignment_param);
         spin_unlock(&resource_alignment_lock);
-        return count;
-}
 
-static ssize_t resource_alignment_show(struct bus_type *bus, char *buf)
-{
-        return pci_get_resource_alignment_param(buf, PAGE_SIZE);
+        /*
+         * When set by the command line, resource_alignment_param will not
+         * have a trailing line feed, which is ugly. So conditionally add
+         * it here.
+         */
+        if (count >= 2 && buf[count - 2] != '\n' && count < PAGE_SIZE - 1) {
+                buf[count - 1] = '\n';
+                buf[count++] = 0;
+        }
+
+        return count;
 }
 
 static ssize_t resource_alignment_store(struct bus_type *bus,
                                         const char *buf, size_t count)
 {
-        return pci_set_resource_alignment_param(buf, count);
+        char *param = kstrndup(buf, count, GFP_KERNEL);
+
+        if (!param)
+                return -ENOMEM;
+
+        spin_lock(&resource_alignment_lock);
+        kfree(resource_alignment_param);
+        resource_alignment_param = param;
+        spin_unlock(&resource_alignment_lock);
+        return count;
 }
 
 static BUS_ATTR_RW(resource_alignment);
@@ -6266,8 +6283,7 @@ static int __init pci_setup(char *str)
                         } else if (!strncmp(str, "cbmemsize=", 10)) {
                                 pci_cardbus_mem_size = memparse(str + 10, &str);
                         } else if (!strncmp(str, "resource_alignment=", 19)) {
-                                pci_set_resource_alignment_param(str + 19,
-                                                        strlen(str + 19));
+                                resource_alignment_param = str + 19;
                         } else if (!strncmp(str, "ecrc=", 5)) {
                                 pcie_ecrc_get_policy(str + 5);
                         } else if (!strncmp(str, "hpiosize=", 9)) {
@@ -6302,15 +6318,18 @@ static int __init pci_setup(char *str)
 early_param("pci", pci_setup);
 
 /*
- * 'disable_acs_redir_param' is initialized in pci_setup(), above, to point
- * to data in the __initdata section which will be freed after the init
- * sequence is complete. We can't allocate memory in pci_setup() because some
- * architectures do not have any memory allocation service available during
- * an early_param() call. So we allocate memory and copy the variable here
- * before the init section is freed.
+ * 'resource_alignment_param' and 'disable_acs_redir_param' are initialized
+ * in pci_setup(), above, to point to data in the __initdata section which
+ * will be freed after the init sequence is complete. We can't allocate memory
+ * in pci_setup() because some architectures do not have any memory allocation
+ * service available during an early_param() call. So we allocate memory and
+ * copy the variable here before the init section is freed.
+ *
  */
 static int __init pci_realloc_setup_params(void)
 {
+        resource_alignment_param = kstrdup(resource_alignment_param,
+                                           GFP_KERNEL);
         disable_acs_redir_param = kstrdup(disable_acs_redir_param, GFP_KERNEL);
 
         return 0;