drivers/iommu/iommu.c

   1 /*
   2  * Copyright (C) 2007-2008 Advanced Micro Devices, Inc.
   3  * Author: Joerg Roedel <jroedel@suse.de>
   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)    "iommu: " fmt
  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 <linux/pci.h>
  33 #include <linux/bitops.h>
  34 #include <linux/property.h>
  35 #include <trace/events/iommu.h>
  36
  37 static struct kset *iommu_group_kset;
  38 static DEFINE_IDA(iommu_group_ida);
  39
  40 struct iommu_callback_data {
  41         const struct iommu_ops *ops;
  42 };
  43
  44 struct iommu_group {
  45         struct kobject kobj;
  46         struct kobject *devices_kobj;
  47         struct list_head devices;
  48         struct mutex mutex;
  49         struct blocking_notifier_head notifier;
  50         void *iommu_data;
  51         void (*iommu_data_release)(void *iommu_data);
  52         char *name;
  53         int id;
  54         struct iommu_domain *default_domain;
  55         struct iommu_domain *domain;
  56 };
  57
  58 struct iommu_device {
  59         struct list_head list;
  60         struct device *dev;
  61         char *name;
  62 };
  63
  64 struct iommu_group_attribute {
  65         struct attribute attr;
  66         ssize_t (*show)(struct iommu_group *group, char *buf);
  67         ssize_t (*store)(struct iommu_group *group,
  68                          const char *buf, size_t count);
  69 };
  70
  71 #define IOMMU_GROUP_ATTR(_name, _mode, _show, _store)           \
  72 struct iommu_group_attribute iommu_group_attr_##_name =         \
  73         __ATTR(_name, _mode, _show, _store)
  74
  75 #define to_iommu_group_attr(_attr)      \
  76         container_of(_attr, struct iommu_group_attribute, attr)
  77 #define to_iommu_group(_kobj)           \
  78         container_of(_kobj, struct iommu_group, kobj)
  79
  80 static struct iommu_domain *__iommu_domain_alloc(struct bus_type *bus,
  81                                                  unsigned type);
  82 static int __iommu_attach_device(struct iommu_domain *domain,
  83                                  struct device *dev);
  84 static int __iommu_attach_group(struct iommu_domain *domain,
  85                                 struct iommu_group *group);
  86 static void __iommu_detach_group(struct iommu_domain *domain,
  87                                  struct iommu_group *group);
  88
  89 static ssize_t iommu_group_attr_show(struct kobject *kobj,
  90                                      struct attribute *__attr, char *buf)
  91 {
  92         struct iommu_group_attribute *attr = to_iommu_group_attr(__attr);
  93         struct iommu_group *group = to_iommu_group(kobj);
  94         ssize_t ret = -EIO;
  95
  96         if (attr->show)
  97                 ret = attr->show(group, buf);
  98         return ret;
  99 }
 100
 101 static ssize_t iommu_group_attr_store(struct kobject *kobj,
 102                                       struct attribute *__attr,
 103                                       const char *buf, size_t count)
 104 {
 105         struct iommu_group_attribute *attr = to_iommu_group_attr(__attr);
 106         struct iommu_group *group = to_iommu_group(kobj);
 107         ssize_t ret = -EIO;
 108
 109         if (attr->store)
 110                 ret = attr->store(group, buf, count);
 111         return ret;
 112 }
 113
 114 static const struct sysfs_ops iommu_group_sysfs_ops = {
 115         .show = iommu_group_attr_show,
 116         .store = iommu_group_attr_store,
 117 };
 118
 119 static int iommu_group_create_file(struct iommu_group *group,
 120                                    struct iommu_group_attribute *attr)
 121 {
 122         return sysfs_create_file(&group->kobj, &attr->attr);
 123 }
 124
 125 static void iommu_group_remove_file(struct iommu_group *group,
 126                                     struct iommu_group_attribute *attr)
 127 {
 128         sysfs_remove_file(&group->kobj, &attr->attr);
 129 }
 130
 131 static ssize_t iommu_group_show_name(struct iommu_group *group, char *buf)
 132 {
 133         return sprintf(buf, "%s\n", group->name);
 134 }
 135
 136 static IOMMU_GROUP_ATTR(name, S_IRUGO, iommu_group_show_name, NULL);
 137
 138 static void iommu_group_release(struct kobject *kobj)
 139 {
 140         struct iommu_group *group = to_iommu_group(kobj);
 141
 142         pr_debug("Releasing group %d\n", group->id);
 143
 144         if (group->iommu_data_release)
 145                 group->iommu_data_release(group->iommu_data);
 146
 147         ida_simple_remove(&iommu_group_ida, group->id);
 148
 149         if (group->default_domain)
 150                 iommu_domain_free(group->default_domain);
 151
 152         kfree(group->name);
 153         kfree(group);
 154 }
 155
 156 static struct kobj_type iommu_group_ktype = {
 157         .sysfs_ops = &iommu_group_sysfs_ops,
 158         .release = iommu_group_release,
 159 };
 160
 161 /**
 162  * iommu_group_alloc - Allocate a new group
 163  * @name: Optional name to associate with group, visible in sysfs
 164  *
 165  * This function is called by an iommu driver to allocate a new iommu
 166  * group.  The iommu group represents the minimum granularity of the iommu.
 167  * Upon successful return, the caller holds a reference to the supplied
 168  * group in order to hold the group until devices are added.  Use
 169  * iommu_group_put() to release this extra reference count, allowing the
 170  * group to be automatically reclaimed once it has no devices or external
 171  * references.
 172  */
 173 struct iommu_group *iommu_group_alloc(void)
 174 {
 175         struct iommu_group *group;
 176         int ret;
 177
 178         group = kzalloc(sizeof(*group), GFP_KERNEL);
 179         if (!group)
 180                 return ERR_PTR(-ENOMEM);
 181
 182         group->kobj.kset = iommu_group_kset;
 183         mutex_init(&group->mutex);
 184         INIT_LIST_HEAD(&group->devices);
 185         BLOCKING_INIT_NOTIFIER_HEAD(&group->notifier);
 186
 187         ret = ida_simple_get(&iommu_group_ida, 0, 0, GFP_KERNEL);
 188         if (ret < 0) {
 189                 kfree(group);
 190                 return ERR_PTR(ret);
 191         }
 192         group->id = ret;
 193
 194         ret = kobject_init_and_add(&group->kobj, &iommu_group_ktype,
 195                                    NULL, "%d", group->id);
 196         if (ret) {
 197                 ida_simple_remove(&iommu_group_ida, group->id);
 198                 kfree(group);
 199                 return ERR_PTR(ret);
 200         }
 201
 202         group->devices_kobj = kobject_create_and_add("devices", &group->kobj);
 203         if (!group->devices_kobj) {
 204                 kobject_put(&group->kobj); /* triggers .release & free */
 205                 return ERR_PTR(-ENOMEM);
 206         }
 207
 208         /*
 209          * The devices_kobj holds a reference on the group kobject, so
 210          * as long as that exists so will the group.  We can therefore
 211          * use the devices_kobj for reference counting.
 212          */
 213         kobject_put(&group->kobj);
 214
 215         pr_debug("Allocated group %d\n", group->id);
 216
 217         return group;
 218 }
 219 EXPORT_SYMBOL_GPL(iommu_group_alloc);
 220
 221 struct iommu_group *iommu_group_get_by_id(int id)
 222 {
 223         struct kobject *group_kobj;
 224         struct iommu_group *group;
 225         const char *name;
 226
 227         if (!iommu_group_kset)
 228                 return NULL;
 229
 230         name = kasprintf(GFP_KERNEL, "%d", id);
 231         if (!name)
 232                 return NULL;
 233
 234         group_kobj = kset_find_obj(iommu_group_kset, name);
 235         kfree(name);
 236
 237         if (!group_kobj)
 238                 return NULL;
 239
 240         group = container_of(group_kobj, struct iommu_group, kobj);
 241         BUG_ON(group->id != id);
 242
 243         kobject_get(group->devices_kobj);
 244         kobject_put(&group->kobj);
 245
 246         return group;
 247 }
 248 EXPORT_SYMBOL_GPL(iommu_group_get_by_id);
 249
 250 /**
 251  * iommu_group_get_iommudata - retrieve iommu_data registered for a group
 252  * @group: the group
 253  *
 254  * iommu drivers can store data in the group for use when doing iommu
 255  * operations.  This function provides a way to retrieve it.  Caller
 256  * should hold a group reference.
 257  */
 258 void *iommu_group_get_iommudata(struct iommu_group *group)
 259 {
 260         return group->iommu_data;
 261 }
 262 EXPORT_SYMBOL_GPL(iommu_group_get_iommudata);
 263
 264 /**
 265  * iommu_group_set_iommudata - set iommu_data for a group
 266  * @group: the group
 267  * @iommu_data: new data
 268  * @release: release function for iommu_data
 269  *
 270  * iommu drivers can store data in the group for use when doing iommu
 271  * operations.  This function provides a way to set the data after
 272  * the group has been allocated.  Caller should hold a group reference.
 273  */
 274 void iommu_group_set_iommudata(struct iommu_group *group, void *iommu_data,
 275                                void (*release)(void *iommu_data))
 276 {
 277         group->iommu_data = iommu_data;
 278         group->iommu_data_release = release;
 279 }
 280 EXPORT_SYMBOL_GPL(iommu_group_set_iommudata);
 281
 282 /**
 283  * iommu_group_set_name - set name for a group
 284  * @group: the group
 285  * @name: name
 286  *
 287  * Allow iommu driver to set a name for a group.  When set it will
 288  * appear in a name attribute file under the group in sysfs.
 289  */
 290 int iommu_group_set_name(struct iommu_group *group, const char *name)
 291 {
 292         int ret;
 293
 294         if (group->name) {
 295                 iommu_group_remove_file(group, &iommu_group_attr_name);
 296                 kfree(group->name);
 297                 group->name = NULL;
 298                 if (!name)
 299                         return 0;
 300         }
 301
 302         group->name = kstrdup(name, GFP_KERNEL);
 303         if (!group->name)
 304                 return -ENOMEM;
 305
 306         ret = iommu_group_create_file(group, &iommu_group_attr_name);
 307         if (ret) {
 308                 kfree(group->name);
 309                 group->name = NULL;
 310                 return ret;
 311         }
 312
 313         return 0;
 314 }
 315 EXPORT_SYMBOL_GPL(iommu_group_set_name);
 316
 317 static int iommu_group_create_direct_mappings(struct iommu_group *group,
 318                                               struct device *dev)
 319 {
 320         struct iommu_domain *domain = group->default_domain;
 321         struct iommu_resv_region *entry;
 322         struct list_head mappings;
 323         unsigned long pg_size;
 324         int ret = 0;
 325
 326         if (!domain || domain->type != IOMMU_DOMAIN_DMA)
 327                 return 0;
 328
 329         BUG_ON(!domain->pgsize_bitmap);
 330
 331         pg_size = 1UL << __ffs(domain->pgsize_bitmap);
 332         INIT_LIST_HEAD(&mappings);
 333
 334         iommu_get_resv_regions(dev, &mappings);
 335
 336         /* We need to consider overlapping regions for different devices */
 337         list_for_each_entry(entry, &mappings, list) {
 338                 dma_addr_t start, end, addr;
 339
 340                 if (domain->ops->apply_resv_region)
 341                         domain->ops->apply_resv_region(dev, domain, entry);
 342
 343                 start = ALIGN(entry->start, pg_size);
 344                 end   = ALIGN(entry->start + entry->length, pg_size);
 345
 346                 if (entry->type != IOMMU_RESV_DIRECT)
 347                         continue;
 348
 349                 for (addr = start; addr < end; addr += pg_size) {
 350                         phys_addr_t phys_addr;
 351
 352                         phys_addr = iommu_iova_to_phys(domain, addr);
 353                         if (phys_addr)
 354                                 continue;
 355
 356                         ret = iommu_map(domain, addr, addr, pg_size, entry->prot);
 357                         if (ret)
 358                                 goto out;
 359                 }
 360
 361         }
 362
 363 out:
 364         iommu_put_resv_regions(dev, &mappings);
 365
 366         return ret;
 367 }
 368
 369 /**
 370  * iommu_group_add_device - add a device to an iommu group
 371  * @group: the group into which to add the device (reference should be held)
 372  * @dev: the device
 373  *
 374  * This function is called by an iommu driver to add a device into a
 375  * group.  Adding a device increments the group reference count.
 376  */
 377 int iommu_group_add_device(struct iommu_group *group, struct device *dev)
 378 {
 379         int ret, i = 0;
 380         struct iommu_device *device;
 381
 382         device = kzalloc(sizeof(*device), GFP_KERNEL);
 383         if (!device)
 384                 return -ENOMEM;
 385
 386         device->dev = dev;
 387
 388         ret = sysfs_create_link(&dev->kobj, &group->kobj, "iommu_group");
 389         if (ret) {
 390                 kfree(device);
 391                 return ret;
 392         }
 393
 394         device->name = kasprintf(GFP_KERNEL, "%s", kobject_name(&dev->kobj));
 395 rename:
 396         if (!device->name) {
 397                 sysfs_remove_link(&dev->kobj, "iommu_group");
 398                 kfree(device);
 399                 return -ENOMEM;
 400         }
 401
 402         ret = sysfs_create_link_nowarn(group->devices_kobj,
 403                                        &dev->kobj, device->name);
 404         if (ret) {
 405                 kfree(device->name);
 406                 if (ret == -EEXIST && i >= 0) {
 407                         /*
 408                          * Account for the slim chance of collision
 409                          * and append an instance to the name.
 410                          */
 411                         device->name = kasprintf(GFP_KERNEL, "%s.%d",
 412                                                  kobject_name(&dev->kobj), i++);
 413                         goto rename;
 414                 }
 415
 416                 sysfs_remove_link(&dev->kobj, "iommu_group");
 417                 kfree(device);
 418                 return ret;
 419         }
 420
 421         kobject_get(group->devices_kobj);
 422
 423         dev->iommu_group = group;
 424
 425         iommu_group_create_direct_mappings(group, dev);
 426
 427         mutex_lock(&group->mutex);
 428         list_add_tail(&device->list, &group->devices);
 429         if (group->domain)
 430                 __iommu_attach_device(group->domain, dev);
 431         mutex_unlock(&group->mutex);
 432
 433         /* Notify any listeners about change to group. */
 434         blocking_notifier_call_chain(&group->notifier,
 435                                      IOMMU_GROUP_NOTIFY_ADD_DEVICE, dev);
 436
 437         trace_add_device_to_group(group->id, dev);
 438
 439         pr_info("Adding device %s to group %d\n", dev_name(dev), group->id);
 440
 441         return 0;
 442 }
 443 EXPORT_SYMBOL_GPL(iommu_group_add_device);
 444
 445 /**
 446  * iommu_group_remove_device - remove a device from it's current group
 447  * @dev: device to be removed
 448  *
 449  * This function is called by an iommu driver to remove the device from
 450  * it's current group.  This decrements the iommu group reference count.
 451  */
 452 void iommu_group_remove_device(struct device *dev)
 453 {
 454         struct iommu_group *group = dev->iommu_group;
 455         struct iommu_device *tmp_device, *device = NULL;
 456
 457         pr_info("Removing device %s from group %d\n", dev_name(dev), group->id);
 458
 459         /* Pre-notify listeners that a device is being removed. */
 460         blocking_notifier_call_chain(&group->notifier,
 461                                      IOMMU_GROUP_NOTIFY_DEL_DEVICE, dev);
 462
 463         mutex_lock(&group->mutex);
 464         list_for_each_entry(tmp_device, &group->devices, list) {
 465                 if (tmp_device->dev == dev) {
 466                         device = tmp_device;
 467                         list_del(&device->list);
 468                         break;
 469                 }
 470         }
 471         mutex_unlock(&group->mutex);
 472
 473         if (!device)
 474                 return;
 475
 476         sysfs_remove_link(group->devices_kobj, device->name);
 477         sysfs_remove_link(&dev->kobj, "iommu_group");
 478
 479         trace_remove_device_from_group(group->id, dev);
 480
 481         kfree(device->name);
 482         kfree(device);
 483         dev->iommu_group = NULL;
 484         kobject_put(group->devices_kobj);
 485 }
 486 EXPORT_SYMBOL_GPL(iommu_group_remove_device);
 487
 488 static int iommu_group_device_count(struct iommu_group *group)
 489 {
 490         struct iommu_device *entry;
 491         int ret = 0;
 492
 493         list_for_each_entry(entry, &group->devices, list)
 494                 ret++;
 495
 496         return ret;
 497 }
 498
 499 /**
 500  * iommu_group_for_each_dev - iterate over each device in the group
 501  * @group: the group
 502  * @data: caller opaque data to be passed to callback function
 503  * @fn: caller supplied callback function
 504  *
 505  * This function is called by group users to iterate over group devices.
 506  * Callers should hold a reference count to the group during callback.
 507  * The group->mutex is held across callbacks, which will block calls to
 508  * iommu_group_add/remove_device.
 509  */
 510 static int __iommu_group_for_each_dev(struct iommu_group *group, void *data,
 511                                       int (*fn)(struct device *, void *))
 512 {
 513         struct iommu_device *device;
 514         int ret = 0;
 515
 516         list_for_each_entry(device, &group->devices, list) {
 517                 ret = fn(device->dev, data);
 518                 if (ret)
 519                         break;
 520         }
 521         return ret;
 522 }
 523
 524
 525 int iommu_group_for_each_dev(struct iommu_group *group, void *data,
 526                              int (*fn)(struct device *, void *))
 527 {
 528         int ret;
 529
 530         mutex_lock(&group->mutex);
 531         ret = __iommu_group_for_each_dev(group, data, fn);
 532         mutex_unlock(&group->mutex);
 533
 534         return ret;
 535 }
 536 EXPORT_SYMBOL_GPL(iommu_group_for_each_dev);
 537
 538 /**
 539  * iommu_group_get - Return the group for a device and increment reference
 540  * @dev: get the group that this device belongs to
 541  *
 542  * This function is called by iommu drivers and users to get the group
 543  * for the specified device.  If found, the group is returned and the group
 544  * reference in incremented, else NULL.
 545  */
 546 struct iommu_group *iommu_group_get(struct device *dev)
 547 {
 548         struct iommu_group *group = dev->iommu_group;
 549
 550         if (group)
 551                 kobject_get(group->devices_kobj);
 552
 553         return group;
 554 }
 555 EXPORT_SYMBOL_GPL(iommu_group_get);
 556
 557 /**
 558  * iommu_group_ref_get - Increment reference on a group
 559  * @group: the group to use, must not be NULL
 560  *
 561  * This function is called by iommu drivers to take additional references on an
 562  * existing group.  Returns the given group for convenience.
 563  */
 564 struct iommu_group *iommu_group_ref_get(struct iommu_group *group)
 565 {
 566         kobject_get(group->devices_kobj);
 567         return group;
 568 }
 569
 570 /**
 571  * iommu_group_put - Decrement group reference
 572  * @group: the group to use
 573  *
 574  * This function is called by iommu drivers and users to release the
 575  * iommu group.  Once the reference count is zero, the group is released.
 576  */
 577 void iommu_group_put(struct iommu_group *group)
 578 {
 579         if (group)
 580                 kobject_put(group->devices_kobj);
 581 }
 582 EXPORT_SYMBOL_GPL(iommu_group_put);
 583
 584 /**
 585  * iommu_group_register_notifier - Register a notifier for group changes
 586  * @group: the group to watch
 587  * @nb: notifier block to signal
 588  *
 589  * This function allows iommu group users to track changes in a group.
 590  * See include/linux/iommu.h for actions sent via this notifier.  Caller
 591  * should hold a reference to the group throughout notifier registration.
 592  */
 593 int iommu_group_register_notifier(struct iommu_group *group,
 594                                   struct notifier_block *nb)
 595 {
 596         return blocking_notifier_chain_register(&group->notifier, nb);
 597 }
 598 EXPORT_SYMBOL_GPL(iommu_group_register_notifier);
 599
 600 /**
 601  * iommu_group_unregister_notifier - Unregister a notifier
 602  * @group: the group to watch
 603  * @nb: notifier block to signal
 604  *
 605  * Unregister a previously registered group notifier block.
 606  */
 607 int iommu_group_unregister_notifier(struct iommu_group *group,
 608                                     struct notifier_block *nb)
 609 {
 610         return blocking_notifier_chain_unregister(&group->notifier, nb);
 611 }
 612 EXPORT_SYMBOL_GPL(iommu_group_unregister_notifier);
 613
 614 /**
 615  * iommu_group_id - Return ID for a group
 616  * @group: the group to ID
 617  *
 618  * Return the unique ID for the group matching the sysfs group number.
 619  */
 620 int iommu_group_id(struct iommu_group *group)
 621 {
 622         return group->id;
 623 }
 624 EXPORT_SYMBOL_GPL(iommu_group_id);
 625
 626 static struct iommu_group *get_pci_alias_group(struct pci_dev *pdev,
 627                                                unsigned long *devfns);
 628
 629 /*
 630  * To consider a PCI device isolated, we require ACS to support Source
 631  * Validation, Request Redirection, Completer Redirection, and Upstream
 632  * Forwarding.  This effectively means that devices cannot spoof their
 633  * requester ID, requests and completions cannot be redirected, and all
 634  * transactions are forwarded upstream, even as it passes through a
 635  * bridge where the target device is downstream.
 636  */
 637 #define REQ_ACS_FLAGS   (PCI_ACS_SV | PCI_ACS_RR | PCI_ACS_CR | PCI_ACS_UF)
 638
 639 /*
 640  * For multifunction devices which are not isolated from each other, find
 641  * all the other non-isolated functions and look for existing groups.  For
 642  * each function, we also need to look for aliases to or from other devices
 643  * that may already have a group.
 644  */
 645 static struct iommu_group *get_pci_function_alias_group(struct pci_dev *pdev,
 646                                                         unsigned long *devfns)
 647 {
 648         struct pci_dev *tmp = NULL;
 649         struct iommu_group *group;
 650
 651         if (!pdev->multifunction || pci_acs_enabled(pdev, REQ_ACS_FLAGS))
 652                 return NULL;
 653
 654         for_each_pci_dev(tmp) {
 655                 if (tmp == pdev || tmp->bus != pdev->bus ||
 656                     PCI_SLOT(tmp->devfn) != PCI_SLOT(pdev->devfn) ||
 657                     pci_acs_enabled(tmp, REQ_ACS_FLAGS))
 658                         continue;
 659
 660                 group = get_pci_alias_group(tmp, devfns);
 661                 if (group) {
 662                         pci_dev_put(tmp);
 663                         return group;
 664                 }
 665         }
 666
 667         return NULL;
 668 }
 669
 670 /*
 671  * Look for aliases to or from the given device for existing groups. DMA
 672  * aliases are only supported on the same bus, therefore the search
 673  * space is quite small (especially since we're really only looking at pcie
 674  * device, and therefore only expect multiple slots on the root complex or
 675  * downstream switch ports).  It's conceivable though that a pair of
 676  * multifunction devices could have aliases between them that would cause a
 677  * loop.  To prevent this, we use a bitmap to track where we've been.
 678  */
 679 static struct iommu_group *get_pci_alias_group(struct pci_dev *pdev,
 680                                                unsigned long *devfns)
 681 {
 682         struct pci_dev *tmp = NULL;
 683         struct iommu_group *group;
 684
 685         if (test_and_set_bit(pdev->devfn & 0xff, devfns))
 686                 return NULL;
 687
 688         group = iommu_group_get(&pdev->dev);
 689         if (group)
 690                 return group;
 691
 692         for_each_pci_dev(tmp) {
 693                 if (tmp == pdev || tmp->bus != pdev->bus)
 694                         continue;
 695
 696                 /* We alias them or they alias us */
 697                 if (pci_devs_are_dma_aliases(pdev, tmp)) {
 698                         group = get_pci_alias_group(tmp, devfns);
 699                         if (group) {
 700                                 pci_dev_put(tmp);
 701                                 return group;
 702                         }
 703
 704                         group = get_pci_function_alias_group(tmp, devfns);
 705                         if (group) {
 706                                 pci_dev_put(tmp);
 707                                 return group;
 708                         }
 709                 }
 710         }
 711
 712         return NULL;
 713 }
 714
 715 struct group_for_pci_data {
 716         struct pci_dev *pdev;
 717         struct iommu_group *group;
 718 };
 719
 720 /*
 721  * DMA alias iterator callback, return the last seen device.  Stop and return
 722  * the IOMMU group if we find one along the way.
 723  */
 724 static int get_pci_alias_or_group(struct pci_dev *pdev, u16 alias, void *opaque)
 725 {
 726         struct group_for_pci_data *data = opaque;
 727
 728         data->pdev = pdev;
 729         data->group = iommu_group_get(&pdev->dev);
 730
 731         return data->group != NULL;
 732 }
 733
 734 /*
 735  * Generic device_group call-back function. It just allocates one
 736  * iommu-group per device.
 737  */
 738 struct iommu_group *generic_device_group(struct device *dev)
 739 {
 740         struct iommu_group *group;
 741
 742         group = iommu_group_alloc();
 743         if (IS_ERR(group))
 744                 return NULL;
 745
 746         return group;
 747 }
 748
 749 /*
 750  * Use standard PCI bus topology, isolation features, and DMA alias quirks
 751  * to find or create an IOMMU group for a device.
 752  */
 753 struct iommu_group *pci_device_group(struct device *dev)
 754 {
 755         struct pci_dev *pdev = to_pci_dev(dev);
 756         struct group_for_pci_data data;
 757         struct pci_bus *bus;
 758         struct iommu_group *group = NULL;
 759         u64 devfns[4] = { 0 };
 760
 761         if (WARN_ON(!dev_is_pci(dev)))
 762                 return ERR_PTR(-EINVAL);
 763
 764         /*
 765          * Find the upstream DMA alias for the device.  A device must not
 766          * be aliased due to topology in order to have its own IOMMU group.
 767          * If we find an alias along the way that already belongs to a
 768          * group, use it.
 769          */
 770         if (pci_for_each_dma_alias(pdev, get_pci_alias_or_group, &data))
 771                 return data.group;
 772
 773         pdev = data.pdev;
 774
 775         /*
 776          * Continue upstream from the point of minimum IOMMU granularity
 777          * due to aliases to the point where devices are protected from
 778          * peer-to-peer DMA by PCI ACS.  Again, if we find an existing
 779          * group, use it.
 780          */
 781         for (bus = pdev->bus; !pci_is_root_bus(bus); bus = bus->parent) {
 782                 if (!bus->self)
 783                         continue;
 784
 785                 if (pci_acs_path_enabled(bus->self, NULL, REQ_ACS_FLAGS))
 786                         break;
 787
 788                 pdev = bus->self;
 789
 790                 group = iommu_group_get(&pdev->dev);
 791                 if (group)
 792                         return group;
 793         }
 794
 795         /*
 796          * Look for existing groups on device aliases.  If we alias another
 797          * device or another device aliases us, use the same group.
 798          */
 799         group = get_pci_alias_group(pdev, (unsigned long *)devfns);
 800         if (group)
 801                 return group;
 802
 803         /*
 804          * Look for existing groups on non-isolated functions on the same
 805          * slot and aliases of those funcions, if any.  No need to clear
 806          * the search bitmap, the tested devfns are still valid.
 807          */
 808         group = get_pci_function_alias_group(pdev, (unsigned long *)devfns);
 809         if (group)
 810                 return group;
 811
 812         /* No shared group found, allocate new */
 813         group = iommu_group_alloc();
 814         if (IS_ERR(group))
 815                 return NULL;
 816
 817         return group;
 818 }
 819
 820 /**
 821  * iommu_group_get_for_dev - Find or create the IOMMU group for a device
 822  * @dev: target device
 823  *
 824  * This function is intended to be called by IOMMU drivers and extended to
 825  * support common, bus-defined algorithms when determining or creating the
 826  * IOMMU group for a device.  On success, the caller will hold a reference
 827  * to the returned IOMMU group, which will already include the provided
 828  * device.  The reference should be released with iommu_group_put().
 829  */
 830 struct iommu_group *iommu_group_get_for_dev(struct device *dev)
 831 {
 832         const struct iommu_ops *ops = dev->bus->iommu_ops;
 833         struct iommu_group *group;
 834         int ret;
 835
 836         group = iommu_group_get(dev);
 837         if (group)
 838                 return group;
 839
 840         group = ERR_PTR(-EINVAL);
 841
 842         if (ops && ops->device_group)
 843                 group = ops->device_group(dev);
 844
 845         if (IS_ERR(group))
 846                 return group;
 847
 848         /*
 849          * Try to allocate a default domain - needs support from the
 850          * IOMMU driver.
 851          */
 852         if (!group->default_domain) {
 853                 group->default_domain = __iommu_domain_alloc(dev->bus,
 854                                                              IOMMU_DOMAIN_DMA);
 855                 if (!group->domain)
 856                         group->domain = group->default_domain;
 857         }
 858
 859         ret = iommu_group_add_device(group, dev);
 860         if (ret) {
 861                 iommu_group_put(group);
 862                 return ERR_PTR(ret);
 863         }
 864
 865         return group;
 866 }
 867
 868 struct iommu_domain *iommu_group_default_domain(struct iommu_group *group)
 869 {
 870         return group->default_domain;
 871 }
 872
 873 static int add_iommu_group(struct device *dev, void *data)
 874 {
 875         struct iommu_callback_data *cb = data;
 876         const struct iommu_ops *ops = cb->ops;
 877         int ret;
 878
 879         if (!ops->add_device)
 880                 return 0;
 881
 882         WARN_ON(dev->iommu_group);
 883
 884         ret = ops->add_device(dev);
 885
 886         /*
 887          * We ignore -ENODEV errors for now, as they just mean that the
 888          * device is not translated by an IOMMU. We still care about
 889          * other errors and fail to initialize when they happen.
 890          */
 891         if (ret == -ENODEV)
 892                 ret = 0;
 893
 894         return ret;
 895 }
 896
 897 static int remove_iommu_group(struct device *dev, void *data)
 898 {
 899         struct iommu_callback_data *cb = data;
 900         const struct iommu_ops *ops = cb->ops;
 901
 902         if (ops->remove_device && dev->iommu_group)
 903                 ops->remove_device(dev);
 904
 905         return 0;
 906 }
 907
 908 static int iommu_bus_notifier(struct notifier_block *nb,
 909                               unsigned long action, void *data)
 910 {
 911         struct device *dev = data;
 912         const struct iommu_ops *ops = dev->bus->iommu_ops;
 913         struct iommu_group *group;
 914         unsigned long group_action = 0;
 915
 916         /*
 917          * ADD/DEL call into iommu driver ops if provided, which may
 918          * result in ADD/DEL notifiers to group->notifier
 919          */
 920         if (action == BUS_NOTIFY_ADD_DEVICE) {
 921                 if (ops->add_device)
 922                         return ops->add_device(dev);
 923         } else if (action == BUS_NOTIFY_REMOVED_DEVICE) {
 924                 if (ops->remove_device && dev->iommu_group) {
 925                         ops->remove_device(dev);
 926                         return 0;
 927                 }
 928         }
 929
 930         /*
 931          * Remaining BUS_NOTIFYs get filtered and republished to the
 932          * group, if anyone is listening
 933          */
 934         group = iommu_group_get(dev);
 935         if (!group)
 936                 return 0;
 937
 938         switch (action) {
 939         case BUS_NOTIFY_BIND_DRIVER:
 940                 group_action = IOMMU_GROUP_NOTIFY_BIND_DRIVER;
 941                 break;
 942         case BUS_NOTIFY_BOUND_DRIVER:
 943                 group_action = IOMMU_GROUP_NOTIFY_BOUND_DRIVER;
 944                 break;
 945         case BUS_NOTIFY_UNBIND_DRIVER:
 946                 group_action = IOMMU_GROUP_NOTIFY_UNBIND_DRIVER;
 947                 break;
 948         case BUS_NOTIFY_UNBOUND_DRIVER:
 949                 group_action = IOMMU_GROUP_NOTIFY_UNBOUND_DRIVER;
 950                 break;
 951         }
 952
 953         if (group_action)
 954                 blocking_notifier_call_chain(&group->notifier,
 955                                              group_action, dev);
 956
 957         iommu_group_put(group);
 958         return 0;
 959 }
 960
 961 static int iommu_bus_init(struct bus_type *bus, const struct iommu_ops *ops)
 962 {
 963         int err;
 964         struct notifier_block *nb;
 965         struct iommu_callback_data cb = {
 966                 .ops = ops,
 967         };
 968
 969         nb = kzalloc(sizeof(struct notifier_block), GFP_KERNEL);
 970         if (!nb)
 971                 return -ENOMEM;
 972
 973         nb->notifier_call = iommu_bus_notifier;
 974
 975         err = bus_register_notifier(bus, nb);
 976         if (err)
 977                 goto out_free;
 978
 979         err = bus_for_each_dev(bus, NULL, &cb, add_iommu_group);
 980         if (err)
 981                 goto out_err;
 982
 983
 984         return 0;
 985
 986 out_err:
 987         /* Clean up */
 988         bus_for_each_dev(bus, NULL, &cb, remove_iommu_group);
 989         bus_unregister_notifier(bus, nb);
 990
 991 out_free:
 992         kfree(nb);
 993
 994         return err;
 995 }
 996
 997 /**
 998  * bus_set_iommu - set iommu-callbacks for the bus
 999  * @bus: bus.
1000  * @ops: the callbacks provided by the iommu-driver
1001  *
1002  * This function is called by an iommu driver to set the iommu methods
1003  * used for a particular bus. Drivers for devices on that bus can use
1004  * the iommu-api after these ops are registered.
1005  * This special function is needed because IOMMUs are usually devices on
1006  * the bus itself, so the iommu drivers are not initialized when the bus
1007  * is set up. With this function the iommu-driver can set the iommu-ops
1008  * afterwards.
1009  */
1010 int bus_set_iommu(struct bus_type *bus, const struct iommu_ops *ops)
1011 {
1012         int err;
1013
1014         if (bus->iommu_ops != NULL)
1015                 return -EBUSY;
1016
1017         bus->iommu_ops = ops;
1018
1019         /* Do IOMMU specific setup for this bus-type */
1020         err = iommu_bus_init(bus, ops);
1021         if (err)
1022                 bus->iommu_ops = NULL;
1023
1024         return err;
1025 }
1026 EXPORT_SYMBOL_GPL(bus_set_iommu);
1027
1028 bool iommu_present(struct bus_type *bus)
1029 {
1030         return bus->iommu_ops != NULL;
1031 }
1032 EXPORT_SYMBOL_GPL(iommu_present);
1033
1034 bool iommu_capable(struct bus_type *bus, enum iommu_cap cap)
1035 {
1036         if (!bus->iommu_ops || !bus->iommu_ops->capable)
1037                 return false;
1038
1039         return bus->iommu_ops->capable(cap);
1040 }
1041 EXPORT_SYMBOL_GPL(iommu_capable);
1042
1043 /**
1044  * iommu_set_fault_handler() - set a fault handler for an iommu domain
1045  * @domain: iommu domain
1046  * @handler: fault handler
1047  * @token: user data, will be passed back to the fault handler
1048  *
1049  * This function should be used by IOMMU users which want to be notified
1050  * whenever an IOMMU fault happens.
1051  *
1052  * The fault handler itself should return 0 on success, and an appropriate
1053  * error code otherwise.
1054  */
1055 void iommu_set_fault_handler(struct iommu_domain *domain,
1056                                         iommu_fault_handler_t handler,
1057                                         void *token)
1058 {
1059         BUG_ON(!domain);
1060
1061         domain->handler = handler;
1062         domain->handler_token = token;
1063 }
1064 EXPORT_SYMBOL_GPL(iommu_set_fault_handler);
1065
1066 static struct iommu_domain *__iommu_domain_alloc(struct bus_type *bus,
1067                                                  unsigned type)
1068 {
1069         struct iommu_domain *domain;
1070
1071         if (bus == NULL || bus->iommu_ops == NULL)
1072                 return NULL;
1073
1074         domain = bus->iommu_ops->domain_alloc(type);
1075         if (!domain)
1076                 return NULL;
1077
1078         domain->ops  = bus->iommu_ops;
1079         domain->type = type;
1080         /* Assume all sizes by default; the driver may override this later */
1081         domain->pgsize_bitmap  = bus->iommu_ops->pgsize_bitmap;
1082
1083         return domain;
1084 }
1085
1086 struct iommu_domain *iommu_domain_alloc(struct bus_type *bus)
1087 {
1088         return __iommu_domain_alloc(bus, IOMMU_DOMAIN_UNMANAGED);
1089 }
1090 EXPORT_SYMBOL_GPL(iommu_domain_alloc);
1091
1092 void iommu_domain_free(struct iommu_domain *domain)
1093 {
1094         domain->ops->domain_free(domain);
1095 }
1096 EXPORT_SYMBOL_GPL(iommu_domain_free);
1097
1098 static int __iommu_attach_device(struct iommu_domain *domain,
1099                                  struct device *dev)
1100 {
1101         int ret;
1102         if (unlikely(domain->ops->attach_dev == NULL))
1103                 return -ENODEV;
1104
1105         ret = domain->ops->attach_dev(domain, dev);
1106         if (!ret)
1107                 trace_attach_device_to_domain(dev);
1108         return ret;
1109 }
1110
1111 int iommu_attach_device(struct iommu_domain *domain, struct device *dev)
1112 {
1113         struct iommu_group *group;
1114         int ret;
1115
1116         group = iommu_group_get(dev);
1117         /* FIXME: Remove this when groups a mandatory for iommu drivers */
1118         if (group == NULL)
1119                 return __iommu_attach_device(domain, dev);
1120
1121         /*
1122          * We have a group - lock it to make sure the device-count doesn't
1123          * change while we are attaching
1124          */
1125         mutex_lock(&group->mutex);
1126         ret = -EINVAL;
1127         if (iommu_group_device_count(group) != 1)
1128                 goto out_unlock;
1129
1130         ret = __iommu_attach_group(domain, group);
1131
1132 out_unlock:
1133         mutex_unlock(&group->mutex);
1134         iommu_group_put(group);
1135
1136         return ret;
1137 }
1138 EXPORT_SYMBOL_GPL(iommu_attach_device);
1139
1140 static void __iommu_detach_device(struct iommu_domain *domain,
1141                                   struct device *dev)
1142 {
1143         if (unlikely(domain->ops->detach_dev == NULL))
1144                 return;
1145
1146         domain->ops->detach_dev(domain, dev);
1147         trace_detach_device_from_domain(dev);
1148 }
1149
1150 void iommu_detach_device(struct iommu_domain *domain, struct device *dev)
1151 {
1152         struct iommu_group *group;
1153
1154         group = iommu_group_get(dev);
1155         /* FIXME: Remove this when groups a mandatory for iommu drivers */
1156         if (group == NULL)
1157                 return __iommu_detach_device(domain, dev);
1158
1159         mutex_lock(&group->mutex);
1160         if (iommu_group_device_count(group) != 1) {
1161                 WARN_ON(1);
1162                 goto out_unlock;
1163         }
1164
1165         __iommu_detach_group(domain, group);
1166
1167 out_unlock:
1168         mutex_unlock(&group->mutex);
1169         iommu_group_put(group);
1170 }
1171 EXPORT_SYMBOL_GPL(iommu_detach_device);
1172
1173 struct iommu_domain *iommu_get_domain_for_dev(struct device *dev)
1174 {
1175         struct iommu_domain *domain;
1176         struct iommu_group *group;
1177
1178         group = iommu_group_get(dev);
1179         /* FIXME: Remove this when groups a mandatory for iommu drivers */
1180         if (group == NULL)
1181                 return NULL;
1182
1183         domain = group->domain;
1184
1185         iommu_group_put(group);
1186
1187         return domain;
1188 }
1189 EXPORT_SYMBOL_GPL(iommu_get_domain_for_dev);
1190
1191 /*
1192  * IOMMU groups are really the natrual working unit of the IOMMU, but
1193  * the IOMMU API works on domains and devices.  Bridge that gap by
1194  * iterating over the devices in a group.  Ideally we'd have a single
1195  * device which represents the requestor ID of the group, but we also
1196  * allow IOMMU drivers to create policy defined minimum sets, where
1197  * the physical hardware may be able to distiguish members, but we
1198  * wish to group them at a higher level (ex. untrusted multi-function
1199  * PCI devices).  Thus we attach each device.
1200  */
1201 static int iommu_group_do_attach_device(struct device *dev, void *data)
1202 {
1203         struct iommu_domain *domain = data;
1204
1205         return __iommu_attach_device(domain, dev);
1206 }
1207
1208 static int __iommu_attach_group(struct iommu_domain *domain,
1209                                 struct iommu_group *group)
1210 {
1211         int ret;
1212
1213         if (group->default_domain && group->domain != group->default_domain)
1214                 return -EBUSY;
1215
1216         ret = __iommu_group_for_each_dev(group, domain,
1217                                          iommu_group_do_attach_device);
1218         if (ret == 0)
1219                 group->domain = domain;
1220
1221         return ret;
1222 }
1223
1224 int iommu_attach_group(struct iommu_domain *domain, struct iommu_group *group)
1225 {
1226         int ret;
1227
1228         mutex_lock(&group->mutex);
1229         ret = __iommu_attach_group(domain, group);
1230         mutex_unlock(&group->mutex);
1231
1232         return ret;
1233 }
1234 EXPORT_SYMBOL_GPL(iommu_attach_group);
1235
1236 static int iommu_group_do_detach_device(struct device *dev, void *data)
1237 {
1238         struct iommu_domain *domain = data;
1239
1240         __iommu_detach_device(domain, dev);
1241
1242         return 0;
1243 }
1244
1245 static void __iommu_detach_group(struct iommu_domain *domain,
1246                                  struct iommu_group *group)
1247 {
1248         int ret;
1249
1250         if (!group->default_domain) {
1251                 __iommu_group_for_each_dev(group, domain,
1252                                            iommu_group_do_detach_device);
1253                 group->domain = NULL;
1254                 return;
1255         }
1256
1257         if (group->domain == group->default_domain)
1258                 return;
1259
1260         /* Detach by re-attaching to the default domain */
1261         ret = __iommu_group_for_each_dev(group, group->default_domain,
1262                                          iommu_group_do_attach_device);
1263         if (ret != 0)
1264                 WARN_ON(1);
1265         else
1266                 group->domain = group->default_domain;
1267 }
1268
1269 void iommu_detach_group(struct iommu_domain *domain, struct iommu_group *group)
1270 {
1271         mutex_lock(&group->mutex);
1272         __iommu_detach_group(domain, group);
1273         mutex_unlock(&group->mutex);
1274 }
1275 EXPORT_SYMBOL_GPL(iommu_detach_group);
1276
1277 phys_addr_t iommu_iova_to_phys(struct iommu_domain *domain, dma_addr_t iova)
1278 {
1279         if (unlikely(domain->ops->iova_to_phys == NULL))
1280                 return 0;
1281
1282         return domain->ops->iova_to_phys(domain, iova);
1283 }
1284 EXPORT_SYMBOL_GPL(iommu_iova_to_phys);
1285
1286 static size_t iommu_pgsize(struct iommu_domain *domain,
1287                            unsigned long addr_merge, size_t size)
1288 {
1289         unsigned int pgsize_idx;
1290         size_t pgsize;
1291
1292         /* Max page size that still fits into 'size' */
1293         pgsize_idx = __fls(size);
1294
1295         /* need to consider alignment requirements ? */
1296         if (likely(addr_merge)) {
1297                 /* Max page size allowed by address */
1298                 unsigned int align_pgsize_idx = __ffs(addr_merge);
1299                 pgsize_idx = min(pgsize_idx, align_pgsize_idx);
1300         }
1301
1302         /* build a mask of acceptable page sizes */
1303         pgsize = (1UL << (pgsize_idx + 1)) - 1;
1304
1305         /* throw away page sizes not supported by the hardware */
1306         pgsize &= domain->pgsize_bitmap;
1307
1308         /* make sure we're still sane */
1309         BUG_ON(!pgsize);
1310
1311         /* pick the biggest page */
1312         pgsize_idx = __fls(pgsize);
1313         pgsize = 1UL << pgsize_idx;
1314
1315         return pgsize;
1316 }
1317
1318 int iommu_map(struct iommu_domain *domain, unsigned long iova,
1319               phys_addr_t paddr, size_t size, int prot)
1320 {
1321         unsigned long orig_iova = iova;
1322         unsigned int min_pagesz;
1323         size_t orig_size = size;
1324         phys_addr_t orig_paddr = paddr;
1325         int ret = 0;
1326
1327         if (unlikely(domain->ops->map == NULL ||
1328                      domain->pgsize_bitmap == 0UL))
1329                 return -ENODEV;
1330
1331         if (unlikely(!(domain->type & __IOMMU_DOMAIN_PAGING)))
1332                 return -EINVAL;
1333
1334         /* find out the minimum page size supported */
1335         min_pagesz = 1 << __ffs(domain->pgsize_bitmap);
1336
1337         /*
1338          * both the virtual address and the physical one, as well as
1339          * the size of the mapping, must be aligned (at least) to the
1340          * size of the smallest page supported by the hardware
1341          */
1342         if (!IS_ALIGNED(iova | paddr | size, min_pagesz)) {
1343                 pr_err("unaligned: iova 0x%lx pa %pa size 0x%zx min_pagesz 0x%x\n",
1344                        iova, &paddr, size, min_pagesz);
1345                 return -EINVAL;
1346         }
1347
1348         pr_debug("map: iova 0x%lx pa %pa size 0x%zx\n", iova, &paddr, size);
1349
1350         while (size) {
1351                 size_t pgsize = iommu_pgsize(domain, iova | paddr, size);
1352
1353                 pr_debug("mapping: iova 0x%lx pa %pa pgsize 0x%zx\n",
1354                          iova, &paddr, pgsize);
1355
1356                 ret = domain->ops->map(domain, iova, paddr, pgsize, prot);
1357                 if (ret)
1358                         break;
1359
1360                 iova += pgsize;
1361                 paddr += pgsize;
1362                 size -= pgsize;
1363         }
1364
1365         /* unroll mapping in case something went wrong */
1366         if (ret)
1367                 iommu_unmap(domain, orig_iova, orig_size - size);
1368         else
1369                 trace_map(orig_iova, orig_paddr, orig_size);
1370
1371         return ret;
1372 }
1373 EXPORT_SYMBOL_GPL(iommu_map);
1374
1375 size_t iommu_unmap(struct iommu_domain *domain, unsigned long iova, size_t size)
1376 {
1377         size_t unmapped_page, unmapped = 0;
1378         unsigned int min_pagesz;
1379         unsigned long orig_iova = iova;
1380
1381         if (unlikely(domain->ops->unmap == NULL ||
1382                      domain->pgsize_bitmap == 0UL))
1383                 return -ENODEV;
1384
1385         if (unlikely(!(domain->type & __IOMMU_DOMAIN_PAGING)))
1386                 return -EINVAL;
1387
1388         /* find out the minimum page size supported */
1389         min_pagesz = 1 << __ffs(domain->pgsize_bitmap);
1390
1391         /*
1392          * The virtual address, as well as the size of the mapping, must be
1393          * aligned (at least) to the size of the smallest page supported
1394          * by the hardware
1395          */
1396         if (!IS_ALIGNED(iova | size, min_pagesz)) {
1397                 pr_err("unaligned: iova 0x%lx size 0x%zx min_pagesz 0x%x\n",
1398                        iova, size, min_pagesz);
1399                 return -EINVAL;
1400         }
1401
1402         pr_debug("unmap this: iova 0x%lx size 0x%zx\n", iova, size);
1403
1404         /*
1405          * Keep iterating until we either unmap 'size' bytes (or more)
1406          * or we hit an area that isn't mapped.
1407          */
1408         while (unmapped < size) {
1409                 size_t pgsize = iommu_pgsize(domain, iova, size - unmapped);
1410
1411                 unmapped_page = domain->ops->unmap(domain, iova, pgsize);
1412                 if (!unmapped_page)
1413                         break;
1414
1415                 pr_debug("unmapped: iova 0x%lx size 0x%zx\n",
1416                          iova, unmapped_page);
1417
1418                 iova += unmapped_page;
1419                 unmapped += unmapped_page;
1420         }
1421
1422         trace_unmap(orig_iova, size, unmapped);
1423         return unmapped;
1424 }
1425 EXPORT_SYMBOL_GPL(iommu_unmap);
1426
1427 size_t default_iommu_map_sg(struct iommu_domain *domain, unsigned long iova,
1428                          struct scatterlist *sg, unsigned int nents, int prot)
1429 {
1430         struct scatterlist *s;
1431         size_t mapped = 0;
1432         unsigned int i, min_pagesz;
1433         int ret;
1434
1435         if (unlikely(domain->pgsize_bitmap == 0UL))
1436                 return 0;
1437
1438         min_pagesz = 1 << __ffs(domain->pgsize_bitmap);
1439
1440         for_each_sg(sg, s, nents, i) {
1441                 phys_addr_t phys = page_to_phys(sg_page(s)) + s->offset;
1442
1443                 /*
1444                  * We are mapping on IOMMU page boundaries, so offset within
1445                  * the page must be 0. However, the IOMMU may support pages
1446                  * smaller than PAGE_SIZE, so s->offset may still represent
1447                  * an offset of that boundary within the CPU page.
1448                  */
1449                 if (!IS_ALIGNED(s->offset, min_pagesz))
1450                         goto out_err;
1451
1452                 ret = iommu_map(domain, iova + mapped, phys, s->length, prot);
1453                 if (ret)
1454                         goto out_err;
1455
1456                 mapped += s->length;
1457         }
1458
1459         return mapped;
1460
1461 out_err:
1462         /* undo mappings already done */
1463         iommu_unmap(domain, iova, mapped);
1464
1465         return 0;
1466
1467 }
1468 EXPORT_SYMBOL_GPL(default_iommu_map_sg);
1469
1470 int iommu_domain_window_enable(struct iommu_domain *domain, u32 wnd_nr,
1471                                phys_addr_t paddr, u64 size, int prot)
1472 {
1473         if (unlikely(domain->ops->domain_window_enable == NULL))
1474                 return -ENODEV;
1475
1476         return domain->ops->domain_window_enable(domain, wnd_nr, paddr, size,
1477                                                  prot);
1478 }
1479 EXPORT_SYMBOL_GPL(iommu_domain_window_enable);
1480
1481 void iommu_domain_window_disable(struct iommu_domain *domain, u32 wnd_nr)
1482 {
1483         if (unlikely(domain->ops->domain_window_disable == NULL))
1484                 return;
1485
1486         return domain->ops->domain_window_disable(domain, wnd_nr);
1487 }
1488 EXPORT_SYMBOL_GPL(iommu_domain_window_disable);
1489
1490 static int __init iommu_init(void)
1491 {
1492         iommu_group_kset = kset_create_and_add("iommu_groups",
1493                                                NULL, kernel_kobj);
1494         BUG_ON(!iommu_group_kset);
1495
1496         return 0;
1497 }
1498 core_initcall(iommu_init);
1499
1500 int iommu_domain_get_attr(struct iommu_domain *domain,
1501                           enum iommu_attr attr, void *data)
1502 {
1503         struct iommu_domain_geometry *geometry;
1504         bool *paging;
1505         int ret = 0;
1506         u32 *count;
1507
1508         switch (attr) {
1509         case DOMAIN_ATTR_GEOMETRY:
1510                 geometry  = data;
1511                 *geometry = domain->geometry;
1512
1513                 break;
1514         case DOMAIN_ATTR_PAGING:
1515                 paging  = data;
1516                 *paging = (domain->pgsize_bitmap != 0UL);
1517                 break;
1518         case DOMAIN_ATTR_WINDOWS:
1519                 count = data;
1520
1521                 if (domain->ops->domain_get_windows != NULL)
1522                         *count = domain->ops->domain_get_windows(domain);
1523                 else
1524                         ret = -ENODEV;
1525
1526                 break;
1527         default:
1528                 if (!domain->ops->domain_get_attr)
1529                         return -EINVAL;
1530
1531                 ret = domain->ops->domain_get_attr(domain, attr, data);
1532         }
1533
1534         return ret;
1535 }
1536 EXPORT_SYMBOL_GPL(iommu_domain_get_attr);
1537
1538 int iommu_domain_set_attr(struct iommu_domain *domain,
1539                           enum iommu_attr attr, void *data)
1540 {
1541         int ret = 0;
1542         u32 *count;
1543
1544         switch (attr) {
1545         case DOMAIN_ATTR_WINDOWS:
1546                 count = data;
1547
1548                 if (domain->ops->domain_set_windows != NULL)
1549                         ret = domain->ops->domain_set_windows(domain, *count);
1550                 else
1551                         ret = -ENODEV;
1552
1553                 break;
1554         default:
1555                 if (domain->ops->domain_set_attr == NULL)
1556                         return -EINVAL;
1557
1558                 ret = domain->ops->domain_set_attr(domain, attr, data);
1559         }
1560
1561         return ret;
1562 }
1563 EXPORT_SYMBOL_GPL(iommu_domain_set_attr);
1564
1565 void iommu_get_resv_regions(struct device *dev, struct list_head *list)
1566 {
1567         const struct iommu_ops *ops = dev->bus->iommu_ops;
1568
1569         if (ops && ops->get_resv_regions)
1570                 ops->get_resv_regions(dev, list);
1571 }
1572
1573 void iommu_put_resv_regions(struct device *dev, struct list_head *list)
1574 {
1575         const struct iommu_ops *ops = dev->bus->iommu_ops;
1576
1577         if (ops && ops->put_resv_regions)
1578                 ops->put_resv_regions(dev, list);
1579 }
1580
1581 struct iommu_resv_region *iommu_alloc_resv_region(phys_addr_t start,
1582                                                   size_t length,
1583                                                   int prot, int type)
1584 {
1585         struct iommu_resv_region *region;
1586
1587         region = kzalloc(sizeof(*region), GFP_KERNEL);
1588         if (!region)
1589                 return NULL;
1590
1591         INIT_LIST_HEAD(&region->list);
1592         region->start = start;
1593         region->length = length;
1594         region->prot = prot;
1595         region->type = type;
1596         return region;
1597 }
1598
1599 /* Request that a device is direct mapped by the IOMMU */
1600 int iommu_request_dm_for_dev(struct device *dev)
1601 {
1602         struct iommu_domain *dm_domain;
1603         struct iommu_group *group;
1604         int ret;
1605
1606         /* Device must already be in a group before calling this function */
1607         group = iommu_group_get_for_dev(dev);
1608         if (IS_ERR(group))
1609                 return PTR_ERR(group);
1610
1611         mutex_lock(&group->mutex);
1612
1613         /* Check if the default domain is already direct mapped */
1614         ret = 0;
1615         if (group->default_domain &&
1616             group->default_domain->type == IOMMU_DOMAIN_IDENTITY)
1617                 goto out;
1618
1619         /* Don't change mappings of existing devices */
1620         ret = -EBUSY;
1621         if (iommu_group_device_count(group) != 1)
1622                 goto out;
1623
1624         /* Allocate a direct mapped domain */
1625         ret = -ENOMEM;
1626         dm_domain = __iommu_domain_alloc(dev->bus, IOMMU_DOMAIN_IDENTITY);
1627         if (!dm_domain)
1628                 goto out;
1629
1630         /* Attach the device to the domain */
1631         ret = __iommu_attach_group(dm_domain, group);
1632         if (ret) {
1633                 iommu_domain_free(dm_domain);
1634                 goto out;
1635         }
1636
1637         /* Make the direct mapped domain the default for this group */
1638         if (group->default_domain)
1639                 iommu_domain_free(group->default_domain);
1640         group->default_domain = dm_domain;
1641
1642         pr_info("Using direct mapping for device %s\n", dev_name(dev));
1643
1644         ret = 0;
1645 out:
1646         mutex_unlock(&group->mutex);
1647         iommu_group_put(group);
1648
1649         return ret;
1650 }
1651
1652 struct iommu_instance {
1653         struct list_head list;
1654         struct fwnode_handle *fwnode;
1655         const struct iommu_ops *ops;
1656 };
1657 static LIST_HEAD(iommu_instance_list);
1658 static DEFINE_SPINLOCK(iommu_instance_lock);
1659
1660 void iommu_register_instance(struct fwnode_handle *fwnode,
1661                              const struct iommu_ops *ops)
1662 {
1663         struct iommu_instance *iommu = kzalloc(sizeof(*iommu), GFP_KERNEL);
1664
1665         if (WARN_ON(!iommu))
1666                 return;
1667
1668         of_node_get(to_of_node(fwnode));
1669         INIT_LIST_HEAD(&iommu->list);
1670         iommu->fwnode = fwnode;
1671         iommu->ops = ops;
1672         spin_lock(&iommu_instance_lock);
1673         list_add_tail(&iommu->list, &iommu_instance_list);
1674         spin_unlock(&iommu_instance_lock);
1675 }
1676
1677 const struct iommu_ops *iommu_get_instance(struct fwnode_handle *fwnode)
1678 {
1679         struct iommu_instance *instance;
1680         const struct iommu_ops *ops = NULL;
1681
1682         spin_lock(&iommu_instance_lock);
1683         list_for_each_entry(instance, &iommu_instance_list, list)
1684                 if (instance->fwnode == fwnode) {
1685                         ops = instance->ops;
1686                         break;
1687                 }
1688         spin_unlock(&iommu_instance_lock);
1689         return ops;
1690 }
1691
1692 int iommu_fwspec_init(struct device *dev, struct fwnode_handle *iommu_fwnode,
1693                       const struct iommu_ops *ops)
1694 {
1695         struct iommu_fwspec *fwspec = dev->iommu_fwspec;
1696
1697         if (fwspec)
1698                 return ops == fwspec->ops ? 0 : -EINVAL;
1699
1700         fwspec = kzalloc(sizeof(*fwspec), GFP_KERNEL);
1701         if (!fwspec)
1702                 return -ENOMEM;
1703
1704         of_node_get(to_of_node(iommu_fwnode));
1705         fwspec->iommu_fwnode = iommu_fwnode;
1706         fwspec->ops = ops;
1707         dev->iommu_fwspec = fwspec;
1708         return 0;
1709 }
1710 EXPORT_SYMBOL_GPL(iommu_fwspec_init);
1711
1712 void iommu_fwspec_free(struct device *dev)
1713 {
1714         struct iommu_fwspec *fwspec = dev->iommu_fwspec;
1715
1716         if (fwspec) {
1717                 fwnode_handle_put(fwspec->iommu_fwnode);
1718                 kfree(fwspec);
1719                 dev->iommu_fwspec = NULL;
1720         }
1721 }
1722 EXPORT_SYMBOL_GPL(iommu_fwspec_free);
1723
1724 int iommu_fwspec_add_ids(struct device *dev, u32 *ids, int num_ids)
1725 {
1726         struct iommu_fwspec *fwspec = dev->iommu_fwspec;
1727         size_t size;
1728         int i;
1729
1730         if (!fwspec)
1731                 return -EINVAL;
1732
1733         size = offsetof(struct iommu_fwspec, ids[fwspec->num_ids + num_ids]);
1734         if (size > sizeof(*fwspec)) {
1735                 fwspec = krealloc(dev->iommu_fwspec, size, GFP_KERNEL);
1736                 if (!fwspec)
1737                         return -ENOMEM;
1738         }
1739
1740         for (i = 0; i < num_ids; i++)
1741                 fwspec->ids[fwspec->num_ids + i] = ids[i];
1742
1743         fwspec->num_ids += num_ids;
1744         dev->iommu_fwspec = fwspec;
1745         return 0;
1746 }
1747 EXPORT_SYMBOL_GPL(iommu_fwspec_add_ids);