PCI: Use to_pci_driver() instead of pci_dev->driver

Struct pci_driver contains a struct device_driver, so for PCI devices, it's
easy to convert a device_driver * to a pci_driver * with to_pci_driver().
The device_driver * is in struct device, so we don't need to also keep
track of the pci_driver * in struct pci_dev.

Replace pci_dev->driver with to_pci_driver().  This is a step toward
removing pci_dev->driver.

[bhelgaas: split to separate patch]
Link: https://lore.kernel.org/r/20211004125935.2300113-11-u.kleine-koenig@pengutronix.de
Signed-off-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
Signed-off-by: Bjorn Helgaas <bhelgaas@google.com>

diff --git a/drivers/pci/iov.c b/drivers/pci/iov.c
index dafdc652fcd06690a25581e224c4b8a318d90e5d..fa4b52bb1e055b65258cb32a81c4e0daa3b3d416 100644 (file)
--- a/drivers/pci/iov.c
+++ b/drivers/pci/iov.c
@@ -164,13 +164,15 @@ static ssize_t sriov_vf_total_msix_show(struct device *dev,
                                        char *buf)
 {
        struct pci_dev *pdev = to_pci_dev(dev);
+       struct pci_driver *pdrv;
        u32 vf_total_msix = 0;
 
        device_lock(dev);
-       if (!pdev->driver || !pdev->driver->sriov_get_vf_total_msix)
+       pdrv = to_pci_driver(dev->driver);
+       if (!pdrv || !pdrv->sriov_get_vf_total_msix)
                goto unlock;
 
-       vf_total_msix = pdev->driver->sriov_get_vf_total_msix(pdev);
+       vf_total_msix = pdrv->sriov_get_vf_total_msix(pdev);
 unlock:
        device_unlock(dev);
        return sysfs_emit(buf, "%u\n", vf_total_msix);
@@ -183,6 +185,7 @@ static ssize_t sriov_vf_msix_count_store(struct device *dev,
 {
        struct pci_dev *vf_dev = to_pci_dev(dev);
        struct pci_dev *pdev = pci_physfn(vf_dev);
+       struct pci_driver *pdrv;
        int val, ret;
 
        ret = kstrtoint(buf, 0, &val);
@@ -193,13 +196,14 @@ static ssize_t sriov_vf_msix_count_store(struct device *dev,
                return -EINVAL;
 
        device_lock(&pdev->dev);
-       if (!pdev->driver || !pdev->driver->sriov_set_msix_vec_count) {
+       pdrv = to_pci_driver(dev->driver);
+       if (!pdrv || !pdrv->sriov_set_msix_vec_count) {
                ret = -EOPNOTSUPP;
                goto err_pdev;
        }
 
        device_lock(&vf_dev->dev);
-       if (vf_dev->driver) {
+       if (to_pci_driver(vf_dev->dev.driver)) {
                /*
                 * A driver is already attached to this VF and has configured
                 * itself based on the current MSI-X vector count. Changing
@@ -209,7 +213,7 @@ static ssize_t sriov_vf_msix_count_store(struct device *dev,
                goto err_dev;
        }
 
-       ret = pdev->driver->sriov_set_msix_vec_count(vf_dev, val);
+       ret = pdrv->sriov_set_msix_vec_count(vf_dev, val);
 
 err_dev:
        device_unlock(&vf_dev->dev);
@@ -376,6 +380,7 @@ static ssize_t sriov_numvfs_store(struct device *dev,
                                  const char *buf, size_t count)
 {
        struct pci_dev *pdev = to_pci_dev(dev);
+       struct pci_driver *pdrv;
        int ret;
        u16 num_vfs;
 
@@ -392,14 +397,15 @@ static ssize_t sriov_numvfs_store(struct device *dev,
                goto exit;
 
        /* is PF driver loaded */
-       if (!pdev->driver) {
+       pdrv = to_pci_driver(dev->driver);
+       if (!pdrv) {
                pci_info(pdev, "no driver bound to device; cannot configure SR-IOV\n");
                ret = -ENOENT;
                goto exit;
        }
 
        /* is PF driver loaded w/callback */
-       if (!pdev->driver->sriov_configure) {
+       if (!pdrv->sriov_configure) {
                pci_info(pdev, "driver does not support SR-IOV configuration via sysfs\n");
                ret = -ENOENT;
                goto exit;
@@ -407,7 +413,7 @@ static ssize_t sriov_numvfs_store(struct device *dev,
 
        if (num_vfs == 0) {
                /* disable VFs */
-               ret = pdev->driver->sriov_configure(pdev, 0);
+               ret = pdrv->sriov_configure(pdev, 0);
                goto exit;
        }
 
@@ -419,7 +425,7 @@ static ssize_t sriov_numvfs_store(struct device *dev,
                goto exit;
        }
 
-       ret = pdev->driver->sriov_configure(pdev, num_vfs);
+       ret = pdrv->sriov_configure(pdev, num_vfs);
        if (ret < 0)
                goto exit;
 

diff --git a/drivers/pci/pci-driver.c b/drivers/pci/pci-driver.c
index 50449ec622a3edcfdc250425fff2e3ad54d069c4..b919c5361694c64e93cb5f340465838bc5d1d506 100644 (file)
--- a/drivers/pci/pci-driver.c
+++ b/drivers/pci/pci-driver.c
@@ -457,7 +457,7 @@ static int pci_device_probe(struct device *dev)
 static void pci_device_remove(struct device *dev)
 {
        struct pci_dev *pci_dev = to_pci_dev(dev);
-       struct pci_driver *drv = pci_dev->driver;
+       struct pci_driver *drv = to_pci_driver(dev->driver);
 
        if (drv->remove) {
                pm_runtime_get_sync(dev);
@@ -493,7 +493,7 @@ static void pci_device_remove(struct device *dev)
 static void pci_device_shutdown(struct device *dev)
 {
        struct pci_dev *pci_dev = to_pci_dev(dev);
-       struct pci_driver *drv = pci_dev->driver;
+       struct pci_driver *drv = to_pci_driver(dev->driver);
 
        pm_runtime_resume(dev);
 
@@ -589,7 +589,7 @@ static int pci_pm_reenable_device(struct pci_dev *pci_dev)
 static int pci_legacy_suspend(struct device *dev, pm_message_t state)
 {
        struct pci_dev *pci_dev = to_pci_dev(dev);
-       struct pci_driver *drv = pci_dev->driver;
+       struct pci_driver *drv = to_pci_driver(dev->driver);
 
        if (drv && drv->suspend) {
                pci_power_t prev = pci_dev->current_state;
@@ -630,7 +630,7 @@ static int pci_legacy_suspend_late(struct device *dev, pm_message_t state)
 static int pci_legacy_resume(struct device *dev)
 {
        struct pci_dev *pci_dev = to_pci_dev(dev);
-       struct pci_driver *drv = pci_dev->driver;
+       struct pci_driver *drv = to_pci_driver(dev->driver);
 
        pci_fixup_device(pci_fixup_resume, pci_dev);
 
@@ -649,7 +649,7 @@ static void pci_pm_default_suspend(struct pci_dev *pci_dev)
 
 static bool pci_has_legacy_pm_support(struct pci_dev *pci_dev)
 {
-       struct pci_driver *drv = pci_dev->driver;
+       struct pci_driver *drv = to_pci_driver(pci_dev->dev.driver);
        bool ret = drv && (drv->suspend || drv->resume);
 
        /*
@@ -1242,11 +1242,11 @@ static int pci_pm_runtime_suspend(struct device *dev)
        int error;
 
        /*
-        * If pci_dev->driver is not set (unbound), we leave the device in D0,
-        * but it may go to D3cold when the bridge above it runtime suspends.
-        * Save its config space in case that happens.
+        * If the device has no driver, we leave it in D0, but it may go to
+        * D3cold when the bridge above it runtime suspends.  Save its
+        * config space in case that happens.
         */
-       if (!pci_dev->driver) {
+       if (!to_pci_driver(dev->driver)) {
                pci_save_state(pci_dev);
                return 0;
        }
@@ -1303,7 +1303,7 @@ static int pci_pm_runtime_resume(struct device *dev)
         */
        pci_restore_standard_config(pci_dev);
 
-       if (!pci_dev->driver)
+       if (!to_pci_driver(dev->driver))
                return 0;
 
        pci_fixup_device(pci_fixup_resume_early, pci_dev);
@@ -1322,14 +1322,13 @@ static int pci_pm_runtime_resume(struct device *dev)
 
 static int pci_pm_runtime_idle(struct device *dev)
 {
-       struct pci_dev *pci_dev = to_pci_dev(dev);
        const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
 
        /*
-        * If pci_dev->driver is not set (unbound), the device should
-        * always remain in D0 regardless of the runtime PM status
+        * If the device has no driver, it should always remain in D0
+        * regardless of the runtime PM status
         */
-       if (!pci_dev->driver)
+       if (!to_pci_driver(dev->driver))
                return 0;
 
        if (!pm)
@@ -1436,8 +1435,10 @@ static struct pci_driver pci_compat_driver = {
  */
 struct pci_driver *pci_dev_driver(const struct pci_dev *dev)
 {
-       if (dev->driver)
-               return dev->driver;
+       struct pci_driver *drv = to_pci_driver(dev->dev.driver);
+
+       if (drv)
+               return drv;
        else {
                int i;
                for (i = 0; i <= PCI_ROM_RESOURCE; i++)

diff --git a/drivers/pci/pci.c b/drivers/pci/pci.c
index ce2ab62b64cfab5b1212527ffc06201696889689..5298ce131f8cfa74881a3b43488aacc38cee5f4a 100644 (file)
--- a/drivers/pci/pci.c
+++ b/drivers/pci/pci.c
@@ -5088,13 +5088,14 @@ EXPORT_SYMBOL_GPL(pci_dev_unlock);
 
 static void pci_dev_save_and_disable(struct pci_dev *dev)
 {
+       struct pci_driver *drv = to_pci_driver(dev->dev.driver);
        const struct pci_error_handlers *err_handler =
-                       dev->driver ? dev->driver->err_handler : NULL;
+                       drv ? drv->err_handler : NULL;
 
        /*
-        * dev->driver->err_handler->reset_prepare() is protected against
-        * races with ->remove() by the device lock, which must be held by
-        * the caller.
+        * drv->err_handler->reset_prepare() is protected against races
+        * with ->remove() by the device lock, which must be held by the
+        * caller.
         */
        if (err_handler && err_handler->reset_prepare)
                err_handler->reset_prepare(dev);
@@ -5119,15 +5120,15 @@ static void pci_dev_save_and_disable(struct pci_dev *dev)
 
 static void pci_dev_restore(struct pci_dev *dev)
 {
+       struct pci_driver *drv = to_pci_driver(dev->dev.driver);
        const struct pci_error_handlers *err_handler =
-                       dev->driver ? dev->driver->err_handler : NULL;
+                       drv ? drv->err_handler : NULL;
 
        pci_restore_state(dev);
 
        /*
-        * dev->driver->err_handler->reset_done() is protected against
-        * races with ->remove() by the device lock, which must be held by
-        * the caller.
+        * drv->err_handler->reset_done() is protected against races with
+        * ->remove() by the device lock, which must be held by the caller.
         */
        if (err_handler && err_handler->reset_done)
                err_handler->reset_done(dev);

diff --git a/drivers/pci/pcie/err.c b/drivers/pci/pcie/err.c
index 0c5a143025af435e9728ef319185915562d831b2..356b9317297e57a189871c5868cd574b17bd0004 100644 (file)
--- a/drivers/pci/pcie/err.c
+++ b/drivers/pci/pcie/err.c
@@ -54,7 +54,7 @@ static int report_error_detected(struct pci_dev *dev,
        const struct pci_error_handlers *err_handler;
 
        device_lock(&dev->dev);
-       pdrv = dev->driver;
+       pdrv = to_pci_driver(dev->dev.driver);
        if (!pci_dev_set_io_state(dev, state) ||
                !pdrv ||
                !pdrv->err_handler ||
@@ -98,7 +98,7 @@ static int report_mmio_enabled(struct pci_dev *dev, void *data)
        const struct pci_error_handlers *err_handler;
 
        device_lock(&dev->dev);
-       pdrv = dev->driver;
+       pdrv = to_pci_driver(dev->dev.driver);
        if (!pdrv ||
                !pdrv->err_handler ||
                !pdrv->err_handler->mmio_enabled)
@@ -119,7 +119,7 @@ static int report_slot_reset(struct pci_dev *dev, void *data)
        const struct pci_error_handlers *err_handler;
 
        device_lock(&dev->dev);
-       pdrv = dev->driver;
+       pdrv = to_pci_driver(dev->dev.driver);
        if (!pdrv ||
                !pdrv->err_handler ||
                !pdrv->err_handler->slot_reset)
@@ -139,7 +139,7 @@ static int report_resume(struct pci_dev *dev, void *data)
        const struct pci_error_handlers *err_handler;
 
        device_lock(&dev->dev);
-       pdrv = dev->driver;
+       pdrv = to_pci_driver(dev->dev.driver);
        if (!pci_dev_set_io_state(dev, pci_channel_io_normal) ||
                !pdrv ||
                !pdrv->err_handler ||