platform-msi: Allow creation of a MSI-based stacked irq domain

We almost have all the needed bits requiredable to create a irq domain
on top of a MSI domain.

For this, we enable a few things:
- the virq is stored in the msi_desc
- device, msi_alloc_info and domain-specific data
  are stored in the platform_priv_data structure
- we introduce a new API for platform-msi:

  /* Create a MSI-based domain */
  struct irq_domain *
  platform_msi_create_device_domain(struct device *dev,
                                    unsigned int nvec,
                                    irq_write_msi_msg_t write_msi_msg,
                                    const struct irq_domain_ops *ops,
                                    void *host_data);

  /* Allocate MSIs in an MSI domain */
  int platform_msi_domain_alloc(struct irq_domain *domain,
				unsigned int virq,
				unsigned int nr_irqs);

  /* Free MSIs from an MSI domain */
  void platform_msi_domain_free(struct irq_domain *domain,
				unsigned int virq,
				unsigned int nvec);

  /* Obtain the host data passed to platform_msi_create_device_domain */
  void *platform_msi_get_host_data(struct irq_domain *domain);

platform_msi_create_device_domain() is a hybrid of irqdomain creation
and interrupt allocation, creating a domain backed by the MSIs associated
to a device. IRQs can then be allocated in that domain using
platform_msi_domain_alloc().

This now allows a wired irq to MSI bridge to be created.

Signed-off-by: Marc Zyngier <marc.zyngier@arm.com>

diff --git a/drivers/base/platform-msi.c b/drivers/base/platform-msi.c
index 44b8c0d816fe87cd9310cf9c3650858dbb6ea4a8..a203896f204f31d38c40c0bc5867e85899f3ea5e 100644 (file)
--- a/drivers/base/platform-msi.c
+++ b/drivers/base/platform-msi.c
@@ -32,6 +32,9 @@
  * and the callback to write the MSI message.
  */
 struct platform_msi_priv_data {
+       struct device           *dev;
+       void                    *host_data;
+       msi_alloc_info_t        arg;
        irq_write_msi_msg_t     write_msg;
        int                     devid;
 };
@@ -124,8 +127,9 @@ static void platform_msi_free_descs(struct device *dev, int base, int nvec)
        }
 }
 
