5 files changed, 663 insertions, 103 deletions

diff --git a/Documentation/ABI/testing/sysfs-kernel-iommu_groups b/Documentation/ABI/testing/sysfs-kernel-iommu_groups
new file mode 100644
index 000000000000..9b31556cfdda
--- /dev/null
+++ b/Documentation/ABI/testing/sysfs-kernel-iommu_groups
@@ -0,0 +1,14 @@
+What:           /sys/kernel/iommu_groups/
+Date:           May 2012
+KernelVersion:  v3.5
+Contact:        Alex Williamson <alex.williamson@redhat.com>
+Description:    /sys/kernel/iommu_groups/ contains a number of sub-
+                directories, each representing an IOMMU group.  The
+                name of the sub-directory matches the iommu_group_id()
+                for the group, which is an integer value.  Within each
+                subdirectory is another directory named "devices" with
+                links to the sysfs devices contained in this group.
+                The group directory also optionally contains a "name"
+                file if the IOMMU driver has chosen to register a more
+                common name for the group.
+Users:
diff --git a/drivers/iommu/amd_iommu.c b/drivers/iommu/amd_iommu.c
index a2e418cba0ff..55283d6291c8 100644
--- a/drivers/iommu/amd_iommu.c
+++ b/drivers/iommu/amd_iommu.c
@@ -3227,26 +3227,6 @@ static int amd_iommu_domain_has_cap(struct iommu_domain *domain,
         return 0;
 }
 
