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

Pull PCI updates from Bjorn Helgaas:
 "Enumeration:

   - Make pci_stop_dev() and pci_destroy_dev() safe so concurrent
     callers can't stop a device multiple times, even as we migrate from
     the global pci_rescan_remove_lock to finer-grained locking (Keith
     Busch)

   - Improve pci_walk_bus() implementation by making it recursive and
     moving locking up to avoid need for a 'locked' parameter (Keith
     Busch)

   - Unexport pci_walk_bus_locked(), which is only used internally by
     the PCI core (Keith Busch)

   - Detect some Thunderbolt chips that are built-in and hence
     'trustworthy' by a heuristic since the 'ExternalFacingPort' and
     'usb4-host-interface' ACPI properties are not quite enough (Esther
     Shimanovich)

  Resource management:

   - Use PCI bus addresses (not CPU addresses) in 'ranges' properties
     when building dynamic DT nodes so systems where PCI and CPU
     addresses differ work correctly (Andrea della Porta)

   - Tidy resource sizing and assignment with helpers to reduce
     redundancy (Ilpo Järvinen)

   - Improve pdev_sort_resources() 'bogus alignment' warning to be more
     specific (Ilpo Järvinen)

  Driver binding:

   - Convert driver .remove_new() callbacks to .remove() again to finish
     the conversion from returning 'int' to being 'void' (Sergio
     Paracuellos)

   - Export pcim_request_all_regions(), a managed interface to request
     all BARs (Philipp Stanner)

   - Replace pcim_iomap_regions_request_all() with
     pcim_request_all_regions(), and pcim_iomap_table()[n] with
     pcim_iomap(n), in the following drivers: ahci, crypto qat, crypto
     octeontx2, intel_th, iwlwifi, ntb idt, serial rp2, ALSA korg1212
     (Philipp Stanner)

   - Remove the now unused pcim_iomap_regions_request_all() (Philipp
     Stanner)

   - Export pcim_iounmap_region(), a managed interface to unmap and
     release a PCI BAR (Philipp Stanner)

   - Replace pcim_iomap_regions(mask) with pcim_iomap_region(n), and
     pcim_iounmap_regions(mask) with pcim_iounmap_region(n), in the
     following drivers: fpga dfl-pci, block mtip32xx, gpio-merrifield,
     cavium (Philipp Stanner)

  Error handling:

   - Add sysfs 'reset_subordinate' to reset the entire hierarchy below a
     bridge; previously Secondary Bus Reset could only be used when
     there was a single device below a bridge (Keith Busch)

   - Warn if we reset a running device where the driver didn't register
     pci_error_handlers notification callbacks (Keith Busch)

  ASPM:

   - Disable ASPM L1 before touching L1 PM Substates to follow the spec
     closer and avoid a CPU load timeout on some platforms (Ajay
     Agarwal)

   - Set devices below Intel VMD to D0 before enabling ASPM L1 Substates
     as required per spec for all L1 Substates changes (Jian-Hong Pan)

  Power management:

   - Enable starfive controller runtime PM before probing host bridge
     (Mayank Rana)

   - Enable runtime power management for host bridges (Krishna chaitanya
     chundru)

  Power control:

   - Use of_platform_device_create() instead of of_platform_populate()
     to create pwrctl platform devices so we can control it based on the
     child nodes (Manivannan Sadhasivam)

   - Create pwrctrl platform devices only if there's a relevant power
     supply property (Manivannan Sadhasivam)

   - Add device link from the pwrctl supplier to the PCI dev to ensure
     pwrctl drivers are probed before the PCI dev driver; this avoids a
     race where pwrctl could change device power state while the PCI
     driver was active (Manivannan Sadhasivam)

   - Find pwrctl device for removal with of_find_device_by_node()
     instead of searching all children of the parent (Manivannan
     Sadhasivam)

   - Rename 'pwrctl' to 'pwrctrl' to match new bandwidth controller
     ('bwctrl') and hotplug files (Bjorn Helgaas)

  Bandwidth control:

   - Add read/modify/write locking for Link Control 2, which is used to
     manage Link speed (Ilpo Järvinen)

   - Extract Link Bandwidth Management Status check into
     pcie_lbms_seen(), where it can be shared between the bandwidth
     controller and quirks that use it to help retrain failed links
     (Ilpo Järvinen)

   - Re-add Link Bandwidth notification support with updates to address
     the reasons it was previously reverted (Alexandru Gagniuc, Ilpo
     Järvinen)

   - Add pcie_set_target_speed() and related functionality so drivers
     can manage PCIe Link speed based on thermal or other constraints
     (Ilpo Järvinen)

   - Add a thermal cooling driver to throttle PCIe Links via the
     existing thermal management framework (Ilpo Järvinen)

   - Add a userspace selftest for the PCIe bandwidth controller (Ilpo
     Järvinen)

  PCI device hotplug:

   - Add hotplug controller driver for Marvell OCTEON multi-function
     device where function 0 has a management console interface to
     enable/disable and provision various personalities for the other
     functions (Shijith Thotton)

   - Retain a reference to the pci_bus for the lifetime of a pci_slot to
     avoid a use-after-free when the thunderbolt driver resets USB4 host
     routers on boot, causing hotplug remove/add of downstream docks or
     other devices (Lukas Wunner)

   - Remove unused cpcihp struct cpci_hp_controller_ops.hardware_test
     (Guilherme Giacomo Simoes)

   - Remove unused cpqphp struct ctrl_dbg.ctrl (Christophe JAILLET)

   - Use pci_bus_read_dev_vendor_id() instead of hand-coded presence
     detection in cpqphp (Ilpo Järvinen)

   - Simplify cpqphp enumeration, which is already simple-minded and
     doesn't handle devices below hot-added bridges (Ilpo Järvinen)

  Virtualization:

   - Add ACS quirk for Wangxun FF5xxx NICs, which don't advertise an ACS
     capability but do isolate functions as though PCI_ACS_RR and
     PCI_ACS_CR were set, so the functions can be in independent IOMMU
     groups (Mengyuan Lou)

  TLP Processing Hints (TPH):

   - Add and document TLP Processing Hints (TPH) support so drivers can
     enable and disable TPH and the kernel can save/restore TPH
     configuration (Wei Huang)

   - Add TPH Steering Tag support so drivers can retrieve Steering Tag
     values associated with specific CPUs via an ACPI _DSM to improve
     performance by directing DMA writes closer to their consumers (Wei
     Huang)

  Data Object Exchange (DOE):

   - Wait up to 1 second for DOE Busy bit to clear before writing a
     request to the mailbox to avoid failures if the mailbox is still
     busy from a previous transfer (Gregory Price)

  Endpoint framework:

   - Skip attempts to allocate from endpoint controller memory window if
     the requested size is larger than the window (Damien Le Moal)

   - Add and document pci_epc_mem_map() and pci_epc_mem_unmap() to
     handle controller-specific size and alignment constraints, and add
     test cases to the endpoint test driver (Damien Le Moal)

   - Implement dwc pci_epc_ops.align_addr() so pci_epc_mem_map() can
     observe DWC-specific alignment requirements (Damien Le Moal)

   - Synchronously cancel command handler work in endpoint test before
     cleaning up DMA and BARs (Damien Le Moal)

   - Respect endpoint page size in dw_pcie_ep_align_addr() (Niklas
     Cassel)

   - Use dw_pcie_ep_align_addr() in dw_pcie_ep_raise_msi_irq() and
     dw_pcie_ep_raise_msix_irq() instead of open coding the equivalent
     (Niklas Cassel)

   - Avoid NULL dereference if Modem Host Interface Endpoint lacks
     'mmio' DT property (Zhongqiu Han)

   - Release PCI domain ID of Endpoint controller parent (not controller
     itself) and before unregistering the controller, to avoid
     use-after-free (Zijun Hu)

   - Clear secondary (not primary) EPC in pci_epc_remove_epf() when
     removing the secondary controller associated with an NTB (Zijun Hu)

  Cadence PCIe controller driver:

   - Lower severity of 'phy-names' message (Bartosz Wawrzyniak)

  Freescale i.MX6 PCIe controller driver:

   - Fix suspend/resume support on i.MX6QDL, which has a hardware
     erratum that prevents use of L2 (Stefan Eichenberger)

  Intel VMD host bridge driver:

   - Add 0xb60b and 0xb06f Device IDs for client SKUs (Nirmal Patel)

  MediaTek PCIe Gen3 controller driver:

   - Update mediatek-gen3 DT binding to require the exact number of
     clocks for each SoC (Fei Shao)

   - Add support for DT 'max-link-speed' and 'num-lanes' properties to
     restrict the link speed and width (AngeloGioacchino Del Regno)

  Microchip PolarFlare PCIe controller driver:

   - Add DT and driver support for using either of the two PolarFire
     Root Ports (Conor Dooley)

  NVIDIA Tegra194 PCIe controller driver:

   - Move endpoint controller cleanups that depend on refclk from the
     host to the notifier that tells us the host has deasserted PERST#,
     when refclk should be valid (Manivannan Sadhasivam)

  Qualcomm PCIe controller driver:

   - Add qcom SAR2130P DT binding with an additional clock (Dmitry
     Baryshkov)

   - Enable MSI interrupts if 'global' IRQ is supported, since a
     previous commit unintentionally masked them (Manivannan Sadhasivam)

   - Move endpoint controller cleanups that depend on refclk from the
     host to the notifier that tells us the host has deasserted PERST#,
     when refclk should be valid (Manivannan Sadhasivam)

   - Add DT binding and driver support for IPQ9574, with Synopsys IP
     v5.80a and Qcom IP 1.27.0 (devi priya)

   - Move the OPP "operating-points-v2" table from the
     qcom,pcie-sm8450.yaml DT binding to qcom,pcie-common.yaml, where it
     can be used by other Qcom platforms (Qiang Yu)

   - Add 'global' SPI interrupt for events like link-up, link-down to
     qcom,pcie-x1e80100 DT binding so we can start enumeration when the
     link comes up (Qiang Yu)

   - Disable ASPM L0s for qcom,pcie-x1e80100 since the PHY is not tuned
     to support this (Qiang Yu)

   - Add ops_1_21_0 for SC8280X family SoC, which doesn't use the
     'iommu-map' DT property and doesn't need BDF-to-SID translation
     (Qiang Yu)

  Rockchip PCIe controller driver:

   - Define ROCKCHIP_PCIE_AT_SIZE_ALIGN to replace magic 256 endpoint
     .align value (Damien Le Moal)

   - When unmapping an endpoint window, compute the region index instead
     of searching for it, and verify that the address was mapped (Damien
     Le Moal)

   - When mapping an endpoint window, verify that the address hasn't
     been mapped already (Damien Le Moal)

   - Implement pci_epc_ops.align_addr() for rockchip-ep (Damien Le Moal)

   - Fix MSI IRQ data mapping to observe the alignment constraint, which
     fixes intermittent page faults in memcpy_toio() and memcpy_fromio()
     (Damien Le Moal)

   - Rename rockchip_pcie_parse_ep_dt() to
     rockchip_pcie_ep_get_resources() for consistency with similar DT
     interfaces (Damien Le Moal)

   - Skip the unnecessary link train in rockchip_pcie_ep_probe() and do
     it only in the endpoint start operation (Damien Le Moal)

   - Implement pci_epc_ops.stop_link() to disable link training and
     controller configuration (Damien Le Moal)

   - Attempt link training at 5 GT/s when both partners support it
     (Damien Le Moal)

   - Add a handler for PERST# signal so we can detect host-initiated
     resets and start link training after PERST# is deasserted (Damien
     Le Moal)

  Synopsys DesignWare PCIe controller driver:

   - Clear outbound address on unmap so dw_pcie_find_index() won't match
     an ATU index that was already unmapped (Damien Le Moal)

   - Use of_property_present() instead of of_property_read_bool() when
     testing for presence of non-boolean DT properties (Rob Herring)

   - Advertise 1MB size if endpoint supports Resizable BARs, which was
     inadvertently lost in v6.11 (Niklas Cassel)

  TI J721E PCIe driver:

   - Add PCIe support for J722S SoC (Siddharth Vadapalli)

   - Delay PCIE_T_PVPERL_MS (100 ms), not just PCIE_T_PERST_CLK_US (100
     us), before deasserting PERST# to ensure power and refclk are
     stable (Siddharth Vadapalli)

  TI Keystone PCIe controller driver:

   - Set the 'ti,keystone-pcie' mode so v3.65a devices work in Root
     Complex mode (Kishon Vijay Abraham I)

   - Try to avoid unrecoverable SError for attempts to issue config
     transactions when the link is down; this is racy but the best we
     can do (Kishon Vijay Abraham I)

  Miscellaneous:

   - Reorganize kerneldoc parameter names to match order in function
     signature (Julia Lawall)

   - Fix sysfs reset_method_store() memory leak (Todd Kjos)

   - Simplify pci_create_slot() (Ilpo Järvinen)

   - Fix incorrect printf format specifiers in pcitest (Luo Yifan)"

