drivers/iommu/amd_iommu.c

   1 /*
   2  * Copyright (C) 2007-2010 Advanced Micro Devices, Inc.
   3  * Author: Joerg Roedel <joerg.roedel@amd.com>
   4  *         Leo Duran <leo.duran@amd.com>
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License version 2 as published
   8  * by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  18  */
  19
  20 #include <linux/ratelimit.h>
  21 #include <linux/pci.h>
  22 #include <linux/pci-ats.h>
  23 #include <linux/bitmap.h>
  24 #include <linux/slab.h>
  25 #include <linux/debugfs.h>
  26 #include <linux/scatterlist.h>
  27 #include <linux/dma-mapping.h>
  28 #include <linux/iommu-helper.h>
  29 #include <linux/iommu.h>
  30 #include <linux/delay.h>
  31 #include <linux/amd-iommu.h>
  32 #include <linux/notifier.h>
  33 #include <linux/export.h>
  34 #include <asm/msidef.h>
  35 #include <asm/proto.h>
  36 #include <asm/iommu.h>
  37 #include <asm/gart.h>
  38 #include <asm/dma.h>
  39
  40 #include "amd_iommu_proto.h"
  41 #include "amd_iommu_types.h"
  42
  43 #define CMD_SET_TYPE(cmd, t) ((cmd)->data[1] |= ((t) << 28))
  44
  45 #define LOOP_TIMEOUT    100000
  46
  47 /*
  48  * This bitmap is used to advertise the page sizes our hardware support
  49  * to the IOMMU core, which will then use this information to split
  50  * physically contiguous memory regions it is mapping into page sizes
  51  * that we support.
  52  *
  53  * Traditionally the IOMMU core just handed us the mappings directly,
  54  * after making sure the size is an order of a 4KiB page and that the
  55  * mapping has natural alignment.
  56  *
  57  * To retain this behavior, we currently advertise that we support
  58  * all page sizes that are an order of 4KiB.
  59  *
  60  * If at some point we'd like to utilize the IOMMU core's new behavior,
  61  * we could change this to advertise the real page sizes we support.
  62  */
  63 #define AMD_IOMMU_PGSIZES       (~0xFFFUL)
  64
  65 static DEFINE_RWLOCK(amd_iommu_devtable_lock);
  66
  67 /* A list of preallocated protection domains */
  68 static LIST_HEAD(iommu_pd_list);
  69 static DEFINE_SPINLOCK(iommu_pd_list_lock);
  70
  71 /* List of all available dev_data structures */
  72 static LIST_HEAD(dev_data_list);
  73 static DEFINE_SPINLOCK(dev_data_list_lock);
  74
  75 LIST_HEAD(ioapic_map);
  76 LIST_HEAD(hpet_map);
  77
  78 /*
  79  * Domain for untranslated devices - only allocated
  80  * if iommu=pt passed on kernel cmd line.
  81  */
  82 static struct protection_domain *pt_domain;
  83
  84 static struct iommu_ops amd_iommu_ops;
  85
  86 static ATOMIC_NOTIFIER_HEAD(ppr_notifier);
  87 int amd_iommu_max_glx_val = -1;
  88
  89 static struct dma_map_ops amd_iommu_dma_ops;
  90
  91 /*
  92  * general struct to manage commands send to an IOMMU
  93  */
  94 struct iommu_cmd {
  95         u32 data[4];
  96 };
  97
  98 struct kmem_cache *amd_iommu_irq_cache;
  99
 100 static void update_domain(struct protection_domain *domain);
 101 static int __init alloc_passthrough_domain(void);
 102
 103 /****************************************************************************
 104  *
 105  * Helper functions
 106  *
 107  ****************************************************************************/
 108
 109 static struct iommu_dev_data *alloc_dev_data(u16 devid)
 110 {
 111         struct iommu_dev_data *dev_data;
 112         unsigned long flags;
 113
 114         dev_data = kzalloc(sizeof(*dev_data), GFP_KERNEL);
 115         if (!dev_data)
 116                 return NULL;
 117
 118         dev_data->devid = devid;
 119         atomic_set(&dev_data->bind, 0);
 120
 121         spin_lock_irqsave(&dev_data_list_lock, flags);
 122         list_add_tail(&dev_data->dev_data_list, &dev_data_list);
 123         spin_unlock_irqrestore(&dev_data_list_lock, flags);
 124
 125         return dev_data;
 126 }
 127
 128 static void free_dev_data(struct iommu_dev_data *dev_data)
 129 {
 130         unsigned long flags;
 131
 132         spin_lock_irqsave(&dev_data_list_lock, flags);
 133         list_del(&dev_data->dev_data_list);
 134         spin_unlock_irqrestore(&dev_data_list_lock, flags);
 135
 136         kfree(dev_data);
 137 }
 138
 139 static struct iommu_dev_data *search_dev_data(u16 devid)
 140 {
 141         struct iommu_dev_data *dev_data;
 142         unsigned long flags;
 143
 144         spin_lock_irqsave(&dev_data_list_lock, flags);
 145         list_for_each_entry(dev_data, &dev_data_list, dev_data_list) {
 146                 if (dev_data->devid == devid)
 147                         goto out_unlock;
 148         }
 149
 150         dev_data = NULL;
 151
 152 out_unlock:
 153         spin_unlock_irqrestore(&dev_data_list_lock, flags);
 154
 155         return dev_data;
 156 }
 157
 158 static struct iommu_dev_data *find_dev_data(u16 devid)
 159 {
 160         struct iommu_dev_data *dev_data;
 161
 162         dev_data = search_dev_data(devid);
 163
 164         if (dev_data == NULL)
 165                 dev_data = alloc_dev_data(devid);
 166
 167         return dev_data;
 168 }
 169
 170 static inline u16 get_device_id(struct device *dev)
 171 {
 172         struct pci_dev *pdev = to_pci_dev(dev);
 173
 174         return calc_devid(pdev->bus->number, pdev->devfn);
 175 }
 176
 177 static struct iommu_dev_data *get_dev_data(struct device *dev)
 178 {
 179         return dev->archdata.iommu;
 180 }
 181
 182 static bool pci_iommuv2_capable(struct pci_dev *pdev)
 183 {
 184         static const int caps[] = {
 185                 PCI_EXT_CAP_ID_ATS,
 186                 PCI_EXT_CAP_ID_PRI,
 187                 PCI_EXT_CAP_ID_PASID,
 188         };
 189         int i, pos;
 190
 191         for (i = 0; i < 3; ++i) {
 192                 pos = pci_find_ext_capability(pdev, caps[i]);
 193                 if (pos == 0)
 194                         return false;
 195         }
 196
 197         return true;
 198 }
 199
 200 static bool pdev_pri_erratum(struct pci_dev *pdev, u32 erratum)
 201 {
 202         struct iommu_dev_data *dev_data;
 203
 204         dev_data = get_dev_data(&pdev->dev);
 205
 206         return dev_data->errata & (1 << erratum) ? true : false;
 207 }
 208
 209 /*
 210  * In this function the list of preallocated protection domains is traversed to
 211  * find the domain for a specific device
 212  */
 213 static struct dma_ops_domain *find_protection_domain(u16 devid)
 214 {
 215         struct dma_ops_domain *entry, *ret = NULL;
 216         unsigned long flags;
 217         u16 alias = amd_iommu_alias_table[devid];
 218
 219         if (list_empty(&iommu_pd_list))
 220                 return NULL;
 221
 222         spin_lock_irqsave(&iommu_pd_list_lock, flags);
 223
 224         list_for_each_entry(entry, &iommu_pd_list, list) {
 225                 if (entry->target_dev == devid ||
 226                     entry->target_dev == alias) {
 227                         ret = entry;
 228                         break;
 229                 }
 230         }
 231
 232         spin_unlock_irqrestore(&iommu_pd_list_lock, flags);
 233
 234         return ret;
 235 }
 236
 237 /*
 238  * This function checks if the driver got a valid device from the caller to
 239  * avoid dereferencing invalid pointers.
 240  */
 241 static bool check_device(struct device *dev)
 242 {
 243         u16 devid;
 244
 245         if (!dev || !dev->dma_mask)
 246                 return false;
 247
 248         /* No device or no PCI device */
 249         if (dev->bus != &pci_bus_type)
 250                 return false;
 251
 252         devid = get_device_id(dev);
 253
 254         /* Out of our scope? */
 255         if (devid > amd_iommu_last_bdf)
 256                 return false;
 257
 258         if (amd_iommu_rlookup_table[devid] == NULL)
 259                 return false;
 260
 261         return true;
 262 }
 263
 264 static void swap_pci_ref(struct pci_dev **from, struct pci_dev *to)
 265 {
 266         pci_dev_put(*from);
 267         *from = to;
 268 }
 269
 270 #define REQ_ACS_FLAGS   (PCI_ACS_SV | PCI_ACS_RR | PCI_ACS_CR | PCI_ACS_UF)
 271
 272 static int iommu_init_device(struct device *dev)
 273 {
 274         struct pci_dev *dma_pdev, *pdev = to_pci_dev(dev);
 275         struct iommu_dev_data *dev_data;
 276         struct iommu_group *group;
 277         u16 alias;
 278         int ret;
 279
 280         if (dev->archdata.iommu)
 281                 return 0;
 282
 283         dev_data = find_dev_data(get_device_id(dev));
 284         if (!dev_data)
 285                 return -ENOMEM;
 286
 287         alias = amd_iommu_alias_table[dev_data->devid];
 288         if (alias != dev_data->devid) {
 289                 struct iommu_dev_data *alias_data;
 290
 291                 alias_data = find_dev_data(alias);
 292                 if (alias_data == NULL) {
 293                         pr_err("AMD-Vi: Warning: Unhandled device %s\n",
 294                                         dev_name(dev));
 295                         free_dev_data(dev_data);
 296                         return -ENOTSUPP;
 297                 }
 298                 dev_data->alias_data = alias_data;
 299
 300                 dma_pdev = pci_get_bus_and_slot(alias >> 8, alias & 0xff);
 301         } else
 302                 dma_pdev = pci_dev_get(pdev);
 303
 304         /* Account for quirked devices */
 305         swap_pci_ref(&dma_pdev, pci_get_dma_source(dma_pdev));
 306
 307         /*
 308          * If it's a multifunction device that does not support our
 309          * required ACS flags, add to the same group as function 0.
 310          */
 311         if (dma_pdev->multifunction &&
 312             !pci_acs_enabled(dma_pdev, REQ_ACS_FLAGS))
 313                 swap_pci_ref(&dma_pdev,
 314                              pci_get_slot(dma_pdev->bus,
 315                                           PCI_DEVFN(PCI_SLOT(dma_pdev->devfn),
 316                                           0)));
 317
 318         /*
 319          * Devices on the root bus go through the iommu.  If that's not us,
 320          * find the next upstream device and test ACS up to the root bus.
 321          * Finding the next device may require skipping virtual buses.
 322          */
 323         while (!pci_is_root_bus(dma_pdev->bus)) {
 324                 struct pci_bus *bus = dma_pdev->bus;
 325
 326                 while (!bus->self) {
 327                         if (!pci_is_root_bus(bus))
 328                                 bus = bus->parent;
 329                         else
 330                                 goto root_bus;
 331                 }
 332
 333                 if (pci_acs_path_enabled(bus->self, NULL, REQ_ACS_FLAGS))
 334                         break;
 335
 336                 swap_pci_ref(&dma_pdev, pci_dev_get(bus->self));
 337         }
 338
 339 root_bus:
 340         group = iommu_group_get(&dma_pdev->dev);
 341         pci_dev_put(dma_pdev);
 342         if (!group) {
 343                 group = iommu_group_alloc();
 344                 if (IS_ERR(group))
 345                         return PTR_ERR(group);
 346         }
 347
 348         ret = iommu_group_add_device(group, dev);
 349
 350         iommu_group_put(group);
 351
 352         if (ret)
 353                 return ret;
 354
 355         if (pci_iommuv2_capable(pdev)) {
 356                 struct amd_iommu *iommu;
 357
 358                 iommu              = amd_iommu_rlookup_table[dev_data->devid];
 359                 dev_data->iommu_v2 = iommu->is_iommu_v2;
 360         }
 361
 362         dev->archdata.iommu = dev_data;
 363
 364         return 0;
 365 }
 366
 367 static void iommu_ignore_device(struct device *dev)
 368 {
 369         u16 devid, alias;
 370
 371         devid = get_device_id(dev);
 372         alias = amd_iommu_alias_table[devid];
 373
 374         memset(&amd_iommu_dev_table[devid], 0, sizeof(struct dev_table_entry));
 375         memset(&amd_iommu_dev_table[alias], 0, sizeof(struct dev_table_entry));
 376
 377         amd_iommu_rlookup_table[devid] = NULL;
 378         amd_iommu_rlookup_table[alias] = NULL;
 379 }
 380
 381 static void iommu_uninit_device(struct device *dev)
 382 {
 383         iommu_group_remove_device(dev);
 384
 385         /*
 386          * Nothing to do here - we keep dev_data around for unplugged devices
 387          * and reuse it when the device is re-plugged - not doing so would
 388          * introduce a ton of races.
 389          */
 390 }
 391
 392 void __init amd_iommu_uninit_devices(void)
 393 {
 394         struct iommu_dev_data *dev_data, *n;
 395         struct pci_dev *pdev = NULL;
 396
 397         for_each_pci_dev(pdev) {
 398
 399                 if (!check_device(&pdev->dev))
 400                         continue;
 401
 402                 iommu_uninit_device(&pdev->dev);
 403         }
 404
 405         /* Free all of our dev_data structures */
 406         list_for_each_entry_safe(dev_data, n, &dev_data_list, dev_data_list)
 407                 free_dev_data(dev_data);
 408 }
 409
 410 int __init amd_iommu_init_devices(void)
 411 {
 412         struct pci_dev *pdev = NULL;
 413         int ret = 0;
 414
 415         for_each_pci_dev(pdev) {
 416
 417                 if (!check_device(&pdev->dev))
 418                         continue;
 419
 420                 ret = iommu_init_device(&pdev->dev);
 421                 if (ret == -ENOTSUPP)
 422                         iommu_ignore_device(&pdev->dev);
 423                 else if (ret)
 424                         goto out_free;
 425         }
 426
 427         return 0;
 428
 429 out_free:
 430
 431         amd_iommu_uninit_devices();
 432
 433         return ret;
 434 }
 435 #ifdef CONFIG_AMD_IOMMU_STATS
 436
 437 /*
 438  * Initialization code for statistics collection
 439  */
 440
 441 DECLARE_STATS_COUNTER(compl_wait);
 442 DECLARE_STATS_COUNTER(cnt_map_single);
 443 DECLARE_STATS_COUNTER(cnt_unmap_single);
 444 DECLARE_STATS_COUNTER(cnt_map_sg);
 445 DECLARE_STATS_COUNTER(cnt_unmap_sg);
 446 DECLARE_STATS_COUNTER(cnt_alloc_coherent);
 447 DECLARE_STATS_COUNTER(cnt_free_coherent);
 448 DECLARE_STATS_COUNTER(cross_page);
 449 DECLARE_STATS_COUNTER(domain_flush_single);
 450 DECLARE_STATS_COUNTER(domain_flush_all);
 451 DECLARE_STATS_COUNTER(alloced_io_mem);
 452 DECLARE_STATS_COUNTER(total_map_requests);
 453 DECLARE_STATS_COUNTER(complete_ppr);
 454 DECLARE_STATS_COUNTER(invalidate_iotlb);
 455 DECLARE_STATS_COUNTER(invalidate_iotlb_all);
 456 DECLARE_STATS_COUNTER(pri_requests);
 457
 458 static struct dentry *stats_dir;
 459 static struct dentry *de_fflush;
 460
 461 static void amd_iommu_stats_add(struct __iommu_counter *cnt)
 462 {
 463         if (stats_dir == NULL)
 464                 return;
 465
 466         cnt->dent = debugfs_create_u64(cnt->name, 0444, stats_dir,
 467                                        &cnt->value);
 468 }
 469
 470 static void amd_iommu_stats_init(void)
 471 {
 472         stats_dir = debugfs_create_dir("amd-iommu", NULL);
 473         if (stats_dir == NULL)
 474                 return;
 475
 476         de_fflush  = debugfs_create_bool("fullflush", 0444, stats_dir,
 477                                          &amd_iommu_unmap_flush);
 478
 479         amd_iommu_stats_add(&compl_wait);
 480         amd_iommu_stats_add(&cnt_map_single);
 481         amd_iommu_stats_add(&cnt_unmap_single);
 482         amd_iommu_stats_add(&cnt_map_sg);
 483         amd_iommu_stats_add(&cnt_unmap_sg);
 484         amd_iommu_stats_add(&cnt_alloc_coherent);
 485         amd_iommu_stats_add(&cnt_free_coherent);
 486         amd_iommu_stats_add(&cross_page);
 487         amd_iommu_stats_add(&domain_flush_single);
 488         amd_iommu_stats_add(&domain_flush_all);
 489         amd_iommu_stats_add(&alloced_io_mem);
 490         amd_iommu_stats_add(&total_map_requests);
 491         amd_iommu_stats_add(&complete_ppr);
 492         amd_iommu_stats_add(&invalidate_iotlb);
 493         amd_iommu_stats_add(&invalidate_iotlb_all);
 494         amd_iommu_stats_add(&pri_requests);
 495 }
 496
 497 #endif
 498
 499 /****************************************************************************
 500  *
 501  * Interrupt handling functions
 502  *
 503  ****************************************************************************/
 504
 505 static void dump_dte_entry(u16 devid)
 506 {
 507         int i;
 508
 509         for (i = 0; i < 4; ++i)
 510                 pr_err("AMD-Vi: DTE[%d]: %016llx\n", i,
 511                         amd_iommu_dev_table[devid].data[i]);
 512 }
 513
 514 static void dump_command(unsigned long phys_addr)
 515 {
 516         struct iommu_cmd *cmd = phys_to_virt(phys_addr);
 517         int i;
 518
 519         for (i = 0; i < 4; ++i)
 520                 pr_err("AMD-Vi: CMD[%d]: %08x\n", i, cmd->data[i]);
 521 }
 522
 523 static void iommu_print_event(struct amd_iommu *iommu, void *__evt)
 524 {
 525         int type, devid, domid, flags;
 526         volatile u32 *event = __evt;
 527         int count = 0;
 528         u64 address;
 529
 530 retry:
 531         type    = (event[1] >> EVENT_TYPE_SHIFT)  & EVENT_TYPE_MASK;
 532         devid   = (event[0] >> EVENT_DEVID_SHIFT) & EVENT_DEVID_MASK;
 533         domid   = (event[1] >> EVENT_DOMID_SHIFT) & EVENT_DOMID_MASK;
 534         flags   = (event[1] >> EVENT_FLAGS_SHIFT) & EVENT_FLAGS_MASK;
 535         address = (u64)(((u64)event[3]) << 32) | event[2];
 536
 537         if (type == 0) {
 538                 /* Did we hit the erratum? */
 539                 if (++count == LOOP_TIMEOUT) {
 540                         pr_err("AMD-Vi: No event written to event log\n");
 541                         return;
 542                 }
 543                 udelay(1);
 544                 goto retry;
 545         }
 546
 547         printk(KERN_ERR "AMD-Vi: Event logged [");
 548
 549         switch (type) {
 550         case EVENT_TYPE_ILL_DEV:
 551                 printk("ILLEGAL_DEV_TABLE_ENTRY device=%02x:%02x.%x "
 552                        "address=0x%016llx flags=0x%04x]\n",
 553                        PCI_BUS(devid), PCI_SLOT(devid), PCI_FUNC(devid),
 554                        address, flags);
 555                 dump_dte_entry(devid);
 556                 break;
 557         case EVENT_TYPE_IO_FAULT:
 558                 printk("IO_PAGE_FAULT device=%02x:%02x.%x "
 559                        "domain=0x%04x address=0x%016llx flags=0x%04x]\n",
 560                        PCI_BUS(devid), PCI_SLOT(devid), PCI_FUNC(devid),
 561                        domid, address, flags);
 562                 break;
 563         case EVENT_TYPE_DEV_TAB_ERR:
 564                 printk("DEV_TAB_HARDWARE_ERROR device=%02x:%02x.%x "
 565                        "address=0x%016llx flags=0x%04x]\n",
 566                        PCI_BUS(devid), PCI_SLOT(devid), PCI_FUNC(devid),
 567                        address, flags);
 568                 break;
 569         case EVENT_TYPE_PAGE_TAB_ERR:
 570                 printk("PAGE_TAB_HARDWARE_ERROR device=%02x:%02x.%x "
 571                        "domain=0x%04x address=0x%016llx flags=0x%04x]\n",
 572                        PCI_BUS(devid), PCI_SLOT(devid), PCI_FUNC(devid),
 573                        domid, address, flags);
 574                 break;
 575         case EVENT_TYPE_ILL_CMD:
 576                 printk("ILLEGAL_COMMAND_ERROR address=0x%016llx]\n", address);
 577                 dump_command(address);
 578                 break;
 579         case EVENT_TYPE_CMD_HARD_ERR:
 580                 printk("COMMAND_HARDWARE_ERROR address=0x%016llx "
 581                        "flags=0x%04x]\n", address, flags);
 582                 break;
 583         case EVENT_TYPE_IOTLB_INV_TO:
 584                 printk("IOTLB_INV_TIMEOUT device=%02x:%02x.%x "
 585                        "address=0x%016llx]\n",
 586                        PCI_BUS(devid), PCI_SLOT(devid), PCI_FUNC(devid),
 587                        address);
 588                 break;
 589         case EVENT_TYPE_INV_DEV_REQ:
 590                 printk("INVALID_DEVICE_REQUEST device=%02x:%02x.%x "
 591                        "address=0x%016llx flags=0x%04x]\n",
 592                        PCI_BUS(devid), PCI_SLOT(devid), PCI_FUNC(devid),
 593                        address, flags);
 594                 break;
 595         default:
 596                 printk(KERN_ERR "UNKNOWN type=0x%02x]\n", type);
 597         }
 598
 599         memset(__evt, 0, 4 * sizeof(u32));
 600 }
 601
 602 static void iommu_poll_events(struct amd_iommu *iommu)
 603 {
 604         u32 head, tail;
 605         unsigned long flags;
 606
 607         spin_lock_irqsave(&iommu->lock, flags);
 608
 609         head = readl(iommu->mmio_base + MMIO_EVT_HEAD_OFFSET);
 610         tail = readl(iommu->mmio_base + MMIO_EVT_TAIL_OFFSET);
 611
 612         while (head != tail) {
 613                 iommu_print_event(iommu, iommu->evt_buf + head);
 614                 head = (head + EVENT_ENTRY_SIZE) % iommu->evt_buf_size;
 615         }
 616
 617         writel(head, iommu->mmio_base + MMIO_EVT_HEAD_OFFSET);
 618
 619         spin_unlock_irqrestore(&iommu->lock, flags);
 620 }
 621
 622 static void iommu_handle_ppr_entry(struct amd_iommu *iommu, u64 *raw)
 623 {
 624         struct amd_iommu_fault fault;
 625
 626         INC_STATS_COUNTER(pri_requests);
 627
 628         if (PPR_REQ_TYPE(raw[0]) != PPR_REQ_FAULT) {
 629                 pr_err_ratelimited("AMD-Vi: Unknown PPR request received\n");
 630                 return;
 631         }
 632
 633         fault.address   = raw[1];
 634         fault.pasid     = PPR_PASID(raw[0]);
 635         fault.device_id = PPR_DEVID(raw[0]);
 636         fault.tag       = PPR_TAG(raw[0]);
 637         fault.flags     = PPR_FLAGS(raw[0]);
 638
 639         atomic_notifier_call_chain(&ppr_notifier, 0, &fault);
 640 }
 641
 642 static void iommu_poll_ppr_log(struct amd_iommu *iommu)
 643 {
 644         unsigned long flags;
 645         u32 head, tail;
 646
 647         if (iommu->ppr_log == NULL)
 648                 return;
 649
 650         /* enable ppr interrupts again */
 651         writel(MMIO_STATUS_PPR_INT_MASK, iommu->mmio_base + MMIO_STATUS_OFFSET);
 652
 653         spin_lock_irqsave(&iommu->lock, flags);
 654
 655         head = readl(iommu->mmio_base + MMIO_PPR_HEAD_OFFSET);
 656         tail = readl(iommu->mmio_base + MMIO_PPR_TAIL_OFFSET);
 657
 658         while (head != tail) {
 659                 volatile u64 *raw;
 660                 u64 entry[2];
 661                 int i;
 662
 663                 raw = (u64 *)(iommu->ppr_log + head);
 664
 665                 /*
 666                  * Hardware bug: Interrupt may arrive before the entry is
 667                  * written to memory. If this happens we need to wait for the
 668                  * entry to arrive.
 669                  */
 670                 for (i = 0; i < LOOP_TIMEOUT; ++i) {
 671                         if (PPR_REQ_TYPE(raw[0]) != 0)
 672                                 break;
 673                         udelay(1);
 674                 }
 675
 676                 /* Avoid memcpy function-call overhead */
 677                 entry[0] = raw[0];
 678                 entry[1] = raw[1];
 679
 680                 /*
 681                  * To detect the hardware bug we need to clear the entry
 682                  * back to zero.
 683                  */
 684                 raw[0] = raw[1] = 0UL;
 685
 686                 /* Update head pointer of hardware ring-buffer */
 687                 head = (head + PPR_ENTRY_SIZE) % PPR_LOG_SIZE;
 688                 writel(head, iommu->mmio_base + MMIO_PPR_HEAD_OFFSET);
 689
 690                 /*
 691                  * Release iommu->lock because ppr-handling might need to
 692                  * re-aquire it
 693                  */
 694                 spin_unlock_irqrestore(&iommu->lock, flags);
 695
 696                 /* Handle PPR entry */
 697                 iommu_handle_ppr_entry(iommu, entry);
 698
 699                 spin_lock_irqsave(&iommu->lock, flags);
 700
 701                 /* Refresh ring-buffer information */
 702                 head = readl(iommu->mmio_base + MMIO_PPR_HEAD_OFFSET);
 703                 tail = readl(iommu->mmio_base + MMIO_PPR_TAIL_OFFSET);
 704         }
 705
 706         spin_unlock_irqrestore(&iommu->lock, flags);
 707 }
 708
 709 irqreturn_t amd_iommu_int_thread(int irq, void *data)
 710 {
 711         struct amd_iommu *iommu;
 712
 713         for_each_iommu(iommu) {
 714                 iommu_poll_events(iommu);
 715                 iommu_poll_ppr_log(iommu);
 716         }
 717
 718         return IRQ_HANDLED;
 719 }
 720
 721 irqreturn_t amd_iommu_int_handler(int irq, void *data)
 722 {
 723         return IRQ_WAKE_THREAD;
 724 }
 725
 726 /****************************************************************************
 727  *
 728  * IOMMU command queuing functions
 729  *
 730  ****************************************************************************/
 731
 732 static int wait_on_sem(volatile u64 *sem)
 733 {
 734         int i = 0;
 735
 736         while (*sem == 0 && i < LOOP_TIMEOUT) {
 737                 udelay(1);
 738                 i += 1;
 739         }
 740
 741         if (i == LOOP_TIMEOUT) {
 742                 pr_alert("AMD-Vi: Completion-Wait loop timed out\n");
 743                 return -EIO;
 744         }
 745
 746         return 0;
 747 }
 748
 749 static void copy_cmd_to_buffer(struct amd_iommu *iommu,
 750                                struct iommu_cmd *cmd,
 751                                u32 tail)
 752 {
 753         u8 *target;
 754
 755         target = iommu->cmd_buf + tail;
 756         tail   = (tail + sizeof(*cmd)) % iommu->cmd_buf_size;
 757
 758         /* Copy command to buffer */
 759         memcpy(target, cmd, sizeof(*cmd));
 760
 761         /* Tell the IOMMU about it */
 762         writel(tail, iommu->mmio_base + MMIO_CMD_TAIL_OFFSET);
 763 }
 764
 765 static void build_completion_wait(struct iommu_cmd *cmd, u64 address)
 766 {
 767         WARN_ON(address & 0x7ULL);
 768
 769         memset(cmd, 0, sizeof(*cmd));
 770         cmd->data[0] = lower_32_bits(__pa(address)) | CMD_COMPL_WAIT_STORE_MASK;
 771         cmd->data[1] = upper_32_bits(__pa(address));
 772         cmd->data[2] = 1;
 773         CMD_SET_TYPE(cmd, CMD_COMPL_WAIT);
 774 }
 775
 776 static void build_inv_dte(struct iommu_cmd *cmd, u16 devid)
 777 {
 778         memset(cmd, 0, sizeof(*cmd));
 779         cmd->data[0] = devid;
 780         CMD_SET_TYPE(cmd, CMD_INV_DEV_ENTRY);
 781 }
 782
 783 static void build_inv_iommu_pages(struct iommu_cmd *cmd, u64 address,
 784                                   size_t size, u16 domid, int pde)
 785 {
 786         u64 pages;
 787         int s;
 788
 789         pages = iommu_num_pages(address, size, PAGE_SIZE);
 790         s     = 0;
 791
 792         if (pages > 1) {
 793                 /*
 794                  * If we have to flush more than one page, flush all
 795                  * TLB entries for this domain
 796                  */
 797                 address = CMD_INV_IOMMU_ALL_PAGES_ADDRESS;
 798                 s = 1;
 799         }
 800
 801         address &= PAGE_MASK;
 802
 803         memset(cmd, 0, sizeof(*cmd));
 804         cmd->data[1] |= domid;
 805         cmd->data[2]  = lower_32_bits(address);
 806         cmd->data[3]  = upper_32_bits(address);
 807         CMD_SET_TYPE(cmd, CMD_INV_IOMMU_PAGES);
 808         if (s) /* size bit - we flush more than one 4kb page */
 809                 cmd->data[2] |= CMD_INV_IOMMU_PAGES_SIZE_MASK;
 810         if (pde) /* PDE bit - we wan't flush everything not only the PTEs */
 811                 cmd->data[2] |= CMD_INV_IOMMU_PAGES_PDE_MASK;
 812 }
 813
 814 static void build_inv_iotlb_pages(struct iommu_cmd *cmd, u16 devid, int qdep,
 815                                   u64 address, size_t size)
 816 {
 817         u64 pages;
 818         int s;
 819
 820         pages = iommu_num_pages(address, size, PAGE_SIZE);
 821         s     = 0;
 822
 823         if (pages > 1) {
 824                 /*
 825                  * If we have to flush more than one page, flush all
 826                  * TLB entries for this domain
 827                  */
 828                 address = CMD_INV_IOMMU_ALL_PAGES_ADDRESS;
 829                 s = 1;
 830         }
 831
 832         address &= PAGE_MASK;
 833
 834         memset(cmd, 0, sizeof(*cmd));
 835         cmd->data[0]  = devid;
 836         cmd->data[0] |= (qdep & 0xff) << 24;
 837         cmd->data[1]  = devid;
 838         cmd->data[2]  = lower_32_bits(address);
 839         cmd->data[3]  = upper_32_bits(address);
 840         CMD_SET_TYPE(cmd, CMD_INV_IOTLB_PAGES);
 841         if (s)
 842                 cmd->data[2] |= CMD_INV_IOMMU_PAGES_SIZE_MASK;
 843 }
 844
 845 static void build_inv_iommu_pasid(struct iommu_cmd *cmd, u16 domid, int pasid,
 846                                   u64 address, bool size)
 847 {
 848         memset(cmd, 0, sizeof(*cmd));
 849
 850         address &= ~(0xfffULL);
 851
 852         cmd->data[0]  = pasid & PASID_MASK;
 853         cmd->data[1]  = domid;
 854         cmd->data[2]  = lower_32_bits(address);
 855         cmd->data[3]  = upper_32_bits(address);
 856         cmd->data[2] |= CMD_INV_IOMMU_PAGES_PDE_MASK;
 857         cmd->data[2] |= CMD_INV_IOMMU_PAGES_GN_MASK;
 858         if (size)
 859                 cmd->data[2] |= CMD_INV_IOMMU_PAGES_SIZE_MASK;
 860         CMD_SET_TYPE(cmd, CMD_INV_IOMMU_PAGES);
 861 }
 862
 863 static void build_inv_iotlb_pasid(struct iommu_cmd *cmd, u16 devid, int pasid,
 864                                   int qdep, u64 address, bool size)
 865 {
 866         memset(cmd, 0, sizeof(*cmd));
 867
 868         address &= ~(0xfffULL);
 869
 870         cmd->data[0]  = devid;
 871         cmd->data[0] |= (pasid & 0xff) << 16;
 872         cmd->data[0] |= (qdep  & 0xff) << 24;
 873         cmd->data[1]  = devid;
 874         cmd->data[1] |= ((pasid >> 8) & 0xfff) << 16;
 875         cmd->data[2]  = lower_32_bits(address);
 876         cmd->data[2] |= CMD_INV_IOMMU_PAGES_GN_MASK;
 877         cmd->data[3]  = upper_32_bits(address);
 878         if (size)
 879                 cmd->data[2] |= CMD_INV_IOMMU_PAGES_SIZE_MASK;
 880         CMD_SET_TYPE(cmd, CMD_INV_IOTLB_PAGES);
 881 }
 882
 883 static void build_complete_ppr(struct iommu_cmd *cmd, u16 devid, int pasid,
 884                                int status, int tag, bool gn)
 885 {
 886         memset(cmd, 0, sizeof(*cmd));
 887
 888         cmd->data[0]  = devid;
 889         if (gn) {
 890                 cmd->data[1]  = pasid & PASID_MASK;
 891                 cmd->data[2]  = CMD_INV_IOMMU_PAGES_GN_MASK;
 892         }
 893         cmd->data[3]  = tag & 0x1ff;
 894         cmd->data[3] |= (status & PPR_STATUS_MASK) << PPR_STATUS_SHIFT;
 895
 896         CMD_SET_TYPE(cmd, CMD_COMPLETE_PPR);
 897 }
 898
 899 static void build_inv_all(struct iommu_cmd *cmd)
 900 {
 901         memset(cmd, 0, sizeof(*cmd));
 902         CMD_SET_TYPE(cmd, CMD_INV_ALL);
 903 }
 904
 905 /*
 906  * Writes the command to the IOMMUs command buffer and informs the
 907  * hardware about the new command.
 908  */
 909 static int iommu_queue_command_sync(struct amd_iommu *iommu,
 910                                     struct iommu_cmd *cmd,
 911                                     bool sync)
 912 {
 913         u32 left, tail, head, next_tail;
 914         unsigned long flags;
 915
 916         WARN_ON(iommu->cmd_buf_size & CMD_BUFFER_UNINITIALIZED);
 917
 918 again:
 919         spin_lock_irqsave(&iommu->lock, flags);
 920
 921         head      = readl(iommu->mmio_base + MMIO_CMD_HEAD_OFFSET);
 922         tail      = readl(iommu->mmio_base + MMIO_CMD_TAIL_OFFSET);
 923         next_tail = (tail + sizeof(*cmd)) % iommu->cmd_buf_size;
 924         left      = (head - next_tail) % iommu->cmd_buf_size;
 925
 926         if (left <= 2) {
 927                 struct iommu_cmd sync_cmd;
 928                 volatile u64 sem = 0;
 929                 int ret;
 930
 931                 build_completion_wait(&sync_cmd, (u64)&sem);
 932                 copy_cmd_to_buffer(iommu, &sync_cmd, tail);
 933
 934                 spin_unlock_irqrestore(&iommu->lock, flags);
 935
 936                 if ((ret = wait_on_sem(&sem)) != 0)
 937                         return ret;
 938
 939                 goto again;
 940         }
 941
 942         copy_cmd_to_buffer(iommu, cmd, tail);
 943
 944         /* We need to sync now to make sure all commands are processed */
 945         iommu->need_sync = sync;
 946
 947         spin_unlock_irqrestore(&iommu->lock, flags);
 948
 949         return 0;
 950 }
 951
 952 static int iommu_queue_command(struct amd_iommu *iommu, struct iommu_cmd *cmd)
 953 {
 954         return iommu_queue_command_sync(iommu, cmd, true);
 955 }
 956
 957 /*
 958  * This function queues a completion wait command into the command
 959  * buffer of an IOMMU
 960  */
 961 static int iommu_completion_wait(struct amd_iommu *iommu)
 962 {
 963         struct iommu_cmd cmd;
 964         volatile u64 sem = 0;
 965         int ret;
 966
 967         if (!iommu->need_sync)
 968                 return 0;
 969
 970         build_completion_wait(&cmd, (u64)&sem);
 971
 972         ret = iommu_queue_command_sync(iommu, &cmd, false);
 973         if (ret)
 974                 return ret;
 975
 976         return wait_on_sem(&sem);
 977 }
 978
 979 static int iommu_flush_dte(struct amd_iommu *iommu, u16 devid)
 980 {
 981         struct iommu_cmd cmd;
 982
 983         build_inv_dte(&cmd, devid);
 984
 985         return iommu_queue_command(iommu, &cmd);
 986 }
 987
 988 static void iommu_flush_dte_all(struct amd_iommu *iommu)
 989 {
 990         u32 devid;
 991
 992         for (devid = 0; devid <= 0xffff; ++devid)
 993                 iommu_flush_dte(iommu, devid);
 994
 995         iommu_completion_wait(iommu);
 996 }
 997
 998 /*
 999  * This function uses heavy locking and may disable irqs for some time. But
1000  * this is no issue because it is only called during resume.
1001  */
1002 static void iommu_flush_tlb_all(struct amd_iommu *iommu)
1003 {
1004         u32 dom_id;
1005
1006         for (dom_id = 0; dom_id <= 0xffff; ++dom_id) {
1007                 struct iommu_cmd cmd;
1008                 build_inv_iommu_pages(&cmd, 0, CMD_INV_IOMMU_ALL_PAGES_ADDRESS,
1009                                       dom_id, 1);
1010                 iommu_queue_command(iommu, &cmd);
1011         }
1012
1013         iommu_completion_wait(iommu);
1014 }
1015
1016 static void iommu_flush_all(struct amd_iommu *iommu)
1017 {
1018         struct iommu_cmd cmd;
1019
1020         build_inv_all(&cmd);
1021
1022         iommu_queue_command(iommu, &cmd);
1023         iommu_completion_wait(iommu);
1024 }
1025
1026 void iommu_flush_all_caches(struct amd_iommu *iommu)
1027 {
1028         if (iommu_feature(iommu, FEATURE_IA)) {
1029                 iommu_flush_all(iommu);
1030         } else {
1031                 iommu_flush_dte_all(iommu);
1032                 iommu_flush_tlb_all(iommu);
1033         }
1034 }
1035
1036 /*
1037  * Command send function for flushing on-device TLB
1038  */
1039 static int device_flush_iotlb(struct iommu_dev_data *dev_data,
1040                               u64 address, size_t size)
1041 {
1042         struct amd_iommu *iommu;
1043         struct iommu_cmd cmd;
1044         int qdep;
1045
1046         qdep     = dev_data->ats.qdep;
1047         iommu    = amd_iommu_rlookup_table[dev_data->devid];
1048
1049         build_inv_iotlb_pages(&cmd, dev_data->devid, qdep, address, size);
1050
1051         return iommu_queue_command(iommu, &cmd);
1052 }
1053
1054 /*
1055  * Command send function for invalidating a device table entry
1056  */
1057 static int device_flush_dte(struct iommu_dev_data *dev_data)
1058 {
1059         struct amd_iommu *iommu;
1060         int ret;
1061
1062         iommu = amd_iommu_rlookup_table[dev_data->devid];
1063
1064         ret = iommu_flush_dte(iommu, dev_data->devid);
1065         if (ret)
1066                 return ret;
1067
1068         if (dev_data->ats.enabled)
1069                 ret = device_flush_iotlb(dev_data, 0, ~0UL);
1070
1071         return ret;
1072 }
1073
1074 /*
1075  * TLB invalidation function which is called from the mapping functions.
1076  * It invalidates a single PTE if the range to flush is within a single
1077  * page. Otherwise it flushes the whole TLB of the IOMMU.
1078  */
1079 static void __domain_flush_pages(struct protection_domain *domain,
1080                                  u64 address, size_t size, int pde)
1081 {
1082         struct iommu_dev_data *dev_data;
1083         struct iommu_cmd cmd;
1084         int ret = 0, i;
1085
1086         build_inv_iommu_pages(&cmd, address, size, domain->id, pde);
1087
1088         for (i = 0; i < amd_iommus_present; ++i) {
1089                 if (!domain->dev_iommu[i])
1090                         continue;
1091
1092                 /*
1093                  * Devices of this domain are behind this IOMMU
1094                  * We need a TLB flush
1095                  */
1096                 ret |= iommu_queue_command(amd_iommus[i], &cmd);
1097         }
1098
1099         list_for_each_entry(dev_data, &domain->dev_list, list) {
1100
1101                 if (!dev_data->ats.enabled)
1102                         continue;
1103
1104                 ret |= device_flush_iotlb(dev_data, address, size);
1105         }
1106
1107         WARN_ON(ret);
1108 }
1109
1110 static void domain_flush_pages(struct protection_domain *domain,
1111                                u64 address, size_t size)
1112 {
1113         __domain_flush_pages(domain, address, size, 0);
1114 }
1115
1116 /* Flush the whole IO/TLB for a given protection domain */
1117 static void domain_flush_tlb(struct protection_domain *domain)
1118 {
1119         __domain_flush_pages(domain, 0, CMD_INV_IOMMU_ALL_PAGES_ADDRESS, 0);
1120 }
1121
1122 /* Flush the whole IO/TLB for a given protection domain - including PDE */
1123 static void domain_flush_tlb_pde(struct protection_domain *domain)
1124 {
1125         __domain_flush_pages(domain, 0, CMD_INV_IOMMU_ALL_PAGES_ADDRESS, 1);
1126 }
1127
1128 static void domain_flush_complete(struct protection_domain *domain)
1129 {
1130         int i;
1131
1132         for (i = 0; i < amd_iommus_present; ++i) {
1133                 if (!domain->dev_iommu[i])
1134                         continue;
1135
1136                 /*
1137                  * Devices of this domain are behind this IOMMU
1138                  * We need to wait for completion of all commands.
1139                  */
1140                 iommu_completion_wait(amd_iommus[i]);
1141         }
1142 }
1143
1144
1145 /*
1146  * This function flushes the DTEs for all devices in domain
1147  */
1148 static void domain_flush_devices(struct protection_domain *domain)
1149 {
1150         struct iommu_dev_data *dev_data;
1151
1152         list_for_each_entry(dev_data, &domain->dev_list, list)
1153                 device_flush_dte(dev_data);
1154 }
1155
1156 /****************************************************************************
1157  *
1158  * The functions below are used the create the page table mappings for
1159  * unity mapped regions.
1160  *
1161  ****************************************************************************/
1162
1163 /*
1164  * This function is used to add another level to an IO page table. Adding
1165  * another level increases the size of the address space by 9 bits to a size up
1166  * to 64 bits.
1167  */
1168 static bool increase_address_space(struct protection_domain *domain,
1169                                    gfp_t gfp)
1170 {
1171         u64 *pte;
1172
1173         if (domain->mode == PAGE_MODE_6_LEVEL)
1174                 /* address space already 64 bit large */
1175                 return false;
1176
1177         pte = (void *)get_zeroed_page(gfp);
1178         if (!pte)
1179                 return false;
1180
1181         *pte             = PM_LEVEL_PDE(domain->mode,
1182                                         virt_to_phys(domain->pt_root));
1183         domain->pt_root  = pte;
1184         domain->mode    += 1;
1185         domain->updated  = true;
1186
1187         return true;
1188 }
1189
1190 static u64 *alloc_pte(struct protection_domain *domain,
1191                       unsigned long address,
1192                       unsigned long page_size,
1193                       u64 **pte_page,
1194                       gfp_t gfp)
1195 {
1196         int level, end_lvl;
1197         u64 *pte, *page;
1198
1199         BUG_ON(!is_power_of_2(page_size));
1200
1201         while (address > PM_LEVEL_SIZE(domain->mode))
1202                 increase_address_space(domain, gfp);
1203
1204         level   = domain->mode - 1;
1205         pte     = &domain->pt_root[PM_LEVEL_INDEX(level, address)];
1206         address = PAGE_SIZE_ALIGN(address, page_size);
1207         end_lvl = PAGE_SIZE_LEVEL(page_size);
1208
1209         while (level > end_lvl) {
1210                 if (!IOMMU_PTE_PRESENT(*pte)) {
1211                         page = (u64 *)get_zeroed_page(gfp);
1212                         if (!page)
1213                                 return NULL;
1214                         *pte = PM_LEVEL_PDE(level, virt_to_phys(page));
1215                 }
1216
1217                 /* No level skipping support yet */
1218                 if (PM_PTE_LEVEL(*pte) != level)
1219                         return NULL;
1220
1221                 level -= 1;
1222
1223                 pte = IOMMU_PTE_PAGE(*pte);
1224
1225                 if (pte_page && level == end_lvl)
1226                         *pte_page = pte;
1227
1228                 pte = &pte[PM_LEVEL_INDEX(level, address)];
1229         }
1230
1231         return pte;
1232 }
1233
1234 /*
1235  * This function checks if there is a PTE for a given dma address. If
1236  * there is one, it returns the pointer to it.
1237  */
1238 static u64 *fetch_pte(struct protection_domain *domain, unsigned long address)
1239 {
1240         int level;
1241         u64 *pte;
1242
1243         if (address > PM_LEVEL_SIZE(domain->mode))
1244                 return NULL;
1245
1246         level   =  domain->mode - 1;
1247         pte     = &domain->pt_root[PM_LEVEL_INDEX(level, address)];
1248
1249         while (level > 0) {
1250
1251                 /* Not Present */
1252                 if (!IOMMU_PTE_PRESENT(*pte))
1253                         return NULL;
1254
1255                 /* Large PTE */
1256                 if (PM_PTE_LEVEL(*pte) == 0x07) {
1257                         unsigned long pte_mask, __pte;
1258
1259                         /*
1260                          * If we have a series of large PTEs, make
1261                          * sure to return a pointer to the first one.
1262                          */
1263                         pte_mask = PTE_PAGE_SIZE(*pte);
1264                         pte_mask = ~((PAGE_SIZE_PTE_COUNT(pte_mask) << 3) - 1);
1265                         __pte    = ((unsigned long)pte) & pte_mask;
1266
1267                         return (u64 *)__pte;
1268                 }
1269
1270                 /* No level skipping support yet */
1271                 if (PM_PTE_LEVEL(*pte) != level)
1272                         return NULL;
1273
1274                 level -= 1;
1275
1276                 /* Walk to the next level */
1277                 pte = IOMMU_PTE_PAGE(*pte);
1278                 pte = &pte[PM_LEVEL_INDEX(level, address)];
1279         }
1280
1281         return pte;
1282 }
1283
1284 /*
1285  * Generic mapping functions. It maps a physical address into a DMA
1286  * address space. It allocates the page table pages if necessary.
1287  * In the future it can be extended to a generic mapping function
1288  * supporting all features of AMD IOMMU page tables like level skipping
1289  * and full 64 bit address spaces.
1290  */
1291 static int iommu_map_page(struct protection_domain *dom,
1292                           unsigned long bus_addr,
1293                           unsigned long phys_addr,
1294                           int prot,
1295                           unsigned long page_size)
1296 {
1297         u64 __pte, *pte;
1298         int i, count;
1299
1300         if (!(prot & IOMMU_PROT_MASK))
1301                 return -EINVAL;
1302
1303         bus_addr  = PAGE_ALIGN(bus_addr);
1304         phys_addr = PAGE_ALIGN(phys_addr);
1305         count     = PAGE_SIZE_PTE_COUNT(page_size);
1306         pte       = alloc_pte(dom, bus_addr, page_size, NULL, GFP_KERNEL);
1307
1308         for (i = 0; i < count; ++i)
1309                 if (IOMMU_PTE_PRESENT(pte[i]))
1310                         return -EBUSY;
1311
1312         if (page_size > PAGE_SIZE) {
1313                 __pte = PAGE_SIZE_PTE(phys_addr, page_size);
1314                 __pte |= PM_LEVEL_ENC(7) | IOMMU_PTE_P | IOMMU_PTE_FC;
1315         } else
1316                 __pte = phys_addr | IOMMU_PTE_P | IOMMU_PTE_FC;
1317
1318         if (prot & IOMMU_PROT_IR)
1319                 __pte |= IOMMU_PTE_IR;
1320         if (prot & IOMMU_PROT_IW)
1321                 __pte |= IOMMU_PTE_IW;
1322
1323         for (i = 0; i < count; ++i)
1324                 pte[i] = __pte;
1325
1326         update_domain(dom);
1327
1328         return 0;
1329 }
1330
1331 static unsigned long iommu_unmap_page(struct protection_domain *dom,
1332                                       unsigned long bus_addr,
1333                                       unsigned long page_size)
1334 {
1335         unsigned long long unmap_size, unmapped;
1336         u64 *pte;
1337
1338         BUG_ON(!is_power_of_2(page_size));
1339
1340         unmapped = 0;
1341
1342         while (unmapped < page_size) {
1343
1344                 pte = fetch_pte(dom, bus_addr);
1345
1346                 if (!pte) {
1347                         /*
1348                          * No PTE for this address
1349                          * move forward in 4kb steps
1350                          */
1351                         unmap_size = PAGE_SIZE;
1352                 } else if (PM_PTE_LEVEL(*pte) == 0) {
1353                         /* 4kb PTE found for this address */
1354                         unmap_size = PAGE_SIZE;
1355                         *pte       = 0ULL;
1356                 } else {
1357                         int count, i;
1358
1359                         /* Large PTE found which maps this address */
1360                         unmap_size = PTE_PAGE_SIZE(*pte);
1361                         count      = PAGE_SIZE_PTE_COUNT(unmap_size);
1362                         for (i = 0; i < count; i++)
1363                                 pte[i] = 0ULL;
1364                 }
1365
1366                 bus_addr  = (bus_addr & ~(unmap_size - 1)) + unmap_size;
1367                 unmapped += unmap_size;
1368         }
1369
1370         BUG_ON(!is_power_of_2(unmapped));
1371
1372         return unmapped;
1373 }
1374
1375 /*
1376  * This function checks if a specific unity mapping entry is needed for
1377  * this specific IOMMU.
1378  */
1379 static int iommu_for_unity_map(struct amd_iommu *iommu,
1380                                struct unity_map_entry *entry)
1381 {
1382         u16 bdf, i;
1383
1384         for (i = entry->devid_start; i <= entry->devid_end; ++i) {
1385                 bdf = amd_iommu_alias_table[i];
1386                 if (amd_iommu_rlookup_table[bdf] == iommu)
1387                         return 1;
1388         }
1389
1390         return 0;
1391 }
1392
1393 /*
1394  * This function actually applies the mapping to the page table of the
1395  * dma_ops domain.
1396  */
1397 static int dma_ops_unity_map(struct dma_ops_domain *dma_dom,
1398                              struct unity_map_entry *e)
1399 {
1400         u64 addr;
1401         int ret;
1402
1403         for (addr = e->address_start; addr < e->address_end;
1404              addr += PAGE_SIZE) {
1405                 ret = iommu_map_page(&dma_dom->domain, addr, addr, e->prot,
1406                                      PAGE_SIZE);
1407                 if (ret)
1408                         return ret;
1409                 /*
1410                  * if unity mapping is in aperture range mark the page
1411                  * as allocated in the aperture
1412                  */
1413                 if (addr < dma_dom->aperture_size)
1414                         __set_bit(addr >> PAGE_SHIFT,
1415                                   dma_dom->aperture[0]->bitmap);
1416         }
1417
1418         return 0;
1419 }
1420
1421 /*
1422  * Init the unity mappings for a specific IOMMU in the system
1423  *
1424  * Basically iterates over all unity mapping entries and applies them to
1425  * the default domain DMA of that IOMMU if necessary.
1426  */
1427 static int iommu_init_unity_mappings(struct amd_iommu *iommu)
1428 {
1429         struct unity_map_entry *entry;
1430         int ret;
1431
1432         list_for_each_entry(entry, &amd_iommu_unity_map, list) {
1433                 if (!iommu_for_unity_map(iommu, entry))
1434                         continue;
1435                 ret = dma_ops_unity_map(iommu->default_dom, entry);
1436                 if (ret)
1437                         return ret;
1438         }
1439
1440         return 0;
1441 }
1442
1443 /*
1444  * Inits the unity mappings required for a specific device
1445  */
1446 static int init_unity_mappings_for_device(struct dma_ops_domain *dma_dom,
1447                                           u16 devid)
1448 {
1449         struct unity_map_entry *e;
1450         int ret;
1451
1452         list_for_each_entry(e, &amd_iommu_unity_map, list) {
1453                 if (!(devid >= e->devid_start && devid <= e->devid_end))
1454                         continue;
1455                 ret = dma_ops_unity_map(dma_dom, e);
1456                 if (ret)
1457                         return ret;
1458         }
1459
1460         return 0;
1461 }
1462
1463 /****************************************************************************
1464  *
1465  * The next functions belong to the address allocator for the dma_ops
1466  * interface functions. They work like the allocators in the other IOMMU
1467  * drivers. Its basically a bitmap which marks the allocated pages in
1468  * the aperture. Maybe it could be enhanced in the future to a more
1469  * efficient allocator.
1470  *
1471  ****************************************************************************/
1472
1473 /*
1474  * The address allocator core functions.
1475  *
1476  * called with domain->lock held
1477  */
1478
1479 /*
1480  * Used to reserve address ranges in the aperture (e.g. for exclusion
1481  * ranges.
1482  */
1483 static void dma_ops_reserve_addresses(struct dma_ops_domain *dom,
1484                                       unsigned long start_page,
1485                                       unsigned int pages)
1486 {
1487         unsigned int i, last_page = dom->aperture_size >> PAGE_SHIFT;
1488
1489         if (start_page + pages > last_page)
1490                 pages = last_page - start_page;
1491
1492         for (i = start_page; i < start_page + pages; ++i) {
1493                 int index = i / APERTURE_RANGE_PAGES;
1494                 int page  = i % APERTURE_RANGE_PAGES;
1495                 __set_bit(page, dom->aperture[index]->bitmap);
1496         }
1497 }
1498
1499 /*
1500  * This function is used to add a new aperture range to an existing
1501  * aperture in case of dma_ops domain allocation or address allocation
1502  * failure.
1503  */
1504 static int alloc_new_range(struct dma_ops_domain *dma_dom,
1505                            bool populate, gfp_t gfp)
1506 {
1507         int index = dma_dom->aperture_size >> APERTURE_RANGE_SHIFT;
1508         struct amd_iommu *iommu;
1509         unsigned long i, old_size;
1510
1511 #ifdef CONFIG_IOMMU_STRESS
1512         populate = false;
1513 #endif
1514
1515         if (index >= APERTURE_MAX_RANGES)
1516                 return -ENOMEM;
1517
1518         dma_dom->aperture[index] = kzalloc(sizeof(struct aperture_range), gfp);
1519         if (!dma_dom->aperture[index])
1520                 return -ENOMEM;
1521
1522         dma_dom->aperture[index]->bitmap = (void *)get_zeroed_page(gfp);
1523         if (!dma_dom->aperture[index]->bitmap)
1524                 goto out_free;
1525
1526         dma_dom->aperture[index]->offset = dma_dom->aperture_size;
1527
1528         if (populate) {
1529                 unsigned long address = dma_dom->aperture_size;
1530                 int i, num_ptes = APERTURE_RANGE_PAGES / 512;
1531                 u64 *pte, *pte_page;
1532
1533                 for (i = 0; i < num_ptes; ++i) {
1534                         pte = alloc_pte(&dma_dom->domain, address, PAGE_SIZE,
1535                                         &pte_page, gfp);
1536                         if (!pte)
1537                                 goto out_free;
1538
1539                         dma_dom->aperture[index]->pte_pages[i] = pte_page;
1540
1541                         address += APERTURE_RANGE_SIZE / 64;
1542                 }
1543         }
1544
1545         old_size                = dma_dom->aperture_size;
1546         dma_dom->aperture_size += APERTURE_RANGE_SIZE;
1547
1548         /* Reserve address range used for MSI messages */
1549         if (old_size < MSI_ADDR_BASE_LO &&
1550             dma_dom->aperture_size > MSI_ADDR_BASE_LO) {
1551                 unsigned long spage;
1552                 int pages;
1553
1554                 pages = iommu_num_pages(MSI_ADDR_BASE_LO, 0x10000, PAGE_SIZE);
1555                 spage = MSI_ADDR_BASE_LO >> PAGE_SHIFT;
1556
1557                 dma_ops_reserve_addresses(dma_dom, spage, pages);
1558         }
1559
1560         /* Initialize the exclusion range if necessary */
1561         for_each_iommu(iommu) {
1562                 if (iommu->exclusion_start &&
1563                     iommu->exclusion_start >= dma_dom->aperture[index]->offset
1564                     && iommu->exclusion_start < dma_dom->aperture_size) {
1565                         unsigned long startpage;
1566                         int pages = iommu_num_pages(iommu->exclusion_start,
1567                                                     iommu->exclusion_length,
1568                                                     PAGE_SIZE);
1569                         startpage = iommu->exclusion_start >> PAGE_SHIFT;
1570                         dma_ops_reserve_addresses(dma_dom, startpage, pages);
1571                 }
1572         }
1573
1574         /*
1575          * Check for areas already mapped as present in the new aperture
1576          * range and mark those pages as reserved in the allocator. Such
1577          * mappings may already exist as a result of requested unity
1578          * mappings for devices.
1579          */
1580         for (i = dma_dom->aperture[index]->offset;
1581              i < dma_dom->aperture_size;
1582              i += PAGE_SIZE) {
1583                 u64 *pte = fetch_pte(&dma_dom->domain, i);
1584                 if (!pte || !IOMMU_PTE_PRESENT(*pte))
1585                         continue;
1586
1587                 dma_ops_reserve_addresses(dma_dom, i >> PAGE_SHIFT, 1);
1588         }
1589
1590         update_domain(&dma_dom->domain);
1591
1592         return 0;
1593
1594 out_free:
1595         update_domain(&dma_dom->domain);
1596
1597         free_page((unsigned long)dma_dom->aperture[index]->bitmap);
1598
1599         kfree(dma_dom->aperture[index]);
1600         dma_dom->aperture[index] = NULL;
1601
1602         return -ENOMEM;
1603 }
1604
1605 static unsigned long dma_ops_area_alloc(struct device *dev,
1606                                         struct dma_ops_domain *dom,
1607                                         unsigned int pages,
1608                                         unsigned long align_mask,
1609                                         u64 dma_mask,
1610                                         unsigned long start)
1611 {
1612         unsigned long next_bit = dom->next_address % APERTURE_RANGE_SIZE;
1613         int max_index = dom->aperture_size >> APERTURE_RANGE_SHIFT;
1614         int i = start >> APERTURE_RANGE_SHIFT;
1615         unsigned long boundary_size;
1616         unsigned long address = -1;
1617         unsigned long limit;
1618
1619         next_bit >>= PAGE_SHIFT;
1620
1621         boundary_size = ALIGN(dma_get_seg_boundary(dev) + 1,
1622                         PAGE_SIZE) >> PAGE_SHIFT;
1623
1624         for (;i < max_index; ++i) {
1625                 unsigned long offset = dom->aperture[i]->offset >> PAGE_SHIFT;
1626
1627                 if (dom->aperture[i]->offset >= dma_mask)
1628                         break;
1629
1630                 limit = iommu_device_max_index(APERTURE_RANGE_PAGES, offset,
1631                                                dma_mask >> PAGE_SHIFT);
1632
1633                 address = iommu_area_alloc(dom->aperture[i]->bitmap,
1634                                            limit, next_bit, pages, 0,
1635                                             boundary_size, align_mask);
1636                 if (address != -1) {
1637                         address = dom->aperture[i]->offset +
1638                                   (address << PAGE_SHIFT);
1639                         dom->next_address = address + (pages << PAGE_SHIFT);
1640                         break;
1641                 }
1642
1643                 next_bit = 0;
1644         }
1645
1646         return address;
1647 }
1648
1649 static unsigned long dma_ops_alloc_addresses(struct device *dev,
1650                                              struct dma_ops_domain *dom,
1651                                              unsigned int pages,
1652                                              unsigned long align_mask,
1653                                              u64 dma_mask)
1654 {
1655         unsigned long address;
1656
1657 #ifdef CONFIG_IOMMU_STRESS
1658         dom->next_address = 0;
1659         dom->need_flush = true;
1660 #endif
1661
1662         address = dma_ops_area_alloc(dev, dom, pages, align_mask,
1663                                      dma_mask, dom->next_address);
1664
1665         if (address == -1) {
1666                 dom->next_address = 0;
1667                 address = dma_ops_area_alloc(dev, dom, pages, align_mask,
1668                                              dma_mask, 0);
1669                 dom->need_flush = true;
1670         }
1671
1672         if (unlikely(address == -1))
1673                 address = DMA_ERROR_CODE;
1674
1675         WARN_ON((address + (PAGE_SIZE*pages)) > dom->aperture_size);
1676
1677         return address;
1678 }
1679
1680 /*
1681  * The address free function.
1682  *
1683  * called with domain->lock held
1684  */
1685 static void dma_ops_free_addresses(struct dma_ops_domain *dom,
1686                                    unsigned long address,
1687                                    unsigned int pages)
1688 {
1689         unsigned i = address >> APERTURE_RANGE_SHIFT;
1690         struct aperture_range *range = dom->aperture[i];
1691
1692         BUG_ON(i >= APERTURE_MAX_RANGES || range == NULL);
1693
1694 #ifdef CONFIG_IOMMU_STRESS
1695         if (i < 4)
1696                 return;
1697 #endif
1698
1699         if (address >= dom->next_address)
1700                 dom->need_flush = true;
1701
1702         address = (address % APERTURE_RANGE_SIZE) >> PAGE_SHIFT;
1703
1704         bitmap_clear(range->bitmap, address, pages);
1705
1706 }
1707
1708 /****************************************************************************
1709  *
1710  * The next functions belong to the domain allocation. A domain is
1711  * allocated for every IOMMU as the default domain. If device isolation
1712  * is enabled, every device get its own domain. The most important thing
1713  * about domains is the page table mapping the DMA address space they
1714  * contain.
1715  *
1716  ****************************************************************************/
1717
1718 /*
1719  * This function adds a protection domain to the global protection domain list
1720  */
1721 static void add_domain_to_list(struct protection_domain *domain)
1722 {
1723         unsigned long flags;
1724
1725         spin_lock_irqsave(&amd_iommu_pd_lock, flags);
1726         list_add(&domain->list, &amd_iommu_pd_list);
1727         spin_unlock_irqrestore(&amd_iommu_pd_lock, flags);
1728 }
1729
1730 /*
1731  * This function removes a protection domain to the global
1732  * protection domain list
1733  */
1734 static void del_domain_from_list(struct protection_domain *domain)
1735 {
1736         unsigned long flags;
1737
1738         spin_lock_irqsave(&amd_iommu_pd_lock, flags);
1739         list_del(&domain->list);
1740         spin_unlock_irqrestore(&amd_iommu_pd_lock, flags);
1741 }
1742
1743 static u16 domain_id_alloc(void)
1744 {
1745         unsigned long flags;
1746         int id;
1747
1748         write_lock_irqsave(&amd_iommu_devtable_lock, flags);
1749         id = find_first_zero_bit(amd_iommu_pd_alloc_bitmap, MAX_DOMAIN_ID);
1750         BUG_ON(id == 0);
1751         if (id > 0 && id < MAX_DOMAIN_ID)
1752                 __set_bit(id, amd_iommu_pd_alloc_bitmap);
1753         else
1754                 id = 0;
1755         write_unlock_irqrestore(&amd_iommu_devtable_lock, flags);
1756
1757         return id;
1758 }
1759
1760 static void domain_id_free(int id)
1761 {
1762         unsigned long flags;
1763
1764         write_lock_irqsave(&amd_iommu_devtable_lock, flags);
1765         if (id > 0 && id < MAX_DOMAIN_ID)
1766                 __clear_bit(id, amd_iommu_pd_alloc_bitmap);
1767         write_unlock_irqrestore(&amd_iommu_devtable_lock, flags);
1768 }
1769
1770 static void free_pagetable(struct protection_domain *domain)
1771 {
1772         int i, j;
1773         u64 *p1, *p2, *p3;
1774
1775         p1 = domain->pt_root;
1776
1777         if (!p1)
1778                 return;
1779
1780         for (i = 0; i < 512; ++i) {
1781                 if (!IOMMU_PTE_PRESENT(p1[i]))
1782                         continue;
1783
1784                 p2 = IOMMU_PTE_PAGE(p1[i]);
1785                 for (j = 0; j < 512; ++j) {
1786                         if (!IOMMU_PTE_PRESENT(p2[j]))
1787                                 continue;
1788                         p3 = IOMMU_PTE_PAGE(p2[j]);
1789                         free_page((unsigned long)p3);
1790                 }
1791
1792                 free_page((unsigned long)p2);
1793         }
1794
1795         free_page((unsigned long)p1);
1796
1797         domain->pt_root = NULL;
1798 }
1799
1800 static void free_gcr3_tbl_level1(u64 *tbl)
1801 {
1802         u64 *ptr;
1803         int i;
1804
1805         for (i = 0; i < 512; ++i) {
1806                 if (!(tbl[i] & GCR3_VALID))
1807                         continue;
1808
1809                 ptr = __va(tbl[i] & PAGE_MASK);
1810
1811                 free_page((unsigned long)ptr);
1812         }
1813 }
1814
1815 static void free_gcr3_tbl_level2(u64 *tbl)
1816 {
1817         u64 *ptr;
1818         int i;
1819
1820         for (i = 0; i < 512; ++i) {
1821                 if (!(tbl[i] & GCR3_VALID))
1822                         continue;
1823
1824                 ptr = __va(tbl[i] & PAGE_MASK);
1825
1826                 free_gcr3_tbl_level1(ptr);
1827         }
1828 }
1829
1830 static void free_gcr3_table(struct protection_domain *domain)
1831 {
1832         if (domain->glx == 2)
1833                 free_gcr3_tbl_level2(domain->gcr3_tbl);
1834         else if (domain->glx == 1)
1835                 free_gcr3_tbl_level1(domain->gcr3_tbl);
1836         else if (domain->glx != 0)
1837                 BUG();
1838
1839         free_page((unsigned long)domain->gcr3_tbl);
1840 }
1841
1842 /*
1843  * Free a domain, only used if something went wrong in the
1844  * allocation path and we need to free an already allocated page table
1845  */
1846 static void dma_ops_domain_free(struct dma_ops_domain *dom)
1847 {
1848         int i;
1849
1850         if (!dom)
1851                 return;
1852
1853         del_domain_from_list(&dom->domain);
1854
1855         free_pagetable(&dom->domain);
1856
1857         for (i = 0; i < APERTURE_MAX_RANGES; ++i) {
1858                 if (!dom->aperture[i])
1859                         continue;
1860                 free_page((unsigned long)dom->aperture[i]->bitmap);
1861                 kfree(dom->aperture[i]);
1862         }
1863
1864         kfree(dom);
1865 }
1866
1867 /*
1868  * Allocates a new protection domain usable for the dma_ops functions.
1869  * It also initializes the page table and the address allocator data
1870  * structures required for the dma_ops interface
1871  */
1872 static struct dma_ops_domain *dma_ops_domain_alloc(void)
1873 {
1874         struct dma_ops_domain *dma_dom;
1875
1876         dma_dom = kzalloc(sizeof(struct dma_ops_domain), GFP_KERNEL);
1877         if (!dma_dom)
1878                 return NULL;
1879
1880         spin_lock_init(&dma_dom->domain.lock);
1881
1882         dma_dom->domain.id = domain_id_alloc();
1883         if (dma_dom->domain.id == 0)
1884                 goto free_dma_dom;
1885         INIT_LIST_HEAD(&dma_dom->domain.dev_list);
1886         dma_dom->domain.mode = PAGE_MODE_2_LEVEL;
1887         dma_dom->domain.pt_root = (void *)get_zeroed_page(GFP_KERNEL);
1888         dma_dom->domain.flags = PD_DMA_OPS_MASK;
1889         dma_dom->domain.priv = dma_dom;
1890         if (!dma_dom->domain.pt_root)
1891                 goto free_dma_dom;
1892
1893         dma_dom->need_flush = false;
1894         dma_dom->target_dev = 0xffff;
1895
1896         add_domain_to_list(&dma_dom->domain);
1897
1898         if (alloc_new_range(dma_dom, true, GFP_KERNEL))
1899                 goto free_dma_dom;
1900
1901         /*
1902          * mark the first page as allocated so we never return 0 as
1903          * a valid dma-address. So we can use 0 as error value
1904          */
1905         dma_dom->aperture[0]->bitmap[0] = 1;
1906         dma_dom->next_address = 0;
1907
1908
1909         return dma_dom;
1910
1911 free_dma_dom:
1912         dma_ops_domain_free(dma_dom);
1913
1914         return NULL;
1915 }
1916
1917 /*
1918  * little helper function to check whether a given protection domain is a
1919  * dma_ops domain
1920  */
1921 static bool dma_ops_domain(struct protection_domain *domain)
1922 {
1923         return domain->flags & PD_DMA_OPS_MASK;
1924 }
1925
1926 static void set_dte_entry(u16 devid, struct protection_domain *domain, bool ats)
1927 {
1928         u64 pte_root = 0;
1929         u64 flags = 0;
1930
1931         if (domain->mode != PAGE_MODE_NONE)
1932                 pte_root = virt_to_phys(domain->pt_root);
1933
1934         pte_root |= (domain->mode & DEV_ENTRY_MODE_MASK)
1935                     << DEV_ENTRY_MODE_SHIFT;
1936         pte_root |= IOMMU_PTE_IR | IOMMU_PTE_IW | IOMMU_PTE_P | IOMMU_PTE_TV;
1937
1938         flags = amd_iommu_dev_table[devid].data[1];
1939
1940         if (ats)
1941                 flags |= DTE_FLAG_IOTLB;
1942
1943         if (domain->flags & PD_IOMMUV2_MASK) {
1944                 u64 gcr3 = __pa(domain->gcr3_tbl);
1945                 u64 glx  = domain->glx;
1946                 u64 tmp;
1947
1948                 pte_root |= DTE_FLAG_GV;
1949                 pte_root |= (glx & DTE_GLX_MASK) << DTE_GLX_SHIFT;
1950
1951                 /* First mask out possible old values for GCR3 table */
1952                 tmp = DTE_GCR3_VAL_B(~0ULL) << DTE_GCR3_SHIFT_B;
1953                 flags    &= ~tmp;
1954
1955                 tmp = DTE_GCR3_VAL_C(~0ULL) << DTE_GCR3_SHIFT_C;
1956                 flags    &= ~tmp;
1957
1958                 /* Encode GCR3 table into DTE */
1959                 tmp = DTE_GCR3_VAL_A(gcr3) << DTE_GCR3_SHIFT_A;
1960                 pte_root |= tmp;
1961
1962                 tmp = DTE_GCR3_VAL_B(gcr3) << DTE_GCR3_SHIFT_B;
1963                 flags    |= tmp;
1964
1965                 tmp = DTE_GCR3_VAL_C(gcr3) << DTE_GCR3_SHIFT_C;
1966                 flags    |= tmp;
1967         }
1968
1969         flags &= ~(0xffffUL);
1970         flags |= domain->id;
1971
1972         amd_iommu_dev_table[devid].data[1]  = flags;
1973         amd_iommu_dev_table[devid].data[0]  = pte_root;
1974 }
1975
1976 static void clear_dte_entry(u16 devid)
1977 {
1978         /* remove entry from the device table seen by the hardware */
1979         amd_iommu_dev_table[devid].data[0] = IOMMU_PTE_P | IOMMU_PTE_TV;
1980         amd_iommu_dev_table[devid].data[1] = 0;
1981
1982         amd_iommu_apply_erratum_63(devid);
1983 }
1984
1985 static void do_attach(struct iommu_dev_data *dev_data,
1986                       struct protection_domain *domain)
1987 {
1988         struct amd_iommu *iommu;
1989         bool ats;
1990
1991         iommu = amd_iommu_rlookup_table[dev_data->devid];
1992         ats   = dev_data->ats.enabled;
1993
1994         /* Update data structures */
1995         dev_data->domain = domain;
1996         list_add(&dev_data->list, &domain->dev_list);
1997         set_dte_entry(dev_data->devid, domain, ats);
1998
1999         /* Do reference counting */
2000         domain->dev_iommu[iommu->index] += 1;
2001         domain->dev_cnt                 += 1;
2002
2003         /* Flush the DTE entry */
2004         device_flush_dte(dev_data);
2005 }
2006
2007 static void do_detach(struct iommu_dev_data *dev_data)
2008 {
2009         struct amd_iommu *iommu;
2010
2011         iommu = amd_iommu_rlookup_table[dev_data->devid];
2012
2013         /* decrease reference counters */
2014         dev_data->domain->dev_iommu[iommu->index] -= 1;
2015         dev_data->domain->dev_cnt                 -= 1;
2016
2017         /* Update data structures */
2018         dev_data->domain = NULL;
2019         list_del(&dev_data->list);
2020         clear_dte_entry(dev_data->devid);
2021
2022         /* Flush the DTE entry */
2023         device_flush_dte(dev_data);
2024 }
2025
2026 /*
2027  * If a device is not yet associated with a domain, this function does
2028  * assigns it visible for the hardware
2029  */
2030 static int __attach_device(struct iommu_dev_data *dev_data,
2031                            struct protection_domain *domain)
2032 {
2033         int ret;
2034
2035         /* lock domain */
2036         spin_lock(&domain->lock);
2037
2038         if (dev_data->alias_data != NULL) {
2039                 struct iommu_dev_data *alias_data = dev_data->alias_data;
2040
2041                 /* Some sanity checks */
2042                 ret = -EBUSY;
2043                 if (alias_data->domain != NULL &&
2044                                 alias_data->domain != domain)
2045                         goto out_unlock;
2046
2047                 if (dev_data->domain != NULL &&
2048                                 dev_data->domain != domain)
2049                         goto out_unlock;
2050
2051                 /* Do real assignment */
2052                 if (alias_data->domain == NULL)
2053                         do_attach(alias_data, domain);
2054
2055                 atomic_inc(&alias_data->bind);
2056         }
2057
2058         if (dev_data->domain == NULL)
2059                 do_attach(dev_data, domain);
2060
2061         atomic_inc(&dev_data->bind);
2062
2063         ret = 0;
2064
2065 out_unlock:
2066
2067         /* ready */
2068         spin_unlock(&domain->lock);
2069
2070         return ret;
2071 }
2072
2073
2074 static void pdev_iommuv2_disable(struct pci_dev *pdev)
2075 {
2076         pci_disable_ats(pdev);
2077         pci_disable_pri(pdev);
2078         pci_disable_pasid(pdev);
2079 }
2080
2081 /* FIXME: Change generic reset-function to do the same */
2082 static int pri_reset_while_enabled(struct pci_dev *pdev)
2083 {
2084         u16 control;
2085         int pos;
2086
2087         pos = pci_find_ext_capability(pdev, PCI_EXT_CAP_ID_PRI);
2088         if (!pos)
2089                 return -EINVAL;
2090
2091         pci_read_config_word(pdev, pos + PCI_PRI_CTRL, &control);
2092         control |= PCI_PRI_CTRL_RESET;
2093         pci_write_config_word(pdev, pos + PCI_PRI_CTRL, control);
2094
2095         return 0;
2096 }
2097
2098 static int pdev_iommuv2_enable(struct pci_dev *pdev)
2099 {
2100         bool reset_enable;
2101         int reqs, ret;
2102
2103         /* FIXME: Hardcode number of outstanding requests for now */
2104         reqs = 32;
2105         if (pdev_pri_erratum(pdev, AMD_PRI_DEV_ERRATUM_LIMIT_REQ_ONE))
2106                 reqs = 1;
2107         reset_enable = pdev_pri_erratum(pdev, AMD_PRI_DEV_ERRATUM_ENABLE_RESET);
2108
2109         /* Only allow access to user-accessible pages */
2110         ret = pci_enable_pasid(pdev, 0);
2111         if (ret)
2112                 goto out_err;
2113
2114         /* First reset the PRI state of the device */
2115         ret = pci_reset_pri(pdev);
2116         if (ret)
2117                 goto out_err;
2118
2119         /* Enable PRI */
2120         ret = pci_enable_pri(pdev, reqs);
2121         if (ret)
2122                 goto out_err;
2123
2124         if (reset_enable) {
2125                 ret = pri_reset_while_enabled(pdev);
2126                 if (ret)
2127                         goto out_err;
2128         }
2129
2130         ret = pci_enable_ats(pdev, PAGE_SHIFT);
2131         if (ret)
2132                 goto out_err;
2133
2134         return 0;
2135
2136 out_err:
2137         pci_disable_pri(pdev);
2138         pci_disable_pasid(pdev);
2139
2140         return ret;
2141 }
2142
2143 /* FIXME: Move this to PCI code */
2144 #define PCI_PRI_TLP_OFF         (1 << 15)
2145
2146 static bool pci_pri_tlp_required(struct pci_dev *pdev)
2147 {
2148         u16 status;
2149         int pos;
2150
2151         pos = pci_find_ext_capability(pdev, PCI_EXT_CAP_ID_PRI);
2152         if (!pos)
2153                 return false;
2154
2155         pci_read_config_word(pdev, pos + PCI_PRI_STATUS, &status);
2156
2157         return (status & PCI_PRI_TLP_OFF) ? true : false;
2158 }
2159
2160 /*
2161  * If a device is not yet associated with a domain, this function does
2162  * assigns it visible for the hardware
2163  */
2164 static int attach_device(struct device *dev,
2165                          struct protection_domain *domain)
2166 {
2167         struct pci_dev *pdev = to_pci_dev(dev);
2168         struct iommu_dev_data *dev_data;
2169         unsigned long flags;
2170         int ret;
2171
2172         dev_data = get_dev_data(dev);
2173
2174         if (domain->flags & PD_IOMMUV2_MASK) {
2175                 if (!dev_data->iommu_v2 || !dev_data->passthrough)
2176                         return -EINVAL;
2177
2178                 if (pdev_iommuv2_enable(pdev) != 0)
2179                         return -EINVAL;
2180
2181                 dev_data->ats.enabled = true;
2182                 dev_data->ats.qdep    = pci_ats_queue_depth(pdev);
2183                 dev_data->pri_tlp     = pci_pri_tlp_required(pdev);
2184         } else if (amd_iommu_iotlb_sup &&
2185                    pci_enable_ats(pdev, PAGE_SHIFT) == 0) {
2186                 dev_data->ats.enabled = true;
2187                 dev_data->ats.qdep    = pci_ats_queue_depth(pdev);
2188         }
2189
2190         write_lock_irqsave(&amd_iommu_devtable_lock, flags);
2191         ret = __attach_device(dev_data, domain);
2192         write_unlock_irqrestore(&amd_iommu_devtable_lock, flags);
2193
2194         /*
2195          * We might boot into a crash-kernel here. The crashed kernel
2196          * left the caches in the IOMMU dirty. So we have to flush
2197          * here to evict all dirty stuff.
2198          */
2199         domain_flush_tlb_pde(domain);
2200
2201         return ret;
2202 }
2203
2204 /*
2205  * Removes a device from a protection domain (unlocked)
2206  */
2207 static void __detach_device(struct iommu_dev_data *dev_data)
2208 {
2209         struct protection_domain *domain;
2210         unsigned long flags;
2211
2212         BUG_ON(!dev_data->domain);
2213
2214         domain = dev_data->domain;
2215
2216         spin_lock_irqsave(&domain->lock, flags);
2217
2218         if (dev_data->alias_data != NULL) {
2219                 struct iommu_dev_data *alias_data = dev_data->alias_data;
2220
2221                 if (atomic_dec_and_test(&alias_data->bind))
2222                         do_detach(alias_data);
2223         }
2224
2225         if (atomic_dec_and_test(&dev_data->bind))
2226                 do_detach(dev_data);
2227
2228         spin_unlock_irqrestore(&domain->lock, flags);
2229
2230         /*
2231          * If we run in passthrough mode the device must be assigned to the
2232          * passthrough domain if it is detached from any other domain.
2233          * Make sure we can deassign from the pt_domain itself.
2234          */
2235         if (dev_data->passthrough &&
2236             (dev_data->domain == NULL && domain != pt_domain))
2237                 __attach_device(dev_data, pt_domain);
2238 }
2239
2240 /*
2241  * Removes a device from a protection domain (with devtable_lock held)
2242  */
2243 static void detach_device(struct device *dev)
2244 {
2245         struct protection_domain *domain;
2246         struct iommu_dev_data *dev_data;
2247         unsigned long flags;
2248
2249         dev_data = get_dev_data(dev);
2250         domain   = dev_data->domain;
2251
2252         /* lock device table */
2253         write_lock_irqsave(&amd_iommu_devtable_lock, flags);
2254         __detach_device(dev_data);
2255         write_unlock_irqrestore(&amd_iommu_devtable_lock, flags);
2256
2257         if (domain->flags & PD_IOMMUV2_MASK)
2258                 pdev_iommuv2_disable(to_pci_dev(dev));
2259         else if (dev_data->ats.enabled)
2260                 pci_disable_ats(to_pci_dev(dev));
2261
2262         dev_data->ats.enabled = false;
2263 }
2264
2265 /*
2266  * Find out the protection domain structure for a given PCI device. This
2267  * will give us the pointer to the page table root for example.
2268  */
2269 static struct protection_domain *domain_for_device(struct device *dev)
2270 {
2271         struct iommu_dev_data *dev_data;
2272         struct protection_domain *dom = NULL;
2273         unsigned long flags;
2274
2275         dev_data   = get_dev_data(dev);
2276
2277         if (dev_data->domain)
2278                 return dev_data->domain;
2279
2280         if (dev_data->alias_data != NULL) {
2281                 struct iommu_dev_data *alias_data = dev_data->alias_data;
2282
2283                 read_lock_irqsave(&amd_iommu_devtable_lock, flags);
2284                 if (alias_data->domain != NULL) {
2285                         __attach_device(dev_data, alias_data->domain);
2286                         dom = alias_data->domain;
2287                 }
2288                 read_unlock_irqrestore(&amd_iommu_devtable_lock, flags);
2289         }
2290
2291         return dom;
2292 }
2293
2294 static int device_change_notifier(struct notifier_block *nb,
2295                                   unsigned long action, void *data)
2296 {
2297         struct dma_ops_domain *dma_domain;
2298         struct protection_domain *domain;
2299         struct iommu_dev_data *dev_data;
2300         struct device *dev = data;
2301         struct amd_iommu *iommu;
2302         unsigned long flags;
2303         u16 devid;
2304
2305         if (!check_device(dev))
2306                 return 0;
2307
2308         devid    = get_device_id(dev);
2309         iommu    = amd_iommu_rlookup_table[devid];
2310         dev_data = get_dev_data(dev);
2311
2312         switch (action) {
2313         case BUS_NOTIFY_UNBOUND_DRIVER:
2314
2315                 domain = domain_for_device(dev);
2316
2317                 if (!domain)
2318                         goto out;
2319                 if (dev_data->passthrough)
2320                         break;
2321                 detach_device(dev);
2322                 break;
2323         case BUS_NOTIFY_ADD_DEVICE:
2324
2325                 iommu_init_device(dev);
2326
2327                 /*
2328                  * dev_data is still NULL and
2329                  * got initialized in iommu_init_device
2330                  */
2331                 dev_data = get_dev_data(dev);
2332
2333                 if (iommu_pass_through || dev_data->iommu_v2) {
2334                         dev_data->passthrough = true;
2335                         attach_device(dev, pt_domain);
2336                         break;
2337                 }
2338
2339                 domain = domain_for_device(dev);
2340
2341                 /* allocate a protection domain if a device is added */
2342                 dma_domain = find_protection_domain(devid);
2343                 if (dma_domain)
2344                         goto out;
2345                 dma_domain = dma_ops_domain_alloc();
2346                 if (!dma_domain)
2347                         goto out;
2348                 dma_domain->target_dev = devid;
2349
2350                 spin_lock_irqsave(&iommu_pd_list_lock, flags);
2351                 list_add_tail(&dma_domain->list, &iommu_pd_list);
2352                 spin_unlock_irqrestore(&iommu_pd_list_lock, flags);
2353
2354                 dev_data = get_dev_data(dev);
2355
2356                 dev->archdata.dma_ops = &amd_iommu_dma_ops;
2357
2358                 break;
2359         case BUS_NOTIFY_DEL_DEVICE:
2360
2361                 iommu_uninit_device(dev);
2362
2363         default:
2364                 goto out;
2365         }
2366
2367         iommu_completion_wait(iommu);
2368
2369 out:
2370         return 0;
2371 }
2372
2373 static struct notifier_block device_nb = {
2374         .notifier_call = device_change_notifier,
2375 };
2376
2377 void amd_iommu_init_notifier(void)
2378 {
2379         bus_register_notifier(&pci_bus_type, &device_nb);
2380 }
2381
2382 /*****************************************************************************
2383  *
2384  * The next functions belong to the dma_ops mapping/unmapping code.
2385  *
2386  *****************************************************************************/
2387
2388 /*
2389  * In the dma_ops path we only have the struct device. This function
2390  * finds the corresponding IOMMU, the protection domain and the
2391  * requestor id for a given device.
2392  * If the device is not yet associated with a domain this is also done
2393  * in this function.
2394  */
2395 static struct protection_domain *get_domain(struct device *dev)
2396 {
2397         struct protection_domain *domain;
2398         struct dma_ops_domain *dma_dom;
2399         u16 devid = get_device_id(dev);
2400
2401         if (!check_device(dev))
2402                 return ERR_PTR(-EINVAL);
2403
2404         domain = domain_for_device(dev);
2405         if (domain != NULL && !dma_ops_domain(domain))
2406                 return ERR_PTR(-EBUSY);
2407
2408         if (domain != NULL)
2409                 return domain;
2410
2411         /* Device not bount yet - bind it */
2412         dma_dom = find_protection_domain(devid);
2413         if (!dma_dom)
2414                 dma_dom = amd_iommu_rlookup_table[devid]->default_dom;
2415         attach_device(dev, &dma_dom->domain);
2416         DUMP_printk("Using protection domain %d for device %s\n",
2417                     dma_dom->domain.id, dev_name(dev));
2418
2419         return &dma_dom->domain;
2420 }
2421
2422 static void update_device_table(struct protection_domain *domain)
2423 {
2424         struct iommu_dev_data *dev_data;
2425
2426         list_for_each_entry(dev_data, &domain->dev_list, list)
2427                 set_dte_entry(dev_data->devid, domain, dev_data->ats.enabled);
2428 }
2429
2430 static void update_domain(struct protection_domain *domain)
2431 {
2432         if (!domain->updated)
2433                 return;
2434
2435         update_device_table(domain);
2436
2437         domain_flush_devices(domain);
2438         domain_flush_tlb_pde(domain);
2439
2440         domain->updated = false;
2441 }
2442
2443 /*
2444  * This function fetches the PTE for a given address in the aperture
2445  */
2446 static u64* dma_ops_get_pte(struct dma_ops_domain *dom,
2447                             unsigned long address)
2448 {
2449         struct aperture_range *aperture;
2450         u64 *pte, *pte_page;
2451
2452         aperture = dom->aperture[APERTURE_RANGE_INDEX(address)];
2453         if (!aperture)
2454                 return NULL;
2455
2456         pte = aperture->pte_pages[APERTURE_PAGE_INDEX(address)];
2457         if (!pte) {
2458                 pte = alloc_pte(&dom->domain, address, PAGE_SIZE, &pte_page,
2459                                 GFP_ATOMIC);
2460                 aperture->pte_pages[APERTURE_PAGE_INDEX(address)] = pte_page;
2461         } else
2462                 pte += PM_LEVEL_INDEX(0, address);
2463
2464         update_domain(&dom->domain);
2465
2466         return pte;
2467 }
2468
2469 /*
2470  * This is the generic map function. It maps one 4kb page at paddr to
2471  * the given address in the DMA address space for the domain.
2472  */
2473 static dma_addr_t dma_ops_domain_map(struct dma_ops_domain *dom,
2474                                      unsigned long address,
2475                                      phys_addr_t paddr,
2476                                      int direction)
2477 {
2478         u64 *pte, __pte;
2479
2480         WARN_ON(address > dom->aperture_size);
2481
2482         paddr &= PAGE_MASK;
2483
2484         pte  = dma_ops_get_pte(dom, address);
2485         if (!pte)
2486                 return DMA_ERROR_CODE;
2487
2488         __pte = paddr | IOMMU_PTE_P | IOMMU_PTE_FC;
2489
2490         if (direction == DMA_TO_DEVICE)
2491                 __pte |= IOMMU_PTE_IR;
2492         else if (direction == DMA_FROM_DEVICE)
2493                 __pte |= IOMMU_PTE_IW;
2494         else if (direction == DMA_BIDIRECTIONAL)
2495                 __pte |= IOMMU_PTE_IR | IOMMU_PTE_IW;
2496
2497         WARN_ON(*pte);
2498
2499         *pte = __pte;
2500
2501         return (dma_addr_t)address;
2502 }
2503
2504 /*
2505  * The generic unmapping function for on page in the DMA address space.
2506  */
2507 static void dma_ops_domain_unmap(struct dma_ops_domain *dom,
2508                                  unsigned long address)
2509 {
2510         struct aperture_range *aperture;
2511         u64 *pte;
2512
2513         if (address >= dom->aperture_size)
2514                 return;
2515
2516         aperture = dom->aperture[APERTURE_RANGE_INDEX(address)];
2517         if (!aperture)
2518                 return;
2519
2520         pte  = aperture->pte_pages[APERTURE_PAGE_INDEX(address)];
2521         if (!pte)
2522                 return;
2523
2524         pte += PM_LEVEL_INDEX(0, address);
2525
2526         WARN_ON(!*pte);
2527
2528         *pte = 0ULL;
2529 }
2530
2531 /*
2532  * This function contains common code for mapping of a physically
2533  * contiguous memory region into DMA address space. It is used by all
2534  * mapping functions provided with this IOMMU driver.
2535  * Must be called with the domain lock held.
2536  */
2537 static dma_addr_t __map_single(struct device *dev,
2538                                struct dma_ops_domain *dma_dom,
2539                                phys_addr_t paddr,
2540                                size_t size,
2541                                int dir,
2542                                bool align,
2543                                u64 dma_mask)
2544 {
2545         dma_addr_t offset = paddr & ~PAGE_MASK;
2546         dma_addr_t address, start, ret;
2547         unsigned int pages;
2548         unsigned long align_mask = 0;
2549         int i;
2550
2551         pages = iommu_num_pages(paddr, size, PAGE_SIZE);
2552         paddr &= PAGE_MASK;
2553
2554         INC_STATS_COUNTER(total_map_requests);
2555
2556         if (pages > 1)
2557                 INC_STATS_COUNTER(cross_page);
2558
2559         if (align)
2560                 align_mask = (1UL << get_order(size)) - 1;
2561
2562 retry:
2563         address = dma_ops_alloc_addresses(dev, dma_dom, pages, align_mask,
2564                                           dma_mask);
2565         if (unlikely(address == DMA_ERROR_CODE)) {
2566                 /*
2567                  * setting next_address here will let the address
2568                  * allocator only scan the new allocated range in the
2569                  * first run. This is a small optimization.
2570                  */
2571                 dma_dom->next_address = dma_dom->aperture_size;
2572
2573                 if (alloc_new_range(dma_dom, false, GFP_ATOMIC))
2574                         goto out;
2575
2576                 /*
2577                  * aperture was successfully enlarged by 128 MB, try
2578                  * allocation again
2579                  */
2580                 goto retry;
2581         }
2582
2583         start = address;
2584         for (i = 0; i < pages; ++i) {
2585                 ret = dma_ops_domain_map(dma_dom, start, paddr, dir);
2586                 if (ret == DMA_ERROR_CODE)
2587                         goto out_unmap;
2588
2589                 paddr += PAGE_SIZE;
2590                 start += PAGE_SIZE;
2591         }
2592         address += offset;
2593
2594         ADD_STATS_COUNTER(alloced_io_mem, size);
2595
2596         if (unlikely(dma_dom->need_flush && !amd_iommu_unmap_flush)) {
2597                 domain_flush_tlb(&dma_dom->domain);
2598                 dma_dom->need_flush = false;
2599         } else if (unlikely(amd_iommu_np_cache))
2600                 domain_flush_pages(&dma_dom->domain, address, size);
2601
2602 out:
2603         return address;
2604
2605 out_unmap:
2606
2607         for (--i; i >= 0; --i) {
2608                 start -= PAGE_SIZE;
2609                 dma_ops_domain_unmap(dma_dom, start);
2610         }
2611
2612         dma_ops_free_addresses(dma_dom, address, pages);
2613
2614         return DMA_ERROR_CODE;
2615 }
2616
2617 /*
2618  * Does the reverse of the __map_single function. Must be called with
2619  * the domain lock held too
2620  */
2621 static void __unmap_single(struct dma_ops_domain *dma_dom,
2622                            dma_addr_t dma_addr,
2623                            size_t size,
2624                            int dir)
2625 {
2626         dma_addr_t flush_addr;
2627         dma_addr_t i, start;
2628         unsigned int pages;
2629
2630         if ((dma_addr == DMA_ERROR_CODE) ||
2631             (dma_addr + size > dma_dom->aperture_size))
2632                 return;
2633
2634         flush_addr = dma_addr;
2635         pages = iommu_num_pages(dma_addr, size, PAGE_SIZE);
2636         dma_addr &= PAGE_MASK;
2637         start = dma_addr;
2638
2639         for (i = 0; i < pages; ++i) {
2640                 dma_ops_domain_unmap(dma_dom, start);
2641                 start += PAGE_SIZE;
2642         }
2643
2644         SUB_STATS_COUNTER(alloced_io_mem, size);
2645
2646         dma_ops_free_addresses(dma_dom, dma_addr, pages);
2647
2648         if (amd_iommu_unmap_flush || dma_dom->need_flush) {
2649                 domain_flush_pages(&dma_dom->domain, flush_addr, size);
2650                 dma_dom->need_flush = false;
2651         }
2652 }
2653
2654 /*
2655  * The exported map_single function for dma_ops.
2656  */
2657 static dma_addr_t map_page(struct device *dev, struct page *page,
2658                            unsigned long offset, size_t size,
2659                            enum dma_data_direction dir,
2660                            struct dma_attrs *attrs)
2661 {
2662         unsigned long flags;
2663         struct protection_domain *domain;
2664         dma_addr_t addr;
2665         u64 dma_mask;
2666         phys_addr_t paddr = page_to_phys(page) + offset;
2667
2668         INC_STATS_COUNTER(cnt_map_single);
2669
2670         domain = get_domain(dev);
2671         if (PTR_ERR(domain) == -EINVAL)
2672                 return (dma_addr_t)paddr;
2673         else if (IS_ERR(domain))
2674                 return DMA_ERROR_CODE;
2675
2676         dma_mask = *dev->dma_mask;
2677
2678         spin_lock_irqsave(&domain->lock, flags);
2679
2680         addr = __map_single(dev, domain->priv, paddr, size, dir, false,
2681                             dma_mask);
2682         if (addr == DMA_ERROR_CODE)
2683                 goto out;
2684
2685         domain_flush_complete(domain);
2686
2687 out:
2688         spin_unlock_irqrestore(&domain->lock, flags);
2689
2690         return addr;
2691 }
2692
2693 /*
2694  * The exported unmap_single function for dma_ops.
2695  */
2696 static void unmap_page(struct device *dev, dma_addr_t dma_addr, size_t size,
2697                        enum dma_data_direction dir, struct dma_attrs *attrs)
2698 {
2699         unsigned long flags;
2700         struct protection_domain *domain;
2701
2702         INC_STATS_COUNTER(cnt_unmap_single);
2703
2704         domain = get_domain(dev);
2705         if (IS_ERR(domain))
2706                 return;
2707
2708         spin_lock_irqsave(&domain->lock, flags);
2709
2710         __unmap_single(domain->priv, dma_addr, size, dir);
2711
2712         domain_flush_complete(domain);
2713
2714         spin_unlock_irqrestore(&domain->lock, flags);
2715 }
2716
2717 /*
2718  * This is a special map_sg function which is used if we should map a
2719  * device which is not handled by an AMD IOMMU in the system.
2720  */
2721 static int map_sg_no_iommu(struct device *dev, struct scatterlist *sglist,
2722                            int nelems, int dir)
2723 {
2724         struct scatterlist *s;
2725         int i;
2726
2727         for_each_sg(sglist, s, nelems, i) {
2728                 s->dma_address = (dma_addr_t)sg_phys(s);
2729                 s->dma_length  = s->length;
2730         }
2731
2732         return nelems;
2733 }
2734
2735 /*
2736  * The exported map_sg function for dma_ops (handles scatter-gather
2737  * lists).
2738  */
2739 static int map_sg(struct device *dev, struct scatterlist *sglist,
2740                   int nelems, enum dma_data_direction dir,
2741                   struct dma_attrs *attrs)
2742 {
2743         unsigned long flags;
2744         struct protection_domain *domain;
2745         int i;
2746         struct scatterlist *s;
2747         phys_addr_t paddr;
2748         int mapped_elems = 0;
2749         u64 dma_mask;
2750
2751         INC_STATS_COUNTER(cnt_map_sg);
2752
2753         domain = get_domain(dev);
2754         if (PTR_ERR(domain) == -EINVAL)
2755                 return map_sg_no_iommu(dev, sglist, nelems, dir);
2756         else if (IS_ERR(domain))
2757                 return 0;
2758
2759         dma_mask = *dev->dma_mask;
2760
2761         spin_lock_irqsave(&domain->lock, flags);
2762
2763         for_each_sg(sglist, s, nelems, i) {
2764                 paddr = sg_phys(s);
2765
2766                 s->dma_address = __map_single(dev, domain->priv,
2767                                               paddr, s->length, dir, false,
2768                                               dma_mask);
2769
2770                 if (s->dma_address) {
2771                         s->dma_length = s->length;
2772                         mapped_elems++;
2773                 } else
2774                         goto unmap;
2775         }
2776
2777         domain_flush_complete(domain);
2778
2779 out:
2780         spin_unlock_irqrestore(&domain->lock, flags);
2781
2782         return mapped_elems;
2783 unmap:
2784         for_each_sg(sglist, s, mapped_elems, i) {
2785                 if (s->dma_address)
2786                         __unmap_single(domain->priv, s->dma_address,
2787                                        s->dma_length, dir);
2788                 s->dma_address = s->dma_length = 0;
2789         }
2790
2791         mapped_elems = 0;
2792
2793         goto out;
2794 }
2795
2796 /*
2797  * The exported map_sg function for dma_ops (handles scatter-gather
2798  * lists).
2799  */
2800 static void unmap_sg(struct device *dev, struct scatterlist *sglist,
2801                      int nelems, enum dma_data_direction dir,
2802                      struct dma_attrs *attrs)
2803 {
2804         unsigned long flags;
2805         struct protection_domain *domain;
2806         struct scatterlist *s;
2807         int i;
2808
2809         INC_STATS_COUNTER(cnt_unmap_sg);
2810
2811         domain = get_domain(dev);
2812         if (IS_ERR(domain))
2813                 return;
2814
2815         spin_lock_irqsave(&domain->lock, flags);
2816
2817         for_each_sg(sglist, s, nelems, i) {
2818                 __unmap_single(domain->priv, s->dma_address,
2819                                s->dma_length, dir);
2820                 s->dma_address = s->dma_length = 0;
2821         }
2822
2823         domain_flush_complete(domain);
2824
2825         spin_unlock_irqrestore(&domain->lock, flags);
2826 }
2827
2828 /*
2829  * The exported alloc_coherent function for dma_ops.
2830  */
2831 static void *alloc_coherent(struct device *dev, size_t size,
2832                             dma_addr_t *dma_addr, gfp_t flag,
2833                             struct dma_attrs *attrs)
2834 {
2835         unsigned long flags;
2836         void *virt_addr;
2837         struct protection_domain *domain;
2838         phys_addr_t paddr;
2839         u64 dma_mask = dev->coherent_dma_mask;
2840
2841         INC_STATS_COUNTER(cnt_alloc_coherent);
2842
2843         domain = get_domain(dev);
2844         if (PTR_ERR(domain) == -EINVAL) {
2845                 virt_addr = (void *)__get_free_pages(flag, get_order(size));
2846                 *dma_addr = __pa(virt_addr);
2847                 return virt_addr;
2848         } else if (IS_ERR(domain))
2849                 return NULL;
2850
2851         dma_mask  = dev->coherent_dma_mask;
2852         flag     &= ~(__GFP_DMA | __GFP_HIGHMEM | __GFP_DMA32);
2853         flag     |= __GFP_ZERO;
2854
2855         virt_addr = (void *)__get_free_pages(flag, get_order(size));
2856         if (!virt_addr)
2857                 return NULL;
2858
2859         paddr = virt_to_phys(virt_addr);
2860
2861         if (!dma_mask)
2862                 dma_mask = *dev->dma_mask;
2863
2864         spin_lock_irqsave(&domain->lock, flags);
2865
2866         *dma_addr = __map_single(dev, domain->priv, paddr,
2867                                  size, DMA_BIDIRECTIONAL, true, dma_mask);
2868
2869         if (*dma_addr == DMA_ERROR_CODE) {
2870                 spin_unlock_irqrestore(&domain->lock, flags);
2871                 goto out_free;
2872         }
2873
2874         domain_flush_complete(domain);
2875
2876         spin_unlock_irqrestore(&domain->lock, flags);
2877
2878         return virt_addr;
2879
2880 out_free:
2881
2882         free_pages((unsigned long)virt_addr, get_order(size));
2883
2884         return NULL;
2885 }
2886
2887 /*
2888  * The exported free_coherent function for dma_ops.
2889  */
2890 static void free_coherent(struct device *dev, size_t size,
2891                           void *virt_addr, dma_addr_t dma_addr,
2892                           struct dma_attrs *attrs)
2893 {
2894         unsigned long flags;
2895         struct protection_domain *domain;
2896
2897         INC_STATS_COUNTER(cnt_free_coherent);
2898
2899         domain = get_domain(dev);
2900         if (IS_ERR(domain))
2901                 goto free_mem;
2902
2903         spin_lock_irqsave(&domain->lock, flags);
2904
2905         __unmap_single(domain->priv, dma_addr, size, DMA_BIDIRECTIONAL);
2906
2907         domain_flush_complete(domain);
2908
2909         spin_unlock_irqrestore(&domain->lock, flags);
2910
2911 free_mem:
2912         free_pages((unsigned long)virt_addr, get_order(size));
2913 }
2914
2915 /*
2916  * This function is called by the DMA layer to find out if we can handle a
2917  * particular device. It is part of the dma_ops.
2918  */
2919 static int amd_iommu_dma_supported(struct device *dev, u64 mask)
2920 {
2921         return check_device(dev);
2922 }
2923
2924 /*
2925  * The function for pre-allocating protection domains.
2926  *
2927  * If the driver core informs the DMA layer if a driver grabs a device
2928  * we don't need to preallocate the protection domains anymore.
2929  * For now we have to.
2930  */
2931 static void __init prealloc_protection_domains(void)
2932 {
2933         struct iommu_dev_data *dev_data;
2934         struct dma_ops_domain *dma_dom;
2935         struct pci_dev *dev = NULL;
2936         u16 devid;
2937
2938         for_each_pci_dev(dev) {
2939
2940                 /* Do we handle this device? */
2941                 if (!check_device(&dev->dev))
2942                         continue;
2943
2944                 dev_data = get_dev_data(&dev->dev);
2945                 if (!amd_iommu_force_isolation && dev_data->iommu_v2) {
2946                         /* Make sure passthrough domain is allocated */
2947                         alloc_passthrough_domain();
2948                         dev_data->passthrough = true;
2949                         attach_device(&dev->dev, pt_domain);
2950                         pr_info("AMD-Vi: Using passthough domain for device %s\n",
2951                                 dev_name(&dev->dev));
2952                 }
2953
2954                 /* Is there already any domain for it? */
2955                 if (domain_for_device(&dev->dev))
2956                         continue;
2957
2958                 devid = get_device_id(&dev->dev);
2959
2960                 dma_dom = dma_ops_domain_alloc();
2961                 if (!dma_dom)
2962                         continue;
2963                 init_unity_mappings_for_device(dma_dom, devid);
2964                 dma_dom->target_dev = devid;
2965
2966                 attach_device(&dev->dev, &dma_dom->domain);
2967
2968                 list_add_tail(&dma_dom->list, &iommu_pd_list);
2969         }
2970 }
2971
2972 static struct dma_map_ops amd_iommu_dma_ops = {
2973         .alloc = alloc_coherent,
2974         .free = free_coherent,
2975         .map_page = map_page,
2976         .unmap_page = unmap_page,
2977         .map_sg = map_sg,
2978         .unmap_sg = unmap_sg,
2979         .dma_supported = amd_iommu_dma_supported,
2980 };
2981
2982 static unsigned device_dma_ops_init(void)
2983 {
2984         struct iommu_dev_data *dev_data;
2985         struct pci_dev *pdev = NULL;
2986         unsigned unhandled = 0;
2987
2988         for_each_pci_dev(pdev) {
2989                 if (!check_device(&pdev->dev)) {
2990
2991                         iommu_ignore_device(&pdev->dev);
2992
2993                         unhandled += 1;
2994                         continue;
2995                 }
2996
2997                 dev_data = get_dev_data(&pdev->dev);
2998
2999                 if (!dev_data->passthrough)
3000                         pdev->dev.archdata.dma_ops = &amd_iommu_dma_ops;
3001                 else
3002                         pdev->dev.archdata.dma_ops = &nommu_dma_ops;
3003         }
3004
3005         return unhandled;
3006 }
3007
3008 /*
3009  * The function which clues the AMD IOMMU driver into dma_ops.
3010  */
3011
3012 void __init amd_iommu_init_api(void)
3013 {
3014         bus_set_iommu(&pci_bus_type, &amd_iommu_ops);
3015 }
3016
3017 int __init amd_iommu_init_dma_ops(void)
3018 {
3019         struct amd_iommu *iommu;
3020         int ret, unhandled;
3021
3022         /*
3023          * first allocate a default protection domain for every IOMMU we
3024          * found in the system. Devices not assigned to any other
3025          * protection domain will be assigned to the default one.
3026          */
3027         for_each_iommu(iommu) {
3028                 iommu->default_dom = dma_ops_domain_alloc();
3029                 if (iommu->default_dom == NULL)
3030                         return -ENOMEM;
3031                 iommu->default_dom->domain.flags |= PD_DEFAULT_MASK;
3032                 ret = iommu_init_unity_mappings(iommu);
3033                 if (ret)
3034                         goto free_domains;
3035         }
3036
3037         /*
3038          * Pre-allocate the protection domains for each device.
3039          */
3040         prealloc_protection_domains();
3041
3042         iommu_detected = 1;
3043         swiotlb = 0;
3044
3045         /* Make the driver finally visible to the drivers */
3046         unhandled = device_dma_ops_init();
3047         if (unhandled && max_pfn > MAX_DMA32_PFN) {
3048                 /* There are unhandled devices - initialize swiotlb for them */
3049                 swiotlb = 1;
3050         }
3051
3052         amd_iommu_stats_init();
3053
3054         if (amd_iommu_unmap_flush)
3055                 pr_info("AMD-Vi: IO/TLB flush on unmap enabled\n");
3056         else
3057                 pr_info("AMD-Vi: Lazy IO/TLB flushing enabled\n");
3058
3059         return 0;
3060
3061 free_domains:
3062
3063         for_each_iommu(iommu) {
3064                 if (iommu->default_dom)
3065                         dma_ops_domain_free(iommu->default_dom);
3066         }
3067
3068         return ret;
3069 }
3070
3071 /*****************************************************************************
3072  *
3073  * The following functions belong to the exported interface of AMD IOMMU
3074  *
3075  * This interface allows access to lower level functions of the IOMMU
3076  * like protection domain handling and assignement of devices to domains
3077  * which is not possible with the dma_ops interface.
3078  *
3079  *****************************************************************************/
3080
3081 static void cleanup_domain(struct protection_domain *domain)
3082 {
3083         struct iommu_dev_data *dev_data, *next;
3084         unsigned long flags;
3085
3086         write_lock_irqsave(&amd_iommu_devtable_lock, flags);
3087
3088         list_for_each_entry_safe(dev_data, next, &domain->dev_list, list) {
3089                 __detach_device(dev_data);
3090                 atomic_set(&dev_data->bind, 0);
3091         }
3092
3093         write_unlock_irqrestore(&amd_iommu_devtable_lock, flags);
3094 }
3095
3096 static void protection_domain_free(struct protection_domain *domain)
3097 {
3098         if (!domain)
3099                 return;
3100
3101         del_domain_from_list(domain);
3102
3103         if (domain->id)
3104                 domain_id_free(domain->id);
3105
3106         kfree(domain);
3107 }
3108
3109 static struct protection_domain *protection_domain_alloc(void)
3110 {
3111         struct protection_domain *domain;
3112
3113         domain = kzalloc(sizeof(*domain), GFP_KERNEL);
3114         if (!domain)
3115                 return NULL;
3116
3117         spin_lock_init(&domain->lock);
3118         mutex_init(&domain->api_lock);
3119         domain->id = domain_id_alloc();
3120         if (!domain->id)
3121                 goto out_err;
3122         INIT_LIST_HEAD(&domain->dev_list);
3123
3124         add_domain_to_list(domain);
3125
3126         return domain;
3127
3128 out_err:
3129         kfree(domain);
3130
3131         return NULL;
3132 }
3133
3134 static int __init alloc_passthrough_domain(void)
3135 {
3136         if (pt_domain != NULL)
3137                 return 0;
3138
3139         /* allocate passthrough domain */
3140         pt_domain = protection_domain_alloc();
3141         if (!pt_domain)
3142                 return -ENOMEM;
3143
3144         pt_domain->mode = PAGE_MODE_NONE;
3145
3146         return 0;
3147 }
3148 static int amd_iommu_domain_init(struct iommu_domain *dom)
3149 {
3150         struct protection_domain *domain;
3151
3152         domain = protection_domain_alloc();
3153         if (!domain)
3154                 goto out_free;
3155
3156         domain->mode    = PAGE_MODE_3_LEVEL;
3157         domain->pt_root = (void *)get_zeroed_page(GFP_KERNEL);
3158         if (!domain->pt_root)
3159                 goto out_free;
3160
3161         domain->iommu_domain = dom;
3162
3163         dom->priv = domain;
3164
3165         dom->geometry.aperture_start = 0;
3166         dom->geometry.aperture_end   = ~0ULL;
3167         dom->geometry.force_aperture = true;
3168
3169         return 0;
3170
3171 out_free:
3172         protection_domain_free(domain);
3173
3174         return -ENOMEM;
3175 }
3176
3177 static void amd_iommu_domain_destroy(struct iommu_domain *dom)
3178 {
3179         struct protection_domain *domain = dom->priv;
3180
3181         if (!domain)
3182                 return;
3183
3184         if (domain->dev_cnt > 0)
3185                 cleanup_domain(domain);
3186
3187         BUG_ON(domain->dev_cnt != 0);
3188
3189         if (domain->mode != PAGE_MODE_NONE)
3190                 free_pagetable(domain);
3191
3192         if (domain->flags & PD_IOMMUV2_MASK)
3193                 free_gcr3_table(domain);
3194
3195         protection_domain_free(domain);
3196
3197         dom->priv = NULL;
3198 }
3199
3200 static void amd_iommu_detach_device(struct iommu_domain *dom,
3201                                     struct device *dev)
3202 {
3203         struct iommu_dev_data *dev_data = dev->archdata.iommu;
3204         struct amd_iommu *iommu;
3205         u16 devid;
3206
3207         if (!check_device(dev))
3208                 return;
3209
3210         devid = get_device_id(dev);
3211
3212         if (dev_data->domain != NULL)
3213                 detach_device(dev);
3214
3215         iommu = amd_iommu_rlookup_table[devid];
3216         if (!iommu)
3217                 return;
3218
3219         iommu_completion_wait(iommu);
3220 }
3221
3222 static int amd_iommu_attach_device(struct iommu_domain *dom,
3223                                    struct device *dev)
3224 {
3225         struct protection_domain *domain = dom->priv;
3226         struct iommu_dev_data *dev_data;
3227         struct amd_iommu *iommu;
3228         int ret;
3229
3230         if (!check_device(dev))
3231                 return -EINVAL;
3232
3233         dev_data = dev->archdata.iommu;
3234
3235         iommu = amd_iommu_rlookup_table[dev_data->devid];
3236         if (!iommu)
3237                 return -EINVAL;
3238
3239         if (dev_data->domain)
3240                 detach_device(dev);
3241
3242         ret = attach_device(dev, domain);
3243
3244         iommu_completion_wait(iommu);
3245
3246         return ret;
3247 }
3248
3249 static int amd_iommu_map(struct iommu_domain *dom, unsigned long iova,
3250                          phys_addr_t paddr, size_t page_size, int iommu_prot)
3251 {
3252         struct protection_domain *domain = dom->priv;
3253         int prot = 0;
3254         int ret;
3255
3256         if (domain->mode == PAGE_MODE_NONE)
3257                 return -EINVAL;
3258
3259         if (iommu_prot & IOMMU_READ)
3260                 prot |= IOMMU_PROT_IR;
3261         if (iommu_prot & IOMMU_WRITE)
3262                 prot |= IOMMU_PROT_IW;
3263
3264         mutex_lock(&domain->api_lock);
3265         ret = iommu_map_page(domain, iova, paddr, prot, page_size);
3266         mutex_unlock(&domain->api_lock);
3267
3268         return ret;
3269 }
3270
3271 static size_t amd_iommu_unmap(struct iommu_domain *dom, unsigned long iova,
3272                            size_t page_size)
3273 {
3274         struct protection_domain *domain = dom->priv;
3275         size_t unmap_size;
3276
3277         if (domain->mode == PAGE_MODE_NONE)
3278                 return -EINVAL;
3279
3280         mutex_lock(&domain->api_lock);
3281         unmap_size = iommu_unmap_page(domain, iova, page_size);
3282         mutex_unlock(&domain->api_lock);
3283
3284         domain_flush_tlb_pde(domain);
3285
3286         return unmap_size;
3287 }
3288
3289 static phys_addr_t amd_iommu_iova_to_phys(struct iommu_domain *dom,
3290                                           unsigned long iova)
3291 {
3292         struct protection_domain *domain = dom->priv;
3293         unsigned long offset_mask;
3294         phys_addr_t paddr;
3295         u64 *pte, __pte;
3296
3297         if (domain->mode == PAGE_MODE_NONE)
3298                 return iova;
3299
3300         pte = fetch_pte(domain, iova);
3301
3302         if (!pte || !IOMMU_PTE_PRESENT(*pte))
3303                 return 0;
3304
3305         if (PM_PTE_LEVEL(*pte) == 0)
3306                 offset_mask = PAGE_SIZE - 1;
3307         else
3308                 offset_mask = PTE_PAGE_SIZE(*pte) - 1;
3309
3310         __pte = *pte & PM_ADDR_MASK;
3311         paddr = (__pte & ~offset_mask) | (iova & offset_mask);
3312
3313         return paddr;
3314 }
3315
3316 static int amd_iommu_domain_has_cap(struct iommu_domain *domain,
3317                                     unsigned long cap)
3318 {
3319         switch (cap) {
3320         case IOMMU_CAP_CACHE_COHERENCY:
3321                 return 1;
3322         }
3323
3324         return 0;
3325 }
3326
3327 static struct iommu_ops amd_iommu_ops = {
3328         .domain_init = amd_iommu_domain_init,
3329         .domain_destroy = amd_iommu_domain_destroy,
3330         .attach_dev = amd_iommu_attach_device,
3331         .detach_dev = amd_iommu_detach_device,
3332         .map = amd_iommu_map,
3333         .unmap = amd_iommu_unmap,
3334         .iova_to_phys = amd_iommu_iova_to_phys,
3335         .domain_has_cap = amd_iommu_domain_has_cap,
3336         .pgsize_bitmap  = AMD_IOMMU_PGSIZES,
3337 };
3338
3339 /*****************************************************************************
3340  *
3341  * The next functions do a basic initialization of IOMMU for pass through
3342  * mode
3343  *
3344  * In passthrough mode the IOMMU is initialized and enabled but not used for
3345  * DMA-API translation.
3346  *
3347  *****************************************************************************/
3348
3349 int __init amd_iommu_init_passthrough(void)
3350 {
3351         struct iommu_dev_data *dev_data;
3352         struct pci_dev *dev = NULL;
3353         struct amd_iommu *iommu;
3354         u16 devid;
3355         int ret;
3356
3357         ret = alloc_passthrough_domain();
3358         if (ret)
3359                 return ret;
3360
3361         for_each_pci_dev(dev) {
3362                 if (!check_device(&dev->dev))
3363                         continue;
3364
3365                 dev_data = get_dev_data(&dev->dev);
3366                 dev_data->passthrough = true;
3367
3368                 devid = get_device_id(&dev->dev);
3369
3370                 iommu = amd_iommu_rlookup_table[devid];
3371                 if (!iommu)
3372                         continue;
3373
3374                 attach_device(&dev->dev, pt_domain);
3375         }
3376
3377         amd_iommu_stats_init();
3378
3379         pr_info("AMD-Vi: Initialized for Passthrough Mode\n");
3380
3381         return 0;
3382 }
3383
3384 /* IOMMUv2 specific functions */
3385 int amd_iommu_register_ppr_notifier(struct notifier_block *nb)
3386 {
3387         return atomic_notifier_chain_register(&ppr_notifier, nb);
3388 }
3389 EXPORT_SYMBOL(amd_iommu_register_ppr_notifier);
3390
3391 int amd_iommu_unregister_ppr_notifier(struct notifier_block *nb)
3392 {
3393         return atomic_notifier_chain_unregister(&ppr_notifier, nb);
3394 }
3395 EXPORT_SYMBOL(amd_iommu_unregister_ppr_notifier);
3396
3397 void amd_iommu_domain_direct_map(struct iommu_domain *dom)
3398 {
3399         struct protection_domain *domain = dom->priv;
3400         unsigned long flags;
3401
3402         spin_lock_irqsave(&domain->lock, flags);
3403
3404         /* Update data structure */
3405         domain->mode    = PAGE_MODE_NONE;
3406         domain->updated = true;
3407
3408         /* Make changes visible to IOMMUs */
3409         update_domain(domain);
3410
3411         /* Page-table is not visible to IOMMU anymore, so free it */
3412         free_pagetable(domain);
3413
3414         spin_unlock_irqrestore(&domain->lock, flags);
3415 }
3416 EXPORT_SYMBOL(amd_iommu_domain_direct_map);
3417
3418 int amd_iommu_domain_enable_v2(struct iommu_domain *dom, int pasids)
3419 {
3420         struct protection_domain *domain = dom->priv;
3421         unsigned long flags;
3422         int levels, ret;
3423
3424         if (pasids <= 0 || pasids > (PASID_MASK + 1))
3425                 return -EINVAL;
3426
3427         /* Number of GCR3 table levels required */
3428         for (levels = 0; (pasids - 1) & ~0x1ff; pasids >>= 9)
3429                 levels += 1;
3430
3431         if (levels > amd_iommu_max_glx_val)
3432                 return -EINVAL;
3433
3434         spin_lock_irqsave(&domain->lock, flags);
3435
3436         /*
3437          * Save us all sanity checks whether devices already in the
3438          * domain support IOMMUv2. Just force that the domain has no
3439          * devices attached when it is switched into IOMMUv2 mode.
3440          */
3441         ret = -EBUSY;
3442         if (domain->dev_cnt > 0 || domain->flags & PD_IOMMUV2_MASK)
3443                 goto out;
3444
3445         ret = -ENOMEM;
3446         domain->gcr3_tbl = (void *)get_zeroed_page(GFP_ATOMIC);
3447         if (domain->gcr3_tbl == NULL)
3448                 goto out;
3449
3450         domain->glx      = levels;
3451         domain->flags   |= PD_IOMMUV2_MASK;
3452         domain->updated  = true;
3453
3454         update_domain(domain);
3455
3456         ret = 0;
3457
3458 out:
3459         spin_unlock_irqrestore(&domain->lock, flags);
3460
3461         return ret;
3462 }
3463 EXPORT_SYMBOL(amd_iommu_domain_enable_v2);
3464
3465 static int __flush_pasid(struct protection_domain *domain, int pasid,
3466                          u64 address, bool size)
3467 {
3468         struct iommu_dev_data *dev_data;
3469         struct iommu_cmd cmd;
3470         int i, ret;
3471
3472         if (!(domain->flags & PD_IOMMUV2_MASK))
3473                 return -EINVAL;
3474
3475         build_inv_iommu_pasid(&cmd, domain->id, pasid, address, size);
3476
3477         /*
3478          * IOMMU TLB needs to be flushed before Device TLB to
3479          * prevent device TLB refill from IOMMU TLB
3480          */
3481         for (i = 0; i < amd_iommus_present; ++i) {
3482                 if (domain->dev_iommu[i] == 0)
3483                         continue;
3484
3485                 ret = iommu_queue_command(amd_iommus[i], &cmd);
3486                 if (ret != 0)
3487                         goto out;
3488         }
3489
3490         /* Wait until IOMMU TLB flushes are complete */
3491         domain_flush_complete(domain);
3492
3493         /* Now flush device TLBs */
3494         list_for_each_entry(dev_data, &domain->dev_list, list) {
3495                 struct amd_iommu *iommu;
3496                 int qdep;
3497
3498                 BUG_ON(!dev_data->ats.enabled);
3499
3500                 qdep  = dev_data->ats.qdep;
3501                 iommu = amd_iommu_rlookup_table[dev_data->devid];
3502
3503                 build_inv_iotlb_pasid(&cmd, dev_data->devid, pasid,
3504                                       qdep, address, size);
3505
3506                 ret = iommu_queue_command(iommu, &cmd);
3507                 if (ret != 0)
3508                         goto out;
3509         }
3510
3511         /* Wait until all device TLBs are flushed */
3512         domain_flush_complete(domain);
3513
3514         ret = 0;
3515
3516 out:
3517
3518         return ret;
3519 }
3520
3521 static int __amd_iommu_flush_page(struct protection_domain *domain, int pasid,
3522                                   u64 address)
3523 {
3524         INC_STATS_COUNTER(invalidate_iotlb);
3525
3526         return __flush_pasid(domain, pasid, address, false);
3527 }
3528
3529 int amd_iommu_flush_page(struct iommu_domain *dom, int pasid,
3530                          u64 address)
3531 {
3532         struct protection_domain *domain = dom->priv;
3533         unsigned long flags;
3534         int ret;
3535
3536         spin_lock_irqsave(&domain->lock, flags);
3537         ret = __amd_iommu_flush_page(domain, pasid, address);
3538         spin_unlock_irqrestore(&domain->lock, flags);
3539
3540         return ret;
3541 }
3542 EXPORT_SYMBOL(amd_iommu_flush_page);
3543
3544 static int __amd_iommu_flush_tlb(struct protection_domain *domain, int pasid)
3545 {
3546         INC_STATS_COUNTER(invalidate_iotlb_all);
3547
3548         return __flush_pasid(domain, pasid, CMD_INV_IOMMU_ALL_PAGES_ADDRESS,
3549                              true);
3550 }
3551
3552 int amd_iommu_flush_tlb(struct iommu_domain *dom, int pasid)
3553 {
3554         struct protection_domain *domain = dom->priv;
3555         unsigned long flags;
3556         int ret;
3557
3558         spin_lock_irqsave(&domain->lock, flags);
3559         ret = __amd_iommu_flush_tlb(domain, pasid);
3560         spin_unlock_irqrestore(&domain->lock, flags);
3561
3562         return ret;
3563 }
3564 EXPORT_SYMBOL(amd_iommu_flush_tlb);
3565
3566 static u64 *__get_gcr3_pte(u64 *root, int level, int pasid, bool alloc)
3567 {
3568         int index;
3569         u64 *pte;
3570
3571         while (true) {
3572
3573                 index = (pasid >> (9 * level)) & 0x1ff;
3574                 pte   = &root[index];
3575
3576                 if (level == 0)
3577                         break;
3578
3579                 if (!(*pte & GCR3_VALID)) {
3580                         if (!alloc)
3581                                 return NULL;
3582
3583                         root = (void *)get_zeroed_page(GFP_ATOMIC);
3584                         if (root == NULL)
3585                                 return NULL;
3586
3587                         *pte = __pa(root) | GCR3_VALID;
3588                 }
3589
3590                 root = __va(*pte & PAGE_MASK);
3591
3592                 level -= 1;
3593         }
3594
3595         return pte;
3596 }
3597
3598 static int __set_gcr3(struct protection_domain *domain, int pasid,
3599                       unsigned long cr3)
3600 {
3601         u64 *pte;
3602
3603         if (domain->mode != PAGE_MODE_NONE)
3604                 return -EINVAL;
3605
3606         pte = __get_gcr3_pte(domain->gcr3_tbl, domain->glx, pasid, true);
3607         if (pte == NULL)
3608                 return -ENOMEM;
3609
3610         *pte = (cr3 & PAGE_MASK) | GCR3_VALID;
3611
3612         return __amd_iommu_flush_tlb(domain, pasid);
3613 }
3614
3615 static int __clear_gcr3(struct protection_domain *domain, int pasid)
3616 {
3617         u64 *pte;
3618
3619         if (domain->mode != PAGE_MODE_NONE)
3620                 return -EINVAL;
3621
3622         pte = __get_gcr3_pte(domain->gcr3_tbl, domain->glx, pasid, false);
3623         if (pte == NULL)
3624                 return 0;
3625
3626         *pte = 0;
3627
3628         return __amd_iommu_flush_tlb(domain, pasid);
3629 }
3630
3631 int amd_iommu_domain_set_gcr3(struct iommu_domain *dom, int pasid,
3632                               unsigned long cr3)
3633 {
3634         struct protection_domain *domain = dom->priv;
3635         unsigned long flags;
3636         int ret;
3637
3638         spin_lock_irqsave(&domain->lock, flags);
3639         ret = __set_gcr3(domain, pasid, cr3);
3640         spin_unlock_irqrestore(&domain->lock, flags);
3641
3642         return ret;
3643 }
3644 EXPORT_SYMBOL(amd_iommu_domain_set_gcr3);
3645
3646 int amd_iommu_domain_clear_gcr3(struct iommu_domain *dom, int pasid)
3647 {
3648         struct protection_domain *domain = dom->priv;
3649         unsigned long flags;
3650         int ret;
3651
3652         spin_lock_irqsave(&domain->lock, flags);
3653         ret = __clear_gcr3(domain, pasid);
3654         spin_unlock_irqrestore(&domain->lock, flags);
3655
3656         return ret;
3657 }
3658 EXPORT_SYMBOL(amd_iommu_domain_clear_gcr3);
3659
3660 int amd_iommu_complete_ppr(struct pci_dev *pdev, int pasid,
3661                            int status, int tag)
3662 {
3663         struct iommu_dev_data *dev_data;
3664         struct amd_iommu *iommu;
3665         struct iommu_cmd cmd;
3666
3667         INC_STATS_COUNTER(complete_ppr);
3668
3669         dev_data = get_dev_data(&pdev->dev);
3670         iommu    = amd_iommu_rlookup_table[dev_data->devid];
3671
3672         build_complete_ppr(&cmd, dev_data->devid, pasid, status,
3673                            tag, dev_data->pri_tlp);
3674
3675         return iommu_queue_command(iommu, &cmd);
3676 }
3677 EXPORT_SYMBOL(amd_iommu_complete_ppr);
3678
3679 struct iommu_domain *amd_iommu_get_v2_domain(struct pci_dev *pdev)
3680 {
3681         struct protection_domain *domain;
3682
3683         domain = get_domain(&pdev->dev);
3684         if (IS_ERR(domain))
3685                 return NULL;
3686
3687         /* Only return IOMMUv2 domains */
3688         if (!(domain->flags & PD_IOMMUV2_MASK))
3689                 return NULL;
3690
3691         return domain->iommu_domain;
3692 }
3693 EXPORT_SYMBOL(amd_iommu_get_v2_domain);
3694
3695 void amd_iommu_enable_device_erratum(struct pci_dev *pdev, u32 erratum)
3696 {
3697         struct iommu_dev_data *dev_data;
3698
3699         if (!amd_iommu_v2_supported())
3700                 return;
3701
3702         dev_data = get_dev_data(&pdev->dev);
3703         dev_data->errata |= (1 << erratum);
3704 }
3705 EXPORT_SYMBOL(amd_iommu_enable_device_erratum);
3706
3707 int amd_iommu_device_info(struct pci_dev *pdev,
3708                           struct amd_iommu_device_info *info)
3709 {
3710         int max_pasids;
3711         int pos;
3712
3713         if (pdev == NULL || info == NULL)
3714                 return -EINVAL;
3715
3716         if (!amd_iommu_v2_supported())
3717                 return -EINVAL;
3718
3719         memset(info, 0, sizeof(*info));
3720
3721         pos = pci_find_ext_capability(pdev, PCI_EXT_CAP_ID_ATS);
3722         if (pos)
3723                 info->flags |= AMD_IOMMU_DEVICE_FLAG_ATS_SUP;
3724
3725         pos = pci_find_ext_capability(pdev, PCI_EXT_CAP_ID_PRI);
3726         if (pos)
3727                 info->flags |= AMD_IOMMU_DEVICE_FLAG_PRI_SUP;
3728
3729         pos = pci_find_ext_capability(pdev, PCI_EXT_CAP_ID_PASID);
3730         if (pos) {
3731                 int features;
3732
3733                 max_pasids = 1 << (9 * (amd_iommu_max_glx_val + 1));
3734                 max_pasids = min(max_pasids, (1 << 20));
3735
3736                 info->flags |= AMD_IOMMU_DEVICE_FLAG_PASID_SUP;
3737                 info->max_pasids = min(pci_max_pasids(pdev), max_pasids);
3738
3739                 features = pci_pasid_features(pdev);
3740                 if (features & PCI_PASID_CAP_EXEC)
3741                         info->flags |= AMD_IOMMU_DEVICE_FLAG_EXEC_SUP;
3742                 if (features & PCI_PASID_CAP_PRIV)
3743                         info->flags |= AMD_IOMMU_DEVICE_FLAG_PRIV_SUP;
3744         }
3745
3746         return 0;
3747 }
3748 EXPORT_SYMBOL(amd_iommu_device_info);