base: dma-contiguous: Set CMA page prot to page_kernel_exec
[linux-3.10.git] / arch / arm / mm / dma-mapping.c
1 /*
2  *  linux/arch/arm/mm/dma-mapping.c
3  *
4  *  Copyright (C) 2000-2004 Russell King
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 as
8  * published by the Free Software Foundation.
9  *
10  *  DMA uncached mapping support.
11  */
12 #include <linux/module.h>
13 #include <linux/mm.h>
14 #include <linux/gfp.h>
15 #include <linux/errno.h>
16 #include <linux/list.h>
17 #include <linux/init.h>
18 #include <linux/device.h>
19 #include <linux/dma-mapping.h>
20 #include <linux/dma-contiguous.h>
21 #include <linux/highmem.h>
22 #include <linux/memblock.h>
23 #include <linux/slab.h>
24 #include <linux/iommu.h>
25 #include <linux/io.h>
26 #include <linux/vmalloc.h>
27 #include <linux/sizes.h>
28 #include <linux/seq_file.h>
29 #include <linux/debugfs.h>
30
31 #include <asm/memory.h>
32 #include <asm/highmem.h>
33 #include <asm/cacheflush.h>
34 #include <asm/tlbflush.h>
35 #include <asm/mach/arch.h>
36 #include <asm/dma-iommu.h>
37 #include <asm/mach/map.h>
38 #include <asm/system_info.h>
39 #include <asm/dma-contiguous.h>
40
41 #include "mm.h"
42
43 #define CREATE_TRACE_POINTS
44 #include <trace/events/dmadebug.h>
45
46 /*
47  * The DMA API is built upon the notion of "buffer ownership".  A buffer
48  * is either exclusively owned by the CPU (and therefore may be accessed
49  * by it) or exclusively owned by the DMA device.  These helper functions
50  * represent the transitions between these two ownership states.
51  *
52  * Note, however, that on later ARMs, this notion does not work due to
53  * speculative prefetches.  We model our approach on the assumption that
54  * the CPU does do speculative prefetches, which means we clean caches
55  * before transfers and delay cache invalidation until transfer completion.
56  *
57  */
58 static void __dma_page_cpu_to_dev(struct page *, unsigned long,
59                 size_t, enum dma_data_direction);
60 static void __dma_page_dev_to_cpu(struct page *, unsigned long,
61                 size_t, enum dma_data_direction);
62
63 /**
64  * arm_dma_map_page - map a portion of a page for streaming DMA
65  * @dev: valid struct device pointer, or NULL for ISA and EISA-like devices
66  * @page: page that buffer resides in
67  * @offset: offset into page for start of buffer
68  * @size: size of buffer to map
69  * @dir: DMA transfer direction
70  *
71  * Ensure that any data held in the cache is appropriately discarded
72  * or written back.
73  *
74  * The device owns this memory once this call has completed.  The CPU
75  * can regain ownership by calling dma_unmap_page().
76  */
77 static dma_addr_t arm_dma_map_page(struct device *dev, struct page *page,
78              unsigned long offset, size_t size, enum dma_data_direction dir,
79              struct dma_attrs *attrs)
80 {
81         if (!dma_get_attr(DMA_ATTR_SKIP_CPU_SYNC, attrs))
82                 __dma_page_cpu_to_dev(page, offset, size, dir);
83         return pfn_to_dma(dev, page_to_pfn(page)) + offset;
84 }
85
86 static dma_addr_t arm_coherent_dma_map_page(struct device *dev, struct page *page,
87              unsigned long offset, size_t size, enum dma_data_direction dir,
88              struct dma_attrs *attrs)
89 {
90         return pfn_to_dma(dev, page_to_pfn(page)) + offset;
91 }
92
93 /**
94  * arm_dma_unmap_page - unmap a buffer previously mapped through dma_map_page()
95  * @dev: valid struct device pointer, or NULL for ISA and EISA-like devices
96  * @handle: DMA address of buffer
97  * @size: size of buffer (same as passed to dma_map_page)
98  * @dir: DMA transfer direction (same as passed to dma_map_page)
99  *
100  * Unmap a page streaming mode DMA translation.  The handle and size
101  * must match what was provided in the previous dma_map_page() call.
102  * All other usages are undefined.
103  *
104  * After this call, reads by the CPU to the buffer are guaranteed to see
105  * whatever the device wrote there.
106  */
107 static void arm_dma_unmap_page(struct device *dev, dma_addr_t handle,
108                 size_t size, enum dma_data_direction dir,
109                 struct dma_attrs *attrs)
110 {
111         if (!dma_get_attr(DMA_ATTR_SKIP_CPU_SYNC, attrs))
112                 __dma_page_dev_to_cpu(pfn_to_page(dma_to_pfn(dev, handle)),
113                                       handle & ~PAGE_MASK, size, dir);
114 }
115
116 static void arm_dma_sync_single_for_cpu(struct device *dev,
117                 dma_addr_t handle, size_t size, enum dma_data_direction dir)
118 {
119         unsigned int offset = handle & (PAGE_SIZE - 1);
120         struct page *page = pfn_to_page(dma_to_pfn(dev, handle-offset));
121         __dma_page_dev_to_cpu(page, offset, size, dir);
122 }
123
124 static void arm_dma_sync_single_for_device(struct device *dev,
125                 dma_addr_t handle, size_t size, enum dma_data_direction dir)
126 {
127         unsigned int offset = handle & (PAGE_SIZE - 1);
128         struct page *page = pfn_to_page(dma_to_pfn(dev, handle-offset));
129         __dma_page_cpu_to_dev(page, offset, size, dir);
130 }
131
132 struct dma_map_ops arm_dma_ops = {
133         .alloc                  = arm_dma_alloc,
134         .free                   = arm_dma_free,
135         .mmap                   = arm_dma_mmap,
136         .get_sgtable            = arm_dma_get_sgtable,
137         .map_page               = arm_dma_map_page,
138         .unmap_page             = arm_dma_unmap_page,
139         .map_sg                 = arm_dma_map_sg,
140         .unmap_sg               = arm_dma_unmap_sg,
141         .sync_single_for_cpu    = arm_dma_sync_single_for_cpu,
142         .sync_single_for_device = arm_dma_sync_single_for_device,
143         .sync_sg_for_cpu        = arm_dma_sync_sg_for_cpu,
144         .sync_sg_for_device     = arm_dma_sync_sg_for_device,
145         .set_dma_mask           = arm_dma_set_mask,
146 };
147 EXPORT_SYMBOL(arm_dma_ops);
148
149 static void *arm_coherent_dma_alloc(struct device *dev, size_t size,
150         dma_addr_t *handle, gfp_t gfp, struct dma_attrs *attrs);
151 static void arm_coherent_dma_free(struct device *dev, size_t size, void *cpu_addr,
152                                   dma_addr_t handle, struct dma_attrs *attrs);
153
154 struct dma_map_ops arm_coherent_dma_ops = {
155         .alloc                  = arm_coherent_dma_alloc,
156         .free                   = arm_coherent_dma_free,
157         .mmap                   = arm_dma_mmap,
158         .get_sgtable            = arm_dma_get_sgtable,
159         .map_page               = arm_coherent_dma_map_page,
160         .map_sg                 = arm_dma_map_sg,
161         .set_dma_mask           = arm_dma_set_mask,
162 };
163 EXPORT_SYMBOL(arm_coherent_dma_ops);
164
165 static u64 get_coherent_dma_mask(struct device *dev)
166 {
167         u64 mask = (u64)arm_dma_limit;
168
169         if (dev) {
170                 mask = dev->coherent_dma_mask;
171
172                 /*
173                  * Sanity check the DMA mask - it must be non-zero, and
174                  * must be able to be satisfied by a DMA allocation.
175                  */
176                 if (mask == 0) {
177                         dev_warn(dev, "coherent DMA mask is unset\n");
178                         return 0;
179                 }
180
181                 if ((~mask) & (u64)arm_dma_limit) {
182                         dev_warn(dev, "coherent DMA mask %#llx is smaller "
183                                  "than system GFP_DMA mask %#llx\n",
184                                  mask, (u64)arm_dma_limit);
185                         return 0;
186                 }
187         }
188
189         return mask;
190 }
191
192 static void __dma_clear_buffer(struct page *page, size_t size)
193 {
194         /*
195          * Ensure that the allocated pages are zeroed, and that any data
196          * lurking in the kernel direct-mapped region is invalidated.
197          */
198         if (PageHighMem(page)) {
199                 phys_addr_t base = __pfn_to_phys(page_to_pfn(page));
200                 phys_addr_t end = base + size;
201                 while (size > 0) {
202                         void *ptr = kmap_atomic(page);
203                         memset(ptr, 0, PAGE_SIZE);
204                         dmac_flush_range(ptr, ptr + PAGE_SIZE);
205                         kunmap_atomic(ptr);
206                         page++;
207                         size -= PAGE_SIZE;
208                 }
209                 outer_flush_range(base, end);
210         } else {
211                 void *ptr = page_address(page);
212                 memset(ptr, 0, size);
213                 dmac_flush_range(ptr, ptr + size);
214                 outer_flush_range(__pa(ptr), __pa(ptr) + size);
215         }
216 }
217
218 /*
219  * Allocate a DMA buffer for 'dev' of size 'size' using the
220  * specified gfp mask.  Note that 'size' must be page aligned.
221  */
222 static struct page *__dma_alloc_buffer(struct device *dev, size_t size, gfp_t gfp)
223 {
224         unsigned long order = get_order(size);
225         struct page *page, *p, *e;
226
227         page = alloc_pages(gfp, order);
228         if (!page)
229                 return NULL;
230
231         /*
232          * Now split the huge page and free the excess pages
233          */
234         split_page(page, order);
235         for (p = page + (size >> PAGE_SHIFT), e = page + (1 << order); p < e; p++)
236                 __free_page(p);
237
238         __dma_clear_buffer(page, size);
239
240         return page;
241 }
242
243 /*
244  * Free a DMA buffer.  'size' must be page aligned.
245  */
246 static void __dma_free_buffer(struct page *page, size_t size)
247 {
248         struct page *e = page + (size >> PAGE_SHIFT);
249
250         while (page < e) {
251                 __free_page(page);
252                 page++;
253         }
254 }
255
256 #ifdef CONFIG_MMU
257 #ifdef CONFIG_HUGETLB_PAGE
258 #error ARM Coherent DMA allocator does not (yet) support huge TLB
259 #endif
260
261 static void *__alloc_from_contiguous(struct device *dev, size_t size,
262                                      pgprot_t prot, struct page **ret_page,
263                                      const void *caller);
264
265 static void *__alloc_remap_buffer(struct device *dev, size_t size, gfp_t gfp,
266                                  pgprot_t prot, struct page **ret_page,
267                                  const void *caller);
268
269 static void *
270 __dma_alloc_remap(struct page *page, size_t size, gfp_t gfp, pgprot_t prot,
271         const void *caller)
272 {
273         struct vm_struct *area;
274         unsigned long addr;
275
276         /*
277          * DMA allocation can be mapped to user space, so lets
278          * set VM_USERMAP flags too.
279          */
280         area = get_vm_area_caller(size, VM_ARM_DMA_CONSISTENT | VM_USERMAP,
281                                   caller);
282         if (!area)
283                 return NULL;
284         addr = (unsigned long)area->addr;
285         area->phys_addr = __pfn_to_phys(page_to_pfn(page));
286
287         if (ioremap_page_range(addr, addr + size, area->phys_addr, prot)) {
288                 vunmap((void *)addr);
289                 return NULL;
290         }
291         return (void *)addr;
292 }
293
294 static void __dma_free_remap(void *cpu_addr, size_t size)
295 {
296         unsigned int flags = VM_ARM_DMA_CONSISTENT | VM_USERMAP;
297         struct vm_struct *area = find_vm_area(cpu_addr);
298         if (!area || (area->flags & flags) != flags) {
299                 WARN(1, "trying to free invalid coherent area: %p\n", cpu_addr);
300                 return;
301         }
302         unmap_kernel_range((unsigned long)cpu_addr, size);
303         vunmap(cpu_addr);
304 }
305
306 #define DEFAULT_DMA_COHERENT_POOL_SIZE  SZ_256K
307
308 struct dma_pool {
309         size_t size;
310         spinlock_t lock;
311         unsigned long *bitmap;
312         unsigned long nr_pages;
313         void *vaddr;
314         struct page **pages;
315 };
316
317 static struct dma_pool atomic_pool = {
318         .size = DEFAULT_DMA_COHERENT_POOL_SIZE,
319 };
320
321 static int __init early_coherent_pool(char *p)
322 {
323         atomic_pool.size = memparse(p, &p);
324         return 0;
325 }
326 early_param("coherent_pool", early_coherent_pool);
327
328 void __init init_dma_coherent_pool_size(unsigned long size)
329 {
330         /*
331          * Catch any attempt to set the pool size too late.
332          */
333         BUG_ON(atomic_pool.vaddr);
334
335         /*
336          * Set architecture specific coherent pool size only if
337          * it has not been changed by kernel command line parameter.
338          */
339         if (atomic_pool.size == DEFAULT_DMA_COHERENT_POOL_SIZE)
340                 atomic_pool.size = size;
341 }
342
343 /*
344  * Initialise the coherent pool for atomic allocations.
345  */
346 static int __init atomic_pool_init(void)
347 {
348         struct dma_pool *pool = &atomic_pool;
349         pgprot_t prot = pgprot_dmacoherent(pgprot_kernel);
350         gfp_t gfp = GFP_KERNEL | GFP_DMA;
351         unsigned long nr_pages = pool->size >> PAGE_SHIFT;
352         unsigned long *bitmap;
353         struct page *page;
354         struct page **pages;
355         void *ptr;
356         int bitmap_size = BITS_TO_LONGS(nr_pages) * sizeof(long);
357
358         bitmap = kzalloc(bitmap_size, GFP_KERNEL);
359         if (!bitmap)
360                 goto no_bitmap;
361
362         pages = kzalloc(nr_pages * sizeof(struct page *), GFP_KERNEL);
363         if (!pages)
364                 goto no_pages;
365
366         if (IS_ENABLED(CONFIG_CMA))
367                 ptr = __alloc_from_contiguous(NULL, pool->size, prot, &page,
368                                               atomic_pool_init);
369         else
370                 ptr = __alloc_remap_buffer(NULL, pool->size, gfp, prot, &page,
371                                            atomic_pool_init);
372         if (ptr) {
373                 int i;
374
375                 for (i = 0; i < nr_pages; i++)
376                         pages[i] = page + i;
377
378                 spin_lock_init(&pool->lock);
379                 pool->vaddr = ptr;
380                 pool->pages = pages;
381                 pool->bitmap = bitmap;
382                 pool->nr_pages = nr_pages;
383                 pr_info("DMA: preallocated %u KiB pool for atomic coherent allocations\n",
384                        (unsigned)pool->size / 1024);
385                 return 0;
386         }
387
388         kfree(pages);
389 no_pages:
390         kfree(bitmap);
391 no_bitmap:
392         pr_err("DMA: failed to allocate %u KiB pool for atomic coherent allocation\n",
393                (unsigned)pool->size / 1024);
394         return -ENOMEM;
395 }
396 /*
397  * CMA is activated by core_initcall, so we must be called after it.
398  */
399 postcore_initcall(atomic_pool_init);
400
401 struct dma_contig_early_reserve {
402         phys_addr_t base;
403         unsigned long size;
404 };
405
406 static struct dma_contig_early_reserve dma_mmu_remap[MAX_CMA_AREAS] __initdata;
407
408 static int dma_mmu_remap_num __initdata;
409
410 void __init dma_contiguous_early_fixup(phys_addr_t base, unsigned long size)
411 {
412         dma_mmu_remap[dma_mmu_remap_num].base = base;
413         dma_mmu_remap[dma_mmu_remap_num].size = size;
414         dma_mmu_remap_num++;
415 }
416
417 __init void iotable_init_va(struct map_desc *io_desc, int nr);
418 __init void iotable_init_mapping(struct map_desc *io_desc, int nr);
419
420 void __init dma_contiguous_remap(void)
421 {
422         int i;
423         for (i = 0; i < dma_mmu_remap_num; i++) {
424                 phys_addr_t start = dma_mmu_remap[i].base;
425                 phys_addr_t end = start + dma_mmu_remap[i].size;
426                 struct map_desc map;
427                 unsigned long addr;
428
429                 if (end > arm_lowmem_limit)
430                         end = arm_lowmem_limit;
431                 if (start >= end)
432                         continue;
433
434                 map.type = MT_MEMORY;
435
436                 /*
437                  * Clear previous low-memory mapping
438                  */
439                 for (addr = __phys_to_virt(start); addr < __phys_to_virt(end);
440                      addr += PMD_SIZE)
441                         pmd_clear(pmd_off_k(addr));
442
443                 for (addr = start; addr < end; addr += PAGE_SIZE) {
444                         map.pfn = __phys_to_pfn(addr);
445                         map.virtual = __phys_to_virt(addr);
446                         map.length = PAGE_SIZE;
447                         iotable_init_mapping(&map, 1);
448                 }
449
450                 map.pfn = __phys_to_pfn(start);
451                 map.virtual = __phys_to_virt(start);
452                 map.length = end - start;
453                 iotable_init_va(&map, 1);
454         }
455 }
456
457 static void *__alloc_remap_buffer(struct device *dev, size_t size, gfp_t gfp,
458                                  pgprot_t prot, struct page **ret_page,
459                                  const void *caller)
460 {
461         struct page *page;
462         void *ptr;
463         page = __dma_alloc_buffer(dev, size, gfp);
464         if (!page)
465                 return NULL;
466
467         ptr = __dma_alloc_remap(page, size, gfp, prot, caller);
468         if (!ptr) {
469                 __dma_free_buffer(page, size);
470                 return NULL;
471         }
472
473         *ret_page = page;
474         return ptr;
475 }
476
477 static void *__alloc_from_pool(size_t size, struct page **ret_page)
478 {
479         struct dma_pool *pool = &atomic_pool;
480         unsigned int count = PAGE_ALIGN(size) >> PAGE_SHIFT;
481         unsigned int pageno;
482         unsigned long flags;
483         void *ptr = NULL;
484         unsigned long align_mask;
485
486         if (!pool->vaddr) {
487                 WARN(1, "coherent pool not initialised!\n");
488                 return NULL;
489         }
490
491         /*
492          * Align the region allocation - allocations from pool are rather
493          * small, so align them to their order in pages, minimum is a page
494          * size. This helps reduce fragmentation of the DMA space.
495          */
496         align_mask = (1 << get_order(size)) - 1;
497
498         spin_lock_irqsave(&pool->lock, flags);
499         pageno = bitmap_find_next_zero_area(pool->bitmap, pool->nr_pages,
500                                             0, count, align_mask);
501         if (pageno < pool->nr_pages) {
502                 bitmap_set(pool->bitmap, pageno, count);
503                 ptr = pool->vaddr + PAGE_SIZE * pageno;
504                 *ret_page = pool->pages[pageno];
505         } else {
506                 pr_err_once("ERROR: %u KiB atomic DMA coherent pool is too small!\n"
507                             "Please increase it with coherent_pool= kernel parameter!\n",
508                             (unsigned)pool->size / 1024);
509         }
510         spin_unlock_irqrestore(&pool->lock, flags);
511
512         return ptr;
513 }
514
515 static bool __in_atomic_pool(void *start, size_t size)
516 {
517         struct dma_pool *pool = &atomic_pool;
518         void *end = start + size;
519         void *pool_start = pool->vaddr;
520         void *pool_end = pool->vaddr + pool->size;
521
522         if (start < pool_start || start >= pool_end)
523                 return false;
524
525         if (end <= pool_end)
526                 return true;
527
528         WARN(1, "Wrong coherent size(%p-%p) from atomic pool(%p-%p)\n",
529              start, end - 1, pool_start, pool_end - 1);
530
531         return false;
532 }
533
534 static int __free_from_pool(void *start, size_t size)
535 {
536         struct dma_pool *pool = &atomic_pool;
537         unsigned long pageno, count;
538         unsigned long flags;
539
540         if (!__in_atomic_pool(start, size))
541                 return 0;
542
543         pageno = (start - pool->vaddr) >> PAGE_SHIFT;
544         count = size >> PAGE_SHIFT;
545
546         spin_lock_irqsave(&pool->lock, flags);
547         bitmap_clear(pool->bitmap, pageno, count);
548         spin_unlock_irqrestore(&pool->lock, flags);
549
550         return 1;
551 }
552
553 static void *__alloc_from_contiguous(struct device *dev, size_t size,
554                                      pgprot_t prot, struct page **ret_page,
555                                      const void *caller)
556 {
557         unsigned long order = get_order(size);
558         size_t count = size >> PAGE_SHIFT;
559         struct page *page;
560         void *ptr;
561
562         page = dma_alloc_from_contiguous(dev, count, order);
563         if (!page)
564                 return NULL;
565
566         __dma_clear_buffer(page, size);
567
568         if (PageHighMem(page)) {
569                 ptr = __dma_alloc_remap(page, size, GFP_KERNEL, prot, caller);
570                 if (!ptr) {
571                         dma_release_from_contiguous(dev, page, count);
572                         return NULL;
573                 }
574         } else {
575                 ptr = page_address(page);
576         }
577         *ret_page = page;
578         return ptr;
579 }
580
581 static void __free_from_contiguous(struct device *dev, struct page *page,
582                                    void *cpu_addr, size_t size)
583 {
584         if (PageHighMem(page))
585                 __dma_free_remap(cpu_addr, size);
586         dma_release_from_contiguous(dev, page, size >> PAGE_SHIFT);
587 }
588
589 static inline pgprot_t __get_dma_pgprot(struct dma_attrs *attrs, pgprot_t prot)
590 {
591         prot = dma_get_attr(DMA_ATTR_WRITE_COMBINE, attrs) ?
592                             pgprot_writecombine(prot) :
593                             pgprot_dmacoherent(prot);
594         return prot;
595 }
596
597 #define nommu() 0
598
599 #else   /* !CONFIG_MMU */
600
601 #define nommu() 1
602
603 #define __get_dma_pgprot(attrs, prot)   __pgprot(0)
604 #define __alloc_remap_buffer(dev, size, gfp, prot, ret, c)      NULL
605 #define __alloc_from_pool(size, ret_page)                       NULL
606 #define __alloc_from_contiguous(dev, size, prot, ret, c)        NULL
607 #define __free_from_pool(cpu_addr, size)                        0
608 #define __free_from_contiguous(dev, page, cpu_addr, size)       do { } while (0)
609 #define __dma_free_remap(cpu_addr, size)                        do { } while (0)
610
611 #endif  /* CONFIG_MMU */
612
613 static void *__alloc_simple_buffer(struct device *dev, size_t size, gfp_t gfp,
614                                    struct page **ret_page)
615 {
616         struct page *page;
617         page = __dma_alloc_buffer(dev, size, gfp);
618         if (!page)
619                 return NULL;
620
621         *ret_page = page;
622         return page_address(page);
623 }
624
625
626
627 static void *__dma_alloc(struct device *dev, size_t size, dma_addr_t *handle,
628                          gfp_t gfp, pgprot_t prot, bool is_coherent, const void *caller)
629 {
630         u64 mask = get_coherent_dma_mask(dev);
631         struct page *page = NULL;
632         void *addr;
633
634 #ifdef CONFIG_DMA_API_DEBUG
635         u64 limit = (mask + 1) & ~mask;
636         if (limit && size >= limit) {
637                 dev_warn(dev, "coherent allocation too big (requested %#x mask %#llx)\n",
638                         size, mask);
639                 return NULL;
640         }
641 #endif
642
643         if (!mask)
644                 return NULL;
645
646         if (mask < 0xffffffffULL)
647                 gfp |= GFP_DMA;
648
649         /*
650          * Following is a work-around (a.k.a. hack) to prevent pages
651          * with __GFP_COMP being passed to split_page() which cannot
652          * handle them.  The real problem is that this flag probably
653          * should be 0 on ARM as it is not supported on this
654          * platform; see CONFIG_HUGETLBFS.
655          */
656         gfp &= ~(__GFP_COMP);
657
658         *handle = DMA_ERROR_CODE;
659         size = PAGE_ALIGN(size);
660
661         if (is_coherent || nommu())
662                 addr = __alloc_simple_buffer(dev, size, gfp, &page);
663         else if (!(gfp & __GFP_WAIT))
664                 addr = __alloc_from_pool(size, &page);
665         else if (!IS_ENABLED(CONFIG_CMA))
666                 addr = __alloc_remap_buffer(dev, size, gfp, prot, &page, caller);
667         else
668                 addr = __alloc_from_contiguous(dev, size, prot, &page, caller);
669
670         if (addr)
671                 *handle = pfn_to_dma(dev, page_to_pfn(page));
672
673         return addr;
674 }
675
676 /*
677  * Allocate DMA-coherent memory space and return both the kernel remapped
678  * virtual and bus address for that space.
679  */
680 void *arm_dma_alloc(struct device *dev, size_t size, dma_addr_t *handle,
681                     gfp_t gfp, struct dma_attrs *attrs)
682 {
683         pgprot_t prot = __get_dma_pgprot(attrs, pgprot_kernel);
684         void *memory;
685
686         if (dma_alloc_from_coherent_attr(dev, size, handle,
687                         &memory, attrs))
688                 return memory;
689
690         return __dma_alloc(dev, size, handle, gfp, prot, false,
691                            __builtin_return_address(0));
692 }
693
694 static void *arm_coherent_dma_alloc(struct device *dev, size_t size,
695         dma_addr_t *handle, gfp_t gfp, struct dma_attrs *attrs)
696 {
697         pgprot_t prot = __get_dma_pgprot(attrs, pgprot_kernel);
698         void *memory;
699
700         if (dma_alloc_from_coherent_attr(dev, size, handle,
701                         &memory, attrs))
702                         return memory;
703
704         return __dma_alloc(dev, size, handle, gfp, prot, true,
705                            __builtin_return_address(0));
706 }
707
708 /*
709  * Create userspace mapping for the DMA-coherent memory.
710  */
711 int arm_dma_mmap(struct device *dev, struct vm_area_struct *vma,
712                  void *cpu_addr, dma_addr_t dma_addr, size_t size,
713                  struct dma_attrs *attrs)
714 {
715         int ret = -ENXIO;
716 #ifdef CONFIG_MMU
717         unsigned long nr_vma_pages = (vma->vm_end - vma->vm_start) >> PAGE_SHIFT;
718         unsigned long nr_pages = PAGE_ALIGN(size) >> PAGE_SHIFT;
719         unsigned long pfn = dma_to_pfn(dev, dma_addr);
720         unsigned long off = vma->vm_pgoff;
721
722         vma->vm_page_prot = __get_dma_pgprot(attrs, vma->vm_page_prot);
723
724         if (dma_mmap_from_coherent(dev, vma, cpu_addr, size, &ret))
725                 return ret;
726
727         if (off < nr_pages && nr_vma_pages <= (nr_pages - off)) {
728                 ret = remap_pfn_range(vma, vma->vm_start,
729                                       pfn + off,
730                                       vma->vm_end - vma->vm_start,
731                                       vma->vm_page_prot);
732         }
733 #endif  /* CONFIG_MMU */
734
735         return ret;
736 }
737
738 /*
739  * Free a buffer as defined by the above mapping.
740  */
741 static void __arm_dma_free(struct device *dev, size_t size, void *cpu_addr,
742                            dma_addr_t handle, struct dma_attrs *attrs,
743                            bool is_coherent)
744 {
745         struct page *page = pfn_to_page(dma_to_pfn(dev, handle));
746
747         if (dma_release_from_coherent_attr(dev, size, cpu_addr, attrs))
748                 return;
749
750         size = PAGE_ALIGN(size);
751
752         if (is_coherent || nommu()) {
753                 __dma_free_buffer(page, size);
754         } else if (__free_from_pool(cpu_addr, size)) {
755                 return;
756         } else if (!IS_ENABLED(CONFIG_CMA)) {
757                 __dma_free_remap(cpu_addr, size);
758                 __dma_free_buffer(page, size);
759         } else {
760                 /*
761                  * Non-atomic allocations cannot be freed with IRQs disabled
762                  */
763                 WARN_ON(irqs_disabled());
764                 __free_from_contiguous(dev, page, cpu_addr, size);
765         }
766 }
767
768 void arm_dma_free(struct device *dev, size_t size, void *cpu_addr,
769                   dma_addr_t handle, struct dma_attrs *attrs)
770 {
771         __arm_dma_free(dev, size, cpu_addr, handle, attrs, false);
772 }
773
774 static void arm_coherent_dma_free(struct device *dev, size_t size, void *cpu_addr,
775                                   dma_addr_t handle, struct dma_attrs *attrs)
776 {
777         __arm_dma_free(dev, size, cpu_addr, handle, attrs, true);
778 }
779
780 int arm_dma_get_sgtable(struct device *dev, struct sg_table *sgt,
781                  void *cpu_addr, dma_addr_t handle, size_t size,
782                  struct dma_attrs *attrs)
783 {
784         struct page *page = pfn_to_page(dma_to_pfn(dev, handle));
785         int ret;
786
787         ret = sg_alloc_table(sgt, 1, GFP_KERNEL);
788         if (unlikely(ret))
789                 return ret;
790
791         sg_set_page(sgt->sgl, page, PAGE_ALIGN(size), 0);
792         return 0;
793 }
794
795 static void dma_cache_maint_page(struct page *page, unsigned long offset,
796         size_t size, enum dma_data_direction dir,
797         void (*op)(const void *, size_t, int))
798 {
799         unsigned long pfn;
800         size_t left = size;
801
802         pfn = page_to_pfn(page) + offset / PAGE_SIZE;
803         offset %= PAGE_SIZE;
804
805         /*
806          * A single sg entry may refer to multiple physically contiguous
807          * pages.  But we still need to process highmem pages individually.
808          * If highmem is not configured then the bulk of this loop gets
809          * optimized out.
810          */
811         do {
812                 size_t len = left;
813                 void *vaddr;
814
815                 page = pfn_to_page(pfn);
816
817                 if (PageHighMem(page)) {
818                         if (len + offset > PAGE_SIZE)
819                                 len = PAGE_SIZE - offset;
820
821                         if (cache_is_vipt_nonaliasing()) {
822                                 vaddr = kmap_atomic(page);
823                                 op(vaddr + offset, len, dir);
824                                 kunmap_atomic(vaddr);
825                         } else {
826                                 vaddr = kmap_high_get(page);
827                                 if (vaddr) {
828                                         op(vaddr + offset, len, dir);
829                                         kunmap_high(page);
830                                 }
831                         }
832                 } else {
833                         vaddr = page_address(page) + offset;
834                         op(vaddr, len, dir);
835                 }
836                 offset = 0;
837                 pfn++;
838                 left -= len;
839         } while (left);
840 }
841
842 /*
843  * Make an area consistent for devices.
844  * Note: Drivers should NOT use this function directly, as it will break
845  * platforms with CONFIG_DMABOUNCE.
846  * Use the driver DMA support - see dma-mapping.h (dma_sync_*)
847  */
848 static void __dma_page_cpu_to_dev(struct page *page, unsigned long off,
849         size_t size, enum dma_data_direction dir)
850 {
851         unsigned long paddr;
852
853         dma_cache_maint_page(page, off, size, dir, dmac_map_area);
854
855         paddr = page_to_phys(page) + off;
856         if (dir == DMA_FROM_DEVICE) {
857                 outer_inv_range(paddr, paddr + size);
858         } else {
859                 outer_clean_range(paddr, paddr + size);
860         }
861         /* FIXME: non-speculating: flush on bidirectional mappings? */
862 }
863
864 static void __dma_page_dev_to_cpu(struct page *page, unsigned long off,
865         size_t size, enum dma_data_direction dir)
866 {
867         unsigned long paddr = page_to_phys(page) + off;
868
869         /* FIXME: non-speculating: not required */
870         /* don't bother invalidating if DMA to device */
871         if (dir != DMA_TO_DEVICE)
872                 outer_inv_range(paddr, paddr + size);
873
874         dma_cache_maint_page(page, off, size, dir, dmac_unmap_area);
875
876         /*
877          * Mark the D-cache clean for this page to avoid extra flushing.
878          */
879         if (dir != DMA_TO_DEVICE && off == 0 && size >= PAGE_SIZE)
880                 set_bit(PG_dcache_clean, &page->flags);
881 }
882
883 /**
884  * arm_dma_map_sg - map a set of SG buffers for streaming mode DMA
885  * @dev: valid struct device pointer, or NULL for ISA and EISA-like devices
886  * @sg: list of buffers
887  * @nents: number of buffers to map
888  * @dir: DMA transfer direction
889  *
890  * Map a set of buffers described by scatterlist in streaming mode for DMA.
891  * This is the scatter-gather version of the dma_map_single interface.
892  * Here the scatter gather list elements are each tagged with the
893  * appropriate dma address and length.  They are obtained via
894  * sg_dma_{address,length}.
895  *
896  * Device ownership issues as mentioned for dma_map_single are the same
897  * here.
898  */
899 int arm_dma_map_sg(struct device *dev, struct scatterlist *sg, int nents,
900                 enum dma_data_direction dir, struct dma_attrs *attrs)
901 {
902         struct dma_map_ops *ops = get_dma_ops(dev);
903         struct scatterlist *s;
904         int i, j;
905
906         for_each_sg(sg, s, nents, i) {
907 #ifdef CONFIG_NEED_SG_DMA_LENGTH
908                 s->dma_length = s->length;
909 #endif
910                 s->dma_address = ops->map_page(dev, sg_page(s), s->offset,
911                                                 s->length, dir, attrs);
912                 if (dma_mapping_error(dev, s->dma_address))
913                         goto bad_mapping;
914         }
915         return nents;
916
917  bad_mapping:
918         for_each_sg(sg, s, i, j)
919                 ops->unmap_page(dev, sg_dma_address(s), sg_dma_len(s), dir, attrs);
920         return 0;
921 }
922
923 /**
924  * arm_dma_unmap_sg - unmap a set of SG buffers mapped by dma_map_sg
925  * @dev: valid struct device pointer, or NULL for ISA and EISA-like devices
926  * @sg: list of buffers
927  * @nents: number of buffers to unmap (same as was passed to dma_map_sg)
928  * @dir: DMA transfer direction (same as was passed to dma_map_sg)
929  *
930  * Unmap a set of streaming mode DMA translations.  Again, CPU access
931  * rules concerning calls here are the same as for dma_unmap_single().
932  */
933 void arm_dma_unmap_sg(struct device *dev, struct scatterlist *sg, int nents,
934                 enum dma_data_direction dir, struct dma_attrs *attrs)
935 {
936         struct dma_map_ops *ops = get_dma_ops(dev);
937         struct scatterlist *s;
938
939         int i;
940
941         for_each_sg(sg, s, nents, i)
942                 ops->unmap_page(dev, sg_dma_address(s), sg_dma_len(s), dir, attrs);
943 }
944
945 /**
946  * arm_dma_sync_sg_for_cpu
947  * @dev: valid struct device pointer, or NULL for ISA and EISA-like devices
948  * @sg: list of buffers
949  * @nents: number of buffers to map (returned from dma_map_sg)
950  * @dir: DMA transfer direction (same as was passed to dma_map_sg)
951  */
952 void arm_dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg,
953                         int nents, enum dma_data_direction dir)
954 {
955         struct dma_map_ops *ops = get_dma_ops(dev);
956         struct scatterlist *s;
957         int i;
958
959         for_each_sg(sg, s, nents, i)
960                 ops->sync_single_for_cpu(dev, sg_dma_address(s), s->length,
961                                          dir);
962 }
963
964 /**
965  * arm_dma_sync_sg_for_device
966  * @dev: valid struct device pointer, or NULL for ISA and EISA-like devices
967  * @sg: list of buffers
968  * @nents: number of buffers to map (returned from dma_map_sg)
969  * @dir: DMA transfer direction (same as was passed to dma_map_sg)
970  */
971 void arm_dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg,
972                         int nents, enum dma_data_direction dir)
973 {
974         struct dma_map_ops *ops = get_dma_ops(dev);
975         struct scatterlist *s;
976         int i;
977
978         for_each_sg(sg, s, nents, i)
979                 ops->sync_single_for_device(dev, sg_dma_address(s), s->length,
980                                             dir);
981 }
982
983 /*
984  * Return whether the given device DMA address mask can be supported
985  * properly.  For example, if your device can only drive the low 24-bits
986  * during bus mastering, then you would pass 0x00ffffff as the mask
987  * to this function.
988  */
989 int dma_supported(struct device *dev, u64 mask)
990 {
991         if (mask < (u64)arm_dma_limit)
992                 return 0;
993         return 1;
994 }
995 EXPORT_SYMBOL(dma_supported);
996
997 int arm_dma_set_mask(struct device *dev, u64 dma_mask)
998 {
999         if (!dev->dma_mask || !dma_supported(dev, dma_mask))
1000                 return -EIO;
1001
1002         *dev->dma_mask = dma_mask;
1003
1004         return 0;
1005 }
1006
1007 #if defined(CONFIG_ARM_DMA_USE_IOMMU)
1008
1009 static LIST_HEAD(iommu_mapping_list);
1010 static DEFINE_SPINLOCK(iommu_mapping_list_lock);
1011
1012 #if defined(CONFIG_DEBUG_FS)
1013 static dma_addr_t bit_to_addr(size_t pos, dma_addr_t base, size_t order)
1014 {
1015         return base + pos * (1 << (PAGE_SHIFT + order));
1016 }
1017
1018 static void seq_print_dma_areas(struct seq_file *s, void *bitmap,
1019                                 dma_addr_t base, size_t bits, size_t order)
1020 {
1021         /* one bit = one (page + order) sized block */
1022         size_t pos = find_first_bit(bitmap, bits), end;
1023
1024         for (; pos < bits; pos = find_next_bit(bitmap, bits, end + 1)) {
1025                 dma_addr_t start_addr, end_addr;
1026
1027                 end = find_next_zero_bit(bitmap, bits, pos);
1028                 start_addr = bit_to_addr(pos, base, order);
1029                 end_addr = bit_to_addr(end, base, order) - 1;
1030                 seq_printf(s, "    %pa-%pa pages=%zu\n",
1031                            &start_addr, &end_addr, (end - pos) << order);
1032         }
1033 }
1034
1035 static void seq_print_mapping(struct seq_file *s,
1036                               struct dma_iommu_mapping *mapping)
1037 {
1038         seq_printf(s, "  memory map: base=%pa size=%lld order=%d domain=%p\n",
1039                    &mapping->base, (u64)(mapping->end - mapping->base),
1040                    mapping->order, mapping->domain);
1041
1042         seq_print_dma_areas(s, mapping->bitmap, mapping->base, mapping->bits,
1043                             mapping->order);
1044 }
1045
1046 static void debug_dma_seq_print_mappings(struct seq_file *s)
1047 {
1048         struct dma_iommu_mapping *mapping;
1049         int i = 0;
1050
1051         list_for_each_entry(mapping, &iommu_mapping_list, list) {
1052                 seq_printf(s, "Map %d (%p):\n", i, mapping);
1053                 seq_print_mapping(s, mapping);
1054                 i++;
1055         }
1056 }
1057
1058 static int dump_iommu_mappings(struct seq_file *s, void *data)
1059 {
1060         debug_dma_seq_print_mappings(s);
1061         return 0;
1062 }
1063
1064 static int dump_iommu_mappings_open(struct inode *inode, struct file *file)
1065 {
1066         return single_open(file, dump_iommu_mappings, NULL);
1067 }
1068
1069 static const struct file_operations dump_iommu_mappings_fops = {
1070         .open           = dump_iommu_mappings_open,
1071         .read           = seq_read,
1072         .llseek         = seq_lseek,
1073         .release        = single_release,
1074 };
1075
1076 #endif /* CONFIG_DEBUG_FS */
1077
1078 void dma_debugfs_platform_info(struct dentry *dent)
1079 {
1080         debugfs_create_file("dump_mappings", S_IRUGO, dent, NULL,
1081                             &dump_iommu_mappings_fops);
1082 }
1083
1084 #else /* !CONFIG_ARM_DMA_USE_IOMMU */
1085 static inline void dma_debugfs_platform_info(struct dentry *dent)
1086 {
1087 }
1088 #endif /* !CONFIG_ARM_DMA_USE_IOMMU */
1089
1090 #if defined(CONFIG_DMA_API_DEBUG)
1091 static inline void dma_debug_platform(void)
1092 {
1093 }
1094 #else /* !CONFIG_DMA_API_DEBUG */
1095 static void dma_debug_platform(void)
1096 {
1097         struct dentry *dent;
1098
1099         dent = debugfs_create_dir("dma-api", NULL);
1100         if (dent)
1101                 dma_debugfs_platform_info(dent);
1102 }
1103 #endif /* !CONFIG_DMA_API_DEBUG */
1104
1105 #define PREALLOC_DMA_DEBUG_ENTRIES      4096
1106
1107 static int __init dma_debug_do_init(void)
1108 {
1109         dma_debug_init(PREALLOC_DMA_DEBUG_ENTRIES);
1110         dma_debug_platform();
1111         return 0;
1112 }
1113 fs_initcall(dma_debug_do_init);
1114
1115 char *__weak debug_dma_platformdata(struct device *dev)
1116 {
1117         /* empty string by default */
1118         static char buf[1];
1119
1120         return buf;
1121 }
1122
1123 #ifdef CONFIG_ARM_DMA_USE_IOMMU
1124
1125 /* IOMMU */
1126
1127 static unsigned int prefetch_page_count = 1;
1128 static unsigned int gap_page_count = 1;
1129
1130 #define PF_PAGES_SIZE (prefetch_page_count << PAGE_SHIFT)
1131 #define PG_PAGES (prefetch_page_count + gap_page_count)
1132
1133 static struct page *iova_gap_pages;
1134 static phys_addr_t iova_gap_phys;
1135
1136 static int __init iova_gap_pages_init(void)
1137 {
1138         unsigned long order = get_order(PF_PAGES_SIZE);
1139
1140         iova_gap_pages = alloc_pages(GFP_KERNEL, order);
1141         if (WARN_ON(!iova_gap_pages)) {
1142                 prefetch_page_count = 0;
1143                 return 0;
1144         }
1145
1146         __dma_clear_buffer(iova_gap_pages, PAGE_SIZE << order);
1147         iova_gap_phys = page_to_phys(iova_gap_pages);
1148         return 0;
1149 }
1150 core_initcall(iova_gap_pages_init);
1151
1152 static void iommu_mapping_list_add(struct dma_iommu_mapping *mapping)
1153 {
1154         unsigned long flags;
1155
1156         spin_lock_irqsave(&iommu_mapping_list_lock, flags);
1157         list_add_tail(&mapping->list, &iommu_mapping_list);
1158         spin_unlock_irqrestore(&iommu_mapping_list_lock, flags);
1159 }
1160
1161 static void iommu_mapping_list_del(struct dma_iommu_mapping *mapping)
1162 {
1163         unsigned long flags;
1164
1165         spin_lock_irqsave(&iommu_mapping_list_lock, flags);
1166         list_del(&mapping->list);
1167         spin_unlock_irqrestore(&iommu_mapping_list_lock, flags);
1168 }
1169
1170 static inline int iommu_get_num_pf_pages(struct dma_iommu_mapping *mapping,
1171                                          struct dma_attrs *attrs)
1172 {
1173         int count = 0;
1174
1175         /* XXX: give priority to DMA_ATTR_SKIP_IOVA_GAP */
1176         if (dma_get_attr(DMA_ATTR_SKIP_IOVA_GAP, attrs))
1177                         return 0;
1178
1179         /* XXX: currently we support only 1 prefetch page */
1180         WARN_ON(mapping->num_pf_page > prefetch_page_count);
1181
1182         count += mapping->num_pf_page;
1183         count += mapping->gap_page ? gap_page_count : 0;
1184         return count;
1185 }
1186
1187 static int pg_iommu_map(struct dma_iommu_mapping *mapping, unsigned long iova,
1188                         phys_addr_t phys, size_t len, int prot)
1189 {
1190         int err;
1191         struct iommu_domain *domain = mapping->domain;
1192         struct dma_attrs *attrs = (struct dma_attrs *)prot;
1193         bool need_prefetch_page = !!iommu_get_num_pf_pages(mapping, attrs);
1194
1195         if (need_prefetch_page) {
1196                 err = iommu_map(domain, iova + len, iova_gap_phys,
1197                                 PF_PAGES_SIZE, prot);
1198                 if (err)
1199                         return err;
1200         }
1201
1202         err = iommu_map(domain, iova, phys, len, prot);
1203         if (err && need_prefetch_page)
1204                 iommu_unmap(domain, iova + len, PF_PAGES_SIZE);
1205
1206         return err;
1207 }
1208
1209 static size_t pg_iommu_unmap(struct dma_iommu_mapping *mapping,
1210                              unsigned long iova, size_t len, int prot)
1211 {
1212         struct dma_attrs *attrs = (struct dma_attrs *)prot;
1213         struct iommu_domain *domain = mapping->domain;
1214         bool need_prefetch_page = !!iommu_get_num_pf_pages(mapping, attrs);
1215
1216         if (need_prefetch_page) {
1217                 phys_addr_t phys_addr;
1218
1219                 phys_addr = iommu_iova_to_phys(domain, iova + len);
1220                 BUG_ON(phys_addr != iova_gap_phys);
1221                 iommu_unmap(domain, iova + len, PF_PAGES_SIZE);
1222         }
1223
1224         return iommu_unmap(domain, iova, len);
1225 }
1226
1227 static int pg_iommu_map_pages(struct dma_iommu_mapping *mapping,
1228                               unsigned long iova, struct page **pages,
1229                               size_t count, int prot)
1230 {
1231         int err;
1232         struct dma_attrs *attrs = (struct dma_attrs *)prot;
1233         struct iommu_domain *domain = mapping->domain;
1234         bool need_prefetch_page = !!iommu_get_num_pf_pages(mapping, attrs);
1235
1236         if (need_prefetch_page) {
1237                 err = iommu_map(domain, iova + (count << PAGE_SHIFT),
1238                                 iova_gap_phys, PF_PAGES_SIZE, prot);
1239                 if (err)
1240                         return err;
1241         }
1242
1243         err = iommu_map_pages(domain, iova, pages, count, prot);
1244         if (err && need_prefetch_page)
1245                 iommu_unmap(domain, iova + (count << PAGE_SHIFT), PF_PAGES_SIZE);
1246
1247         return err;
1248 }
1249
1250 static int pg_iommu_map_sg(struct dma_iommu_mapping *mapping,
1251                            unsigned long iova, struct scatterlist *sgl,
1252                            int nents, int prot)
1253 {
1254         int err;
1255         struct dma_attrs *attrs = (struct dma_attrs *)prot;
1256         struct iommu_domain *domain = mapping->domain;
1257         bool need_prefetch_page = !!iommu_get_num_pf_pages(mapping, attrs);
1258
1259         if (need_prefetch_page) {
1260                 err = iommu_map(domain, iova + (nents << PAGE_SHIFT),
1261                                 iova_gap_phys, PF_PAGES_SIZE, prot);
1262                 if (err)
1263                         return err;
1264         }
1265
1266         err = iommu_map_sg(domain, iova, sgl, nents, prot);
1267         if (err && need_prefetch_page)
1268                 iommu_unmap(domain, iova + (nents << PAGE_SHIFT), PF_PAGES_SIZE);
1269
1270         return err;
1271 }
1272
1273 static size_t arm_iommu_iova_get_free_total(struct device *dev)
1274 {
1275         struct dma_iommu_mapping *mapping = dev->archdata.mapping;
1276         unsigned long flags;
1277         size_t size = 0;
1278         unsigned long start = 0;
1279
1280         BUG_ON(!dev);
1281         BUG_ON(!mapping);
1282
1283         spin_lock_irqsave(&mapping->lock, flags);
1284         while (1) {
1285                 unsigned long end;
1286
1287                 start = bitmap_find_next_zero_area(mapping->bitmap,
1288                                                    mapping->bits, start, 1, 0);
1289                 if (start > mapping->bits)
1290                         break;
1291
1292                 end = find_next_bit(mapping->bitmap, mapping->bits, start);
1293                 size += end - start;
1294                 start = end;
1295         }
1296         spin_unlock_irqrestore(&mapping->lock, flags);
1297         return size << (mapping->order + PAGE_SHIFT);
1298 }
1299
1300 static size_t arm_iommu_iova_get_free_max(struct device *dev)
1301 {
1302         struct dma_iommu_mapping *mapping = dev->archdata.mapping;
1303         unsigned long flags;
1304         size_t max_free = 0;
1305         unsigned long start = 0;
1306
1307         spin_lock_irqsave(&mapping->lock, flags);
1308         while (1) {
1309                 unsigned long end;
1310
1311                 start = bitmap_find_next_zero_area(mapping->bitmap,
1312                                                    mapping->bits, start, 1, 0);
1313                 if (start > mapping->bits)
1314                         break;
1315
1316                 end = find_next_bit(mapping->bitmap, mapping->bits, start);
1317                 max_free = max_t(size_t, max_free, end - start);
1318                 start = end;
1319         }
1320         spin_unlock_irqrestore(&mapping->lock, flags);
1321         return max_free << (mapping->order + PAGE_SHIFT);
1322 }
1323
1324 static inline dma_addr_t __alloc_iova(struct dma_iommu_mapping *mapping,
1325                                       size_t size, struct dma_attrs *attrs)
1326 {
1327         unsigned int order = get_order(size);
1328         unsigned int align = 0;
1329         unsigned int count, start;
1330         unsigned long flags;
1331
1332         if (order > CONFIG_ARM_DMA_IOMMU_ALIGNMENT)
1333                 order = CONFIG_ARM_DMA_IOMMU_ALIGNMENT;
1334
1335         count = ((PAGE_ALIGN(size) >> PAGE_SHIFT) +
1336                  (1 << mapping->order) - 1) >> mapping->order;
1337
1338         count += iommu_get_num_pf_pages(mapping, attrs);
1339
1340         if (order > mapping->order)
1341                 align = (1 << (order - mapping->order)) - 1;
1342
1343         spin_lock_irqsave(&mapping->lock, flags);
1344         start = bitmap_find_next_zero_area(mapping->bitmap, mapping->bits, 0,
1345                                            count, align);
1346         if (start > mapping->bits) {
1347                 spin_unlock_irqrestore(&mapping->lock, flags);
1348                 return DMA_ERROR_CODE;
1349         }
1350
1351         bitmap_set(mapping->bitmap, start, count);
1352         spin_unlock_irqrestore(&mapping->lock, flags);
1353
1354         return mapping->base + (start << (mapping->order + PAGE_SHIFT));
1355 }
1356
1357 static dma_addr_t __alloc_iova_at(struct dma_iommu_mapping *mapping,
1358                                   dma_addr_t *iova, size_t size,
1359                                   struct dma_attrs *attrs)
1360 {
1361         unsigned int count, start, orig;
1362         unsigned long flags;
1363         size_t bytes;
1364
1365         count = ((PAGE_ALIGN(size) >> PAGE_SHIFT) +
1366                  (1 << mapping->order) - 1) >> mapping->order;
1367
1368         count += iommu_get_num_pf_pages(mapping, attrs);
1369
1370         bytes = count << (mapping->order + PAGE_SHIFT);
1371
1372         spin_lock_irqsave(&mapping->lock, flags);
1373
1374         if ((*iova < mapping->base) || (bytes > mapping->end - *iova)) {
1375                 *iova = -ENXIO;
1376                 goto err_out;
1377         }
1378
1379         orig = (*iova - mapping->base) >> (mapping->order + PAGE_SHIFT);
1380         start = bitmap_find_next_zero_area(mapping->bitmap, mapping->bits,
1381                                            orig, count, 0);
1382
1383         if ((start > mapping->bits) || (orig != start)) {
1384                 *iova = -EINVAL;
1385                 goto err_out;
1386         }
1387
1388         bitmap_set(mapping->bitmap, start, count);
1389         spin_unlock_irqrestore(&mapping->lock, flags);
1390
1391         return mapping->base + (start << (mapping->order + PAGE_SHIFT));
1392
1393 err_out:
1394         spin_unlock_irqrestore(&mapping->lock, flags);
1395         return DMA_ERROR_CODE;
1396 }
1397
1398 static dma_addr_t arm_iommu_iova_alloc_at(struct device *dev, dma_addr_t *iova,
1399                                           size_t size, struct dma_attrs *attrs)
1400 {
1401         struct dma_iommu_mapping *mapping = dev->archdata.mapping;
1402
1403         return __alloc_iova_at(mapping, iova, size, attrs);
1404 }
1405
1406 static dma_addr_t arm_iommu_iova_alloc(struct device *dev, size_t size,
1407                                        struct dma_attrs *attrs)
1408 {
1409         struct dma_iommu_mapping *mapping = dev->archdata.mapping;
1410
1411         return __alloc_iova(mapping, size, attrs);
1412 }
1413
1414 static inline void __free_iova(struct dma_iommu_mapping *mapping,
1415                                dma_addr_t addr, size_t size,
1416                                struct dma_attrs *attrs)
1417 {
1418         unsigned int start = (addr - mapping->base) >>
1419                              (mapping->order + PAGE_SHIFT);
1420         unsigned int count = ((size >> PAGE_SHIFT) +
1421                               (1 << mapping->order) - 1) >> mapping->order;
1422         unsigned long flags;
1423
1424         count += iommu_get_num_pf_pages(mapping, attrs);
1425
1426         spin_lock_irqsave(&mapping->lock, flags);
1427         bitmap_clear(mapping->bitmap, start, count);
1428         spin_unlock_irqrestore(&mapping->lock, flags);
1429 }
1430
1431 static void arm_iommu_iova_free(struct device *dev, dma_addr_t addr,
1432                                 size_t size, struct dma_attrs *attrs)
1433 {
1434         struct dma_iommu_mapping *mapping = dev->archdata.mapping;
1435
1436         __free_iova(mapping, addr, size, attrs);
1437 }
1438
1439 static struct page **__iommu_alloc_buffer(struct device *dev, size_t size,
1440                                           gfp_t gfp, struct dma_attrs *attrs)
1441 {
1442         struct page **pages;
1443         int count = size >> PAGE_SHIFT;
1444         int array_size = count * sizeof(struct page *);
1445         int i = 0;
1446
1447         if (array_size <= PAGE_SIZE)
1448                 pages = kzalloc(array_size,
1449                                 gfp & ~(__GFP_HIGHMEM | __GFP_DMA32));
1450         else
1451                 pages = vzalloc(array_size);
1452         if (!pages)
1453                 return NULL;
1454
1455         if (dma_get_attr(DMA_ATTR_FORCE_CONTIGUOUS, attrs))
1456         {
1457                 unsigned long order = get_order(size);
1458                 struct page *page;
1459
1460                 page = dma_alloc_from_contiguous(dev, count, order);
1461                 if (!page)
1462                         goto error;
1463
1464                 __dma_clear_buffer(page, size);
1465
1466                 for (i = 0; i < count; i++)
1467                         pages[i] = page + i;
1468
1469                 return pages;
1470         }
1471
1472         /*
1473          * IOMMU can map any pages, so himem can also be used here
1474          * unless some DMA'able area is explicitly required.
1475          */
1476         if (!(gfp & GFP_DMA) && !(gfp & GFP_DMA32))
1477                 gfp |= __GFP_HIGHMEM;
1478
1479         gfp |= __GFP_NOWARN;
1480         while (count) {
1481                 int j, order = __fls(count);
1482
1483                 pages[i] = alloc_pages(gfp, order);
1484                 while (!pages[i] && order)
1485                         pages[i] = alloc_pages(gfp, --order);
1486                 if (!pages[i])
1487                         goto error;
1488
1489                 if (order) {
1490                         split_page(pages[i], order);
1491                         j = 1 << order;
1492                         while (--j)
1493                                 pages[i + j] = pages[i] + j;
1494                 }
1495
1496                 __dma_clear_buffer(pages[i], PAGE_SIZE << order);
1497                 i += 1 << order;
1498                 count -= 1 << order;
1499         }
1500
1501         return pages;
1502 error:
1503         while (i--)
1504                 if (pages[i])
1505                         __free_pages(pages[i], 0);
1506         if (array_size <= PAGE_SIZE)
1507                 kfree(pages);
1508         else
1509                 vfree(pages);
1510         return NULL;
1511 }
1512
1513 static int __iommu_free_buffer(struct device *dev, struct page **pages,
1514                                size_t size, struct dma_attrs *attrs)
1515 {
1516         int count = size >> PAGE_SHIFT;
1517         int array_size = count * sizeof(struct page *);
1518         int i;
1519
1520         if (dma_get_attr(DMA_ATTR_FORCE_CONTIGUOUS, attrs)) {
1521                 dma_release_from_contiguous(dev, pages[0], count);
1522         } else {
1523                 for (i = 0; i < count; i++)
1524                         if (pages[i])
1525                                 __free_pages(pages[i], 0);
1526         }
1527
1528         if (array_size <= PAGE_SIZE)
1529                 kfree(pages);
1530         else
1531                 vfree(pages);
1532         return 0;
1533 }
1534
1535 /*
1536  * Create a CPU mapping for a specified pages
1537  */
1538 static void *
1539 __iommu_alloc_remap(struct page **pages, size_t size, gfp_t gfp, pgprot_t prot,
1540                     const void *caller)
1541 {
1542         unsigned int i, nr_pages = PAGE_ALIGN(size) >> PAGE_SHIFT;
1543         struct vm_struct *area;
1544         unsigned long p;
1545
1546         area = get_vm_area_caller(size, VM_ARM_DMA_CONSISTENT | VM_USERMAP,
1547                                   caller);
1548         if (!area)
1549                 return NULL;
1550
1551         area->pages = pages;
1552         area->nr_pages = nr_pages;
1553         p = (unsigned long)area->addr;
1554
1555         for (i = 0; i < nr_pages; i++) {
1556                 phys_addr_t phys = __pfn_to_phys(page_to_pfn(pages[i]));
1557                 if (ioremap_page_range(p, p + PAGE_SIZE, phys, prot))
1558                         goto err;
1559                 p += PAGE_SIZE;
1560         }
1561         return area->addr;
1562 err:
1563         unmap_kernel_range((unsigned long)area->addr, size);
1564         vunmap(area->addr);
1565         return NULL;
1566 }
1567
1568 /*
1569  * Create a mapping in device IO address space for specified pages
1570  */
1571 static dma_addr_t
1572 ____iommu_create_mapping(struct device *dev, dma_addr_t *req,
1573                          struct page **pages, size_t size,
1574                          struct dma_attrs *attrs)
1575 {
1576         struct dma_iommu_mapping *mapping = dev->archdata.mapping;
1577         unsigned int count = PAGE_ALIGN(size) >> PAGE_SHIFT;
1578         dma_addr_t dma_addr, iova;
1579         int i, ret = DMA_ERROR_CODE;
1580
1581         if (req)
1582                 dma_addr = __alloc_iova_at(mapping, req, size, attrs);
1583         else
1584                 dma_addr = __alloc_iova(mapping, size, attrs);
1585
1586         if (dma_addr == DMA_ERROR_CODE)
1587                 return dma_addr;
1588
1589         iova = dma_addr;
1590         for (i = 0; i < count; ) {
1591                 unsigned int next_pfn = page_to_pfn(pages[i]) + 1;
1592                 phys_addr_t phys = page_to_phys(pages[i]);
1593                 unsigned int len, j;
1594
1595                 for (j = i + 1; j < count; j++, next_pfn++)
1596                         if (page_to_pfn(pages[j]) != next_pfn)
1597                                 break;
1598
1599                 len = (j - i) << PAGE_SHIFT;
1600                 ret = pg_iommu_map(mapping, iova, phys, len, (int)attrs);
1601                 if (ret < 0)
1602                         goto fail;
1603                 iova += len;
1604                 i = j;
1605         }
1606         return dma_addr;
1607 fail:
1608         pg_iommu_unmap(mapping, dma_addr, iova-dma_addr, (int)attrs);
1609         __free_iova(mapping, dma_addr, size, attrs);
1610         return DMA_ERROR_CODE;
1611 }
1612
1613 static dma_addr_t
1614 __iommu_create_mapping(struct device *dev, struct page **pages, size_t size,
1615                        struct dma_attrs *attrs)
1616 {
1617         return ____iommu_create_mapping(dev, NULL, pages, size, attrs);
1618 }
1619
1620 static int __iommu_remove_mapping(struct device *dev, dma_addr_t iova,
1621                                   size_t size, struct dma_attrs *attrs)
1622 {
1623         struct dma_iommu_mapping *mapping = dev->archdata.mapping;
1624
1625         /*
1626          * add optional in-page offset from iova to size and align
1627          * result to page size
1628          */
1629         size = PAGE_ALIGN((iova & ~PAGE_MASK) + size);
1630         iova &= PAGE_MASK;
1631
1632         pg_iommu_unmap(mapping, iova, size, (int)attrs);
1633         __free_iova(mapping, iova, size, attrs);
1634         return 0;
1635 }
1636
1637 static struct page **__atomic_get_pages(void *addr)
1638 {
1639         struct dma_pool *pool = &atomic_pool;
1640         struct page **pages = pool->pages;
1641         int offs = (addr - pool->vaddr) >> PAGE_SHIFT;
1642
1643         return pages + offs;
1644 }
1645
1646 static struct page **__iommu_get_pages(void *cpu_addr, struct dma_attrs *attrs)
1647 {
1648         struct vm_struct *area;
1649
1650         if (__in_atomic_pool(cpu_addr, PAGE_SIZE))
1651                 return __atomic_get_pages(cpu_addr);
1652
1653         if (dma_get_attr(DMA_ATTR_NO_KERNEL_MAPPING, attrs))
1654                 return cpu_addr;
1655
1656         area = find_vm_area(cpu_addr);
1657         if (area && (area->flags & VM_ARM_DMA_CONSISTENT))
1658                 return area->pages;
1659         return NULL;
1660 }
1661
1662 static void *__iommu_alloc_atomic(struct device *dev, size_t size,
1663                                   dma_addr_t *handle, struct dma_attrs *attrs)
1664 {
1665         struct page *page;
1666         void *addr;
1667
1668         addr = __alloc_from_pool(size, &page);
1669         if (!addr)
1670                 return NULL;
1671
1672         *handle = __iommu_create_mapping(dev, &page, size, attrs);
1673         if (*handle == DMA_ERROR_CODE)
1674                 goto err_mapping;
1675
1676         dev_dbg(dev, "%s() %pa(%x)\n", __func__, handle, size);
1677         return addr;
1678
1679 err_mapping:
1680         __free_from_pool(addr, size);
1681         return NULL;
1682 }
1683
1684 static void __iommu_free_atomic(struct device *dev, void *cpu_addr,
1685                                 dma_addr_t handle, size_t size,
1686                                 struct dma_attrs *attrs)
1687 {
1688         __iommu_remove_mapping(dev, handle, size, attrs);
1689         __free_from_pool(cpu_addr, size);
1690         dev_dbg(dev, "%s() %pa(%x)\n", __func__, &handle, size);
1691 }
1692
1693 static void *arm_iommu_alloc_attrs(struct device *dev, size_t size,
1694             dma_addr_t *handle, gfp_t gfp, struct dma_attrs *attrs)
1695 {
1696         pgprot_t prot = __get_dma_pgprot(attrs, pgprot_kernel);
1697         struct page **pages;
1698         void *addr = NULL;
1699
1700         /* Following is a work-around (a.k.a. hack) to prevent pages
1701          * with __GFP_COMP being passed to split_page() which cannot
1702          * handle them.  The real problem is that this flag probably
1703          * should be 0 on ARM as it is not supported on this
1704          * platform--see CONFIG_HUGETLB_PAGE. */
1705         gfp &= ~(__GFP_COMP);
1706
1707         size = PAGE_ALIGN(size);
1708
1709         if (!(gfp & __GFP_WAIT)) {
1710                 addr = __iommu_alloc_atomic(dev, size, handle, attrs);
1711                 trace_dmadebug_alloc_attrs(dev, *handle, size, NULL, addr);
1712                 return addr;
1713         }
1714
1715         pages = __iommu_alloc_buffer(dev, size, gfp, attrs);
1716         if (!pages)
1717                 return NULL;
1718
1719         if (*handle == DMA_ERROR_CODE)
1720                 *handle = __iommu_create_mapping(dev, pages, size, attrs);
1721         else
1722                 *handle = ____iommu_create_mapping(dev, handle, pages, size,
1723                                                    attrs);
1724
1725         if (*handle == DMA_ERROR_CODE)
1726                 goto err_buffer;
1727
1728         if (dma_get_attr(DMA_ATTR_NO_KERNEL_MAPPING, attrs))
1729                 return pages;
1730
1731         addr = __iommu_alloc_remap(pages, size, gfp, prot,
1732                                    __builtin_return_address(0));
1733         if (!addr)
1734                 goto err_mapping;
1735
1736         trace_dmadebug_alloc_attrs(dev, *handle, size, pages, addr);
1737         return addr;
1738
1739 err_mapping:
1740         __iommu_remove_mapping(dev, *handle, size, attrs);
1741 err_buffer:
1742         __iommu_free_buffer(dev, pages, size, attrs);
1743         return NULL;
1744 }
1745
1746 static int arm_iommu_mmap_attrs(struct device *dev, struct vm_area_struct *vma,
1747                     void *cpu_addr, dma_addr_t dma_addr, size_t size,
1748                     struct dma_attrs *attrs)
1749 {
1750         unsigned long uaddr = vma->vm_start;
1751         unsigned long usize = vma->vm_end - vma->vm_start;
1752         struct page **pages = __iommu_get_pages(cpu_addr, attrs);
1753
1754         vma->vm_page_prot = __get_dma_pgprot(attrs, vma->vm_page_prot);
1755
1756         if (!pages)
1757                 return -ENXIO;
1758
1759         do {
1760                 int ret = vm_insert_page(vma, uaddr, *pages++);
1761                 if (ret) {
1762                         pr_err("Remapping memory failed: %d\n", ret);
1763                         return ret;
1764                 }
1765                 uaddr += PAGE_SIZE;
1766                 usize -= PAGE_SIZE;
1767         } while (usize > 0);
1768
1769         return 0;
1770 }
1771
1772 /*
1773  * free a page as defined by the above mapping.
1774  * Must not be called with IRQs disabled.
1775  */
1776 void arm_iommu_free_attrs(struct device *dev, size_t size, void *cpu_addr,
1777                           dma_addr_t handle, struct dma_attrs *attrs)
1778 {
1779         struct page **pages = __iommu_get_pages(cpu_addr, attrs);
1780         size = PAGE_ALIGN(size);
1781
1782         if (!pages) {
1783                 WARN(1, "trying to free invalid coherent area: %p\n", cpu_addr);
1784                 return;
1785         }
1786
1787         if (__in_atomic_pool(cpu_addr, size)) {
1788                 trace_dmadebug_free_attrs(dev, handle, size, NULL, cpu_addr);
1789                 __iommu_free_atomic(dev, cpu_addr, handle, size, attrs);
1790                 return;
1791         }
1792
1793         if (!dma_get_attr(DMA_ATTR_NO_KERNEL_MAPPING, attrs)) {
1794                 unmap_kernel_range((unsigned long)cpu_addr, size);
1795                 vunmap(cpu_addr);
1796         }
1797
1798         trace_dmadebug_free_attrs(dev, handle, size, pages, cpu_addr);
1799         __iommu_remove_mapping(dev, handle, size, attrs);
1800         __iommu_free_buffer(dev, pages, size, attrs);
1801 }
1802
1803 static int arm_iommu_get_sgtable(struct device *dev, struct sg_table *sgt,
1804                                  void *cpu_addr, dma_addr_t dma_addr,
1805                                  size_t size, struct dma_attrs *attrs)
1806 {
1807         unsigned int count = PAGE_ALIGN(size) >> PAGE_SHIFT;
1808         struct page **pages = __iommu_get_pages(cpu_addr, attrs);
1809
1810         if (!pages)
1811                 return -ENXIO;
1812
1813         return sg_alloc_table_from_pages(sgt, pages, count, 0, size,
1814                                          GFP_KERNEL);
1815 }
1816
1817 /*
1818  * Map a part of the scatter-gather list into contiguous io address space
1819  */
1820 static int __map_sg_chunk(struct device *dev, struct scatterlist *sg,
1821                           size_t size, dma_addr_t *handle,
1822                           enum dma_data_direction dir, struct dma_attrs *attrs,
1823                           bool is_coherent)
1824 {
1825         struct dma_iommu_mapping *mapping = dev->archdata.mapping;
1826         dma_addr_t iova, iova_base;
1827         int ret = 0;
1828         unsigned int count;
1829         struct scatterlist *s;
1830
1831         size = PAGE_ALIGN(size);
1832         *handle = DMA_ERROR_CODE;
1833
1834         iova_base = iova = __alloc_iova(mapping, size, attrs);
1835         if (iova == DMA_ERROR_CODE)
1836                 return -ENOMEM;
1837
1838         if (is_coherent || dma_get_attr(DMA_ATTR_SKIP_CPU_SYNC, attrs))
1839                 goto skip_cmaint;
1840
1841         for (count = 0, s = sg; count < (size >> PAGE_SHIFT); s = sg_next(s)) {
1842                 unsigned int len = PAGE_ALIGN(s->offset + s->length);
1843
1844                 __dma_page_cpu_to_dev(sg_page(s), s->offset, s->length, dir);
1845
1846                 count += len >> PAGE_SHIFT;
1847                 iova += len;
1848         }
1849
1850 skip_cmaint:
1851         count = size >> PAGE_SHIFT;
1852         ret = pg_iommu_map_sg(mapping, iova_base, sg, count, (int)attrs);
1853         if (WARN_ON(ret < 0))
1854                 goto fail;
1855
1856         *handle = iova_base;
1857
1858         return 0;
1859 fail:
1860         pg_iommu_unmap(mapping, iova_base, count * PAGE_SIZE, (int)attrs);
1861         __free_iova(mapping, iova_base, size, attrs);
1862         return ret;
1863 }
1864
1865 static int __iommu_map_sg(struct device *dev, struct scatterlist *sg, int nents,
1866                      enum dma_data_direction dir, struct dma_attrs *attrs,
1867                      bool is_coherent)
1868 {
1869         struct scatterlist *s = sg, *dma = sg, *start = sg;
1870         int i, count = 0;
1871         unsigned int offset = s->offset;
1872         unsigned int size = s->offset + s->length;
1873         unsigned int max = dma_get_max_seg_size(dev);
1874
1875         for (i = 1; i < nents; i++) {
1876                 s = sg_next(s);
1877
1878                 s->dma_address = DMA_ERROR_CODE;
1879                 s->dma_length = 0;
1880
1881                 if (s->offset || (size & ~PAGE_MASK) || size + s->length > max) {
1882                         if (__map_sg_chunk(dev, start, size, &dma->dma_address,
1883                             dir, attrs, is_coherent) < 0)
1884                                 goto bad_mapping;
1885
1886                         dma->dma_address += offset;
1887                         dma->dma_length = size - offset;
1888
1889                         size = offset = s->offset;
1890                         start = s;
1891                         dma = sg_next(dma);
1892                         count += 1;
1893                 }
1894                 size += s->length;
1895         }
1896         if (__map_sg_chunk(dev, start, size, &dma->dma_address, dir, attrs,
1897                 is_coherent) < 0)
1898                 goto bad_mapping;
1899
1900         dma->dma_address += offset;
1901         dma->dma_length = size - offset;
1902
1903         trace_dmadebug_map_sg(dev, dma->dma_address, dma->dma_length,
1904                               sg_page(sg));
1905         return count+1;
1906
1907 bad_mapping:
1908         for_each_sg(sg, s, count, i)
1909                 __iommu_remove_mapping(dev, sg_dma_address(s), sg_dma_len(s),
1910                         attrs);
1911         return 0;
1912 }
1913
1914 /**
1915  * arm_coherent_iommu_map_sg - map a set of SG buffers for streaming mode DMA
1916  * @dev: valid struct device pointer
1917  * @sg: list of buffers
1918  * @nents: number of buffers to map
1919  * @dir: DMA transfer direction
1920  *
1921  * Map a set of i/o coherent buffers described by scatterlist in streaming
1922  * mode for DMA. The scatter gather list elements are merged together (if
1923  * possible) and tagged with the appropriate dma address and length. They are
1924  * obtained via sg_dma_{address,length}.
1925  */
1926 int arm_coherent_iommu_map_sg(struct device *dev, struct scatterlist *sg,
1927                 int nents, enum dma_data_direction dir, struct dma_attrs *attrs)
1928 {
1929         return __iommu_map_sg(dev, sg, nents, dir, attrs, true);
1930 }
1931
1932 /**
1933  * arm_iommu_map_sg - map a set of SG buffers for streaming mode DMA
1934  * @dev: valid struct device pointer
1935  * @sg: list of buffers
1936  * @nents: number of buffers to map
1937  * @dir: DMA transfer direction
1938  *
1939  * Map a set of buffers described by scatterlist in streaming mode for DMA.
1940  * The scatter gather list elements are merged together (if possible) and
1941  * tagged with the appropriate dma address and length. They are obtained via
1942  * sg_dma_{address,length}.
1943  */
1944 int arm_iommu_map_sg(struct device *dev, struct scatterlist *sg,
1945                 int nents, enum dma_data_direction dir, struct dma_attrs *attrs)
1946 {
1947         return __iommu_map_sg(dev, sg, nents, dir, attrs, false);
1948 }
1949
1950 static void __iommu_unmap_sg(struct device *dev, struct scatterlist *sg,
1951                 int nents, enum dma_data_direction dir, struct dma_attrs *attrs,
1952                 bool is_coherent)
1953 {
1954         struct scatterlist *s;
1955         int i;
1956
1957         for_each_sg(sg, s, nents, i) {
1958                 if (sg_dma_len(s))
1959                         __iommu_remove_mapping(dev, sg_dma_address(s),
1960                                                sg_dma_len(s), attrs);
1961                 if (!is_coherent &&
1962                     !dma_get_attr(DMA_ATTR_SKIP_CPU_SYNC, attrs))
1963                         __dma_page_dev_to_cpu(sg_page(s), s->offset,
1964                                               s->length, dir);
1965         }
1966
1967         trace_dmadebug_unmap_sg(dev, sg_dma_address(sg), sg_dma_len(sg),
1968                                 sg_page(sg));
1969 }
1970
1971 /**
1972  * arm_coherent_iommu_unmap_sg - unmap a set of SG buffers mapped by dma_map_sg
1973  * @dev: valid struct device pointer
1974  * @sg: list of buffers
1975  * @nents: number of buffers to unmap (same as was passed to dma_map_sg)
1976  * @dir: DMA transfer direction (same as was passed to dma_map_sg)
1977  *
1978  * Unmap a set of streaming mode DMA translations.  Again, CPU access
1979  * rules concerning calls here are the same as for dma_unmap_single().
1980  */
1981 void arm_coherent_iommu_unmap_sg(struct device *dev, struct scatterlist *sg,
1982                 int nents, enum dma_data_direction dir, struct dma_attrs *attrs)
1983 {
1984         __iommu_unmap_sg(dev, sg, nents, dir, attrs, true);
1985 }
1986
1987 /**
1988  * arm_iommu_unmap_sg - unmap a set of SG buffers mapped by dma_map_sg
1989  * @dev: valid struct device pointer
1990  * @sg: list of buffers
1991  * @nents: number of buffers to unmap (same as was passed to dma_map_sg)
1992  * @dir: DMA transfer direction (same as was passed to dma_map_sg)
1993  *
1994  * Unmap a set of streaming mode DMA translations.  Again, CPU access
1995  * rules concerning calls here are the same as for dma_unmap_single().
1996  */
1997 void arm_iommu_unmap_sg(struct device *dev, struct scatterlist *sg, int nents,
1998                         enum dma_data_direction dir, struct dma_attrs *attrs)
1999 {
2000         __iommu_unmap_sg(dev, sg, nents, dir, attrs, false);
2001 }
2002
2003 /**
2004  * arm_iommu_sync_sg_for_cpu
2005  * @dev: valid struct device pointer
2006  * @sg: list of buffers
2007  * @nents: number of buffers to map (returned from dma_map_sg)
2008  * @dir: DMA transfer direction (same as was passed to dma_map_sg)
2009  */
2010 void arm_iommu_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg,
2011                         int nents, enum dma_data_direction dir)
2012 {
2013         struct scatterlist *s;
2014         int i;
2015
2016         for_each_sg(sg, s, nents, i)
2017                 __dma_page_dev_to_cpu(sg_page(s), s->offset, s->length, dir);
2018
2019 }
2020
2021 /**
2022  * arm_iommu_sync_sg_for_device
2023  * @dev: valid struct device pointer
2024  * @sg: list of buffers
2025  * @nents: number of buffers to map (returned from dma_map_sg)
2026  * @dir: DMA transfer direction (same as was passed to dma_map_sg)
2027  */
2028 void arm_iommu_sync_sg_for_device(struct device *dev, struct scatterlist *sg,
2029                         int nents, enum dma_data_direction dir)
2030 {
2031         struct scatterlist *s;
2032         int i;
2033
2034         for_each_sg(sg, s, nents, i)
2035                 __dma_page_cpu_to_dev(sg_page(s), s->offset, s->length, dir);
2036 }
2037
2038
2039 /**
2040  * arm_coherent_iommu_map_page
2041  * @dev: valid struct device pointer
2042  * @page: page that buffer resides in
2043  * @offset: offset into page for start of buffer
2044  * @size: size of buffer to map
2045  * @dir: DMA transfer direction
2046  *
2047  * Coherent IOMMU aware version of arm_dma_map_page()
2048  */
2049 static dma_addr_t arm_coherent_iommu_map_page(struct device *dev, struct page *page,
2050              unsigned long offset, size_t size, enum dma_data_direction dir,
2051              struct dma_attrs *attrs)
2052 {
2053         struct dma_iommu_mapping *mapping = dev->archdata.mapping;
2054         dma_addr_t dma_addr;
2055         int ret, len = PAGE_ALIGN(size + offset);
2056
2057         dma_addr = __alloc_iova(mapping, len, attrs);
2058         if (dma_addr == DMA_ERROR_CODE)
2059                 return dma_addr;
2060
2061         ret = pg_iommu_map(mapping, dma_addr,
2062                            page_to_phys(page), len, (int)attrs);
2063         if (ret < 0)
2064                 goto fail;
2065
2066         trace_dmadebug_map_page(dev, dma_addr + offset, size, page);
2067         return dma_addr + offset;
2068 fail:
2069         __free_iova(mapping, dma_addr, len, attrs);
2070         return DMA_ERROR_CODE;
2071 }
2072
2073 /**
2074  * arm_iommu_map_page
2075  * @dev: valid struct device pointer
2076  * @page: page that buffer resides in
2077  * @offset: offset into page for start of buffer
2078  * @size: size of buffer to map
2079  * @dir: DMA transfer direction
2080  *
2081  * IOMMU aware version of arm_dma_map_page()
2082  */
2083 static dma_addr_t arm_iommu_map_page(struct device *dev, struct page *page,
2084              unsigned long offset, size_t size, enum dma_data_direction dir,
2085              struct dma_attrs *attrs)
2086 {
2087         if (!dma_get_attr(DMA_ATTR_SKIP_CPU_SYNC, attrs))
2088                 __dma_page_cpu_to_dev(page, offset, size, dir);
2089
2090         return arm_coherent_iommu_map_page(dev, page, offset, size, dir, attrs);
2091 }
2092
2093 static dma_addr_t arm_iommu_map_page_at(struct device *dev, struct page *page,
2094                  dma_addr_t dma_addr, unsigned long offset, size_t size,
2095                  enum dma_data_direction dir, struct dma_attrs *attrs)
2096 {
2097         struct dma_iommu_mapping *mapping = dev->archdata.mapping;
2098         int ret, len = PAGE_ALIGN(size + offset);
2099
2100         if (!dma_get_attr(DMA_ATTR_SKIP_CPU_SYNC, attrs))
2101                 __dma_page_cpu_to_dev(page, offset, size, dir);
2102
2103         ret = pg_iommu_map(mapping, dma_addr,
2104                            page_to_phys(page), len, (int)attrs);
2105         if (ret < 0)
2106                 return DMA_ERROR_CODE;
2107
2108         trace_dmadebug_map_page(dev, dma_addr, size, page);
2109         return dma_addr + offset;
2110 }
2111
2112 static dma_addr_t arm_iommu_map_pages(struct device *dev, struct page **pages,
2113                                   dma_addr_t dma_handle, size_t count,
2114                                   enum dma_data_direction dir,
2115                                   struct dma_attrs *attrs)
2116 {
2117         struct dma_iommu_mapping *mapping = dev->archdata.mapping;
2118         int ret;
2119
2120         if (!dma_get_attr(DMA_ATTR_SKIP_CPU_SYNC, attrs)) {
2121                 int i;
2122
2123                 for (i = 0; i < count; i++)
2124                         __dma_page_cpu_to_dev(pages[i], 0, PAGE_SIZE, dir);
2125         }
2126
2127         ret = pg_iommu_map_pages(mapping, dma_handle, pages, count, (int)attrs);
2128         if (ret < 0)
2129                 return DMA_ERROR_CODE;
2130
2131         trace_dmadebug_map_page(dev, dma_handle, count * PAGE_SIZE, *pages);
2132         return dma_handle;
2133 }
2134
2135
2136 /**
2137  * arm_coherent_iommu_unmap_page
2138  * @dev: valid struct device pointer
2139  * @handle: DMA address of buffer
2140  * @size: size of buffer (same as passed to dma_map_page)
2141  * @dir: DMA transfer direction (same as passed to dma_map_page)
2142  *
2143  * Coherent IOMMU aware version of arm_dma_unmap_page()
2144  */
2145 static void arm_coherent_iommu_unmap_page(struct device *dev, dma_addr_t handle,
2146                 size_t size, enum dma_data_direction dir,
2147                 struct dma_attrs *attrs)
2148 {
2149         struct dma_iommu_mapping *mapping = dev->archdata.mapping;
2150         dma_addr_t iova = handle & PAGE_MASK;
2151         int offset = handle & ~PAGE_MASK;
2152         int len = PAGE_ALIGN(size + offset);
2153
2154         if (!iova)
2155                 return;
2156
2157         trace_dmadebug_unmap_page(dev, handle, size,
2158                   phys_to_page(iommu_iova_to_phys(mapping->domain, handle)));
2159         pg_iommu_unmap(mapping, iova, len, (int)attrs);
2160         if (!dma_get_attr(DMA_ATTR_SKIP_FREE_IOVA, attrs))
2161                 __free_iova(mapping, iova, len, attrs);
2162 }
2163
2164 /**
2165  * arm_iommu_unmap_page
2166  * @dev: valid struct device pointer
2167  * @handle: DMA address of buffer
2168  * @size: size of buffer (same as passed to dma_map_page)
2169  * @dir: DMA transfer direction (same as passed to dma_map_page)
2170  *
2171  * IOMMU aware version of arm_dma_unmap_page()
2172  */
2173 static void arm_iommu_unmap_page(struct device *dev, dma_addr_t handle,
2174                 size_t size, enum dma_data_direction dir,
2175                 struct dma_attrs *attrs)
2176 {
2177         struct dma_iommu_mapping *mapping = dev->archdata.mapping;
2178         dma_addr_t iova = handle & PAGE_MASK;
2179         struct page *page = phys_to_page(iommu_iova_to_phys(mapping->domain, iova));
2180         int offset = handle & ~PAGE_MASK;
2181         int len = PAGE_ALIGN(size + offset);
2182
2183         if (!iova)
2184                 return;
2185
2186         if (!dma_get_attr(DMA_ATTR_SKIP_CPU_SYNC, attrs))
2187                 __dma_page_dev_to_cpu(page, offset, size, dir);
2188
2189         trace_dmadebug_unmap_page(dev, handle, size,
2190                   phys_to_page(iommu_iova_to_phys(mapping->domain, handle)));
2191         pg_iommu_unmap(mapping, iova, len, (int)attrs);
2192         if (!dma_get_attr(DMA_ATTR_SKIP_FREE_IOVA, attrs))
2193                 __free_iova(mapping, iova, len, attrs);
2194 }
2195
2196 static void arm_iommu_sync_single_for_cpu(struct device *dev,
2197                 dma_addr_t handle, size_t size, enum dma_data_direction dir)
2198 {
2199         struct dma_iommu_mapping *mapping = dev->archdata.mapping;
2200         dma_addr_t iova = handle & PAGE_MASK;
2201         struct page *page = phys_to_page(iommu_iova_to_phys(mapping->domain, iova));
2202         unsigned int offset = handle & ~PAGE_MASK;
2203
2204         if (!iova)
2205                 return;
2206
2207         if (WARN_ON(!pfn_valid(page_to_pfn(page))))
2208                 return;
2209
2210         __dma_page_dev_to_cpu(page, offset, size, dir);
2211 }
2212
2213 static void arm_iommu_sync_single_for_device(struct device *dev,
2214                 dma_addr_t handle, size_t size, enum dma_data_direction dir)
2215 {
2216         struct dma_iommu_mapping *mapping = dev->archdata.mapping;
2217         dma_addr_t iova = handle & PAGE_MASK;
2218         struct page *page = phys_to_page(iommu_iova_to_phys(mapping->domain, iova));
2219         unsigned int offset = handle & ~PAGE_MASK;
2220
2221         if (!iova)
2222                 return;
2223
2224         if (WARN_ON(!pfn_valid(page_to_pfn(page))))
2225                 return;
2226
2227         __dma_page_cpu_to_dev(page, offset, size, dir);
2228 }
2229
2230 static phys_addr_t arm_iommu_iova_to_phys(struct device *dev, dma_addr_t iova)
2231 {
2232         struct dma_iommu_mapping *mapping = dev->archdata.mapping;
2233
2234         return iommu_iova_to_phys(mapping->domain, iova);
2235 }
2236
2237 struct dma_map_ops iommu_ops = {
2238         .alloc          = arm_iommu_alloc_attrs,
2239         .free           = arm_iommu_free_attrs,
2240         .mmap           = arm_iommu_mmap_attrs,
2241         .get_sgtable    = arm_iommu_get_sgtable,
2242
2243         .map_page               = arm_iommu_map_page,
2244         .map_pages              = arm_iommu_map_pages,
2245         .map_page_at            = arm_iommu_map_page_at,
2246         .unmap_page             = arm_iommu_unmap_page,
2247         .sync_single_for_cpu    = arm_iommu_sync_single_for_cpu,
2248         .sync_single_for_device = arm_iommu_sync_single_for_device,
2249
2250         .map_sg                 = arm_iommu_map_sg,
2251         .unmap_sg               = arm_iommu_unmap_sg,
2252         .sync_sg_for_cpu        = arm_iommu_sync_sg_for_cpu,
2253         .sync_sg_for_device     = arm_iommu_sync_sg_for_device,
2254
2255         .set_dma_mask           = arm_dma_set_mask,
2256
2257         .iova_alloc             = arm_iommu_iova_alloc,
2258         .iova_alloc_at          = arm_iommu_iova_alloc_at,
2259         .iova_free              = arm_iommu_iova_free,
2260         .iova_get_free_total    = arm_iommu_iova_get_free_total,
2261         .iova_get_free_max      = arm_iommu_iova_get_free_max,
2262
2263         .iova_to_phys           = arm_iommu_iova_to_phys,
2264 };
2265
2266 struct dma_map_ops iommu_coherent_ops = {
2267         .alloc          = arm_iommu_alloc_attrs,
2268         .free           = arm_iommu_free_attrs,
2269         .mmap           = arm_iommu_mmap_attrs,
2270         .get_sgtable    = arm_iommu_get_sgtable,
2271
2272         .map_page       = arm_coherent_iommu_map_page,
2273         .unmap_page     = arm_coherent_iommu_unmap_page,
2274
2275         .map_sg         = arm_coherent_iommu_map_sg,
2276         .unmap_sg       = arm_coherent_iommu_unmap_sg,
2277
2278         .set_dma_mask   = arm_dma_set_mask,
2279 };
2280
2281 bool device_is_iommuable(struct device *dev)
2282 {
2283         return (dev->archdata.dma_ops == &iommu_ops) ||
2284                 (dev->archdata.dma_ops == &iommu_coherent_ops);
2285 }
2286
2287 static inline void __dummy_common(void)
2288 { WARN(1, "DMA API should be called after ->probe() is done.\n"); }
2289
2290 static void *__dummy_alloc_attrs(struct device *dev, size_t size,
2291                                  dma_addr_t *dma_handle, gfp_t gfp,
2292                                  struct dma_attrs *attrs)
2293 { __dummy_common(); return NULL; }
2294
2295 static void __dummy_free_attrs(struct device *dev, size_t size,
2296                                void *vaddr, dma_addr_t dma_handle,
2297                                struct dma_attrs *attrs)
2298 { __dummy_common(); }
2299
2300 static int __dummy_mmap_attrs(struct device *dev, struct vm_area_struct *vma,
2301                               void *cpu_addr, dma_addr_t dma_addr, size_t size,
2302                               struct dma_attrs *attrs)
2303 { __dummy_common(); return -ENXIO; }
2304
2305 static int __dummy_get_sgtable(struct device *dev, struct sg_table *sgt,
2306                                void *cpu_addr, dma_addr_t dma_addr,
2307                                size_t size, struct dma_attrs *attrs)
2308 { __dummy_common(); return -ENXIO; }
2309
2310 static dma_addr_t __dummy_map_page(struct device *dev, struct page *page,
2311                                    unsigned long offset, size_t size,
2312                                    enum dma_data_direction dir,
2313                                    struct dma_attrs *attrs)
2314 { __dummy_common(); return DMA_ERROR_CODE; }
2315
2316 static dma_addr_t __dummy_map_pages(struct device *dev, struct page **pages,
2317                                     dma_addr_t dma_handle, size_t count,
2318                                     enum dma_data_direction dir,
2319                                     struct dma_attrs *attrs)
2320 { __dummy_common(); return DMA_ERROR_CODE; }
2321
2322 static dma_addr_t __dummy_map_page_at(struct device *dev, struct page *page,
2323                                       dma_addr_t dma_handle,
2324                                       unsigned long offset, size_t size,
2325                                       enum dma_data_direction dir,
2326                                       struct dma_attrs *attrs)
2327 { __dummy_common(); return DMA_ERROR_CODE; }
2328
2329 static void __dummy_unmap_page(struct device *dev, dma_addr_t dma_handle,
2330                                size_t size, enum dma_data_direction dir,
2331                                struct dma_attrs *attrs)
2332 { __dummy_common(); }
2333
2334 static int __dummy_map_sg(struct device *dev, struct scatterlist *sg,
2335                           int nents, enum dma_data_direction dir,
2336                           struct dma_attrs *attrs)
2337 { __dummy_common(); return 0; }
2338
2339 static void __dummy_unmap_sg(struct device *dev,
2340                              struct scatterlist *sg, int nents,
2341                              enum dma_data_direction dir,
2342                              struct dma_attrs *attrs)
2343 { __dummy_common(); }
2344
2345 static void __dummy_sync_single_for_cpu(struct device *dev,
2346                                         dma_addr_t dma_handle, size_t size,
2347                                         enum dma_data_direction dir)
2348 { __dummy_common(); }
2349
2350 static void __dummy_sync_single_for_device(struct device *dev,
2351                                            dma_addr_t dma_handle, size_t size,
2352                                            enum dma_data_direction dir)
2353 { __dummy_common(); }
2354
2355 static void __dummy_sync_sg_for_cpu(struct device *dev,
2356                                     struct scatterlist *sg, int nents,
2357                                     enum dma_data_direction dir)
2358 { __dummy_common(); }
2359
2360 static void __dummy_sync_sg_for_device(struct device *dev,
2361                                        struct scatterlist *sg, int nents,
2362                                        enum dma_data_direction dir)
2363 { __dummy_common(); }
2364
2365 static dma_addr_t __dummy_iova_alloc(struct device *dev, size_t size,
2366                                      struct dma_attrs *attrs)
2367 { __dummy_common(); return DMA_ERROR_CODE; }
2368
2369 static dma_addr_t __dummy_iova_alloc_at(struct device *dev, dma_addr_t *dma_addr,
2370                                         size_t size, struct dma_attrs *attrs)
2371 { __dummy_common(); return DMA_ERROR_CODE; }
2372
2373 static void __dummy_iova_free(struct device *dev, dma_addr_t addr, size_t size,
2374                               struct dma_attrs *attrs)
2375 { __dummy_common(); }
2376
2377 static size_t __dummy_iova_get_free_total(struct device *dev)
2378 { __dummy_common(); return 0; }
2379
2380 static size_t __dummy_iova_get_free_max(struct device *dev)
2381 { __dummy_common(); return 0; }
2382
2383 static struct dma_map_ops __dummy_ops = {
2384         .alloc          = __dummy_alloc_attrs,
2385         .free           = __dummy_free_attrs,
2386         .mmap           = __dummy_mmap_attrs,
2387         .get_sgtable    = __dummy_get_sgtable,
2388
2389         .map_page               = __dummy_map_page,
2390         .map_pages              = __dummy_map_pages,
2391         .map_page_at            = __dummy_map_page_at,
2392         .unmap_page             = __dummy_unmap_page,
2393         .sync_single_for_cpu    = __dummy_sync_single_for_cpu,
2394         .sync_single_for_device = __dummy_sync_single_for_device,
2395
2396         .map_sg                 = __dummy_map_sg,
2397         .unmap_sg               = __dummy_unmap_sg,
2398         .sync_sg_for_cpu        = __dummy_sync_sg_for_cpu,
2399         .sync_sg_for_device     = __dummy_sync_sg_for_device,
2400
2401         .iova_alloc             = __dummy_iova_alloc,
2402         .iova_alloc_at          = __dummy_iova_alloc_at,
2403         .iova_free              = __dummy_iova_free,
2404         .iova_get_free_total    = __dummy_iova_get_free_total,
2405         .iova_get_free_max      = __dummy_iova_get_free_max,
2406 };
2407
2408 void set_dummy_dma_ops(struct device *dev)
2409 {
2410         set_dma_ops(dev, &__dummy_ops);
2411 }
2412
2413 /**
2414  * arm_iommu_create_mapping
2415  * @bus: pointer to the bus holding the client device (for IOMMU calls)
2416  * @base: start address of the valid IO address space
2417  * @size: size of the valid IO address space
2418  * @order: accuracy of the IO addresses allocations
2419  *
2420  * Creates a mapping structure which holds information about used/unused
2421  * IO address ranges, which is required to perform memory allocation and
2422  * mapping with IOMMU aware functions.
2423  *
2424  * The client device need to be attached to the mapping with
2425  * arm_iommu_attach_device function.
2426  */
2427 struct dma_iommu_mapping *
2428 arm_iommu_create_mapping(struct bus_type *bus, dma_addr_t base, size_t size,
2429                          int order)
2430 {
2431         unsigned int count = size >> (PAGE_SHIFT + order);
2432         unsigned int bitmap_size = BITS_TO_LONGS(count) * sizeof(long);
2433         struct dma_iommu_mapping *mapping;
2434         int err = -ENOMEM;
2435
2436         /*
2437          * Upstream kernel is modified to remove order. To mimic the same
2438          * behavior downstream, it is enough to keep order = 0.
2439          * So, do not allow non zero order.
2440          */
2441         BUG_ON(order);
2442
2443         if (!count)
2444                 return ERR_PTR(-EINVAL);
2445
2446         mapping = kzalloc(sizeof(struct dma_iommu_mapping), GFP_KERNEL);
2447         if (!mapping)
2448                 goto err;
2449
2450         mapping->bitmap = kzalloc(bitmap_size, GFP_KERNEL);
2451         if (!mapping->bitmap)
2452                 goto err2;
2453
2454         base = round_up(base, 1 << (order + PAGE_SHIFT));
2455         mapping->base = base;
2456         mapping->end = base + size;
2457         mapping->bits = BITS_PER_BYTE * bitmap_size;
2458         mapping->order = order;
2459         spin_lock_init(&mapping->lock);
2460
2461         mapping->domain = iommu_domain_alloc(bus);
2462         if (!mapping->domain)
2463                 goto err3;
2464
2465         kref_init(&mapping->kref);
2466
2467         iommu_mapping_list_add(mapping);
2468         return mapping;
2469 err3:
2470         kfree(mapping->bitmap);
2471 err2:
2472         kfree(mapping);
2473 err:
2474         return ERR_PTR(err);
2475 }
2476 EXPORT_SYMBOL_GPL(arm_iommu_create_mapping);
2477
2478 static void release_iommu_mapping(struct kref *kref)
2479 {
2480         struct dma_iommu_mapping *mapping =
2481                 container_of(kref, struct dma_iommu_mapping, kref);
2482
2483         iommu_mapping_list_del(mapping);
2484         iommu_domain_free(mapping->domain);
2485         kfree(mapping->bitmap);
2486         kfree(mapping);
2487 }
2488
2489 void arm_iommu_release_mapping(struct dma_iommu_mapping *mapping)
2490 {
2491         if (mapping)
2492                 kref_put(&mapping->kref, release_iommu_mapping);
2493 }
2494 EXPORT_SYMBOL_GPL(arm_iommu_release_mapping);
2495
2496 /**
2497  * arm_iommu_attach_device
2498  * @dev: valid struct device pointer
2499  * @mapping: io address space mapping structure (returned from
2500  *      arm_iommu_create_mapping)
2501  *
2502  * Attaches specified io address space mapping to the provided device,
2503  * this replaces the dma operations (dma_map_ops pointer) with the
2504  * IOMMU aware version. More than one client might be attached to
2505  * the same io address space mapping.
2506  */
2507 int arm_iommu_attach_device(struct device *dev,
2508                             struct dma_iommu_mapping *mapping)
2509 {
2510         int err;
2511         struct dma_map_ops *org_ops;
2512         struct dma_iommu_mapping *org_map;
2513
2514         org_ops = get_dma_ops(dev);
2515         set_dma_ops(dev, &iommu_ops);
2516
2517         org_map = dev->archdata.mapping;
2518         dev->archdata.mapping = mapping;
2519
2520         err = iommu_attach_device(mapping->domain, dev);
2521         if (err) {
2522                 set_dma_ops(dev, org_ops);
2523                 dev->archdata.mapping = org_map;
2524                 return err;
2525         }
2526
2527         kref_get(&mapping->kref);
2528
2529         pr_debug("Attached IOMMU controller to %s device.\n", dev_name(dev));
2530         return 0;
2531 }
2532 EXPORT_SYMBOL_GPL(arm_iommu_attach_device);
2533
2534 /**
2535  * arm_iommu_detach_device
2536  * @dev: valid struct device pointer
2537  *
2538  * Detaches the provided device from a previously attached map.
2539  * This voids the dma operations (dma_map_ops pointer)
2540  */
2541 void arm_iommu_detach_device(struct device *dev)
2542 {
2543         struct dma_iommu_mapping *mapping;
2544
2545         mapping = to_dma_iommu_mapping(dev);
2546         if (!mapping) {
2547                 dev_warn(dev, "Not attached\n");
2548                 return;
2549         }
2550
2551         iommu_detach_device(mapping->domain, dev);
2552         kref_put(&mapping->kref, release_iommu_mapping);
2553         mapping = NULL;
2554         set_dma_ops(dev, NULL);
2555
2556         pr_debug("Detached IOMMU controller from %s device.\n", dev_name(dev));
2557 }
2558 EXPORT_SYMBOL_GPL(arm_iommu_detach_device);
2559
2560 #endif