* tag 'pci-v6.13-changes' of git://git.kernel.org/pub/scm/linux/kernel/git/pci/pci: (127 commits)
  PCI: rockchip-ep: Handle PERST# signal in EP mode
  PCI: rockchip-ep: Improve link training
  PCI: rockship-ep: Implement the pci_epc_ops::stop_link() operation
  PCI: rockchip-ep: Refactor endpoint link training enable
  PCI: rockchip-ep: Refactor rockchip_pcie_ep_probe() MSI-X hiding
  PCI: rockchip-ep: Refactor rockchip_pcie_ep_probe() memory allocations
  PCI: rockchip-ep: Rename rockchip_pcie_parse_ep_dt()
  PCI: rockchip-ep: Fix MSI IRQ data mapping
  PCI: rockchip-ep: Implement the pci_epc_ops::align_addr() operation
  PCI: rockchip-ep: Improve rockchip_pcie_ep_map_addr()
  PCI: rockchip-ep: Improve rockchip_pcie_ep_unmap_addr()
  PCI: rockchip-ep: Use a macro to define EP controller .align feature
  PCI: rockchip-ep: Fix address translation unit programming
  PCI/pwrctrl: Rename pwrctrl functions and structures
  PCI/pwrctrl: Rename pwrctl files to pwrctrl
  PCI/pwrctl: Remove pwrctl device without iterating over all children of pwrctl parent
  PCI/pwrctl: Ensure that pwrctl drivers are probed before PCI client drivers
  PCI/pwrctl: Create pwrctl device only if at least one power supply is present
  PCI/pwrctl: Use of_platform_device_create() to create pwrctl devices
  tools: PCI: Fix incorrect printf format specifiers
  ...