-static int amd_iommu_device_group(struct device *dev, unsigned int *groupid)
-{
-        struct iommu_dev_data *dev_data = dev->archdata.iommu;
-        struct pci_dev *pdev = to_pci_dev(dev);
-        u16 devid;
-
-        if (!dev_data)
-                return -ENODEV;
-
-        if (pdev->is_virtfn || !iommu_group_mf)
-                devid = dev_data->devid;
-        else
-                devid = calc_devid(pdev->bus->number,
-                                   PCI_DEVFN(PCI_SLOT(pdev->devfn), 0));
-
-        *groupid = amd_iommu_alias_table[devid];
-
-        return 0;
-}
-
 static struct iommu_ops amd_iommu_ops = {
         .domain_init = amd_iommu_domain_init,
         .domain_destroy = amd_iommu_domain_destroy,
@@ -3256,7 +3236,6 @@ static struct iommu_ops amd_iommu_ops = {
         .unmap = amd_iommu_unmap,
         .iova_to_phys = amd_iommu_iova_to_phys,
         .domain_has_cap = amd_iommu_domain_has_cap,
-        .device_group = amd_iommu_device_group,
         .pgsize_bitmap  = AMD_IOMMU_PGSIZES,
 };
 
diff --git a/drivers/iommu/intel-iommu.c b/drivers/iommu/intel-iommu.c
index b12af2ff8c54..c62f2df25221 100644
--- a/drivers/iommu/intel-iommu.c
+++ b/drivers/iommu/intel-iommu.c
@@ -4090,54 +4090,6 @@ static int intel_iommu_domain_has_cap(struct iommu_domain *domain,
         return 0;
 }
 
-/*
- * Group numbers are arbitrary.  Device with the same group number
- * indicate the iommu cannot differentiate between them.  To avoid
- * tracking used groups we just use the seg|bus|devfn of the lowest
- * level we're able to differentiate devices
- */
-static int intel_iommu_device_group(struct device *dev, unsigned int *groupid)
-{
-        struct pci_dev *pdev = to_pci_dev(dev);
-        struct pci_dev *bridge;
-        union {
-                struct {
-                        u8 devfn;
-                        u8 bus;
-                        u16 segment;
-                } pci;
-                u32 group;
-        } id;
-
-        if (iommu_no_mapping(dev))
-                return -ENODEV;
-
-        id.pci.segment = pci_domain_nr(pdev->bus);
-        id.pci.bus = pdev->bus->number;
-        id.pci.devfn = pdev->devfn;
-
-        if (!device_to_iommu(id.pci.segment, id.pci.bus, id.pci.devfn))
-                return -ENODEV;
-
-        bridge = pci_find_upstream_pcie_bridge(pdev);
-        if (bridge) {
-                if (pci_is_pcie(bridge)) {
-                        id.pci.bus = bridge->subordinate->number;
-                        id.pci.devfn = 0;
-                } else {
-                        id.pci.bus = bridge->bus->number;
-                        id.pci.devfn = bridge->devfn;
-                }
-        }
-
-        if (!pdev->is_virtfn && iommu_group_mf)
-                id.pci.devfn = PCI_DEVFN(PCI_SLOT(id.pci.devfn), 0);
-
-        *groupid = id.group;
-
-        return 0;
-}
-
 static struct iommu_ops intel_iommu_ops = {
         .domain_init    = intel_iommu_domain_init,
         .domain_destroy = intel_iommu_domain_destroy,
@@ -4147,7 +4099,6 @@ static struct iommu_ops intel_iommu_ops = {
         .unmap          = intel_iommu_unmap,
         .iova_to_phys   = intel_iommu_iova_to_phys,
         .domain_has_cap = intel_iommu_domain_has_cap,
-        .device_group   = intel_iommu_device_group,
         .pgsize_bitmap  = INTEL_IOMMU_PGSIZES,
 };
 
diff --git a/drivers/iommu/iommu.c b/drivers/iommu/iommu.c
index 8b9ded88e6f5..0e928acd7dcf 100644
--- a/drivers/iommu/iommu.c
+++ b/drivers/iommu/iommu.c
@@ -26,60 +26,535 @@
 #include <linux/slab.h>
 #include <linux/errno.h>
 #include <linux/iommu.h>
+#include <linux/idr.h>
+#include <linux/notifier.h>
+#include <linux/err.h>
+
+static struct kset *iommu_group_kset;
+static struct ida iommu_group_ida;
+static struct mutex iommu_group_mutex;
+
+struct iommu_group {
+        struct kobject kobj;
+        struct kobject *devices_kobj;
+        struct list_head devices;
+        struct mutex mutex;
+        struct blocking_notifier_head notifier;
+        void *iommu_data;
+        void (*iommu_data_release)(void *iommu_data);
+        char *name;
+        int id;
+};
+
+struct iommu_device {
+        struct list_head list;
+        struct device *dev;
+        char *name;
+};
+
+struct iommu_group_attribute {
+        struct attribute attr;
+        ssize_t (*show)(struct iommu_group *group, char *buf);
+        ssize_t (*store)(struct iommu_group *group,
+                         const char *buf, size_t count);
+};
+
+#define IOMMU_GROUP_ATTR(_name, _mode, _show, _store)           \
+struct iommu_group_attribute iommu_group_attr_##_name =         \
+        __ATTR(_name, _mode, _show, _store)
 
-static ssize_t show_iommu_group(struct device *dev,
-                                struct device_attribute *attr, char *buf)
+#define to_iommu_group_attr(_attr)      \
+        container_of(_attr, struct iommu_group_attribute, attr)
+#define to_iommu_group(_kobj)           \
+        container_of(_kobj, struct iommu_group, kobj)
+
+static ssize_t iommu_group_attr_show(struct kobject *kobj,
+                                     struct attribute *__attr, char *buf)
 {
-        unsigned int groupid;
+        struct iommu_group_attribute *attr = to_iommu_group_attr(__attr);
+        struct iommu_group *group = to_iommu_group(kobj);
+        ssize_t ret = -EIO;
 
-        if (iommu_device_group(dev, &groupid))
-                return 0;
+        if (attr->show)
+                ret = attr->show(group, buf);
+        return ret;
+}
+
+static ssize_t iommu_group_attr_store(struct kobject *kobj,
+                                      struct attribute *__attr,
+                                      const char *buf, size_t count)
+{
+        struct iommu_group_attribute *attr = to_iommu_group_attr(__attr);
+        struct iommu_group *group = to_iommu_group(kobj);
+        ssize_t ret = -EIO;
 
-        return sprintf(buf, "%u", groupid);
+        if (attr->store)
+                ret = attr->store(group, buf, count);
+        return ret;
 }
-static DEVICE_ATTR(iommu_group, S_IRUGO, show_iommu_group, NULL);
 
-static int add_iommu_group(struct device *dev, void *data)
+static const struct sysfs_ops iommu_group_sysfs_ops = {
+        .show = iommu_group_attr_show,
+        .store = iommu_group_attr_store,
+};
+
+static int iommu_group_create_file(struct iommu_group *group,
+                                   struct iommu_group_attribute *attr)
+{
+        return sysfs_create_file(&group->kobj, &attr->attr);
+}
+
+static void iommu_group_remove_file(struct iommu_group *group,
+                                    struct iommu_group_attribute *attr)
+{
+        sysfs_remove_file(&group->kobj, &attr->attr);
+}
+
+static ssize_t iommu_group_show_name(struct iommu_group *group, char *buf)
+{
+        return sprintf(buf, "%s\n", group->name);
+}
+
+static IOMMU_GROUP_ATTR(name, S_IRUGO, iommu_group_show_name, NULL);
+
+static void iommu_group_release(struct kobject *kobj)
+{
+        struct iommu_group *group = to_iommu_group(kobj);
+
+        if (group->iommu_data_release)
+                group->iommu_data_release(group->iommu_data);
+
+        mutex_lock(&iommu_group_mutex);
+        ida_remove(&iommu_group_ida, group->id);
+        mutex_unlock(&iommu_group_mutex);
+
+        kfree(group->name);
+        kfree(group);
+}
+
+static struct kobj_type iommu_group_ktype = {
+        .sysfs_ops = &iommu_group_sysfs_ops,
+        .release = iommu_group_release,
+};
+
+/**
+ * iommu_group_alloc - Allocate a new group
+ * @name: Optional name to associate with group, visible in sysfs
+ *
+ * This function is called by an iommu driver to allocate a new iommu
+ * group.  The iommu group represents the minimum granularity of the iommu.
+ * Upon successful return, the caller holds a reference to the supplied
+ * group in order to hold the group until devices are added.  Use
+ * iommu_group_put() to release this extra reference count, allowing the
+ * group to be automatically reclaimed once it has no devices or external
+ * references.
+ */
+struct iommu_group *iommu_group_alloc(void)
 {
-        unsigned int groupid;
+        struct iommu_group *group;
+        int ret;
+
+        group = kzalloc(sizeof(*group), GFP_KERNEL);
+        if (!group)
+                return ERR_PTR(-ENOMEM);
+
+        group->kobj.kset = iommu_group_kset;
+        mutex_init(&group->mutex);
+        INIT_LIST_HEAD(&group->devices);
+        BLOCKING_INIT_NOTIFIER_HEAD(&group->notifier);
+
+        mutex_lock(&iommu_group_mutex);
+
+again:
+        if (unlikely(0 == ida_pre_get(&iommu_group_ida, GFP_KERNEL))) {
+                kfree(group);
+                mutex_unlock(&iommu_group_mutex);
+                return ERR_PTR(-ENOMEM);
+        }
+
+        if (-EAGAIN == ida_get_new(&iommu_group_ida, &group->id))
+                goto again;
+
+        mutex_unlock(&iommu_group_mutex);
 
-        if (iommu_device_group(dev, &groupid) == 0)
-                return device_create_file(dev, &dev_attr_iommu_group);
+        ret = kobject_init_and_add(&group->kobj, &iommu_group_ktype,
+                                   NULL, "%d", group->id);
+        if (ret) {
+                mutex_lock(&iommu_group_mutex);
+                ida_remove(&iommu_group_ida, group->id);
+                mutex_unlock(&iommu_group_mutex);
+                kfree(group);
+                return ERR_PTR(ret);
+        }
+
+        group->devices_kobj = kobject_create_and_add("devices", &group->kobj);
+        if (!group->devices_kobj) {
+                kobject_put(&group->kobj); /* triggers .release & free */
+                return ERR_PTR(-ENOMEM);
+        }
+
+        /*
+         * The devices_kobj holds a reference on the group kobject, so
+         * as long as that exists so will the group.  We can therefore
+         * use the devices_kobj for reference counting.
+         */
+        kobject_put(&group->kobj);
+
+        return group;
+}
+EXPORT_SYMBOL_GPL(iommu_group_alloc);
+
+/**
+ * iommu_group_get_iommudata - retrieve iommu_data registered for a group
+ * @group: the group
+ *
+ * iommu drivers can store data in the group for use when doing iommu
+ * operations.  This function provides a way to retrieve it.  Caller
+ * should hold a group reference.
+ */
+void *iommu_group_get_iommudata(struct iommu_group *group)
+{
+        return group->iommu_data;
+}
+EXPORT_SYMBOL_GPL(iommu_group_get_iommudata);
+
+/**
+ * iommu_group_set_iommudata - set iommu_data for a group
+ * @group: the group
+ * @iommu_data: new data
+ * @release: release function for iommu_data
+ *
+ * iommu drivers can store data in the group for use when doing iommu
+ * operations.  This function provides a way to set the data after
+ * the group has been allocated.  Caller should hold a group reference.
+ */
+void iommu_group_set_iommudata(struct iommu_group *group, void *iommu_data,
+                               void (*release)(void *iommu_data))
+{
+        group->iommu_data = iommu_data;
+        group->iommu_data_release = release;
+}
+EXPORT_SYMBOL_GPL(iommu_group_set_iommudata);
+
+/**
+ * iommu_group_set_name - set name for a group
+ * @group: the group
+ * @name: name
+ *
+ * Allow iommu driver to set a name for a group.  When set it will
+ * appear in a name attribute file under the group in sysfs.
+ */
+int iommu_group_set_name(struct iommu_group *group, const char *name)
+{
+        int ret;
+
+        if (group->name) {
+                iommu_group_remove_file(group, &iommu_group_attr_name);
+                kfree(group->name);
+                group->name = NULL;
+                if (!name)
+                        return 0;
+        }
+
+        group->name = kstrdup(name, GFP_KERNEL);
+        if (!group->name)
+                return -ENOMEM;
+
+        ret = iommu_group_create_file(group, &iommu_group_attr_name);
+        if (ret) {
+                kfree(group->name);
+                group->name = NULL;
+                return ret;
+        }
 
         return 0;
 }
+EXPORT_SYMBOL_GPL(iommu_group_set_name);
 
-static int remove_iommu_group(struct device *dev)
+/**
+ * iommu_group_add_device - add a device to an iommu group
+ * @group: the group into which to add the device (reference should be held)
+ * @dev: the device
+ *
+ * This function is called by an iommu driver to add a device into a
+ * group.  Adding a device increments the group reference count.
+ */
+int iommu_group_add_device(struct iommu_group *group, struct device *dev)
 {
-        unsigned int groupid;
+        int ret, i = 0;
+        struct iommu_device *device;
+
+        device = kzalloc(sizeof(*device), GFP_KERNEL);
+        if (!device)
+                return -ENOMEM;
+
+        device->dev = dev;
 
-        if (iommu_device_group(dev, &groupid) == 0)
-                device_remove_file(dev, &dev_attr_iommu_group);
+        ret = sysfs_create_link(&dev->kobj, &group->kobj, "iommu_group");
+        if (ret) {
+                kfree(device);
+                return ret;
+        }
+
+        device->name = kasprintf(GFP_KERNEL, "%s", kobject_name(&dev->kobj));
+rename:
+        if (!device->name) {
+                sysfs_remove_link(&dev->kobj, "iommu_group");
+                kfree(device);
+                return -ENOMEM;
+        }
 
+        ret = sysfs_create_link_nowarn(group->devices_kobj,
+                                       &dev->kobj, device->name);
+        if (ret) {
+                kfree(device->name);
+                if (ret == -EEXIST && i >= 0) {
+                        /*
+                         * Account for the slim chance of collision
+                         * and append an instance to the name.
+                         */
+                        device->name = kasprintf(GFP_KERNEL, "%s.%d",
+                                                 kobject_name(&dev->kobj), i++);
+                        goto rename;
+                }
+
+                sysfs_remove_link(&dev->kobj, "iommu_group");
+                kfree(device);
+                return ret;
+        }
+
+        kobject_get(group->devices_kobj);
+
+        dev->iommu_group = group;
+
+        mutex_lock(&group->mutex);
+        list_add_tail(&device->list, &group->devices);
+        mutex_unlock(&group->mutex);
+
+        /* Notify any listeners about change to group. */
+        blocking_notifier_call_chain(&group->notifier,
+                                     IOMMU_GROUP_NOTIFY_ADD_DEVICE, dev);
         return 0;
 }
+EXPORT_SYMBOL_GPL(iommu_group_add_device);
 
-static int iommu_device_notifier(struct notifier_block *nb,
-                                 unsigned long action, void *data)
+/**
+ * iommu_group_remove_device - remove a device from it's current group
+ * @dev: device to be removed
+ *
+ * This function is called by an iommu driver to remove the device from
+ * it's current group.  This decrements the iommu group reference count.
+ */
+void iommu_group_remove_device(struct device *dev)
+{
+        struct iommu_group *group = dev->iommu_group;
+        struct iommu_device *tmp_device, *device = NULL;
+
+        /* Pre-notify listeners that a device is being removed. */
+        blocking_notifier_call_chain(&group->notifier,
+                                     IOMMU_GROUP_NOTIFY_DEL_DEVICE, dev);
+
+        mutex_lock(&group->mutex);
+        list_for_each_entry(tmp_device, &group->devices, list) {
+                if (tmp_device->dev == dev) {
+                        device = tmp_device;
+                        list_del(&device->list);
+                        break;
+                }
+        }
+        mutex_unlock(&group->mutex);
+
+        if (!device)
+                return;
+
+        sysfs_remove_link(group->devices_kobj, device->name);
+        sysfs_remove_link(&dev->kobj, "iommu_group");
+
+        kfree(device->name);
+        kfree(device);
+        dev->iommu_group = NULL;
+        kobject_put(group->devices_kobj);
+}
+EXPORT_SYMBOL_GPL(iommu_group_remove_device);
+
+/**
+ * iommu_group_for_each_dev - iterate over each device in the group
+ * @group: the group
+ * @data: caller opaque data to be passed to callback function
+ * @fn: caller supplied callback function
+ *
+ * This function is called by group users to iterate over group devices.
+ * Callers should hold a reference count to the group during callback.
+ * The group->mutex is held across callbacks, which will block calls to
+ * iommu_group_add/remove_device.
+ */
+int iommu_group_for_each_dev(struct iommu_group *group, void *data,
+                             int (*fn)(struct device *, void *))
+{
+        struct iommu_device *device;
+        int ret = 0;
+
+        mutex_lock(&group->mutex);
+        list_for_each_entry(device, &group->devices, list) {
+                ret = fn(device->dev, data);
+                if (ret)
+                        break;
+        }
+        mutex_unlock(&group->mutex);
+        return ret;
+}
+EXPORT_SYMBOL_GPL(iommu_group_for_each_dev);
+
+/**
+ * iommu_group_get - Return the group for a device and increment reference
+ * @dev: get the group that this device belongs to
+ *
+ * This function is called by iommu drivers and users to get the group
+ * for the specified device.  If found, the group is returned and the group
+ * reference in incremented, else NULL.
+ */
+struct iommu_group *iommu_group_get(struct device *dev)
+{
+        struct iommu_group *group = dev->iommu_group;
+
+        if (group)
+                kobject_get(group->devices_kobj);
+
+        return group;
+}
+EXPORT_SYMBOL_GPL(iommu_group_get);
+
+/**
+ * iommu_group_put - Decrement group reference
+ * @group: the group to use
+ *
+ * This function is called by iommu drivers and users to release the
+ * iommu group.  Once the reference count is zero, the group is released.
+ */
+void iommu_group_put(struct iommu_group *group)
+{
+        if (group)
+                kobject_put(group->devices_kobj);
+}
+EXPORT_SYMBOL_GPL(iommu_group_put);
+
+/**
+ * iommu_group_register_notifier - Register a notifier for group changes
+ * @group: the group to watch
+ * @nb: notifier block to signal
+ *
+ * This function allows iommu group users to track changes in a group.
+ * See include/linux/iommu.h for actions sent via this notifier.  Caller
+ * should hold a reference to the group throughout notifier registration.
+ */
+int iommu_group_register_notifier(struct iommu_group *group,
+                                  struct notifier_block *nb)
+{
+        return blocking_notifier_chain_register(&group->notifier, nb);
+}
+EXPORT_SYMBOL_GPL(iommu_group_register_notifier);
+
+/**
+ * iommu_group_unregister_notifier - Unregister a notifier
+ * @group: the group to watch
+ * @nb: notifier block to signal
+ *
+ * Unregister a previously registered group notifier block.
+ */
+int iommu_group_unregister_notifier(struct iommu_group *group,
+                                    struct notifier_block *nb)
+{
+        return blocking_notifier_chain_unregister(&group->notifier, nb);
+}
+EXPORT_SYMBOL_GPL(iommu_group_unregister_notifier);
+
+/**
+ * iommu_group_id - Return ID for a group
+ * @group: the group to ID
+ *
+ * Return the unique ID for the group matching the sysfs group number.
+ */
+int iommu_group_id(struct iommu_group *group)
+{
+        return group->id;
+}
+EXPORT_SYMBOL_GPL(iommu_group_id);
+
+static int add_iommu_group(struct device *dev, void *data)
+{
+        struct iommu_ops *ops = data;
+
+        if (!ops->add_device)
+                return -ENODEV;
+
+        WARN_ON(dev->iommu_group);
+
+        ops->add_device(dev);
+
+        return 0;
+}
+
+static int iommu_bus_notifier(struct notifier_block *nb,
+                              unsigned long action, void *data)
 {
         struct device *dev = data;
+        struct iommu_ops *ops = dev->bus->iommu_ops;
+        struct iommu_group *group;
+        unsigned long group_action = 0;
+
+        /*
+         * ADD/DEL call into iommu driver ops if provided, which may
+         * result in ADD/DEL notifiers to group->notifier
+         */
+        if (action == BUS_NOTIFY_ADD_DEVICE) {
+                if (ops->add_device)
+                        return ops->add_device(dev);
+        } else if (action == BUS_NOTIFY_DEL_DEVICE) {
+                if (ops->remove_device && dev->iommu_group) {
+                        ops->remove_device(dev);
+                        return 0;
+                }
+        }
 
-        if (action == BUS_NOTIFY_ADD_DEVICE)
-                return add_iommu_group(dev, NULL);
-        else if (action == BUS_NOTIFY_DEL_DEVICE)
-                return remove_iommu_group(dev);
+        /*
+         * Remaining BUS_NOTIFYs get filtered and republished to the
+         * group, if anyone is listening
+         */
+        group = iommu_group_get(dev);
+        if (!group)
+                return 0;
 
+        switch (action) {
+        case BUS_NOTIFY_BIND_DRIVER:
+                group_action = IOMMU_GROUP_NOTIFY_BIND_DRIVER;
+                break;
+        case BUS_NOTIFY_BOUND_DRIVER:
+                group_action = IOMMU_GROUP_NOTIFY_BOUND_DRIVER;
+                break;
+        case BUS_NOTIFY_UNBIND_DRIVER:
+                group_action = IOMMU_GROUP_NOTIFY_UNBIND_DRIVER;
+                break;
+        case BUS_NOTIFY_UNBOUND_DRIVER:
+                group_action = IOMMU_GROUP_NOTIFY_UNBOUND_DRIVER;
+                break;
+        }
+
+        if (group_action)
+                blocking_notifier_call_chain(&group->notifier,
+                                             group_action, dev);
+
+        iommu_group_put(group);
         return 0;
 }
 
-static struct notifier_block iommu_device_nb = {
-        .notifier_call = iommu_device_notifier,
+static struct notifier_block iommu_bus_nb = {
+        .notifier_call = iommu_bus_notifier,
 };
 
 static void iommu_bus_init(struct bus_type *bus, struct iommu_ops *ops)
 {
-        bus_register_notifier(bus, &iommu_device_nb);
-        bus_for_each_dev(bus, NULL, NULL, add_iommu_group);
+        bus_register_notifier(bus, &iommu_bus_nb);
+        bus_for_each_dev(bus, NULL, ops, add_iommu_group);
 }
 
 /**
@@ -192,6 +667,45 @@ void iommu_detach_device(struct iommu_domain *domain, struct device *dev)
 }
 EXPORT_SYMBOL_GPL(iommu_detach_device);
 
+/*
+ * IOMMU groups are really the natrual working unit of the IOMMU, but
+ * the IOMMU API works on domains and devices.  Bridge that gap by
+ * iterating over the devices in a group.  Ideally we'd have a single
+ * device which represents the requestor ID of the group, but we also
+ * allow IOMMU drivers to create policy defined minimum sets, where
+ * the physical hardware may be able to distiguish members, but we
+ * wish to group them at a higher level (ex. untrusted multi-function
+ * PCI devices).  Thus we attach each device.
+ */
+static int iommu_group_do_attach_device(struct device *dev, void *data)
+{
+        struct iommu_domain *domain = data;
+
+        return iommu_attach_device(domain, dev);
+}
+
+int iommu_attach_group(struct iommu_domain *domain, struct iommu_group *group)
+{
+        return iommu_group_for_each_dev(group, domain,
+                                        iommu_group_do_attach_device);
+}
+EXPORT_SYMBOL_GPL(iommu_attach_group);
+
+static int iommu_group_do_detach_device(struct device *dev, void *data)
+{
+        struct iommu_domain *domain = data;
+
+        iommu_detach_device(domain, dev);
+
+        return 0;
+}
+
+void iommu_detach_group(struct iommu_domain *domain, struct iommu_group *group)
+{
+        iommu_group_for_each_dev(group, domain, iommu_group_do_detach_device);
+}
+EXPORT_SYMBOL_GPL(iommu_detach_group);
+
 phys_addr_t iommu_iova_to_phys(struct iommu_domain *domain,
                                unsigned long iova)
 {
@@ -336,11 +850,15 @@ size_t iommu_unmap(struct iommu_domain *domain, unsigned long iova, size_t size)
 }
 EXPORT_SYMBOL_GPL(iommu_unmap);
 
-int iommu_device_group(struct device *dev, unsigned int *groupid)
+static int __init iommu_init(void)
 {
-        if (iommu_present(dev->bus) && dev->bus->iommu_ops->device_group)
-                return dev->bus->iommu_ops->device_group(dev, groupid);
+        iommu_group_kset = kset_create_and_add("iommu_groups",
+                                               NULL, kernel_kobj);
+        ida_init(&iommu_group_ida);
+        mutex_init(&iommu_group_mutex);
 
-        return -ENODEV;
+        BUG_ON(!iommu_group_kset);
+
+        return 0;
 }
-EXPORT_SYMBOL_GPL(iommu_device_group);
+subsys_initcall(iommu_init);
diff --git a/include/linux/iommu.h b/include/linux/iommu.h
index 450293f6d68b..a71df92be992 100644
--- a/include/linux/iommu.h
+++ b/include/linux/iommu.h
@@ -26,6 +26,7 @@
 #define IOMMU_CACHE     (4) /* DMA cache coherency */
 
 struct iommu_ops;
+struct iommu_group;
 struct bus_type;
 struct device;
 struct iommu_domain;
@@ -60,6 +61,8 @@ struct iommu_domain {
  * @iova_to_phys: translate iova to physical address
  * @domain_has_cap: domain capabilities query
  * @commit: commit iommu domain
+ * @add_device: add device to iommu grouping
+ * @remove_device: remove device from iommu grouping
  * @pgsize_bitmap: bitmap of supported page sizes
  */
 struct iommu_ops {
@@ -75,10 +78,18 @@ struct iommu_ops {
                                     unsigned long iova);
         int (*domain_has_cap)(struct iommu_domain *domain,
                               unsigned long cap);
-        int (*device_group)(struct device *dev, unsigned int *groupid);
+        int (*add_device)(struct device *dev);
+        void (*remove_device)(struct device *dev);
         unsigned long pgsize_bitmap;
 };
 
+#define IOMMU_GROUP_NOTIFY_ADD_DEVICE           1 /* Device added */
+#define IOMMU_GROUP_NOTIFY_DEL_DEVICE           2 /* Pre Device removed */
+#define IOMMU_GROUP_NOTIFY_BIND_DRIVER          3 /* Pre Driver bind */
+#define IOMMU_GROUP_NOTIFY_BOUND_DRIVER         4 /* Post Driver bind */
+#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 bool iommu_present(struct bus_type *bus);
 extern struct iommu_domain *iommu_domain_alloc(struct bus_type *bus);
@@ -97,7 +108,29 @@ extern int iommu_domain_has_cap(struct iommu_domain *domain,
                                 unsigned long cap);
 extern void iommu_set_fault_handler(struct iommu_domain *domain,
                         iommu_fault_handler_t handler, void *token);
-extern int iommu_device_group(struct device *dev, unsigned int *groupid);
+
+extern int iommu_attach_group(struct iommu_domain *domain,
+                              struct iommu_group *group);
+extern void iommu_detach_group(struct iommu_domain *domain,
+                               struct iommu_group *group);
+extern struct iommu_group *iommu_group_alloc(void);
+extern void *iommu_group_get_iommudata(struct iommu_group *group);
+extern void iommu_group_set_iommudata(struct iommu_group *group,
+                                      void *iommu_data,
+                                      void (*release)(void *iommu_data));
+extern int iommu_group_set_name(struct iommu_group *group, const char *name);
+extern int iommu_group_add_device(struct iommu_group *group,
+                                  struct device *dev);
+extern void iommu_group_remove_device(struct device *dev);
+extern int iommu_group_for_each_dev(struct iommu_group *group, void *data,
+                                    int (*fn)(struct device *, void *));
+extern struct iommu_group *iommu_group_get(struct device *dev);
+extern void iommu_group_put(struct iommu_group *group);
+extern int iommu_group_register_notifier(struct iommu_group *group,
+                                         struct notifier_block *nb);
+extern int iommu_group_unregister_notifier(struct iommu_group *group,
+                                           struct notifier_block *nb);
+extern int iommu_group_id(struct iommu_group *group);
 
 /**
  * report_iommu_fault() - report about an IOMMU fault to the IOMMU framework
@@ -142,6 +175,7 @@ static inline int report_iommu_fault(struct iommu_domain *domain,
 #else /* CONFIG_IOMMU_API */
 
 struct iommu_ops {};
+struct iommu_group {};
 
 static inline bool iommu_present(struct bus_type *bus)
 {
@@ -197,11 +231,75 @@ static inline void iommu_set_fault_handler(struct iommu_domain *domain,
 {
 }
 
-static inline int iommu_device_group(struct device *dev, unsigned int *groupid)
+int iommu_attach_group(struct iommu_domain *domain, struct iommu_group *group)
+{
+        return -ENODEV;
+}
+
+void iommu_detach_group(struct iommu_domain *domain, struct iommu_group *group)
+{
+}
+
+struct iommu_group *iommu_group_alloc(void)
+{
+        return ERR_PTR(-ENODEV);
+}
+
+void *iommu_group_get_iommudata(struct iommu_group *group)
+{
+        return NULL;
+}
+
+void iommu_group_set_iommudata(struct iommu_group *group, void *iommu_data,
+                               void (*release)(void *iommu_data))
+{
+}
+
+int iommu_group_set_name(struct iommu_group *group, const char *name)
+{
+        return -ENODEV;
+}
+
+int iommu_group_add_device(struct iommu_group *group, struct device *dev)
+{
+        return -ENODEV;
+}
+
+void iommu_group_remove_device(struct device *dev)
+{
+}
+
+int iommu_group_for_each_dev(struct iommu_group *group, void *data,
+                             int (*fn)(struct device *, void *))
+{
+        return -ENODEV;
+}
+
+struct iommu_group *iommu_group_get(struct device *dev)
+{
+        return NULL;
+}
+
+void iommu_group_put(struct iommu_group *group)
+{
+}
+
+int iommu_group_register_notifier(struct iommu_group *group,
+                                  struct notifier_block *nb)
 {
         return -ENODEV;
 }
 
+int iommu_group_unregister_notifier(struct iommu_group *group,
+                                    struct notifier_block *nb)
+{
+        return 0;
+}
+
+int iommu_group_id(struct iommu_group *group)
+{
+        return -ENODEV;
+}
 #endif /* CONFIG_IOMMU_API */
 
 #endif /* __LINUX_IOMMU_H */