SAFE public projects git trees. - safe/jmp/linux-2.6/blob - arch/x86/kernel/amd_iommu.c

   1 /*
   2  * Copyright (C) 2007-2008 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/scatterlist.h>
  24 #include <linux/iommu-helper.h>
  25 #include <asm/proto.h>
  26 #include <asm/iommu.h>
  27 #include <asm/amd_iommu_types.h>
  28 #include <asm/amd_iommu.h>
  29
  30 #define CMD_SET_TYPE(cmd, t) ((cmd)->data[1] |= ((t) << 28))
  31
  32 #define EXIT_LOOP_COUNT 10000000
  33
  34 static DEFINE_RWLOCK(amd_iommu_devtable_lock);
  35
  36 /*
  37  * general struct to manage commands send to an IOMMU
  38  */
  39 struct iommu_cmd {
  40         u32 data[4];
  41 };
  42
  43 static int dma_ops_unity_map(struct dma_ops_domain *dma_dom,
  44                              struct unity_map_entry *e);
  45
  46 /* returns !0 if the IOMMU is caching non-present entries in its TLB */
  47 static int iommu_has_npcache(struct amd_iommu *iommu)
  48 {
  49         return iommu->cap & IOMMU_CAP_NPCACHE;
  50 }
  51
  52 /****************************************************************************
  53  *
  54  * IOMMU command queuing functions
  55  *
  56  ****************************************************************************/
  57
  58 /*
  59  * Writes the command to the IOMMUs command buffer and informs the
  60  * hardware about the new command. Must be called with iommu->lock held.
  61  */
  62 static int __iommu_queue_command(struct amd_iommu *iommu, struct iommu_cmd *cmd)
  63 {
  64         u32 tail, head;
  65         u8 *target;
  66
  67         tail = readl(iommu->mmio_base + MMIO_CMD_TAIL_OFFSET);
  68         target = iommu->cmd_buf + tail;
  69         memcpy_toio(target, cmd, sizeof(*cmd));
  70         tail = (tail + sizeof(*cmd)) % iommu->cmd_buf_size;
  71         head = readl(iommu->mmio_base + MMIO_CMD_HEAD_OFFSET);
  72         if (tail == head)
  73                 return -ENOMEM;
  74         writel(tail, iommu->mmio_base + MMIO_CMD_TAIL_OFFSET);
  75
  76         return 0;
  77 }
  78
  79 /*
  80  * General queuing function for commands. Takes iommu->lock and calls
  81  * __iommu_queue_command().
  82  */
  83 static int iommu_queue_command(struct amd_iommu *iommu, struct iommu_cmd *cmd)
  84 {
  85         unsigned long flags;
  86         int ret;
  87
  88         spin_lock_irqsave(&iommu->lock, flags);
  89         ret = __iommu_queue_command(iommu, cmd);
  90         spin_unlock_irqrestore(&iommu->lock, flags);
  91
  92         return ret;
  93 }
  94
  95 /*
  96  * This function is called whenever we need to ensure that the IOMMU has
  97  * completed execution of all commands we sent. It sends a
  98  * COMPLETION_WAIT command and waits for it to finish. The IOMMU informs
  99  * us about that by writing a value to a physical address we pass with
 100  * the command.
 101  */
 102 static int iommu_completion_wait(struct amd_iommu *iommu)
 103 {
 104         int ret, ready = 0;
 105         unsigned status = 0;
 106         struct iommu_cmd cmd;
 107         unsigned long i = 0;
 108
 109         memset(&cmd, 0, sizeof(cmd));
 110         cmd.data[0] = CMD_COMPL_WAIT_INT_MASK;
 111         CMD_SET_TYPE(&cmd, CMD_COMPL_WAIT);
 112
 113         iommu->need_sync = 0;
 114
 115         ret = iommu_queue_command(iommu, &cmd);
 116
 117         if (ret)
 118                 return ret;
 119
 120         while (!ready && (i < EXIT_LOOP_COUNT)) {
 121                 ++i;
 122                 /* wait for the bit to become one */
 123                 status = readl(iommu->mmio_base + MMIO_STATUS_OFFSET);
 124                 ready = status & MMIO_STATUS_COM_WAIT_INT_MASK;
 125         }
 126
 127         /* set bit back to zero */
 128         status &= ~MMIO_STATUS_COM_WAIT_INT_MASK;
 129         writel(status, iommu->mmio_base + MMIO_STATUS_OFFSET);
 130
 131         if (unlikely((i == EXIT_LOOP_COUNT) && printk_ratelimit()))
 132                 printk(KERN_WARNING "AMD IOMMU: Completion wait loop failed\n");
 133
 134         return 0;
 135 }
 136
 137 /*
 138  * Command send function for invalidating a device table entry
 139  */
 140 static int iommu_queue_inv_dev_entry(struct amd_iommu *iommu, u16 devid)
 141 {
 142         struct iommu_cmd cmd;
 143
 144         BUG_ON(iommu == NULL);
 145
 146         memset(&cmd, 0, sizeof(cmd));
 147         CMD_SET_TYPE(&cmd, CMD_INV_DEV_ENTRY);
 148         cmd.data[0] = devid;
 149
 150         iommu->need_sync = 1;
 151
 152         return iommu_queue_command(iommu, &cmd);
 153 }
 154
 155 /*
 156  * Generic command send function for invalidaing TLB entries
 157  */
 158 static int iommu_queue_inv_iommu_pages(struct amd_iommu *iommu,
 159                 u64 address, u16 domid, int pde, int s)
 160 {
 161         struct iommu_cmd cmd;
 162
 163         memset(&cmd, 0, sizeof(cmd));
 164         address &= PAGE_MASK;
 165         CMD_SET_TYPE(&cmd, CMD_INV_IOMMU_PAGES);
 166         cmd.data[1] |= domid;
 167         cmd.data[2] = lower_32_bits(address);
 168         cmd.data[3] = upper_32_bits(address);
 169         if (s) /* size bit - we flush more than one 4kb page */
 170                 cmd.data[2] |= CMD_INV_IOMMU_PAGES_SIZE_MASK;
 171         if (pde) /* PDE bit - we wan't flush everything not only the PTEs */
 172                 cmd.data[2] |= CMD_INV_IOMMU_PAGES_PDE_MASK;
 173
 174         iommu->need_sync = 1;
 175
 176         return iommu_queue_command(iommu, &cmd);
 177 }
 178
 179 /*
 180  * TLB invalidation function which is called from the mapping functions.
 181  * It invalidates a single PTE if the range to flush is within a single
 182  * page. Otherwise it flushes the whole TLB of the IOMMU.
 183  */
 184 static int iommu_flush_pages(struct amd_iommu *iommu, u16 domid,
 185                 u64 address, size_t size)
 186 {
 187         int s = 0;
 188         unsigned pages = iommu_num_pages(address, size);
 189
 190         address &= PAGE_MASK;
 191
 192         if (pages > 1) {
 193                 /*
 194                  * If we have to flush more than one page, flush all
 195                  * TLB entries for this domain
 196                  */
 197                 address = CMD_INV_IOMMU_ALL_PAGES_ADDRESS;
 198                 s = 1;
 199         }
 200
 201         iommu_queue_inv_iommu_pages(iommu, address, domid, 0, s);
 202
 203         return 0;
 204 }
 205
 206 /****************************************************************************
 207  *
 208  * The functions below are used the create the page table mappings for
 209  * unity mapped regions.
 210  *
 211  ****************************************************************************/
 212
 213 /*
 214  * Generic mapping functions. It maps a physical address into a DMA
 215  * address space. It allocates the page table pages if necessary.
 216  * In the future it can be extended to a generic mapping function
 217  * supporting all features of AMD IOMMU page tables like level skipping
 218  * and full 64 bit address spaces.
 219  */
 220 static int iommu_map(struct protection_domain *dom,
 221                      unsigned long bus_addr,
 222                      unsigned long phys_addr,
 223                      int prot)
 224 {
 225         u64 __pte, *pte, *page;
 226
 227         bus_addr  = PAGE_ALIGN(bus_addr);
 228         phys_addr = PAGE_ALIGN(bus_addr);
 229
 230         /* only support 512GB address spaces for now */
 231         if (bus_addr > IOMMU_MAP_SIZE_L3 || !(prot & IOMMU_PROT_MASK))
 232                 return -EINVAL;
 233
 234         pte = &dom->pt_root[IOMMU_PTE_L2_INDEX(bus_addr)];
 235
 236         if (!IOMMU_PTE_PRESENT(*pte)) {
 237                 page = (u64 *)get_zeroed_page(GFP_KERNEL);
 238                 if (!page)
 239                         return -ENOMEM;
 240                 *pte = IOMMU_L2_PDE(virt_to_phys(page));
 241         }
 242
 243         pte = IOMMU_PTE_PAGE(*pte);
 244         pte = &pte[IOMMU_PTE_L1_INDEX(bus_addr)];
 245
 246         if (!IOMMU_PTE_PRESENT(*pte)) {
 247                 page = (u64 *)get_zeroed_page(GFP_KERNEL);
 248                 if (!page)
 249                         return -ENOMEM;
 250                 *pte = IOMMU_L1_PDE(virt_to_phys(page));
 251         }
 252
 253         pte = IOMMU_PTE_PAGE(*pte);
 254         pte = &pte[IOMMU_PTE_L0_INDEX(bus_addr)];
 255
 256         if (IOMMU_PTE_PRESENT(*pte))
 257                 return -EBUSY;
 258
 259         __pte = phys_addr | IOMMU_PTE_P;
 260         if (prot & IOMMU_PROT_IR)
 261                 __pte |= IOMMU_PTE_IR;
 262         if (prot & IOMMU_PROT_IW)
 263                 __pte |= IOMMU_PTE_IW;
 264
 265         *pte = __pte;
 266
 267         return 0;
 268 }
 269
 270 /*
 271  * This function checks if a specific unity mapping entry is needed for
 272  * this specific IOMMU.
 273  */
 274 static int iommu_for_unity_map(struct amd_iommu *iommu,
 275                                struct unity_map_entry *entry)
 276 {
 277         u16 bdf, i;
 278
 279         for (i = entry->devid_start; i <= entry->devid_end; ++i) {
 280                 bdf = amd_iommu_alias_table[i];
 281                 if (amd_iommu_rlookup_table[bdf] == iommu)
 282                         return 1;
 283         }
 284
 285         return 0;
 286 }
 287
 288 /*
 289  * Init the unity mappings for a specific IOMMU in the system
 290  *
 291  * Basically iterates over all unity mapping entries and applies them to
 292  * the default domain DMA of that IOMMU if necessary.
 293  */
 294 static int iommu_init_unity_mappings(struct amd_iommu *iommu)
 295 {
 296         struct unity_map_entry *entry;
 297         int ret;
 298
 299         list_for_each_entry(entry, &amd_iommu_unity_map, list) {
 300                 if (!iommu_for_unity_map(iommu, entry))
 301                         continue;
 302                 ret = dma_ops_unity_map(iommu->default_dom, entry);
 303                 if (ret)
 304                         return ret;
 305         }
 306
 307         return 0;
 308 }
 309
 310 /*
 311  * This function actually applies the mapping to the page table of the
 312  * dma_ops domain.
 313  */
 314 static int dma_ops_unity_map(struct dma_ops_domain *dma_dom,
 315                              struct unity_map_entry *e)
 316 {
 317         u64 addr;
 318         int ret;
 319
 320         for (addr = e->address_start; addr < e->address_end;
 321              addr += PAGE_SIZE) {
 322                 ret = iommu_map(&dma_dom->domain, addr, addr, e->prot);
 323                 if (ret)
 324                         return ret;
 325                 /*
 326                  * if unity mapping is in aperture range mark the page
 327                  * as allocated in the aperture
 328                  */
 329                 if (addr < dma_dom->aperture_size)
 330                         __set_bit(addr >> PAGE_SHIFT, dma_dom->bitmap);
 331         }
 332
 333         return 0;
 334 }
 335
 336 /*
 337  * Inits the unity mappings required for a specific device
 338  */
 339 static int init_unity_mappings_for_device(struct dma_ops_domain *dma_dom,
 340                                           u16 devid)
 341 {
 342         struct unity_map_entry *e;
 343         int ret;
 344
 345         list_for_each_entry(e, &amd_iommu_unity_map, list) {
 346                 if (!(devid >= e->devid_start && devid <= e->devid_end))
 347                         continue;
 348                 ret = dma_ops_unity_map(dma_dom, e);
 349                 if (ret)
 350                         return ret;
 351         }
 352
 353         return 0;
 354 }
 355
 356 /****************************************************************************
 357  *
 358  * The next functions belong to the address allocator for the dma_ops
 359  * interface functions. They work like the allocators in the other IOMMU
 360  * drivers. Its basically a bitmap which marks the allocated pages in
 361  * the aperture. Maybe it could be enhanced in the future to a more
 362  * efficient allocator.
 363  *
 364  ****************************************************************************/
 365 static unsigned long dma_mask_to_pages(unsigned long mask)
 366 {
 367         return (mask >> PAGE_SHIFT) +
 368                 (PAGE_ALIGN(mask & ~PAGE_MASK) >> PAGE_SHIFT);
 369 }
 370
 371 /*
 372  * The address allocator core function.
 373  *
 374  * called with domain->lock held
 375  */
 376 static unsigned long dma_ops_alloc_addresses(struct device *dev,
 377                                              struct dma_ops_domain *dom,
 378                                              unsigned int pages)
 379 {
 380         unsigned long limit = dma_mask_to_pages(*dev->dma_mask);
 381         unsigned long address;
 382         unsigned long size = dom->aperture_size >> PAGE_SHIFT;
 383         unsigned long boundary_size;
 384
 385         boundary_size = ALIGN(dma_get_seg_boundary(dev) + 1,
 386                         PAGE_SIZE) >> PAGE_SHIFT;
 387         limit = limit < size ? limit : size;
 388
 389         if (dom->next_bit >= limit)
 390                 dom->next_bit = 0;
 391
 392         address = iommu_area_alloc(dom->bitmap, limit, dom->next_bit, pages,
 393                         0 , boundary_size, 0);
 394         if (address == -1)
 395                 address = iommu_area_alloc(dom->bitmap, limit, 0, pages,
 396                                 0, boundary_size, 0);
 397
 398         if (likely(address != -1)) {
 399                 dom->next_bit = address + pages;
 400                 address <<= PAGE_SHIFT;
 401         } else
 402                 address = bad_dma_address;
 403
 404         WARN_ON((address + (PAGE_SIZE*pages)) > dom->aperture_size);
 405
 406         return address;
 407 }
 408
 409 /*
 410  * The address free function.
 411  *
 412  * called with domain->lock held
 413  */
 414 static void dma_ops_free_addresses(struct dma_ops_domain *dom,
 415                                    unsigned long address,
 416                                    unsigned int pages)
 417 {
 418         address >>= PAGE_SHIFT;
 419         iommu_area_free(dom->bitmap, address, pages);
 420 }
 421
 422 /****************************************************************************
 423  *
 424  * The next functions belong to the domain allocation. A domain is
 425  * allocated for every IOMMU as the default domain. If device isolation
 426  * is enabled, every device get its own domain. The most important thing
 427  * about domains is the page table mapping the DMA address space they
 428  * contain.
 429  *
 430  ****************************************************************************/
 431
 432 static u16 domain_id_alloc(void)
 433 {
 434         unsigned long flags;
 435         int id;
 436
 437         write_lock_irqsave(&amd_iommu_devtable_lock, flags);
 438         id = find_first_zero_bit(amd_iommu_pd_alloc_bitmap, MAX_DOMAIN_ID);
 439         BUG_ON(id == 0);
 440         if (id > 0 && id < MAX_DOMAIN_ID)
 441                 __set_bit(id, amd_iommu_pd_alloc_bitmap);
 442         else
 443                 id = 0;
 444         write_unlock_irqrestore(&amd_iommu_devtable_lock, flags);
 445
 446         return id;
 447 }
 448
 449 /*
 450  * Used to reserve address ranges in the aperture (e.g. for exclusion
 451  * ranges.
 452  */
 453 static void dma_ops_reserve_addresses(struct dma_ops_domain *dom,
 454                                       unsigned long start_page,
 455                                       unsigned int pages)
 456 {
 457         unsigned int last_page = dom->aperture_size >> PAGE_SHIFT;
 458
 459         if (start_page + pages > last_page)
 460                 pages = last_page - start_page;
 461
 462         set_bit_string(dom->bitmap, start_page, pages);
 463 }
 464
 465 static void dma_ops_free_pagetable(struct dma_ops_domain *dma_dom)
 466 {
 467         int i, j;
 468         u64 *p1, *p2, *p3;
 469
 470         p1 = dma_dom->domain.pt_root;
 471
 472         if (!p1)
 473                 return;
 474
 475         for (i = 0; i < 512; ++i) {
 476                 if (!IOMMU_PTE_PRESENT(p1[i]))
 477                         continue;
 478
 479                 p2 = IOMMU_PTE_PAGE(p1[i]);
 480                 for (j = 0; j < 512; ++i) {
 481                         if (!IOMMU_PTE_PRESENT(p2[j]))
 482                                 continue;
 483                         p3 = IOMMU_PTE_PAGE(p2[j]);
 484                         free_page((unsigned long)p3);
 485                 }
 486
 487                 free_page((unsigned long)p2);
 488         }
 489
 490         free_page((unsigned long)p1);
 491 }
 492
 493 /*
 494  * Free a domain, only used if something went wrong in the
 495  * allocation path and we need to free an already allocated page table
 496  */
 497 static void dma_ops_domain_free(struct dma_ops_domain *dom)
 498 {
 499         if (!dom)
 500                 return;
 501
 502         dma_ops_free_pagetable(dom);
 503
 504         kfree(dom->pte_pages);
 505
 506         kfree(dom->bitmap);
 507
 508         kfree(dom);
 509 }
 510
 511 /*
 512  * Allocates a new protection domain usable for the dma_ops functions.
 513  * It also intializes the page table and the address allocator data
 514  * structures required for the dma_ops interface
 515  */
 516 static struct dma_ops_domain *dma_ops_domain_alloc(struct amd_iommu *iommu,
 517                                                    unsigned order)
 518 {
 519         struct dma_ops_domain *dma_dom;
 520         unsigned i, num_pte_pages;
 521         u64 *l2_pde;
 522         u64 address;
 523
 524         /*
 525          * Currently the DMA aperture must be between 32 MB and 1GB in size
 526          */
 527         if ((order < 25) || (order > 30))
 528                 return NULL;
 529
 530         dma_dom = kzalloc(sizeof(struct dma_ops_domain), GFP_KERNEL);
 531         if (!dma_dom)
 532                 return NULL;
 533
 534         spin_lock_init(&dma_dom->domain.lock);
 535
 536         dma_dom->domain.id = domain_id_alloc();
 537         if (dma_dom->domain.id == 0)
 538                 goto free_dma_dom;
 539         dma_dom->domain.mode = PAGE_MODE_3_LEVEL;
 540         dma_dom->domain.pt_root = (void *)get_zeroed_page(GFP_KERNEL);
 541         dma_dom->domain.priv = dma_dom;
 542         if (!dma_dom->domain.pt_root)
 543                 goto free_dma_dom;
 544         dma_dom->aperture_size = (1ULL << order);
 545         dma_dom->bitmap = kzalloc(dma_dom->aperture_size / (PAGE_SIZE * 8),
 546                                   GFP_KERNEL);
 547         if (!dma_dom->bitmap)
 548                 goto free_dma_dom;
 549         /*
 550          * mark the first page as allocated so we never return 0 as
 551          * a valid dma-address. So we can use 0 as error value
 552          */
 553         dma_dom->bitmap[0] = 1;
 554         dma_dom->next_bit = 0;
 555
 556         /* Intialize the exclusion range if necessary */
 557         if (iommu->exclusion_start &&
 558             iommu->exclusion_start < dma_dom->aperture_size) {
 559                 unsigned long startpage = iommu->exclusion_start >> PAGE_SHIFT;
 560                 int pages = iommu_num_pages(iommu->exclusion_start,
 561                                             iommu->exclusion_length);
 562                 dma_ops_reserve_addresses(dma_dom, startpage, pages);
 563         }
 564
 565         /*
 566          * At the last step, build the page tables so we don't need to
 567          * allocate page table pages in the dma_ops mapping/unmapping
 568          * path.
 569          */
 570         num_pte_pages = dma_dom->aperture_size / (PAGE_SIZE * 512);
 571         dma_dom->pte_pages = kzalloc(num_pte_pages * sizeof(void *),
 572                         GFP_KERNEL);
 573         if (!dma_dom->pte_pages)
 574                 goto free_dma_dom;
 575
 576         l2_pde = (u64 *)get_zeroed_page(GFP_KERNEL);
 577         if (l2_pde == NULL)
 578                 goto free_dma_dom;
 579
 580         dma_dom->domain.pt_root[0] = IOMMU_L2_PDE(virt_to_phys(l2_pde));
 581
 582         for (i = 0; i < num_pte_pages; ++i) {
 583                 dma_dom->pte_pages[i] = (u64 *)get_zeroed_page(GFP_KERNEL);
 584                 if (!dma_dom->pte_pages[i])
 585                         goto free_dma_dom;
 586                 address = virt_to_phys(dma_dom->pte_pages[i]);
 587                 l2_pde[i] = IOMMU_L1_PDE(address);
 588         }
 589
 590         return dma_dom;
 591
 592 free_dma_dom:
 593         dma_ops_domain_free(dma_dom);
 594
 595         return NULL;
 596 }
 597
 598 /*
 599  * Find out the protection domain structure for a given PCI device. This
 600  * will give us the pointer to the page table root for example.
 601  */
 602 static struct protection_domain *domain_for_device(u16 devid)
 603 {
 604         struct protection_domain *dom;
 605         unsigned long flags;
 606
 607         read_lock_irqsave(&amd_iommu_devtable_lock, flags);
 608         dom = amd_iommu_pd_table[devid];
 609         read_unlock_irqrestore(&amd_iommu_devtable_lock, flags);
 610
 611         return dom;
 612 }
 613
 614 /*
 615  * If a device is not yet associated with a domain, this function does
 616  * assigns it visible for the hardware
 617  */
 618 static void set_device_domain(struct amd_iommu *iommu,
 619                               struct protection_domain *domain,
 620                               u16 devid)
 621 {
 622         unsigned long flags;
 623
 624         u64 pte_root = virt_to_phys(domain->pt_root);
 625
 626         pte_root |= (domain->mode & 0x07) << 9;
 627         pte_root |= IOMMU_PTE_IR | IOMMU_PTE_IW | IOMMU_PTE_P | 2;
 628
 629         write_lock_irqsave(&amd_iommu_devtable_lock, flags);
 630         amd_iommu_dev_table[devid].data[0] = pte_root;
 631         amd_iommu_dev_table[devid].data[1] = pte_root >> 32;
 632         amd_iommu_dev_table[devid].data[2] = domain->id;
 633
 634         amd_iommu_pd_table[devid] = domain;
 635         write_unlock_irqrestore(&amd_iommu_devtable_lock, flags);
 636
 637         iommu_queue_inv_dev_entry(iommu, devid);
 638
 639         iommu->need_sync = 1;
 640 }
 641
 642 /*****************************************************************************
 643  *
 644  * The next functions belong to the dma_ops mapping/unmapping code.
 645  *
 646  *****************************************************************************/
 647
 648 /*
 649  * This function checks if the driver got a valid device from the caller to
 650  * avoid dereferencing invalid pointers.
 651  */
 652 static bool check_device(struct device *dev)
 653 {
 654         if (!dev || !dev->dma_mask)
 655                 return false;
 656
 657         return true;
 658 }
 659
 660 /*
 661  * In the dma_ops path we only have the struct device. This function
 662  * finds the corresponding IOMMU, the protection domain and the
 663  * requestor id for a given device.
 664  * If the device is not yet associated with a domain this is also done
 665  * in this function.
 666  */
 667 static int get_device_resources(struct device *dev,
 668                                 struct amd_iommu **iommu,
 669                                 struct protection_domain **domain,
 670                                 u16 *bdf)
 671 {
 672         struct dma_ops_domain *dma_dom;
 673         struct pci_dev *pcidev;
 674         u16 _bdf;
 675
 676         *iommu = NULL;
 677         *domain = NULL;
 678         *bdf = 0xffff;
 679
 680         if (dev->bus != &pci_bus_type)
 681                 return 0;
 682
 683         pcidev = to_pci_dev(dev);
 684         _bdf = calc_devid(pcidev->bus->number, pcidev->devfn);
 685
 686         /* device not translated by any IOMMU in the system? */
 687         if (_bdf > amd_iommu_last_bdf)
 688                 return 0;
 689
 690         *bdf = amd_iommu_alias_table[_bdf];
 691
 692         *iommu = amd_iommu_rlookup_table[*bdf];
 693         if (*iommu == NULL)
 694                 return 0;
 695         dma_dom = (*iommu)->default_dom;
 696         *domain = domain_for_device(*bdf);
 697         if (*domain == NULL) {
 698                 *domain = &dma_dom->domain;
 699                 set_device_domain(*iommu, *domain, *bdf);
 700                 printk(KERN_INFO "AMD IOMMU: Using protection domain %d for "
 701                                 "device ", (*domain)->id);
 702                 print_devid(_bdf, 1);
 703         }
 704
 705         return 1;
 706 }
 707
 708 /*
 709  * This is the generic map function. It maps one 4kb page at paddr to
 710  * the given address in the DMA address space for the domain.
 711  */
 712 static dma_addr_t dma_ops_domain_map(struct amd_iommu *iommu,
 713                                      struct dma_ops_domain *dom,
 714                                      unsigned long address,
 715                                      phys_addr_t paddr,
 716                                      int direction)
 717 {
 718         u64 *pte, __pte;
 719
 720         WARN_ON(address > dom->aperture_size);
 721
 722         paddr &= PAGE_MASK;
 723
 724         pte  = dom->pte_pages[IOMMU_PTE_L1_INDEX(address)];
 725         pte += IOMMU_PTE_L0_INDEX(address);
 726
 727         __pte = paddr | IOMMU_PTE_P | IOMMU_PTE_FC;
 728
 729         if (direction == DMA_TO_DEVICE)
 730                 __pte |= IOMMU_PTE_IR;
 731         else if (direction == DMA_FROM_DEVICE)
 732                 __pte |= IOMMU_PTE_IW;
 733         else if (direction == DMA_BIDIRECTIONAL)
 734                 __pte |= IOMMU_PTE_IR | IOMMU_PTE_IW;
 735
 736         WARN_ON(*pte);
 737
 738         *pte = __pte;
 739
 740         return (dma_addr_t)address;
 741 }
 742
 743 /*
 744  * The generic unmapping function for on page in the DMA address space.
 745  */
 746 static void dma_ops_domain_unmap(struct amd_iommu *iommu,
 747                                  struct dma_ops_domain *dom,
 748                                  unsigned long address)
 749 {
 750         u64 *pte;
 751
 752         if (address >= dom->aperture_size)
 753                 return;
 754
 755         WARN_ON(address & 0xfffULL || address > dom->aperture_size);
 756
 757         pte  = dom->pte_pages[IOMMU_PTE_L1_INDEX(address)];
 758         pte += IOMMU_PTE_L0_INDEX(address);
 759
 760         WARN_ON(!*pte);
 761
 762         *pte = 0ULL;
 763 }
 764
 765 /*
 766  * This function contains common code for mapping of a physically
 767  * contiguous memory region into DMA address space. It is uses by all
 768  * mapping functions provided by this IOMMU driver.
 769  * Must be called with the domain lock held.
 770  */
 771 static dma_addr_t __map_single(struct device *dev,
 772                                struct amd_iommu *iommu,
 773                                struct dma_ops_domain *dma_dom,
 774                                phys_addr_t paddr,
 775                                size_t size,
 776                                int dir)
 777 {
 778         dma_addr_t offset = paddr & ~PAGE_MASK;
 779         dma_addr_t address, start;
 780         unsigned int pages;
 781         int i;
 782
 783         pages = iommu_num_pages(paddr, size);
 784         paddr &= PAGE_MASK;
 785
 786         address = dma_ops_alloc_addresses(dev, dma_dom, pages);
 787         if (unlikely(address == bad_dma_address))
 788                 goto out;
 789
 790         start = address;
 791         for (i = 0; i < pages; ++i) {
 792                 dma_ops_domain_map(iommu, dma_dom, start, paddr, dir);
 793                 paddr += PAGE_SIZE;
 794                 start += PAGE_SIZE;
 795         }
 796         address += offset;
 797
 798         if (unlikely(iommu_has_npcache(iommu)))
 799                 iommu_flush_pages(iommu, dma_dom->domain.id, address, size);
 800
 801 out:
 802         return address;
 803 }
 804
 805 /*
 806  * Does the reverse of the __map_single function. Must be called with
 807  * the domain lock held too
 808  */
 809 static void __unmap_single(struct amd_iommu *iommu,
 810                            struct dma_ops_domain *dma_dom,
 811                            dma_addr_t dma_addr,
 812                            size_t size,
 813                            int dir)
 814 {
 815         dma_addr_t i, start;
 816         unsigned int pages;
 817
 818         if ((dma_addr == 0) || (dma_addr + size > dma_dom->aperture_size))
 819                 return;
 820
 821         pages = iommu_num_pages(dma_addr, size);
 822         dma_addr &= PAGE_MASK;
 823         start = dma_addr;
 824
 825         for (i = 0; i < pages; ++i) {
 826                 dma_ops_domain_unmap(iommu, dma_dom, start);
 827                 start += PAGE_SIZE;
 828         }
 829
 830         dma_ops_free_addresses(dma_dom, dma_addr, pages);
 831
 832         iommu_flush_pages(iommu, dma_dom->domain.id, dma_addr, size);
 833 }
 834
 835 /*
 836  * The exported map_single function for dma_ops.
 837  */
 838 static dma_addr_t map_single(struct device *dev, phys_addr_t paddr,
 839                              size_t size, int dir)
 840 {
 841         unsigned long flags;
 842         struct amd_iommu *iommu;
 843         struct protection_domain *domain;
 844         u16 devid;
 845         dma_addr_t addr;
 846
 847         if (!check_device(dev))
 848                 return bad_dma_address;
 849
 850         get_device_resources(dev, &iommu, &domain, &devid);
 851
 852         if (iommu == NULL || domain == NULL)
 853                 /* device not handled by any AMD IOMMU */
 854                 return (dma_addr_t)paddr;
 855
 856         spin_lock_irqsave(&domain->lock, flags);
 857         addr = __map_single(dev, iommu, domain->priv, paddr, size, dir);
 858         if (addr == bad_dma_address)
 859                 goto out;
 860
 861         if (iommu->need_sync)
 862                 iommu_completion_wait(iommu);
 863
 864 out:
 865         spin_unlock_irqrestore(&domain->lock, flags);
 866
 867         return addr;
 868 }
 869
 870 /*
 871  * The exported unmap_single function for dma_ops.
 872  */
 873 static void unmap_single(struct device *dev, dma_addr_t dma_addr,
 874                          size_t size, int dir)
 875 {
 876         unsigned long flags;
 877         struct amd_iommu *iommu;
 878         struct protection_domain *domain;
 879         u16 devid;
 880
 881         if (!check_device(dev) ||
 882             !get_device_resources(dev, &iommu, &domain, &devid))
 883                 /* device not handled by any AMD IOMMU */
 884                 return;
 885
 886         spin_lock_irqsave(&domain->lock, flags);
 887
 888         __unmap_single(iommu, domain->priv, dma_addr, size, dir);
 889
 890         if (iommu->need_sync)
 891                 iommu_completion_wait(iommu);
 892
 893         spin_unlock_irqrestore(&domain->lock, flags);
 894 }
 895
 896 /*
 897  * This is a special map_sg function which is used if we should map a
 898  * device which is not handled by an AMD IOMMU in the system.
 899  */
 900 static int map_sg_no_iommu(struct device *dev, struct scatterlist *sglist,
 901                            int nelems, int dir)
 902 {
 903         struct scatterlist *s;
 904         int i;
 905
 906         for_each_sg(sglist, s, nelems, i) {
 907                 s->dma_address = (dma_addr_t)sg_phys(s);
 908                 s->dma_length  = s->length;
 909         }
 910
 911         return nelems;
 912 }
 913
 914 /*
 915  * The exported map_sg function for dma_ops (handles scatter-gather
 916  * lists).
 917  */
 918 static int map_sg(struct device *dev, struct scatterlist *sglist,
 919                   int nelems, int dir)
 920 {
 921         unsigned long flags;
 922         struct amd_iommu *iommu;
 923         struct protection_domain *domain;
 924         u16 devid;
 925         int i;
 926         struct scatterlist *s;
 927         phys_addr_t paddr;
 928         int mapped_elems = 0;
 929
 930         if (!check_device(dev))
 931                 return 0;
 932
 933         get_device_resources(dev, &iommu, &domain, &devid);
 934
 935         if (!iommu || !domain)
 936                 return map_sg_no_iommu(dev, sglist, nelems, dir);
 937
 938         spin_lock_irqsave(&domain->lock, flags);
 939
 940         for_each_sg(sglist, s, nelems, i) {
 941                 paddr = sg_phys(s);
 942
 943                 s->dma_address = __map_single(dev, iommu, domain->priv,
 944                                               paddr, s->length, dir);
 945
 946                 if (s->dma_address) {
 947                         s->dma_length = s->length;
 948                         mapped_elems++;
 949                 } else
 950                         goto unmap;
 951         }
 952
 953         if (iommu->need_sync)
 954                 iommu_completion_wait(iommu);
 955
 956 out:
 957         spin_unlock_irqrestore(&domain->lock, flags);
 958
 959         return mapped_elems;
 960 unmap:
 961         for_each_sg(sglist, s, mapped_elems, i) {
 962                 if (s->dma_address)
 963                         __unmap_single(iommu, domain->priv, s->dma_address,
 964                                        s->dma_length, dir);
 965                 s->dma_address = s->dma_length = 0;
 966         }
 967
 968         mapped_elems = 0;
 969
 970         goto out;
 971 }
 972
 973 /*
 974  * The exported map_sg function for dma_ops (handles scatter-gather
 975  * lists).
 976  */
 977 static void unmap_sg(struct device *dev, struct scatterlist *sglist,
 978                      int nelems, int dir)
 979 {
 980         unsigned long flags;
 981         struct amd_iommu *iommu;
 982         struct protection_domain *domain;
 983         struct scatterlist *s;
 984         u16 devid;
 985         int i;
 986
 987         if (!check_device(dev) ||
 988             !get_device_resources(dev, &iommu, &domain, &devid))
 989                 return;
 990
 991         spin_lock_irqsave(&domain->lock, flags);
 992
 993         for_each_sg(sglist, s, nelems, i) {
 994                 __unmap_single(iommu, domain->priv, s->dma_address,
 995                                s->dma_length, dir);
 996                 s->dma_address = s->dma_length = 0;
 997         }
 998
 999         if (iommu->need_sync)
1000                 iommu_completion_wait(iommu);
1001
1002         spin_unlock_irqrestore(&domain->lock, flags);
1003 }
1004
1005 /*
1006  * The exported alloc_coherent function for dma_ops.
1007  */
1008 static void *alloc_coherent(struct device *dev, size_t size,
1009                             dma_addr_t *dma_addr, gfp_t flag)
1010 {
1011         unsigned long flags;
1012         void *virt_addr;
1013         struct amd_iommu *iommu;
1014         struct protection_domain *domain;
1015         u16 devid;
1016         phys_addr_t paddr;
1017
1018         if (!check_device(dev))
1019                 return NULL;
1020
1021         virt_addr = (void *)__get_free_pages(flag, get_order(size));
1022         if (!virt_addr)
1023                 return 0;
1024
1025         memset(virt_addr, 0, size);
1026         paddr = virt_to_phys(virt_addr);
1027
1028         get_device_resources(dev, &iommu, &domain, &devid);
1029
1030         if (!iommu || !domain) {
1031                 *dma_addr = (dma_addr_t)paddr;
1032                 return virt_addr;
1033         }
1034
1035         spin_lock_irqsave(&domain->lock, flags);
1036
1037         *dma_addr = __map_single(dev, iommu, domain->priv, paddr,
1038                                  size, DMA_BIDIRECTIONAL);
1039
1040         if (*dma_addr == bad_dma_address) {
1041                 free_pages((unsigned long)virt_addr, get_order(size));
1042                 virt_addr = NULL;
1043                 goto out;
1044         }
1045
1046         if (iommu->need_sync)
1047                 iommu_completion_wait(iommu);
1048
1049 out:
1050         spin_unlock_irqrestore(&domain->lock, flags);
1051
1052         return virt_addr;
1053 }
1054
1055 /*
1056  * The exported free_coherent function for dma_ops.
1057  */
1058 static void free_coherent(struct device *dev, size_t size,
1059                           void *virt_addr, dma_addr_t dma_addr)
1060 {
1061         unsigned long flags;
1062         struct amd_iommu *iommu;
1063         struct protection_domain *domain;
1064         u16 devid;
1065
1066         if (!check_device(dev))
1067                 return;
1068
1069         get_device_resources(dev, &iommu, &domain, &devid);
1070
1071         if (!iommu || !domain)
1072                 goto free_mem;
1073
1074         spin_lock_irqsave(&domain->lock, flags);
1075
1076         __unmap_single(iommu, domain->priv, dma_addr, size, DMA_BIDIRECTIONAL);
1077
1078         if (iommu->need_sync)
1079                 iommu_completion_wait(iommu);
1080
1081         spin_unlock_irqrestore(&domain->lock, flags);
1082
1083 free_mem:
1084         free_pages((unsigned long)virt_addr, get_order(size));
1085 }
1086
1087 /*
1088  * The function for pre-allocating protection domains.
1089  *
1090  * If the driver core informs the DMA layer if a driver grabs a device
1091  * we don't need to preallocate the protection domains anymore.
1092  * For now we have to.
1093  */
1094 void prealloc_protection_domains(void)
1095 {
1096         struct pci_dev *dev = NULL;
1097         struct dma_ops_domain *dma_dom;
1098         struct amd_iommu *iommu;
1099         int order = amd_iommu_aperture_order;
1100         u16 devid;
1101
1102         while ((dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, dev)) != NULL) {
1103                 devid = (dev->bus->number << 8) | dev->devfn;
1104                 if (devid > amd_iommu_last_bdf)
1105                         continue;
1106                 devid = amd_iommu_alias_table[devid];
1107                 if (domain_for_device(devid))
1108                         continue;
1109                 iommu = amd_iommu_rlookup_table[devid];
1110                 if (!iommu)
1111                         continue;
1112                 dma_dom = dma_ops_domain_alloc(iommu, order);
1113                 if (!dma_dom)
1114                         continue;
1115                 init_unity_mappings_for_device(dma_dom, devid);
1116                 set_device_domain(iommu, &dma_dom->domain, devid);
1117                 printk(KERN_INFO "AMD IOMMU: Allocated domain %d for device ",
1118                        dma_dom->domain.id);
1119                 print_devid(devid, 1);
1120         }
1121 }
1122
1123 static struct dma_mapping_ops amd_iommu_dma_ops = {
1124         .alloc_coherent = alloc_coherent,
1125         .free_coherent = free_coherent,
1126         .map_single = map_single,
1127         .unmap_single = unmap_single,
1128         .map_sg = map_sg,
1129         .unmap_sg = unmap_sg,
1130 };
1131
1132 /*
1133  * The function which clues the AMD IOMMU driver into dma_ops.
1134  */
1135 int __init amd_iommu_init_dma_ops(void)
1136 {
1137         struct amd_iommu *iommu;
1138         int order = amd_iommu_aperture_order;
1139         int ret;
1140
1141         /*
1142          * first allocate a default protection domain for every IOMMU we
1143          * found in the system. Devices not assigned to any other
1144          * protection domain will be assigned to the default one.
1145          */
1146         list_for_each_entry(iommu, &amd_iommu_list, list) {
1147                 iommu->default_dom = dma_ops_domain_alloc(iommu, order);
1148                 if (iommu->default_dom == NULL)
1149                         return -ENOMEM;
1150                 ret = iommu_init_unity_mappings(iommu);
1151                 if (ret)
1152                         goto free_domains;
1153         }
1154
1155         /*
1156          * If device isolation is enabled, pre-allocate the protection
1157          * domains for each device.
1158          */
1159         if (amd_iommu_isolate)
1160                 prealloc_protection_domains();
1161
1162         iommu_detected = 1;
1163         force_iommu = 1;
1164         bad_dma_address = 0;
1165 #ifdef CONFIG_GART_IOMMU
1166         gart_iommu_aperture_disabled = 1;
1167         gart_iommu_aperture = 0;
1168 #endif
1169
1170         /* Make the driver finally visible to the drivers */
1171         dma_ops = &amd_iommu_dma_ops;
1172
1173         return 0;
1174
1175 free_domains:
1176
1177         list_for_each_entry(iommu, &amd_iommu_list, list) {
1178                 if (iommu->default_dom)
1179                         dma_ops_domain_free(iommu->default_dom);
1180         }
1181
1182         return ret;
1183 }