This structure is read-only data and should never be modified.
Signed-off-by: Thierry Reding <treding@nvidia.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Signed-off-by: Joerg Roedel <jroedel@suse.de>
  */
 static struct protection_domain *pt_domain;
 
-static struct iommu_ops amd_iommu_ops;
+static const struct iommu_ops amd_iommu_ops;
 
 static ATOMIC_NOTIFIER_HEAD(ppr_notifier);
 int amd_iommu_max_glx_val = -1;
        return 0;
 }
 
-static struct iommu_ops amd_iommu_ops = {
+static const struct iommu_ops amd_iommu_ops = {
        .domain_init = amd_iommu_domain_init,
        .domain_destroy = amd_iommu_domain_destroy,
        .attach_dev = amd_iommu_attach_device,
 
        iommu_group_remove_device(dev);
 }
 
-static struct iommu_ops arm_smmu_ops = {
+static const struct iommu_ops arm_smmu_ops = {
        .domain_init    = arm_smmu_domain_init,
        .domain_destroy = arm_smmu_domain_destroy,
        .attach_dev     = arm_smmu_attach_dev,
 
        iommu_group_remove_device(dev);
 }
 
-static struct iommu_ops exynos_iommu_ops = {
+static const struct iommu_ops exynos_iommu_ops = {
        .domain_init = exynos_iommu_domain_init,
        .domain_destroy = exynos_iommu_domain_destroy,
        .attach_dev = exynos_iommu_attach_device,
 
        return dma_domain->win_cnt;
 }
 
-static struct iommu_ops fsl_pamu_ops = {
+static const struct iommu_ops fsl_pamu_ops = {
        .domain_init    = fsl_pamu_domain_init,
        .domain_destroy = fsl_pamu_domain_destroy,
        .attach_dev     = fsl_pamu_attach_device,
 
 static DEFINE_SPINLOCK(device_domain_lock);
 static LIST_HEAD(device_domain_list);
 
-static struct iommu_ops intel_iommu_ops;
+static const struct iommu_ops intel_iommu_ops;
 
 static int __init intel_iommu_setup(char *str)
 {
        iommu_device_unlink(iommu->iommu_dev, dev);
 }
 
-static struct iommu_ops intel_iommu_ops = {
+static const struct iommu_ops intel_iommu_ops = {
        .domain_init    = intel_iommu_domain_init,
        .domain_destroy = intel_iommu_domain_destroy,
        .attach_dev     = intel_iommu_attach_device,
 
 static struct ida iommu_group_ida;
 static struct mutex iommu_group_mutex;
 
+struct iommu_callback_data {
+       const struct iommu_ops *ops;
+};
+
 struct iommu_group {
        struct kobject kobj;
        struct kobject *devices_kobj;
 
 static int add_iommu_group(struct device *dev, void *data)
 {
-       struct iommu_ops *ops = data;
+       struct iommu_callback_data *cb = data;
+       const struct iommu_ops *ops = cb->ops;
 
        if (!ops->add_device)
                return -ENODEV;
                              unsigned long action, void *data)
 {
        struct device *dev = data;
-       struct iommu_ops *ops = dev->bus->iommu_ops;
+       const struct iommu_ops *ops = dev->bus->iommu_ops;
        struct iommu_group *group;
        unsigned long group_action = 0;
 
        .notifier_call = iommu_bus_notifier,
 };
 
-static void iommu_bus_init(struct bus_type *bus, struct iommu_ops *ops)
+static void iommu_bus_init(struct bus_type *bus, const struct iommu_ops *ops)
 {
+       struct iommu_callback_data cb = {
+               .ops = ops,
+       };
+
        bus_register_notifier(bus, &iommu_bus_nb);
-       bus_for_each_dev(bus, NULL, ops, add_iommu_group);
+       bus_for_each_dev(bus, NULL, &cb, add_iommu_group);
 }
 
 /**
  * is set up. With this function the iommu-driver can set the iommu-ops
  * afterwards.
  */
-int bus_set_iommu(struct bus_type *bus, struct iommu_ops *ops)
+int bus_set_iommu(struct bus_type *bus, const struct iommu_ops *ops)
 {
        if (bus->iommu_ops != NULL)
                return -EBUSY;
 
        dev->archdata.iommu = NULL;
 }
 
-static struct iommu_ops ipmmu_ops = {
+static const struct iommu_ops ipmmu_ops = {
        .domain_init = ipmmu_domain_init,
        .domain_destroy = ipmmu_domain_destroy,
        .attach_dev = ipmmu_attach_device,
 
        return 0;
 }
 
-static struct iommu_ops msm_iommu_ops = {
+static const struct iommu_ops msm_iommu_ops = {
        .domain_init = msm_iommu_domain_init,
        .domain_destroy = msm_iommu_domain_destroy,
        .attach_dev = msm_iommu_attach_dev,
 
        kfree(arch_data);
 }
 
-static struct iommu_ops omap_iommu_ops = {
+static const struct iommu_ops omap_iommu_ops = {
        .domain_init    = omap_iommu_domain_init,
        .domain_destroy = omap_iommu_domain_destroy,
        .attach_dev     = omap_iommu_attach_dev,
 
        return 0;
 }
 
-static struct iommu_ops shmobile_iommu_ops = {
+static const struct iommu_ops shmobile_iommu_ops = {
        .domain_init = shmobile_iommu_domain_init,
        .domain_destroy = shmobile_iommu_domain_destroy,
        .attach_dev = shmobile_iommu_attach_device,
 
        return 0;
 }
 
-static struct iommu_ops gart_iommu_ops = {
+static const struct iommu_ops gart_iommu_ops = {
        .domain_init    = gart_iommu_domain_init,
        .domain_destroy = gart_iommu_domain_destroy,
        .attach_dev     = gart_iommu_attach_dev,
 
        dev_dbg(smmu->dev, "smmu_as@%p\n", as);
 }
 
-static struct iommu_ops smmu_iommu_ops = {
+static const struct iommu_ops smmu_iommu_ops = {
        .domain_init    = smmu_iommu_domain_init,
        .domain_destroy = smmu_iommu_domain_destroy,
        .attach_dev     = smmu_iommu_attach_dev,
 
 
        const struct dev_pm_ops *pm;
 
-       struct iommu_ops *iommu_ops;
+       const struct iommu_ops *iommu_ops;
 
        struct subsys_private *p;
        struct lock_class_key lock_key;
 
 };
 
 struct iommu_domain {
-       struct iommu_ops *ops;
+       const struct iommu_ops *ops;
        void *priv;
        iommu_fault_handler_t handler;
        void *handler_token;
 #define IOMMU_GROUP_NOTIFY_UNBIND_DRIVER       5 /* Pre Driver unbind */
 #define IOMMU_GROUP_NOTIFY_UNBOUND_DRIVER      6 /* Post Driver unbind */
 
-extern int bus_set_iommu(struct bus_type *bus, struct iommu_ops *ops);
+extern int bus_set_iommu(struct bus_type *bus, const struct iommu_ops *ops);
 extern bool iommu_present(struct bus_type *bus);
 extern struct iommu_domain *iommu_domain_alloc(struct bus_type *bus);
 extern struct iommu_group *iommu_group_get_by_id(int id);