Merge tag 'pci-v3.13-changes' of git://git.kernel.org/pub/scm/linux/kernel/git/helgaas/pci

Pull PCI changes from Bjorn Helgaas:
 "Resource management
    - Fix host bridge window coalescing (Alexey Neyman)
    - Pass type, width, and prefetchability for window alignment (Wei Yang)

  PCI device hotplug
    - Convert acpiphp, acpiphp_ibm to dynamic debug (Lan Tianyu)

  Power management
    - Remove pci_pm_complete() (Liu Chuansheng)

  MSI
    - Fail initialization if device is not in PCI_D0 (Yijing Wang)

  MPS (Max Payload Size)
    - Use pcie_get_mps() and pcie_set_mps() to simplify code (Yijing Wang)
    - Use pcie_set_readrq() to simplify code (Yijing Wang)
    - Use cached pci_dev->pcie_mpss to simplify code (Yijing Wang)

  SR-IOV
    - Enable upstream bridges even for VFs on virtual buses (Bjorn Helgaas)
    - Use pci_is_root_bus() to avoid catching virtual buses (Wei Yang)

  Virtualization
    - Add x86 MSI masking ops (Konrad Rzeszutek Wilk)

  Freescale i.MX6
    - Support i.MX6 PCIe controller (Sean Cross)
    - Increase link startup timeout (Marek Vasut)
    - Probe PCIe in fs_initcall() (Marek Vasut)
    - Fix imprecise abort handler (Tim Harvey)
    - Remove redundant of_match_ptr (Sachin Kamat)

  Renesas R-Car
    - Support Gen2 internal PCIe controller (Valentine Barshak)

  Samsung Exynos
    - Add MSI support (Jingoo Han)
    - Turn off power when link fails (Jingoo Han)
    - Add Jingoo Han as maintainer (Jingoo Han)
    - Add clk_disable_unprepare() on error path (Wei Yongjun)
    - Remove redundant of_match_ptr (Sachin Kamat)

  Synopsys DesignWare
    - Add irq_create_mapping() (Pratyush Anand)
    - Add header guards (Seungwon Jeon)

  Miscellaneous
    - Enable native PCIe services by default on non-ACPI (Andrew Murray)
    - Cleanup _OSC usage and messages (Bjorn Helgaas)
    - Remove pcibios_last_bus boot option on non-x86 (Bjorn Helgaas)
    - Convert bus code to use bus_, drv_, and dev_groups (Greg Kroah-Hartman)
    - Remove unused pci_mem_start (Myron Stowe)
    - Make sysfs functions static (Sachin Kamat)
    - Warn on invalid return from driver probe (Stephen M. Cameron)
    - Remove Intel Haswell D3 delays (Todd E Brandt)
    - Call pci_set_master() in core if driver doesn't do it (Yinghai Lu)
    - Use pci_is_pcie() to simplify code (Yijing Wang)
    - Use PCIe capability accessors to simplify code (Yijing Wang)
    - Use cached pci_dev->pcie_cap to simplify code (Yijing Wang)
    - Removed unused "is_pcie" from struct pci_dev (Yijing Wang)
    - Simplify sysfs CPU affinity implementation (Yijing Wang)"

* tag 'pci-v3.13-changes' of git://git.kernel.org/pub/scm/linux/kernel/git/helgaas/pci: (79 commits)
  PCI: Enable upstream bridges even for VFs on virtual buses
  PCI: Add pci_upstream_bridge()
  PCI: Add x86_msi.msi_mask_irq() and msix_mask_irq()
  PCI: Warn on driver probe return value greater than zero
  PCI: Drop warning about drivers that don't use pci_set_master()
  PCI: Workaround missing pci_set_master in pci drivers
  powerpc/pci: Use pci_is_pcie() to simplify code [fix]
  PCI: Update pcie_ports 'auto' behavior for non-ACPI platforms
  PCI: imx6: Probe the PCIe in fs_initcall()
  PCI: Add R-Car Gen2 internal PCI support
  PCI: imx6: Remove redundant of_match_ptr
  PCI: Report pci_pme_active() kmalloc failure
  mn10300/PCI: Remove useless pcibios_last_bus
  frv/PCI: Remove pcibios_last_bus
  PCI: imx6: Increase link startup timeout
  PCI: exynos: Remove redundant of_match_ptr
  PCI: imx6: Fix imprecise abort handler
  PCI: Fail MSI/MSI-X initialization if device is not in PCI_D0
  PCI: imx6: Remove redundant dev_err() in imx6_pcie_probe()
  x86/PCI: Coalesce multiple overlapping host bridge windows
  ...

