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