thunderbolt: Move pci_device out of tb_nhi

Not all USB4/TB implementations are based on a PCIe-attached
controller. In order to make way for these, start off with moving the
pci_device reference out of the main tb_nhi structure.

Encapsulate the existing struct in a new tb_nhi_pci, that shall also
house all properties that relate to the parent bus. Similarly, any
other type of controller will be expected to contain tb_nhi as a
member.

Signed-off-by: Konrad Dybcio <konrad.dybcio@oss.qualcomm.com>
Signed-off-by: Mika Westerberg <mika.westerberg@linux.intel.com>

diff --git a/drivers/thunderbolt/acpi.c b/drivers/thunderbolt/acpi.c
index 45d1415871b4052f3e7882e8c37a0f1edf0d95eb..53546bc477a5b47e2d107087bab1c27f6c8c4222 100644 (file)
--- a/drivers/thunderbolt/acpi.c
+++ b/drivers/thunderbolt/acpi.c
@@ -28,7 +28,7 @@ static acpi_status tb_acpi_add_link(acpi_handle handle, u32 level, void *data,
                return AE_OK;
 
        /* It needs to reference this NHI */
-       if (dev_fwnode(&nhi->pdev->dev) != fwnode)
+       if (dev_fwnode(nhi->dev) != fwnode)
                goto out_put;
 
        /*
@@ -57,16 +57,16 @@ static acpi_status tb_acpi_add_link(acpi_handle handle, u32 level, void *data,
                 */
                pm_runtime_get_sync(&pdev->dev);
 
-               link = device_link_add(&pdev->dev, &nhi->pdev->dev,
+               link = device_link_add(&pdev->dev, nhi->dev,
                                       DL_FLAG_AUTOREMOVE_SUPPLIER |
                                       DL_FLAG_RPM_ACTIVE |
                                       DL_FLAG_PM_RUNTIME);
                if (link) {
-                       dev_dbg(&nhi->pdev->dev, "created link from %s\n",
+                       dev_dbg(nhi->dev, "created link from %s\n",
                                dev_name(&pdev->dev));
                        *(bool *)ret = true;
                } else {
-                       dev_warn(&nhi->pdev->dev, "device link creation from %s failed\n",
+                       dev_warn(nhi->dev, "device link creation from %s failed\n",
                                 dev_name(&pdev->dev));
                }
 
@@ -93,7 +93,7 @@ bool tb_acpi_add_links(struct tb_nhi *nhi)
        acpi_status status;
        bool ret = false;
 
-       if (!has_acpi_companion(&nhi->pdev->dev))
+       if (!has_acpi_companion(nhi->dev))
                return false;
 
        /*
@@ -103,7 +103,7 @@ bool tb_acpi_add_links(struct tb_nhi *nhi)
        status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT, 32,
                                     tb_acpi_add_link, NULL, nhi, (void **)&ret);
        if (ACPI_FAILURE(status)) {
-               dev_warn(&nhi->pdev->dev, "failed to enumerate tunneled ports\n");
+               dev_warn(nhi->dev, "failed to enumerate tunneled ports\n");
                return false;
        }
 
@@ -305,7 +305,7 @@ static struct acpi_device *tb_acpi_switch_find_companion(struct tb_switch *sw)
                struct tb_nhi *nhi = sw->tb->nhi;
                struct acpi_device *parent_adev;
 
-               parent_adev = ACPI_COMPANION(&nhi->pdev->dev);
+               parent_adev = ACPI_COMPANION(nhi->dev);
                if (parent_adev)
                        adev = acpi_find_child_device(parent_adev, 0, false);
        }

diff --git a/drivers/thunderbolt/ctl.c b/drivers/thunderbolt/ctl.c
index b2fd60fc7bcc78a62e62612fd08ce90f1ae201c9..cd47b627f97b27abb3dde4effd81d2d0ec852383 100644 (file)
--- a/drivers/thunderbolt/ctl.c
+++ b/drivers/thunderbolt/ctl.c
@@ -56,22 +56,22 @@ struct tb_ctl {
 
 
 #define tb_ctl_WARN(ctl, format, arg...) \
-       dev_WARN(&(ctl)->nhi->pdev->dev, format, ## arg)
+       dev_WARN((ctl)->nhi->dev, format, ## arg)
 
 #define tb_ctl_err(ctl, format, arg...) \
-       dev_err(&(ctl)->nhi->pdev->dev, format, ## arg)
+       dev_err((ctl)->nhi->dev, format, ## arg)
 
 #define tb_ctl_warn(ctl, format, arg...) \
-       dev_warn(&(ctl)->nhi->pdev->dev, format, ## arg)
+       dev_warn((ctl)->nhi->dev, format, ## arg)
 
 #define tb_ctl_info(ctl, format, arg...) \
-       dev_info(&(ctl)->nhi->pdev->dev, format, ## arg)
+       dev_info((ctl)->nhi->dev, format, ## arg)
 
 #define tb_ctl_dbg(ctl, format, arg...) \
-       dev_dbg(&(ctl)->nhi->pdev->dev, format, ## arg)
+       dev_dbg((ctl)->nhi->dev, format, ## arg)
 
 #define tb_ctl_dbg_once(ctl, format, arg...) \
-       dev_dbg_once(&(ctl)->nhi->pdev->dev, format, ## arg)
+       dev_dbg_once((ctl)->nhi->dev, format, ## arg)
 
 static DECLARE_WAIT_QUEUE_HEAD(tb_cfg_request_cancel_queue);
 /* Serializes access to request kref_get/put */
@@ -666,8 +666,8 @@ struct tb_ctl *tb_ctl_alloc(struct tb_nhi *nhi, int index, int timeout_msec,
 
        mutex_init(&ctl->request_queue_lock);
        INIT_LIST_HEAD(&ctl->request_queue);
-       ctl->frame_pool = dma_pool_create("thunderbolt_ctl", &nhi->pdev->dev,
-                                        TB_FRAME_SIZE, 4, 0);
+       ctl->frame_pool = dma_pool_create("thunderbolt_ctl", nhi->dev,
+                                         TB_FRAME_SIZE, 4, 0);
        if (!ctl->frame_pool)
                goto err;
 

diff --git a/drivers/thunderbolt/domain.c b/drivers/thunderbolt/domain.c
index b381f184340ec5178425497831f77dd9fc9a0db8..479fa4d265c212e25d61cd5f4c36aeb1a477fe47 100644 (file)
--- a/drivers/thunderbolt/domain.c
+++ b/drivers/thunderbolt/domain.c
@@ -405,7 +405,7 @@ struct tb *tb_domain_alloc(struct tb_nhi *nhi, int timeout_msec, size_t privsize
        if (!tb->ctl)
                goto err_destroy_wq;
 
-       tb->dev.parent = &nhi->pdev->dev;
+       tb->dev.parent = nhi->dev;
        tb->dev.bus = &tb_bus_type;
        tb->dev.type = &tb_domain_type;
        tb->dev.groups = domain_attr_groups;

diff --git a/drivers/thunderbolt/eeprom.c b/drivers/thunderbolt/eeprom.c
index 5477b943704817922276e2cc775d7f2f094b910a..5681c17f82ecc130a642d9eaf0c23533a1b0e634 100644 (file)
--- a/drivers/thunderbolt/eeprom.c
+++ b/drivers/thunderbolt/eeprom.c
@@ -465,7 +465,7 @@ static void tb_switch_drom_free(struct tb_switch *sw)
  */
 static int tb_drom_copy_efi(struct tb_switch *sw, u16 *size)
 {
-       struct device *dev = &sw->tb->nhi->pdev->dev;
+       struct device *dev = sw->tb->nhi->dev;
        int len, res;
 
        len = device_property_count_u8(dev, "ThunderboltDROM");

diff --git a/drivers/thunderbolt/icm.c b/drivers/thunderbolt/icm.c
index c492995166f7a5f12daed2c80c8495543c8da780..10fefac3b1d9318e9545111298bd3ad45b93eb8a 100644 (file)
--- a/drivers/thunderbolt/icm.c
+++ b/drivers/thunderbolt/icm.c
@@ -1466,6 +1466,7 @@ static struct pci_dev *get_upstream_port(struct pci_dev *pdev)
 
 static bool icm_ar_is_supported(struct tb *tb)
 {
+       struct pci_dev *pdev = to_pci_dev(tb->nhi->dev);
        struct pci_dev *upstream_port;
        struct icm *icm = tb_priv(tb);
 
@@ -1483,7 +1484,7 @@ static bool icm_ar_is_supported(struct tb *tb)
         * Find the upstream PCIe port in case we need to do reset
         * through its vendor specific registers.
         */
-       upstream_port = get_upstream_port(tb->nhi->pdev);
+       upstream_port = get_upstream_port(pdev);
        if (upstream_port) {
                int cap;
 
@@ -1519,7 +1520,7 @@ static int icm_ar_get_mode(struct tb *tb)
        } while (--retries);
 
        if (!retries) {
-               dev_err(&nhi->pdev->dev, "ICM firmware not authenticated\n");
+               dev_err(nhi->dev, "ICM firmware not authenticated\n");
                return -ENODEV;
        }
 
@@ -1685,11 +1686,11 @@ icm_icl_driver_ready(struct tb *tb, enum tb_security_level *security_level,
 
 static void icm_icl_set_uuid(struct tb *tb)
 {
-       struct tb_nhi *nhi = tb->nhi;
+       struct pci_dev *pdev = to_pci_dev(tb->nhi->dev);
        u32 uuid[4];
 
-       pci_read_config_dword(nhi->pdev, VS_CAP_10, &uuid[0]);
-       pci_read_config_dword(nhi->pdev, VS_CAP_11, &uuid[1]);
+       pci_read_config_dword(pdev, VS_CAP_10, &uuid[0]);
+       pci_read_config_dword(pdev, VS_CAP_11, &uuid[1]);
        uuid[2] = 0xffffffff;
        uuid[3] = 0xffffffff;
 
@@ -1866,7 +1867,7 @@ static int icm_firmware_start(struct tb *tb, struct tb_nhi *nhi)
        if (icm_firmware_running(nhi))
                return 0;
 
-       dev_dbg(&nhi->pdev->dev, "starting ICM firmware\n");
+       dev_dbg(nhi->dev, "starting ICM firmware\n");
 
        ret = icm_firmware_reset(tb, nhi);
        if (ret)
@@ -1961,7 +1962,7 @@ static int icm_firmware_init(struct tb *tb)
 
        ret = icm_firmware_start(tb, nhi);
        if (ret) {
-               dev_err(&nhi->pdev->dev, "could not start ICM firmware\n");
+               dev_err(nhi->dev, "could not start ICM firmware\n");
                return ret;
        }
 
@@ -1993,10 +1994,10 @@ static int icm_firmware_init(struct tb *tb)
         */
        ret = icm_reset_phy_port(tb, 0);
        if (ret)
-               dev_warn(&nhi->pdev->dev, "failed to reset links on port0\n");
+               dev_warn(nhi->dev, "failed to reset links on port0\n");
        ret = icm_reset_phy_port(tb, 1);
        if (ret)
-               dev_warn(&nhi->pdev->dev, "failed to reset links on port1\n");
+               dev_warn(nhi->dev, "failed to reset links on port1\n");
 
        return 0;
 }
@@ -2477,6 +2478,7 @@ static const struct tb_cm_ops icm_icl_ops = {
 
 struct tb *icm_probe(struct tb_nhi *nhi)
 {
+       struct pci_dev *pdev = to_pci_dev(nhi->dev);
        struct icm *icm;
        struct tb *tb;
 
@@ -2488,7 +2490,7 @@ struct tb *icm_probe(struct tb_nhi *nhi)
        INIT_DELAYED_WORK(&icm->rescan_work, icm_rescan_work);
        mutex_init(&icm->request_lock);
 
-       switch (nhi->pdev->device) {
+       switch (pdev->device) {
        case PCI_DEVICE_ID_INTEL_FALCON_RIDGE_2C_NHI:
        case PCI_DEVICE_ID_INTEL_FALCON_RIDGE_4C_NHI:
                icm->can_upgrade_nvm = true;
@@ -2594,7 +2596,7 @@ struct tb *icm_probe(struct tb_nhi *nhi)
        }
 
        if (!icm->is_supported || !icm->is_supported(tb)) {
-               dev_dbg(&nhi->pdev->dev, "ICM not supported on this controller\n");
+               dev_dbg(nhi->dev, "ICM not supported on this controller\n");
                tb_domain_put(tb);
                return NULL;
        }

diff --git a/drivers/thunderbolt/nhi.c b/drivers/thunderbolt/nhi.c
index a0a789bfb680ff2a97c0cc19e88573fb9de75bbe..d21c8d330f6c2e3a5430c0dc499e2e9da04fe04a 100644 (file)
--- a/drivers/thunderbolt/nhi.c
+++ b/drivers/thunderbolt/nhi.c
@@ -2,7 +2,7 @@
 /*
  * Thunderbolt driver - NHI driver
  *
- * The NHI (native host interface) is the pci device that allows us to send and
+ * The NHI (native host interface) is the device that allows us to send and
  * receive frames from the thunderbolt bus.
  *
  * Copyright (c) 2014 Andreas Noever <andreas.noever@gmail.com>
@@ -12,7 +12,6 @@
 #include <linux/pm_runtime.h>
 #include <linux/slab.h>
 #include <linux/errno.h>
-#include <linux/pci.h>
 #include <linux/dma-mapping.h>
 #include <linux/interrupt.h>
 #include <linux/iommu.h>
@@ -51,6 +50,21 @@ static bool host_reset = true;
 module_param(host_reset, bool, 0444);
 MODULE_PARM_DESC(host_reset, "reset USB4 host router (default: true)");
 
+/**
+ * struct tb_nhi_pci - NHI device connected over PCIe
+ * @nhi: NHI device
+ * @msix_ida: Used to allocate MSI-X vectors for rings
+ */
+struct tb_nhi_pci {
+       struct tb_nhi nhi;
+       struct ida msix_ida;
+};
+
+static inline struct tb_nhi_pci *nhi_to_pci(struct tb_nhi *nhi)
+{
+       return container_of(nhi, struct tb_nhi_pci, nhi);
+}
+
 static int ring_interrupt_index(const struct tb_ring *ring)
 {
        int bit = ring->hop;
@@ -145,15 +159,14 @@ static void ring_interrupt_active(struct tb_ring *ring, bool active)
        else
                new = old & ~mask;
 
-       dev_dbg(&ring->nhi->pdev->dev,
+       dev_dbg(ring->nhi->dev,
                "%s interrupt at register %#x bit %d (%#x -> %#x)\n",
                active ? "enabling" : "disabling", reg, interrupt_bit, old, new);
 
        if (new == old)
-               dev_WARN(&ring->nhi->pdev->dev,
-                                        "interrupt for %s %d is already %s\n",
-                                        RING_TYPE(ring), ring->hop,
-                                        str_enabled_disabled(active));
+               dev_WARN(ring->nhi->dev, "interrupt for %s %d is already %s\n",
+                        RING_TYPE(ring), ring->hop,
+                        str_enabled_disabled(active));
 
        if (active)
                iowrite32(new, ring->nhi->iobase + reg);
@@ -470,19 +483,21 @@ static irqreturn_t ring_msix(int irq, void *data)
 static int ring_request_msix(struct tb_ring *ring, bool no_suspend)
 {
        struct tb_nhi *nhi = ring->nhi;
+       struct tb_nhi_pci *nhi_pci = nhi_to_pci(nhi);
+       struct pci_dev *pdev = to_pci_dev(nhi->dev);
        unsigned long irqflags;
        int ret;
 
-       if (!nhi->pdev->msix_enabled)
+       if (!pdev->msix_enabled)
                return 0;
 
-       ret = ida_alloc_max(&nhi->msix_ida, MSIX_MAX_VECS - 1, GFP_KERNEL);
+       ret = ida_alloc_max(&nhi_pci->msix_ida, MSIX_MAX_VECS - 1, GFP_KERNEL);
        if (ret < 0)
                return ret;
 
        ring->vector = ret;
 
-       ret = pci_irq_vector(ring->nhi->pdev, ring->vector);
+       ret = pci_irq_vector(pdev, ring->vector);
        if (ret < 0)
                goto err_ida_remove;
 
@@ -496,18 +511,20 @@ static int ring_request_msix(struct tb_ring *ring, bool no_suspend)
        return 0;
 
 err_ida_remove:
-       ida_free(&nhi->msix_ida, ring->vector);
+       ida_free(&nhi_pci->msix_ida, ring->vector);
 
        return ret;
 }
 
 static void ring_release_msix(struct tb_ring *ring)
 {
+       struct tb_nhi_pci *nhi_pci = nhi_to_pci(ring->nhi);
+
        if (ring->irq <= 0)
                return;
 
        free_irq(ring->irq, ring);
-       ida_free(&ring->nhi->msix_ida, ring->vector);
+       ida_free(&nhi_pci->msix_ida, ring->vector);
        ring->vector = 0;
        ring->irq = 0;
 }
@@ -520,7 +537,7 @@ static int nhi_alloc_hop(struct tb_nhi *nhi, struct tb_ring *ring)
        if (nhi->quirks & QUIRK_E2E) {
                start_hop = RING_FIRST_USABLE_HOPID + 1;
                if (ring->flags & RING_FLAG_E2E && !ring->is_tx) {
-                       dev_dbg(&nhi->pdev->dev, "quirking E2E TX HopID %u -> %u\n",
+                       dev_dbg(nhi->dev, "quirking E2E TX HopID %u -> %u\n",
                                ring->e2e_tx_hop, RING_E2E_RESERVED_HOPID);
                        ring->e2e_tx_hop = RING_E2E_RESERVED_HOPID;
                }
@@ -551,23 +568,23 @@ static int nhi_alloc_hop(struct tb_nhi *nhi, struct tb_ring *ring)
        }
 
        if (ring->hop > 0 && ring->hop < start_hop) {
-               dev_warn(&nhi->pdev->dev, "invalid hop: %d\n", ring->hop);
+               dev_warn(nhi->dev, "invalid hop: %d\n", ring->hop);
                ret = -EINVAL;
                goto err_unlock;
        }
        if (ring->hop < 0 || ring->hop >= nhi->hop_count) {
-               dev_warn(&nhi->pdev->dev, "invalid hop: %d\n", ring->hop);
+               dev_warn(nhi->dev, "invalid hop: %d\n", ring->hop);
                ret = -EINVAL;
                goto err_unlock;
        }
        if (ring->is_tx && nhi->tx_rings[ring->hop]) {
-               dev_warn(&nhi->pdev->dev, "TX hop %d already allocated\n",
+               dev_warn(nhi->dev, "TX hop %d already allocated\n",
                         ring->hop);
                ret = -EBUSY;
                goto err_unlock;
        }
        if (!ring->is_tx && nhi->rx_rings[ring->hop]) {
-               dev_warn(&nhi->pdev->dev, "RX hop %d already allocated\n",
+               dev_warn(nhi->dev, "RX hop %d already allocated\n",
                         ring->hop);
                ret = -EBUSY;
                goto err_unlock;
@@ -592,7 +609,7 @@ static struct tb_ring *tb_ring_alloc(struct tb_nhi *nhi, u32 hop, int size,
 {
        struct tb_ring *ring = NULL;
 
-       dev_dbg(&nhi->pdev->dev, "allocating %s ring %d of size %d\n",
+       dev_dbg(nhi->dev, "allocating %s ring %d of size %d\n",
                transmit ? "TX" : "RX", hop, size);
 
        ring = kzalloc_obj(*ring);
@@ -619,9 +636,9 @@ static struct tb_ring *tb_ring_alloc(struct tb_nhi *nhi, u32 hop, int size,
        ring->start_poll = start_poll;
        ring->poll_data = poll_data;
 
-       ring->descriptors = dma_alloc_coherent(&ring->nhi->pdev->dev,
-                       size * sizeof(*ring->descriptors),
-                       &ring->descriptors_dma, GFP_KERNEL | __GFP_ZERO);
+       ring->descriptors = dma_alloc_coherent(ring->nhi->dev,
+                                              size * sizeof(*ring->descriptors),
+                                              &ring->descriptors_dma, GFP_KERNEL | __GFP_ZERO);
        if (!ring->descriptors)
                goto err_free_ring;
 
@@ -636,7 +653,7 @@ static struct tb_ring *tb_ring_alloc(struct tb_nhi *nhi, u32 hop, int size,
 err_release_msix:
        ring_release_msix(ring);
 err_free_descs:
-       dma_free_coherent(&ring->nhi->pdev->dev,
+       dma_free_coherent(ring->nhi->dev,
                          ring->size * sizeof(*ring->descriptors),
                          ring->descriptors, ring->descriptors_dma);
 err_free_ring:
@@ -703,10 +720,10 @@ void tb_ring_start(struct tb_ring *ring)
        if (ring->nhi->going_away)
                goto err;
        if (ring->running) {
-               dev_WARN(&ring->nhi->pdev->dev, "ring already started\n");
+               dev_WARN(ring->nhi->dev, "ring already started\n");
                goto err;
        }
-       dev_dbg(&ring->nhi->pdev->dev, "starting %s %d\n",
+       dev_dbg(ring->nhi->dev, "starting %s %d\n",
                RING_TYPE(ring), ring->hop);
 
        if (ring->flags & RING_FLAG_FRAME) {
@@ -743,11 +760,11 @@ void tb_ring_start(struct tb_ring *ring)
                        hop &= REG_RX_OPTIONS_E2E_HOP_MASK;
                        flags |= hop;
 
-                       dev_dbg(&ring->nhi->pdev->dev,
+                       dev_dbg(ring->nhi->dev,
                                "enabling E2E for %s %d with TX HopID %d\n",
                                RING_TYPE(ring), ring->hop, ring->e2e_tx_hop);
                } else {
-                       dev_dbg(&ring->nhi->pdev->dev, "enabling E2E for %s %d\n",
+                       dev_dbg(ring->nhi->dev, "enabling E2E for %s %d\n",
                                RING_TYPE(ring), ring->hop);
                }
 
@@ -806,12 +823,12 @@ void tb_ring_stop(struct tb_ring *ring)
 {
        spin_lock_irq(&ring->nhi->lock);
        spin_lock(&ring->lock);
-       dev_dbg(&ring->nhi->pdev->dev, "stopping %s %d\n",
+       dev_dbg(ring->nhi->dev, "stopping %s %d\n",
                RING_TYPE(ring), ring->hop);
        if (ring->nhi->going_away)
                goto err;
        if (!ring->running) {
-               dev_WARN(&ring->nhi->pdev->dev, "%s %d already stopped\n",
+               dev_WARN(ring->nhi->dev, "%s %d already stopped\n",
                         RING_TYPE(ring), ring->hop);
                goto err;
        }
@@ -860,14 +877,14 @@ void tb_ring_free(struct tb_ring *ring)
                ring->nhi->rx_rings[ring->hop] = NULL;
 
        if (ring->running) {
-               dev_WARN(&ring->nhi->pdev->dev, "%s %d still running\n",
+               dev_WARN(ring->nhi->dev, "%s %d still running\n",
                         RING_TYPE(ring), ring->hop);
        }
        spin_unlock_irq(&ring->nhi->lock);
 
        ring_release_msix(ring);
 
-       dma_free_coherent(&ring->nhi->pdev->dev,
+       dma_free_coherent(ring->nhi->dev,
                          ring->size * sizeof(*ring->descriptors),
                          ring->descriptors, ring->descriptors_dma);
 
@@ -875,7 +892,7 @@ void tb_ring_free(struct tb_ring *ring)
        ring->descriptors_dma = 0;
 
 
-       dev_dbg(&ring->nhi->pdev->dev, "freeing %s %d\n", RING_TYPE(ring),
+       dev_dbg(ring->nhi->dev, "freeing %s %d\n", RING_TYPE(ring),
                ring->hop);
 
        /*
@@ -994,9 +1011,7 @@ static void nhi_interrupt_work(struct work_struct *work)
                if ((value & (1 << (bit % 32))) == 0)
                        continue;
                if (type == 2) {
-                       dev_warn(&nhi->pdev->dev,
-                                "RX overflow for ring %d\n",
-                                hop);
+                       dev_warn(nhi->dev, "RX overflow for ring %d\n", hop);
                        continue;
                }
                if (type == 0)
@@ -1004,7 +1019,7 @@ static void nhi_interrupt_work(struct work_struct *work)
                else
                        ring = nhi->rx_rings[hop];
                if (ring == NULL) {
-                       dev_warn(&nhi->pdev->dev,
+                       dev_warn(nhi->dev,
                                 "got interrupt for inactive %s ring %d\n",
                                 type ? "RX" : "TX",
                                 hop);
@@ -1173,16 +1188,18 @@ static int nhi_runtime_resume(struct device *dev)
 
 static void nhi_shutdown(struct tb_nhi *nhi)
 {
+       struct tb_nhi_pci *nhi_pci = nhi_to_pci(nhi);
+       struct pci_dev *pdev = to_pci_dev(nhi->dev);
        int i;
 
-       dev_dbg(&nhi->pdev->dev, "shutdown\n");
+       dev_dbg(nhi->dev, "shutdown\n");
 
        for (i = 0; i < nhi->hop_count; i++) {
                if (nhi->tx_rings[i])
-                       dev_WARN(&nhi->pdev->dev,
+                       dev_WARN(nhi->dev,
                                 "TX ring %d is still active\n", i);
                if (nhi->rx_rings[i])
-                       dev_WARN(&nhi->pdev->dev,
+                       dev_WARN(nhi->dev,
                                 "RX ring %d is still active\n", i);
        }
        nhi_disable_interrupts(nhi);
@@ -1190,19 +1207,22 @@ static void nhi_shutdown(struct tb_nhi *nhi)
         * We have to release the irq before calling flush_work. Otherwise an
         * already executing IRQ handler could call schedule_work again.
         */
-       if (!nhi->pdev->msix_enabled) {
-               devm_free_irq(&nhi->pdev->dev, nhi->pdev->irq, nhi);
+       if (!pdev->msix_enabled) {
+               devm_free_irq(nhi->dev, pdev->irq, nhi);
                flush_work(&nhi->interrupt_work);
        }
-       ida_destroy(&nhi->msix_ida);
+       ida_destroy(&nhi_pci->msix_ida);
 
        if (nhi->ops && nhi->ops->shutdown)
                nhi->ops->shutdown(nhi);
 }
 
-static void nhi_check_quirks(struct tb_nhi *nhi)
+static void nhi_check_quirks(struct tb_nhi_pci *nhi_pci)
 {
-       if (nhi->pdev->vendor == PCI_VENDOR_ID_INTEL) {
+       struct tb_nhi *nhi = &nhi_pci->nhi;
+       struct pci_dev *pdev = to_pci_dev(nhi->dev);
+
+       if (pdev->vendor == PCI_VENDOR_ID_INTEL) {
                /*
                 * Intel hardware supports auto clear of the interrupt
                 * status register right after interrupt is being
@@ -1210,7 +1230,7 @@ static void nhi_check_quirks(struct tb_nhi *nhi)
                 */
                nhi->quirks |= QUIRK_AUTO_CLEAR_INT;
 
-               switch (nhi->pdev->device) {
+               switch (pdev->device) {
                case PCI_DEVICE_ID_INTEL_FALCON_RIDGE_2C_NHI:
                case PCI_DEVICE_ID_INTEL_FALCON_RIDGE_4C_NHI:
                        /*
@@ -1224,7 +1244,7 @@ static void nhi_check_quirks(struct tb_nhi *nhi)
        }
 }
 
-static int nhi_check_iommu_pdev(struct pci_dev *pdev, void *data)
+static int nhi_check_iommu_pci_dev(struct pci_dev *pdev, void *data)
 {
        if (!pdev->external_facing ||
            !device_iommu_capable(&pdev->dev, IOMMU_CAP_PRE_BOOT_PROTECTION))
@@ -1233,9 +1253,11 @@ static int nhi_check_iommu_pdev(struct pci_dev *pdev, void *data)
        return 1; /* Stop walking */
 }
 
-static void nhi_check_iommu(struct tb_nhi *nhi)
+static void nhi_check_iommu(struct tb_nhi_pci *nhi_pci)
 {
-       struct pci_bus *bus = nhi->pdev->bus;
+       struct tb_nhi *nhi = &nhi_pci->nhi;
+       struct pci_dev *pdev = to_pci_dev(nhi->dev);
+       struct pci_bus *bus = pdev->bus;
        bool port_ok = false;
 
        /*
@@ -1258,10 +1280,10 @@ static void nhi_check_iommu(struct tb_nhi *nhi)
        while (bus->parent)
                bus = bus->parent;
 
-       pci_walk_bus(bus, nhi_check_iommu_pdev, &port_ok);
+       pci_walk_bus(bus, nhi_check_iommu_pci_dev, &port_ok);
 
        nhi->iommu_dma_protection = port_ok;
-       dev_dbg(&nhi->pdev->dev, "IOMMU DMA protection is %s\n",
+       dev_dbg(nhi->dev, "IOMMU DMA protection is %s\n",
                str_enabled_disabled(port_ok));
 }
 
@@ -1276,7 +1298,7 @@ static void nhi_reset(struct tb_nhi *nhi)
                return;
 
        if (!host_reset) {
-               dev_dbg(&nhi->pdev->dev, "skipping host router reset\n");
+               dev_dbg(nhi->dev, "skipping host router reset\n");
                return;
        }
 
@@ -1287,25 +1309,23 @@ static void nhi_reset(struct tb_nhi *nhi)
        do {
                val = ioread32(nhi->iobase + REG_RESET);
                if (!(val & REG_RESET_HRR)) {
-                       dev_warn(&nhi->pdev->dev, "host router reset successful\n");
+                       dev_warn(nhi->dev, "host router reset successful\n");
                        return;
                }
                usleep_range(10, 20);
        } while (ktime_before(ktime_get(), timeout));
 
-       dev_warn(&nhi->pdev->dev, "timeout resetting host router\n");
+       dev_warn(nhi->dev, "timeout resetting host router\n");
 }
 
-static int nhi_init_msi(struct tb_nhi *nhi)
+static int nhi_init_msi(struct tb_nhi_pci *nhi_pci)
 {
-       struct pci_dev *pdev = nhi->pdev;
+       struct tb_nhi *nhi = &nhi_pci->nhi;
+       struct pci_dev *pdev = to_pci_dev(nhi->dev);
        struct device *dev = &pdev->dev;
        int res, irq, nvec;
 
-       /* In case someone left them on. */
-       nhi_disable_interrupts(nhi);
-
-       ida_init(&nhi->msix_ida);
+       ida_init(&nhi_pci->msix_ida);
 
        /*
         * The NHI has 16 MSI-X vectors or a single MSI. We first try to
@@ -1322,7 +1342,7 @@ static int nhi_init_msi(struct tb_nhi *nhi)
 
                INIT_WORK(&nhi->interrupt_work, nhi_interrupt_work);
 
-               irq = pci_irq_vector(nhi->pdev, 0);
+               irq = pci_irq_vector(pdev, 0);
                if (irq < 0)
                        return irq;
 
@@ -1371,6 +1391,7 @@ static struct tb *nhi_select_cm(struct tb_nhi *nhi)
 static int nhi_probe(struct pci_dev *pdev, const struct pci_device_id *id)
 {
        struct device *dev = &pdev->dev;
+       struct tb_nhi_pci *nhi_pci;
        struct tb_nhi *nhi;
        struct tb *tb;
        int res;
@@ -1382,11 +1403,12 @@ static int nhi_probe(struct pci_dev *pdev, const struct pci_device_id *id)
        if (res)
                return dev_err_probe(dev, res, "cannot enable PCI device, aborting\n");
 
-       nhi = devm_kzalloc(&pdev->dev, sizeof(*nhi), GFP_KERNEL);
-       if (!nhi)
+       nhi_pci = devm_kzalloc(dev, sizeof(*nhi_pci), GFP_KERNEL);
+       if (!nhi_pci)
                return -ENOMEM;
 
-       nhi->pdev = pdev;
+       nhi = &nhi_pci->nhi;
+       nhi->dev = dev;
        nhi->ops = (const struct tb_nhi_ops *)id->driver_data;
 
        nhi->iobase = pcim_iomap_region(pdev, 0, "thunderbolt");
@@ -1404,11 +1426,14 @@ static int nhi_probe(struct pci_dev *pdev, const struct pci_device_id *id)
        if (!nhi->tx_rings || !nhi->rx_rings)
                return -ENOMEM;
 
-       nhi_check_quirks(nhi);
-       nhi_check_iommu(nhi);
+       nhi_check_quirks(nhi_pci);
+       nhi_check_iommu(nhi_pci);
        nhi_reset(nhi);
 
-       res = nhi_init_msi(nhi);
+       /* In case someone left them on. */
+       nhi_disable_interrupts(nhi);
+
+       res = nhi_init_msi(nhi_pci);
        if (res)
                return dev_err_probe(dev, res, "cannot enable MSI, aborting\n");
 

diff --git a/drivers/thunderbolt/nhi_ops.c b/drivers/thunderbolt/nhi_ops.c
index 96da07e88c521ad59466f54acc7e1001569c4df2..8c50066f34119b353754dfc044f1420b5d9f2150 100644 (file)
--- a/drivers/thunderbolt/nhi_ops.c
+++ b/drivers/thunderbolt/nhi_ops.c
@@ -24,7 +24,7 @@ static int check_for_device(struct device *dev, void *data)
 
 static bool icl_nhi_is_device_connected(struct tb_nhi *nhi)
 {
-       struct tb *tb = pci_get_drvdata(nhi->pdev);
+       struct tb *tb = dev_get_drvdata(nhi->dev);
        int ret;
 
        ret = device_for_each_child(&tb->root_switch->dev, NULL,
@@ -34,6 +34,7 @@ static bool icl_nhi_is_device_connected(struct tb_nhi *nhi)
 
 static int icl_nhi_force_power(struct tb_nhi *nhi, bool power)
 {
+       struct pci_dev *pdev = to_pci_dev(nhi->dev);
        u32 vs_cap;
 
        /*
@@ -48,7 +49,7 @@ static int icl_nhi_force_power(struct tb_nhi *nhi, bool power)
         * The actual power management happens inside shared ACPI power
         * resources using standard ACPI methods.
         */
-       pci_read_config_dword(nhi->pdev, VS_CAP_22, &vs_cap);
+       pci_read_config_dword(pdev, VS_CAP_22, &vs_cap);
        if (power) {
                vs_cap &= ~VS_CAP_22_DMA_DELAY_MASK;
                vs_cap |= 0x22 << VS_CAP_22_DMA_DELAY_SHIFT;
@@ -56,7 +57,7 @@ static int icl_nhi_force_power(struct tb_nhi *nhi, bool power)
        } else {
                vs_cap &= ~VS_CAP_22_FORCE_POWER;
        }
-       pci_write_config_dword(nhi->pdev, VS_CAP_22, vs_cap);
+       pci_write_config_dword(pdev, VS_CAP_22, vs_cap);
 
        if (power) {
                unsigned int retries = 350;
@@ -64,7 +65,7 @@ static int icl_nhi_force_power(struct tb_nhi *nhi, bool power)
 
                /* Wait until the firmware tells it is up and running */
                do {
-                       pci_read_config_dword(nhi->pdev, VS_CAP_9, &val);
+                       pci_read_config_dword(pdev, VS_CAP_9, &val);
                        if (val & VS_CAP_9_FW_READY)
                                return 0;
                        usleep_range(3000, 3100);
@@ -78,14 +79,16 @@ static int icl_nhi_force_power(struct tb_nhi *nhi, bool power)
 
 static void icl_nhi_lc_mailbox_cmd(struct tb_nhi *nhi, enum icl_lc_mailbox_cmd cmd)
 {
+       struct pci_dev *pdev = to_pci_dev(nhi->dev);
        u32 data;
 
        data = (cmd << VS_CAP_19_CMD_SHIFT) & VS_CAP_19_CMD_MASK;
-       pci_write_config_dword(nhi->pdev, VS_CAP_19, data | VS_CAP_19_VALID);
+       pci_write_config_dword(pdev, VS_CAP_19, data | VS_CAP_19_VALID);
 }
 
 static int icl_nhi_lc_mailbox_cmd_complete(struct tb_nhi *nhi, int timeout)
 {
+       struct pci_dev *pdev = to_pci_dev(nhi->dev);
        unsigned long end;
        u32 data;
 
@@ -94,7 +97,7 @@ static int icl_nhi_lc_mailbox_cmd_complete(struct tb_nhi *nhi, int timeout)
 
        end = jiffies + msecs_to_jiffies(timeout);
        do {
-               pci_read_config_dword(nhi->pdev, VS_CAP_18, &data);
+               pci_read_config_dword(pdev, VS_CAP_18, &data);
                if (data & VS_CAP_18_DONE)
                        goto clear;
                usleep_range(1000, 1100);
@@ -104,24 +107,25 @@ static int icl_nhi_lc_mailbox_cmd_complete(struct tb_nhi *nhi, int timeout)
 
 clear:
        /* Clear the valid bit */
-       pci_write_config_dword(nhi->pdev, VS_CAP_19, 0);
+       pci_write_config_dword(pdev, VS_CAP_19, 0);
        return 0;
 }
 
 static void icl_nhi_set_ltr(struct tb_nhi *nhi)
 {
+       struct pci_dev *pdev = to_pci_dev(nhi->dev);
        u32 max_ltr, ltr;
 
-       pci_read_config_dword(nhi->pdev, VS_CAP_16, &max_ltr);
+       pci_read_config_dword(pdev, VS_CAP_16, &max_ltr);
        max_ltr &= 0xffff;
        /* Program the same value for both snoop and no-snoop */
        ltr = max_ltr << 16 | max_ltr;
-       pci_write_config_dword(nhi->pdev, VS_CAP_15, ltr);
+       pci_write_config_dword(pdev, VS_CAP_15, ltr);
 }
 
 static int icl_nhi_suspend(struct tb_nhi *nhi)
 {
-       struct tb *tb = pci_get_drvdata(nhi->pdev);
+       struct tb *tb = dev_get_drvdata(nhi->dev);
        int ret;
 
        if (icl_nhi_is_device_connected(nhi))
@@ -144,7 +148,7 @@ static int icl_nhi_suspend(struct tb_nhi *nhi)
 
 static int icl_nhi_suspend_noirq(struct tb_nhi *nhi, bool wakeup)
 {
-       struct tb *tb = pci_get_drvdata(nhi->pdev);
+       struct tb *tb = dev_get_drvdata(nhi->dev);
        enum icl_lc_mailbox_cmd cmd;
 
        if (!pm_suspend_via_firmware())

diff --git a/drivers/thunderbolt/switch.c b/drivers/thunderbolt/switch.c
index d7c53eb3221b0577d53dbc1986909ff3898dc6ab..769b57ff276bcfc4a8313709367f13d1c57e0053 100644 (file)
--- a/drivers/thunderbolt/switch.c
+++ b/drivers/thunderbolt/switch.c
@@ -211,6 +211,7 @@ static int nvm_authenticate_device_dma_port(struct tb_switch *sw)
 
 static void nvm_authenticate_start_dma_port(struct tb_switch *sw)
 {
+       struct pci_dev *pdev = to_pci_dev(sw->tb->nhi->dev);
        struct pci_dev *root_port;
 
        /*
@@ -219,16 +220,17 @@ static void nvm_authenticate_start_dma_port(struct tb_switch *sw)
         * itself. To be on the safe side keep the root port in D0 during
         * the whole upgrade process.
         */
-       root_port = pcie_find_root_port(sw->tb->nhi->pdev);
+       root_port = pcie_find_root_port(pdev);
        if (root_port)
                pm_runtime_get_noresume(&root_port->dev);
 }
 
 static void nvm_authenticate_complete_dma_port(struct tb_switch *sw)
 {
+       struct pci_dev *pdev = to_pci_dev(sw->tb->nhi->dev);
        struct pci_dev *root_port;
 
-       root_port = pcie_find_root_port(sw->tb->nhi->pdev);
+       root_port = pcie_find_root_port(pdev);
        if (root_port)
                pm_runtime_put(&root_port->dev);
 }

diff --git a/drivers/thunderbolt/tb.c b/drivers/thunderbolt/tb.c
index 72a0dd27937e82025184bf31470e9330c6f74ed8..d60c0b8eb3908e9ad88da366ef8d3297f51be806 100644 (file)
--- a/drivers/thunderbolt/tb.c
+++ b/drivers/thunderbolt/tb.c
@@ -3310,13 +3310,14 @@ static const struct tb_cm_ops tb_cm_ops = {
  */
 static bool tb_apple_add_links(struct tb_nhi *nhi)
 {
+       struct pci_dev *nhi_pdev = to_pci_dev(nhi->dev);
        struct pci_dev *upstream, *pdev;
        bool ret;
 
        if (!x86_apple_machine)
                return false;
 
-       switch (nhi->pdev->device) {
+       switch (nhi_pdev->device) {
        case PCI_DEVICE_ID_INTEL_LIGHT_RIDGE:
        case PCI_DEVICE_ID_INTEL_CACTUS_RIDGE_4C:
        case PCI_DEVICE_ID_INTEL_FALCON_RIDGE_2C_NHI:
@@ -3326,7 +3327,7 @@ static bool tb_apple_add_links(struct tb_nhi *nhi)
                return false;
        }
 
-       upstream = pci_upstream_bridge(nhi->pdev);
+       upstream = pci_upstream_bridge(nhi_pdev);
        while (upstream) {
                if (!pci_is_pcie(upstream))
                        return false;
@@ -3353,15 +3354,15 @@ static bool tb_apple_add_links(struct tb_nhi *nhi)
                    !pdev->is_pciehp)
                        continue;
 
-               link = device_link_add(&pdev->dev, &nhi->pdev->dev,
+               link = device_link_add(&pdev->dev, nhi->dev,
                                       DL_FLAG_AUTOREMOVE_SUPPLIER |
                                       DL_FLAG_PM_RUNTIME);
                if (link) {
-                       dev_dbg(&nhi->pdev->dev, "created link from %s\n",
+                       dev_dbg(nhi->dev, "created link from %s\n",
                                dev_name(&pdev->dev));
                        ret = true;
                } else {
-                       dev_warn(&nhi->pdev->dev, "device link creation from %s failed\n",
+                       dev_warn(nhi->dev, "device link creation from %s failed\n",
                                 dev_name(&pdev->dev));
                }
        }

diff --git a/drivers/thunderbolt/tb.h b/drivers/thunderbolt/tb.h
index 003db653418aea2e609d28622573fed38ae3a42e..ec9192b61bc0e75add3af4a5e46b0f2a9c482b64 100644 (file)
--- a/drivers/thunderbolt/tb.h
+++ b/drivers/thunderbolt/tb.h
@@ -725,11 +725,11 @@ static inline int tb_port_write(struct tb_port *port, const void *buffer,
                            length);
 }
 
-#define tb_err(tb, fmt, arg...) dev_err(&(tb)->nhi->pdev->dev, fmt, ## arg)
-#define tb_WARN(tb, fmt, arg...) dev_WARN(&(tb)->nhi->pdev->dev, fmt, ## arg)
-#define tb_warn(tb, fmt, arg...) dev_warn(&(tb)->nhi->pdev->dev, fmt, ## arg)
-#define tb_info(tb, fmt, arg...) dev_info(&(tb)->nhi->pdev->dev, fmt, ## arg)
-#define tb_dbg(tb, fmt, arg...) dev_dbg(&(tb)->nhi->pdev->dev, fmt, ## arg)
+#define tb_err(tb, fmt, arg...) dev_err((tb)->nhi->dev, fmt, ## arg)
+#define tb_WARN(tb, fmt, arg...) dev_WARN((tb)->nhi->dev, fmt, ## arg)
+#define tb_warn(tb, fmt, arg...) dev_warn((tb)->nhi->dev, fmt, ## arg)
+#define tb_info(tb, fmt, arg...) dev_info((tb)->nhi->dev, fmt, ## arg)
+#define tb_dbg(tb, fmt, arg...) dev_dbg((tb)->nhi->dev, fmt, ## arg)
 
 #define __TB_SW_PRINT(level, sw, fmt, arg...)           \
        do {                                            \

diff --git a/drivers/thunderbolt/usb4_port.c b/drivers/thunderbolt/usb4_port.c
index c32d3516e78051af1de2ebc9943ec39a84cd60af..890de530debc1fd7112e9f0c10093831b4c05bfc 100644 (file)
--- a/drivers/thunderbolt/usb4_port.c
+++ b/drivers/thunderbolt/usb4_port.c
@@ -138,7 +138,7 @@ bool usb4_usb3_port_match(struct device *usb4_port_dev,
                return false;
 
        /* Check if USB3 fwnode references same NHI where USB4 port resides */
-       if (!device_match_fwnode(&nhi->pdev->dev, nhi_fwnode))
+       if (!device_match_fwnode(nhi->dev, nhi_fwnode))
                return false;
 
        if (fwnode_property_read_u8(usb3_port_fwnode, "usb4-port-number", &usb4_port_num))

diff --git a/include/linux/thunderbolt.h b/include/linux/thunderbolt.h
index 0be9b298e692c9fad2f56f1ad3f11b8d4a29259e..b5659f8835171193261d4a8fa83a4fb906674053 100644 (file)
--- a/include/linux/thunderbolt.h
+++ b/include/linux/thunderbolt.h
@@ -498,12 +498,11 @@ void tb_service_properties_changed(struct tb_service *svc);
  * struct tb_nhi - thunderbolt native host interface
  * @lock: Must be held during ring creation/destruction. Is acquired by
  *       interrupt_work when dispatching interrupts to individual rings.
- * @pdev: Pointer to the PCI device
+ * @dev: Device associated with this NHI instance
  * @ops: NHI specific optional ops
  * @iobase: MMIO space of the NHI
  * @tx_rings: All Tx rings available on this host controller
  * @rx_rings: All Rx rings available on this host controller
- * @msix_ida: Used to allocate MSI-X vectors for rings
  * @going_away: The host controller device is about to disappear so when
  *             this flag is set, avoid touching the hardware anymore.
  * @iommu_dma_protection: An IOMMU will isolate external-facing ports.
@@ -515,12 +514,11 @@ void tb_service_properties_changed(struct tb_service *svc);
  */
 struct tb_nhi {
        spinlock_t lock;
-       struct pci_dev *pdev;
+       struct device *dev;
        const struct tb_nhi_ops *ops;
        void __iomem *iobase;
        struct tb_ring **tx_rings;
        struct tb_ring **rx_rings;
-       struct ida msix_ida;
        bool going_away;
        bool iommu_dma_protection;
        struct work_struct interrupt_work;
@@ -722,7 +720,7 @@ int tb_ring_throttling(struct tb_ring *ring, unsigned int interval_nsec);
  */
 static inline struct device *tb_ring_dma_device(struct tb_ring *ring)
 {
-       return &ring->nhi->pdev->dev;
+       return ring->nhi->dev;
 }
 
 bool usb4_usb3_port_match(struct device *usb4_port_dev,