source: src/linux/universal/linux-3.18/drivers/iommu/intel-iommu.c @ 31869

Last change on this file since 31869 was 31869, checked in by brainslayer, 3 months ago

update

File size: 116.4 KB
Line 
1/*
2 * Copyright © 2006-2014 Intel Corporation.
3 *
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms and conditions of the GNU General Public License,
6 * version 2, as published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope it will be useful, but WITHOUT
9 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
11 * more details.
12 *
13 * Authors: David Woodhouse <dwmw2@infradead.org>,
14 *          Ashok Raj <ashok.raj@intel.com>,
15 *          Shaohua Li <shaohua.li@intel.com>,
16 *          Anil S Keshavamurthy <anil.s.keshavamurthy@intel.com>,
17 *          Fenghua Yu <fenghua.yu@intel.com>
18 */
19
20#include <linux/init.h>
21#include <linux/bitmap.h>
22#include <linux/debugfs.h>
23#include <linux/export.h>
24#include <linux/slab.h>
25#include <linux/irq.h>
26#include <linux/interrupt.h>
27#include <linux/spinlock.h>
28#include <linux/pci.h>
29#include <linux/dmar.h>
30#include <linux/dma-mapping.h>
31#include <linux/mempool.h>
32#include <linux/memory.h>
33#include <linux/timer.h>
34#include <linux/iova.h>
35#include <linux/iommu.h>
36#include <linux/intel-iommu.h>
37#include <linux/syscore_ops.h>
38#include <linux/tboot.h>
39#include <linux/dmi.h>
40#include <linux/pci-ats.h>
41#include <linux/memblock.h>
42#include <linux/dma-contiguous.h>
43#include <asm/irq_remapping.h>
44#include <asm/cacheflush.h>
45#include <asm/iommu.h>
46
47#include "irq_remapping.h"
48
49#define ROOT_SIZE               VTD_PAGE_SIZE
50#define CONTEXT_SIZE            VTD_PAGE_SIZE
51
52#define IS_GFX_DEVICE(pdev) ((pdev->class >> 16) == PCI_BASE_CLASS_DISPLAY)
53#define IS_USB_DEVICE(pdev) ((pdev->class >> 8) == PCI_CLASS_SERIAL_USB)
54#define IS_ISA_DEVICE(pdev) ((pdev->class >> 8) == PCI_CLASS_BRIDGE_ISA)
55#define IS_AZALIA(pdev) ((pdev)->vendor == 0x8086 && (pdev)->device == 0x3a3e)
56
57#define IOAPIC_RANGE_START      (0xfee00000)
58#define IOAPIC_RANGE_END        (0xfeefffff)
59#define IOVA_START_ADDR         (0x1000)
60
61#define DEFAULT_DOMAIN_ADDRESS_WIDTH 48
62
63#define MAX_AGAW_WIDTH 64
64#define MAX_AGAW_PFN_WIDTH      (MAX_AGAW_WIDTH - VTD_PAGE_SHIFT)
65
66#define __DOMAIN_MAX_PFN(gaw)  ((((uint64_t)1) << (gaw-VTD_PAGE_SHIFT)) - 1)
67#define __DOMAIN_MAX_ADDR(gaw) ((((uint64_t)1) << gaw) - 1)
68
69/* We limit DOMAIN_MAX_PFN to fit in an unsigned long, and DOMAIN_MAX_ADDR
70   to match. That way, we can use 'unsigned long' for PFNs with impunity. */
71#define DOMAIN_MAX_PFN(gaw)     ((unsigned long) min_t(uint64_t, \
72                                __DOMAIN_MAX_PFN(gaw), (unsigned long)-1))
73#define DOMAIN_MAX_ADDR(gaw)    (((uint64_t)__DOMAIN_MAX_PFN(gaw)) << VTD_PAGE_SHIFT)
74
75#define IOVA_PFN(addr)          ((addr) >> PAGE_SHIFT)
76#define DMA_32BIT_PFN           IOVA_PFN(DMA_BIT_MASK(32))
77#define DMA_64BIT_PFN           IOVA_PFN(DMA_BIT_MASK(64))
78
79/* page table handling */
80#define LEVEL_STRIDE            (9)
81#define LEVEL_MASK              (((u64)1 << LEVEL_STRIDE) - 1)
82
83/*
84 * This bitmap is used to advertise the page sizes our hardware support
85 * to the IOMMU core, which will then use this information to split
86 * physically contiguous memory regions it is mapping into page sizes
87 * that we support.
88 *
89 * Traditionally the IOMMU core just handed us the mappings directly,
90 * after making sure the size is an order of a 4KiB page and that the
91 * mapping has natural alignment.
92 *
93 * To retain this behavior, we currently advertise that we support
94 * all page sizes that are an order of 4KiB.
95 *
96 * If at some point we'd like to utilize the IOMMU core's new behavior,
97 * we could change this to advertise the real page sizes we support.
98 */
99#define INTEL_IOMMU_PGSIZES     (~0xFFFUL)
100
101static inline int agaw_to_level(int agaw)
102{
103        return agaw + 2;
104}
105
106static inline int agaw_to_width(int agaw)
107{
108        return min_t(int, 30 + agaw * LEVEL_STRIDE, MAX_AGAW_WIDTH);
109}
110
111static inline int width_to_agaw(int width)
112{
113        return DIV_ROUND_UP(width - 30, LEVEL_STRIDE);
114}
115
116static inline unsigned int level_to_offset_bits(int level)
117{
118        return (level - 1) * LEVEL_STRIDE;
119}
120
121static inline int pfn_level_offset(unsigned long pfn, int level)
122{
123        return (pfn >> level_to_offset_bits(level)) & LEVEL_MASK;
124}
125
126static inline unsigned long level_mask(int level)
127{
128        return -1UL << level_to_offset_bits(level);
129}
130
131static inline unsigned long level_size(int level)
132{
133        return 1UL << level_to_offset_bits(level);
134}
135
136static inline unsigned long align_to_level(unsigned long pfn, int level)
137{
138        return (pfn + level_size(level) - 1) & level_mask(level);
139}
140
141static inline unsigned long lvl_to_nr_pages(unsigned int lvl)
142{
143        return  1 << min_t(int, (lvl - 1) * LEVEL_STRIDE, MAX_AGAW_PFN_WIDTH);
144}
145
146/* VT-d pages must always be _smaller_ than MM pages. Otherwise things
147   are never going to work. */
148static inline unsigned long dma_to_mm_pfn(unsigned long dma_pfn)
149{
150        return dma_pfn >> (PAGE_SHIFT - VTD_PAGE_SHIFT);
151}
152
153static inline unsigned long mm_to_dma_pfn(unsigned long mm_pfn)
154{
155        return mm_pfn << (PAGE_SHIFT - VTD_PAGE_SHIFT);
156}
157static inline unsigned long page_to_dma_pfn(struct page *pg)
158{
159        return mm_to_dma_pfn(page_to_pfn(pg));
160}
161static inline unsigned long virt_to_dma_pfn(void *p)
162{
163        return page_to_dma_pfn(virt_to_page(p));
164}
165
166/* global iommu list, set NULL for ignored DMAR units */
167static struct intel_iommu **g_iommus;
168
169static void __init check_tylersburg_isoch(void);
170static int rwbf_quirk;
171
172/*
173 * set to 1 to panic kernel if can't successfully enable VT-d
174 * (used when kernel is launched w/ TXT)
175 */
176static int force_on = 0;
177
178/*
179 * 0: Present
180 * 1-11: Reserved
181 * 12-63: Context Ptr (12 - (haw-1))
182 * 64-127: Reserved
183 */
184struct root_entry {
185        u64     val;
186        u64     rsvd1;
187};
188#define ROOT_ENTRY_NR (VTD_PAGE_SIZE/sizeof(struct root_entry))
189static inline bool root_present(struct root_entry *root)
190{
191        return (root->val & 1);
192}
193static inline void set_root_present(struct root_entry *root)
194{
195        root->val |= 1;
196}
197static inline void set_root_value(struct root_entry *root, unsigned long value)
198{
199        root->val |= value & VTD_PAGE_MASK;
200}
201
202static inline struct context_entry *
203get_context_addr_from_root(struct root_entry *root)
204{
205        return (struct context_entry *)
206                (root_present(root)?phys_to_virt(
207                root->val & VTD_PAGE_MASK) :
208                NULL);
209}
210
211/*
212 * low 64 bits:
213 * 0: present
214 * 1: fault processing disable
215 * 2-3: translation type
216 * 12-63: address space root
217 * high 64 bits:
218 * 0-2: address width
219 * 3-6: aval
220 * 8-23: domain id
221 */
222struct context_entry {
223        u64 lo;
224        u64 hi;
225};
226
227static inline bool context_present(struct context_entry *context)
228{
229        return (context->lo & 1);
230}
231static inline void context_set_present(struct context_entry *context)
232{
233        context->lo |= 1;
234}
235
236static inline void context_set_fault_enable(struct context_entry *context)
237{
238        context->lo &= (((u64)-1) << 2) | 1;
239}
240
241static inline void context_set_translation_type(struct context_entry *context,
242                                                unsigned long value)
243{
244        context->lo &= (((u64)-1) << 4) | 3;
245        context->lo |= (value & 3) << 2;
246}
247
248static inline void context_set_address_root(struct context_entry *context,
249                                            unsigned long value)
250{
251        context->lo |= value & VTD_PAGE_MASK;
252}
253
254static inline void context_set_address_width(struct context_entry *context,
255                                             unsigned long value)
256{
257        context->hi |= value & 7;
258}
259
260static inline void context_set_domain_id(struct context_entry *context,
261                                         unsigned long value)
262{
263        context->hi |= (value & ((1 << 16) - 1)) << 8;
264}
265
266static inline void context_clear_entry(struct context_entry *context)
267{
268        context->lo = 0;
269        context->hi = 0;
270}
271
272/*
273 * 0: readable
274 * 1: writable
275 * 2-6: reserved
276 * 7: super page
277 * 8-10: available
278 * 11: snoop behavior
279 * 12-63: Host physcial address
280 */
281struct dma_pte {
282        u64 val;
283};
284
285static inline void dma_clear_pte(struct dma_pte *pte)
286{
287        pte->val = 0;
288}
289
290static inline u64 dma_pte_addr(struct dma_pte *pte)
291{
292#ifdef CONFIG_64BIT
293        return pte->val & VTD_PAGE_MASK;
294#else
295        /* Must have a full atomic 64-bit read */
296        return  __cmpxchg64(&pte->val, 0ULL, 0ULL) & VTD_PAGE_MASK;
297#endif
298}
299
300static inline bool dma_pte_present(struct dma_pte *pte)
301{
302        return (pte->val & 3) != 0;
303}
304
305static inline bool dma_pte_superpage(struct dma_pte *pte)
306{
307        return (pte->val & DMA_PTE_LARGE_PAGE);
308}
309
310static inline int first_pte_in_page(struct dma_pte *pte)
311{
312        return !((unsigned long)pte & ~VTD_PAGE_MASK);
313}
314
315/*
316 * This domain is a statically identity mapping domain.
317 *      1. This domain creats a static 1:1 mapping to all usable memory.
318 *      2. It maps to each iommu if successful.
319 *      3. Each iommu mapps to this domain if successful.
320 */
321static struct dmar_domain *si_domain;
322static int hw_pass_through = 1;
323
324/* domain represents a virtual machine, more than one devices
325 * across iommus may be owned in one domain, e.g. kvm guest.
326 */
327#define DOMAIN_FLAG_VIRTUAL_MACHINE     (1 << 0)
328
329/* si_domain contains mulitple devices */
330#define DOMAIN_FLAG_STATIC_IDENTITY     (1 << 1)
331
332/* define the limit of IOMMUs supported in each domain */
333#ifdef  CONFIG_X86
334# define        IOMMU_UNITS_SUPPORTED   MAX_IO_APICS
335#else
336# define        IOMMU_UNITS_SUPPORTED   64
337#endif
338
339struct dmar_domain {
340        int     id;                     /* domain id */
341        int     nid;                    /* node id */
342        DECLARE_BITMAP(iommu_bmp, IOMMU_UNITS_SUPPORTED);
343                                        /* bitmap of iommus this domain uses*/
344
345        struct list_head devices;       /* all devices' list */
346        struct iova_domain iovad;       /* iova's that belong to this domain */
347
348        struct dma_pte  *pgd;           /* virtual address */
349        int             gaw;            /* max guest address width */
350
351        /* adjusted guest address width, 0 is level 2 30-bit */
352        int             agaw;
353
354        int             flags;          /* flags to find out type of domain */
355
356        int             iommu_coherency;/* indicate coherency of iommu access */
357        int             iommu_snooping; /* indicate snooping control feature*/
358        int             iommu_count;    /* reference count of iommu */
359        int             iommu_superpage;/* Level of superpages supported:
360                                           0 == 4KiB (no superpages), 1 == 2MiB,
361                                           2 == 1GiB, 3 == 512GiB, 4 == 1TiB */
362        spinlock_t      iommu_lock;     /* protect iommu set in domain */
363        u64             max_addr;       /* maximum mapped address */
364};
365
366/* PCI domain-device relationship */
367struct device_domain_info {
368        struct list_head link;  /* link to domain siblings */
369        struct list_head global; /* link to global list */
370        u8 bus;                 /* PCI bus number */
371        u8 devfn;               /* PCI devfn number */
372        struct device *dev; /* it's NULL for PCIe-to-PCI bridge */
373        struct intel_iommu *iommu; /* IOMMU used by this device */
374        struct dmar_domain *domain; /* pointer to domain */
375};
376
377struct dmar_rmrr_unit {
378        struct list_head list;          /* list of rmrr units   */
379        struct acpi_dmar_header *hdr;   /* ACPI header          */
380        u64     base_address;           /* reserved base address*/
381        u64     end_address;            /* reserved end address */
382        struct dmar_dev_scope *devices; /* target devices */
383        int     devices_cnt;            /* target device count */
384};
385
386struct dmar_atsr_unit {
387        struct list_head list;          /* list of ATSR units */
388        struct acpi_dmar_header *hdr;   /* ACPI header */
389        struct dmar_dev_scope *devices; /* target devices */
390        int devices_cnt;                /* target device count */
391        u8 include_all:1;               /* include all ports */
392};
393
394static LIST_HEAD(dmar_atsr_units);
395static LIST_HEAD(dmar_rmrr_units);
396
397#define for_each_rmrr_units(rmrr) \
398        list_for_each_entry(rmrr, &dmar_rmrr_units, list)
399
400static void flush_unmaps_timeout(unsigned long data);
401
402static DEFINE_TIMER(unmap_timer,  flush_unmaps_timeout, 0, 0);
403
404#define HIGH_WATER_MARK 250
405struct deferred_flush_tables {
406        int next;
407        struct iova *iova[HIGH_WATER_MARK];
408        struct dmar_domain *domain[HIGH_WATER_MARK];
409        struct page *freelist[HIGH_WATER_MARK];
410};
411
412static struct deferred_flush_tables *deferred_flush;
413
414/* bitmap for indexing intel_iommus */
415static int g_num_of_iommus;
416
417static DEFINE_SPINLOCK(async_umap_flush_lock);
418static LIST_HEAD(unmaps_to_do);
419
420static int timer_on;
421static long list_size;
422
423static void domain_exit(struct dmar_domain *domain);
424static void domain_remove_dev_info(struct dmar_domain *domain);
425static void domain_remove_one_dev_info(struct dmar_domain *domain,
426                                       struct device *dev);
427static void iommu_detach_dependent_devices(struct intel_iommu *iommu,
428                                           struct device *dev);
429static int domain_detach_iommu(struct dmar_domain *domain,
430                               struct intel_iommu *iommu);
431
432#ifdef CONFIG_INTEL_IOMMU_DEFAULT_ON
433int dmar_disabled = 0;
434#else
435int dmar_disabled = 1;
436#endif /*CONFIG_INTEL_IOMMU_DEFAULT_ON*/
437
438int intel_iommu_enabled = 0;
439EXPORT_SYMBOL_GPL(intel_iommu_enabled);
440
441static int dmar_map_gfx = 1;
442static int dmar_forcedac;
443static int intel_iommu_strict;
444static int intel_iommu_superpage = 1;
445
446int intel_iommu_gfx_mapped;
447EXPORT_SYMBOL_GPL(intel_iommu_gfx_mapped);
448
449#define DUMMY_DEVICE_DOMAIN_INFO ((struct device_domain_info *)(-1))
450static DEFINE_SPINLOCK(device_domain_lock);
451static LIST_HEAD(device_domain_list);
452
453static const struct iommu_ops intel_iommu_ops;
454
455static int __init intel_iommu_setup(char *str)
456{
457        if (!str)
458                return -EINVAL;
459        while (*str) {
460                if (!strncmp(str, "on", 2)) {
461                        dmar_disabled = 0;
462                        printk(KERN_INFO "Intel-IOMMU: enabled\n");
463                } else if (!strncmp(str, "off", 3)) {
464                        dmar_disabled = 1;
465                        printk(KERN_INFO "Intel-IOMMU: disabled\n");
466                } else if (!strncmp(str, "igfx_off", 8)) {
467                        dmar_map_gfx = 0;
468                        printk(KERN_INFO
469                                "Intel-IOMMU: disable GFX device mapping\n");
470                } else if (!strncmp(str, "forcedac", 8)) {
471                        printk(KERN_INFO
472                                "Intel-IOMMU: Forcing DAC for PCI devices\n");
473                        dmar_forcedac = 1;
474                } else if (!strncmp(str, "strict", 6)) {
475                        printk(KERN_INFO
476                                "Intel-IOMMU: disable batched IOTLB flush\n");
477                        intel_iommu_strict = 1;
478                } else if (!strncmp(str, "sp_off", 6)) {
479                        printk(KERN_INFO
480                                "Intel-IOMMU: disable supported super page\n");
481                        intel_iommu_superpage = 0;
482                }
483
484                str += strcspn(str, ",");
485                while (*str == ',')
486                        str++;
487        }
488        return 0;
489}
490__setup("intel_iommu=", intel_iommu_setup);
491
492static struct kmem_cache *iommu_domain_cache;
493static struct kmem_cache *iommu_devinfo_cache;
494static struct kmem_cache *iommu_iova_cache;
495
496static inline void *alloc_pgtable_page(int node)
497{
498        struct page *page;
499        void *vaddr = NULL;
500
501        page = alloc_pages_node(node, GFP_ATOMIC | __GFP_ZERO, 0);
502        if (page)
503                vaddr = page_address(page);
504        return vaddr;
505}
506
507static inline void free_pgtable_page(void *vaddr)
508{
509        free_page((unsigned long)vaddr);
510}
511
512static inline void *alloc_domain_mem(void)
513{
514        return kmem_cache_alloc(iommu_domain_cache, GFP_ATOMIC);
515}
516
517static void free_domain_mem(void *vaddr)
518{
519        kmem_cache_free(iommu_domain_cache, vaddr);
520}
521
522static inline void * alloc_devinfo_mem(void)
523{
524        return kmem_cache_alloc(iommu_devinfo_cache, GFP_ATOMIC);
525}
526
527static inline void free_devinfo_mem(void *vaddr)
528{
529        kmem_cache_free(iommu_devinfo_cache, vaddr);
530}
531
532struct iova *alloc_iova_mem(void)
533{
534        return kmem_cache_alloc(iommu_iova_cache, GFP_ATOMIC);
535}
536
537void free_iova_mem(struct iova *iova)
538{
539        kmem_cache_free(iommu_iova_cache, iova);
540}
541
542static inline int domain_type_is_vm(struct dmar_domain *domain)
543{
544        return domain->flags & DOMAIN_FLAG_VIRTUAL_MACHINE;
545}
546
547static inline int domain_type_is_vm_or_si(struct dmar_domain *domain)
548{
549        return domain->flags & (DOMAIN_FLAG_VIRTUAL_MACHINE |
550                                DOMAIN_FLAG_STATIC_IDENTITY);
551}
552
553static inline int domain_pfn_supported(struct dmar_domain *domain,
554                                       unsigned long pfn)
555{
556        int addr_width = agaw_to_width(domain->agaw) - VTD_PAGE_SHIFT;
557
558        return !(addr_width < BITS_PER_LONG && pfn >> addr_width);
559}
560
561static int __iommu_calculate_agaw(struct intel_iommu *iommu, int max_gaw)
562{
563        unsigned long sagaw;
564        int agaw = -1;
565
566        sagaw = cap_sagaw(iommu->cap);
567        for (agaw = width_to_agaw(max_gaw);
568             agaw >= 0; agaw--) {
569                if (test_bit(agaw, &sagaw))
570                        break;
571        }
572
573        return agaw;
574}
575
576/*
577 * Calculate max SAGAW for each iommu.
578 */
579int iommu_calculate_max_sagaw(struct intel_iommu *iommu)
580{
581        return __iommu_calculate_agaw(iommu, MAX_AGAW_WIDTH);
582}
583
584/*
585 * calculate agaw for each iommu.
586 * "SAGAW" may be different across iommus, use a default agaw, and
587 * get a supported less agaw for iommus that don't support the default agaw.
588 */
589int iommu_calculate_agaw(struct intel_iommu *iommu)
590{
591        return __iommu_calculate_agaw(iommu, DEFAULT_DOMAIN_ADDRESS_WIDTH);
592}
593
594/* This functionin only returns single iommu in a domain */
595static struct intel_iommu *domain_get_iommu(struct dmar_domain *domain)
596{
597        int iommu_id;
598
599        /* si_domain and vm domain should not get here. */
600        BUG_ON(domain_type_is_vm_or_si(domain));
601        iommu_id = find_first_bit(domain->iommu_bmp, g_num_of_iommus);
602        if (iommu_id < 0 || iommu_id >= g_num_of_iommus)
603                return NULL;
604
605        return g_iommus[iommu_id];
606}
607
608static void domain_update_iommu_coherency(struct dmar_domain *domain)
609{
610        struct dmar_drhd_unit *drhd;
611        struct intel_iommu *iommu;
612        int i, found = 0;
613
614        domain->iommu_coherency = 1;
615
616        for_each_set_bit(i, domain->iommu_bmp, g_num_of_iommus) {
617                found = 1;
618                if (!ecap_coherent(g_iommus[i]->ecap)) {
619                        domain->iommu_coherency = 0;
620                        break;
621                }
622        }
623        if (found)
624                return;
625
626        /* No hardware attached; use lowest common denominator */
627        rcu_read_lock();
628        for_each_active_iommu(iommu, drhd) {
629                if (!ecap_coherent(iommu->ecap)) {
630                        domain->iommu_coherency = 0;
631                        break;
632                }
633        }
634        rcu_read_unlock();
635}
636
637static int domain_update_iommu_snooping(struct intel_iommu *skip)
638{
639        struct dmar_drhd_unit *drhd;
640        struct intel_iommu *iommu;
641        int ret = 1;
642
643        rcu_read_lock();
644        for_each_active_iommu(iommu, drhd) {
645                if (iommu != skip) {
646                        if (!ecap_sc_support(iommu->ecap)) {
647                                ret = 0;
648                                break;
649                        }
650                }
651        }
652        rcu_read_unlock();
653
654        return ret;
655}
656
657static int domain_update_iommu_superpage(struct intel_iommu *skip)
658{
659        struct dmar_drhd_unit *drhd;
660        struct intel_iommu *iommu;
661        int mask = 0xf;
662
663        if (!intel_iommu_superpage) {
664                return 0;
665        }
666
667        /* set iommu_superpage to the smallest common denominator */
668        rcu_read_lock();
669        for_each_active_iommu(iommu, drhd) {
670                if (iommu != skip) {
671                        mask &= cap_super_page_val(iommu->cap);
672                        if (!mask)
673                                break;
674                }
675        }
676        rcu_read_unlock();
677
678        return fls(mask);
679}
680
681/* Some capabilities may be different across iommus */
682static void domain_update_iommu_cap(struct dmar_domain *domain)
683{
684        domain_update_iommu_coherency(domain);
685        domain->iommu_snooping = domain_update_iommu_snooping(NULL);
686        domain->iommu_superpage = domain_update_iommu_superpage(NULL);
687}
688
689static struct intel_iommu *device_to_iommu(struct device *dev, u8 *bus, u8 *devfn)
690{
691        struct dmar_drhd_unit *drhd = NULL;
692        struct intel_iommu *iommu;
693        struct device *tmp;
694        struct pci_dev *ptmp, *pdev = NULL;
695        u16 segment = 0;
696        int i;
697
698        if (dev_is_pci(dev)) {
699                struct pci_dev *pf_pdev;
700
701                pdev = to_pci_dev(dev);
702                /* VFs aren't listed in scope tables; we need to look up
703                 * the PF instead to find the IOMMU. */
704                pf_pdev = pci_physfn(pdev);
705                dev = &pf_pdev->dev;
706                segment = pci_domain_nr(pdev->bus);
707        } else if (ACPI_COMPANION(dev))
708                dev = &ACPI_COMPANION(dev)->dev;
709
710        rcu_read_lock();
711        for_each_active_iommu(iommu, drhd) {
712                if (pdev && segment != drhd->segment)
713                        continue;
714
715                for_each_active_dev_scope(drhd->devices,
716                                          drhd->devices_cnt, i, tmp) {
717                        if (tmp == dev) {
718                                /* For a VF use its original BDF# not that of the PF
719                                 * which we used for the IOMMU lookup. Strictly speaking
720                                 * we could do this for all PCI devices; we only need to
721                                 * get the BDF# from the scope table for ACPI matches. */
722                                if (pdev->is_virtfn)
723                                        goto got_pdev;
724
725                                *bus = drhd->devices[i].bus;
726                                *devfn = drhd->devices[i].devfn;
727                                goto out;
728                        }
729
730                        if (!pdev || !dev_is_pci(tmp))
731                                continue;
732
733                        ptmp = to_pci_dev(tmp);
734                        if (ptmp->subordinate &&
735                            ptmp->subordinate->number <= pdev->bus->number &&
736                            ptmp->subordinate->busn_res.end >= pdev->bus->number)
737                                goto got_pdev;
738                }
739
740                if (pdev && drhd->include_all) {
741                got_pdev:
742                        *bus = pdev->bus->number;
743                        *devfn = pdev->devfn;
744                        goto out;
745                }
746        }
747        iommu = NULL;
748 out:
749        rcu_read_unlock();
750
751        return iommu;
752}
753
754static void domain_flush_cache(struct dmar_domain *domain,
755                               void *addr, int size)
756{
757        if (!domain->iommu_coherency)
758                clflush_cache_range(addr, size);
759}
760
761/* Gets context entry for a given bus and devfn */
762static struct context_entry * device_to_context_entry(struct intel_iommu *iommu,
763                u8 bus, u8 devfn)
764{
765        struct root_entry *root;
766        struct context_entry *context;
767        unsigned long phy_addr;
768        unsigned long flags;
769
770        spin_lock_irqsave(&iommu->lock, flags);
771        root = &iommu->root_entry[bus];
772        context = get_context_addr_from_root(root);
773        if (!context) {
774                context = (struct context_entry *)
775                                alloc_pgtable_page(iommu->node);
776                if (!context) {
777                        spin_unlock_irqrestore(&iommu->lock, flags);
778                        return NULL;
779                }
780                __iommu_flush_cache(iommu, (void *)context, CONTEXT_SIZE);
781                phy_addr = virt_to_phys((void *)context);
782                set_root_value(root, phy_addr);
783                set_root_present(root);
784                __iommu_flush_cache(iommu, root, sizeof(*root));
785        }
786        spin_unlock_irqrestore(&iommu->lock, flags);
787        return &context[devfn];
788}
789
790static int device_context_mapped(struct intel_iommu *iommu, u8 bus, u8 devfn)
791{
792        struct root_entry *root;
793        struct context_entry *context;
794        int ret;
795        unsigned long flags;
796
797        spin_lock_irqsave(&iommu->lock, flags);
798        root = &iommu->root_entry[bus];
799        context = get_context_addr_from_root(root);
800        if (!context) {
801                ret = 0;
802                goto out;
803        }
804        ret = context_present(&context[devfn]);
805out:
806        spin_unlock_irqrestore(&iommu->lock, flags);
807        return ret;
808}
809
810static void clear_context_table(struct intel_iommu *iommu, u8 bus, u8 devfn)
811{
812        struct root_entry *root;
813        struct context_entry *context;
814        unsigned long flags;
815
816        spin_lock_irqsave(&iommu->lock, flags);
817        root = &iommu->root_entry[bus];
818        context = get_context_addr_from_root(root);
819        if (context) {
820                context_clear_entry(&context[devfn]);
821                __iommu_flush_cache(iommu, &context[devfn], \
822                        sizeof(*context));
823        }
824        spin_unlock_irqrestore(&iommu->lock, flags);
825}
826
827static void free_context_table(struct intel_iommu *iommu)
828{
829        struct root_entry *root;
830        int i;
831        unsigned long flags;
832        struct context_entry *context;
833
834        spin_lock_irqsave(&iommu->lock, flags);
835        if (!iommu->root_entry) {
836                goto out;
837        }
838        for (i = 0; i < ROOT_ENTRY_NR; i++) {
839                root = &iommu->root_entry[i];
840                context = get_context_addr_from_root(root);
841                if (context)
842                        free_pgtable_page(context);
843        }
844        free_pgtable_page(iommu->root_entry);
845        iommu->root_entry = NULL;
846out:
847        spin_unlock_irqrestore(&iommu->lock, flags);
848}
849
850static struct dma_pte *pfn_to_dma_pte(struct dmar_domain *domain,
851                                      unsigned long pfn, int *target_level)
852{
853        struct dma_pte *parent, *pte = NULL;
854        int level = agaw_to_level(domain->agaw);
855        int offset;
856
857        BUG_ON(!domain->pgd);
858
859        if (!domain_pfn_supported(domain, pfn))
860                /* Address beyond IOMMU's addressing capabilities. */
861                return NULL;
862
863        parent = domain->pgd;
864
865        while (1) {
866                void *tmp_page;
867
868                offset = pfn_level_offset(pfn, level);
869                pte = &parent[offset];
870                if (!*target_level && (dma_pte_superpage(pte) || !dma_pte_present(pte)))
871                        break;
872                if (level == *target_level)
873                        break;
874
875                if (!dma_pte_present(pte)) {
876                        uint64_t pteval;
877
878                        tmp_page = alloc_pgtable_page(domain->nid);
879
880                        if (!tmp_page)
881                                return NULL;
882
883                        domain_flush_cache(domain, tmp_page, VTD_PAGE_SIZE);
884                        pteval = ((uint64_t)virt_to_dma_pfn(tmp_page) << VTD_PAGE_SHIFT) | DMA_PTE_READ | DMA_PTE_WRITE;
885                        if (cmpxchg64(&pte->val, 0ULL, pteval))
886                                /* Someone else set it while we were thinking; use theirs. */
887                                free_pgtable_page(tmp_page);
888                        else
889                                domain_flush_cache(domain, pte, sizeof(*pte));
890                }
891                if (level == 1)
892                        break;
893
894                parent = phys_to_virt(dma_pte_addr(pte));
895                level--;
896        }
897
898        if (!*target_level)
899                *target_level = level;
900
901        return pte;
902}
903
904
905/* return address's pte at specific level */
906static struct dma_pte *dma_pfn_level_pte(struct dmar_domain *domain,
907                                         unsigned long pfn,
908                                         int level, int *large_page)
909{
910        struct dma_pte *parent, *pte = NULL;
911        int total = agaw_to_level(domain->agaw);
912        int offset;
913
914        parent = domain->pgd;
915        while (level <= total) {
916                offset = pfn_level_offset(pfn, total);
917                pte = &parent[offset];
918                if (level == total)
919                        return pte;
920
921                if (!dma_pte_present(pte)) {
922                        *large_page = total;
923                        break;
924                }
925
926                if (dma_pte_superpage(pte)) {
927                        *large_page = total;
928                        return pte;
929                }
930
931                parent = phys_to_virt(dma_pte_addr(pte));
932                total--;
933        }
934        return NULL;
935}
936
937/* clear last level pte, a tlb flush should be followed */
938static void dma_pte_clear_range(struct dmar_domain *domain,
939                                unsigned long start_pfn,
940                                unsigned long last_pfn)
941{
942        unsigned int large_page = 1;
943        struct dma_pte *first_pte, *pte;
944
945        BUG_ON(!domain_pfn_supported(domain, start_pfn));
946        BUG_ON(!domain_pfn_supported(domain, last_pfn));
947        BUG_ON(start_pfn > last_pfn);
948
949        /* we don't need lock here; nobody else touches the iova range */
950        do {
951                large_page = 1;
952                first_pte = pte = dma_pfn_level_pte(domain, start_pfn, 1, &large_page);
953                if (!pte) {
954                        start_pfn = align_to_level(start_pfn + 1, large_page + 1);
955                        continue;
956                }
957                do {
958                        dma_clear_pte(pte);
959                        start_pfn += lvl_to_nr_pages(large_page);
960                        pte++;
961                } while (start_pfn <= last_pfn && !first_pte_in_page(pte));
962
963                domain_flush_cache(domain, first_pte,
964                                   (void *)pte - (void *)first_pte);
965
966        } while (start_pfn && start_pfn <= last_pfn);
967}
968
969static void dma_pte_free_level(struct dmar_domain *domain, int level,
970                               struct dma_pte *pte, unsigned long pfn,
971                               unsigned long start_pfn, unsigned long last_pfn)
972{
973        pfn = max(start_pfn, pfn);
974        pte = &pte[pfn_level_offset(pfn, level)];
975
976        do {
977                unsigned long level_pfn;
978                struct dma_pte *level_pte;
979
980                if (!dma_pte_present(pte) || dma_pte_superpage(pte))
981                        goto next;
982
983                level_pfn = pfn & level_mask(level - 1);
984                level_pte = phys_to_virt(dma_pte_addr(pte));
985
986                if (level > 2)
987                        dma_pte_free_level(domain, level - 1, level_pte,
988                                           level_pfn, start_pfn, last_pfn);
989
990                /* If range covers entire pagetable, free it */
991                if (!(start_pfn > level_pfn ||
992                      last_pfn < level_pfn + level_size(level) - 1)) {
993                        dma_clear_pte(pte);
994                        domain_flush_cache(domain, pte, sizeof(*pte));
995                        free_pgtable_page(level_pte);
996                }
997next:
998                pfn += level_size(level);
999        } while (!first_pte_in_page(++pte) && pfn <= last_pfn);
1000}
1001
1002/* free page table pages. last level pte should already be cleared */
1003static void dma_pte_free_pagetable(struct dmar_domain *domain,
1004                                   unsigned long start_pfn,
1005                                   unsigned long last_pfn)
1006{
1007        BUG_ON(!domain_pfn_supported(domain, start_pfn));
1008        BUG_ON(!domain_pfn_supported(domain, last_pfn));
1009        BUG_ON(start_pfn > last_pfn);
1010
1011        dma_pte_clear_range(domain, start_pfn, last_pfn);
1012
1013        /* We don't need lock here; nobody else touches the iova range */
1014        dma_pte_free_level(domain, agaw_to_level(domain->agaw),
1015                           domain->pgd, 0, start_pfn, last_pfn);
1016
1017        /* free pgd */
1018        if (start_pfn == 0 && last_pfn == DOMAIN_MAX_PFN(domain->gaw)) {
1019                free_pgtable_page(domain->pgd);
1020                domain->pgd = NULL;
1021        }
1022}
1023
1024/* When a page at a given level is being unlinked from its parent, we don't
1025   need to *modify* it at all. All we need to do is make a list of all the
1026   pages which can be freed just as soon as we've flushed the IOTLB and we
1027   know the hardware page-walk will no longer touch them.
1028   The 'pte' argument is the *parent* PTE, pointing to the page that is to
1029   be freed. */
1030static struct page *dma_pte_list_pagetables(struct dmar_domain *domain,
1031                                            int level, struct dma_pte *pte,
1032                                            struct page *freelist)
1033{
1034        struct page *pg;
1035
1036        pg = pfn_to_page(dma_pte_addr(pte) >> PAGE_SHIFT);
1037        pg->freelist = freelist;
1038        freelist = pg;
1039
1040        if (level == 1)
1041                return freelist;
1042
1043        pte = page_address(pg);
1044        do {
1045                if (dma_pte_present(pte) && !dma_pte_superpage(pte))
1046                        freelist = dma_pte_list_pagetables(domain, level - 1,
1047                                                           pte, freelist);
1048                pte++;
1049        } while (!first_pte_in_page(pte));
1050
1051        return freelist;
1052}
1053
1054static struct page *dma_pte_clear_level(struct dmar_domain *domain, int level,
1055                                        struct dma_pte *pte, unsigned long pfn,
1056                                        unsigned long start_pfn,
1057                                        unsigned long last_pfn,
1058                                        struct page *freelist)
1059{
1060        struct dma_pte *first_pte = NULL, *last_pte = NULL;
1061
1062        pfn = max(start_pfn, pfn);
1063        pte = &pte[pfn_level_offset(pfn, level)];
1064
1065        do {
1066                unsigned long level_pfn;
1067
1068                if (!dma_pte_present(pte))
1069                        goto next;
1070
1071                level_pfn = pfn & level_mask(level);
1072
1073                /* If range covers entire pagetable, free it */
1074                if (start_pfn <= level_pfn &&
1075                    last_pfn >= level_pfn + level_size(level) - 1) {
1076                        /* These suborbinate page tables are going away entirely. Don't
1077                           bother to clear them; we're just going to *free* them. */
1078                        if (level > 1 && !dma_pte_superpage(pte))
1079                                freelist = dma_pte_list_pagetables(domain, level - 1, pte, freelist);
1080
1081                        dma_clear_pte(pte);
1082                        if (!first_pte)
1083                                first_pte = pte;
1084                        last_pte = pte;
1085                } else if (level > 1) {
1086                        /* Recurse down into a level that isn't *entirely* obsolete */
1087                        freelist = dma_pte_clear_level(domain, level - 1,
1088                                                       phys_to_virt(dma_pte_addr(pte)),
1089                                                       level_pfn, start_pfn, last_pfn,
1090                                                       freelist);
1091                }
1092next:
1093                pfn += level_size(level);
1094        } while (!first_pte_in_page(++pte) && pfn <= last_pfn);
1095
1096        if (first_pte)
1097                domain_flush_cache(domain, first_pte,
1098                                   (void *)++last_pte - (void *)first_pte);
1099
1100        return freelist;
1101}
1102
1103/* We can't just free the pages because the IOMMU may still be walking
1104   the page tables, and may have cached the intermediate levels. The
1105   pages can only be freed after the IOTLB flush has been done. */
1106struct page *domain_unmap(struct dmar_domain *domain,
1107                          unsigned long start_pfn,
1108                          unsigned long last_pfn)
1109{
1110        struct page *freelist = NULL;
1111
1112        BUG_ON(!domain_pfn_supported(domain, start_pfn));
1113        BUG_ON(!domain_pfn_supported(domain, last_pfn));
1114        BUG_ON(start_pfn > last_pfn);
1115
1116        /* we don't need lock here; nobody else touches the iova range */
1117        freelist = dma_pte_clear_level(domain, agaw_to_level(domain->agaw),
1118                                       domain->pgd, 0, start_pfn, last_pfn, NULL);
1119
1120        /* free pgd */
1121        if (start_pfn == 0 && last_pfn == DOMAIN_MAX_PFN(domain->gaw)) {
1122                struct page *pgd_page = virt_to_page(domain->pgd);
1123                pgd_page->freelist = freelist;
1124                freelist = pgd_page;
1125
1126                domain->pgd = NULL;
1127        }
1128
1129        return freelist;
1130}
1131
1132void dma_free_pagelist(struct page *freelist)
1133{
1134        struct page *pg;
1135
1136        while ((pg = freelist)) {
1137                freelist = pg->freelist;
1138                free_pgtable_page(page_address(pg));
1139        }
1140}
1141
1142/* iommu handling */
1143static int iommu_alloc_root_entry(struct intel_iommu *iommu)
1144{
1145        struct root_entry *root;
1146        unsigned long flags;
1147
1148        root = (struct root_entry *)alloc_pgtable_page(iommu->node);
1149        if (!root)
1150                return -ENOMEM;
1151
1152        __iommu_flush_cache(iommu, root, ROOT_SIZE);
1153
1154        spin_lock_irqsave(&iommu->lock, flags);
1155        iommu->root_entry = root;
1156        spin_unlock_irqrestore(&iommu->lock, flags);
1157
1158        return 0;
1159}
1160
1161static void iommu_set_root_entry(struct intel_iommu *iommu)
1162{
1163        void *addr;
1164        u32 sts;
1165        unsigned long flag;
1166
1167        addr = iommu->root_entry;
1168
1169        raw_spin_lock_irqsave(&iommu->register_lock, flag);
1170        dmar_writeq(iommu->reg + DMAR_RTADDR_REG, virt_to_phys(addr));
1171
1172        writel(iommu->gcmd | DMA_GCMD_SRTP, iommu->reg + DMAR_GCMD_REG);
1173
1174        /* Make sure hardware complete it */
1175        IOMMU_WAIT_OP(iommu, DMAR_GSTS_REG,
1176                      readl, (sts & DMA_GSTS_RTPS), sts);
1177
1178        raw_spin_unlock_irqrestore(&iommu->register_lock, flag);
1179}
1180
1181static void iommu_flush_write_buffer(struct intel_iommu *iommu)
1182{
1183        u32 val;
1184        unsigned long flag;
1185
1186        if (!rwbf_quirk && !cap_rwbf(iommu->cap))
1187                return;
1188
1189        raw_spin_lock_irqsave(&iommu->register_lock, flag);
1190        writel(iommu->gcmd | DMA_GCMD_WBF, iommu->reg + DMAR_GCMD_REG);
1191
1192        /* Make sure hardware complete it */
1193        IOMMU_WAIT_OP(iommu, DMAR_GSTS_REG,
1194                      readl, (!(val & DMA_GSTS_WBFS)), val);
1195
1196        raw_spin_unlock_irqrestore(&iommu->register_lock, flag);
1197}
1198
1199/* return value determine if we need a write buffer flush */
1200static void __iommu_flush_context(struct intel_iommu *iommu,
1201                                  u16 did, u16 source_id, u8 function_mask,
1202                                  u64 type)
1203{
1204        u64 val = 0;
1205        unsigned long flag;
1206
1207        switch (type) {
1208        case DMA_CCMD_GLOBAL_INVL:
1209                val = DMA_CCMD_GLOBAL_INVL;
1210                break;
1211        case DMA_CCMD_DOMAIN_INVL:
1212                val = DMA_CCMD_DOMAIN_INVL|DMA_CCMD_DID(did);
1213                break;
1214        case DMA_CCMD_DEVICE_INVL:
1215                val = DMA_CCMD_DEVICE_INVL|DMA_CCMD_DID(did)
1216                        | DMA_CCMD_SID(source_id) | DMA_CCMD_FM(function_mask);
1217                break;
1218        default:
1219                BUG();
1220        }
1221        val |= DMA_CCMD_ICC;
1222
1223        raw_spin_lock_irqsave(&iommu->register_lock, flag);
1224        dmar_writeq(iommu->reg + DMAR_CCMD_REG, val);
1225
1226        /* Make sure hardware complete it */
1227        IOMMU_WAIT_OP(iommu, DMAR_CCMD_REG,
1228                dmar_readq, (!(val & DMA_CCMD_ICC)), val);
1229
1230        raw_spin_unlock_irqrestore(&iommu->register_lock, flag);
1231}
1232
1233/* return value determine if we need a write buffer flush */
1234static void __iommu_flush_iotlb(struct intel_iommu *iommu, u16 did,
1235                                u64 addr, unsigned int size_order, u64 type)
1236{
1237        int tlb_offset = ecap_iotlb_offset(iommu->ecap);
1238        u64 val = 0, val_iva = 0;
1239        unsigned long flag;
1240
1241        switch (type) {
1242        case DMA_TLB_GLOBAL_FLUSH:
1243                /* global flush doesn't need set IVA_REG */
1244                val = DMA_TLB_GLOBAL_FLUSH|DMA_TLB_IVT;
1245                break;
1246        case DMA_TLB_DSI_FLUSH:
1247                val = DMA_TLB_DSI_FLUSH|DMA_TLB_IVT|DMA_TLB_DID(did);
1248                break;
1249        case DMA_TLB_PSI_FLUSH:
1250                val = DMA_TLB_PSI_FLUSH|DMA_TLB_IVT|DMA_TLB_DID(did);
1251                /* IH bit is passed in as part of address */
1252                val_iva = size_order | addr;
1253                break;
1254        default:
1255                BUG();
1256        }
1257        /* Note: set drain read/write */
1258#if 0
1259        /*
1260         * This is probably to be super secure.. Looks like we can
1261         * ignore it without any impact.
1262         */
1263        if (cap_read_drain(iommu->cap))
1264                val |= DMA_TLB_READ_DRAIN;
1265#endif
1266        if (cap_write_drain(iommu->cap))
1267                val |= DMA_TLB_WRITE_DRAIN;
1268
1269        raw_spin_lock_irqsave(&iommu->register_lock, flag);
1270        /* Note: Only uses first TLB reg currently */
1271        if (val_iva)
1272                dmar_writeq(iommu->reg + tlb_offset, val_iva);
1273        dmar_writeq(iommu->reg + tlb_offset + 8, val);
1274
1275        /* Make sure hardware complete it */
1276        IOMMU_WAIT_OP(iommu, tlb_offset + 8,
1277                dmar_readq, (!(val & DMA_TLB_IVT)), val);
1278
1279        raw_spin_unlock_irqrestore(&iommu->register_lock, flag);
1280
1281        /* check IOTLB invalidation granularity */
1282        if (DMA_TLB_IAIG(val) == 0)
1283                printk(KERN_ERR"IOMMU: flush IOTLB failed\n");
1284        if (DMA_TLB_IAIG(val) != DMA_TLB_IIRG(type))
1285                pr_debug("IOMMU: tlb flush request %Lx, actual %Lx\n",
1286                        (unsigned long long)DMA_TLB_IIRG(type),
1287                        (unsigned long long)DMA_TLB_IAIG(val));
1288}
1289
1290static struct device_domain_info *
1291iommu_support_dev_iotlb (struct dmar_domain *domain, struct intel_iommu *iommu,
1292                         u8 bus, u8 devfn)
1293{
1294        int found = 0;
1295        unsigned long flags;
1296        struct device_domain_info *info;
1297        struct pci_dev *pdev;
1298
1299        if (!ecap_dev_iotlb_support(iommu->ecap))
1300                return NULL;
1301
1302        if (!iommu->qi)
1303                return NULL;
1304
1305        spin_lock_irqsave(&device_domain_lock, flags);
1306        list_for_each_entry(info, &domain->devices, link)
1307                if (info->iommu == iommu && info->bus == bus &&
1308                    info->devfn == devfn) {
1309                        found = 1;
1310                        break;
1311                }
1312        spin_unlock_irqrestore(&device_domain_lock, flags);
1313
1314        if (!found || !info->dev || !dev_is_pci(info->dev))
1315                return NULL;
1316
1317        pdev = to_pci_dev(info->dev);
1318
1319        if (!pci_find_ext_capability(pdev, PCI_EXT_CAP_ID_ATS))
1320                return NULL;
1321
1322        if (!dmar_find_matched_atsr_unit(pdev))
1323                return NULL;
1324
1325        return info;
1326}
1327
1328static void iommu_enable_dev_iotlb(struct device_domain_info *info)
1329{
1330        if (!info || !dev_is_pci(info->dev))
1331                return;
1332
1333        pci_enable_ats(to_pci_dev(info->dev), VTD_PAGE_SHIFT);
1334}
1335
1336static void iommu_disable_dev_iotlb(struct device_domain_info *info)
1337{
1338        if (!info->dev || !dev_is_pci(info->dev) ||
1339            !pci_ats_enabled(to_pci_dev(info->dev)))
1340                return;
1341
1342        pci_disable_ats(to_pci_dev(info->dev));
1343}
1344
1345static void iommu_flush_dev_iotlb(struct dmar_domain *domain,
1346                                  u64 addr, unsigned mask)
1347{
1348        u16 sid, qdep;
1349        unsigned long flags;
1350        struct device_domain_info *info;
1351
1352        spin_lock_irqsave(&device_domain_lock, flags);
1353        list_for_each_entry(info, &domain->devices, link) {
1354                struct pci_dev *pdev;
1355                if (!info->dev || !dev_is_pci(info->dev))
1356                        continue;
1357
1358                pdev = to_pci_dev(info->dev);
1359                if (!pci_ats_enabled(pdev))
1360                        continue;
1361
1362                sid = info->bus << 8 | info->devfn;
1363                qdep = pci_ats_queue_depth(pdev);
1364                qi_flush_dev_iotlb(info->iommu, sid, qdep, addr, mask);
1365        }
1366        spin_unlock_irqrestore(&device_domain_lock, flags);
1367}
1368
1369static void iommu_flush_iotlb_psi(struct intel_iommu *iommu, u16 did,
1370                                  unsigned long pfn, unsigned int pages, int ih, int map)
1371{
1372        unsigned int mask = ilog2(__roundup_pow_of_two(pages));
1373        uint64_t addr = (uint64_t)pfn << VTD_PAGE_SHIFT;
1374
1375        BUG_ON(pages == 0);
1376
1377        if (ih)
1378                ih = 1 << 6;
1379        /*
1380         * Fallback to domain selective flush if no PSI support or the size is
1381         * too big.
1382         * PSI requires page size to be 2 ^ x, and the base address is naturally
1383         * aligned to the size
1384         */
1385        if (!cap_pgsel_inv(iommu->cap) || mask > cap_max_amask_val(iommu->cap))
1386                iommu->flush.flush_iotlb(iommu, did, 0, 0,
1387                                                DMA_TLB_DSI_FLUSH);
1388        else
1389                iommu->flush.flush_iotlb(iommu, did, addr | ih, mask,
1390                                                DMA_TLB_PSI_FLUSH);
1391
1392        /*
1393         * In caching mode, changes of pages from non-present to present require
1394         * flush. However, device IOTLB doesn't need to be flushed in this case.
1395         */
1396        if (!cap_caching_mode(iommu->cap) || !map)
1397                iommu_flush_dev_iotlb(iommu->domains[did], addr, mask);
1398}
1399
1400static void iommu_disable_protect_mem_regions(struct intel_iommu *iommu)
1401{
1402        u32 pmen;
1403        unsigned long flags;
1404
1405        raw_spin_lock_irqsave(&iommu->register_lock, flags);
1406        pmen = readl(iommu->reg + DMAR_PMEN_REG);
1407        pmen &= ~DMA_PMEN_EPM;
1408        writel(pmen, iommu->reg + DMAR_PMEN_REG);
1409
1410        /* wait for the protected region status bit to clear */
1411        IOMMU_WAIT_OP(iommu, DMAR_PMEN_REG,
1412                readl, !(pmen & DMA_PMEN_PRS), pmen);
1413
1414        raw_spin_unlock_irqrestore(&iommu->register_lock, flags);
1415}
1416
1417static void iommu_enable_translation(struct intel_iommu *iommu)
1418{
1419        u32 sts;
1420        unsigned long flags;
1421
1422        raw_spin_lock_irqsave(&iommu->register_lock, flags);
1423        iommu->gcmd |= DMA_GCMD_TE;
1424        writel(iommu->gcmd, iommu->reg + DMAR_GCMD_REG);
1425
1426        /* Make sure hardware complete it */
1427        IOMMU_WAIT_OP(iommu, DMAR_GSTS_REG,
1428                      readl, (sts & DMA_GSTS_TES), sts);
1429
1430        raw_spin_unlock_irqrestore(&iommu->register_lock, flags);
1431}
1432
1433static void iommu_disable_translation(struct intel_iommu *iommu)
1434{
1435        u32 sts;
1436        unsigned long flag;
1437
1438        raw_spin_lock_irqsave(&iommu->register_lock, flag);
1439        iommu->gcmd &= ~DMA_GCMD_TE;
1440        writel(iommu->gcmd, iommu->reg + DMAR_GCMD_REG);
1441
1442        /* Make sure hardware complete it */
1443        IOMMU_WAIT_OP(iommu, DMAR_GSTS_REG,
1444                      readl, (!(sts & DMA_GSTS_TES)), sts);
1445
1446        raw_spin_unlock_irqrestore(&iommu->register_lock, flag);
1447}
1448
1449
1450static int iommu_init_domains(struct intel_iommu *iommu)
1451{
1452        unsigned long ndomains;
1453        unsigned long nlongs;
1454
1455        ndomains = cap_ndoms(iommu->cap);
1456        pr_debug("IOMMU%d: Number of Domains supported <%ld>\n",
1457                 iommu->seq_id, ndomains);
1458        nlongs = BITS_TO_LONGS(ndomains);
1459
1460        spin_lock_init(&iommu->lock);
1461
1462        /* TBD: there might be 64K domains,
1463         * consider other allocation for future chip
1464         */
1465        iommu->domain_ids = kcalloc(nlongs, sizeof(unsigned long), GFP_KERNEL);
1466        if (!iommu->domain_ids) {
1467                pr_err("IOMMU%d: allocating domain id array failed\n",
1468                       iommu->seq_id);
1469                return -ENOMEM;
1470        }
1471        iommu->domains = kcalloc(ndomains, sizeof(struct dmar_domain *),
1472                        GFP_KERNEL);
1473        if (!iommu->domains) {
1474                pr_err("IOMMU%d: allocating domain array failed\n",
1475                       iommu->seq_id);
1476                kfree(iommu->domain_ids);
1477                iommu->domain_ids = NULL;
1478                return -ENOMEM;
1479        }
1480
1481        /*
1482         * if Caching mode is set, then invalid translations are tagged
1483         * with domainid 0. Hence we need to pre-allocate it.
1484         */
1485        if (cap_caching_mode(iommu->cap))
1486                set_bit(0, iommu->domain_ids);
1487        return 0;
1488}
1489
1490static void free_dmar_iommu(struct intel_iommu *iommu)
1491{
1492        struct dmar_domain *domain;
1493        int i;
1494
1495        if ((iommu->domains) && (iommu->domain_ids)) {
1496                for_each_set_bit(i, iommu->domain_ids, cap_ndoms(iommu->cap)) {
1497                        /*
1498                         * Domain id 0 is reserved for invalid translation
1499                         * if hardware supports caching mode.
1500                         */
1501                        if (cap_caching_mode(iommu->cap) && i == 0)
1502                                continue;
1503
1504                        domain = iommu->domains[i];
1505                        clear_bit(i, iommu->domain_ids);
1506                        if (domain_detach_iommu(domain, iommu) == 0 &&
1507                            !domain_type_is_vm(domain))
1508                                domain_exit(domain);
1509                }
1510        }
1511
1512        if (iommu->gcmd & DMA_GCMD_TE)
1513                iommu_disable_translation(iommu);
1514
1515        kfree(iommu->domains);
1516        kfree(iommu->domain_ids);
1517        iommu->domains = NULL;
1518        iommu->domain_ids = NULL;
1519
1520        g_iommus[iommu->seq_id] = NULL;
1521
1522        /* free context mapping */
1523        free_context_table(iommu);
1524}
1525
1526static struct dmar_domain *alloc_domain(int flags)
1527{
1528        /* domain id for virtual machine, it won't be set in context */
1529        static atomic_t vm_domid = ATOMIC_INIT(0);
1530        struct dmar_domain *domain;
1531
1532        domain = alloc_domain_mem();
1533        if (!domain)
1534                return NULL;
1535
1536        memset(domain, 0, sizeof(*domain));
1537        domain->nid = -1;
1538        domain->flags = flags;
1539        spin_lock_init(&domain->iommu_lock);
1540        INIT_LIST_HEAD(&domain->devices);
1541        if (flags & DOMAIN_FLAG_VIRTUAL_MACHINE)
1542                domain->id = atomic_inc_return(&vm_domid);
1543
1544        return domain;
1545}
1546
1547static int __iommu_attach_domain(struct dmar_domain *domain,
1548                                 struct intel_iommu *iommu)
1549{
1550        int num;
1551        unsigned long ndomains;
1552
1553        ndomains = cap_ndoms(iommu->cap);
1554        num = find_first_zero_bit(iommu->domain_ids, ndomains);
1555        if (num < ndomains) {
1556                set_bit(num, iommu->domain_ids);
1557                iommu->domains[num] = domain;
1558        } else {
1559                num = -ENOSPC;
1560        }
1561
1562        return num;
1563}
1564
1565static int iommu_attach_domain(struct dmar_domain *domain,
1566                               struct intel_iommu *iommu)
1567{
1568        int num;
1569        unsigned long flags;
1570
1571        spin_lock_irqsave(&iommu->lock, flags);
1572        num = __iommu_attach_domain(domain, iommu);
1573        spin_unlock_irqrestore(&iommu->lock, flags);
1574        if (num < 0)
1575                pr_err("IOMMU: no free domain ids\n");
1576
1577        return num;
1578}
1579
1580static int iommu_attach_vm_domain(struct dmar_domain *domain,
1581                                  struct intel_iommu *iommu)
1582{
1583        int num;
1584        unsigned long ndomains;
1585
1586        ndomains = cap_ndoms(iommu->cap);
1587        for_each_set_bit(num, iommu->domain_ids, ndomains)
1588                if (iommu->domains[num] == domain)
1589                        return num;
1590
1591        return __iommu_attach_domain(domain, iommu);
1592}
1593
1594static void iommu_detach_domain(struct dmar_domain *domain,
1595                                struct intel_iommu *iommu)
1596{
1597        unsigned long flags;
1598        int num, ndomains;
1599
1600        spin_lock_irqsave(&iommu->lock, flags);
1601        if (domain_type_is_vm_or_si(domain)) {
1602                ndomains = cap_ndoms(iommu->cap);
1603                for_each_set_bit(num, iommu->domain_ids, ndomains) {
1604                        if (iommu->domains[num] == domain) {
1605                                clear_bit(num, iommu->domain_ids);
1606                                iommu->domains[num] = NULL;
1607                                break;
1608                        }
1609                }
1610        } else {
1611                clear_bit(domain->id, iommu->domain_ids);
1612                iommu->domains[domain->id] = NULL;
1613        }
1614        spin_unlock_irqrestore(&iommu->lock, flags);
1615}
1616
1617static void domain_attach_iommu(struct dmar_domain *domain,
1618                               struct intel_iommu *iommu)
1619{
1620        unsigned long flags;
1621
1622        spin_lock_irqsave(&domain->iommu_lock, flags);
1623        if (!test_and_set_bit(iommu->seq_id, domain->iommu_bmp)) {
1624                domain->iommu_count++;
1625                if (domain->iommu_count == 1)
1626                        domain->nid = iommu->node;
1627                domain_update_iommu_cap(domain);
1628        }
1629        spin_unlock_irqrestore(&domain->iommu_lock, flags);
1630}
1631
1632static int domain_detach_iommu(struct dmar_domain *domain,
1633                               struct intel_iommu *iommu)
1634{
1635        unsigned long flags;
1636        int count = INT_MAX;
1637
1638        spin_lock_irqsave(&domain->iommu_lock, flags);
1639        if (test_and_clear_bit(iommu->seq_id, domain->iommu_bmp)) {
1640                count = --domain->iommu_count;
1641                domain_update_iommu_cap(domain);
1642        }
1643        spin_unlock_irqrestore(&domain->iommu_lock, flags);
1644
1645        return count;
1646}
1647
1648static struct iova_domain reserved_iova_list;
1649static struct lock_class_key reserved_rbtree_key;
1650
1651static int dmar_init_reserved_ranges(void)
1652{
1653        struct pci_dev *pdev = NULL;
1654        struct iova *iova;
1655        int i;
1656
1657        init_iova_domain(&reserved_iova_list, DMA_32BIT_PFN);
1658
1659        lockdep_set_class(&reserved_iova_list.iova_rbtree_lock,
1660                &reserved_rbtree_key);
1661
1662        /* IOAPIC ranges shouldn't be accessed by DMA */
1663        iova = reserve_iova(&reserved_iova_list, IOVA_PFN(IOAPIC_RANGE_START),
1664                IOVA_PFN(IOAPIC_RANGE_END));
1665        if (!iova) {
1666                printk(KERN_ERR "Reserve IOAPIC range failed\n");
1667                return -ENODEV;
1668        }
1669
1670        /* Reserve all PCI MMIO to avoid peer-to-peer access */
1671        for_each_pci_dev(pdev) {
1672                struct resource *r;
1673
1674                for (i = 0; i < PCI_NUM_RESOURCES; i++) {
1675                        r = &pdev->resource[i];
1676                        if (!r->flags || !(r->flags & IORESOURCE_MEM))
1677                                continue;
1678                        iova = reserve_iova(&reserved_iova_list,
1679                                            IOVA_PFN(r->start),
1680                                            IOVA_PFN(r->end));
1681                        if (!iova) {
1682                                printk(KERN_ERR "Reserve iova failed\n");
1683                                return -ENODEV;
1684                        }
1685                }
1686        }
1687        return 0;
1688}
1689
1690static void domain_reserve_special_ranges(struct dmar_domain *domain)
1691{
1692        copy_reserved_iova(&reserved_iova_list, &domain->iovad);
1693}
1694
1695static inline int guestwidth_to_adjustwidth(int gaw)
1696{
1697        int agaw;
1698        int r = (gaw - 12) % 9;
1699
1700        if (r == 0)
1701                agaw = gaw;
1702        else
1703                agaw = gaw + 9 - r;
1704        if (agaw > 64)
1705                agaw = 64;
1706        return agaw;
1707}
1708
1709static int domain_init(struct dmar_domain *domain, int guest_width)
1710{
1711        struct intel_iommu *iommu;
1712        int adjust_width, agaw;
1713        unsigned long sagaw;
1714
1715        init_iova_domain(&domain->iovad, DMA_32BIT_PFN);
1716        domain_reserve_special_ranges(domain);
1717
1718        /* calculate AGAW */
1719        iommu = domain_get_iommu(domain);
1720        if (guest_width > cap_mgaw(iommu->cap))
1721                guest_width = cap_mgaw(iommu->cap);
1722        domain->gaw = guest_width;
1723        adjust_width = guestwidth_to_adjustwidth(guest_width);
1724        agaw = width_to_agaw(adjust_width);
1725        sagaw = cap_sagaw(iommu->cap);
1726        if (!test_bit(agaw, &sagaw)) {
1727                /* hardware doesn't support it, choose a bigger one */
1728                pr_debug("IOMMU: hardware doesn't support agaw %d\n", agaw);
1729                agaw = find_next_bit(&sagaw, 5, agaw);
1730                if (agaw >= 5)
1731                        return -ENODEV;
1732        }
1733        domain->agaw = agaw;
1734
1735        if (ecap_coherent(iommu->ecap))
1736                domain->iommu_coherency = 1;
1737        else
1738                domain->iommu_coherency = 0;
1739
1740        if (ecap_sc_support(iommu->ecap))
1741                domain->iommu_snooping = 1;
1742        else
1743                domain->iommu_snooping = 0;
1744
1745        if (intel_iommu_superpage)
1746                domain->iommu_superpage = fls(cap_super_page_val(iommu->cap));
1747        else
1748                domain->iommu_superpage = 0;
1749
1750        domain->nid = iommu->node;
1751
1752        /* always allocate the top pgd */
1753        domain->pgd = (struct dma_pte *)alloc_pgtable_page(domain->nid);
1754        if (!domain->pgd)
1755                return -ENOMEM;
1756        __iommu_flush_cache(iommu, domain->pgd, PAGE_SIZE);
1757        return 0;
1758}
1759
1760static void domain_exit(struct dmar_domain *domain)
1761{
1762        struct dmar_drhd_unit *drhd;
1763        struct page *freelist = NULL;
1764        int i;
1765
1766        /* Domain 0 is reserved, so dont process it */
1767        if (!domain)
1768                return;
1769
1770        /* Flush any lazy unmaps that may reference this domain */
1771        if (!intel_iommu_strict)
1772                flush_unmaps_timeout(0);
1773
1774        /* remove associated devices */
1775        domain_remove_dev_info(domain);
1776
1777        /* destroy iovas */
1778        put_iova_domain(&domain->iovad);
1779
1780        freelist = domain_unmap(domain, 0, DOMAIN_MAX_PFN(domain->gaw));
1781
1782        /* clear attached or cached domains */
1783        rcu_read_lock();
1784        for_each_set_bit(i, domain->iommu_bmp, g_num_of_iommus)
1785                iommu_detach_domain(domain, g_iommus[i]);
1786        rcu_read_unlock();
1787
1788        dma_free_pagelist(freelist);
1789
1790        free_domain_mem(domain);
1791}
1792
1793static int domain_context_mapping_one(struct dmar_domain *domain,
1794                                      struct intel_iommu *iommu,
1795                                      u8 bus, u8 devfn, int translation)
1796{
1797        struct context_entry *context;
1798        unsigned long flags;
1799        struct dma_pte *pgd;
1800        int id;
1801        int agaw;
1802        struct device_domain_info *info = NULL;
1803
1804        pr_debug("Set context mapping for %02x:%02x.%d\n",
1805                bus, PCI_SLOT(devfn), PCI_FUNC(devfn));
1806
1807        BUG_ON(!domain->pgd);
1808        BUG_ON(translation != CONTEXT_TT_PASS_THROUGH &&
1809               translation != CONTEXT_TT_MULTI_LEVEL);
1810
1811        context = device_to_context_entry(iommu, bus, devfn);
1812        if (!context)
1813                return -ENOMEM;
1814        spin_lock_irqsave(&iommu->lock, flags);
1815        if (context_present(context)) {
1816                spin_unlock_irqrestore(&iommu->lock, flags);
1817                return 0;
1818        }
1819
1820        id = domain->id;
1821        pgd = domain->pgd;
1822
1823        if (domain_type_is_vm_or_si(domain)) {
1824                if (domain_type_is_vm(domain)) {
1825                        id = iommu_attach_vm_domain(domain, iommu);
1826                        if (id < 0) {
1827                                spin_unlock_irqrestore(&iommu->lock, flags);
1828                                pr_err("IOMMU: no free domain ids\n");
1829                                return -EFAULT;
1830                        }
1831                }
1832
1833                /* Skip top levels of page tables for
1834                 * iommu which has less agaw than default.
1835                 * Unnecessary for PT mode.
1836                 */
1837                if (translation != CONTEXT_TT_PASS_THROUGH) {
1838                        for (agaw = domain->agaw; agaw != iommu->agaw; agaw--) {
1839                                pgd = phys_to_virt(dma_pte_addr(pgd));
1840                                if (!dma_pte_present(pgd)) {
1841                                        spin_unlock_irqrestore(&iommu->lock, flags);
1842                                        return -ENOMEM;
1843                                }
1844                        }
1845                }
1846        }
1847
1848        context_set_domain_id(context, id);
1849
1850        if (translation != CONTEXT_TT_PASS_THROUGH) {
1851                info = iommu_support_dev_iotlb(domain, iommu, bus, devfn);
1852                translation = info ? CONTEXT_TT_DEV_IOTLB :
1853                                     CONTEXT_TT_MULTI_LEVEL;
1854        }
1855        /*
1856         * In pass through mode, AW must be programmed to indicate the largest
1857         * AGAW value supported by hardware. And ASR is ignored by hardware.
1858         */
1859        if (unlikely(translation == CONTEXT_TT_PASS_THROUGH))
1860                context_set_address_width(context, iommu->msagaw);
1861        else {
1862                context_set_address_root(context, virt_to_phys(pgd));
1863                context_set_address_width(context, iommu->agaw);
1864        }
1865
1866        context_set_translation_type(context, translation);
1867        context_set_fault_enable(context);
1868        context_set_present(context);
1869        domain_flush_cache(domain, context, sizeof(*context));
1870
1871        /*
1872         * It's a non-present to present mapping. If hardware doesn't cache
1873         * non-present entry we only need to flush the write-buffer. If the
1874         * _does_ cache non-present entries, then it does so in the special
1875         * domain #0, which we have to flush:
1876         */
1877        if (cap_caching_mode(iommu->cap)) {
1878                iommu->flush.flush_context(iommu, 0,
1879                                           (((u16)bus) << 8) | devfn,
1880                                           DMA_CCMD_MASK_NOBIT,
1881                                           DMA_CCMD_DEVICE_INVL);
1882                iommu->flush.flush_iotlb(iommu, id, 0, 0, DMA_TLB_DSI_FLUSH);
1883        } else {
1884                iommu_flush_write_buffer(iommu);
1885        }
1886        iommu_enable_dev_iotlb(info);
1887        spin_unlock_irqrestore(&iommu->lock, flags);
1888
1889        domain_attach_iommu(domain, iommu);
1890
1891        return 0;
1892}
1893
1894struct domain_context_mapping_data {
1895        struct dmar_domain *domain;
1896        struct intel_iommu *iommu;
1897        int translation;
1898};
1899
1900static int domain_context_mapping_cb(struct pci_dev *pdev,
1901                                     u16 alias, void *opaque)
1902{
1903        struct domain_context_mapping_data *data = opaque;
1904
1905        return domain_context_mapping_one(data->domain, data->iommu,
1906                                          PCI_BUS_NUM(alias), alias & 0xff,
1907                                          data->translation);
1908}
1909
1910static int
1911domain_context_mapping(struct dmar_domain *domain, struct device *dev,
1912                       int translation)
1913{
1914        struct intel_iommu *iommu;
1915        u8 bus, devfn;
1916        struct domain_context_mapping_data data;
1917
1918        iommu = device_to_iommu(dev, &bus, &devfn);
1919        if (!iommu)
1920                return -ENODEV;
1921
1922        if (!dev_is_pci(dev))
1923                return domain_context_mapping_one(domain, iommu, bus, devfn,
1924                                                  translation);
1925
1926        data.domain = domain;
1927        data.iommu = iommu;
1928        data.translation = translation;
1929
1930        return pci_for_each_dma_alias(to_pci_dev(dev),
1931                                      &domain_context_mapping_cb, &data);
1932}
1933
1934static int domain_context_mapped_cb(struct pci_dev *pdev,
1935                                    u16 alias, void *opaque)
1936{
1937        struct intel_iommu *iommu = opaque;
1938
1939        return !device_context_mapped(iommu, PCI_BUS_NUM(alias), alias & 0xff);
1940}
1941
1942static int domain_context_mapped(struct device *dev)
1943{
1944        struct intel_iommu *iommu;
1945        u8 bus, devfn;
1946
1947        iommu = device_to_iommu(dev, &bus, &devfn);
1948        if (!iommu)
1949                return -ENODEV;
1950
1951        if (!dev_is_pci(dev))
1952                return device_context_mapped(iommu, bus, devfn);
1953
1954        return !pci_for_each_dma_alias(to_pci_dev(dev),
1955                                       domain_context_mapped_cb, iommu);
1956}
1957
1958/* Returns a number of VTD pages, but aligned to MM page size */
1959static inline unsigned long aligned_nrpages(unsigned long host_addr,
1960                                            size_t size)
1961{
1962        host_addr &= ~PAGE_MASK;
1963        return PAGE_ALIGN(host_addr + size) >> VTD_PAGE_SHIFT;
1964}
1965
1966/* Return largest possible superpage level for a given mapping */
1967static inline int hardware_largepage_caps(struct dmar_domain *domain,
1968                                          unsigned long iov_pfn,
1969                                          unsigned long phy_pfn,
1970                                          unsigned long pages)
1971{
1972        int support, level = 1;
1973        unsigned long pfnmerge;
1974
1975        support = domain->iommu_superpage;
1976
1977        /* To use a large page, the virtual *and* physical addresses
1978           must be aligned to 2MiB/1GiB/etc. Lower bits set in either
1979           of them will mean we have to use smaller pages. So just
1980           merge them and check both at once. */
1981        pfnmerge = iov_pfn | phy_pfn;
1982
1983        while (support && !(pfnmerge & ~VTD_STRIDE_MASK)) {
1984                pages >>= VTD_STRIDE_SHIFT;
1985                if (!pages)
1986                        break;
1987                pfnmerge >>= VTD_STRIDE_SHIFT;
1988                level++;
1989                support--;
1990        }
1991        return level;
1992}
1993
1994static int __domain_mapping(struct dmar_domain *domain, unsigned long iov_pfn,
1995                            struct scatterlist *sg, unsigned long phys_pfn,
1996                            unsigned long nr_pages, int prot)
1997{
1998        struct dma_pte *first_pte = NULL, *pte = NULL;
1999        phys_addr_t uninitialized_var(pteval);
2000        unsigned long sg_res = 0;
2001        unsigned int largepage_lvl = 0;
2002        unsigned long lvl_pages = 0;
2003
2004        BUG_ON(!domain_pfn_supported(domain, iov_pfn + nr_pages - 1));
2005
2006        if ((prot & (DMA_PTE_READ|DMA_PTE_WRITE)) == 0)
2007                return -EINVAL;
2008
2009        prot &= DMA_PTE_READ | DMA_PTE_WRITE | DMA_PTE_SNP;
2010
2011        if (!sg) {
2012                sg_res = nr_pages;
2013                pteval = ((phys_addr_t)phys_pfn << VTD_PAGE_SHIFT) | prot;
2014        }
2015
2016        while (nr_pages > 0) {
2017                uint64_t tmp;
2018
2019                if (!sg_res) {
2020                        sg_res = aligned_nrpages(sg->offset, sg->length);
2021                        sg->dma_address = ((dma_addr_t)iov_pfn << VTD_PAGE_SHIFT) + sg->offset;
2022                        sg->dma_length = sg->length;
2023                        pteval = page_to_phys(sg_page(sg)) | prot;
2024                        phys_pfn = pteval >> VTD_PAGE_SHIFT;
2025                }
2026
2027                if (!pte) {
2028                        largepage_lvl = hardware_largepage_caps(domain, iov_pfn, phys_pfn, sg_res);
2029
2030                        first_pte = pte = pfn_to_dma_pte(domain, iov_pfn, &largepage_lvl);
2031                        if (!pte)
2032                                return -ENOMEM;
2033                        /* It is large page*/
2034                        if (largepage_lvl > 1) {
2035                                pteval |= DMA_PTE_LARGE_PAGE;
2036                                lvl_pages = lvl_to_nr_pages(largepage_lvl);
2037                                /*
2038                                 * Ensure that old small page tables are
2039                                 * removed to make room for superpage,
2040                                 * if they exist.
2041                                 */
2042                                dma_pte_free_pagetable(domain, iov_pfn,
2043                                                       iov_pfn + lvl_pages - 1);
2044                        } else {
2045                                pteval &= ~(uint64_t)DMA_PTE_LARGE_PAGE;
2046                        }
2047
2048                }
2049                /* We don't need lock here, nobody else
2050                 * touches the iova range
2051                 */
2052                tmp = cmpxchg64_local(&pte->val, 0ULL, pteval);
2053                if (tmp) {
2054                        static int dumps = 5;
2055                        printk(KERN_CRIT "ERROR: DMA PTE for vPFN 0x%lx already set (to %llx not %llx)\n",
2056                               iov_pfn, tmp, (unsigned long long)pteval);
2057                        if (dumps) {
2058                                dumps--;
2059                                debug_dma_dump_mappings(NULL);
2060                        }
2061                        WARN_ON(1);
2062                }
2063
2064                lvl_pages = lvl_to_nr_pages(largepage_lvl);
2065
2066                BUG_ON(nr_pages < lvl_pages);
2067                BUG_ON(sg_res < lvl_pages);
2068
2069                nr_pages -= lvl_pages;
2070                iov_pfn += lvl_pages;
2071                phys_pfn += lvl_pages;
2072                pteval += lvl_pages * VTD_PAGE_SIZE;
2073                sg_res -= lvl_pages;
2074
2075                /* If the next PTE would be the first in a new page, then we
2076                   need to flush the cache on the entries we've just written.
2077                   And then we'll need to recalculate 'pte', so clear it and
2078                   let it get set again in the if (!pte) block above.
2079
2080                   If we're done (!nr_pages) we need to flush the cache too.
2081
2082                   Also if we've been setting superpages, we may need to
2083                   recalculate 'pte' and switch back to smaller pages for the
2084                   end of the mapping, if the trailing size is not enough to
2085                   use another superpage (i.e. sg_res < lvl_pages). */
2086                pte++;
2087                if (!nr_pages || first_pte_in_page(pte) ||
2088                    (largepage_lvl > 1 && sg_res < lvl_pages)) {
2089                        domain_flush_cache(domain, first_pte,
2090                                           (void *)pte - (void *)first_pte);
2091                        pte = NULL;
2092                }
2093
2094                if (!sg_res && nr_pages)
2095                        sg = sg_next(sg);
2096        }
2097        return 0;
2098}
2099
2100static inline int domain_sg_mapping(struct dmar_domain *domain, unsigned long iov_pfn,
2101                                    struct scatterlist *sg, unsigned long nr_pages,
2102                                    int prot)
2103{
2104        return __domain_mapping(domain, iov_pfn, sg, 0, nr_pages, prot);
2105}
2106
2107static inline int domain_pfn_mapping(struct dmar_domain *domain, unsigned long iov_pfn,
2108                                     unsigned long phys_pfn, unsigned long nr_pages,
2109                                     int prot)
2110{
2111        return __domain_mapping(domain, iov_pfn, NULL, phys_pfn, nr_pages, prot);
2112}
2113
2114static void iommu_detach_dev(struct intel_iommu *iommu, u8 bus, u8 devfn)
2115{
2116        if (!iommu)
2117                return;
2118
2119        clear_context_table(iommu, bus, devfn);
2120        iommu->flush.flush_context(iommu, 0, 0, 0,
2121                                           DMA_CCMD_GLOBAL_INVL);
2122        iommu->flush.flush_iotlb(iommu, 0, 0, 0, DMA_TLB_GLOBAL_FLUSH);
2123}
2124
2125static inline void unlink_domain_info(struct device_domain_info *info)
2126{
2127        assert_spin_locked(&device_domain_lock);
2128        list_del(&info->link);
2129        list_del(&info->global);
2130        if (info->dev)
2131                info->dev->archdata.iommu = NULL;
2132}
2133
2134static void domain_remove_dev_info(struct dmar_domain *domain)
2135{
2136        struct device_domain_info *info, *tmp;
2137        unsigned long flags;
2138
2139        spin_lock_irqsave(&device_domain_lock, flags);
2140        list_for_each_entry_safe(info, tmp, &domain->devices, link) {
2141                unlink_domain_info(info);
2142                spin_unlock_irqrestore(&device_domain_lock, flags);
2143
2144                iommu_disable_dev_iotlb(info);
2145                iommu_detach_dev(info->iommu, info->bus, info->devfn);
2146
2147                if (domain_type_is_vm(domain)) {
2148                        iommu_detach_dependent_devices(info->iommu, info->dev);
2149                        domain_detach_iommu(domain, info->iommu);
2150                }
2151
2152                free_devinfo_mem(info);
2153                spin_lock_irqsave(&device_domain_lock, flags);
2154        }
2155        spin_unlock_irqrestore(&device_domain_lock, flags);
2156}
2157
2158/*
2159 * find_domain
2160 * Note: we use struct device->archdata.iommu stores the info
2161 */
2162static struct dmar_domain *find_domain(struct device *dev)
2163{
2164        struct device_domain_info *info;
2165
2166        /* No lock here, assumes no domain exit in normal case */
2167        info = dev->archdata.iommu;
2168        if (info)
2169                return info->domain;
2170        return NULL;
2171}
2172
2173static inline struct device_domain_info *
2174dmar_search_domain_by_dev_info(int segment, int bus, int devfn)
2175{
2176        struct device_domain_info *info;
2177
2178        list_for_each_entry(info, &device_domain_list, global)
2179                if (info->iommu->segment == segment && info->bus == bus &&
2180                    info->devfn == devfn)
2181                        return info;
2182
2183        return NULL;
2184}
2185
2186static struct dmar_domain *dmar_insert_dev_info(struct intel_iommu *iommu,
2187                                                int bus, int devfn,
2188                                                struct device *dev,
2189                                                struct dmar_domain *domain)
2190{
2191        struct dmar_domain *found = NULL;
2192        struct device_domain_info *info;
2193        unsigned long flags;
2194
2195        info = alloc_devinfo_mem();
2196        if (!info)
2197                return NULL;
2198
2199        info->bus = bus;
2200        info->devfn = devfn;
2201        info->dev = dev;
2202        info->domain = domain;
2203        info->iommu = iommu;
2204
2205        spin_lock_irqsave(&device_domain_lock, flags);
2206        if (dev)
2207                found = find_domain(dev);
2208        else {
2209                struct device_domain_info *info2;
2210                info2 = dmar_search_domain_by_dev_info(iommu->segment, bus, devfn);
2211                if (info2)
2212                        found = info2->domain;
2213        }
2214        if (found) {
2215                spin_unlock_irqrestore(&device_domain_lock, flags);
2216                free_devinfo_mem(info);
2217                /* Caller must free the original domain */
2218                return found;
2219        }
2220
2221        list_add(&info->link, &domain->devices);
2222        list_add(&info->global, &device_domain_list);
2223        if (dev)
2224                dev->archdata.iommu = info;
2225        spin_unlock_irqrestore(&device_domain_lock, flags);
2226
2227        return domain;
2228}
2229
2230static int get_last_alias(struct pci_dev *pdev, u16 alias, void *opaque)
2231{
2232        *(u16 *)opaque = alias;
2233        return 0;
2234}
2235
2236/* domain is initialized */
2237static struct dmar_domain *get_domain_for_dev(struct device *dev, int gaw)
2238{
2239        struct dmar_domain *domain, *tmp;
2240        struct intel_iommu *iommu;
2241        struct device_domain_info *info;
2242        u16 dma_alias;
2243        unsigned long flags;
2244        u8 bus, devfn;
2245
2246        domain = find_domain(dev);
2247        if (domain)
2248                return domain;
2249
2250        iommu = device_to_iommu(dev, &bus, &devfn);
2251        if (!iommu)
2252                return NULL;
2253
2254        if (dev_is_pci(dev)) {
2255                struct pci_dev *pdev = to_pci_dev(dev);
2256
2257                pci_for_each_dma_alias(pdev, get_last_alias, &dma_alias);
2258
2259                spin_lock_irqsave(&device_domain_lock, flags);
2260                info = dmar_search_domain_by_dev_info(pci_domain_nr(pdev->bus),
2261                                                      PCI_BUS_NUM(dma_alias),
2262                                                      dma_alias & 0xff);
2263                if (info) {
2264                        iommu = info->iommu;
2265                        domain = info->domain;
2266                }
2267                spin_unlock_irqrestore(&device_domain_lock, flags);
2268
2269                /* DMA alias already has a domain, uses it */
2270                if (info)
2271                        goto found_domain;
2272        }
2273
2274        /* Allocate and initialize new domain for the device */
2275        domain = alloc_domain(0);
2276        if (!domain)
2277                return NULL;
2278        domain->id = iommu_attach_domain(domain, iommu);
2279        if (domain->id < 0) {
2280                free_domain_mem(domain);
2281                return NULL;
2282        }
2283        domain_attach_iommu(domain, iommu);
2284        if (domain_init(domain, gaw)) {
2285                domain_exit(domain);
2286                return NULL;
2287        }
2288
2289        /* register PCI DMA alias device */
2290        if (dev_is_pci(dev)) {
2291                tmp = dmar_insert_dev_info(iommu, PCI_BUS_NUM(dma_alias),
2292                                           dma_alias & 0xff, NULL, domain);
2293
2294                if (!tmp || tmp != domain) {
2295                        domain_exit(domain);
2296                        domain = tmp;
2297                }
2298
2299                if (!domain)
2300                        return NULL;
2301        }
2302
2303found_domain:
2304        tmp = dmar_insert_dev_info(iommu, bus, devfn, dev, domain);
2305
2306        if (!tmp || tmp != domain) {
2307                domain_exit(domain);
2308                domain = tmp;
2309        }
2310
2311        return domain;
2312}
2313
2314static int iommu_identity_mapping;
2315#define IDENTMAP_ALL            1
2316#define IDENTMAP_GFX            2
2317#define IDENTMAP_AZALIA         4
2318
2319static int iommu_domain_identity_map(struct dmar_domain *domain,
2320                                     unsigned long long start,
2321                                     unsigned long long end)
2322{
2323        unsigned long first_vpfn = start >> VTD_PAGE_SHIFT;
2324        unsigned long last_vpfn = end >> VTD_PAGE_SHIFT;
2325
2326        if (!reserve_iova(&domain->iovad, dma_to_mm_pfn(first_vpfn),
2327                          dma_to_mm_pfn(last_vpfn))) {
2328                printk(KERN_ERR "IOMMU: reserve iova failed\n");
2329                return -ENOMEM;
2330        }
2331
2332        pr_debug("Mapping reserved region %llx-%llx for domain %d\n",
2333                 start, end, domain->id);
2334        /*
2335         * RMRR range might have overlap with physical memory range,
2336         * clear it first
2337         */
2338        dma_pte_clear_range(domain, first_vpfn, last_vpfn);
2339
2340        return domain_pfn_mapping(domain, first_vpfn, first_vpfn,
2341                                  last_vpfn - first_vpfn + 1,
2342                                  DMA_PTE_READ|DMA_PTE_WRITE);
2343}
2344
2345static int iommu_prepare_identity_map(struct device *dev,
2346                                      unsigned long long start,
2347                                      unsigned long long end)
2348{
2349        struct dmar_domain *domain;
2350        int ret;
2351
2352        domain = get_domain_for_dev(dev, DEFAULT_DOMAIN_ADDRESS_WIDTH);
2353        if (!domain)
2354                return -ENOMEM;
2355
2356        /* For _hardware_ passthrough, don't bother. But for software
2357           passthrough, we do it anyway -- it may indicate a memory
2358           range which is reserved in E820, so which didn't get set
2359           up to start with in si_domain */
2360        if (domain == si_domain && hw_pass_through) {
2361                printk("Ignoring identity map for HW passthrough device %s [0x%Lx - 0x%Lx]\n",
2362                       dev_name(dev), start, end);
2363                return 0;
2364        }
2365
2366        printk(KERN_INFO
2367               "IOMMU: Setting identity map for device %s [0x%Lx - 0x%Lx]\n",
2368               dev_name(dev), start, end);
2369       
2370        if (end < start) {
2371                WARN(1, "Your BIOS is broken; RMRR ends before it starts!\n"
2372                        "BIOS vendor: %s; Ver: %s; Product Version: %s\n",
2373                        dmi_get_system_info(DMI_BIOS_VENDOR),
2374                        dmi_get_system_info(DMI_BIOS_VERSION),
2375                     dmi_get_system_info(DMI_PRODUCT_VERSION));
2376                ret = -EIO;
2377                goto error;
2378        }
2379
2380        if (end >> agaw_to_width(domain->agaw)) {
2381                WARN(1, "Your BIOS is broken; RMRR exceeds permitted address width (%d bits)\n"
2382                     "BIOS vendor: %s; Ver: %s; Product Version: %s\n",
2383                     agaw_to_width(domain->agaw),
2384                     dmi_get_system_info(DMI_BIOS_VENDOR),
2385                     dmi_get_system_info(DMI_BIOS_VERSION),
2386                     dmi_get_system_info(DMI_PRODUCT_VERSION));
2387                ret = -EIO;
2388                goto error;
2389        }
2390
2391        ret = iommu_domain_identity_map(domain, start, end);
2392        if (ret)
2393                goto error;
2394
2395        /* context entry init */
2396        ret = domain_context_mapping(domain, dev, CONTEXT_TT_MULTI_LEVEL);
2397        if (ret)
2398                goto error;
2399
2400        return 0;
2401
2402 error:
2403        domain_exit(domain);
2404        return ret;
2405}
2406
2407static inline int iommu_prepare_rmrr_dev(struct dmar_rmrr_unit *rmrr,
2408                                         struct device *dev)
2409{
2410        if (dev->archdata.iommu == DUMMY_DEVICE_DOMAIN_INFO)
2411                return 0;
2412        return iommu_prepare_identity_map(dev, rmrr->base_address,
2413                                          rmrr->end_address);
2414}
2415
2416#ifdef CONFIG_INTEL_IOMMU_FLOPPY_WA
2417static inline void iommu_prepare_isa(void)
2418{
2419        struct pci_dev *pdev;
2420        int ret;
2421
2422        pdev = pci_get_class(PCI_CLASS_BRIDGE_ISA << 8, NULL);
2423        if (!pdev)
2424                return;
2425
2426        printk(KERN_INFO "IOMMU: Prepare 0-16MiB unity mapping for LPC\n");
2427        ret = iommu_prepare_identity_map(&pdev->dev, 0, 16*1024*1024 - 1);
2428
2429        if (ret)
2430                printk(KERN_ERR "IOMMU: Failed to create 0-16MiB identity map; "
2431                       "floppy might not work\n");
2432
2433        pci_dev_put(pdev);
2434}
2435#else
2436static inline void iommu_prepare_isa(void)
2437{
2438        return;
2439}
2440#endif /* !CONFIG_INTEL_IOMMU_FLPY_WA */
2441
2442static int md_domain_init(struct dmar_domain *domain, int guest_width);
2443
2444static int __init si_domain_init(int hw)
2445{
2446        struct dmar_drhd_unit *drhd;
2447        struct intel_iommu *iommu;
2448        int nid, ret = 0;
2449        bool first = true;
2450
2451        si_domain = alloc_domain(DOMAIN_FLAG_STATIC_IDENTITY);
2452        if (!si_domain)
2453                return -EFAULT;
2454
2455        for_each_active_iommu(iommu, drhd) {
2456                ret = iommu_attach_domain(si_domain, iommu);
2457                if (ret < 0) {
2458                        domain_exit(si_domain);
2459                        return -EFAULT;
2460                } else if (first) {
2461                        si_domain->id = ret;
2462                        first = false;
2463                } else if (si_domain->id != ret) {
2464                        domain_exit(si_domain);
2465                        return -EFAULT;
2466                }
2467                domain_attach_iommu(si_domain, iommu);
2468        }
2469
2470        if (md_domain_init(si_domain, DEFAULT_DOMAIN_ADDRESS_WIDTH)) {
2471                domain_exit(si_domain);
2472                return -EFAULT;
2473        }
2474
2475        pr_debug("IOMMU: identity mapping domain is domain %d\n",
2476                 si_domain->id);
2477
2478        if (hw)
2479                return 0;
2480
2481        for_each_online_node(nid) {
2482                unsigned long start_pfn, end_pfn;
2483                int i;
2484
2485                for_each_mem_pfn_range(i, nid, &start_pfn, &end_pfn, NULL) {
2486                        ret = iommu_domain_identity_map(si_domain,
2487                                        PFN_PHYS(start_pfn), PFN_PHYS(end_pfn));
2488                        if (ret)
2489                                return ret;
2490                }
2491        }
2492
2493        return 0;
2494}
2495
2496static int identity_mapping(struct device *dev)
2497{
2498        struct device_domain_info *info;
2499
2500        if (likely(!iommu_identity_mapping))
2501                return 0;
2502
2503        info = dev->archdata.iommu;
2504        if (info && info != DUMMY_DEVICE_DOMAIN_INFO)
2505                return (info->domain == si_domain);
2506
2507        return 0;
2508}
2509
2510static int domain_add_dev_info(struct dmar_domain *domain,
2511                               struct device *dev, int translation)
2512{
2513        struct dmar_domain *ndomain;
2514        struct intel_iommu *iommu;
2515        u8 bus, devfn;
2516        int ret;
2517
2518        iommu = device_to_iommu(dev, &bus, &devfn);
2519        if (!iommu)
2520                return -ENODEV;
2521
2522        ndomain = dmar_insert_dev_info(iommu, bus, devfn, dev, domain);
2523        if (ndomain != domain)
2524                return -EBUSY;
2525
2526        ret = domain_context_mapping(domain, dev, translation);
2527        if (ret) {
2528                domain_remove_one_dev_info(domain, dev);
2529                return ret;
2530        }
2531
2532        return 0;
2533}
2534
2535static bool device_has_rmrr(struct device *dev)
2536{
2537        struct dmar_rmrr_unit *rmrr;
2538        struct device *tmp;
2539        int i;
2540
2541        rcu_read_lock();
2542        for_each_rmrr_units(rmrr) {
2543                /*
2544                 * Return TRUE if this RMRR contains the device that
2545                 * is passed in.
2546                 */
2547                for_each_active_dev_scope(rmrr->devices,
2548                                          rmrr->devices_cnt, i, tmp)
2549                        if (tmp == dev) {
2550                                rcu_read_unlock();
2551                                return true;
2552                        }
2553        }
2554        rcu_read_unlock();
2555        return false;
2556}
2557
2558/*
2559 * There are a couple cases where we need to restrict the functionality of
2560 * devices associated with RMRRs.  The first is when evaluating a device for
2561 * identity mapping because problems exist when devices are moved in and out
2562 * of domains and their respective RMRR information is lost.  This means that
2563 * a device with associated RMRRs will never be in a "passthrough" domain.
2564 * The second is use of the device through the IOMMU API.  This interface
2565 * expects to have full control of the IOVA space for the device.  We cannot
2566 * satisfy both the requirement that RMRR access is maintained and have an
2567 * unencumbered IOVA space.  We also have no ability to quiesce the device's
2568 * use of the RMRR space or even inform the IOMMU API user of the restriction.
2569 * We therefore prevent devices associated with an RMRR from participating in
2570 * the IOMMU API, which eliminates them from device assignment.
2571 *
2572 * In both cases we assume that PCI USB devices with RMRRs have them largely
2573 * for historical reasons and that the RMRR space is not actively used post
2574 * boot.  This exclusion may change if vendors begin to abuse it.
2575 *
2576 * The same exception is made for graphics devices, with the requirement that
2577 * any use of the RMRR regions will be torn down before assigning the device
2578 * to a guest.
2579 */
2580static bool device_is_rmrr_locked(struct device *dev)
2581{
2582        if (!device_has_rmrr(dev))
2583                return false;
2584
2585        if (dev_is_pci(dev)) {
2586                struct pci_dev *pdev = to_pci_dev(dev);
2587
2588                if (IS_USB_DEVICE(pdev) || IS_GFX_DEVICE(pdev))
2589                        return false;
2590        }
2591
2592        return true;
2593}
2594
2595static int iommu_should_identity_map(struct device *dev, int startup)
2596{
2597
2598        if (dev_is_pci(dev)) {
2599                struct pci_dev *pdev = to_pci_dev(dev);
2600
2601                if (device_is_rmrr_locked(dev))
2602                        return 0;
2603
2604                if ((iommu_identity_mapping & IDENTMAP_AZALIA) && IS_AZALIA(pdev))
2605                        return 1;
2606
2607                if ((iommu_identity_mapping & IDENTMAP_GFX) && IS_GFX_DEVICE(pdev))
2608                        return 1;
2609
2610                if (!(iommu_identity_mapping & IDENTMAP_ALL))
2611                        return 0;
2612
2613                /*
2614                 * We want to start off with all devices in the 1:1 domain, and
2615                 * take them out later if we find they can't access all of memory.
2616                 *
2617                 * However, we can't do this for PCI devices behind bridges,
2618                 * because all PCI devices behind the same bridge will end up
2619                 * with the same source-id on their transactions.
2620                 *
2621                 * Practically speaking, we can't change things around for these
2622                 * devices at run-time, because we can't be sure there'll be no
2623                 * DMA transactions in flight for any of their siblings.
2624                 *
2625                 * So PCI devices (unless they're on the root bus) as well as
2626                 * their parent PCI-PCI or PCIe-PCI bridges must be left _out_ of
2627                 * the 1:1 domain, just in _case_ one of their siblings turns out
2628                 * not to be able to map all of memory.
2629                 */
2630                if (!pci_is_pcie(pdev)) {
2631                        if (!pci_is_root_bus(pdev->bus))
2632                                return 0;
2633                        if (pdev->class >> 8 == PCI_CLASS_BRIDGE_PCI)
2634                                return 0;
2635                } else if (pci_pcie_type(pdev) == PCI_EXP_TYPE_PCI_BRIDGE)
2636                        return 0;
2637        } else {
2638                if (device_has_rmrr(dev))
2639                        return 0;
2640        }
2641
2642        /*
2643         * At boot time, we don't yet know if devices will be 64-bit capable.
2644         * Assume that they will — if they turn out not to be, then we can
2645         * take them out of the 1:1 domain later.
2646         */
2647        if (!startup) {
2648                /*
2649                 * If the device's dma_mask is less than the system's memory
2650                 * size then this is not a candidate for identity mapping.
2651                 */
2652                u64 dma_mask = *dev->dma_mask;
2653
2654                if (dev->coherent_dma_mask &&
2655                    dev->coherent_dma_mask < dma_mask)
2656                        dma_mask = dev->coherent_dma_mask;
2657
2658                return dma_mask >= dma_get_required_mask(dev);
2659        }
2660
2661        return 1;
2662}
2663
2664static int __init dev_prepare_static_identity_mapping(struct device *dev, int hw)
2665{
2666        int ret;
2667
2668        if (!iommu_should_identity_map(dev, 1))
2669                return 0;
2670
2671        ret = domain_add_dev_info(si_domain, dev,
2672                                  hw ? CONTEXT_TT_PASS_THROUGH :
2673                                       CONTEXT_TT_MULTI_LEVEL);
2674        if (!ret)
2675                pr_info("IOMMU: %s identity mapping for device %s\n",
2676                        hw ? "hardware" : "software", dev_name(dev));
2677        else if (ret == -ENODEV)
2678                /* device not associated with an iommu */
2679                ret = 0;
2680
2681        return ret;
2682}
2683
2684
2685static int __init iommu_prepare_static_identity_mapping(int hw)
2686{
2687        struct pci_dev *pdev = NULL;
2688        struct dmar_drhd_unit *drhd;
2689        struct intel_iommu *iommu;
2690        struct device *dev;
2691        int i;
2692        int ret = 0;
2693
2694        ret = si_domain_init(hw);
2695        if (ret)
2696                return -EFAULT;
2697
2698        for_each_pci_dev(pdev) {
2699                ret = dev_prepare_static_identity_mapping(&pdev->dev, hw);
2700                if (ret)
2701                        return ret;
2702        }
2703
2704        for_each_active_iommu(iommu, drhd)
2705                for_each_active_dev_scope(drhd->devices, drhd->devices_cnt, i, dev) {
2706                        struct acpi_device_physical_node *pn;
2707                        struct acpi_device *adev;
2708
2709                        if (dev->bus != &acpi_bus_type)
2710                                continue;
2711                               
2712                        adev= to_acpi_device(dev);
2713                        mutex_lock(&adev->physical_node_lock);
2714                        list_for_each_entry(pn, &adev->physical_node_list, node) {
2715                                ret = dev_prepare_static_identity_mapping(pn->dev, hw);
2716                                if (ret)
2717                                        break;
2718                        }
2719                        mutex_unlock(&adev->physical_node_lock);
2720                        if (ret)
2721                                return ret;
2722                }
2723
2724        return 0;
2725}
2726
2727static int __init init_dmars(void)
2728{
2729        struct dmar_drhd_unit *drhd;
2730        struct dmar_rmrr_unit *rmrr;
2731        struct device *dev;
2732        struct intel_iommu *iommu;
2733        int i, ret;
2734
2735        /*
2736         * for each drhd
2737         *    allocate root
2738         *    initialize and program root entry to not present
2739         * endfor
2740         */
2741        for_each_drhd_unit(drhd) {
2742                /*
2743                 * lock not needed as this is only incremented in the single
2744                 * threaded kernel __init code path all other access are read
2745                 * only
2746                 */
2747                if (g_num_of_iommus < IOMMU_UNITS_SUPPORTED) {
2748                        g_num_of_iommus++;
2749                        continue;
2750                }
2751                printk_once(KERN_ERR "intel-iommu: exceeded %d IOMMUs\n",
2752                          IOMMU_UNITS_SUPPORTED);
2753        }
2754
2755        g_iommus = kcalloc(g_num_of_iommus, sizeof(struct intel_iommu *),
2756                        GFP_KERNEL);
2757        if (!g_iommus) {
2758                printk(KERN_ERR "Allocating global iommu array failed\n");
2759                ret = -ENOMEM;
2760                goto error;
2761        }
2762
2763        deferred_flush = kzalloc(g_num_of_iommus *
2764                sizeof(struct deferred_flush_tables), GFP_KERNEL);
2765        if (!deferred_flush) {
2766                ret = -ENOMEM;
2767                goto free_g_iommus;
2768        }
2769
2770        for_each_active_iommu(iommu, drhd) {
2771                g_iommus[iommu->seq_id] = iommu;
2772
2773                ret = iommu_init_domains(iommu);
2774                if (ret)
2775                        goto free_iommu;
2776
2777                /*
2778                 * TBD:
2779                 * we could share the same root & context tables
2780                 * among all IOMMU's. Need to Split it later.
2781                 */
2782                ret = iommu_alloc_root_entry(iommu);
2783                if (ret) {
2784                        printk(KERN_ERR "IOMMU: allocate root entry failed\n");
2785                        goto free_iommu;
2786                }
2787                if (!ecap_pass_through(iommu->ecap))
2788                        hw_pass_through = 0;
2789        }
2790
2791        /*
2792         * Start from the sane iommu hardware state.
2793         */
2794        for_each_active_iommu(iommu, drhd) {
2795                /*
2796                 * If the queued invalidation is already initialized by us
2797                 * (for example, while enabling interrupt-remapping) then
2798                 * we got the things already rolling from a sane state.
2799                 */
2800                if (iommu->qi)
2801                        continue;
2802
2803                /*
2804                 * Clear any previous faults.
2805                 */
2806                dmar_fault(-1, iommu);
2807                /*
2808                 * Disable queued invalidation if supported and already enabled
2809                 * before OS handover.
2810                 */
2811                dmar_disable_qi(iommu);
2812        }
2813
2814        for_each_active_iommu(iommu, drhd) {
2815                if (dmar_enable_qi(iommu)) {
2816                        /*
2817                         * Queued Invalidate not enabled, use Register Based
2818                         * Invalidate
2819                         */
2820                        iommu->flush.flush_context = __iommu_flush_context;
2821                        iommu->flush.flush_iotlb = __iommu_flush_iotlb;
2822                        printk(KERN_INFO "IOMMU %d 0x%Lx: using Register based "
2823                               "invalidation\n",
2824                                iommu->seq_id,
2825                               (unsigned long long)drhd->reg_base_addr);
2826                } else {
2827                        iommu->flush.flush_context = qi_flush_context;
2828                        iommu->flush.flush_iotlb = qi_flush_iotlb;
2829                        printk(KERN_INFO "IOMMU %d 0x%Lx: using Queued "
2830                               "invalidation\n",
2831                                iommu->seq_id,
2832                               (unsigned long long)drhd->reg_base_addr);
2833                }
2834        }
2835
2836        if (iommu_pass_through)
2837                iommu_identity_mapping |= IDENTMAP_ALL;
2838
2839#ifdef CONFIG_INTEL_IOMMU_BROKEN_GFX_WA
2840        iommu_identity_mapping |= IDENTMAP_GFX;
2841#endif
2842
2843        check_tylersburg_isoch();
2844
2845        /*
2846         * If pass through is not set or not enabled, setup context entries for
2847         * identity mappings for rmrr, gfx, and isa and may fall back to static
2848         * identity mapping if iommu_identity_mapping is set.
2849         */
2850        if (iommu_identity_mapping) {
2851                ret = iommu_prepare_static_identity_mapping(hw_pass_through);
2852                if (ret) {
2853                        printk(KERN_CRIT "Failed to setup IOMMU pass-through\n");
2854                        goto free_iommu;
2855                }
2856        }
2857        /*
2858         * For each rmrr
2859         *   for each dev attached to rmrr
2860         *   do
2861         *     locate drhd for dev, alloc domain for dev
2862         *     allocate free domain
2863         *     allocate page table entries for rmrr
2864         *     if context not allocated for bus
2865         *           allocate and init context
2866         *           set present in root table for this bus
2867         *     init context with domain, translation etc
2868         *    endfor
2869         * endfor
2870         */
2871        printk(KERN_INFO "IOMMU: Setting RMRR:\n");
2872        for_each_rmrr_units(rmrr) {
2873                /* some BIOS lists non-exist devices in DMAR table. */
2874                for_each_active_dev_scope(rmrr->devices, rmrr->devices_cnt,
2875                                          i, dev) {
2876                        ret = iommu_prepare_rmrr_dev(rmrr, dev);
2877                        if (ret)
2878                                printk(KERN_ERR
2879                                       "IOMMU: mapping reserved region failed\n");
2880                }
2881        }
2882
2883        iommu_prepare_isa();
2884
2885        /*
2886         * for each drhd
2887         *   enable fault log
2888         *   global invalidate context cache
2889         *   global invalidate iotlb
2890         *   enable translation
2891         */
2892        for_each_iommu(iommu, drhd) {
2893                if (drhd->ignored) {
2894                        /*
2895                         * we always have to disable PMRs or DMA may fail on
2896                         * this device
2897                         */
2898                        if (force_on)
2899                                iommu_disable_protect_mem_regions(iommu);
2900                        continue;
2901                }
2902
2903                iommu_flush_write_buffer(iommu);
2904
2905                ret = dmar_set_interrupt(iommu);
2906                if (ret)
2907                        goto free_iommu;
2908
2909                iommu_set_root_entry(iommu);
2910
2911                iommu->flush.flush_context(iommu, 0, 0, 0, DMA_CCMD_GLOBAL_INVL);
2912                iommu->flush.flush_iotlb(iommu, 0, 0, 0, DMA_TLB_GLOBAL_FLUSH);
2913                iommu_enable_translation(iommu);
2914                iommu_disable_protect_mem_regions(iommu);
2915        }
2916
2917        return 0;
2918
2919free_iommu:
2920        for_each_active_iommu(iommu, drhd)
2921                free_dmar_iommu(iommu);
2922        kfree(deferred_flush);
2923free_g_iommus:
2924        kfree(g_iommus);
2925error:
2926        return ret;
2927}
2928
2929/* This takes a number of _MM_ pages, not VTD pages */
2930static struct iova *intel_alloc_iova(struct device *dev,
2931                                     struct dmar_domain *domain,
2932                                     unsigned long nrpages, uint64_t dma_mask)
2933{
2934        struct iova *iova = NULL;
2935
2936        /* Restrict dma_mask to the width that the iommu can handle */
2937        dma_mask = min_t(uint64_t, DOMAIN_MAX_ADDR(domain->gaw), dma_mask);
2938
2939        if (!dmar_forcedac && dma_mask > DMA_BIT_MASK(32)) {
2940                /*
2941                 * First try to allocate an io virtual address in
2942                 * DMA_BIT_MASK(32) and if that fails then try allocating
2943                 * from higher range
2944                 */
2945                iova = alloc_iova(&domain->iovad, nrpages,
2946                                  IOVA_PFN(DMA_BIT_MASK(32)), 1);
2947                if (iova)
2948                        return iova;
2949        }
2950        iova = alloc_iova(&domain->iovad, nrpages, IOVA_PFN(dma_mask), 1);
2951        if (unlikely(!iova)) {
2952                printk(KERN_ERR "Allocating %ld-page iova for %s failed",
2953                       nrpages, dev_name(dev));
2954                return NULL;
2955        }
2956
2957        return iova;
2958}
2959
2960static struct dmar_domain *__get_valid_domain_for_dev(struct device *dev)
2961{
2962        struct dmar_domain *domain;
2963        int ret;
2964
2965        domain = get_domain_for_dev(dev, DEFAULT_DOMAIN_ADDRESS_WIDTH);
2966        if (!domain) {
2967                printk(KERN_ERR "Allocating domain for %s failed",
2968                       dev_name(dev));
2969                return NULL;
2970        }
2971
2972        /* make sure context mapping is ok */
2973        if (unlikely(!domain_context_mapped(dev))) {
2974                ret = domain_context_mapping(domain, dev, CONTEXT_TT_MULTI_LEVEL);
2975                if (ret) {
2976                        printk(KERN_ERR "Domain context map for %s failed",
2977                               dev_name(dev));
2978                        return NULL;
2979                }
2980        }
2981
2982        return domain;
2983}
2984
2985static inline struct dmar_domain *get_valid_domain_for_dev(struct device *dev)
2986{
2987        struct device_domain_info *info;
2988
2989        /* No lock here, assumes no domain exit in normal case */
2990        info = dev->archdata.iommu;
2991        if (likely(info))
2992                return info->domain;
2993
2994        return __get_valid_domain_for_dev(dev);
2995}
2996
2997static int iommu_dummy(struct device *dev)
2998{
2999        return dev->archdata.iommu == DUMMY_DEVICE_DOMAIN_INFO;
3000}
3001
3002/* Check if the dev needs to go through non-identity map and unmap process.*/
3003static int iommu_no_mapping(struct device *dev)
3004{
3005        int found;
3006
3007        if (iommu_dummy(dev))
3008                return 1;
3009
3010        if (!iommu_identity_mapping)
3011                return 0;
3012
3013        found = identity_mapping(dev);
3014        if (found) {
3015                if (iommu_should_identity_map(dev, 0))
3016                        return 1;
3017                else {
3018                        /*
3019                         * 32 bit DMA is removed from si_domain and fall back
3020                         * to non-identity mapping.
3021                         */
3022                        domain_remove_one_dev_info(si_domain, dev);
3023                        printk(KERN_INFO "32bit %s uses non-identity mapping\n",
3024                               dev_name(dev));
3025                        return 0;
3026                }
3027        } else {
3028                /*
3029                 * In case of a detached 64 bit DMA device from vm, the device
3030                 * is put into si_domain for identity mapping.
3031                 */
3032                if (iommu_should_identity_map(dev, 0)) {
3033                        int ret;
3034                        ret = domain_add_dev_info(si_domain, dev,
3035                                                  hw_pass_through ?
3036                                                  CONTEXT_TT_PASS_THROUGH :
3037                                                  CONTEXT_TT_MULTI_LEVEL);
3038                        if (!ret) {
3039                                printk(KERN_INFO "64bit %s uses identity mapping\n",
3040                                       dev_name(dev));
3041                                return 1;
3042                        }
3043                }
3044        }
3045
3046        return 0;
3047}
3048
3049static dma_addr_t __intel_map_single(struct device *dev, phys_addr_t paddr,
3050                                     size_t size, int dir, u64 dma_mask)
3051{
3052        struct dmar_domain *domain;
3053        phys_addr_t start_paddr;
3054        struct iova *iova;
3055        int prot = 0;
3056        int ret;
3057        struct intel_iommu *iommu;
3058        unsigned long paddr_pfn = paddr >> PAGE_SHIFT;
3059
3060        BUG_ON(dir == DMA_NONE);
3061
3062        if (iommu_no_mapping(dev))
3063                return paddr;
3064
3065        domain = get_valid_domain_for_dev(dev);
3066        if (!domain)
3067                return 0;
3068
3069        iommu = domain_get_iommu(domain);
3070        size = aligned_nrpages(paddr, size);
3071
3072        iova = intel_alloc_iova(dev, domain, dma_to_mm_pfn(size), dma_mask);
3073        if (!iova)
3074                goto error;
3075
3076        /*
3077         * Check if DMAR supports zero-length reads on write only
3078         * mappings..
3079         */
3080        if (dir == DMA_TO_DEVICE || dir == DMA_BIDIRECTIONAL || \
3081                        !cap_zlr(iommu->cap))
3082                prot |= DMA_PTE_READ;
3083        if (dir == DMA_FROM_DEVICE || dir == DMA_BIDIRECTIONAL)
3084                prot |= DMA_PTE_WRITE;
3085        /*
3086         * paddr - (paddr + size) might be partial page, we should map the whole
3087         * page.  Note: if two part of one page are separately mapped, we
3088         * might have two guest_addr mapping to the same host paddr, but this
3089         * is not a big problem
3090         */
3091        ret = domain_pfn_mapping(domain, mm_to_dma_pfn(iova->pfn_lo),
3092                                 mm_to_dma_pfn(paddr_pfn), size, prot);
3093        if (ret)
3094                goto error;
3095
3096        /* it's a non-present to present mapping. Only flush if caching mode */
3097        if (cap_caching_mode(iommu->cap))
3098                iommu_flush_iotlb_psi(iommu, domain->id, mm_to_dma_pfn(iova->pfn_lo), size, 0, 1);
3099        else
3100                iommu_flush_write_buffer(iommu);
3101
3102        start_paddr = (phys_addr_t)iova->pfn_lo << PAGE_SHIFT;
3103        start_paddr += paddr & ~PAGE_MASK;
3104        return start_paddr;
3105
3106error:
3107        if (iova)
3108                __free_iova(&domain->iovad, iova);
3109        printk(KERN_ERR"Device %s request: %zx@%llx dir %d --- failed\n",
3110                dev_name(dev), size, (unsigned long long)paddr, dir);
3111        return 0;
3112}
3113
3114static dma_addr_t intel_map_page(struct device *dev, struct page *page,
3115                                 unsigned long offset, size_t size,
3116                                 enum dma_data_direction dir,
3117                                 struct dma_attrs *attrs)
3118{
3119        return __intel_map_single(dev, page_to_phys(page) + offset, size,
3120                                  dir, *dev->dma_mask);
3121}
3122
3123static void flush_unmaps(void)
3124{
3125        int i, j;
3126
3127        timer_on = 0;
3128
3129        /* just flush them all */
3130        for (i = 0; i < g_num_of_iommus; i++) {
3131                struct intel_iommu *iommu = g_iommus[i];
3132                if (!iommu)
3133                        continue;
3134
3135                if (!deferred_flush[i].next)
3136                        continue;
3137
3138                /* In caching mode, global flushes turn emulation expensive */
3139                if (!cap_caching_mode(iommu->cap))
3140                        iommu->flush.flush_iotlb(iommu, 0, 0, 0,
3141                                         DMA_TLB_GLOBAL_FLUSH);
3142                for (j = 0; j < deferred_flush[i].next; j++) {
3143                        unsigned long mask;
3144                        struct iova *iova = deferred_flush[i].iova[j];
3145                        struct dmar_domain *domain = deferred_flush[i].domain[j];
3146
3147                        /* On real hardware multiple invalidations are expensive */
3148                        if (cap_caching_mode(iommu->cap))
3149                                iommu_flush_iotlb_psi(iommu, domain->id,
3150                                        iova->pfn_lo, iova_size(iova),
3151                                        !deferred_flush[i].freelist[j], 0);
3152                        else {
3153                                mask = ilog2(mm_to_dma_pfn(iova_size(iova)));
3154                                iommu_flush_dev_iotlb(deferred_flush[i].domain[j],
3155                                                (uint64_t)iova->pfn_lo << PAGE_SHIFT, mask);
3156                        }
3157                        __free_iova(&deferred_flush[i].domain[j]->iovad, iova);
3158                        if (deferred_flush[i].freelist[j])
3159                                dma_free_pagelist(deferred_flush[i].freelist[j]);
3160                }
3161                deferred_flush[i].next = 0;
3162        }
3163
3164        list_size = 0;
3165}
3166
3167static void flush_unmaps_timeout(unsigned long data)
3168{
3169        unsigned long flags;
3170
3171        spin_lock_irqsave(&async_umap_flush_lock, flags);
3172        flush_unmaps();
3173        spin_unlock_irqrestore(&async_umap_flush_lock, flags);
3174}
3175
3176static void add_unmap(struct dmar_domain *dom, struct iova *iova, struct page *freelist)
3177{
3178        unsigned long flags;
3179        int next, iommu_id;
3180        struct intel_iommu *iommu;
3181
3182        spin_lock_irqsave(&async_umap_flush_lock, flags);
3183        if (list_size == HIGH_WATER_MARK)
3184                flush_unmaps();
3185
3186        iommu = domain_get_iommu(dom);
3187        iommu_id = iommu->seq_id;
3188
3189        next = deferred_flush[iommu_id].next;
3190        deferred_flush[iommu_id].domain[next] = dom;
3191        deferred_flush[iommu_id].iova[next] = iova;
3192        deferred_flush[iommu_id].freelist[next] = freelist;
3193        deferred_flush[iommu_id].next++;
3194
3195        if (!timer_on) {
3196                mod_timer(&unmap_timer, jiffies + msecs_to_jiffies(10));
3197                timer_on = 1;
3198        }
3199        list_size++;
3200        spin_unlock_irqrestore(&async_umap_flush_lock, flags);
3201}
3202
3203static void intel_unmap(struct device *dev, dma_addr_t dev_addr)
3204{
3205        struct dmar_domain *domain;
3206        unsigned long start_pfn, last_pfn;
3207        struct iova *iova;
3208        struct intel_iommu *iommu;
3209        struct page *freelist;
3210
3211        if (iommu_no_mapping(dev))
3212                return;
3213
3214        domain = find_domain(dev);
3215        BUG_ON(!domain);
3216
3217        iommu = domain_get_iommu(domain);
3218
3219        iova = find_iova(&domain->iovad, IOVA_PFN(dev_addr));
3220        if (WARN_ONCE(!iova, "Driver unmaps unmatched page at PFN %llx\n",
3221                      (unsigned long long)dev_addr))
3222                return;
3223
3224        start_pfn = mm_to_dma_pfn(iova->pfn_lo);
3225        last_pfn = mm_to_dma_pfn(iova->pfn_hi + 1) - 1;
3226
3227        pr_debug("Device %s unmapping: pfn %lx-%lx\n",
3228                 dev_name(dev), start_pfn, last_pfn);
3229
3230        freelist = domain_unmap(domain, start_pfn, last_pfn);
3231
3232        if (intel_iommu_strict) {
3233                iommu_flush_iotlb_psi(iommu, domain->id, start_pfn,
3234                                      last_pfn - start_pfn + 1, !freelist, 0);
3235                /* free iova */
3236                __free_iova(&domain->iovad, iova);
3237                dma_free_pagelist(freelist);
3238        } else {
3239                add_unmap(domain, iova, freelist);
3240                /*
3241                 * queue up the release of the unmap to save the 1/6th of the
3242                 * cpu used up by the iotlb flush operation...
3243                 */
3244        }
3245}
3246
3247static void intel_unmap_page(struct device *dev, dma_addr_t dev_addr,
3248                             size_t size, enum dma_data_direction dir,
3249                             struct dma_attrs *attrs)
3250{
3251        intel_unmap(dev, dev_addr);
3252}
3253
3254static void *intel_alloc_coherent(struct device *dev, size_t size,
3255                                  dma_addr_t *dma_handle, gfp_t flags,
3256                                  struct dma_attrs *attrs)
3257{
3258        struct page *page = NULL;
3259        int order;
3260
3261        size = PAGE_ALIGN(size);
3262        order = get_order(size);
3263
3264        if (!iommu_no_mapping(dev))
3265                flags &= ~(GFP_DMA | GFP_DMA32);
3266        else if (dev->coherent_dma_mask < dma_get_required_mask(dev)) {
3267                if (dev->coherent_dma_mask < DMA_BIT_MASK(32))
3268                        flags |= GFP_DMA;
3269                else
3270                        flags |= GFP_DMA32;
3271        }
3272
3273        if (flags & __GFP_WAIT) {
3274                unsigned int count = size >> PAGE_SHIFT;
3275
3276                page = dma_alloc_from_contiguous(dev, count, order);
3277                if (page && iommu_no_mapping(dev) &&
3278                    page_to_phys(page) + size > dev->coherent_dma_mask) {
3279                        dma_release_from_contiguous(dev, page, count);
3280                        page = NULL;
3281                }
3282        }
3283
3284        if (!page)
3285                page = alloc_pages(flags, order);
3286        if (!page)
3287                return NULL;
3288        memset(page_address(page), 0, size);
3289
3290        *dma_handle = __intel_map_single(dev, page_to_phys(page), size,
3291                                         DMA_BIDIRECTIONAL,
3292                                         dev->coherent_dma_mask);
3293        if (*dma_handle)
3294                return page_address(page);
3295        if (!dma_release_from_contiguous(dev, page, size >> PAGE_SHIFT))
3296                __free_pages(page, order);
3297
3298        return NULL;
3299}
3300
3301static void intel_free_coherent(struct device *dev, size_t size, void *vaddr,
3302                                dma_addr_t dma_handle, struct dma_attrs *attrs)
3303{
3304        int order;
3305        struct page *page = virt_to_page(vaddr);
3306
3307        size = PAGE_ALIGN(size);
3308        order = get_order(size);
3309
3310        intel_unmap(dev, dma_handle);
3311        if (!dma_release_from_contiguous(dev, page, size >> PAGE_SHIFT))
3312                __free_pages(page, order);
3313}
3314
3315static void intel_unmap_sg(struct device *dev, struct scatterlist *sglist,
3316                           int nelems, enum dma_data_direction dir,
3317                           struct dma_attrs *attrs)
3318{
3319        intel_unmap(dev, sglist[0].dma_address);
3320}
3321
3322static int intel_nontranslate_map_sg(struct device *hddev,
3323        struct scatterlist *sglist, int nelems, int dir)
3324{
3325        int i;
3326        struct scatterlist *sg;
3327
3328        for_each_sg(sglist, sg, nelems, i) {
3329                BUG_ON(!sg_page(sg));
3330                sg->dma_address = page_to_phys(sg_page(sg)) + sg->offset;
3331                sg->dma_length = sg->length;
3332        }
3333        return nelems;
3334}
3335
3336static int intel_map_sg(struct device *dev, struct scatterlist *sglist, int nelems,
3337                        enum dma_data_direction dir, struct dma_attrs *attrs)
3338{
3339        int i;
3340        struct dmar_domain *domain;
3341        size_t size = 0;
3342        int prot = 0;
3343        struct iova *iova = NULL;
3344        int ret;
3345        struct scatterlist *sg;
3346        unsigned long start_vpfn;
3347        struct intel_iommu *iommu;
3348
3349        BUG_ON(dir == DMA_NONE);
3350        if (iommu_no_mapping(dev))
3351                return intel_nontranslate_map_sg(dev, sglist, nelems, dir);
3352
3353        domain = get_valid_domain_for_dev(dev);
3354        if (!domain)
3355                return 0;
3356
3357        iommu = domain_get_iommu(domain);
3358
3359        for_each_sg(sglist, sg, nelems, i)
3360                size += aligned_nrpages(sg->offset, sg->length);
3361
3362        iova = intel_alloc_iova(dev, domain, dma_to_mm_pfn(size),
3363                                *dev->dma_mask);
3364        if (!iova) {
3365                sglist->dma_length = 0;
3366                return 0;
3367        }
3368
3369        /*
3370         * Check if DMAR supports zero-length reads on write only
3371         * mappings..
3372         */
3373        if (dir == DMA_TO_DEVICE || dir == DMA_BIDIRECTIONAL || \
3374                        !cap_zlr(iommu->cap))
3375                prot |= DMA_PTE_READ;
3376        if (dir == DMA_FROM_DEVICE || dir == DMA_BIDIRECTIONAL)
3377                prot |= DMA_PTE_WRITE;
3378
3379        start_vpfn = mm_to_dma_pfn(iova->pfn_lo);
3380
3381        ret = domain_sg_mapping(domain, start_vpfn, sglist, size, prot);
3382        if (unlikely(ret)) {
3383                dma_pte_free_pagetable(domain, start_vpfn,
3384                                       start_vpfn + size - 1);
3385                __free_iova(&domain->iovad, iova);
3386                return 0;
3387        }
3388
3389        /* it's a non-present to present mapping. Only flush if caching mode */
3390        if (cap_caching_mode(iommu->cap))
3391                iommu_flush_iotlb_psi(iommu, domain->id, start_vpfn, size, 0, 1);
3392        else
3393                iommu_flush_write_buffer(iommu);
3394
3395        return nelems;
3396}
3397
3398static int intel_mapping_error(struct device *dev, dma_addr_t dma_addr)
3399{
3400        return !dma_addr;
3401}
3402
3403struct dma_map_ops intel_dma_ops = {
3404        .alloc = intel_alloc_coherent,
3405        .free = intel_free_coherent,
3406        .map_sg = intel_map_sg,
3407        .unmap_sg = intel_unmap_sg,
3408        .map_page = intel_map_page,
3409        .unmap_page = intel_unmap_page,
3410        .mapping_error = intel_mapping_error,
3411};
3412
3413static inline int iommu_domain_cache_init(void)
3414{
3415        int ret = 0;
3416
3417        iommu_domain_cache = kmem_cache_create("iommu_domain",
3418                                         sizeof(struct dmar_domain),
3419                                         0,
3420                                         SLAB_HWCACHE_ALIGN,
3421
3422                                         NULL);
3423        if (!iommu_domain_cache) {
3424                printk(KERN_ERR "Couldn't create iommu_domain cache\n");
3425                ret = -ENOMEM;
3426        }
3427
3428        return ret;
3429}
3430
3431static inline int iommu_devinfo_cache_init(void)
3432{
3433        int ret = 0;
3434
3435        iommu_devinfo_cache = kmem_cache_create("iommu_devinfo",
3436                                         sizeof(struct device_domain_info),
3437                                         0,
3438                                         SLAB_HWCACHE_ALIGN,
3439                                         NULL);
3440        if (!iommu_devinfo_cache) {
3441                printk(KERN_ERR "Couldn't create devinfo cache\n");
3442                ret = -ENOMEM;
3443        }
3444
3445        return ret;
3446}
3447
3448static inline int iommu_iova_cache_init(void)
3449{
3450        int ret = 0;
3451
3452        iommu_iova_cache = kmem_cache_create("iommu_iova",
3453                                         sizeof(struct iova),
3454                                         0,
3455                                         SLAB_HWCACHE_ALIGN,
3456                                         NULL);
3457        if (!iommu_iova_cache) {
3458                printk(KERN_ERR "Couldn't create iova cache\n");
3459                ret = -ENOMEM;
3460        }
3461
3462        return ret;
3463}
3464
3465static int __init iommu_init_mempool(void)
3466{
3467        int ret;
3468        ret = iommu_iova_cache_init();
3469        if (ret)
3470                return ret;
3471
3472        ret = iommu_domain_cache_init();
3473        if (ret)
3474                goto domain_error;
3475
3476        ret = iommu_devinfo_cache_init();
3477        if (!ret)
3478                return ret;
3479
3480        kmem_cache_destroy(iommu_domain_cache);
3481domain_error:
3482        kmem_cache_destroy(iommu_iova_cache);
3483
3484        return -ENOMEM;
3485}
3486
3487static void __init iommu_exit_mempool(void)
3488{
3489        kmem_cache_destroy(iommu_devinfo_cache);
3490        kmem_cache_destroy(iommu_domain_cache);
3491        kmem_cache_destroy(iommu_iova_cache);
3492
3493}
3494
3495static void quirk_ioat_snb_local_iommu(struct pci_dev *pdev)
3496{
3497        struct dmar_drhd_unit *drhd;
3498        u32 vtbar;
3499        int rc;
3500
3501        /* We know that this device on this chipset has its own IOMMU.
3502         * If we find it under a different IOMMU, then the BIOS is lying
3503         * to us. Hope that the IOMMU for this device is actually
3504         * disabled, and it needs no translation...
3505         */
3506        rc = pci_bus_read_config_dword(pdev->bus, PCI_DEVFN(0, 0), 0xb0, &vtbar);
3507        if (rc) {
3508                /* "can't" happen */
3509                dev_info(&pdev->dev, "failed to run vt-d quirk\n");
3510                return;
3511        }
3512        vtbar &= 0xffff0000;
3513
3514        /* we know that the this iommu should be at offset 0xa000 from vtbar */
3515        drhd = dmar_find_matched_drhd_unit(pdev);
3516        if (WARN_TAINT_ONCE(!drhd || drhd->reg_base_addr - vtbar != 0xa000,
3517                            TAINT_FIRMWARE_WORKAROUND,
3518                            "BIOS assigned incorrect VT-d unit for Intel(R) QuickData Technology device\n"))
3519                pdev->dev.archdata.iommu = DUMMY_DEVICE_DOMAIN_INFO;
3520}
3521DECLARE_PCI_FIXUP_ENABLE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_IOAT_SNB, quirk_ioat_snb_local_iommu);
3522
3523static void __init init_no_remapping_devices(void)
3524{
3525        struct dmar_drhd_unit *drhd;
3526        struct device *dev;
3527        int i;
3528
3529        for_each_drhd_unit(drhd) {
3530                if (!drhd->include_all) {
3531                        for_each_active_dev_scope(drhd->devices,
3532                                                  drhd->devices_cnt, i, dev)
3533                                break;
3534                        /* ignore DMAR unit if no devices exist */
3535                        if (i == drhd->devices_cnt)
3536                                drhd->ignored = 1;
3537                }
3538        }
3539
3540        for_each_active_drhd_unit(drhd) {
3541                if (drhd->include_all)
3542                        continue;
3543
3544                for_each_active_dev_scope(drhd->devices,
3545                                          drhd->devices_cnt, i, dev)
3546                        if (!dev_is_pci(dev) || !IS_GFX_DEVICE(to_pci_dev(dev)))
3547                                break;
3548                if (i < drhd->devices_cnt)
3549                        continue;
3550
3551                /* This IOMMU has *only* gfx devices. Either bypass it or
3552                   set the gfx_mapped flag, as appropriate */
3553                if (dmar_map_gfx) {
3554                        intel_iommu_gfx_mapped = 1;
3555                } else {
3556                        drhd->ignored = 1;
3557                        for_each_active_dev_scope(drhd->devices,
3558                                                  drhd->devices_cnt, i, dev)
3559                                dev->archdata.iommu = DUMMY_DEVICE_DOMAIN_INFO;
3560                }
3561        }
3562}
3563
3564#ifdef CONFIG_SUSPEND
3565static int init_iommu_hw(void)
3566{
3567        struct dmar_drhd_unit *drhd;
3568        struct intel_iommu *iommu = NULL;
3569
3570        for_each_active_iommu(iommu, drhd)
3571                if (iommu->qi)
3572                        dmar_reenable_qi(iommu);
3573
3574        for_each_iommu(iommu, drhd) {
3575                if (drhd->ignored) {
3576                        /*
3577                         * we always have to disable PMRs or DMA may fail on
3578                         * this device
3579                         */
3580                        if (force_on)
3581                                iommu_disable_protect_mem_regions(iommu);
3582                        continue;
3583                }
3584       
3585                iommu_flush_write_buffer(iommu);
3586
3587                iommu_set_root_entry(iommu);
3588
3589                iommu->flush.flush_context(iommu, 0, 0, 0,
3590                                           DMA_CCMD_GLOBAL_INVL);
3591                iommu->flush.flush_iotlb(iommu, 0, 0, 0, DMA_TLB_GLOBAL_FLUSH);
3592                iommu_enable_translation(iommu);
3593                iommu_disable_protect_mem_regions(iommu);
3594        }
3595
3596        return 0;
3597}
3598
3599static void iommu_flush_all(void)
3600{
3601        struct dmar_drhd_unit *drhd;
3602        struct intel_iommu *iommu;
3603
3604        for_each_active_iommu(iommu, drhd) {
3605                iommu->flush.flush_context(iommu, 0, 0, 0,
3606                                           DMA_CCMD_GLOBAL_INVL);
3607                iommu->flush.flush_iotlb(iommu, 0, 0, 0,
3608                                         DMA_TLB_GLOBAL_FLUSH);
3609        }
3610}
3611
3612static int iommu_suspend(void)
3613{
3614        struct dmar_drhd_unit *drhd;
3615        struct intel_iommu *iommu = NULL;
3616        unsigned long flag;
3617
3618        for_each_active_iommu(iommu, drhd) {
3619                iommu->iommu_state = kzalloc(sizeof(u32) * MAX_SR_DMAR_REGS,
3620                                                 GFP_ATOMIC);
3621                if (!iommu->iommu_state)
3622                        goto nomem;
3623        }
3624
3625        iommu_flush_all();
3626
3627        for_each_active_iommu(iommu, drhd) {
3628                iommu_disable_translation(iommu);
3629
3630                raw_spin_lock_irqsave(&iommu->register_lock, flag);
3631
3632                iommu->iommu_state[SR_DMAR_FECTL_REG] =
3633                        readl(iommu->reg + DMAR_FECTL_REG);
3634                iommu->iommu_state[SR_DMAR_FEDATA_REG] =
3635                        readl(iommu->reg + DMAR_FEDATA_REG);
3636                iommu->iommu_state[SR_DMAR_FEADDR_REG] =
3637                        readl(iommu->reg + DMAR_FEADDR_REG);
3638                iommu->iommu_state[SR_DMAR_FEUADDR_REG] =
3639                        readl(iommu->reg + DMAR_FEUADDR_REG);
3640
3641                raw_spin_unlock_irqrestore(&iommu->register_lock, flag);
3642        }
3643        return 0;
3644
3645nomem:
3646        for_each_active_iommu(iommu, drhd)
3647                kfree(iommu->iommu_state);
3648
3649        return -ENOMEM;
3650}
3651
3652static void iommu_resume(void)
3653{
3654        struct dmar_drhd_unit *drhd;
3655        struct intel_iommu *iommu = NULL;
3656        unsigned long flag;
3657
3658        if (init_iommu_hw()) {
3659                if (force_on)
3660                        panic("tboot: IOMMU setup failed, DMAR can not resume!\n");
3661                else
3662                        WARN(1, "IOMMU setup failed, DMAR can not resume!\n");
3663                return;
3664        }
3665
3666        for_each_active_iommu(iommu, drhd) {
3667
3668                raw_spin_lock_irqsave(&iommu->register_lock, flag);
3669
3670                writel(iommu->iommu_state[SR_DMAR_FECTL_REG],
3671                        iommu->reg + DMAR_FECTL_REG);
3672                writel(iommu->iommu_state[SR_DMAR_FEDATA_REG],
3673                        iommu->reg + DMAR_FEDATA_REG);
3674                writel(iommu->iommu_state[SR_DMAR_FEADDR_REG],
3675                        iommu->reg + DMAR_FEADDR_REG);
3676                writel(iommu->iommu_state[SR_DMAR_FEUADDR_REG],
3677                        iommu->reg + DMAR_FEUADDR_REG);
3678
3679                raw_spin_unlock_irqrestore(&iommu->register_lock, flag);
3680        }
3681
3682        for_each_active_iommu(iommu, drhd)
3683                kfree(iommu->iommu_state);
3684}
3685
3686static struct syscore_ops iommu_syscore_ops = {
3687        .resume         = iommu_resume,
3688        .suspend        = iommu_suspend,
3689};
3690
3691static void __init init_iommu_pm_ops(void)
3692{
3693        register_syscore_ops(&iommu_syscore_ops);
3694}
3695
3696#else
3697static inline void init_iommu_pm_ops(void) {}
3698#endif  /* CONFIG_PM */
3699
3700
3701int __init dmar_parse_one_rmrr(struct acpi_dmar_header *header)
3702{
3703        struct acpi_dmar_reserved_memory *rmrr;
3704        struct dmar_rmrr_unit *rmrru;
3705
3706        rmrru = kzalloc(sizeof(*rmrru), GFP_KERNEL);
3707        if (!rmrru)
3708                return -ENOMEM;
3709
3710        rmrru->hdr = header;
3711        rmrr = (struct acpi_dmar_reserved_memory *)header;
3712        rmrru->base_address = rmrr->base_address;
3713        rmrru->end_address = rmrr->end_address;
3714        rmrru->devices = dmar_alloc_dev_scope((void *)(rmrr + 1),
3715                                ((void *)rmrr) + rmrr->header.length,
3716                                &rmrru->devices_cnt);
3717        if (rmrru->devices_cnt && rmrru->devices == NULL) {
3718                kfree(rmrru);
3719                return -ENOMEM;
3720        }
3721
3722        list_add(&rmrru->list, &dmar_rmrr_units);
3723
3724        return 0;
3725}
3726
3727int __init dmar_parse_one_atsr(struct acpi_dmar_header *hdr)
3728{
3729        struct acpi_dmar_atsr *atsr;
3730        struct dmar_atsr_unit *atsru;
3731
3732        atsr = container_of(hdr, struct acpi_dmar_atsr, header);
3733        atsru = kzalloc(sizeof(*atsru), GFP_KERNEL);
3734        if (!atsru)
3735                return -ENOMEM;
3736
3737        atsru->hdr = hdr;
3738        atsru->include_all = atsr->flags & 0x1;
3739        if (!atsru->include_all) {
3740                atsru->devices = dmar_alloc_dev_scope((void *)(atsr + 1),
3741                                (void *)atsr + atsr->header.length,
3742                                &atsru->devices_cnt);
3743                if (atsru->devices_cnt && atsru->devices == NULL) {
3744                        kfree(atsru);
3745                        return -ENOMEM;
3746                }
3747        }
3748
3749        list_add_rcu(&atsru->list, &dmar_atsr_units);
3750
3751        return 0;
3752}
3753
3754static void intel_iommu_free_atsr(struct dmar_atsr_unit *atsru)
3755{
3756        dmar_free_dev_scope(&atsru->devices, &atsru->devices_cnt);
3757        kfree(atsru);
3758}
3759
3760static void intel_iommu_free_dmars(void)
3761{
3762        struct dmar_rmrr_unit *rmrru, *rmrr_n;
3763        struct dmar_atsr_unit *atsru, *atsr_n;
3764
3765        list_for_each_entry_safe(rmrru, rmrr_n, &dmar_rmrr_units, list) {
3766                list_del(&rmrru->list);
3767                dmar_free_dev_scope(&rmrru->devices, &rmrru->devices_cnt);
3768                kfree(rmrru);
3769        }
3770
3771        list_for_each_entry_safe(atsru, atsr_n, &dmar_atsr_units, list) {
3772                list_del(&atsru->list);
3773                intel_iommu_free_atsr(atsru);
3774        }
3775}
3776
3777int dmar_find_matched_atsr_unit(struct pci_dev *dev)
3778{
3779        int i, ret = 1;
3780        struct pci_bus *bus;
3781        struct pci_dev *bridge = NULL;
3782        struct device *tmp;
3783        struct acpi_dmar_atsr *atsr;
3784        struct dmar_atsr_unit *atsru;
3785
3786        dev = pci_physfn(dev);
3787        for (bus = dev->bus; bus; bus = bus->parent) {
3788                bridge = bus->self;
3789                if (!bridge || !pci_is_pcie(bridge) ||
3790                    pci_pcie_type(bridge) == PCI_EXP_TYPE_PCI_BRIDGE)
3791                        return 0;
3792                if (pci_pcie_type(bridge) == PCI_EXP_TYPE_ROOT_PORT)
3793                        break;
3794        }
3795        if (!bridge)
3796                return 0;
3797
3798        rcu_read_lock();
3799        list_for_each_entry_rcu(atsru, &dmar_atsr_units, list) {
3800                atsr = container_of(atsru->hdr, struct acpi_dmar_atsr, header);
3801                if (atsr->segment != pci_domain_nr(dev->bus))
3802                        continue;
3803
3804                for_each_dev_scope(atsru->devices, atsru->devices_cnt, i, tmp)
3805                        if (tmp == &bridge->dev)
3806                                goto out;
3807
3808                if (atsru->include_all)
3809                        goto out;
3810        }
3811        ret = 0;
3812out:
3813        rcu_read_unlock();
3814
3815        return ret;
3816}
3817
3818int dmar_iommu_notify_scope_dev(struct dmar_pci_notify_info *info)
3819{
3820        int ret = 0;
3821        struct dmar_rmrr_unit *rmrru;
3822        struct dmar_atsr_unit *atsru;
3823        struct acpi_dmar_atsr *atsr;
3824        struct acpi_dmar_reserved_memory *rmrr;
3825
3826        if (!intel_iommu_enabled && system_state != SYSTEM_BOOTING)
3827                return 0;
3828
3829        list_for_each_entry(rmrru, &dmar_rmrr_units, list) {
3830                rmrr = container_of(rmrru->hdr,
3831                                    struct acpi_dmar_reserved_memory, header);
3832                if (info->event == BUS_NOTIFY_ADD_DEVICE) {
3833                        ret = dmar_insert_dev_scope(info, (void *)(rmrr + 1),
3834                                ((void *)rmrr) + rmrr->header.length,
3835                                rmrr->segment, rmrru->devices,
3836                                rmrru->devices_cnt);
3837                        if(ret < 0)
3838                                return ret;
3839                } else if (info->event == BUS_NOTIFY_DEL_DEVICE) {
3840                        dmar_remove_dev_scope(info, rmrr->segment,
3841                                rmrru->devices, rmrru->devices_cnt);
3842                }
3843        }
3844
3845        list_for_each_entry(atsru, &dmar_atsr_units, list) {
3846                if (atsru->include_all)
3847                        continue;
3848
3849                atsr = container_of(atsru->hdr, struct acpi_dmar_atsr, header);
3850                if (info->event == BUS_NOTIFY_ADD_DEVICE) {
3851                        ret = dmar_insert_dev_scope(info, (void *)(atsr + 1),
3852                                        (void *)atsr + atsr->header.length,
3853                                        atsr->segment, atsru->devices,
3854                                        atsru->devices_cnt);
3855                        if (ret > 0)
3856                                break;
3857                        else if(ret < 0)
3858                                return ret;
3859                } else if (info->event == BUS_NOTIFY_DEL_DEVICE) {
3860                        if (dmar_remove_dev_scope(info, atsr->segment,
3861                                        atsru->devices, atsru->devices_cnt))
3862                                break;
3863                }
3864        }
3865
3866        return 0;
3867}
3868
3869/*
3870 * Here we only respond to action of unbound device from driver.
3871 *
3872 * Added device is not attached to its DMAR domain here yet. That will happen
3873 * when mapping the device to iova.
3874 */
3875static int device_notifier(struct notifier_block *nb,
3876                                  unsigned long action, void *data)
3877{
3878        struct device *dev = data;
3879        struct dmar_domain *domain;
3880
3881        if (iommu_dummy(dev))
3882                return 0;
3883
3884        if (action != BUS_NOTIFY_REMOVED_DEVICE)
3885                return 0;
3886
3887        /*
3888         * If the device is still attached to a device driver we can't
3889         * tear down the domain yet as DMA mappings may still be in use.
3890         * Wait for the BUS_NOTIFY_UNBOUND_DRIVER event to do that.
3891         */
3892        if (action == BUS_NOTIFY_DEL_DEVICE && dev->driver != NULL)
3893                return 0;
3894
3895        domain = find_domain(dev);
3896        if (!domain)
3897                return 0;
3898
3899        down_read(&dmar_global_lock);
3900        domain_remove_one_dev_info(domain, dev);
3901        if (!domain_type_is_vm_or_si(domain) && list_empty(&domain->devices))
3902                domain_exit(domain);
3903        up_read(&dmar_global_lock);
3904
3905        return 0;
3906}
3907
3908static struct notifier_block device_nb = {
3909        .notifier_call = device_notifier,
3910};
3911
3912static int intel_iommu_memory_notifier(struct notifier_block *nb,
3913                                       unsigned long val, void *v)
3914{
3915        struct memory_notify *mhp = v;
3916        unsigned long long start, end;
3917        unsigned long start_vpfn, last_vpfn;
3918
3919        switch (val) {
3920        case MEM_GOING_ONLINE:
3921                start = mhp->start_pfn << PAGE_SHIFT;
3922                end = ((mhp->start_pfn + mhp->nr_pages) << PAGE_SHIFT) - 1;
3923                if (iommu_domain_identity_map(si_domain, start, end)) {
3924                        pr_warn("dmar: failed to build identity map for [%llx-%llx]\n",
3925                                start, end);
3926                        return NOTIFY_BAD;
3927                }
3928                break;
3929
3930        case MEM_OFFLINE:
3931        case MEM_CANCEL_ONLINE:
3932                start_vpfn = mm_to_dma_pfn(mhp->start_pfn);
3933                last_vpfn = mm_to_dma_pfn(mhp->start_pfn + mhp->nr_pages - 1);
3934                while (start_vpfn <= last_vpfn) {
3935                        struct iova *iova;
3936                        struct dmar_drhd_unit *drhd;
3937                        struct intel_iommu *iommu;
3938                        struct page *freelist;
3939
3940                        iova = find_iova(&si_domain->iovad, start_vpfn);
3941                        if (iova == NULL) {
3942                                pr_debug("dmar: failed get IOVA for PFN %lx\n",
3943                                         start_vpfn);
3944                                break;
3945                        }
3946
3947                        iova = split_and_remove_iova(&si_domain->iovad, iova,
3948                                                     start_vpfn, last_vpfn);
3949                        if (iova == NULL) {
3950                                pr_warn("dmar: failed to split IOVA PFN [%lx-%lx]\n",
3951                                        start_vpfn, last_vpfn);
3952                                return NOTIFY_BAD;
3953                        }
3954
3955                        freelist = domain_unmap(si_domain, iova->pfn_lo,
3956                                               iova->pfn_hi);
3957
3958                        rcu_read_lock();
3959                        for_each_active_iommu(iommu, drhd)
3960                                iommu_flush_iotlb_psi(iommu, si_domain->id,
3961                                        iova->pfn_lo, iova_size(iova),
3962                                        !freelist, 0);
3963                        rcu_read_unlock();
3964                        dma_free_pagelist(freelist);
3965
3966                        start_vpfn = iova->pfn_hi + 1;
3967                        free_iova_mem(iova);
3968                }
3969                break;
3970        }
3971
3972        return NOTIFY_OK;
3973}
3974
3975static struct notifier_block intel_iommu_memory_nb = {
3976        .notifier_call = intel_iommu_memory_notifier,
3977        .priority = 0
3978};
3979
3980
3981static ssize_t intel_iommu_show_version(struct device *dev,
3982                                        struct device_attribute *attr,
3983                                        char *buf)
3984{
3985        struct intel_iommu *iommu = dev_get_drvdata(dev);
3986        u32 ver = readl(iommu->reg + DMAR_VER_REG);
3987        return sprintf(buf, "%d:%d\n",
3988                       DMAR_VER_MAJOR(ver), DMAR_VER_MINOR(ver));
3989}
3990static DEVICE_ATTR(version, S_IRUGO, intel_iommu_show_version, NULL);
3991
3992static ssize_t intel_iommu_show_address(struct device *dev,
3993                                        struct device_attribute *attr,
3994                                        char *buf)
3995{
3996        struct intel_iommu *iommu = dev_get_drvdata(dev);
3997        return sprintf(buf, "%llx\n", iommu->reg_phys);
3998}
3999static DEVICE_ATTR(address, S_IRUGO, intel_iommu_show_address, NULL);
4000
4001static ssize_t intel_iommu_show_cap(struct device *dev,
4002                                    struct device_attribute *attr,
4003                                    char *buf)
4004{
4005        struct intel_iommu *iommu = dev_get_drvdata(dev);
4006        return sprintf(buf, "%llx\n", iommu->cap);
4007}
4008static DEVICE_ATTR(cap, S_IRUGO, intel_iommu_show_cap, NULL);
4009
4010static ssize_t intel_iommu_show_ecap(struct device *dev,
4011                                    struct device_attribute *attr,
4012                                    char *buf)
4013{
4014        struct intel_iommu *iommu = dev_get_drvdata(dev);
4015        return sprintf(buf, "%llx\n", iommu->ecap);
4016}
4017static DEVICE_ATTR(ecap, S_IRUGO, intel_iommu_show_ecap, NULL);
4018
4019static struct attribute *intel_iommu_attrs[] = {
4020        &dev_attr_version.attr,
4021        &dev_attr_address.attr,
4022        &dev_attr_cap.attr,
4023        &dev_attr_ecap.attr,
4024        NULL,
4025};
4026
4027static struct attribute_group intel_iommu_group = {
4028        .name = "intel-iommu",
4029        .attrs = intel_iommu_attrs,
4030};
4031
4032const struct attribute_group *intel_iommu_groups[] = {
4033        &intel_iommu_group,
4034        NULL,
4035};
4036
4037int __init intel_iommu_init(void)
4038{
4039        int ret = -ENODEV;
4040        struct dmar_drhd_unit *drhd;
4041        struct intel_iommu *iommu;
4042
4043        /* VT-d is required for a TXT/tboot launch, so enforce that */
4044        force_on = tboot_force_iommu();
4045
4046        if (iommu_init_mempool()) {
4047                if (force_on)
4048                        panic("tboot: Failed to initialize iommu memory\n");
4049                return -ENOMEM;
4050        }
4051
4052        down_write(&dmar_global_lock);
4053        if (dmar_table_init()) {
4054                if (force_on)
4055                        panic("tboot: Failed to initialize DMAR table\n");
4056                goto out_free_dmar;
4057        }
4058
4059        /*
4060         * Disable translation if already enabled prior to OS handover.
4061         */
4062        for_each_active_iommu(iommu, drhd)
4063                if (iommu->gcmd & DMA_GCMD_TE)
4064                        iommu_disable_translation(iommu);
4065
4066        if (dmar_dev_scope_init() < 0) {
4067                if (force_on)
4068                        panic("tboot: Failed to initialize DMAR device scope\n");
4069                goto out_free_dmar;
4070        }
4071
4072        if (no_iommu || dmar_disabled)
4073                goto out_free_dmar;
4074
4075        if (list_empty(&dmar_rmrr_units))
4076                printk(KERN_INFO "DMAR: No RMRR found\n");
4077
4078        if (list_empty(&dmar_atsr_units))
4079                printk(KERN_INFO "DMAR: No ATSR found\n");
4080
4081        if (dmar_init_reserved_ranges()) {
4082                if (force_on)
4083                        panic("tboot: Failed to reserve iommu ranges\n");
4084                goto out_free_reserved_range;
4085        }
4086
4087        init_no_remapping_devices();
4088
4089        ret = init_dmars();
4090        if (ret) {
4091                if (force_on)
4092                        panic("tboot: Failed to initialize DMARs\n");
4093                printk(KERN_ERR "IOMMU: dmar init failed\n");
4094                goto out_free_reserved_range;
4095        }
4096        up_write(&dmar_global_lock);
4097        printk(KERN_INFO
4098        "PCI-DMA: Intel(R) Virtualization Technology for Directed I/O\n");
4099
4100        init_timer(&unmap_timer);
4101#ifdef CONFIG_SWIOTLB
4102        swiotlb = 0;
4103#endif
4104        dma_ops = &intel_dma_ops;
4105
4106        init_iommu_pm_ops();
4107
4108        for_each_active_iommu(iommu, drhd)
4109                iommu->iommu_dev = iommu_device_create(NULL, iommu,
4110                                                       intel_iommu_groups,
4111                                                       iommu->name);
4112
4113        bus_set_iommu(&pci_bus_type, &intel_iommu_ops);
4114        bus_register_notifier(&pci_bus_type, &device_nb);
4115        if (si_domain && !hw_pass_through)
4116                register_memory_notifier(&intel_iommu_memory_nb);
4117
4118        intel_iommu_enabled = 1;
4119
4120        return 0;
4121
4122out_free_reserved_range:
4123        put_iova_domain(&reserved_iova_list);
4124out_free_dmar:
4125        intel_iommu_free_dmars();
4126        up_write(&dmar_global_lock);
4127        iommu_exit_mempool();
4128        return ret;
4129}
4130
4131static int iommu_detach_dev_cb(struct pci_dev *pdev, u16 alias, void *opaque)
4132{
4133        struct intel_iommu *iommu = opaque;
4134
4135        iommu_detach_dev(iommu, PCI_BUS_NUM(alias), alias & 0xff);
4136        return 0;
4137}
4138
4139/*
4140 * NB - intel-iommu lacks any sort of reference counting for the users of
4141 * dependent devices.  If multiple endpoints have intersecting dependent
4142 * devices, unbinding the driver from any one of them will possibly leave
4143 * the others unable to operate.
4144 */
4145static void iommu_detach_dependent_devices(struct intel_iommu *iommu,
4146                                           struct device *dev)
4147{
4148        if (!iommu || !dev || !dev_is_pci(dev))
4149                return;
4150
4151        pci_for_each_dma_alias(to_pci_dev(dev), &iommu_detach_dev_cb, iommu);
4152}
4153
4154static void domain_remove_one_dev_info(struct dmar_domain *domain,
4155                                       struct device *dev)
4156{
4157        struct device_domain_info *info, *tmp;
4158        struct intel_iommu *iommu;
4159        unsigned long flags;
4160        int found = 0;
4161        u8 bus, devfn;
4162
4163        iommu = device_to_iommu(dev, &bus, &devfn);
4164        if (!iommu)
4165                return;
4166
4167        spin_lock_irqsave(&device_domain_lock, flags);
4168        list_for_each_entry_safe(info, tmp, &domain->devices, link) {
4169                if (info->iommu == iommu && info->bus == bus &&
4170                    info->devfn == devfn) {
4171                        unlink_domain_info(info);
4172                        spin_unlock_irqrestore(&device_domain_lock, flags);
4173
4174                        iommu_disable_dev_iotlb(info);
4175                        iommu_detach_dev(iommu, info->bus, info->devfn);
4176                        iommu_detach_dependent_devices(iommu, dev);
4177                        free_devinfo_mem(info);
4178
4179                        spin_lock_irqsave(&device_domain_lock, flags);
4180
4181                        if (found)
4182                                break;
4183                        else
4184                                continue;
4185                }
4186
4187                /* if there is no other devices under the same iommu
4188                 * owned by this domain, clear this iommu in iommu_bmp
4189                 * update iommu count and coherency
4190                 */
4191                if (info->iommu == iommu)
4192                        found = 1;
4193        }
4194
4195        spin_unlock_irqrestore(&device_domain_lock, flags);
4196
4197        if (found == 0) {
4198                domain_detach_iommu(domain, iommu);
4199                if (!domain_type_is_vm_or_si(domain))
4200                        iommu_detach_domain(domain, iommu);
4201        }
4202}
4203
4204static int md_domain_init(struct dmar_domain *domain, int guest_width)
4205{
4206        int adjust_width;
4207
4208        init_iova_domain(&domain->iovad, DMA_32BIT_PFN);
4209        domain_reserve_special_ranges(domain);
4210
4211        /* calculate AGAW */
4212        domain->gaw = guest_width;
4213        adjust_width = guestwidth_to_adjustwidth(guest_width);
4214        domain->agaw = width_to_agaw(adjust_width);
4215
4216        domain->iommu_coherency = 0;
4217        domain->iommu_snooping = 0;
4218        domain->iommu_superpage = 0;
4219        domain->max_addr = 0;
4220
4221        /* always allocate the top pgd */
4222        domain->pgd = (struct dma_pte *)alloc_pgtable_page(domain->nid);
4223        if (!domain->pgd)
4224                return -ENOMEM;
4225        domain_flush_cache(domain, domain->pgd, PAGE_SIZE);
4226        return 0;
4227}
4228
4229static int intel_iommu_domain_init(struct iommu_domain *domain)
4230{
4231        struct dmar_domain *dmar_domain;
4232
4233        dmar_domain = alloc_domain(DOMAIN_FLAG_VIRTUAL_MACHINE);
4234        if (!dmar_domain) {
4235                printk(KERN_ERR
4236                        "intel_iommu_domain_init: dmar_domain == NULL\n");
4237                return -ENOMEM;
4238        }
4239        if (md_domain_init(dmar_domain, DEFAULT_DOMAIN_ADDRESS_WIDTH)) {
4240                printk(KERN_ERR
4241                        "intel_iommu_domain_init() failed\n");
4242                domain_exit(dmar_domain);
4243                return -ENOMEM;
4244        }
4245        domain_update_iommu_cap(dmar_domain);
4246        domain->priv = dmar_domain;
4247
4248        domain->geometry.aperture_start = 0;
4249        domain->geometry.aperture_end   = __DOMAIN_MAX_ADDR(dmar_domain->gaw);
4250        domain->geometry.force_aperture = true;
4251
4252        return 0;
4253}
4254
4255static void intel_iommu_domain_destroy(struct iommu_domain *domain)
4256{
4257        struct dmar_domain *dmar_domain = domain->priv;
4258
4259        domain->priv = NULL;
4260        domain_exit(dmar_domain);
4261}
4262
4263static int intel_iommu_attach_device(struct iommu_domain *domain,
4264                                     struct device *dev)
4265{
4266        struct dmar_domain *dmar_domain = domain->priv;
4267        struct intel_iommu *iommu;
4268        int addr_width;
4269        u8 bus, devfn;
4270
4271        if (device_is_rmrr_locked(dev)) {
4272                dev_warn(dev, "Device is ineligible for IOMMU domain attach due to platform RMRR requirement.  Contact your platform vendor.\n");
4273                return -EPERM;
4274        }
4275
4276        /* normally dev is not mapped */
4277        if (unlikely(domain_context_mapped(dev))) {
4278                struct dmar_domain *old_domain;
4279
4280                old_domain = find_domain(dev);
4281                if (old_domain) {
4282                        if (domain_type_is_vm_or_si(dmar_domain))
4283                                domain_remove_one_dev_info(old_domain, dev);
4284                        else
4285                                domain_remove_dev_info(old_domain);
4286
4287                        if (!domain_type_is_vm_or_si(old_domain) &&
4288                             list_empty(&old_domain->devices))
4289                                domain_exit(old_domain);
4290                }
4291        }
4292
4293        iommu = device_to_iommu(dev, &bus, &devfn);
4294        if (!iommu)
4295                return -ENODEV;
4296
4297        /* check if this iommu agaw is sufficient for max mapped address */
4298        addr_width = agaw_to_width(iommu->agaw);
4299        if (addr_width > cap_mgaw(iommu->cap))
4300                addr_width = cap_mgaw(iommu->cap);
4301
4302        if (dmar_domain->max_addr > (1LL << addr_width)) {
4303                printk(KERN_ERR "%s: iommu width (%d) is not "
4304                       "sufficient for the mapped address (%llx)\n",
4305                       __func__, addr_width, dmar_domain->max_addr);
4306                return -EFAULT;
4307        }
4308        dmar_domain->gaw = addr_width;
4309
4310        /*
4311         * Knock out extra levels of page tables if necessary
4312         */
4313        while (iommu->agaw < dmar_domain->agaw) {
4314                struct dma_pte *pte;
4315
4316                pte = dmar_domain->pgd;
4317                if (dma_pte_present(pte)) {
4318                        dmar_domain->pgd = (struct dma_pte *)
4319                                phys_to_virt(dma_pte_addr(pte));
4320                        free_pgtable_page(pte);
4321                }
4322                dmar_domain->agaw--;
4323        }
4324
4325        return domain_add_dev_info(dmar_domain, dev, CONTEXT_TT_MULTI_LEVEL);
4326}
4327
4328static void intel_iommu_detach_device(struct iommu_domain *domain,
4329                                      struct device *dev)
4330{
4331        struct dmar_domain *dmar_domain = domain->priv;
4332
4333        domain_remove_one_dev_info(dmar_domain, dev);
4334}
4335
4336static int intel_iommu_map(struct iommu_domain *domain,
4337                           unsigned long iova, phys_addr_t hpa,
4338                           size_t size, int iommu_prot)
4339{
4340        struct dmar_domain *dmar_domain = domain->priv;
4341        u64 max_addr;
4342        int prot = 0;
4343        int ret;
4344
4345        if (iommu_prot & IOMMU_READ)
4346                prot |= DMA_PTE_READ;
4347        if (iommu_prot & IOMMU_WRITE)
4348                prot |= DMA_PTE_WRITE;
4349        if ((iommu_prot & IOMMU_CACHE) && dmar_domain->iommu_snooping)
4350                prot |= DMA_PTE_SNP;
4351
4352        max_addr = iova + size;
4353        if (dmar_domain->max_addr < max_addr) {
4354                u64 end;
4355
4356                /* check if minimum agaw is sufficient for mapped address */
4357                end = __DOMAIN_MAX_ADDR(dmar_domain->gaw) + 1;
4358                if (end < max_addr) {
4359                        printk(KERN_ERR "%s: iommu width (%d) is not "
4360                               "sufficient for the mapped address (%llx)\n",
4361                               __func__, dmar_domain->gaw, max_addr);
4362                        return -EFAULT;
4363                }
4364                dmar_domain->max_addr = max_addr;
4365        }
4366        /* Round up size to next multiple of PAGE_SIZE, if it and
4367           the low bits of hpa would take us onto the next page */
4368        size = aligned_nrpages(hpa, size);
4369        ret = domain_pfn_mapping(dmar_domain, iova >> VTD_PAGE_SHIFT,
4370                                 hpa >> VTD_PAGE_SHIFT, size, prot);
4371        return ret;
4372}
4373
4374static size_t intel_iommu_unmap(struct iommu_domain *domain,
4375                                unsigned long iova, size_t size)
4376{
4377        struct dmar_domain *dmar_domain = domain->priv;
4378        struct page *freelist = NULL;
4379        struct intel_iommu *iommu;
4380        unsigned long start_pfn, last_pfn;
4381        unsigned int npages;
4382        int iommu_id, num, ndomains, level = 0;
4383
4384        /* Cope with horrid API which requires us to unmap more than the
4385           size argument if it happens to be a large-page mapping. */
4386        if (!pfn_to_dma_pte(dmar_domain, iova >> VTD_PAGE_SHIFT, &level))
4387                BUG();
4388
4389        if (size < VTD_PAGE_SIZE << level_to_offset_bits(level))
4390                size = VTD_PAGE_SIZE << level_to_offset_bits(level);
4391
4392        start_pfn = iova >> VTD_PAGE_SHIFT;
4393        last_pfn = (iova + size - 1) >> VTD_PAGE_SHIFT;
4394
4395        freelist = domain_unmap(dmar_domain, start_pfn, last_pfn);
4396
4397        npages = last_pfn - start_pfn + 1;
4398
4399        for_each_set_bit(iommu_id, dmar_domain->iommu_bmp, g_num_of_iommus) {
4400               iommu = g_iommus[iommu_id];
4401
4402               /*
4403                * find bit position of dmar_domain
4404                */
4405               ndomains = cap_ndoms(iommu->cap);
4406               for_each_set_bit(num, iommu->domain_ids, ndomains) {
4407                       if (iommu->domains[num] == dmar_domain)
4408                               iommu_flush_iotlb_psi(iommu, num, start_pfn,
4409                                                     npages, !freelist, 0);
4410               }
4411
4412        }
4413
4414        dma_free_pagelist(freelist);
4415
4416        if (dmar_domain->max_addr == iova + size)
4417                dmar_domain->max_addr = iova;
4418
4419        return size;
4420}
4421
4422static phys_addr_t intel_iommu_iova_to_phys(struct iommu_domain *domain,
4423                                            dma_addr_t iova)
4424{
4425        struct dmar_domain *dmar_domain = domain->priv;
4426        struct dma_pte *pte;
4427        int level = 0;
4428        u64 phys = 0;
4429
4430        pte = pfn_to_dma_pte(dmar_domain, iova >> VTD_PAGE_SHIFT, &level);
4431        if (pte)
4432                phys = dma_pte_addr(pte);
4433
4434        return phys;
4435}
4436
4437static bool intel_iommu_capable(enum iommu_cap cap)
4438{
4439        if (cap == IOMMU_CAP_CACHE_COHERENCY)
4440                return domain_update_iommu_snooping(NULL) == 1;
4441        if (cap == IOMMU_CAP_INTR_REMAP)
4442                return irq_remapping_enabled == 1;
4443
4444        return false;
4445}
4446
4447static int intel_iommu_add_device(struct device *dev)
4448{
4449        struct intel_iommu *iommu;
4450        struct iommu_group *group;
4451        u8 bus, devfn;
4452
4453        iommu = device_to_iommu(dev, &bus, &devfn);
4454        if (!iommu)
4455                return -ENODEV;
4456
4457        iommu_device_link(iommu->iommu_dev, dev);
4458
4459        group = iommu_group_get_for_dev(dev);
4460
4461        if (IS_ERR(group))
4462                return PTR_ERR(group);
4463
4464        iommu_group_put(group);
4465        return 0;
4466}
4467
4468static void intel_iommu_remove_device(struct device *dev)
4469{
4470        struct intel_iommu *iommu;
4471        u8 bus, devfn;
4472
4473        iommu = device_to_iommu(dev, &bus, &devfn);
4474        if (!iommu)
4475                return;
4476
4477        iommu_group_remove_device(dev);
4478
4479        iommu_device_unlink(iommu->iommu_dev, dev);
4480}
4481
4482static const struct iommu_ops intel_iommu_ops = {
4483        .capable        = intel_iommu_capable,
4484        .domain_init    = intel_iommu_domain_init,
4485        .domain_destroy = intel_iommu_domain_destroy,
4486        .attach_dev     = intel_iommu_attach_device,
4487        .detach_dev     = intel_iommu_detach_device,
4488        .map            = intel_iommu_map,
4489        .unmap          = intel_iommu_unmap,
4490        .iova_to_phys   = intel_iommu_iova_to_phys,
4491        .add_device     = intel_iommu_add_device,
4492        .remove_device  = intel_iommu_remove_device,
4493        .pgsize_bitmap  = INTEL_IOMMU_PGSIZES,
4494};
4495
4496static void quirk_iommu_g4x_gfx(struct pci_dev *dev)
4497{
4498        /* G4x/GM45 integrated gfx dmar support is totally busted. */
4499        printk(KERN_INFO "DMAR: Disabling IOMMU for graphics on this chipset\n");
4500        dmar_map_gfx = 0;
4501}
4502
4503DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, 0x2a40, quirk_iommu_g4x_gfx);
4504DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, 0x2e00, quirk_iommu_g4x_gfx);
4505DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, 0x2e10, quirk_iommu_g4x_gfx);
4506DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, 0x2e20, quirk_iommu_g4x_gfx);
4507DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, 0x2e30, quirk_iommu_g4x_gfx);
4508DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, 0x2e40, quirk_iommu_g4x_gfx);
4509DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, 0x2e90, quirk_iommu_g4x_gfx);
4510
4511static void quirk_iommu_rwbf(struct pci_dev *dev)
4512{
4513        /*
4514         * Mobile 4 Series Chipset neglects to set RWBF capability,
4515         * but needs it. Same seems to hold for the desktop versions.
4516         */
4517        printk(KERN_INFO "DMAR: Forcing write-buffer flush capability\n");
4518        rwbf_quirk = 1;
4519}
4520
4521DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, 0x2a40, quirk_iommu_rwbf);
4522DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, 0x2e00, quirk_iommu_rwbf);
4523DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, 0x2e10, quirk_iommu_rwbf);
4524DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, 0x2e20, quirk_iommu_rwbf);
4525DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, 0x2e30, quirk_iommu_rwbf);
4526DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, 0x2e40, quirk_iommu_rwbf);
4527DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, 0x2e90, quirk_iommu_rwbf);
4528
4529#define GGC 0x52
4530#define GGC_MEMORY_SIZE_MASK    (0xf << 8)
4531#define GGC_MEMORY_SIZE_NONE    (0x0 << 8)
4532#define GGC_MEMORY_SIZE_1M      (0x1 << 8)
4533#define GGC_MEMORY_SIZE_2M      (0x3 << 8)
4534#define GGC_MEMORY_VT_ENABLED   (0x8 << 8)
4535#define GGC_MEMORY_SIZE_2M_VT   (0x9 << 8)
4536#define GGC_MEMORY_SIZE_3M_VT   (0xa << 8)
4537#define GGC_MEMORY_SIZE_4M_VT   (0xb << 8)
4538
4539static void quirk_calpella_no_shadow_gtt(struct pci_dev *dev)
4540{
4541        unsigned short ggc;
4542
4543        if (pci_read_config_word(dev, GGC, &ggc))
4544                return;
4545
4546        if (!(ggc & GGC_MEMORY_VT_ENABLED)) {
4547                printk(KERN_INFO "DMAR: BIOS has allocated no shadow GTT; disabling IOMMU for graphics\n");
4548                dmar_map_gfx = 0;
4549        } else if (dmar_map_gfx) {
4550                /* we have to ensure the gfx device is idle before we flush */
4551                printk(KERN_INFO "DMAR: Disabling batched IOTLB flush on Ironlake\n");
4552                intel_iommu_strict = 1;
4553       }
4554}
4555DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, 0x0040, quirk_calpella_no_shadow_gtt);
4556DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, 0x0044, quirk_calpella_no_shadow_gtt);
4557DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, 0x0062, quirk_calpella_no_shadow_gtt);
4558DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, 0x006a, quirk_calpella_no_shadow_gtt);
4559
4560/* On Tylersburg chipsets, some BIOSes have been known to enable the
4561   ISOCH DMAR unit for the Azalia sound device, but not give it any
4562   TLB entries, which causes it to deadlock. Check for that.  We do
4563   this in a function called from init_dmars(), instead of in a PCI
4564   quirk, because we don't want to print the obnoxious "BIOS broken"
4565   message if VT-d is actually disabled.
4566*/
4567static void __init check_tylersburg_isoch(void)
4568{
4569        struct pci_dev *pdev;
4570        uint32_t vtisochctrl;
4571
4572        /* If there's no Azalia in the system anyway, forget it. */
4573        pdev = pci_get_device(PCI_VENDOR_ID_INTEL, 0x3a3e, NULL);
4574        if (!pdev)
4575                return;
4576        pci_dev_put(pdev);
4577
4578        /* System Management Registers. Might be hidden, in which case
4579           we can't do the sanity check. But that's OK, because the
4580           known-broken BIOSes _don't_ actually hide it, so far. */
4581        pdev = pci_get_device(PCI_VENDOR_ID_INTEL, 0x342e, NULL);
4582        if (!pdev)
4583                return;
4584
4585        if (pci_read_config_dword(pdev, 0x188, &vtisochctrl)) {
4586                pci_dev_put(pdev);
4587                return;
4588        }
4589
4590        pci_dev_put(pdev);
4591
4592        /* If Azalia DMA is routed to the non-isoch DMAR unit, fine. */
4593        if (vtisochctrl & 1)
4594                return;
4595
4596        /* Drop all bits other than the number of TLB entries */
4597        vtisochctrl &= 0x1c;
4598
4599        /* If we have the recommended number of TLB entries (16), fine. */
4600        if (vtisochctrl == 0x10)
4601                return;
4602
4603        /* Zero TLB entries? You get to ride the short bus to school. */
4604        if (!vtisochctrl) {
4605                WARN(1, "Your BIOS is broken; DMA routed to ISOCH DMAR unit but no TLB space.\n"
4606                     "BIOS vendor: %s; Ver: %s; Product Version: %s\n",
4607                     dmi_get_system_info(DMI_BIOS_VENDOR),
4608                     dmi_get_system_info(DMI_BIOS_VERSION),
4609                     dmi_get_system_info(DMI_PRODUCT_VERSION));
4610                iommu_identity_mapping |= IDENTMAP_AZALIA;
4611                return;
4612        }
4613       
4614        printk(KERN_WARNING "DMAR: Recommended TLB entries for ISOCH unit is 16; your BIOS set %d\n",
4615               vtisochctrl);
4616}
Note: See TracBrowser for help on using the repository browser.