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