diff --cc Documentation/admin-guide/kernel-parameters.txt
Simple merge

diff --cc Documentation/driver-api/driver-model/devres.rst
Simple merge

diff --cc MAINTAINERS
Simple merge

diff --cc arch/s390/pci/pci_bus.c
Simple merge

diff --cc drivers/ata/ahci.c
Simple merge

diff --cc drivers/net/wireless/intel/iwlwifi/pcie/trans.c
Simple merge

diff --cc drivers/pci/pci.c
Simple merge

diff --cc drivers/pci/probe.c
index f161580,bf4c76e..2e81ab0
--- 1/drivers/pci/probe.c
--- 2/drivers/pci/probe.c
+++ b/drivers/pci/probe.c
@@@ -3105,9 -3127,18 +3127,20 @@@ int pci_host_probe(struct pci_host_brid
        list_for_each_entry(child, &bus->children, node)
                pcie_bus_configure_settings(child);
  
 +      pci_lock_rescan_remove();
        pci_bus_add_devices(bus);
 +      pci_unlock_rescan_remove();
+ 
+       /*
+        * Ensure pm_runtime_enable() is called for the controller drivers
+        * before calling pci_host_probe(). The PM framework expects that
+        * if the parent device supports runtime PM, it will be enabled
+        * before child runtime PM is enabled.
+        */
+       pm_runtime_set_active(&bridge->dev);
+       pm_runtime_no_callbacks(&bridge->dev);
+       devm_pm_runtime_enable(&bridge->dev);
+ 
        return 0;
  }
  EXPORT_SYMBOL_GPL(pci_host_probe);

