arch/x86/kernel/amd_iommu.c

   1 /*
   2  * Copyright (C) 2007-2009 Advanced Micro Devices, Inc.
   3  * Author: Joerg Roedel <joerg.roedel@amd.com>
   4  *         Leo Duran <leo.duran@amd.com>
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License version 2 as published
   8  * by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  18  */
  19
  20 #include <linux/pci.h>
  21 #include <linux/gfp.h>
  22 #include <linux/bitops.h>
  23 #include <linux/debugfs.h>
  24 #include <linux/scatterlist.h>
  25 #include <linux/dma-mapping.h>
  26 #include <linux/iommu-helper.h>
  27 #include <linux/iommu.h>
  28 #include <asm/proto.h>
  29 #include <asm/iommu.h>
  30 #include <asm/gart.h>
  31 #include <asm/amd_iommu_proto.h>
  32 #include <asm/amd_iommu_types.h>
  33 #include <asm/amd_iommu.h>
  34
  35 #define CMD_SET_TYPE(cmd, t) ((cmd)->data[1] |= ((t) << 28))
  36
  37 #define EXIT_LOOP_COUNT 10000000
  38
  39 static DEFINE_RWLOCK(amd_iommu_devtable_lock);
  40
  41 /* A list of preallocated protection domains */
  42 static LIST_HEAD(iommu_pd_list);
  43 static DEFINE_SPINLOCK(iommu_pd_list_lock);
  44
  45 /*
  46  * Domain for untranslated devices - only allocated
  47  * if iommu=pt passed on kernel cmd line.
  48  */
  49 static struct protection_domain *pt_domain;
  50
  51 static struct iommu_ops amd_iommu_ops;
  52
  53 /*
  54  * general struct to manage commands send to an IOMMU
  55  */
  56 struct iommu_cmd {
  57         u32 data[4];
  58 };
  59
  60 static void reset_iommu_command_buffer(struct amd_iommu *iommu);
  61 static void update_domain(struct protection_domain *domain);
  62
  63 /****************************************************************************
  64  *
  65  * Helper functions
  66  *
  67  ****************************************************************************/
  68
  69 static inline u16 get_device_id(struct device *dev)
  70 {
  71         struct pci_dev *pdev = to_pci_dev(dev);
  72
  73         return calc_devid(pdev->bus->number, pdev->devfn);
  74 }
  75
  76 static struct iommu_dev_data *get_dev_data(struct device *dev)
  77 {
  78         return dev->archdata.iommu;
  79 }
  80
  81 /*
  82  * In this function the list of preallocated protection domains is traversed to
  83  * find the domain for a specific device
  84  */
  85 static struct dma_ops_domain *find_protection_domain(u16 devid)
  86 {
  87         struct dma_ops_domain *entry, *ret = NULL;
  88         unsigned long flags;
  89         u16 alias = amd_iommu_alias_table[devid];
  90
  91         if (list_empty(&iommu_pd_list))
  92                 return NULL;
  93
  94         spin_lock_irqsave(&iommu_pd_list_lock, flags);
  95
  96         list_for_each_entry(entry, &iommu_pd_list, list) {
  97                 if (entry->target_dev == devid ||
  98                     entry->target_dev == alias) {
  99                         ret = entry;
 100                         break;
 101                 }
 102         }
 103
 104         spin_unlock_irqrestore(&iommu_pd_list_lock, flags);
 105
 106         return ret;
 107 }
 108
 109 /*
 110  * This function checks if the driver got a valid device from the caller to
 111  * avoid dereferencing invalid pointers.
 112  */
 113 static bool check_device(struct device *dev)
 114 {
 115         u16 devid;
 116
 117         if (!dev || !dev->dma_mask)
 118                 return false;
 119
 120         /* No device or no PCI device */
 121         if (!dev || dev->bus != &pci_bus_type)
 122                 return false;
 123
 124         devid = get_device_id(dev);
 125
 126         /* Out of our scope? */
 127         if (devid > amd_iommu_last_bdf)
 128                 return false;
 129
 130         if (amd_iommu_rlookup_table[devid] == NULL)
 131                 return false;
 132
 133         return true;
 134 }
 135
 136 static int iommu_init_device(struct device *dev)
 137 {
 138         struct iommu_dev_data *dev_data;
 139         struct pci_dev *pdev;
 140         u16 devid, alias;
 141
 142         if (dev->archdata.iommu)
 143                 return 0;
 144
 145         dev_data = kzalloc(sizeof(*dev_data), GFP_KERNEL);
 146         if (!dev_data)
 147                 return -ENOMEM;
 148
 149         dev_data->dev = dev;
 150
 151         devid = get_device_id(dev);
 152         alias = amd_iommu_alias_table[devid];
 153         pdev = pci_get_bus_and_slot(PCI_BUS(alias), alias & 0xff);
 154         if (pdev)
 155                 dev_data->alias = &pdev->dev;
 156
 157         atomic_set(&dev_data->bind, 0);
 158
 159         dev->archdata.iommu = dev_data;
 160
 161
 162         return 0;
 163 }
 164
 165 static void iommu_uninit_device(struct device *dev)
 166 {
 167         kfree(dev->archdata.iommu);
 168 }
 169 #ifdef CONFIG_AMD_IOMMU_STATS
 170
 171 /*
 172  * Initialization code for statistics collection
 173  */
 174
 175 DECLARE_STATS_COUNTER(compl_wait);
 176 DECLARE_STATS_COUNTER(cnt_map_single);
 177 DECLARE_STATS_COUNTER(cnt_unmap_single);
 178 DECLARE_STATS_COUNTER(cnt_map_sg);
 179 DECLARE_STATS_COUNTER(cnt_unmap_sg);
 180 DECLARE_STATS_COUNTER(cnt_alloc_coherent);
 181 DECLARE_STATS_COUNTER(cnt_free_coherent);
 182 DECLARE_STATS_COUNTER(cross_page);
 183 DECLARE_STATS_COUNTER(domain_flush_single);
 184 DECLARE_STATS_COUNTER(domain_flush_all);
 185 DECLARE_STATS_COUNTER(alloced_io_mem);
 186 DECLARE_STATS_COUNTER(total_map_requests);
 187
 188 static struct dentry *stats_dir;
 189 static struct dentry *de_fflush;
 190
 191 static void amd_iommu_stats_add(struct __iommu_counter *cnt)
 192 {
 193         if (stats_dir == NULL)
 194                 return;
 195
 196         cnt->dent = debugfs_create_u64(cnt->name, 0444, stats_dir,
 197                                        &cnt->value);
 198 }
 199
 200 static void amd_iommu_stats_init(void)
 201 {
 202         stats_dir = debugfs_create_dir("amd-iommu", NULL);
 203         if (stats_dir == NULL)
 204                 return;
 205
 206         de_fflush  = debugfs_create_bool("fullflush", 0444, stats_dir,
 207                                          (u32 *)&amd_iommu_unmap_flush);
 208
 209         amd_iommu_stats_add(&compl_wait);
 210         amd_iommu_stats_add(&cnt_map_single);
 211         amd_iommu_stats_add(&cnt_unmap_single);
 212         amd_iommu_stats_add(&cnt_map_sg);
 213         amd_iommu_stats_add(&cnt_unmap_sg);
 214         amd_iommu_stats_add(&cnt_alloc_coherent);
 215         amd_iommu_stats_add(&cnt_free_coherent);
 216         amd_iommu_stats_add(&cross_page);
 217         amd_iommu_stats_add(&domain_flush_single);
 218         amd_iommu_stats_add(&domain_flush_all);
 219         amd_iommu_stats_add(&alloced_io_mem);
 220         amd_iommu_stats_add(&total_map_requests);
 221 }
 222
 223 #endif
 224
 225 /****************************************************************************
 226  *
 227  * Interrupt handling functions
 228  *
 229  ****************************************************************************/
 230
 231 static void dump_dte_entry(u16 devid)
 232 {
 233         int i;
 234
 235         for (i = 0; i < 8; ++i)
 236                 pr_err("AMD-Vi: DTE[%d]: %08x\n", i,
 237                         amd_iommu_dev_table[devid].data[i]);
 238 }
 239
 240 static void dump_command(unsigned long phys_addr)
 241 {
 242         struct iommu_cmd *cmd = phys_to_virt(phys_addr);
 243         int i;
 244
 245         for (i = 0; i < 4; ++i)
 246                 pr_err("AMD-Vi: CMD[%d]: %08x\n", i, cmd->data[i]);
 247 }
 248
 249 static void iommu_print_event(struct amd_iommu *iommu, void *__evt)
 250 {
 251         u32 *event = __evt;
 252         int type  = (event[1] >> EVENT_TYPE_SHIFT)  & EVENT_TYPE_MASK;
 253         int devid = (event[0] >> EVENT_DEVID_SHIFT) & EVENT_DEVID_MASK;
 254         int domid = (event[1] >> EVENT_DOMID_SHIFT) & EVENT_DOMID_MASK;
 255         int flags = (event[1] >> EVENT_FLAGS_SHIFT) & EVENT_FLAGS_MASK;
 256         u64 address = (u64)(((u64)event[3]) << 32) | event[2];
 257
 258         printk(KERN_ERR "AMD-Vi: Event logged [");
 259
 260         switch (type) {
 261         case EVENT_TYPE_ILL_DEV:
 262                 printk("ILLEGAL_DEV_TABLE_ENTRY device=%02x:%02x.%x "
 263                        "address=0x%016llx flags=0x%04x]\n",
 264                        PCI_BUS(devid), PCI_SLOT(devid), PCI_FUNC(devid),
 265                        address, flags);
 266                 dump_dte_entry(devid);
 267                 break;
 268         case EVENT_TYPE_IO_FAULT:
 269                 printk("IO_PAGE_FAULT device=%02x:%02x.%x "
 270                        "domain=0x%04x address=0x%016llx flags=0x%04x]\n",
 271                        PCI_BUS(devid), PCI_SLOT(devid), PCI_FUNC(devid),
 272                        domid, address, flags);
 273                 break;
 274         case EVENT_TYPE_DEV_TAB_ERR:
 275                 printk("DEV_TAB_HARDWARE_ERROR device=%02x:%02x.%x "
 276                        "address=0x%016llx flags=0x%04x]\n",
 277                        PCI_BUS(devid), PCI_SLOT(devid), PCI_FUNC(devid),
 278                        address, flags);
 279                 break;
 280         case EVENT_TYPE_PAGE_TAB_ERR:
 281                 printk("PAGE_TAB_HARDWARE_ERROR device=%02x:%02x.%x "
 282                        "domain=0x%04x address=0x%016llx flags=0x%04x]\n",
 283                        PCI_BUS(devid), PCI_SLOT(devid), PCI_FUNC(devid),
 284                        domid, address, flags);
 285                 break;
 286         case EVENT_TYPE_ILL_CMD:
 287                 printk("ILLEGAL_COMMAND_ERROR address=0x%016llx]\n", address);
 288                 reset_iommu_command_buffer(iommu);
 289                 dump_command(address);
 290                 break;
 291         case EVENT_TYPE_CMD_HARD_ERR:
 292                 printk("COMMAND_HARDWARE_ERROR address=0x%016llx "
 293                        "flags=0x%04x]\n", address, flags);
 294                 break;
 295         case EVENT_TYPE_IOTLB_INV_TO:
 296                 printk("IOTLB_INV_TIMEOUT device=%02x:%02x.%x "
 297                        "address=0x%016llx]\n",
 298                        PCI_BUS(devid), PCI_SLOT(devid), PCI_FUNC(devid),
 299                        address);
 300                 break;
 301         case EVENT_TYPE_INV_DEV_REQ:
 302                 printk("INVALID_DEVICE_REQUEST device=%02x:%02x.%x "
 303                        "address=0x%016llx flags=0x%04x]\n",
 304                        PCI_BUS(devid), PCI_SLOT(devid), PCI_FUNC(devid),
 305                        address, flags);
 306                 break;
 307         default:
 308                 printk(KERN_ERR "UNKNOWN type=0x%02x]\n", type);
 309         }
 310 }
 311
 312 static void iommu_poll_events(struct amd_iommu *iommu)
 313 {
 314         u32 head, tail;
 315         unsigned long flags;
 316
 317         spin_lock_irqsave(&iommu->lock, flags);
 318
 319         head = readl(iommu->mmio_base + MMIO_EVT_HEAD_OFFSET);
 320         tail = readl(iommu->mmio_base + MMIO_EVT_TAIL_OFFSET);
 321
 322         while (head != tail) {
 323                 iommu_print_event(iommu, iommu->evt_buf + head);
 324                 head = (head + EVENT_ENTRY_SIZE) % iommu->evt_buf_size;
 325         }
 326
 327         writel(head, iommu->mmio_base + MMIO_EVT_HEAD_OFFSET);
 328
 329         spin_unlock_irqrestore(&iommu->lock, flags);
 330 }
 331
 332 irqreturn_t amd_iommu_int_handler(int irq, void *data)
 333 {
 334         struct amd_iommu *iommu;
 335
 336         for_each_iommu(iommu)
 337                 iommu_poll_events(iommu);
 338
 339         return IRQ_HANDLED;
 340 }
 341
 342 /****************************************************************************
 343  *
 344  * IOMMU command queuing functions
 345  *
 346  ****************************************************************************/
 347
 348 /*
 349  * Writes the command to the IOMMUs command buffer and informs the
 350  * hardware about the new command. Must be called with iommu->lock held.
 351  */
 352 static int __iommu_queue_command(struct amd_iommu *iommu, struct iommu_cmd *cmd)
 353 {
 354         u32 tail, head;
 355         u8 *target;
 356
 357         tail = readl(iommu->mmio_base + MMIO_CMD_TAIL_OFFSET);
 358         target = iommu->cmd_buf + tail;
 359         memcpy_toio(target, cmd, sizeof(*cmd));
 360         tail = (tail + sizeof(*cmd)) % iommu->cmd_buf_size;
 361         head = readl(iommu->mmio_base + MMIO_CMD_HEAD_OFFSET);
 362         if (tail == head)
 363                 return -ENOMEM;
 364         writel(tail, iommu->mmio_base + MMIO_CMD_TAIL_OFFSET);
 365
 366         return 0;
 367 }
 368
 369 /*
 370  * General queuing function for commands. Takes iommu->lock and calls
 371  * __iommu_queue_command().
 372  */
 373 static int iommu_queue_command(struct amd_iommu *iommu, struct iommu_cmd *cmd)
 374 {
 375         unsigned long flags;
 376         int ret;
 377
 378         spin_lock_irqsave(&iommu->lock, flags);
 379         ret = __iommu_queue_command(iommu, cmd);
 380         if (!ret)
 381                 iommu->need_sync = true;
 382         spin_unlock_irqrestore(&iommu->lock, flags);
 383
 384         return ret;
 385 }
 386
 387 /*
 388  * This function waits until an IOMMU has completed a completion
 389  * wait command
 390  */
 391 static void __iommu_wait_for_completion(struct amd_iommu *iommu)
 392 {
 393         int ready = 0;
 394         unsigned status = 0;
 395         unsigned long i = 0;
 396
 397         INC_STATS_COUNTER(compl_wait);
 398
 399         while (!ready && (i < EXIT_LOOP_COUNT)) {
 400                 ++i;
 401                 /* wait for the bit to become one */
 402                 status = readl(iommu->mmio_base + MMIO_STATUS_OFFSET);
 403                 ready = status & MMIO_STATUS_COM_WAIT_INT_MASK;
 404         }
 405
 406         /* set bit back to zero */
 407         status &= ~MMIO_STATUS_COM_WAIT_INT_MASK;
 408         writel(status, iommu->mmio_base + MMIO_STATUS_OFFSET);
 409
 410         if (unlikely(i == EXIT_LOOP_COUNT)) {
 411                 spin_unlock(&iommu->lock);
 412                 reset_iommu_command_buffer(iommu);
 413                 spin_lock(&iommu->lock);
 414         }
 415 }
 416
 417 /*
 418  * This function queues a completion wait command into the command
 419  * buffer of an IOMMU
 420  */
 421 static int __iommu_completion_wait(struct amd_iommu *iommu)
 422 {
 423         struct iommu_cmd cmd;
 424
 425          memset(&cmd, 0, sizeof(cmd));
 426          cmd.data[0] = CMD_COMPL_WAIT_INT_MASK;
 427          CMD_SET_TYPE(&cmd, CMD_COMPL_WAIT);
 428
 429          return __iommu_queue_command(iommu, &cmd);
 430 }
 431
 432 /*
 433  * This function is called whenever we need to ensure that the IOMMU has
 434  * completed execution of all commands we sent. It sends a
 435  * COMPLETION_WAIT command and waits for it to finish. The IOMMU informs
 436  * us about that by writing a value to a physical address we pass with
 437  * the command.
 438  */
 439 static int iommu_completion_wait(struct amd_iommu *iommu)
 440 {
 441         int ret = 0;
 442         unsigned long flags;
 443
 444         spin_lock_irqsave(&iommu->lock, flags);
 445
 446         if (!iommu->need_sync)
 447                 goto out;
 448
 449         ret = __iommu_completion_wait(iommu);
 450
 451         iommu->need_sync = false;
 452
 453         if (ret)
 454                 goto out;
 455
 456         __iommu_wait_for_completion(iommu);
 457
 458 out:
 459         spin_unlock_irqrestore(&iommu->lock, flags);
 460
 461         return 0;
 462 }
 463
 464 static void iommu_flush_complete(struct protection_domain *domain)
 465 {
 466         int i;
 467
 468         for (i = 0; i < amd_iommus_present; ++i) {
 469                 if (!domain->dev_iommu[i])
 470                         continue;
 471
 472                 /*
 473                  * Devices of this domain are behind this IOMMU
 474                  * We need to wait for completion of all commands.
 475                  */
 476                 iommu_completion_wait(amd_iommus[i]);
 477         }
 478 }
 479
 480 /*
 481  * Command send function for invalidating a device table entry
 482  */
 483 static int iommu_flush_device(struct device *dev)
 484 {
 485         struct amd_iommu *iommu;
 486         struct iommu_cmd cmd;
 487         u16 devid;
 488
 489         devid = get_device_id(dev);
 490         iommu = amd_iommu_rlookup_table[devid];
 491
 492         /* Build command */
 493         memset(&cmd, 0, sizeof(cmd));
 494         CMD_SET_TYPE(&cmd, CMD_INV_DEV_ENTRY);
 495         cmd.data[0] = devid;
 496
 497         return iommu_queue_command(iommu, &cmd);
 498 }
 499
 500 static void __iommu_build_inv_iommu_pages(struct iommu_cmd *cmd, u64 address,
 501                                           u16 domid, int pde, int s)
 502 {
 503         memset(cmd, 0, sizeof(*cmd));
 504         address &= PAGE_MASK;
 505         CMD_SET_TYPE(cmd, CMD_INV_IOMMU_PAGES);
 506         cmd->data[1] |= domid;
 507         cmd->data[2] = lower_32_bits(address);
 508         cmd->data[3] = upper_32_bits(address);
 509         if (s) /* size bit - we flush more than one 4kb page */
 510                 cmd->data[2] |= CMD_INV_IOMMU_PAGES_SIZE_MASK;
 511         if (pde) /* PDE bit - we wan't flush everything not only the PTEs */
 512                 cmd->data[2] |= CMD_INV_IOMMU_PAGES_PDE_MASK;
 513 }
 514
 515 /*
 516  * Generic command send function for invalidaing TLB entries
 517  */
 518 static int iommu_queue_inv_iommu_pages(struct amd_iommu *iommu,
 519                 u64 address, u16 domid, int pde, int s)
 520 {
 521         struct iommu_cmd cmd;
 522         int ret;
 523
 524         __iommu_build_inv_iommu_pages(&cmd, address, domid, pde, s);
 525
 526         ret = iommu_queue_command(iommu, &cmd);
 527
 528         return ret;
 529 }
 530
 531 /*
 532  * TLB invalidation function which is called from the mapping functions.
 533  * It invalidates a single PTE if the range to flush is within a single
 534  * page. Otherwise it flushes the whole TLB of the IOMMU.
 535  */
 536 static void __iommu_flush_pages(struct protection_domain *domain,
 537                                 u64 address, size_t size, int pde)
 538 {
 539         int s = 0, i;
 540         unsigned long pages = iommu_num_pages(address, size, PAGE_SIZE);
 541
 542         address &= PAGE_MASK;
 543
 544         if (pages > 1) {
 545                 /*
 546                  * If we have to flush more than one page, flush all
 547                  * TLB entries for this domain
 548                  */
 549                 address = CMD_INV_IOMMU_ALL_PAGES_ADDRESS;
 550                 s = 1;
 551         }
 552
 553
 554         for (i = 0; i < amd_iommus_present; ++i) {
 555                 if (!domain->dev_iommu[i])
 556                         continue;
 557
 558                 /*
 559                  * Devices of this domain are behind this IOMMU
 560                  * We need a TLB flush
 561                  */
 562                 iommu_queue_inv_iommu_pages(amd_iommus[i], address,
 563                                             domain->id, pde, s);
 564         }
 565
 566         return;
 567 }
 568
 569 static void iommu_flush_pages(struct protection_domain *domain,
 570                              u64 address, size_t size)
 571 {
 572         __iommu_flush_pages(domain, address, size, 0);
 573 }
 574
 575 /* Flush the whole IO/TLB for a given protection domain */
 576 static void iommu_flush_tlb(struct protection_domain *domain)
 577 {
 578         __iommu_flush_pages(domain, 0, CMD_INV_IOMMU_ALL_PAGES_ADDRESS, 0);
 579 }
 580
 581 /* Flush the whole IO/TLB for a given protection domain - including PDE */
 582 static void iommu_flush_tlb_pde(struct protection_domain *domain)
 583 {
 584         __iommu_flush_pages(domain, 0, CMD_INV_IOMMU_ALL_PAGES_ADDRESS, 1);
 585 }
 586
 587
 588 /*
 589  * This function flushes the DTEs for all devices in domain
 590  */
 591 static void iommu_flush_domain_devices(struct protection_domain *domain)
 592 {
 593         struct iommu_dev_data *dev_data;
 594         unsigned long flags;
 595
 596         spin_lock_irqsave(&domain->lock, flags);
 597
 598         list_for_each_entry(dev_data, &domain->dev_list, list)
 599                 iommu_flush_device(dev_data->dev);
 600
 601         spin_unlock_irqrestore(&domain->lock, flags);
 602 }
 603
 604 static void iommu_flush_all_domain_devices(void)
 605 {
 606         struct protection_domain *domain;
 607         unsigned long flags;
 608
 609         spin_lock_irqsave(&amd_iommu_pd_lock, flags);
 610
 611         list_for_each_entry(domain, &amd_iommu_pd_list, list) {
 612                 iommu_flush_domain_devices(domain);
 613                 iommu_flush_complete(domain);
 614         }
 615
 616         spin_unlock_irqrestore(&amd_iommu_pd_lock, flags);
 617 }
 618
 619 void amd_iommu_flush_all_devices(void)
 620 {
 621         iommu_flush_all_domain_devices();
 622 }
 623
 624 /*
 625  * This function uses heavy locking and may disable irqs for some time. But
 626  * this is no issue because it is only called during resume.
 627  */
 628 void amd_iommu_flush_all_domains(void)
 629 {
 630         struct protection_domain *domain;
 631         unsigned long flags;
 632
 633         spin_lock_irqsave(&amd_iommu_pd_lock, flags);
 634
 635         list_for_each_entry(domain, &amd_iommu_pd_list, list) {
 636                 spin_lock(&domain->lock);
 637                 iommu_flush_tlb_pde(domain);
 638                 iommu_flush_complete(domain);
 639                 spin_unlock(&domain->lock);
 640         }
 641
 642         spin_unlock_irqrestore(&amd_iommu_pd_lock, flags);
 643 }
 644
 645 static void reset_iommu_command_buffer(struct amd_iommu *iommu)
 646 {
 647         pr_err("AMD-Vi: Resetting IOMMU command buffer\n");
 648
 649         if (iommu->reset_in_progress)
 650                 panic("AMD-Vi: ILLEGAL_COMMAND_ERROR while resetting command buffer\n");
 651
 652         iommu->reset_in_progress = true;
 653
 654         amd_iommu_reset_cmd_buffer(iommu);
 655         amd_iommu_flush_all_devices();
 656         amd_iommu_flush_all_domains();
 657
 658         iommu->reset_in_progress = false;
 659 }
 660
 661 /****************************************************************************
 662  *
 663  * The functions below are used the create the page table mappings for
 664  * unity mapped regions.
 665  *
 666  ****************************************************************************/
 667
 668 /*
 669  * This function is used to add another level to an IO page table. Adding
 670  * another level increases the size of the address space by 9 bits to a size up
 671  * to 64 bits.
 672  */
 673 static bool increase_address_space(struct protection_domain *domain,
 674                                    gfp_t gfp)
 675 {
 676         u64 *pte;
 677
 678         if (domain->mode == PAGE_MODE_6_LEVEL)
 679                 /* address space already 64 bit large */
 680                 return false;
 681
 682         pte = (void *)get_zeroed_page(gfp);
 683         if (!pte)
 684                 return false;
 685
 686         *pte             = PM_LEVEL_PDE(domain->mode,
 687                                         virt_to_phys(domain->pt_root));
 688         domain->pt_root  = pte;
 689         domain->mode    += 1;
 690         domain->updated  = true;
 691
 692         return true;
 693 }
 694
 695 static u64 *alloc_pte(struct protection_domain *domain,
 696                       unsigned long address,
 697                       int end_lvl,
 698                       u64 **pte_page,
 699                       gfp_t gfp)
 700 {
 701         u64 *pte, *page;
 702         int level;
 703
 704         while (address > PM_LEVEL_SIZE(domain->mode))
 705                 increase_address_space(domain, gfp);
 706
 707         level =  domain->mode - 1;
 708         pte   = &domain->pt_root[PM_LEVEL_INDEX(level, address)];
 709
 710         while (level > end_lvl) {
 711                 if (!IOMMU_PTE_PRESENT(*pte)) {
 712                         page = (u64 *)get_zeroed_page(gfp);
 713                         if (!page)
 714                                 return NULL;
 715                         *pte = PM_LEVEL_PDE(level, virt_to_phys(page));
 716                 }
 717
 718                 level -= 1;
 719
 720                 pte = IOMMU_PTE_PAGE(*pte);
 721
 722                 if (pte_page && level == end_lvl)
 723                         *pte_page = pte;
 724
 725                 pte = &pte[PM_LEVEL_INDEX(level, address)];
 726         }
 727
 728         return pte;
 729 }
 730
 731 /*
 732  * This function checks if there is a PTE for a given dma address. If
 733  * there is one, it returns the pointer to it.
 734  */
 735 static u64 *fetch_pte(struct protection_domain *domain,
 736                       unsigned long address, int map_size)
 737 {
 738         int level;
 739         u64 *pte;
 740
 741         level =  domain->mode - 1;
 742         pte   = &domain->pt_root[PM_LEVEL_INDEX(level, address)];
 743
 744         while (level > map_size) {
 745                 if (!IOMMU_PTE_PRESENT(*pte))
 746                         return NULL;
 747
 748                 level -= 1;
 749
 750                 pte = IOMMU_PTE_PAGE(*pte);
 751                 pte = &pte[PM_LEVEL_INDEX(level, address)];
 752
 753                 if ((PM_PTE_LEVEL(*pte) == 0) && level != map_size) {
 754                         pte = NULL;
 755                         break;
 756                 }
 757         }
 758
 759         return pte;
 760 }
 761
 762 /*
 763  * Generic mapping functions. It maps a physical address into a DMA
 764  * address space. It allocates the page table pages if necessary.
 765  * In the future it can be extended to a generic mapping function
 766  * supporting all features of AMD IOMMU page tables like level skipping
 767  * and full 64 bit address spaces.
 768  */
 769 static int iommu_map_page(struct protection_domain *dom,
 770                           unsigned long bus_addr,
 771                           unsigned long phys_addr,
 772                           int prot,
 773                           int map_size)
 774 {
 775         u64 __pte, *pte;
 776
 777         bus_addr  = PAGE_ALIGN(bus_addr);
 778         phys_addr = PAGE_ALIGN(phys_addr);
 779
 780         BUG_ON(!PM_ALIGNED(map_size, bus_addr));
 781         BUG_ON(!PM_ALIGNED(map_size, phys_addr));
 782
 783         if (!(prot & IOMMU_PROT_MASK))
 784                 return -EINVAL;
 785
 786         pte = alloc_pte(dom, bus_addr, map_size, NULL, GFP_KERNEL);
 787
 788         if (IOMMU_PTE_PRESENT(*pte))
 789                 return -EBUSY;
 790
 791         __pte = phys_addr | IOMMU_PTE_P;
 792         if (prot & IOMMU_PROT_IR)
 793                 __pte |= IOMMU_PTE_IR;
 794         if (prot & IOMMU_PROT_IW)
 795                 __pte |= IOMMU_PTE_IW;
 796
 797         *pte = __pte;
 798
 799         update_domain(dom);
 800
 801         return 0;
 802 }
 803
 804 static void iommu_unmap_page(struct protection_domain *dom,
 805                              unsigned long bus_addr, int map_size)
 806 {
 807         u64 *pte = fetch_pte(dom, bus_addr, map_size);
 808
 809         if (pte)
 810                 *pte = 0;
 811 }
 812
 813 /*
 814  * This function checks if a specific unity mapping entry is needed for
 815  * this specific IOMMU.
 816  */
 817 static int iommu_for_unity_map(struct amd_iommu *iommu,
 818                                struct unity_map_entry *entry)
 819 {
 820         u16 bdf, i;
 821
 822         for (i = entry->devid_start; i <= entry->devid_end; ++i) {
 823                 bdf = amd_iommu_alias_table[i];
 824                 if (amd_iommu_rlookup_table[bdf] == iommu)
 825                         return 1;
 826         }
 827
 828         return 0;
 829 }
 830
 831 /*
 832  * This function actually applies the mapping to the page table of the
 833  * dma_ops domain.
 834  */
 835 static int dma_ops_unity_map(struct dma_ops_domain *dma_dom,
 836                              struct unity_map_entry *e)
 837 {
 838         u64 addr;
 839         int ret;
 840
 841         for (addr = e->address_start; addr < e->address_end;
 842              addr += PAGE_SIZE) {
 843                 ret = iommu_map_page(&dma_dom->domain, addr, addr, e->prot,
 844                                      PM_MAP_4k);
 845                 if (ret)
 846                         return ret;
 847                 /*
 848                  * if unity mapping is in aperture range mark the page
 849                  * as allocated in the aperture
 850                  */
 851                 if (addr < dma_dom->aperture_size)
 852                         __set_bit(addr >> PAGE_SHIFT,
 853                                   dma_dom->aperture[0]->bitmap);
 854         }
 855
 856         return 0;
 857 }
 858
 859 /*
 860  * Init the unity mappings for a specific IOMMU in the system
 861  *
 862  * Basically iterates over all unity mapping entries and applies them to
 863  * the default domain DMA of that IOMMU if necessary.
 864  */
 865 static int iommu_init_unity_mappings(struct amd_iommu *iommu)
 866 {
 867         struct unity_map_entry *entry;
 868         int ret;
 869
 870         list_for_each_entry(entry, &amd_iommu_unity_map, list) {
 871                 if (!iommu_for_unity_map(iommu, entry))
 872                         continue;
 873                 ret = dma_ops_unity_map(iommu->default_dom, entry);
 874                 if (ret)
 875                         return ret;
 876         }
 877
 878         return 0;
 879 }
 880
 881 /*
 882  * Inits the unity mappings required for a specific device
 883  */
 884 static int init_unity_mappings_for_device(struct dma_ops_domain *dma_dom,
 885                                           u16 devid)
 886 {
 887         struct unity_map_entry *e;
 888         int ret;
 889
 890         list_for_each_entry(e, &amd_iommu_unity_map, list) {
 891                 if (!(devid >= e->devid_start && devid <= e->devid_end))
 892                         continue;
 893                 ret = dma_ops_unity_map(dma_dom, e);
 894                 if (ret)
 895                         return ret;
 896         }
 897
 898         return 0;
 899 }
 900
 901 /****************************************************************************
 902  *
 903  * The next functions belong to the address allocator for the dma_ops
 904  * interface functions. They work like the allocators in the other IOMMU
 905  * drivers. Its basically a bitmap which marks the allocated pages in
 906  * the aperture. Maybe it could be enhanced in the future to a more
 907  * efficient allocator.
 908  *
 909  ****************************************************************************/
 910
 911 /*
 912  * The address allocator core functions.
 913  *
 914  * called with domain->lock held
 915  */
 916
 917 /*
 918  * Used to reserve address ranges in the aperture (e.g. for exclusion
 919  * ranges.
 920  */
 921 static void dma_ops_reserve_addresses(struct dma_ops_domain *dom,
 922                                       unsigned long start_page,
 923                                       unsigned int pages)
 924 {
 925         unsigned int i, last_page = dom->aperture_size >> PAGE_SHIFT;
 926
 927         if (start_page + pages > last_page)
 928                 pages = last_page - start_page;
 929
 930         for (i = start_page; i < start_page + pages; ++i) {
 931                 int index = i / APERTURE_RANGE_PAGES;
 932                 int page  = i % APERTURE_RANGE_PAGES;
 933                 __set_bit(page, dom->aperture[index]->bitmap);
 934         }
 935 }
 936
 937 /*
 938  * This function is used to add a new aperture range to an existing
 939  * aperture in case of dma_ops domain allocation or address allocation
 940  * failure.
 941  */
 942 static int alloc_new_range(struct dma_ops_domain *dma_dom,
 943                            bool populate, gfp_t gfp)
 944 {
 945         int index = dma_dom->aperture_size >> APERTURE_RANGE_SHIFT;
 946         struct amd_iommu *iommu;
 947         int i;
 948
 949 #ifdef CONFIG_IOMMU_STRESS
 950         populate = false;
 951 #endif
 952
 953         if (index >= APERTURE_MAX_RANGES)
 954                 return -ENOMEM;
 955
 956         dma_dom->aperture[index] = kzalloc(sizeof(struct aperture_range), gfp);
 957         if (!dma_dom->aperture[index])
 958                 return -ENOMEM;
 959
 960         dma_dom->aperture[index]->bitmap = (void *)get_zeroed_page(gfp);
 961         if (!dma_dom->aperture[index]->bitmap)
 962                 goto out_free;
 963
 964         dma_dom->aperture[index]->offset = dma_dom->aperture_size;
 965
 966         if (populate) {
 967                 unsigned long address = dma_dom->aperture_size;
 968                 int i, num_ptes = APERTURE_RANGE_PAGES / 512;
 969                 u64 *pte, *pte_page;
 970
 971                 for (i = 0; i < num_ptes; ++i) {
 972                         pte = alloc_pte(&dma_dom->domain, address, PM_MAP_4k,
 973                                         &pte_page, gfp);
 974                         if (!pte)
 975                                 goto out_free;
 976
 977                         dma_dom->aperture[index]->pte_pages[i] = pte_page;
 978
 979                         address += APERTURE_RANGE_SIZE / 64;
 980                 }
 981         }
 982
 983         dma_dom->aperture_size += APERTURE_RANGE_SIZE;
 984
 985         /* Intialize the exclusion range if necessary */
 986         for_each_iommu(iommu) {
 987                 if (iommu->exclusion_start &&
 988                     iommu->exclusion_start >= dma_dom->aperture[index]->offset
 989                     && iommu->exclusion_start < dma_dom->aperture_size) {
 990                         unsigned long startpage;
 991                         int pages = iommu_num_pages(iommu->exclusion_start,
 992                                                     iommu->exclusion_length,
 993                                                     PAGE_SIZE);
 994                         startpage = iommu->exclusion_start >> PAGE_SHIFT;
 995                         dma_ops_reserve_addresses(dma_dom, startpage, pages);
 996                 }
 997         }
 998
 999         /*
1000          * Check for areas already mapped as present in the new aperture
1001          * range and mark those pages as reserved in the allocator. Such
1002          * mappings may already exist as a result of requested unity
1003          * mappings for devices.
1004          */
1005         for (i = dma_dom->aperture[index]->offset;
1006              i < dma_dom->aperture_size;
1007              i += PAGE_SIZE) {
1008                 u64 *pte = fetch_pte(&dma_dom->domain, i, PM_MAP_4k);
1009                 if (!pte || !IOMMU_PTE_PRESENT(*pte))
1010                         continue;
1011
1012                 dma_ops_reserve_addresses(dma_dom, i << PAGE_SHIFT, 1);
1013         }
1014
1015         update_domain(&dma_dom->domain);
1016
1017         return 0;
1018
1019 out_free:
1020         update_domain(&dma_dom->domain);
1021
1022         free_page((unsigned long)dma_dom->aperture[index]->bitmap);
1023
1024         kfree(dma_dom->aperture[index]);
1025         dma_dom->aperture[index] = NULL;
1026
1027         return -ENOMEM;
1028 }
1029
1030 static unsigned long dma_ops_area_alloc(struct device *dev,
1031                                         struct dma_ops_domain *dom,
1032                                         unsigned int pages,
1033                                         unsigned long align_mask,
1034                                         u64 dma_mask,
1035                                         unsigned long start)
1036 {
1037         unsigned long next_bit = dom->next_address % APERTURE_RANGE_SIZE;
1038         int max_index = dom->aperture_size >> APERTURE_RANGE_SHIFT;
1039         int i = start >> APERTURE_RANGE_SHIFT;
1040         unsigned long boundary_size;
1041         unsigned long address = -1;
1042         unsigned long limit;
1043
1044         next_bit >>= PAGE_SHIFT;
1045
1046         boundary_size = ALIGN(dma_get_seg_boundary(dev) + 1,
1047                         PAGE_SIZE) >> PAGE_SHIFT;
1048
1049         for (;i < max_index; ++i) {
1050                 unsigned long offset = dom->aperture[i]->offset >> PAGE_SHIFT;
1051
1052                 if (dom->aperture[i]->offset >= dma_mask)
1053                         break;
1054
1055                 limit = iommu_device_max_index(APERTURE_RANGE_PAGES, offset,
1056                                                dma_mask >> PAGE_SHIFT);
1057
1058                 address = iommu_area_alloc(dom->aperture[i]->bitmap,
1059                                            limit, next_bit, pages, 0,
1060                                             boundary_size, align_mask);
1061                 if (address != -1) {
1062                         address = dom->aperture[i]->offset +
1063                                   (address << PAGE_SHIFT);
1064                         dom->next_address = address + (pages << PAGE_SHIFT);
1065                         break;
1066                 }
1067
1068                 next_bit = 0;
1069         }
1070
1071         return address;
1072 }
1073
1074 static unsigned long dma_ops_alloc_addresses(struct device *dev,
1075                                              struct dma_ops_domain *dom,
1076                                              unsigned int pages,
1077                                              unsigned long align_mask,
1078                                              u64 dma_mask)
1079 {
1080         unsigned long address;
1081
1082 #ifdef CONFIG_IOMMU_STRESS
1083         dom->next_address = 0;
1084         dom->need_flush = true;
1085 #endif
1086
1087         address = dma_ops_area_alloc(dev, dom, pages, align_mask,
1088                                      dma_mask, dom->next_address);
1089
1090         if (address == -1) {
1091                 dom->next_address = 0;
1092                 address = dma_ops_area_alloc(dev, dom, pages, align_mask,
1093                                              dma_mask, 0);
1094                 dom->need_flush = true;
1095         }
1096
1097         if (unlikely(address == -1))
1098                 address = DMA_ERROR_CODE;
1099
1100         WARN_ON((address + (PAGE_SIZE*pages)) > dom->aperture_size);
1101
1102         return address;
1103 }
1104
1105 /*
1106  * The address free function.
1107  *
1108  * called with domain->lock held
1109  */
1110 static void dma_ops_free_addresses(struct dma_ops_domain *dom,
1111                                    unsigned long address,
1112                                    unsigned int pages)
1113 {
1114         unsigned i = address >> APERTURE_RANGE_SHIFT;
1115         struct aperture_range *range = dom->aperture[i];
1116
1117         BUG_ON(i >= APERTURE_MAX_RANGES || range == NULL);
1118
1119 #ifdef CONFIG_IOMMU_STRESS
1120         if (i < 4)
1121                 return;
1122 #endif
1123
1124         if (address >= dom->next_address)
1125                 dom->need_flush = true;
1126
1127         address = (address % APERTURE_RANGE_SIZE) >> PAGE_SHIFT;
1128
1129         iommu_area_free(range->bitmap, address, pages);
1130
1131 }
1132
1133 /****************************************************************************
1134  *
1135  * The next functions belong to the domain allocation. A domain is
1136  * allocated for every IOMMU as the default domain. If device isolation
1137  * is enabled, every device get its own domain. The most important thing
1138  * about domains is the page table mapping the DMA address space they
1139  * contain.
1140  *
1141  ****************************************************************************/
1142
1143 /*
1144  * This function adds a protection domain to the global protection domain list
1145  */
1146 static void add_domain_to_list(struct protection_domain *domain)
1147 {
1148         unsigned long flags;
1149
1150         spin_lock_irqsave(&amd_iommu_pd_lock, flags);
1151         list_add(&domain->list, &amd_iommu_pd_list);
1152         spin_unlock_irqrestore(&amd_iommu_pd_lock, flags);
1153 }
1154
1155 /*
1156  * This function removes a protection domain to the global
1157  * protection domain list
1158  */
1159 static void del_domain_from_list(struct protection_domain *domain)
1160 {
1161         unsigned long flags;
1162
1163         spin_lock_irqsave(&amd_iommu_pd_lock, flags);
1164         list_del(&domain->list);
1165         spin_unlock_irqrestore(&amd_iommu_pd_lock, flags);
1166 }
1167
1168 static u16 domain_id_alloc(void)
1169 {
1170         unsigned long flags;
1171         int id;
1172
1173         write_lock_irqsave(&amd_iommu_devtable_lock, flags);
1174         id = find_first_zero_bit(amd_iommu_pd_alloc_bitmap, MAX_DOMAIN_ID);
1175         BUG_ON(id == 0);
1176         if (id > 0 && id < MAX_DOMAIN_ID)
1177                 __set_bit(id, amd_iommu_pd_alloc_bitmap);
1178         else
1179                 id = 0;
1180         write_unlock_irqrestore(&amd_iommu_devtable_lock, flags);
1181
1182         return id;
1183 }
1184
1185 static void domain_id_free(int id)
1186 {
1187         unsigned long flags;
1188
1189         write_lock_irqsave(&amd_iommu_devtable_lock, flags);
1190         if (id > 0 && id < MAX_DOMAIN_ID)
1191                 __clear_bit(id, amd_iommu_pd_alloc_bitmap);
1192         write_unlock_irqrestore(&amd_iommu_devtable_lock, flags);
1193 }
1194
1195 static void free_pagetable(struct protection_domain *domain)
1196 {
1197         int i, j;
1198         u64 *p1, *p2, *p3;
1199
1200         p1 = domain->pt_root;
1201
1202         if (!p1)
1203                 return;
1204
1205         for (i = 0; i < 512; ++i) {
1206                 if (!IOMMU_PTE_PRESENT(p1[i]))
1207                         continue;
1208
1209                 p2 = IOMMU_PTE_PAGE(p1[i]);
1210                 for (j = 0; j < 512; ++j) {
1211                         if (!IOMMU_PTE_PRESENT(p2[j]))
1212                                 continue;
1213                         p3 = IOMMU_PTE_PAGE(p2[j]);
1214                         free_page((unsigned long)p3);
1215                 }
1216
1217                 free_page((unsigned long)p2);
1218         }
1219
1220         free_page((unsigned long)p1);
1221
1222         domain->pt_root = NULL;
1223 }
1224
1225 /*
1226  * Free a domain, only used if something went wrong in the
1227  * allocation path and we need to free an already allocated page table
1228  */
1229 static void dma_ops_domain_free(struct dma_ops_domain *dom)
1230 {
1231         int i;
1232
1233         if (!dom)
1234                 return;
1235
1236         del_domain_from_list(&dom->domain);
1237
1238         free_pagetable(&dom->domain);
1239
1240         for (i = 0; i < APERTURE_MAX_RANGES; ++i) {
1241                 if (!dom->aperture[i])
1242                         continue;
1243                 free_page((unsigned long)dom->aperture[i]->bitmap);
1244                 kfree(dom->aperture[i]);
1245         }
1246
1247         kfree(dom);
1248 }
1249
1250 /*
1251  * Allocates a new protection domain usable for the dma_ops functions.
1252  * It also intializes the page table and the address allocator data
1253  * structures required for the dma_ops interface
1254  */
1255 static struct dma_ops_domain *dma_ops_domain_alloc(void)
1256 {
1257         struct dma_ops_domain *dma_dom;
1258
1259         dma_dom = kzalloc(sizeof(struct dma_ops_domain), GFP_KERNEL);
1260         if (!dma_dom)
1261                 return NULL;
1262
1263         spin_lock_init(&dma_dom->domain.lock);
1264
1265         dma_dom->domain.id = domain_id_alloc();
1266         if (dma_dom->domain.id == 0)
1267                 goto free_dma_dom;
1268         INIT_LIST_HEAD(&dma_dom->domain.dev_list);
1269         dma_dom->domain.mode = PAGE_MODE_2_LEVEL;
1270         dma_dom->domain.pt_root = (void *)get_zeroed_page(GFP_KERNEL);
1271         dma_dom->domain.flags = PD_DMA_OPS_MASK;
1272         dma_dom->domain.priv = dma_dom;
1273         if (!dma_dom->domain.pt_root)
1274                 goto free_dma_dom;
1275
1276         dma_dom->need_flush = false;
1277         dma_dom->target_dev = 0xffff;
1278
1279         add_domain_to_list(&dma_dom->domain);
1280
1281         if (alloc_new_range(dma_dom, true, GFP_KERNEL))
1282                 goto free_dma_dom;
1283
1284         /*
1285          * mark the first page as allocated so we never return 0 as
1286          * a valid dma-address. So we can use 0 as error value
1287          */
1288         dma_dom->aperture[0]->bitmap[0] = 1;
1289         dma_dom->next_address = 0;
1290
1291
1292         return dma_dom;
1293
1294 free_dma_dom:
1295         dma_ops_domain_free(dma_dom);
1296
1297         return NULL;
1298 }
1299
1300 /*
1301  * little helper function to check whether a given protection domain is a
1302  * dma_ops domain
1303  */
1304 static bool dma_ops_domain(struct protection_domain *domain)
1305 {
1306         return domain->flags & PD_DMA_OPS_MASK;
1307 }
1308
1309 static void set_dte_entry(u16 devid, struct protection_domain *domain)
1310 {
1311         u64 pte_root = virt_to_phys(domain->pt_root);
1312
1313         BUG_ON(amd_iommu_pd_table[devid] != NULL);
1314
1315         pte_root |= (domain->mode & DEV_ENTRY_MODE_MASK)
1316                     << DEV_ENTRY_MODE_SHIFT;
1317         pte_root |= IOMMU_PTE_IR | IOMMU_PTE_IW | IOMMU_PTE_P | IOMMU_PTE_TV;
1318
1319         amd_iommu_dev_table[devid].data[2] = domain->id;
1320         amd_iommu_dev_table[devid].data[1] = upper_32_bits(pte_root);
1321         amd_iommu_dev_table[devid].data[0] = lower_32_bits(pte_root);
1322
1323         amd_iommu_pd_table[devid] = domain;
1324
1325 }
1326
1327 static void clear_dte_entry(u16 devid)
1328 {
1329         struct protection_domain *domain = amd_iommu_pd_table[devid];
1330
1331         BUG_ON(domain == NULL);
1332
1333         /* remove domain from the lookup table */
1334         amd_iommu_pd_table[devid] = NULL;
1335
1336         /* remove entry from the device table seen by the hardware */
1337         amd_iommu_dev_table[devid].data[0] = IOMMU_PTE_P | IOMMU_PTE_TV;
1338         amd_iommu_dev_table[devid].data[1] = 0;
1339         amd_iommu_dev_table[devid].data[2] = 0;
1340
1341         amd_iommu_apply_erratum_63(devid);
1342 }
1343
1344 static void do_attach(struct device *dev, struct protection_domain *domain)
1345 {
1346         struct iommu_dev_data *dev_data;
1347         struct amd_iommu *iommu;
1348         u16 devid;
1349
1350         devid    = get_device_id(dev);
1351         iommu    = amd_iommu_rlookup_table[devid];
1352         dev_data = get_dev_data(dev);
1353
1354         /* Update data structures */
1355         dev_data->domain = domain;
1356         list_add(&dev_data->list, &domain->dev_list);
1357         set_dte_entry(devid, domain);
1358
1359         /* Do reference counting */
1360         domain->dev_iommu[iommu->index] += 1;
1361         domain->dev_cnt                 += 1;
1362
1363         /* Flush the DTE entry */
1364         iommu_flush_device(dev);
1365 }
1366
1367 static void do_detach(struct device *dev)
1368 {
1369         struct iommu_dev_data *dev_data;
1370         struct amd_iommu *iommu;
1371         u16 devid;
1372
1373         devid    = get_device_id(dev);
1374         iommu    = amd_iommu_rlookup_table[devid];
1375         dev_data = get_dev_data(dev);
1376
1377         /* decrease reference counters */
1378         dev_data->domain->dev_iommu[iommu->index] -= 1;
1379         dev_data->domain->dev_cnt                 -= 1;
1380
1381         /* Update data structures */
1382         dev_data->domain = NULL;
1383         list_del(&dev_data->list);
1384         clear_dte_entry(devid);
1385
1386         /* Flush the DTE entry */
1387         iommu_flush_device(dev);
1388 }
1389
1390 /*
1391  * If a device is not yet associated with a domain, this function does
1392  * assigns it visible for the hardware
1393  */
1394 static int __attach_device(struct device *dev,
1395                            struct protection_domain *domain)
1396 {
1397         struct iommu_dev_data *dev_data, *alias_data;
1398
1399         dev_data   = get_dev_data(dev);
1400         alias_data = get_dev_data(dev_data->alias);
1401
1402         if (!alias_data)
1403                 return -EINVAL;
1404
1405         /* lock domain */
1406         spin_lock(&domain->lock);
1407
1408         /* Some sanity checks */
1409         if (alias_data->domain != NULL &&
1410             alias_data->domain != domain)
1411                 return -EBUSY;
1412
1413         if (dev_data->domain != NULL &&
1414             dev_data->domain != domain)
1415                 return -EBUSY;
1416
1417         /* Do real assignment */
1418         if (dev_data->alias != dev) {
1419                 alias_data = get_dev_data(dev_data->alias);
1420                 if (alias_data->domain == NULL)
1421                         do_attach(dev_data->alias, domain);
1422
1423                 atomic_inc(&alias_data->bind);
1424         }
1425
1426         if (dev_data->domain == NULL)
1427                 do_attach(dev, domain);
1428
1429         atomic_inc(&dev_data->bind);
1430
1431         /* ready */
1432         spin_unlock(&domain->lock);
1433
1434         return 0;
1435 }
1436
1437 /*
1438  * If a device is not yet associated with a domain, this function does
1439  * assigns it visible for the hardware
1440  */
1441 static int attach_device(struct device *dev,
1442                          struct protection_domain *domain)
1443 {
1444         unsigned long flags;
1445         int ret;
1446
1447         write_lock_irqsave(&amd_iommu_devtable_lock, flags);
1448         ret = __attach_device(dev, domain);
1449         write_unlock_irqrestore(&amd_iommu_devtable_lock, flags);
1450
1451         /*
1452          * We might boot into a crash-kernel here. The crashed kernel
1453          * left the caches in the IOMMU dirty. So we have to flush
1454          * here to evict all dirty stuff.
1455          */
1456         iommu_flush_tlb_pde(domain);
1457
1458         return ret;
1459 }
1460
1461 /*
1462  * Removes a device from a protection domain (unlocked)
1463  */
1464 static void __detach_device(struct device *dev)
1465 {
1466         struct iommu_dev_data *dev_data = get_dev_data(dev);
1467         struct iommu_dev_data *alias_data;
1468         unsigned long flags;
1469
1470         BUG_ON(!dev_data->domain);
1471
1472         spin_lock_irqsave(&dev_data->domain->lock, flags);
1473
1474         if (dev_data->alias != dev) {
1475                 alias_data = get_dev_data(dev_data->alias);
1476                 if (atomic_dec_and_test(&alias_data->bind))
1477                         do_detach(dev_data->alias);
1478         }
1479
1480         if (atomic_dec_and_test(&dev_data->bind))
1481                 do_detach(dev);
1482
1483         spin_unlock_irqrestore(&dev_data->domain->lock, flags);
1484
1485         /*
1486          * If we run in passthrough mode the device must be assigned to the
1487          * passthrough domain if it is detached from any other domain
1488          */
1489         if (iommu_pass_through && dev_data->domain == NULL)
1490                 __attach_device(dev, pt_domain);
1491 }
1492
1493 /*
1494  * Removes a device from a protection domain (with devtable_lock held)
1495  */
1496 static void detach_device(struct device *dev)
1497 {
1498         unsigned long flags;
1499
1500         /* lock device table */
1501         write_lock_irqsave(&amd_iommu_devtable_lock, flags);
1502         __detach_device(dev);
1503         write_unlock_irqrestore(&amd_iommu_devtable_lock, flags);
1504 }
1505
1506 /*
1507  * Find out the protection domain structure for a given PCI device. This
1508  * will give us the pointer to the page table root for example.
1509  */
1510 static struct protection_domain *domain_for_device(struct device *dev)
1511 {
1512         struct protection_domain *dom;
1513         struct iommu_dev_data *dev_data, *alias_data;
1514         unsigned long flags;
1515         u16 devid, alias;
1516
1517         devid      = get_device_id(dev);
1518         alias      = amd_iommu_alias_table[devid];
1519         dev_data   = get_dev_data(dev);
1520         alias_data = get_dev_data(dev_data->alias);
1521         if (!alias_data)
1522                 return NULL;
1523
1524         read_lock_irqsave(&amd_iommu_devtable_lock, flags);
1525         dom = dev_data->domain;
1526         if (dom == NULL &&
1527             alias_data->domain != NULL) {
1528                 __attach_device(dev, alias_data->domain);
1529                 dom = alias_data->domain;
1530         }
1531
1532         read_unlock_irqrestore(&amd_iommu_devtable_lock, flags);
1533
1534         return dom;
1535 }
1536
1537 static int device_change_notifier(struct notifier_block *nb,
1538                                   unsigned long action, void *data)
1539 {
1540         struct device *dev = data;
1541         u16 devid;
1542         struct protection_domain *domain;
1543         struct dma_ops_domain *dma_domain;
1544         struct amd_iommu *iommu;
1545         unsigned long flags;
1546
1547         if (!check_device(dev))
1548                 return 0;
1549
1550         devid  = get_device_id(dev);
1551         iommu  = amd_iommu_rlookup_table[devid];
1552
1553         switch (action) {
1554         case BUS_NOTIFY_UNBOUND_DRIVER:
1555
1556                 domain = domain_for_device(dev);
1557
1558                 if (!domain)
1559                         goto out;
1560                 if (iommu_pass_through)
1561                         break;
1562                 detach_device(dev);
1563                 break;
1564         case BUS_NOTIFY_ADD_DEVICE:
1565
1566                 iommu_init_device(dev);
1567
1568                 domain = domain_for_device(dev);
1569
1570                 /* allocate a protection domain if a device is added */
1571                 dma_domain = find_protection_domain(devid);
1572                 if (dma_domain)
1573                         goto out;
1574                 dma_domain = dma_ops_domain_alloc();
1575                 if (!dma_domain)
1576                         goto out;
1577                 dma_domain->target_dev = devid;
1578
1579                 spin_lock_irqsave(&iommu_pd_list_lock, flags);
1580                 list_add_tail(&dma_domain->list, &iommu_pd_list);
1581                 spin_unlock_irqrestore(&iommu_pd_list_lock, flags);
1582
1583                 break;
1584         case BUS_NOTIFY_DEL_DEVICE:
1585
1586                 iommu_uninit_device(dev);
1587
1588         default:
1589                 goto out;
1590         }
1591
1592         iommu_flush_device(dev);
1593         iommu_completion_wait(iommu);
1594
1595 out:
1596         return 0;
1597 }
1598
1599 static struct notifier_block device_nb = {
1600         .notifier_call = device_change_notifier,
1601 };
1602
1603 /*****************************************************************************
1604  *
1605  * The next functions belong to the dma_ops mapping/unmapping code.
1606  *
1607  *****************************************************************************/
1608
1609 /*
1610  * In the dma_ops path we only have the struct device. This function
1611  * finds the corresponding IOMMU, the protection domain and the
1612  * requestor id for a given device.
1613  * If the device is not yet associated with a domain this is also done
1614  * in this function.
1615  */
1616 static struct protection_domain *get_domain(struct device *dev)
1617 {
1618         struct protection_domain *domain;
1619         struct dma_ops_domain *dma_dom;
1620         u16 devid = get_device_id(dev);
1621
1622         if (!check_device(dev))
1623                 return ERR_PTR(-EINVAL);
1624
1625         domain = domain_for_device(dev);
1626         if (domain != NULL && !dma_ops_domain(domain))
1627                 return ERR_PTR(-EBUSY);
1628
1629         if (domain != NULL)
1630                 return domain;
1631
1632         /* Device not bount yet - bind it */
1633         dma_dom = find_protection_domain(devid);
1634         if (!dma_dom)
1635                 dma_dom = amd_iommu_rlookup_table[devid]->default_dom;
1636         attach_device(dev, &dma_dom->domain);
1637         DUMP_printk("Using protection domain %d for device %s\n",
1638                     dma_dom->domain.id, dev_name(dev));
1639
1640         return &dma_dom->domain;
1641 }
1642
1643 static void update_device_table(struct protection_domain *domain)
1644 {
1645         unsigned long flags;
1646         int i;
1647
1648         for (i = 0; i <= amd_iommu_last_bdf; ++i) {
1649                 if (amd_iommu_pd_table[i] != domain)
1650                         continue;
1651                 write_lock_irqsave(&amd_iommu_devtable_lock, flags);
1652                 set_dte_entry(i, domain);
1653                 write_unlock_irqrestore(&amd_iommu_devtable_lock, flags);
1654         }
1655 }
1656
1657 static void update_domain(struct protection_domain *domain)
1658 {
1659         if (!domain->updated)
1660                 return;
1661
1662         update_device_table(domain);
1663         iommu_flush_domain_devices(domain);
1664         iommu_flush_tlb_pde(domain);
1665
1666         domain->updated = false;
1667 }
1668
1669 /*
1670  * This function fetches the PTE for a given address in the aperture
1671  */
1672 static u64* dma_ops_get_pte(struct dma_ops_domain *dom,
1673                             unsigned long address)
1674 {
1675         struct aperture_range *aperture;
1676         u64 *pte, *pte_page;
1677
1678         aperture = dom->aperture[APERTURE_RANGE_INDEX(address)];
1679         if (!aperture)
1680                 return NULL;
1681
1682         pte = aperture->pte_pages[APERTURE_PAGE_INDEX(address)];
1683         if (!pte) {
1684                 pte = alloc_pte(&dom->domain, address, PM_MAP_4k, &pte_page,
1685                                 GFP_ATOMIC);
1686                 aperture->pte_pages[APERTURE_PAGE_INDEX(address)] = pte_page;
1687         } else
1688                 pte += PM_LEVEL_INDEX(0, address);
1689
1690         update_domain(&dom->domain);
1691
1692         return pte;
1693 }
1694
1695 /*
1696  * This is the generic map function. It maps one 4kb page at paddr to
1697  * the given address in the DMA address space for the domain.
1698  */
1699 static dma_addr_t dma_ops_domain_map(struct dma_ops_domain *dom,
1700                                      unsigned long address,
1701                                      phys_addr_t paddr,
1702                                      int direction)
1703 {
1704         u64 *pte, __pte;
1705
1706         WARN_ON(address > dom->aperture_size);
1707
1708         paddr &= PAGE_MASK;
1709
1710         pte  = dma_ops_get_pte(dom, address);
1711         if (!pte)
1712                 return DMA_ERROR_CODE;
1713
1714         __pte = paddr | IOMMU_PTE_P | IOMMU_PTE_FC;
1715
1716         if (direction == DMA_TO_DEVICE)
1717                 __pte |= IOMMU_PTE_IR;
1718         else if (direction == DMA_FROM_DEVICE)
1719                 __pte |= IOMMU_PTE_IW;
1720         else if (direction == DMA_BIDIRECTIONAL)
1721                 __pte |= IOMMU_PTE_IR | IOMMU_PTE_IW;
1722
1723         WARN_ON(*pte);
1724
1725         *pte = __pte;
1726
1727         return (dma_addr_t)address;
1728 }
1729
1730 /*
1731  * The generic unmapping function for on page in the DMA address space.
1732  */
1733 static void dma_ops_domain_unmap(struct dma_ops_domain *dom,
1734                                  unsigned long address)
1735 {
1736         struct aperture_range *aperture;
1737         u64 *pte;
1738
1739         if (address >= dom->aperture_size)
1740                 return;
1741
1742         aperture = dom->aperture[APERTURE_RANGE_INDEX(address)];
1743         if (!aperture)
1744                 return;
1745
1746         pte  = aperture->pte_pages[APERTURE_PAGE_INDEX(address)];
1747         if (!pte)
1748                 return;
1749
1750         pte += PM_LEVEL_INDEX(0, address);
1751
1752         WARN_ON(!*pte);
1753
1754         *pte = 0ULL;
1755 }
1756
1757 /*
1758  * This function contains common code for mapping of a physically
1759  * contiguous memory region into DMA address space. It is used by all
1760  * mapping functions provided with this IOMMU driver.
1761  * Must be called with the domain lock held.
1762  */
1763 static dma_addr_t __map_single(struct device *dev,
1764                                struct dma_ops_domain *dma_dom,
1765                                phys_addr_t paddr,
1766                                size_t size,
1767                                int dir,
1768                                bool align,
1769                                u64 dma_mask)
1770 {
1771         dma_addr_t offset = paddr & ~PAGE_MASK;
1772         dma_addr_t address, start, ret;
1773         unsigned int pages;
1774         unsigned long align_mask = 0;
1775         int i;
1776
1777         pages = iommu_num_pages(paddr, size, PAGE_SIZE);
1778         paddr &= PAGE_MASK;
1779
1780         INC_STATS_COUNTER(total_map_requests);
1781
1782         if (pages > 1)
1783                 INC_STATS_COUNTER(cross_page);
1784
1785         if (align)
1786                 align_mask = (1UL << get_order(size)) - 1;
1787
1788 retry:
1789         address = dma_ops_alloc_addresses(dev, dma_dom, pages, align_mask,
1790                                           dma_mask);
1791         if (unlikely(address == DMA_ERROR_CODE)) {
1792                 /*
1793                  * setting next_address here will let the address
1794                  * allocator only scan the new allocated range in the
1795                  * first run. This is a small optimization.
1796                  */
1797                 dma_dom->next_address = dma_dom->aperture_size;
1798
1799                 if (alloc_new_range(dma_dom, false, GFP_ATOMIC))
1800                         goto out;
1801
1802                 /*
1803                  * aperture was sucessfully enlarged by 128 MB, try
1804                  * allocation again
1805                  */
1806                 goto retry;
1807         }
1808
1809         start = address;
1810         for (i = 0; i < pages; ++i) {
1811                 ret = dma_ops_domain_map(dma_dom, start, paddr, dir);
1812                 if (ret == DMA_ERROR_CODE)
1813                         goto out_unmap;
1814
1815                 paddr += PAGE_SIZE;
1816                 start += PAGE_SIZE;
1817         }
1818         address += offset;
1819
1820         ADD_STATS_COUNTER(alloced_io_mem, size);
1821
1822         if (unlikely(dma_dom->need_flush && !amd_iommu_unmap_flush)) {
1823                 iommu_flush_tlb(&dma_dom->domain);
1824                 dma_dom->need_flush = false;
1825         } else if (unlikely(amd_iommu_np_cache))
1826                 iommu_flush_pages(&dma_dom->domain, address, size);
1827
1828 out:
1829         return address;
1830
1831 out_unmap:
1832
1833         for (--i; i >= 0; --i) {
1834                 start -= PAGE_SIZE;
1835                 dma_ops_domain_unmap(dma_dom, start);
1836         }
1837
1838         dma_ops_free_addresses(dma_dom, address, pages);
1839
1840         return DMA_ERROR_CODE;
1841 }
1842
1843 /*
1844  * Does the reverse of the __map_single function. Must be called with
1845  * the domain lock held too
1846  */
1847 static void __unmap_single(struct dma_ops_domain *dma_dom,
1848                            dma_addr_t dma_addr,
1849                            size_t size,
1850                            int dir)
1851 {
1852         dma_addr_t i, start;
1853         unsigned int pages;
1854
1855         if ((dma_addr == DMA_ERROR_CODE) ||
1856             (dma_addr + size > dma_dom->aperture_size))
1857                 return;
1858
1859         pages = iommu_num_pages(dma_addr, size, PAGE_SIZE);
1860         dma_addr &= PAGE_MASK;
1861         start = dma_addr;
1862
1863         for (i = 0; i < pages; ++i) {
1864                 dma_ops_domain_unmap(dma_dom, start);
1865                 start += PAGE_SIZE;
1866         }
1867
1868         SUB_STATS_COUNTER(alloced_io_mem, size);
1869
1870         dma_ops_free_addresses(dma_dom, dma_addr, pages);
1871
1872         if (amd_iommu_unmap_flush || dma_dom->need_flush) {
1873                 iommu_flush_pages(&dma_dom->domain, dma_addr, size);
1874                 dma_dom->need_flush = false;
1875         }
1876 }
1877
1878 /*
1879  * The exported map_single function for dma_ops.
1880  */
1881 static dma_addr_t map_page(struct device *dev, struct page *page,
1882                            unsigned long offset, size_t size,
1883                            enum dma_data_direction dir,
1884                            struct dma_attrs *attrs)
1885 {
1886         unsigned long flags;
1887         struct protection_domain *domain;
1888         dma_addr_t addr;
1889         u64 dma_mask;
1890         phys_addr_t paddr = page_to_phys(page) + offset;
1891
1892         INC_STATS_COUNTER(cnt_map_single);
1893
1894         domain = get_domain(dev);
1895         if (PTR_ERR(domain) == -EINVAL)
1896                 return (dma_addr_t)paddr;
1897         else if (IS_ERR(domain))
1898                 return DMA_ERROR_CODE;
1899
1900         dma_mask = *dev->dma_mask;
1901
1902         spin_lock_irqsave(&domain->lock, flags);
1903
1904         addr = __map_single(dev, domain->priv, paddr, size, dir, false,
1905                             dma_mask);
1906         if (addr == DMA_ERROR_CODE)
1907                 goto out;
1908
1909         iommu_flush_complete(domain);
1910
1911 out:
1912         spin_unlock_irqrestore(&domain->lock, flags);
1913
1914         return addr;
1915 }
1916
1917 /*
1918  * The exported unmap_single function for dma_ops.
1919  */
1920 static void unmap_page(struct device *dev, dma_addr_t dma_addr, size_t size,
1921                        enum dma_data_direction dir, struct dma_attrs *attrs)
1922 {
1923         unsigned long flags;
1924         struct protection_domain *domain;
1925
1926         INC_STATS_COUNTER(cnt_unmap_single);
1927
1928         domain = get_domain(dev);
1929         if (IS_ERR(domain))
1930                 return;
1931
1932         spin_lock_irqsave(&domain->lock, flags);
1933
1934         __unmap_single(domain->priv, dma_addr, size, dir);
1935
1936         iommu_flush_complete(domain);
1937
1938         spin_unlock_irqrestore(&domain->lock, flags);
1939 }
1940
1941 /*
1942  * This is a special map_sg function which is used if we should map a
1943  * device which is not handled by an AMD IOMMU in the system.
1944  */
1945 static int map_sg_no_iommu(struct device *dev, struct scatterlist *sglist,
1946                            int nelems, int dir)
1947 {
1948         struct scatterlist *s;
1949         int i;
1950
1951         for_each_sg(sglist, s, nelems, i) {
1952                 s->dma_address = (dma_addr_t)sg_phys(s);
1953                 s->dma_length  = s->length;
1954         }
1955
1956         return nelems;
1957 }
1958
1959 /*
1960  * The exported map_sg function for dma_ops (handles scatter-gather
1961  * lists).
1962  */
1963 static int map_sg(struct device *dev, struct scatterlist *sglist,
1964                   int nelems, enum dma_data_direction dir,
1965                   struct dma_attrs *attrs)
1966 {
1967         unsigned long flags;
1968         struct protection_domain *domain;
1969         int i;
1970         struct scatterlist *s;
1971         phys_addr_t paddr;
1972         int mapped_elems = 0;
1973         u64 dma_mask;
1974
1975         INC_STATS_COUNTER(cnt_map_sg);
1976
1977         domain = get_domain(dev);
1978         if (PTR_ERR(domain) == -EINVAL)
1979                 return map_sg_no_iommu(dev, sglist, nelems, dir);
1980         else if (IS_ERR(domain))
1981                 return 0;
1982
1983         dma_mask = *dev->dma_mask;
1984
1985         spin_lock_irqsave(&domain->lock, flags);
1986
1987         for_each_sg(sglist, s, nelems, i) {
1988                 paddr = sg_phys(s);
1989
1990                 s->dma_address = __map_single(dev, domain->priv,
1991                                               paddr, s->length, dir, false,
1992                                               dma_mask);
1993
1994                 if (s->dma_address) {
1995                         s->dma_length = s->length;
1996                         mapped_elems++;
1997                 } else
1998                         goto unmap;
1999         }
2000
2001         iommu_flush_complete(domain);
2002
2003 out:
2004         spin_unlock_irqrestore(&domain->lock, flags);
2005
2006         return mapped_elems;
2007 unmap:
2008         for_each_sg(sglist, s, mapped_elems, i) {
2009                 if (s->dma_address)
2010                         __unmap_single(domain->priv, s->dma_address,
2011                                        s->dma_length, dir);
2012                 s->dma_address = s->dma_length = 0;
2013         }
2014
2015         mapped_elems = 0;
2016
2017         goto out;
2018 }
2019
2020 /*
2021  * The exported map_sg function for dma_ops (handles scatter-gather
2022  * lists).
2023  */
2024 static void unmap_sg(struct device *dev, struct scatterlist *sglist,
2025                      int nelems, enum dma_data_direction dir,
2026                      struct dma_attrs *attrs)
2027 {
2028         unsigned long flags;
2029         struct protection_domain *domain;
2030         struct scatterlist *s;
2031         int i;
2032
2033         INC_STATS_COUNTER(cnt_unmap_sg);
2034
2035         domain = get_domain(dev);
2036         if (IS_ERR(domain))
2037                 return;
2038
2039         spin_lock_irqsave(&domain->lock, flags);
2040
2041         for_each_sg(sglist, s, nelems, i) {
2042                 __unmap_single(domain->priv, s->dma_address,
2043                                s->dma_length, dir);
2044                 s->dma_address = s->dma_length = 0;
2045         }
2046
2047         iommu_flush_complete(domain);
2048
2049         spin_unlock_irqrestore(&domain->lock, flags);
2050 }
2051
2052 /*
2053  * The exported alloc_coherent function for dma_ops.
2054  */
2055 static void *alloc_coherent(struct device *dev, size_t size,
2056                             dma_addr_t *dma_addr, gfp_t flag)
2057 {
2058         unsigned long flags;
2059         void *virt_addr;
2060         struct protection_domain *domain;
2061         phys_addr_t paddr;
2062         u64 dma_mask = dev->coherent_dma_mask;
2063
2064         INC_STATS_COUNTER(cnt_alloc_coherent);
2065
2066         domain = get_domain(dev);
2067         if (PTR_ERR(domain) == -EINVAL) {
2068                 virt_addr = (void *)__get_free_pages(flag, get_order(size));
2069                 *dma_addr = __pa(virt_addr);
2070                 return virt_addr;
2071         } else if (IS_ERR(domain))
2072                 return NULL;
2073
2074         dma_mask  = dev->coherent_dma_mask;
2075         flag     &= ~(__GFP_DMA | __GFP_HIGHMEM | __GFP_DMA32);
2076         flag     |= __GFP_ZERO;
2077
2078         virt_addr = (void *)__get_free_pages(flag, get_order(size));
2079         if (!virt_addr)
2080                 return NULL;
2081
2082         paddr = virt_to_phys(virt_addr);
2083
2084         if (!dma_mask)
2085                 dma_mask = *dev->dma_mask;
2086
2087         spin_lock_irqsave(&domain->lock, flags);
2088
2089         *dma_addr = __map_single(dev, domain->priv, paddr,
2090                                  size, DMA_BIDIRECTIONAL, true, dma_mask);
2091
2092         if (*dma_addr == DMA_ERROR_CODE) {
2093                 spin_unlock_irqrestore(&domain->lock, flags);
2094                 goto out_free;
2095         }
2096
2097         iommu_flush_complete(domain);
2098
2099         spin_unlock_irqrestore(&domain->lock, flags);
2100
2101         return virt_addr;
2102
2103 out_free:
2104
2105         free_pages((unsigned long)virt_addr, get_order(size));
2106
2107         return NULL;
2108 }
2109
2110 /*
2111  * The exported free_coherent function for dma_ops.
2112  */
2113 static void free_coherent(struct device *dev, size_t size,
2114                           void *virt_addr, dma_addr_t dma_addr)
2115 {
2116         unsigned long flags;
2117         struct protection_domain *domain;
2118
2119         INC_STATS_COUNTER(cnt_free_coherent);
2120
2121         domain = get_domain(dev);
2122         if (IS_ERR(domain))
2123                 goto free_mem;
2124
2125         spin_lock_irqsave(&domain->lock, flags);
2126
2127         __unmap_single(domain->priv, dma_addr, size, DMA_BIDIRECTIONAL);
2128
2129         iommu_flush_complete(domain);
2130
2131         spin_unlock_irqrestore(&domain->lock, flags);
2132
2133 free_mem:
2134         free_pages((unsigned long)virt_addr, get_order(size));
2135 }
2136
2137 /*
2138  * This function is called by the DMA layer to find out if we can handle a
2139  * particular device. It is part of the dma_ops.
2140  */
2141 static int amd_iommu_dma_supported(struct device *dev, u64 mask)
2142 {
2143         return check_device(dev);
2144 }
2145
2146 /*
2147  * The function for pre-allocating protection domains.
2148  *
2149  * If the driver core informs the DMA layer if a driver grabs a device
2150  * we don't need to preallocate the protection domains anymore.
2151  * For now we have to.
2152  */
2153 static void prealloc_protection_domains(void)
2154 {
2155         struct pci_dev *dev = NULL;
2156         struct dma_ops_domain *dma_dom;
2157         u16 devid;
2158
2159         while ((dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, dev)) != NULL) {
2160
2161                 /* Do we handle this device? */
2162                 if (!check_device(&dev->dev))
2163                         continue;
2164
2165                 iommu_init_device(&dev->dev);
2166
2167                 /* Is there already any domain for it? */
2168                 if (domain_for_device(&dev->dev))
2169                         continue;
2170
2171                 devid = get_device_id(&dev->dev);
2172
2173                 dma_dom = dma_ops_domain_alloc();
2174                 if (!dma_dom)
2175                         continue;
2176                 init_unity_mappings_for_device(dma_dom, devid);
2177                 dma_dom->target_dev = devid;
2178
2179                 attach_device(&dev->dev, &dma_dom->domain);
2180
2181                 list_add_tail(&dma_dom->list, &iommu_pd_list);
2182         }
2183 }
2184
2185 static struct dma_map_ops amd_iommu_dma_ops = {
2186         .alloc_coherent = alloc_coherent,
2187         .free_coherent = free_coherent,
2188         .map_page = map_page,
2189         .unmap_page = unmap_page,
2190         .map_sg = map_sg,
2191         .unmap_sg = unmap_sg,
2192         .dma_supported = amd_iommu_dma_supported,
2193 };
2194
2195 /*
2196  * The function which clues the AMD IOMMU driver into dma_ops.
2197  */
2198 int __init amd_iommu_init_dma_ops(void)
2199 {
2200         struct amd_iommu *iommu;
2201         int ret;
2202
2203         /*
2204          * first allocate a default protection domain for every IOMMU we
2205          * found in the system. Devices not assigned to any other
2206          * protection domain will be assigned to the default one.
2207          */
2208         for_each_iommu(iommu) {
2209                 iommu->default_dom = dma_ops_domain_alloc();
2210                 if (iommu->default_dom == NULL)
2211                         return -ENOMEM;
2212                 iommu->default_dom->domain.flags |= PD_DEFAULT_MASK;
2213                 ret = iommu_init_unity_mappings(iommu);
2214                 if (ret)
2215                         goto free_domains;
2216         }
2217
2218         /*
2219          * Pre-allocate the protection domains for each device.
2220          */
2221         prealloc_protection_domains();
2222
2223         iommu_detected = 1;
2224         swiotlb = 0;
2225 #ifdef CONFIG_GART_IOMMU
2226         gart_iommu_aperture_disabled = 1;
2227         gart_iommu_aperture = 0;
2228 #endif
2229
2230         /* Make the driver finally visible to the drivers */
2231         dma_ops = &amd_iommu_dma_ops;
2232
2233         register_iommu(&amd_iommu_ops);
2234
2235         bus_register_notifier(&pci_bus_type, &device_nb);
2236
2237         amd_iommu_stats_init();
2238
2239         return 0;
2240
2241 free_domains:
2242
2243         for_each_iommu(iommu) {
2244                 if (iommu->default_dom)
2245                         dma_ops_domain_free(iommu->default_dom);
2246         }
2247
2248         return ret;
2249 }
2250
2251 /*****************************************************************************
2252  *
2253  * The following functions belong to the exported interface of AMD IOMMU
2254  *
2255  * This interface allows access to lower level functions of the IOMMU
2256  * like protection domain handling and assignement of devices to domains
2257  * which is not possible with the dma_ops interface.
2258  *
2259  *****************************************************************************/
2260
2261 static void cleanup_domain(struct protection_domain *domain)
2262 {
2263         unsigned long flags;
2264         u16 devid;
2265
2266         write_lock_irqsave(&amd_iommu_devtable_lock, flags);
2267
2268         for (devid = 0; devid <= amd_iommu_last_bdf; ++devid)
2269                 if (amd_iommu_pd_table[devid] == domain)
2270                         clear_dte_entry(devid);
2271
2272         write_unlock_irqrestore(&amd_iommu_devtable_lock, flags);
2273 }
2274
2275 static void protection_domain_free(struct protection_domain *domain)
2276 {
2277         if (!domain)
2278                 return;
2279
2280         del_domain_from_list(domain);
2281
2282         if (domain->id)
2283                 domain_id_free(domain->id);
2284
2285         kfree(domain);
2286 }
2287
2288 static struct protection_domain *protection_domain_alloc(void)
2289 {
2290         struct protection_domain *domain;
2291
2292         domain = kzalloc(sizeof(*domain), GFP_KERNEL);
2293         if (!domain)
2294                 return NULL;
2295
2296         spin_lock_init(&domain->lock);
2297         domain->id = domain_id_alloc();
2298         if (!domain->id)
2299                 goto out_err;
2300         INIT_LIST_HEAD(&domain->dev_list);
2301
2302         add_domain_to_list(domain);
2303
2304         return domain;
2305
2306 out_err:
2307         kfree(domain);
2308
2309         return NULL;
2310 }
2311
2312 static int amd_iommu_domain_init(struct iommu_domain *dom)
2313 {
2314         struct protection_domain *domain;
2315
2316         domain = protection_domain_alloc();
2317         if (!domain)
2318                 goto out_free;
2319
2320         domain->mode    = PAGE_MODE_3_LEVEL;
2321         domain->pt_root = (void *)get_zeroed_page(GFP_KERNEL);
2322         if (!domain->pt_root)
2323                 goto out_free;
2324
2325         dom->priv = domain;
2326
2327         return 0;
2328
2329 out_free:
2330         protection_domain_free(domain);
2331
2332         return -ENOMEM;
2333 }
2334
2335 static void amd_iommu_domain_destroy(struct iommu_domain *dom)
2336 {
2337         struct protection_domain *domain = dom->priv;
2338
2339         if (!domain)
2340                 return;
2341
2342         if (domain->dev_cnt > 0)
2343                 cleanup_domain(domain);
2344
2345         BUG_ON(domain->dev_cnt != 0);
2346
2347         free_pagetable(domain);
2348
2349         domain_id_free(domain->id);
2350
2351         kfree(domain);
2352
2353         dom->priv = NULL;
2354 }
2355
2356 static void amd_iommu_detach_device(struct iommu_domain *dom,
2357                                     struct device *dev)
2358 {
2359         struct iommu_dev_data *dev_data = dev->archdata.iommu;
2360         struct amd_iommu *iommu;
2361         u16 devid;
2362
2363         if (!check_device(dev))
2364                 return;
2365
2366         devid = get_device_id(dev);
2367
2368         if (dev_data->domain != NULL)
2369                 detach_device(dev);
2370
2371         iommu = amd_iommu_rlookup_table[devid];
2372         if (!iommu)
2373                 return;
2374
2375         iommu_flush_device(dev);
2376         iommu_completion_wait(iommu);
2377 }
2378
2379 static int amd_iommu_attach_device(struct iommu_domain *dom,
2380                                    struct device *dev)
2381 {
2382         struct protection_domain *domain = dom->priv;
2383         struct iommu_dev_data *dev_data;
2384         struct amd_iommu *iommu;
2385         int ret;
2386         u16 devid;
2387
2388         if (!check_device(dev))
2389                 return -EINVAL;
2390
2391         dev_data = dev->archdata.iommu;
2392
2393         devid = get_device_id(dev);
2394
2395         iommu = amd_iommu_rlookup_table[devid];
2396         if (!iommu)
2397                 return -EINVAL;
2398
2399         if (dev_data->domain)
2400                 detach_device(dev);
2401
2402         ret = attach_device(dev, domain);
2403
2404         iommu_completion_wait(iommu);
2405
2406         return ret;
2407 }
2408
2409 static int amd_iommu_map_range(struct iommu_domain *dom,
2410                                unsigned long iova, phys_addr_t paddr,
2411                                size_t size, int iommu_prot)
2412 {
2413         struct protection_domain *domain = dom->priv;
2414         unsigned long i,  npages = iommu_num_pages(paddr, size, PAGE_SIZE);
2415         int prot = 0;
2416         int ret;
2417
2418         if (iommu_prot & IOMMU_READ)
2419                 prot |= IOMMU_PROT_IR;
2420         if (iommu_prot & IOMMU_WRITE)
2421                 prot |= IOMMU_PROT_IW;
2422
2423         iova  &= PAGE_MASK;
2424         paddr &= PAGE_MASK;
2425
2426         for (i = 0; i < npages; ++i) {
2427                 ret = iommu_map_page(domain, iova, paddr, prot, PM_MAP_4k);
2428                 if (ret)
2429                         return ret;
2430
2431                 iova  += PAGE_SIZE;
2432                 paddr += PAGE_SIZE;
2433         }
2434
2435         return 0;
2436 }
2437
2438 static void amd_iommu_unmap_range(struct iommu_domain *dom,
2439                                   unsigned long iova, size_t size)
2440 {
2441
2442         struct protection_domain *domain = dom->priv;
2443         unsigned long i,  npages = iommu_num_pages(iova, size, PAGE_SIZE);
2444
2445         iova  &= PAGE_MASK;
2446
2447         for (i = 0; i < npages; ++i) {
2448                 iommu_unmap_page(domain, iova, PM_MAP_4k);
2449                 iova  += PAGE_SIZE;
2450         }
2451
2452         iommu_flush_tlb_pde(domain);
2453 }
2454
2455 static phys_addr_t amd_iommu_iova_to_phys(struct iommu_domain *dom,
2456                                           unsigned long iova)
2457 {
2458         struct protection_domain *domain = dom->priv;
2459         unsigned long offset = iova & ~PAGE_MASK;
2460         phys_addr_t paddr;
2461         u64 *pte;
2462
2463         pte = fetch_pte(domain, iova, PM_MAP_4k);
2464
2465         if (!pte || !IOMMU_PTE_PRESENT(*pte))
2466                 return 0;
2467
2468         paddr  = *pte & IOMMU_PAGE_MASK;
2469         paddr |= offset;
2470
2471         return paddr;
2472 }
2473
2474 static int amd_iommu_domain_has_cap(struct iommu_domain *domain,
2475                                     unsigned long cap)
2476 {
2477         return 0;
2478 }
2479
2480 static struct iommu_ops amd_iommu_ops = {
2481         .domain_init = amd_iommu_domain_init,
2482         .domain_destroy = amd_iommu_domain_destroy,
2483         .attach_dev = amd_iommu_attach_device,
2484         .detach_dev = amd_iommu_detach_device,
2485         .map = amd_iommu_map_range,
2486         .unmap = amd_iommu_unmap_range,
2487         .iova_to_phys = amd_iommu_iova_to_phys,
2488         .domain_has_cap = amd_iommu_domain_has_cap,
2489 };
2490
2491 /*****************************************************************************
2492  *
2493  * The next functions do a basic initialization of IOMMU for pass through
2494  * mode
2495  *
2496  * In passthrough mode the IOMMU is initialized and enabled but not used for
2497  * DMA-API translation.
2498  *
2499  *****************************************************************************/
2500
2501 int __init amd_iommu_init_passthrough(void)
2502 {
2503         struct amd_iommu *iommu;
2504         struct pci_dev *dev = NULL;
2505         u16 devid;
2506
2507         /* allocate passthroug domain */
2508         pt_domain = protection_domain_alloc();
2509         if (!pt_domain)
2510                 return -ENOMEM;
2511
2512         pt_domain->mode |= PAGE_MODE_NONE;
2513
2514         while ((dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, dev)) != NULL) {
2515
2516                 if (!check_device(&dev->dev))
2517                         continue;
2518
2519                 devid = get_device_id(&dev->dev);
2520
2521                 iommu = amd_iommu_rlookup_table[devid];
2522                 if (!iommu)
2523                         continue;
2524
2525                 attach_device(&dev->dev, pt_domain);
2526         }
2527
2528         pr_info("AMD-Vi: Initialized for Passthrough Mode\n");
2529
2530         return 0;
2531 }