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