-static int platform_msi_alloc_descs(struct device *dev, int nvec,
-                                   struct platform_msi_priv_data *data)
+static int platform_msi_alloc_descs_with_irq(struct device *dev, int virq,
+                                            int nvec,
+                                            struct platform_msi_priv_data *data)
 
 {
        struct msi_desc *desc;
@@ -145,6 +149,7 @@ static int platform_msi_alloc_descs(struct device *dev, int nvec,
                desc->platform.msi_priv_data = data;
                desc->platform.msi_index = base + i;
                desc->nvec_used = 1;
+               desc->irq = virq ? virq + i : 0;
 
                list_add_tail(&desc->list, dev_to_msi_list(dev));
        }
@@ -159,6 +164,13 @@ static int platform_msi_alloc_descs(struct device *dev, int nvec,
        return 0;
 }
 
+static int platform_msi_alloc_descs(struct device *dev, int nvec,
+                                   struct platform_msi_priv_data *data)
+
+{
+       return platform_msi_alloc_descs_with_irq(dev, 0, nvec, data);
+}
+
 /**
  * platform_msi_create_irq_domain - Create a platform MSI interrupt domain
  * @fwnode:            Optional fwnode of the interrupt controller
@@ -225,6 +237,7 @@ platform_msi_alloc_priv_data(struct device *dev, unsigned int nvec,
        }
 
        datap->write_msg = write_msi_msg;
+       datap->dev = dev;
 
        return datap;
 }
@@ -288,3 +301,116 @@ void platform_msi_domain_free_irqs(struct device *dev)
        msi_domain_free_irqs(dev->msi_domain, dev);
        platform_msi_free_descs(dev, 0, MAX_DEV_MSIS);
 }
+
+/**
+ * platform_msi_get_host_data - Query the private data associated with
+ *                              a platform-msi domain
+ * @domain:    The platform-msi domain
+ *
+ * Returns the private data provided when calling
+ * platform_msi_create_device_domain.
+ */
+void *platform_msi_get_host_data(struct irq_domain *domain)
+{
+       struct platform_msi_priv_data *data = domain->host_data;
+       return data->host_data;
+}
+
+/**
+ * platform_msi_create_device_domain - Create a platform-msi domain
+ *
+ * @dev:               The device generating the MSIs
+ * @nvec:              The number of MSIs that need to be allocated
+ * @write_msi_msg:     Callback to write an interrupt message for @dev
+ * @ops:               The hierarchy domain operations to use
+ * @host_data:         Private data associated to this domain
+ *
+ * Returns an irqdomain for @nvec interrupts
+ */
+struct irq_domain *
+platform_msi_create_device_domain(struct device *dev,
+                                 unsigned int nvec,
+                                 irq_write_msi_msg_t write_msi_msg,
+                                 const struct irq_domain_ops *ops,
+                                 void *host_data)
+{
+       struct platform_msi_priv_data *data;
+       struct irq_domain *domain;
+       int err;
+
+       data = platform_msi_alloc_priv_data(dev, nvec, write_msi_msg);
+       if (IS_ERR(data))
+               return NULL;
+
+       data->host_data = host_data;
+       domain = irq_domain_create_hierarchy(dev->msi_domain, 0, nvec,
+                                            of_node_to_fwnode(dev->of_node),
+                                            ops, data);
+       if (!domain)
+               goto free_priv;
+
+       err = msi_domain_prepare_irqs(domain->parent, dev, nvec, &data->arg);
+       if (err)
+               goto free_domain;
+
+       return domain;
+
+free_domain:
+       irq_domain_remove(domain);
+free_priv:
+       platform_msi_free_priv_data(data);
+       return NULL;
+}
+
+/**
+ * platform_msi_domain_free - Free interrupts associated with a platform-msi
+ *                            domain
+ *
+ * @domain:    The platform-msi domain
+ * @virq:      The base irq from which to perform the free operation
+ * @nvec:      How many interrupts to free from @virq
+ */
+void platform_msi_domain_free(struct irq_domain *domain, unsigned int virq,
+                             unsigned int nvec)
+{
+       struct platform_msi_priv_data *data = domain->host_data;
+       struct msi_desc *desc;
+       for_each_msi_entry(desc, data->dev) {
+               if (WARN_ON(!desc->irq || desc->nvec_used != 1))
+                       return;
+               if (!(desc->irq >= virq && desc->irq < (virq + nvec)))
+                       continue;
+
+               irq_domain_free_irqs_common(domain, desc->irq, 1);
+       }
+}
+
+/**
+ * platform_msi_domain_alloc - Allocate interrupts associated with
+ *                            a platform-msi domain
+ *
+ * @domain:    The platform-msi domain
+ * @virq:      The base irq from which to perform the allocate operation
+ * @nvec:      How many interrupts to free from @virq
+ *
+ * Return 0 on success, or an error code on failure. Must be called
+ * with irq_domain_mutex held (which can only be done as part of a
+ * top-level interrupt allocation).
+ */
+int platform_msi_domain_alloc(struct irq_domain *domain, unsigned int virq,
+                             unsigned int nr_irqs)
+{
+       struct platform_msi_priv_data *data = domain->host_data;
+       int err;
+
+       err = platform_msi_alloc_descs_with_irq(data->dev, virq, nr_irqs, data);
+       if (err)
+               return err;
+
+       err = msi_domain_populate_irqs(domain->parent, data->dev,
+                                      virq, nr_irqs, &data->arg);
+       if (err)
+               platform_msi_domain_free(domain, virq, nr_irqs);
+
+       return err;
+}

diff --git a/include/linux/msi.h b/include/linux/msi.h
index cee102b1916d72025a3d6c0905885a6343e4a772..1c6342ab8c0e92be0991f1e4c1b976c7f8f5f386 100644 (file)
--- a/include/linux/msi.h
+++ b/include/linux/msi.h
@@ -174,6 +174,7 @@ struct msi_controller {
 #include <asm/msi.h>
 
 struct irq_domain;
+struct irq_domain_ops;
 struct irq_chip;
 struct device_node;
 struct fwnode_handle;
@@ -285,6 +286,17 @@ int msi_domain_prepare_irqs(struct irq_domain *domain, struct device *dev,
                            int nvec, msi_alloc_info_t *args);
 int msi_domain_populate_irqs(struct irq_domain *domain, struct device *dev,
                             int virq, int nvec, msi_alloc_info_t *args);
+struct irq_domain *
+platform_msi_create_device_domain(struct device *dev,
+                                 unsigned int nvec,
+                                 irq_write_msi_msg_t write_msi_msg,
+                                 const struct irq_domain_ops *ops,
+                                 void *host_data);
+int platform_msi_domain_alloc(struct irq_domain *domain, unsigned int virq,
+                             unsigned int nr_irqs);
+void platform_msi_domain_free(struct irq_domain *domain, unsigned int virq,
+                             unsigned int nvec);
+void *platform_msi_get_host_data(struct irq_domain *domain);
 #endif /* CONFIG_GENERIC_MSI_IRQ_DOMAIN */
 
 #ifdef CONFIG_PCI_MSI_IRQ_DOMAIN