iommu/arm-smmu: Convert to iommu_fwspec

In the final step of preparation for full generic configuration support,
swap our fixed-size master_cfg for the generic iommu_fwspec. For the
legacy DT bindings, the driver simply gets to act as its own 'firmware'.
Farewell, arbitrary MAX_MASTER_STREAMIDS!

Signed-off-by: Robin Murphy <robin.murphy@arm.com>
Signed-off-by: Will Deacon <will.deacon@arm.com>

1 files changed, 78 insertions, 62 deletions

diff --git a/drivers/iommu/arm-smmu.c b/drivers/iommu/arm-smmu.c
index 7a2bd60a54da..9dbb6a37e625 100644
--- a/drivers/iommu/arm-smmu.c
+++ b/drivers/iommu/arm-smmu.c
@@ -42,6 +42,7 @@
 #include <linux/of.h>
 #include <linux/of_address.h>
 #include <linux/of_device.h>
+#include <linux/of_iommu.h>
 #include <linux/pci.h>
 #include <linux/platform_device.h>
 #include <linux/slab.h>
@@ -51,9 +52,6 @@
 
 #include "io-pgtable.h"
 
-/* Maximum number of stream IDs assigned to a single device */
-#define MAX_MASTER_STREAMIDS            128
-
 /* Maximum number of context banks per SMMU */
 #define ARM_SMMU_MAX_CBS                128
 