diff --cc drivers/pci/pwrctrl/pci-pwrctrl-pwrseq.c
index 0000000,e9f8986..4e664e7
mode 000000,100644..100644
--- /dev/null
--- 2/drivers/pci/pwrctrl/pci-pwrctrl-pwrseq.c
+++ b/drivers/pci/pwrctrl/pci-pwrctrl-pwrseq.c
@@@ -1,0 -1,94 +1,139 @@@
 -#include <linux/of.h>
+ // SPDX-License-Identifier: GPL-2.0-only
+ /*
+  * Copyright (C) 2024 Linaro Ltd.
+  */
+ 
+ #include <linux/device.h>
+ #include <linux/mod_devicetable.h>
+ #include <linux/module.h>
 -      data->pwrseq = devm_pwrseq_get(dev, of_device_get_match_data(dev));
+ #include <linux/pci-pwrctrl.h>
+ #include <linux/platform_device.h>
++#include <linux/property.h>
+ #include <linux/pwrseq/consumer.h>
+ #include <linux/slab.h>
+ #include <linux/types.h>
+ 
+ struct pci_pwrctrl_pwrseq_data {
+       struct pci_pwrctrl ctx;
+       struct pwrseq_desc *pwrseq;
+ };
+ 
++struct pci_pwrctrl_pwrseq_pdata {
++      const char *target;
++      /*
++       * Called before doing anything else to perform device-specific
++       * verification between requesting the power sequencing handle.
++       */
++      int (*validate_device)(struct device *dev);
++};
++
++static int pci_pwrctrl_pwrseq_qcm_wcn_validate_device(struct device *dev)
++{
++      /*
++       * Old device trees for some platforms already define wifi nodes for
++       * the WCN family of chips since before power sequencing was added
++       * upstream.
++       *
++       * These nodes don't consume the regulator outputs from the PMU, and
++       * if we allow this driver to bind to one of such "incomplete" nodes,
++       * we'll see a kernel log error about the indefinite probe deferral.
++       *
++       * Check the existence of the regulator supply that exists on all
++       * WCN models before moving forward.
++       */
++      if (!device_property_present(dev, "vddaon-supply"))
++              return -ENODEV;
++
++      return 0;
++}
++
++static const struct pci_pwrctrl_pwrseq_pdata pci_pwrctrl_pwrseq_qcom_wcn_pdata = {
++      .target = "wlan",
++      .validate_device = pci_pwrctrl_pwrseq_qcm_wcn_validate_device,
++};
++
+ static void devm_pci_pwrctrl_pwrseq_power_off(void *data)
+ {
+       struct pwrseq_desc *pwrseq = data;
+ 
+       pwrseq_power_off(pwrseq);
+ }
+ 
+ static int pci_pwrctrl_pwrseq_probe(struct platform_device *pdev)
+ {
++      const struct pci_pwrctrl_pwrseq_pdata *pdata;
+       struct pci_pwrctrl_pwrseq_data *data;
+       struct device *dev = &pdev->dev;
+       int ret;
+ 
++      pdata = device_get_match_data(dev);
++      if (!pdata || !pdata->target)
++              return -EINVAL;
++
++      if (pdata->validate_device) {
++              ret = pdata->validate_device(dev);
++              if (ret)
++                      return ret;
++      }
++
+       data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
+       if (!data)
+               return -ENOMEM;
+ 
 -              .data = "wlan",
++      data->pwrseq = devm_pwrseq_get(dev, pdata->target);
+       if (IS_ERR(data->pwrseq))
+               return dev_err_probe(dev, PTR_ERR(data->pwrseq),
+                                    "Failed to get the power sequencer\n");
+ 
+       ret = pwrseq_power_on(data->pwrseq);
+       if (ret)
+               return dev_err_probe(dev, ret,
+                                    "Failed to power-on the device\n");
+ 
+       ret = devm_add_action_or_reset(dev, devm_pci_pwrctrl_pwrseq_power_off,
+                                      data->pwrseq);
+       if (ret)
+               return ret;
+ 
+       pci_pwrctrl_init(&data->ctx, dev);
+ 
+       ret = devm_pci_pwrctrl_device_set_ready(dev, &data->ctx);
+       if (ret)
+               return dev_err_probe(dev, ret,
+                                    "Failed to register the pwrctrl wrapper\n");
+ 
+       return 0;
+ }
+ 
+ static const struct of_device_id pci_pwrctrl_pwrseq_of_match[] = {
+       {
+               /* ATH11K in QCA6390 package. */
+               .compatible = "pci17cb,1101",
 -              .data = "wlan",
++              .data = &pci_pwrctrl_pwrseq_qcom_wcn_pdata,
+       },
+       {
+               /* ATH11K in WCN6855 package. */
+               .compatible = "pci17cb,1103",
 -              .data = "wlan",
++              .data = &pci_pwrctrl_pwrseq_qcom_wcn_pdata,
+       },
+       {
+               /* ATH12K in WCN7850 package. */
+               .compatible = "pci17cb,1107",
++              .data = &pci_pwrctrl_pwrseq_qcom_wcn_pdata,
+       },
+       { }
+ };
+ MODULE_DEVICE_TABLE(of, pci_pwrctrl_pwrseq_of_match);
+ 
+ static struct platform_driver pci_pwrctrl_pwrseq_driver = {
+       .driver = {
+               .name = "pci-pwrctrl-pwrseq",
+               .of_match_table = pci_pwrctrl_pwrseq_of_match,
+       },
+       .probe = pci_pwrctrl_pwrseq_probe,
+ };
+ module_platform_driver(pci_pwrctrl_pwrseq_driver);
+ 
+ MODULE_AUTHOR("Bartosz Golaszewski <bartosz.golaszewski@linaro.org>");
+ MODULE_DESCRIPTION("Generic PCI Power Control module for power sequenced devices");
+ MODULE_LICENSE("GPL");

diff --cc drivers/pci/quirks.c
Simple merge

diff --cc drivers/thermal/Makefile
Simple merge

diff --cc include/linux/pci.h
Simple merge

diff --cc tools/testing/selftests/Makefile
Simple merge