drivers/iommu/amd_iommu.c

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