@@ -321,13 +319,13 @@ struct arm_smmu_smr {
 
 struct arm_smmu_master_cfg {
         struct arm_smmu_device          *smmu;
-        int                             num_streamids;
-        u16                             streamids[MAX_MASTER_STREAMIDS];
-        s16                             smendx[MAX_MASTER_STREAMIDS];
+        s16                             smendx[];
 };
 #define INVALID_SMENDX                  -1
-#define for_each_cfg_sme(cfg, i, idx) \
-        for (i = 0; idx = cfg->smendx[i], i < cfg->num_streamids; ++i)
+#define __fwspec_cfg(fw) ((struct arm_smmu_master_cfg *)fw->iommu_priv)
+#define fwspec_smmu(fw)  (__fwspec_cfg(fw)->smmu)
+#define for_each_cfg_sme(fw, i, idx) \
+        for (i = 0; idx = __fwspec_cfg(fw)->smendx[i], i < fw->num_ids; ++i)
 
 struct arm_smmu_device {
         struct device                   *dev;
@@ -480,14 +478,16 @@ static int __find_legacy_master_phandle(struct device *dev, void *data)
 }
 
 static struct platform_driver arm_smmu_driver;
+static struct iommu_ops arm_smmu_ops;
 
-static int arm_smmu_register_legacy_master(struct device *dev)
+static int arm_smmu_register_legacy_master(struct device *dev,
+                                           struct arm_smmu_device **smmu)
 {
-        struct arm_smmu_device *smmu;
-        struct arm_smmu_master_cfg *cfg;
+        struct device *smmu_dev;
         struct device_node *np;
         struct of_phandle_iterator it;
         void *data = &it;
+        u32 *sids;
         __be32 pci_sid;
         int err;
 
@@ -500,20 +500,13 @@ static int arm_smmu_register_legacy_master(struct device *dev)
         it.node = np;
         err = driver_for_each_device(&arm_smmu_driver.driver, NULL, &data,
                                      __find_legacy_master_phandle);
+        smmu_dev = data;
         of_node_put(np);
         if (err == 0)
                 return -ENODEV;
         if (err < 0)
                 return err;
 
-        smmu = dev_get_drvdata(data);
-
-        if (it.cur_count > MAX_MASTER_STREAMIDS) {
-                dev_err(smmu->dev,
-                        "reached maximum number (%d) of stream IDs for master device %s\n",
-                        MAX_MASTER_STREAMIDS, dev_name(dev));
-                return -ENOSPC;
-        }
         if (dev_is_pci(dev)) {
                 /* "mmu-masters" assumes Stream ID == Requester ID */
                 pci_for_each_dma_alias(to_pci_dev(dev), __arm_smmu_get_pci_sid,
@@ -522,17 +515,20 @@ static int arm_smmu_register_legacy_master(struct device *dev)
                 it.cur_count = 1;
         }
 
-        cfg = kzalloc(sizeof(*cfg), GFP_KERNEL);
-        if (!cfg)
-                return -ENOMEM;
-
-        cfg->smmu = smmu;
-        dev->archdata.iommu = cfg;
+        err = iommu_fwspec_init(dev, &smmu_dev->of_node->fwnode,
+                                &arm_smmu_ops);
+        if (err)
+                return err;
 
-        while (it.cur_count--)
-                cfg->streamids[cfg->num_streamids++] = be32_to_cpup(it.cur++);
+        sids = kcalloc(it.cur_count, sizeof(*sids), GFP_KERNEL);
+        if (!sids)
+                return -ENOMEM;
 
-        return 0;
+        *smmu = dev_get_drvdata(smmu_dev);
+        of_phandle_iterator_args(&it, sids, it.cur_count);
+        err = iommu_fwspec_add_ids(dev, sids, it.cur_count);
+        kfree(sids);
+        return err;
 }
 
 static int __arm_smmu_alloc_bitmap(unsigned long *map, int start, int end)
@@ -1127,7 +1123,8 @@ static bool arm_smmu_free_sme(struct arm_smmu_device *smmu, int idx)
 
 static int arm_smmu_master_alloc_smes(struct device *dev)
 {
-        struct arm_smmu_master_cfg *cfg = dev->archdata.iommu;
+        struct iommu_fwspec *fwspec = dev->iommu_fwspec;
+        struct arm_smmu_master_cfg *cfg = fwspec->iommu_priv;
         struct arm_smmu_device *smmu = cfg->smmu;
         struct arm_smmu_smr *smrs = smmu->smrs;
         struct iommu_group *group;
@@ -1135,19 +1132,19 @@ static int arm_smmu_master_alloc_smes(struct device *dev)
 
         mutex_lock(&smmu->stream_map_mutex);
         /* Figure out a viable stream map entry allocation */
-        for_each_cfg_sme(cfg, i, idx) {
+        for_each_cfg_sme(fwspec, i, idx) {
                 if (idx != INVALID_SMENDX) {
                         ret = -EEXIST;
                         goto out_err;
                 }
 
-                ret = arm_smmu_find_sme(smmu, cfg->streamids[i], 0);
+                ret = arm_smmu_find_sme(smmu, fwspec->ids[i], 0);
                 if (ret < 0)
                         goto out_err;
 
                 idx = ret;
                 if (smrs && smmu->s2crs[idx].count == 0) {
-                        smrs[idx].id = cfg->streamids[i];
+                        smrs[idx].id = fwspec->ids[i];
                         smrs[idx].mask = 0; /* We don't currently share SMRs */
                         smrs[idx].valid = true;
                 }
@@ -1165,7 +1162,7 @@ static int arm_smmu_master_alloc_smes(struct device *dev)
         iommu_group_put(group);
 
         /* It worked! Now, poke the actual hardware */
-        for_each_cfg_sme(cfg, i, idx) {
+        for_each_cfg_sme(fwspec, i, idx) {
                 arm_smmu_write_sme(smmu, idx);
                 smmu->s2crs[idx].group = group;
         }
@@ -1182,13 +1179,14 @@ out_err:
         return ret;
 }
 
-static void arm_smmu_master_free_smes(struct arm_smmu_master_cfg *cfg)
+static void arm_smmu_master_free_smes(struct iommu_fwspec *fwspec)
 {
-        struct arm_smmu_device *smmu = cfg->smmu;
+        struct arm_smmu_device *smmu = fwspec_smmu(fwspec);
+        struct arm_smmu_master_cfg *cfg = fwspec->iommu_priv;
         int i, idx;
 
         mutex_lock(&smmu->stream_map_mutex);
-        for_each_cfg_sme(cfg, i, idx) {
+        for_each_cfg_sme(fwspec, i, idx) {
                 if (arm_smmu_free_sme(smmu, idx))
                         arm_smmu_write_sme(smmu, idx);
                 cfg->smendx[i] = INVALID_SMENDX;
@@ -1197,7 +1195,7 @@ static void arm_smmu_master_free_smes(struct arm_smmu_master_cfg *cfg)