drivers/iommu/iommu.c

   1 /*
   2  * Copyright (C) 2007-2008 Advanced Micro Devices, Inc.
   3  * Author: Joerg Roedel <joerg.roedel@amd.com>
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 as published
   7  * by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  17  */
  18
  19 #define pr_fmt(fmt)    "%s: " fmt, __func__
  20
  21 #include <linux/device.h>
  22 #include <linux/kernel.h>
  23 #include <linux/bug.h>
  24 #include <linux/types.h>
  25 #include <linux/module.h>
  26 #include <linux/slab.h>
  27 #include <linux/errno.h>
  28 #include <linux/iommu.h>
  29 #include <linux/idr.h>
  30 #include <linux/notifier.h>
  31 #include <linux/err.h>
  32 #include <trace/events/iommu.h>
  33
  34 static struct kset *iommu_group_kset;
  35 static struct ida iommu_group_ida;
  36 static struct mutex iommu_group_mutex;
  37
  38 struct iommu_group {
  39         struct kobject kobj;
  40         struct kobject *devices_kobj;
  41         struct list_head devices;
  42         struct mutex mutex;
  43         struct blocking_notifier_head notifier;
  44         void *iommu_data;
  45         void (*iommu_data_release)(void *iommu_data);
  46         char *name;
  47         int id;
  48 };
  49
  50 struct iommu_device {
  51         struct list_head list;
  52         struct device *dev;
  53         char *name;
  54 };
  55
  56 struct iommu_group_attribute {
  57         struct attribute attr;
  58         ssize_t (*show)(struct iommu_group *group, char *buf);
  59         ssize_t (*store)(struct iommu_group *group,
  60                          const char *buf, size_t count);
  61 };
  62
  63 #define IOMMU_GROUP_ATTR(_name, _mode, _show, _store)           \
  64 struct iommu_group_attribute iommu_group_attr_##_name =         \
  65         __ATTR(_name, _mode, _show, _store)
  66
  67 #define to_iommu_group_attr(_attr)      \
  68         container_of(_attr, struct iommu_group_attribute, attr)
  69 #define to_iommu_group(_kobj)           \
  70         container_of(_kobj, struct iommu_group, kobj)
  71
  72 static ssize_t iommu_group_attr_show(struct kobject *kobj,
  73                                      struct attribute *__attr, char *buf)
  74 {
  75         struct iommu_group_attribute *attr = to_iommu_group_attr(__attr);
  76         struct iommu_group *group = to_iommu_group(kobj);
  77         ssize_t ret = -EIO;
  78
  79         if (attr->show)
  80                 ret = attr->show(group, buf);
  81         return ret;
  82 }
  83
  84 static ssize_t iommu_group_attr_store(struct kobject *kobj,
  85                                       struct attribute *__attr,
  86                                       const char *buf, size_t count)
  87 {
  88         struct iommu_group_attribute *attr = to_iommu_group_attr(__attr);
  89         struct iommu_group *group = to_iommu_group(kobj);
  90         ssize_t ret = -EIO;
  91
  92         if (attr->store)
  93                 ret = attr->store(group, buf, count);
  94         return ret;
  95 }
  96
  97 static const struct sysfs_ops iommu_group_sysfs_ops = {
  98         .show = iommu_group_attr_show,
  99         .store = iommu_group_attr_store,
 100 };
 101
 102 static int iommu_group_create_file(struct iommu_group *group,
 103                                    struct iommu_group_attribute *attr)
 104 {
 105         return sysfs_create_file(&group->kobj, &attr->attr);
 106 }
 107
 108 static void iommu_group_remove_file(struct iommu_group *group,
 109                                     struct iommu_group_attribute *attr)
 110 {
 111         sysfs_remove_file(&group->kobj, &attr->attr);
 112 }
 113
 114 static ssize_t iommu_group_show_name(struct iommu_group *group, char *buf)
 115 {
 116         return sprintf(buf, "%s\n", group->name);
 117 }
 118
 119 static IOMMU_GROUP_ATTR(name, S_IRUGO, iommu_group_show_name, NULL);
 120
 121 static void iommu_group_release(struct kobject *kobj)
 122 {
 123         struct iommu_group *group = to_iommu_group(kobj);
 124
 125         if (group->iommu_data_release)
 126                 group->iommu_data_release(group->iommu_data);
 127
 128         mutex_lock(&iommu_group_mutex);
 129         ida_remove(&iommu_group_ida, group->id);
 130         mutex_unlock(&iommu_group_mutex);
 131
 132         kfree(group->name);
 133         kfree(group);
 134 }
 135
 136 static struct kobj_type iommu_group_ktype = {
 137         .sysfs_ops = &iommu_group_sysfs_ops,
 138         .release = iommu_group_release,
 139 };
 140
 141 /**
 142  * iommu_group_alloc - Allocate a new group
 143  * @name: Optional name to associate with group, visible in sysfs
 144  *
 145  * This function is called by an iommu driver to allocate a new iommu
 146  * group.  The iommu group represents the minimum granularity of the iommu.
 147  * Upon successful return, the caller holds a reference to the supplied
 148  * group in order to hold the group until devices are added.  Use
 149  * iommu_group_put() to release this extra reference count, allowing the
 150  * group to be automatically reclaimed once it has no devices or external
 151  * references.
 152  */
 153 struct iommu_group *iommu_group_alloc(void)
 154 {
 155         struct iommu_group *group;
 156         int ret;
 157
 158         group = kzalloc(sizeof(*group), GFP_KERNEL);
 159         if (!group)
 160                 return ERR_PTR(-ENOMEM);
 161
 162         group->kobj.kset = iommu_group_kset;
 163         mutex_init(&group->mutex);
 164         INIT_LIST_HEAD(&group->devices);
 165         BLOCKING_INIT_NOTIFIER_HEAD(&group->notifier);
 166
 167         mutex_lock(&iommu_group_mutex);
 168
 169 again:
 170         if (unlikely(0 == ida_pre_get(&iommu_group_ida, GFP_KERNEL))) {
 171                 kfree(group);
 172                 mutex_unlock(&iommu_group_mutex);
 173                 return ERR_PTR(-ENOMEM);
 174         }
 175
 176         if (-EAGAIN == ida_get_new(&iommu_group_ida, &group->id))
 177                 goto again;
 178
 179         mutex_unlock(&iommu_group_mutex);
 180
 181         ret = kobject_init_and_add(&group->kobj, &iommu_group_ktype,
 182                                    NULL, "%d", group->id);
 183         if (ret) {
 184                 mutex_lock(&iommu_group_mutex);
 185                 ida_remove(&iommu_group_ida, group->id);
 186                 mutex_unlock(&iommu_group_mutex);
 187                 kfree(group);
 188                 return ERR_PTR(ret);
 189         }
 190
 191         group->devices_kobj = kobject_create_and_add("devices", &group->kobj);
 192         if (!group->devices_kobj) {
 193                 kobject_put(&group->kobj); /* triggers .release & free */
 194                 return ERR_PTR(-ENOMEM);
 195         }
 196
 197         /*
 198          * The devices_kobj holds a reference on the group kobject, so
 199          * as long as that exists so will the group.  We can therefore
 200          * use the devices_kobj for reference counting.
 201          */
 202         kobject_put(&group->kobj);
 203
 204         return group;
 205 }
 206 EXPORT_SYMBOL_GPL(iommu_group_alloc);
 207
 208 struct iommu_group *iommu_group_get_by_id(int id)
 209 {
 210         struct kobject *group_kobj;
 211         struct iommu_group *group;
 212         const char *name;
 213
 214         if (!iommu_group_kset)
 215                 return NULL;
 216
 217         name = kasprintf(GFP_KERNEL, "%d", id);
 218         if (!name)
 219                 return NULL;
 220
 221         group_kobj = kset_find_obj(iommu_group_kset, name);
 222         kfree(name);
 223
 224         if (!group_kobj)
 225                 return NULL;
 226
 227         group = container_of(group_kobj, struct iommu_group, kobj);
 228         BUG_ON(group->id != id);
 229
 230         kobject_get(group->devices_kobj);
 231         kobject_put(&group->kobj);
 232
 233         return group;
 234 }
 235 EXPORT_SYMBOL_GPL(iommu_group_get_by_id);
 236
 237 /**
 238  * iommu_group_get_iommudata - retrieve iommu_data registered for a group
 239  * @group: the group
 240  *
 241  * iommu drivers can store data in the group for use when doing iommu
 242  * operations.  This function provides a way to retrieve it.  Caller
 243  * should hold a group reference.
 244  */
 245 void *iommu_group_get_iommudata(struct iommu_group *group)
 246 {
 247         return group->iommu_data;
 248 }
 249 EXPORT_SYMBOL_GPL(iommu_group_get_iommudata);
 250
 251 /**
 252  * iommu_group_set_iommudata - set iommu_data for a group
 253  * @group: the group
 254  * @iommu_data: new data
 255  * @release: release function for iommu_data
 256  *
 257  * iommu drivers can store data in the group for use when doing iommu
 258  * operations.  This function provides a way to set the data after
 259  * the group has been allocated.  Caller should hold a group reference.
 260  */
 261 void iommu_group_set_iommudata(struct iommu_group *group, void *iommu_data,
 262                                void (*release)(void *iommu_data))
 263 {
 264         group->iommu_data = iommu_data;
 265         group->iommu_data_release = release;
 266 }
 267 EXPORT_SYMBOL_GPL(iommu_group_set_iommudata);
 268
 269 /**
 270  * iommu_group_set_name - set name for a group
 271  * @group: the group
 272  * @name: name
 273  *
 274  * Allow iommu driver to set a name for a group.  When set it will
 275  * appear in a name attribute file under the group in sysfs.
 276  */
 277 int iommu_group_set_name(struct iommu_group *group, const char *name)
 278 {
 279         int ret;
 280
 281         if (group->name) {
 282                 iommu_group_remove_file(group, &iommu_group_attr_name);
 283                 kfree(group->name);
 284                 group->name = NULL;
 285                 if (!name)
 286                         return 0;
 287         }
 288
 289         group->name = kstrdup(name, GFP_KERNEL);
 290         if (!group->name)
 291                 return -ENOMEM;
 292
 293         ret = iommu_group_create_file(group, &iommu_group_attr_name);
 294         if (ret) {
 295                 kfree(group->name);
 296                 group->name = NULL;
 297                 return ret;
 298         }
 299
 300         return 0;
 301 }
 302 EXPORT_SYMBOL_GPL(iommu_group_set_name);
 303
 304 /**
 305  * iommu_group_add_device - add a device to an iommu group
 306  * @group: the group into which to add the device (reference should be held)
 307  * @dev: the device
 308  *
 309  * This function is called by an iommu driver to add a device into a
 310  * group.  Adding a device increments the group reference count.
 311  */
 312 int iommu_group_add_device(struct iommu_group *group, struct device *dev)
 313 {
 314         int ret, i = 0;
 315         struct iommu_device *device;
 316
 317         device = kzalloc(sizeof(*device), GFP_KERNEL);
 318         if (!device)
 319                 return -ENOMEM;
 320
 321         device->dev = dev;
 322
 323         ret = sysfs_create_link(&dev->kobj, &group->kobj, "iommu_group");
 324         if (ret) {
 325                 kfree(device);
 326                 return ret;
 327         }
 328
 329         device->name = kasprintf(GFP_KERNEL, "%s", kobject_name(&dev->kobj));
 330 rename:
 331         if (!device->name) {
 332                 sysfs_remove_link(&dev->kobj, "iommu_group");
 333                 kfree(device);
 334                 return -ENOMEM;
 335         }
 336
 337         ret = sysfs_create_link_nowarn(group->devices_kobj,
 338                                        &dev->kobj, device->name);
 339         if (ret) {
 340                 kfree(device->name);
 341                 if (ret == -EEXIST && i >= 0) {
 342                         /*
 343                          * Account for the slim chance of collision
 344                          * and append an instance to the name.
 345                          */
 346                         device->name = kasprintf(GFP_KERNEL, "%s.%d",
 347                                                  kobject_name(&dev->kobj), i++);
 348                         goto rename;
 349                 }
 350
 351                 sysfs_remove_link(&dev->kobj, "iommu_group");
 352                 kfree(device);
 353                 return ret;
 354         }
 355
 356         kobject_get(group->devices_kobj);
 357
 358         dev->iommu_group = group;
 359
 360         mutex_lock(&group->mutex);
 361         list_add_tail(&device->list, &group->devices);
 362         mutex_unlock(&group->mutex);
 363
 364         /* Notify any listeners about change to group. */
 365         blocking_notifier_call_chain(&group->notifier,
 366                                      IOMMU_GROUP_NOTIFY_ADD_DEVICE, dev);
 367         return 0;
 368 }
 369 EXPORT_SYMBOL_GPL(iommu_group_add_device);
 370
 371 /**
 372  * iommu_group_remove_device - remove a device from it's current group
 373  * @dev: device to be removed
 374  *
 375  * This function is called by an iommu driver to remove the device from
 376  * it's current group.  This decrements the iommu group reference count.
 377  */
 378 void iommu_group_remove_device(struct device *dev)
 379 {
 380         struct iommu_group *group = dev->iommu_group;
 381         struct iommu_device *tmp_device, *device = NULL;
 382
 383         /* Pre-notify listeners that a device is being removed. */
 384         blocking_notifier_call_chain(&group->notifier,
 385                                      IOMMU_GROUP_NOTIFY_DEL_DEVICE, dev);
 386
 387         mutex_lock(&group->mutex);
 388         list_for_each_entry(tmp_device, &group->devices, list) {
 389                 if (tmp_device->dev == dev) {
 390                         device = tmp_device;
 391                         list_del(&device->list);
 392                         break;
 393                 }
 394         }
 395         mutex_unlock(&group->mutex);
 396
 397         if (!device)
 398                 return;
 399
 400         sysfs_remove_link(group->devices_kobj, device->name);
 401         sysfs_remove_link(&dev->kobj, "iommu_group");
 402
 403         kfree(device->name);
 404         kfree(device);
 405         dev->iommu_group = NULL;
 406         kobject_put(group->devices_kobj);
 407 }
 408 EXPORT_SYMBOL_GPL(iommu_group_remove_device);
 409
 410 /**
 411  * iommu_group_for_each_dev - iterate over each device in the group
 412  * @group: the group
 413  * @data: caller opaque data to be passed to callback function
 414  * @fn: caller supplied callback function
 415  *
 416  * This function is called by group users to iterate over group devices.
 417  * Callers should hold a reference count to the group during callback.
 418  * The group->mutex is held across callbacks, which will block calls to
 419  * iommu_group_add/remove_device.
 420  */
 421 int iommu_group_for_each_dev(struct iommu_group *group, void *data,
 422                              int (*fn)(struct device *, void *))
 423 {
 424         struct iommu_device *device;
 425         int ret = 0;
 426
 427         mutex_lock(&group->mutex);
 428         list_for_each_entry(device, &group->devices, list) {
 429                 ret = fn(device->dev, data);
 430                 if (ret)
 431                         break;
 432         }
 433         mutex_unlock(&group->mutex);
 434         return ret;
 435 }
 436 EXPORT_SYMBOL_GPL(iommu_group_for_each_dev);
 437
 438 /**
 439  * iommu_group_get - Return the group for a device and increment reference
 440  * @dev: get the group that this device belongs to
 441  *
 442  * This function is called by iommu drivers and users to get the group
 443  * for the specified device.  If found, the group is returned and the group
 444  * reference in incremented, else NULL.
 445  */
 446 struct iommu_group *iommu_group_get(struct device *dev)
 447 {
 448         struct iommu_group *group = dev->iommu_group;
 449
 450         if (group)
 451                 kobject_get(group->devices_kobj);
 452
 453         return group;
 454 }
 455 EXPORT_SYMBOL_GPL(iommu_group_get);
 456
 457 /**
 458  * iommu_group_put - Decrement group reference
 459  * @group: the group to use
 460  *
 461  * This function is called by iommu drivers and users to release the
 462  * iommu group.  Once the reference count is zero, the group is released.
 463  */
 464 void iommu_group_put(struct iommu_group *group)
 465 {
 466         if (group)
 467                 kobject_put(group->devices_kobj);
 468 }
 469 EXPORT_SYMBOL_GPL(iommu_group_put);
 470
 471 /**
 472  * iommu_group_register_notifier - Register a notifier for group changes
 473  * @group: the group to watch
 474  * @nb: notifier block to signal
 475  *
 476  * This function allows iommu group users to track changes in a group.
 477  * See include/linux/iommu.h for actions sent via this notifier.  Caller
 478  * should hold a reference to the group throughout notifier registration.
 479  */
 480 int iommu_group_register_notifier(struct iommu_group *group,
 481                                   struct notifier_block *nb)
 482 {
 483         return blocking_notifier_chain_register(&group->notifier, nb);
 484 }
 485 EXPORT_SYMBOL_GPL(iommu_group_register_notifier);
 486
 487 /**
 488  * iommu_group_unregister_notifier - Unregister a notifier
 489  * @group: the group to watch
 490  * @nb: notifier block to signal
 491  *
 492  * Unregister a previously registered group notifier block.
 493  */
 494 int iommu_group_unregister_notifier(struct iommu_group *group,
 495                                     struct notifier_block *nb)
 496 {
 497         return blocking_notifier_chain_unregister(&group->notifier, nb);
 498 }
 499 EXPORT_SYMBOL_GPL(iommu_group_unregister_notifier);
 500
 501 /**
 502  * iommu_group_id - Return ID for a group
 503  * @group: the group to ID
 504  *
 505  * Return the unique ID for the group matching the sysfs group number.
 506  */
 507 int iommu_group_id(struct iommu_group *group)
 508 {
 509         return group->id;
 510 }
 511 EXPORT_SYMBOL_GPL(iommu_group_id);
 512
 513 static int add_iommu_group(struct device *dev, void *data)
 514 {
 515         struct iommu_ops *ops = data;
 516
 517         if (!ops->add_device)
 518                 return -ENODEV;
 519
 520         WARN_ON(dev->iommu_group);
 521
 522         ops->add_device(dev);
 523
 524         return 0;
 525 }
 526
 527 static int iommu_bus_notifier(struct notifier_block *nb,
 528                               unsigned long action, void *data)
 529 {
 530         struct device *dev = data;
 531         struct iommu_ops *ops = dev->bus->iommu_ops;
 532         struct iommu_group *group;
 533         unsigned long group_action = 0;
 534
 535         /*
 536          * ADD/DEL call into iommu driver ops if provided, which may
 537          * result in ADD/DEL notifiers to group->notifier
 538          */
 539         if (action == BUS_NOTIFY_ADD_DEVICE) {
 540                 if (ops->add_device)
 541                         return ops->add_device(dev);
 542         } else if (action == BUS_NOTIFY_DEL_DEVICE) {
 543                 if (ops->remove_device && dev->iommu_group) {
 544                         ops->remove_device(dev);
 545                         return 0;
 546                 }
 547         }
 548
 549         /*
 550          * Remaining BUS_NOTIFYs get filtered and republished to the
 551          * group, if anyone is listening
 552          */
 553         group = iommu_group_get(dev);
 554         if (!group)
 555                 return 0;
 556
 557         switch (action) {
 558         case BUS_NOTIFY_BIND_DRIVER:
 559                 group_action = IOMMU_GROUP_NOTIFY_BIND_DRIVER;
 560                 break;
 561         case BUS_NOTIFY_BOUND_DRIVER:
 562                 group_action = IOMMU_GROUP_NOTIFY_BOUND_DRIVER;
 563                 break;
 564         case BUS_NOTIFY_UNBIND_DRIVER:
 565                 group_action = IOMMU_GROUP_NOTIFY_UNBIND_DRIVER;
 566                 break;
 567         case BUS_NOTIFY_UNBOUND_DRIVER:
 568                 group_action = IOMMU_GROUP_NOTIFY_UNBOUND_DRIVER;
 569                 break;
 570         }
 571
 572         if (group_action)
 573                 blocking_notifier_call_chain(&group->notifier,
 574                                              group_action, dev);
 575
 576         iommu_group_put(group);
 577         return 0;
 578 }
 579
 580 static struct notifier_block iommu_bus_nb = {
 581         .notifier_call = iommu_bus_notifier,
 582 };
 583
 584 static void iommu_bus_init(struct bus_type *bus, struct iommu_ops *ops)
 585 {
 586         bus_register_notifier(bus, &iommu_bus_nb);
 587         bus_for_each_dev(bus, NULL, ops, add_iommu_group);
 588 }
 589
 590 /**
 591  * bus_set_iommu - set iommu-callbacks for the bus
 592  * @bus: bus.
 593  * @ops: the callbacks provided by the iommu-driver
 594  *
 595  * This function is called by an iommu driver to set the iommu methods
 596  * used for a particular bus. Drivers for devices on that bus can use
 597  * the iommu-api after these ops are registered.
 598  * This special function is needed because IOMMUs are usually devices on
 599  * the bus itself, so the iommu drivers are not initialized when the bus
 600  * is set up. With this function the iommu-driver can set the iommu-ops
 601  * afterwards.
 602  */
 603 int bus_set_iommu(struct bus_type *bus, struct iommu_ops *ops)
 604 {
 605         if (bus->iommu_ops != NULL)
 606                 return -EBUSY;
 607
 608         bus->iommu_ops = ops;
 609
 610         /* Do IOMMU specific setup for this bus-type */
 611         iommu_bus_init(bus, ops);
 612
 613         return 0;
 614 }
 615 EXPORT_SYMBOL_GPL(bus_set_iommu);
 616
 617 bool iommu_present(struct bus_type *bus)
 618 {
 619         return bus->iommu_ops != NULL;
 620 }
 621 EXPORT_SYMBOL_GPL(iommu_present);
 622
 623 /**
 624  * iommu_set_fault_handler() - set a fault handler for an iommu domain
 625  * @domain: iommu domain
 626  * @handler: fault handler
 627  * @token: user data, will be passed back to the fault handler
 628  *
 629  * This function should be used by IOMMU users which want to be notified
 630  * whenever an IOMMU fault happens.
 631  *
 632  * The fault handler itself should return 0 on success, and an appropriate
 633  * error code otherwise.
 634  */
 635 void iommu_set_fault_handler(struct iommu_domain *domain,
 636                                         iommu_fault_handler_t handler,
 637                                         void *token)
 638 {
 639         BUG_ON(!domain);
 640
 641         domain->handler = handler;
 642         domain->handler_token = token;
 643 }
 644 EXPORT_SYMBOL_GPL(iommu_set_fault_handler);
 645
 646 struct iommu_domain *iommu_domain_alloc(struct bus_type *bus)
 647 {
 648         struct iommu_domain *domain;
 649         int ret;
 650
 651         if (bus == NULL || bus->iommu_ops == NULL)
 652                 return NULL;
 653
 654         domain = kzalloc(sizeof(*domain), GFP_KERNEL);
 655         if (!domain)
 656                 return NULL;
 657
 658         domain->ops = bus->iommu_ops;
 659
 660         ret = domain->ops->domain_init(domain);
 661         if (ret)
 662                 goto out_free;
 663
 664         return domain;
 665
 666 out_free:
 667         kfree(domain);
 668
 669         return NULL;
 670 }
 671 EXPORT_SYMBOL_GPL(iommu_domain_alloc);
 672
 673 void iommu_domain_free(struct iommu_domain *domain)
 674 {
 675         if (likely(domain->ops->domain_destroy != NULL))
 676                 domain->ops->domain_destroy(domain);
 677
 678         kfree(domain);
 679 }
 680 EXPORT_SYMBOL_GPL(iommu_domain_free);
 681
 682 int iommu_attach_device(struct iommu_domain *domain, struct device *dev)
 683 {
 684         if (unlikely(domain->ops->attach_dev == NULL))
 685                 return -ENODEV;
 686
 687         return domain->ops->attach_dev(domain, dev);
 688 }
 689 EXPORT_SYMBOL_GPL(iommu_attach_device);
 690
 691 void iommu_detach_device(struct iommu_domain *domain, struct device *dev)
 692 {
 693         if (unlikely(domain->ops->detach_dev == NULL))
 694                 return;
 695
 696         domain->ops->detach_dev(domain, dev);
 697 }
 698 EXPORT_SYMBOL_GPL(iommu_detach_device);
 699
 700 /*
 701  * IOMMU groups are really the natrual working unit of the IOMMU, but
 702  * the IOMMU API works on domains and devices.  Bridge that gap by
 703  * iterating over the devices in a group.  Ideally we'd have a single
 704  * device which represents the requestor ID of the group, but we also
 705  * allow IOMMU drivers to create policy defined minimum sets, where
 706  * the physical hardware may be able to distiguish members, but we
 707  * wish to group them at a higher level (ex. untrusted multi-function
 708  * PCI devices).  Thus we attach each device.
 709  */
 710 static int iommu_group_do_attach_device(struct device *dev, void *data)
 711 {
 712         struct iommu_domain *domain = data;
 713
 714         return iommu_attach_device(domain, dev);
 715 }
 716
 717 int iommu_attach_group(struct iommu_domain *domain, struct iommu_group *group)
 718 {
 719         return iommu_group_for_each_dev(group, domain,
 720                                         iommu_group_do_attach_device);
 721 }
 722 EXPORT_SYMBOL_GPL(iommu_attach_group);
 723
 724 static int iommu_group_do_detach_device(struct device *dev, void *data)
 725 {
 726         struct iommu_domain *domain = data;
 727
 728         iommu_detach_device(domain, dev);
 729
 730         return 0;
 731 }
 732
 733 void iommu_detach_group(struct iommu_domain *domain, struct iommu_group *group)
 734 {
 735         iommu_group_for_each_dev(group, domain, iommu_group_do_detach_device);
 736 }
 737 EXPORT_SYMBOL_GPL(iommu_detach_group);
 738
 739 phys_addr_t iommu_iova_to_phys(struct iommu_domain *domain, dma_addr_t iova)
 740 {
 741         if (unlikely(domain->ops->iova_to_phys == NULL))
 742                 return 0;
 743
 744         return domain->ops->iova_to_phys(domain, iova);
 745 }
 746 EXPORT_SYMBOL_GPL(iommu_iova_to_phys);
 747
 748 int iommu_domain_has_cap(struct iommu_domain *domain,
 749                          unsigned long cap)
 750 {
 751         if (unlikely(domain->ops->domain_has_cap == NULL))
 752                 return 0;
 753
 754         return domain->ops->domain_has_cap(domain, cap);
 755 }
 756 EXPORT_SYMBOL_GPL(iommu_domain_has_cap);
 757
 758 static size_t iommu_pgsize(struct iommu_domain *domain,
 759                            unsigned long addr_merge, size_t size)
 760 {
 761         unsigned int pgsize_idx;
 762         size_t pgsize;
 763
 764         /* Max page size that still fits into 'size' */
 765         pgsize_idx = __fls(size);
 766
 767         /* need to consider alignment requirements ? */
 768         if (likely(addr_merge)) {
 769                 /* Max page size allowed by address */
 770                 unsigned int align_pgsize_idx = __ffs(addr_merge);
 771                 pgsize_idx = min(pgsize_idx, align_pgsize_idx);
 772         }
 773
 774         /* build a mask of acceptable page sizes */
 775         pgsize = (1UL << (pgsize_idx + 1)) - 1;
 776
 777         /* throw away page sizes not supported by the hardware */
 778         pgsize &= domain->ops->pgsize_bitmap;
 779
 780         /* make sure we're still sane */
 781         BUG_ON(!pgsize);
 782
 783         /* pick the biggest page */
 784         pgsize_idx = __fls(pgsize);
 785         pgsize = 1UL << pgsize_idx;
 786
 787         return pgsize;
 788 }
 789
 790 int iommu_map(struct iommu_domain *domain, unsigned long iova,
 791               phys_addr_t paddr, size_t size, int prot)
 792 {
 793         unsigned long orig_iova = iova;
 794         unsigned int min_pagesz;
 795         size_t orig_size = size;
 796         int ret = 0;
 797
 798         if (unlikely(domain->ops->unmap == NULL ||
 799                      domain->ops->pgsize_bitmap == 0UL))
 800                 return -ENODEV;
 801
 802         /* find out the minimum page size supported */
 803         min_pagesz = 1 << __ffs(domain->ops->pgsize_bitmap);
 804
 805         /*
 806          * both the virtual address and the physical one, as well as
 807          * the size of the mapping, must be aligned (at least) to the
 808          * size of the smallest page supported by the hardware
 809          */
 810         if (!IS_ALIGNED(iova | paddr | size, min_pagesz)) {
 811                 pr_err("unaligned: iova 0x%lx pa 0x%pa size 0x%zx min_pagesz 0x%x\n",
 812                        iova, &paddr, size, min_pagesz);
 813                 return -EINVAL;
 814         }
 815
 816         pr_debug("map: iova 0x%lx pa 0x%pa size 0x%zx\n", iova, &paddr, size);
 817
 818         while (size) {
 819                 size_t pgsize = iommu_pgsize(domain, iova | paddr, size);
 820
 821                 pr_debug("mapping: iova 0x%lx pa 0x%pa pgsize 0x%zx\n",
 822                          iova, &paddr, pgsize);
 823
 824                 ret = domain->ops->map(domain, iova, paddr, pgsize, prot);
 825                 if (ret)
 826                         break;
 827
 828                 iova += pgsize;
 829                 paddr += pgsize;
 830                 size -= pgsize;
 831         }
 832
 833         /* unroll mapping in case something went wrong */
 834         if (ret)
 835                 iommu_unmap(domain, orig_iova, orig_size - size);
 836
 837         return ret;
 838 }
 839 EXPORT_SYMBOL_GPL(iommu_map);
 840
 841 size_t iommu_unmap(struct iommu_domain *domain, unsigned long iova, size_t size)
 842 {
 843         size_t unmapped_page, unmapped = 0;
 844         unsigned int min_pagesz;
 845
 846         if (unlikely(domain->ops->unmap == NULL ||
 847                      domain->ops->pgsize_bitmap == 0UL))
 848                 return -ENODEV;
 849
 850         /* find out the minimum page size supported */
 851         min_pagesz = 1 << __ffs(domain->ops->pgsize_bitmap);
 852
 853         /*
 854          * The virtual address, as well as the size of the mapping, must be
 855          * aligned (at least) to the size of the smallest page supported
 856          * by the hardware
 857          */
 858         if (!IS_ALIGNED(iova | size, min_pagesz)) {
 859                 pr_err("unaligned: iova 0x%lx size 0x%zx min_pagesz 0x%x\n",
 860                        iova, size, min_pagesz);
 861                 return -EINVAL;
 862         }
 863
 864         pr_debug("unmap this: iova 0x%lx size 0x%zx\n", iova, size);
 865
 866         /*
 867          * Keep iterating until we either unmap 'size' bytes (or more)
 868          * or we hit an area that isn't mapped.
 869          */
 870         while (unmapped < size) {
 871                 size_t pgsize = iommu_pgsize(domain, iova, size - unmapped);
 872
 873                 unmapped_page = domain->ops->unmap(domain, iova, pgsize);
 874                 if (!unmapped_page)
 875                         break;
 876
 877                 pr_debug("unmapped: iova 0x%lx size 0x%zx\n",
 878                          iova, unmapped_page);
 879
 880                 iova += unmapped_page;
 881                 unmapped += unmapped_page;
 882         }
 883
 884         return unmapped;
 885 }
 886 EXPORT_SYMBOL_GPL(iommu_unmap);
 887
 888
 889 int iommu_domain_window_enable(struct iommu_domain *domain, u32 wnd_nr,
 890                                phys_addr_t paddr, u64 size, int prot)
 891 {
 892         if (unlikely(domain->ops->domain_window_enable == NULL))
 893                 return -ENODEV;
 894
 895         return domain->ops->domain_window_enable(domain, wnd_nr, paddr, size,
 896                                                  prot);
 897 }
 898 EXPORT_SYMBOL_GPL(iommu_domain_window_enable);
 899
 900 void iommu_domain_window_disable(struct iommu_domain *domain, u32 wnd_nr)
 901 {
 902         if (unlikely(domain->ops->domain_window_disable == NULL))
 903                 return;
 904
 905         return domain->ops->domain_window_disable(domain, wnd_nr);
 906 }
 907 EXPORT_SYMBOL_GPL(iommu_domain_window_disable);
 908
 909 static int __init iommu_init(void)
 910 {
 911         iommu_group_kset = kset_create_and_add("iommu_groups",
 912                                                NULL, kernel_kobj);
 913         ida_init(&iommu_group_ida);
 914         mutex_init(&iommu_group_mutex);
 915
 916         BUG_ON(!iommu_group_kset);
 917
 918         return 0;
 919 }
 920 arch_initcall(iommu_init);
 921
 922 int iommu_domain_get_attr(struct iommu_domain *domain,
 923                           enum iommu_attr attr, void *data)
 924 {
 925         struct iommu_domain_geometry *geometry;
 926         bool *paging;
 927         int ret = 0;
 928         u32 *count;
 929
 930         switch (attr) {
 931         case DOMAIN_ATTR_GEOMETRY:
 932                 geometry  = data;
 933                 *geometry = domain->geometry;
 934
 935                 break;
 936         case DOMAIN_ATTR_PAGING:
 937                 paging  = data;
 938                 *paging = (domain->ops->pgsize_bitmap != 0UL);
 939                 break;
 940         case DOMAIN_ATTR_WINDOWS:
 941                 count = data;
 942
 943                 if (domain->ops->domain_get_windows != NULL)
 944                         *count = domain->ops->domain_get_windows(domain);
 945                 else
 946                         ret = -ENODEV;
 947
 948                 break;
 949         default:
 950                 if (!domain->ops->domain_get_attr)
 951                         return -EINVAL;
 952
 953                 ret = domain->ops->domain_get_attr(domain, attr, data);
 954         }
 955
 956         return ret;
 957 }
 958 EXPORT_SYMBOL_GPL(iommu_domain_get_attr);
 959
 960 int iommu_domain_set_attr(struct iommu_domain *domain,
 961                           enum iommu_attr attr, void *data)
 962 {
 963         int ret = 0;
 964         u32 *count;
 965
 966         switch (attr) {
 967         case DOMAIN_ATTR_WINDOWS:
 968                 count = data;
 969
 970                 if (domain->ops->domain_set_windows != NULL)
 971                         ret = domain->ops->domain_set_windows(domain, *count);
 972                 else
 973                         ret = -ENODEV;
 974
 975                 break;
 976         default:
 977                 if (domain->ops->domain_set_attr == NULL)
 978                         return -EINVAL;
 979
 980                 ret = domain->ops->domain_set_attr(domain, attr, data);
 981         }
 982
 983         return ret;
 984 }
 985 EXPORT_SYMBOL_GPL(iommu_domain_set_attr);