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