1 files changed, 148 insertions, 98 deletions

diff --git a/drivers/acpi/pci_root.c b/drivers/acpi/pci_root.c
index 417876bce854..56f05869b08d 100644
--- a/drivers/acpi/pci_root.c
+++ b/drivers/acpi/pci_root.c
@@ -51,10 +51,10 @@ static int acpi_pci_root_add(struct acpi_device *device,
                              const struct acpi_device_id *not_used);
 static void acpi_pci_root_remove(struct acpi_device *device);
 
-#define ACPI_PCIE_REQ_SUPPORT (OSC_EXT_PCI_CONFIG_SUPPORT \
-                                | OSC_ACTIVE_STATE_PWR_SUPPORT \
-                                | OSC_CLOCK_PWR_CAPABILITY_SUPPORT \
-                                | OSC_MSI_SUPPORT)
+#define ACPI_PCIE_REQ_SUPPORT (OSC_PCI_EXT_CONFIG_SUPPORT \
+                                | OSC_PCI_ASPM_SUPPORT \
+                                | OSC_PCI_CLOCK_PM_SUPPORT \
+                                | OSC_PCI_MSI_SUPPORT)
 
 static const struct acpi_device_id root_device_ids[] = {
         {"PNP0A03", 0},
@@ -129,6 +129,55 @@ static acpi_status try_get_root_bridge_busnr(acpi_handle handle,
         return AE_OK;
 }
 
+struct pci_osc_bit_struct {
+        u32 bit;
+        char *desc;
+};
+
+static struct pci_osc_bit_struct pci_osc_support_bit[] = {
+        { OSC_PCI_EXT_CONFIG_SUPPORT, "ExtendedConfig" },
+        { OSC_PCI_ASPM_SUPPORT, "ASPM" },
+        { OSC_PCI_CLOCK_PM_SUPPORT, "ClockPM" },
+        { OSC_PCI_SEGMENT_GROUPS_SUPPORT, "Segments" },
+        { OSC_PCI_MSI_SUPPORT, "MSI" },
+};
+
+static struct pci_osc_bit_struct pci_osc_control_bit[] = {
+        { OSC_PCI_EXPRESS_NATIVE_HP_CONTROL, "PCIeHotplug" },
+        { OSC_PCI_SHPC_NATIVE_HP_CONTROL, "SHPCHotplug" },
+        { OSC_PCI_EXPRESS_PME_CONTROL, "PME" },
+        { OSC_PCI_EXPRESS_AER_CONTROL, "AER" },
+        { OSC_PCI_EXPRESS_CAPABILITY_CONTROL, "PCIeCapability" },
+};
+
+static void decode_osc_bits(struct acpi_pci_root *root, char *msg, u32 word,
+                            struct pci_osc_bit_struct *table, int size)
+{
+        char buf[80];
+        int i, len = 0;
+        struct pci_osc_bit_struct *entry;
+
+        buf[0] = '\0';
+        for (i = 0, entry = table; i < size; i++, entry++)
+                if (word & entry->bit)
+                        len += snprintf(buf + len, sizeof(buf) - len, "%s%s",
+                                        len ? " " : "", entry->desc);
+
+        dev_info(&root->device->dev, "_OSC: %s [%s]\n", msg, buf);
+}
+
+static void decode_osc_support(struct acpi_pci_root *root, char *msg, u32 word)
+{
+        decode_osc_bits(root, msg, word, pci_osc_support_bit,
+                        ARRAY_SIZE(pci_osc_support_bit));
+}
+
+static void decode_osc_control(struct acpi_pci_root *root, char *msg, u32 word)
+{
+        decode_osc_bits(root, msg, word, pci_osc_control_bit,
+                        ARRAY_SIZE(pci_osc_control_bit));
+}
+
 static u8 pci_osc_uuid_str[] = "33DB4D5B-1FF7-401C-9657-7441C03DD766";
 
 static acpi_status acpi_pci_run_osc(acpi_handle handle,
@@ -160,14 +209,14 @@ static acpi_status acpi_pci_query_osc(struct acpi_pci_root *root,
         support &= OSC_PCI_SUPPORT_MASKS;
         support |= root->osc_support_set;
 
-        capbuf[OSC_QUERY_TYPE] = OSC_QUERY_ENABLE;
-        capbuf[OSC_SUPPORT_TYPE] = support;
+        capbuf[OSC_QUERY_DWORD] = OSC_QUERY_ENABLE;
+        capbuf[OSC_SUPPORT_DWORD] = support;
         if (control) {
                 *control &= OSC_PCI_CONTROL_MASKS;
-                capbuf[OSC_CONTROL_TYPE] = *control | root->osc_control_set;
+                capbuf[OSC_CONTROL_DWORD] = *control | root->osc_control_set;
         } else {
                 /* Run _OSC query only with existing controls. */
-                capbuf[OSC_CONTROL_TYPE] = root->osc_control_set;
+                capbuf[OSC_CONTROL_DWORD] = root->osc_control_set;
         }
 
         status = acpi_pci_run_osc(root->device->handle, capbuf, &result);
@@ -182,11 +231,7 @@ static acpi_status acpi_pci_query_osc(struct acpi_pci_root *root,
 static acpi_status acpi_pci_osc_support(struct acpi_pci_root *root, u32 flags)
 {
         acpi_status status;
-        acpi_handle tmp;
 
-        status = acpi_get_handle(root->device->handle, "_OSC", &tmp);
-        if (ACPI_FAILURE(status))
-                return status;
         mutex_lock(&osc_lock);
         status = acpi_pci_query_osc(root, flags, NULL);
         mutex_unlock(&osc_lock);
@@ -318,9 +363,8 @@ EXPORT_SYMBOL_GPL(acpi_get_pci_dev);
 acpi_status acpi_pci_osc_control_set(acpi_handle handle, u32 *mask, u32 req)
 {
         struct acpi_pci_root *root;
-        acpi_status status;
+        acpi_status status = AE_OK;
         u32 ctrl, capbuf[3];
-        acpi_handle tmp;
 
         if (!mask)
                 return AE_BAD_PARAMETER;
@@ -333,10 +377,6 @@ acpi_status acpi_pci_osc_control_set(acpi_handle handle, u32 *mask, u32 req)
         if (!root)
                 return AE_NOT_EXIST;
 
-        status = acpi_get_handle(handle, "_OSC", &tmp);
-        if (ACPI_FAILURE(status))
-                return status;
-
         mutex_lock(&osc_lock);
 
         *mask = ctrl | root->osc_control_set;
@@ -351,17 +391,21 @@ acpi_status acpi_pci_osc_control_set(acpi_handle handle, u32 *mask, u32 req)
                         goto out;
                 if (ctrl == *mask)
                         break;
+                decode_osc_control(root, "platform does not support",
+                                   ctrl & ~(*mask));
                 ctrl = *mask;
         }
 
         if ((ctrl & req) != req) {
+                decode_osc_control(root, "not requesting control; platform does not support",
+                                   req & ~(ctrl));
                 status = AE_SUPPORT;
                 goto out;
         }
 
-        capbuf[OSC_QUERY_TYPE] = 0;
-        capbuf[OSC_SUPPORT_TYPE] = root->osc_support_set;
-        capbuf[OSC_CONTROL_TYPE] = ctrl;
+        capbuf[OSC_QUERY_DWORD] = 0;
+        capbuf[OSC_SUPPORT_DWORD] = root->osc_support_set;
+        capbuf[OSC_CONTROL_DWORD] = ctrl;
         status = acpi_pci_run_osc(handle, capbuf, mask);
         if (ACPI_SUCCESS(status))
                 root->osc_control_set = *mask;
@@ -371,6 +415,87 @@ out:
 }
 EXPORT_SYMBOL(acpi_pci_osc_control_set);
 
+static void negotiate_os_control(struct acpi_pci_root *root, int *no_aspm,
+                                 int *clear_aspm)
+{
+        u32 support, control, requested;
+        acpi_status status;
+        struct acpi_device *device = root->device;
+        acpi_handle handle = device->handle;
+
+        /*
+         * All supported architectures that use ACPI have support for
+         * PCI domains, so we indicate this in _OSC support capabilities.
+         */
+        support = OSC_PCI_SEGMENT_GROUPS_SUPPORT;
+        if (pci_ext_cfg_avail())
+                support |= OSC_PCI_EXT_CONFIG_SUPPORT;
+        if (pcie_aspm_support_enabled())
+                support |= OSC_PCI_ASPM_SUPPORT | OSC_PCI_CLOCK_PM_SUPPORT;
+        if (pci_msi_enabled())
+                support |= OSC_PCI_MSI_SUPPORT;
+
+        decode_osc_support(root, "OS supports", support);
+        status = acpi_pci_osc_support(root, support);
+        if (ACPI_FAILURE(status)) {
+                dev_info(&device->dev, "_OSC failed (%s); disabling ASPM\n",
+                         acpi_format_exception(status));
+                *no_aspm = 1;
+                return;
+        }
+
+        if (pcie_ports_disabled) {
+                dev_info(&device->dev, "PCIe port services disabled; not requesting _OSC control\n");
+                return;
+        }
+
+        if ((support & ACPI_PCIE_REQ_SUPPORT) != ACPI_PCIE_REQ_SUPPORT) {
+                decode_osc_support(root, "not requesting OS control; OS requires",
+                                   ACPI_PCIE_REQ_SUPPORT);
+                return;
+        }
+
+        control = OSC_PCI_EXPRESS_CAPABILITY_CONTROL
+                | OSC_PCI_EXPRESS_NATIVE_HP_CONTROL
+                | OSC_PCI_EXPRESS_PME_CONTROL;
+
+        if (pci_aer_available()) {
+                if (aer_acpi_firmware_first())
+                        dev_info(&device->dev,
+                                 "PCIe AER handled by firmware\n");
+                else
+                        control |= OSC_PCI_EXPRESS_AER_CONTROL;
+        }
+
+        requested = control;
+        status = acpi_pci_osc_control_set(handle, &control,
+                                          OSC_PCI_EXPRESS_CAPABILITY_CONTROL);
+        if (ACPI_SUCCESS(status)) {
+                decode_osc_control(root, "OS now controls", control);
+                if (acpi_gbl_FADT.boot_flags & ACPI_FADT_NO_ASPM) {
+                        /*
+                         * We have ASPM control, but the FADT indicates
+                         * that it's unsupported. Clear it.
+                         */
+                        *clear_aspm = 1;
+                }
+        } else {
+                decode_osc_control(root, "OS requested", requested);
+                decode_osc_control(root, "platform willing to grant", control);
+                dev_info(&device->dev, "_OSC failed (%s); disabling ASPM\n",
+                        acpi_format_exception(status));
+
+                /*
+                 * We want to disable ASPM here, but aspm_disabled
+                 * needs to remain in its state from boot so that we
+                 * properly handle PCIe 1.1 devices.  So we set this
+                 * flag here, to defer the action until after the ACPI
+                 * root scan.
+                 */
+                *no_aspm = 1;
+        }
+}
+
 static int acpi_pci_root_add(struct acpi_device *device,
                              const struct acpi_device_id *not_used)
 {
@@ -378,9 +503,8 @@ static int acpi_pci_root_add(struct acpi_device *device,
         acpi_status status;
         int result;
         struct acpi_pci_root *root;
-        u32 flags, base_flags;
         acpi_handle handle = device->handle;
-        bool no_aspm = false, clear_aspm = false;
+        int no_aspm = 0, clear_aspm = 0;
 
         root = kzalloc(sizeof(struct acpi_pci_root), GFP_KERNEL);
         if (!root)
@@ -433,81 +557,7 @@ static int acpi_pci_root_add(struct acpi_device *device,
 
         root->mcfg_addr = acpi_pci_root_get_mcfg_addr(handle);
 
-        /*
-         * All supported architectures that use ACPI have support for
-         * PCI domains, so we indicate this in _OSC support capabilities.
-         */
-        flags = base_flags = OSC_PCI_SEGMENT_GROUPS_SUPPORT;
-        acpi_pci_osc_support(root, flags);
-
-        if (pci_ext_cfg_avail())
-                flags |= OSC_EXT_PCI_CONFIG_SUPPORT;
-        if (pcie_aspm_support_enabled()) {
-                flags |= OSC_ACTIVE_STATE_PWR_SUPPORT |
-                OSC_CLOCK_PWR_CAPABILITY_SUPPORT;
-        }
-        if (pci_msi_enabled())
-                flags |= OSC_MSI_SUPPORT;
-        if (flags != base_flags) {
-                status = acpi_pci_osc_support(root, flags);
-                if (ACPI_FAILURE(status)) {
-                        dev_info(&device->dev, "ACPI _OSC support "
-                                "notification failed, disabling PCIe ASPM\n");
-                        no_aspm = true;
-                        flags = base_flags;
-                }
-        }
-
-        if (!pcie_ports_disabled
-            && (flags & ACPI_PCIE_REQ_SUPPORT) == ACPI_PCIE_REQ_SUPPORT) {
-                flags = OSC_PCI_EXPRESS_CAP_STRUCTURE_CONTROL
-                        | OSC_PCI_EXPRESS_NATIVE_HP_CONTROL
-                        | OSC_PCI_EXPRESS_PME_CONTROL;
-
-                if (pci_aer_available()) {
-                        if (aer_acpi_firmware_first())
-                                dev_dbg(&device->dev,
-                                        "PCIe errors handled by BIOS.\n");
-                        else
-                                flags |= OSC_PCI_EXPRESS_AER_CONTROL;
-                }
-
-                dev_info(&device->dev,
-                        "Requesting ACPI _OSC control (0x%02x)\n", flags);
-
-                status = acpi_pci_osc_control_set(handle, &flags,
-                                       OSC_PCI_EXPRESS_CAP_STRUCTURE_CONTROL);
-                if (ACPI_SUCCESS(status)) {
-                        dev_info(&device->dev,
-                                "ACPI _OSC control (0x%02x) granted\n", flags);
-                        if (acpi_gbl_FADT.boot_flags & ACPI_FADT_NO_ASPM) {
-                                /*
-                                 * We have ASPM control, but the FADT indicates
-                                 * that it's unsupported. Clear it.
-                                 */
-                                clear_aspm = true;
-                        }
-                } else {
-                        dev_info(&device->dev,
-                                "ACPI _OSC request failed (%s), "
-                                "returned control mask: 0x%02x\n",
-                                acpi_format_exception(status), flags);
-                        dev_info(&device->dev,
-                                 "ACPI _OSC control for PCIe not granted, disabling ASPM\n");
-                        /*
-                         * We want to disable ASPM here, but aspm_disabled
-                         * needs to remain in its state from boot so that we
-                         * properly handle PCIe 1.1 devices.  So we set this
-                         * flag here, to defer the action until after the ACPI
-                         * root scan.
-                         */
-                        no_aspm = true;
-                }
-        } else {
-                dev_info(&device->dev,
-                         "Unable to request _OSC control "
-                         "(_OSC support mask: 0x%02x)\n", flags);
-        }
+        negotiate_os_control(root, &no_aspm, &clear_aspm);
 
         /*
          * TBD: Need PCI interface for enumeration/configuration of roots.