genirq/msi: Provide a set of advanced MSI accessors and iterators

In preparation for dynamic handling of MSI-X interrupts provide a new set
of MSI descriptor accessor functions and iterators. They are benefitial per
se as they allow to cleanup quite some code in various MSI domain
implementations.

Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Tested-by: Michael Kelley <mikelley@microsoft.com>
Tested-by: Nishanth Menon <nm@ti.com>
Reviewed-by: Jason Gunthorpe <jgg@nvidia.com>
Link: https://lore.kernel.org/r/20211206210747.818635078@linutronix.de

diff --git a/include/linux/msi.h b/include/linux/msi.h
index 69c588e..703221f 100644 (file)
--- a/include/linux/msi.h
+++ b/include/linux/msi.h
@@ -140,6 +140,18 @@ struct msi_desc {
        struct pci_msi_desc             pci;
 };
 
+/*
+ * Filter values for the MSI descriptor iterators and accessor functions.
+ */
+enum msi_desc_filter {
+       /* All descriptors */
+       MSI_DESC_ALL,
+       /* Descriptors which have no interrupt associated */
+       MSI_DESC_NOTASSOCIATED,
+       /* Descriptors which have an interrupt associated */
+       MSI_DESC_ASSOCIATED,
+};
+
 /**
  * msi_device_data - MSI per device data
  * @properties:                MSI properties which are interesting to drivers
@@ -147,6 +159,7 @@ struct msi_desc {
  * @platform_data:     Platform-MSI specific data
  * @list:              List of MSI descriptors associated to the device
  * @mutex:             Mutex protecting the MSI list
+ * @__next:            Cached pointer to the next entry for iterators
  */
 struct msi_device_data {
        unsigned long                   properties;
@@ -154,6 +167,7 @@ struct msi_device_data {
        struct platform_msi_priv_data   *platform_data;
        struct list_head                list;
        struct mutex                    mutex;
+       struct msi_desc                 *__next;
 };
 
 int msi_setup_device_data(struct device *dev);
@@ -162,6 +176,25 @@ unsigned int msi_get_virq(struct device *dev, unsigned int index);
 void msi_lock_descs(struct device *dev);
 void msi_unlock_descs(struct device *dev);
 
+struct msi_desc *msi_first_desc(struct device *dev, enum msi_desc_filter filter);
+struct msi_desc *msi_next_desc(struct device *dev, enum msi_desc_filter filter);
+
+/**
+ * msi_for_each_desc - Iterate the MSI descriptors
+ *
+ * @desc:      struct msi_desc pointer used as iterator
+ * @dev:       struct device pointer - device to iterate
+ * @filter:    Filter for descriptor selection
+ *
+ * Notes:
+ *  - The loop must be protected with a msi_lock_descs()/msi_unlock_descs()
+ *    pair.
+ *  - It is safe to remove a retrieved MSI descriptor in the loop.
+ */
+#define msi_for_each_desc(desc, dev, filter)                   \
+       for ((desc) = msi_first_desc((dev), (filter)); (desc);  \
+            (desc) = msi_next_desc((dev), (filter)))
+
 /* Helpers to hide struct msi_desc implementation details */
 #define msi_desc_to_dev(desc)          ((desc)->dev)
 #define dev_to_msi_list(dev)           (&(dev)->msi.data->list)

diff --git a/kernel/irq/msi.c b/kernel/irq/msi.c
index 3b21e99..bc67b2c 100644 (file)
--- a/kernel/irq/msi.c
+++ b/kernel/irq/msi.c
@@ -125,10 +125,106 @@ EXPORT_SYMBOL_GPL(msi_lock_descs);
  */
 void msi_unlock_descs(struct device *dev)
 {
+       /* Clear the next pointer which was cached by the iterator */
+       dev->msi.data->__next = NULL;
        mutex_unlock(&dev->msi.data->mutex);
 }
 EXPORT_SYMBOL_GPL(msi_unlock_descs);
 
+static bool msi_desc_match(struct msi_desc *desc, enum msi_desc_filter filter)
+{
+       switch (filter) {
+       case MSI_DESC_ALL:
+               return true;
+       case MSI_DESC_NOTASSOCIATED:
+               return !desc->irq;
+       case MSI_DESC_ASSOCIATED:
+               return !!desc->irq;
+       }
+       WARN_ON_ONCE(1);
+       return false;
+}
+
+static struct msi_desc *msi_find_first_desc(struct device *dev, enum msi_desc_filter filter)
+{
+       struct msi_desc *desc;
+
+       list_for_each_entry(desc, dev_to_msi_list(dev), list) {
+               if (msi_desc_match(desc, filter))
+                       return desc;
+       }
+       return NULL;
+}
+
+/**
+ * msi_first_desc - Get the first MSI descriptor of a device
+ * @dev:       Device to operate on
+ * @filter:    Descriptor state filter
+ *
+ * Must be called with the MSI descriptor mutex held, i.e. msi_lock_descs()
+ * must be invoked before the call.
+ *
+ * Return: Pointer to the first MSI descriptor matching the search
+ *        criteria, NULL if none found.
+ */
+struct msi_desc *msi_first_desc(struct device *dev, enum msi_desc_filter filter)
+{
+       struct msi_desc *desc;
+
+       if (WARN_ON_ONCE(!dev->msi.data))
+               return NULL;
+
+       lockdep_assert_held(&dev->msi.data->mutex);
+
+       desc = msi_find_first_desc(dev, filter);
+       dev->msi.data->__next = desc ? list_next_entry(desc, list) : NULL;
+       return desc;
+}
+EXPORT_SYMBOL_GPL(msi_first_desc);
+
+static struct msi_desc *__msi_next_desc(struct device *dev, enum msi_desc_filter filter,
+                                       struct msi_desc *from)
+{
+       struct msi_desc *desc = from;
+
+       list_for_each_entry_from(desc, dev_to_msi_list(dev), list) {
+               if (msi_desc_match(desc, filter))
+                       return desc;
+       }
+       return NULL;
+}
+
+/**
+ * msi_next_desc - Get the next MSI descriptor of a device
+ * @dev:       Device to operate on
+ *
+ * The first invocation of msi_next_desc() has to be preceeded by a
+ * successful incovation of __msi_first_desc(). Consecutive invocations are
+ * only valid if the previous one was successful. All these operations have
+ * to be done within the same MSI mutex held region.
+ *
+ * Return: Pointer to the next MSI descriptor matching the search
+ *        criteria, NULL if none found.
+ */
+struct msi_desc *msi_next_desc(struct device *dev, enum msi_desc_filter filter)
+{
+       struct msi_device_data *data = dev->msi.data;
+       struct msi_desc *desc;
+
+       if (WARN_ON_ONCE(!data))
+               return NULL;
+
+       lockdep_assert_held(&data->mutex);
+
+       if (!data->__next)
+               return NULL;
+
+       desc = __msi_next_desc(dev, filter, data->__next);
+       dev->msi.data->__next = desc ? list_next_entry(desc, list) : NULL;
+       return desc;
+}
+EXPORT_SYMBOL_GPL(msi_next_desc);
+
 /**
  * msi_get_virq - Return Linux interrupt number of a MSI interrupt
  * @dev:       Device to operate on