ff01976fb4dbe9f59a6d71312b23c8df50f225ba
[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 to ensure that the
438                  * TLB does not see any conflicting entries, then flush
439                  * the TLB of the old entries before creating new mappings.
440                  *
441                  * This ensures that any speculatively loaded TLB entries
442                  * (even though they may be rare) can not cause any problems,
443                  * and ensures that this code is architecturally compliant.
444                  */
445                 for (addr = __phys_to_virt(start); addr < __phys_to_virt(end);
446                      addr += PMD_SIZE)
447                         pmd_clear(pmd_off_k(addr));
448
449                 for (addr = start; addr < end; addr += PAGE_SIZE) {
450                         map.pfn = __phys_to_pfn(addr);
451                         map.virtual = __phys_to_virt(addr);
452                         map.length = PAGE_SIZE;
453                         iotable_init_mapping(&map, 1);
454                 }
455
456                 map.pfn = __phys_to_pfn(start);
457                 map.virtual = __phys_to_virt(start);
458                 map.length = end - start;
459                 iotable_init_va(&map, 1);
460         }
461 }
462
463 static void *__alloc_remap_buffer(struct device *dev, size_t size, gfp_t gfp,
464                                  pgprot_t prot, struct page **ret_page,
465                                  const void *caller)
466 {
467         struct page *page;
468         void *ptr;
469         page = __dma_alloc_buffer(dev, size, gfp);
470         if (!page)
471                 return NULL;
472
473         ptr = __dma_alloc_remap(page, size, gfp, prot, caller);
474         if (!ptr) {
475                 __dma_free_buffer(page, size);
476                 return NULL;
477         }
478
479         *ret_page = page;
480         return ptr;
481 }
482
483 static void *__alloc_from_pool(size_t size, struct page **ret_page)
484 {
485         struct dma_pool *pool = &atomic_pool;
486         unsigned int count = PAGE_ALIGN(size) >> PAGE_SHIFT;
487         unsigned int pageno;
488         unsigned long flags;
489         void *ptr = NULL;
490         unsigned long align_mask;
491
492         if (!pool->vaddr) {
493                 WARN(1, "coherent pool not initialised!\n");
494                 return NULL;
495         }
496
497         /*
498          * Align the region allocation - allocations from pool are rather
499          * small, so align them to their order in pages, minimum is a page
500          * size. This helps reduce fragmentation of the DMA space.
501          */
502         align_mask = (1 << get_order(size)) - 1;
503
504         spin_lock_irqsave(&pool->lock, flags);
505         pageno = bitmap_find_next_zero_area(pool->bitmap, pool->nr_pages,
506                                             0, count, align_mask);
507         if (pageno < pool->nr_pages) {
508                 bitmap_set(pool->bitmap, pageno, count);
509                 ptr = pool->vaddr + PAGE_SIZE * pageno;
510                 *ret_page = pool->pages[pageno];
511         } else {
512                 pr_err_once("ERROR: %u KiB atomic DMA coherent pool is too small!\n"
513                             "Please increase it with coherent_pool= kernel parameter!\n",
514                             (unsigned)pool->size / 1024);
515         }
516         spin_unlock_irqrestore(&pool->lock, flags);
517
518         return ptr;
519 }
520
521 static bool __in_atomic_pool(void *start, size_t size)
522 {
523         struct dma_pool *pool = &atomic_pool;
524         void *end = start + size;
525         void *pool_start = pool->vaddr;
526         void *pool_end = pool->vaddr + pool->size;
527
528         if (start < pool_start || start >= pool_end)
529                 return false;
530
531         if (end <= pool_end)
532                 return true;
533
534         WARN(1, "Wrong coherent size(%p-%p) from atomic pool(%p-%p)\n",
535              start, end - 1, pool_start, pool_end - 1);
536
537         return false;
538 }
539
540 static int __free_from_pool(void *start, size_t size)
541 {
542         struct dma_pool *pool = &atomic_pool;
543         unsigned long pageno, count;
544         unsigned long flags;
545
546         if (!__in_atomic_pool(start, size))
547                 return 0;
548
549         pageno = (start - pool->vaddr) >> PAGE_SHIFT;
550         count = size >> PAGE_SHIFT;
551
552         spin_lock_irqsave(&pool->lock, flags);
553         bitmap_clear(pool->bitmap, pageno, count);
554         spin_unlock_irqrestore(&pool->lock, flags);
555
556         return 1;
557 }
558
559 static void *__alloc_from_contiguous(struct device *dev, size_t size,
560                                      pgprot_t prot, struct page **ret_page,
561                                      const void *caller)
562 {
563         unsigned long order = get_order(size);
564         size_t count = size >> PAGE_SHIFT;
565         struct page *page;
566         void *ptr;
567
568         page = dma_alloc_from_contiguous(dev, count, order);
569         if (!page)
570                 return NULL;
571
572         if (PageHighMem(page)) {
573                 ptr = __dma_alloc_remap(page, size, GFP_KERNEL, prot, caller);
574                 if (!ptr) {
575                         dma_release_from_contiguous(dev, page, count);
576                         return NULL;
577                 }
578         } else {
579                 ptr = page_address(page);
580         }
581         *ret_page = page;
582         return ptr;
583 }
584
585 static void __free_from_contiguous(struct device *dev, struct page *page,
586                                    void *cpu_addr, size_t size)
587 {
588         if (PageHighMem(page))
589                 __dma_free_remap(cpu_addr, size);
590         dma_release_from_contiguous(dev, page, size >> PAGE_SHIFT);
591 }
592
593 static inline pgprot_t __get_dma_pgprot(struct dma_attrs *attrs, pgprot_t prot)
594 {
595         prot = dma_get_attr(DMA_ATTR_WRITE_COMBINE, attrs) ?
596                             pgprot_writecombine(prot) :
597                             pgprot_dmacoherent(prot);
598         return prot;
599 }
600
601 #define nommu() 0
602
603 #else   /* !CONFIG_MMU */
604
605 #define nommu() 1
606
607 #define __get_dma_pgprot(attrs, prot)   __pgprot(0)
608 #define __alloc_remap_buffer(dev, size, gfp, prot, ret, c)      NULL
609 #define __alloc_from_pool(size, ret_page)                       NULL
610 #define __alloc_from_contiguous(dev, size, prot, ret, c)        NULL
611 #define __free_from_pool(cpu_addr, size)                        0
612 #define __free_from_contiguous(dev, page, cpu_addr, size)       do { } while (0)
613 #define __dma_free_remap(cpu_addr, size)                        do { } while (0)
614
615 #endif  /* CONFIG_MMU */
616
617 static void *__alloc_simple_buffer(struct device *dev, size_t size, gfp_t gfp,
618                                    struct page **ret_page)
619 {
620         struct page *page;
621         page = __dma_alloc_buffer(dev, size, gfp);
622         if (!page)
623                 return NULL;
624
625         *ret_page = page;
626         return page_address(page);
627 }
628
629
630
631 static void *__dma_alloc(struct device *dev, size_t size, dma_addr_t *handle,
632                          gfp_t gfp, pgprot_t prot, bool is_coherent, const void *caller)
633 {
634         u64 mask = get_coherent_dma_mask(dev);
635         struct page *page = NULL;
636         void *addr;
637
638 #ifdef CONFIG_DMA_API_DEBUG
639         u64 limit = (mask + 1) & ~mask;
640         if (limit && size >= limit) {
641                 dev_warn(dev, "coherent allocation too big (requested %#zx mask %#llx)\n",
642                         size, mask);
643                 return NULL;
644         }
645 #endif
646
647         if (!mask)
648                 return NULL;
649
650         if (mask < 0xffffffffULL)
651                 gfp |= GFP_DMA;
652
653         /*
654          * Following is a work-around (a.k.a. hack) to prevent pages
655          * with __GFP_COMP being passed to split_page() which cannot
656          * handle them.  The real problem is that this flag probably
657          * should be 0 on ARM as it is not supported on this
658          * platform; see CONFIG_HUGETLBFS.
659          */
660         gfp &= ~(__GFP_COMP);
661
662         *handle = DMA_ERROR_CODE;
663         size = PAGE_ALIGN(size);
664
665         if (is_coherent || nommu())
666                 addr = __alloc_simple_buffer(dev, size, gfp, &page);
667         else if (!(gfp & __GFP_WAIT))
668                 addr = __alloc_from_pool(size, &page);
669         else if (!IS_ENABLED(CONFIG_CMA))
670                 addr = __alloc_remap_buffer(dev, size, gfp, prot, &page, caller);
671         else
672                 addr = __alloc_from_contiguous(dev, size, prot, &page, caller);
673
674         if (addr)
675                 *handle = pfn_to_dma(dev, page_to_pfn(page));
676
677         return addr;
678 }
679
680 /*
681  * Allocate DMA-coherent memory space and return both the kernel remapped
682  * virtual and bus address for that space.
683  */
684 void *arm_dma_alloc(struct device *dev, size_t size, dma_addr_t *handle,
685                     gfp_t gfp, struct dma_attrs *attrs)
686 {
687         pgprot_t prot = __get_dma_pgprot(attrs, pgprot_kernel);
688         void *memory;
689
690         if (dma_alloc_from_coherent_attr(dev, size, handle,
691                         &memory, attrs))
692                 return memory;
693
694         return __dma_alloc(dev, size, handle, gfp, prot, false,
695                            __builtin_return_address(0));
696 }
697
698 static void *arm_coherent_dma_alloc(struct device *dev, size_t size,
699         dma_addr_t *handle, gfp_t gfp, struct dma_attrs *attrs)
700 {
701         pgprot_t prot = __get_dma_pgprot(attrs, pgprot_kernel);
702         void *memory;
703
704         if (dma_alloc_from_coherent_attr(dev, size, handle,
705                         &memory, attrs))
706                         return memory;
707
708         return __dma_alloc(dev, size, handle, gfp, prot, true,
709                            __builtin_return_address(0));
710 }
711
712 /*
713  * Create userspace mapping for the DMA-coherent memory.
714  */
715 int arm_dma_mmap(struct device *dev, struct vm_area_struct *vma,
716                  void *cpu_addr, dma_addr_t dma_addr, size_t size,
717                  struct dma_attrs *attrs)
718 {
719         int ret = -ENXIO;
720 #ifdef CONFIG_MMU
721         unsigned long nr_vma_pages = (vma->vm_end - vma->vm_start) >> PAGE_SHIFT;
722         unsigned long nr_pages = PAGE_ALIGN(size) >> PAGE_SHIFT;
723         unsigned long pfn = dma_to_pfn(dev, dma_addr);
724         unsigned long off = vma->vm_pgoff;
725
726         vma->vm_page_prot = __get_dma_pgprot(attrs, vma->vm_page_prot);
727
728         if (dma_mmap_from_coherent(dev, vma, cpu_addr, size, &ret))
729                 return ret;
730
731         if (off < nr_pages && nr_vma_pages <= (nr_pages - off)) {
732                 ret = remap_pfn_range(vma, vma->vm_start,
733                                       pfn + off,
734                                       vma->vm_end - vma->vm_start,
735                                       vma->vm_page_prot);
736         }
737 #endif  /* CONFIG_MMU */
738
739         return ret;
740 }
741
742 /*
743  * Free a buffer as defined by the above mapping.
744  */
745 static void __arm_dma_free(struct device *dev, size_t size, void *cpu_addr,
746                            dma_addr_t handle, struct dma_attrs *attrs,
747                            bool is_coherent)
748 {
749         struct page *page = pfn_to_page(dma_to_pfn(dev, handle));
750
751         if (dma_release_from_coherent_attr(dev, size, cpu_addr, attrs))
752                 return;
753
754         size = PAGE_ALIGN(size);
755
756         if (is_coherent || nommu()) {
757                 __dma_free_buffer(page, size);
758         } else if (__free_from_pool(cpu_addr, size)) {
759                 return;
760         } else if (!IS_ENABLED(CONFIG_CMA)) {
761                 __dma_free_remap(cpu_addr, size);
762                 __dma_free_buffer(page, size);
763         } else {
764                 /*
765                  * Non-atomic allocations cannot be freed with IRQs disabled
766                  */
767                 WARN_ON(irqs_disabled());
768                 __free_from_contiguous(dev, page, cpu_addr, size);
769         }
770 }
771
772 void arm_dma_free(struct device *dev, size_t size, void *cpu_addr,
773                   dma_addr_t handle, struct dma_attrs *attrs)
774 {
775         __arm_dma_free(dev, size, cpu_addr, handle, attrs, false);
776 }
777
778 static void arm_coherent_dma_free(struct device *dev, size_t size, void *cpu_addr,
779                                   dma_addr_t handle, struct dma_attrs *attrs)
780 {
781         __arm_dma_free(dev, size, cpu_addr, handle, attrs, true);
782 }
783
784 int arm_dma_get_sgtable(struct device *dev, struct sg_table *sgt,
785                  void *cpu_addr, dma_addr_t handle, size_t size,
786                  struct dma_attrs *attrs)
787 {
788         struct page *page = pfn_to_page(dma_to_pfn(dev, handle));
789         int ret;
790
791         ret = sg_alloc_table(sgt, 1, GFP_KERNEL);
792         if (unlikely(ret))
793                 return ret;
794
795         sg_set_page(sgt->sgl, page, PAGE_ALIGN(size), 0);
796         return 0;
797 }
798
799 static void dma_cache_maint_page(struct page *page, unsigned long offset,
800         size_t size, enum dma_data_direction dir,
801         void (*op)(const void *, size_t, int))
802 {
803         unsigned long pfn;
804         size_t left = size;
805
806         pfn = page_to_pfn(page) + offset / PAGE_SIZE;
807         offset %= PAGE_SIZE;
808
809         /*
810          * A single sg entry may refer to multiple physically contiguous
811          * pages.  But we still need to process highmem pages individually.
812          * If highmem is not configured then the bulk of this loop gets
813          * optimized out.
814          */
815         do {
816                 size_t len = left;
817                 void *vaddr;
818
819                 page = pfn_to_page(pfn);
820
821                 if (PageHighMem(page)) {
822                         if (len + offset > PAGE_SIZE)
823                                 len = PAGE_SIZE - offset;
824
825                         if (cache_is_vipt_nonaliasing()) {
826                                 vaddr = kmap_atomic(page);
827                                 op(vaddr + offset, len, dir);
828                                 kunmap_atomic(vaddr);
829                         } else {
830                                 vaddr = kmap_high_get(page);
831                                 if (vaddr) {
832                                         op(vaddr + offset, len, dir);
833                                         kunmap_high(page);
834                                 }
835                         }
836                 } else {
837                         vaddr = page_address(page) + offset;
838                         op(vaddr, len, dir);
839                 }
840                 offset = 0;
841                 pfn++;
842                 left -= len;
843         } while (left);
844 }
845
846 /*
847  * Make an area consistent for devices.
848  * Note: Drivers should NOT use this function directly, as it will break
849  * platforms with CONFIG_DMABOUNCE.
850  * Use the driver DMA support - see dma-mapping.h (dma_sync_*)
851  */
852 static void __dma_page_cpu_to_dev(struct page *page, unsigned long off,
853         size_t size, enum dma_data_direction dir)
854 {
855         unsigned long paddr;
856
857         dma_cache_maint_page(page, off, size, dir, dmac_map_area);
858
859         paddr = page_to_phys(page) + off;
860         if (dir == DMA_FROM_DEVICE) {
861                 outer_inv_range(paddr, paddr + size);
862         } else {
863                 outer_clean_range(paddr, paddr + size);
864         }
865         /* FIXME: non-speculating: flush on bidirectional mappings? */
866 }
867
868 static void __dma_page_dev_to_cpu(struct page *page, unsigned long off,
869         size_t size, enum dma_data_direction dir)
870 {
871         unsigned long paddr = page_to_phys(page) + off;
872
873         /* FIXME: non-speculating: not required */
874         /* don't bother invalidating if DMA to device */
875         if (dir != DMA_TO_DEVICE)
876                 outer_inv_range(paddr, paddr + size);
877
878         dma_cache_maint_page(page, off, size, dir, dmac_unmap_area);
879
880         /*
881          * Mark the D-cache clean for this page to avoid extra flushing.
882          */
883         if (dir != DMA_TO_DEVICE && off == 0 && size >= PAGE_SIZE)
884                 set_bit(PG_dcache_clean, &page->flags);
885 }
886
887 /**
888  * arm_dma_map_sg - map a set of SG buffers for streaming mode DMA
889  * @dev: valid struct device pointer, or NULL for ISA and EISA-like devices
890  * @sg: list of buffers
891  * @nents: number of buffers to map
892  * @dir: DMA transfer direction
893  *
894  * Map a set of buffers described by scatterlist in streaming mode for DMA.
895  * This is the scatter-gather version of the dma_map_single interface.
896  * Here the scatter gather list elements are each tagged with the
897  * appropriate dma address and length.  They are obtained via
898  * sg_dma_{address,length}.
899  *
900  * Device ownership issues as mentioned for dma_map_single are the same
901  * here.
902  */
903 int arm_dma_map_sg(struct device *dev, struct scatterlist *sg, int nents,
904                 enum dma_data_direction dir, struct dma_attrs *attrs)
905 {
906         struct dma_map_ops *ops = get_dma_ops(dev);
907         struct scatterlist *s;
908         int i, j;
909
910         for_each_sg(sg, s, nents, i) {
911 #ifdef CONFIG_NEED_SG_DMA_LENGTH
912                 s->dma_length = s->length;
913 #endif
914                 s->dma_address = ops->map_page(dev, sg_page(s), s->offset,
915                                                 s->length, dir, attrs);
916                 if (dma_mapping_error(dev, s->dma_address))
917                         goto bad_mapping;
918         }
919         return nents;
920
921  bad_mapping:
922         for_each_sg(sg, s, i, j)
923                 ops->unmap_page(dev, sg_dma_address(s), sg_dma_len(s), dir, attrs);
924         return 0;
925 }
926
927 /**
928  * arm_dma_unmap_sg - unmap a set of SG buffers mapped by dma_map_sg
929  * @dev: valid struct device pointer, or NULL for ISA and EISA-like devices
930  * @sg: list of buffers
931  * @nents: number of buffers to unmap (same as was passed to dma_map_sg)
932  * @dir: DMA transfer direction (same as was passed to dma_map_sg)
933  *
934  * Unmap a set of streaming mode DMA translations.  Again, CPU access
935  * rules concerning calls here are the same as for dma_unmap_single().
936  */
937 void arm_dma_unmap_sg(struct device *dev, struct scatterlist *sg, int nents,
938                 enum dma_data_direction dir, struct dma_attrs *attrs)
939 {
940         struct dma_map_ops *ops = get_dma_ops(dev);
941         struct scatterlist *s;
942
943         int i;
944
945         for_each_sg(sg, s, nents, i)
946                 ops->unmap_page(dev, sg_dma_address(s), sg_dma_len(s), dir, attrs);
947 }
948
949 /**
950  * arm_dma_sync_sg_for_cpu
951  * @dev: valid struct device pointer, or NULL for ISA and EISA-like devices
952  * @sg: list of buffers
953  * @nents: number of buffers to map (returned from dma_map_sg)
954  * @dir: DMA transfer direction (same as was passed to dma_map_sg)
955  */
956 void arm_dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg,
957                         int nents, enum dma_data_direction dir)
958 {
959         struct dma_map_ops *ops = get_dma_ops(dev);
960         struct scatterlist *s;
961         int i;
962
963         for_each_sg(sg, s, nents, i)
964                 ops->sync_single_for_cpu(dev, sg_dma_address(s), s->length,
965                                          dir);
966 }
967
968 /**
969  * arm_dma_sync_sg_for_device
970  * @dev: valid struct device pointer, or NULL for ISA and EISA-like devices
971  * @sg: list of buffers
972  * @nents: number of buffers to map (returned from dma_map_sg)
973  * @dir: DMA transfer direction (same as was passed to dma_map_sg)
974  */
975 void arm_dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg,
976                         int nents, enum dma_data_direction dir)
977 {
978         struct dma_map_ops *ops = get_dma_ops(dev);
979         struct scatterlist *s;
980         int i;
981
982         for_each_sg(sg, s, nents, i)
983                 ops->sync_single_for_device(dev, sg_dma_address(s), s->length,
984                                             dir);
985 }
986
987 /*
988  * Return whether the given device DMA address mask can be supported
989  * properly.  For example, if your device can only drive the low 24-bits
990  * during bus mastering, then you would pass 0x00ffffff as the mask
991  * to this function.
992  */
993 int dma_supported(struct device *dev, u64 mask)
994 {
995         if (mask < (u64)arm_dma_limit)
996                 return 0;
997         return 1;
998 }
999 EXPORT_SYMBOL(dma_supported);
1000
1001 int arm_dma_set_mask(struct device *dev, u64 dma_mask)
1002 {
1003         if (!dev->dma_mask || !dma_supported(dev, dma_mask))
1004                 return -EIO;
1005
1006         *dev->dma_mask = dma_mask;
1007
1008         return 0;
1009 }
1010
1011 #if defined(CONFIG_ARM_DMA_USE_IOMMU)
1012
1013 static LIST_HEAD(iommu_mapping_list);
1014 static DEFINE_SPINLOCK(iommu_mapping_list_lock);
1015
1016 #if defined(CONFIG_DEBUG_FS)
1017 static dma_addr_t bit_to_addr(size_t pos, dma_addr_t base, size_t order)
1018 {
1019         return base + pos * (1 << (PAGE_SHIFT + order));
1020 }
1021
1022 static void seq_print_dma_areas(struct seq_file *s, void *bitmap,
1023                                 dma_addr_t base, size_t bits, size_t order)
1024 {
1025         /* one bit = one (page + order) sized block */
1026         size_t pos = find_first_bit(bitmap, bits), end;
1027
1028         for (; pos < bits; pos = find_next_bit(bitmap, bits, end + 1)) {
1029                 dma_addr_t start_addr, end_addr;
1030
1031                 end = find_next_zero_bit(bitmap, bits, pos);
1032                 start_addr = bit_to_addr(pos, base, order);
1033                 end_addr = bit_to_addr(end, base, order) - 1;
1034                 seq_printf(s, "    %pa-%pa pages=%zu\n",
1035                            &start_addr, &end_addr, (end - pos) << order);
1036         }
1037 }
1038
1039 static void seq_print_mapping(struct seq_file *s,
1040                               struct dma_iommu_mapping *mapping)
1041 {
1042         seq_printf(s, "  memory map: base=%pa size=%lld order=%d domain=%p\n",
1043                    &mapping->base, (u64)(mapping->end - mapping->base),
1044                    mapping->order, mapping->domain);
1045
1046         seq_print_dma_areas(s, mapping->bitmap, mapping->base, mapping->bits,
1047                             mapping->order);
1048 }
1049
1050 static void debug_dma_seq_print_mappings(struct seq_file *s)
1051 {
1052         struct dma_iommu_mapping *mapping;
1053         int i = 0;
1054
1055         list_for_each_entry(mapping, &iommu_mapping_list, list) {
1056                 seq_printf(s, "Map %d (%p):\n", i, mapping);
1057                 seq_print_mapping(s, mapping);
1058                 i++;
1059         }
1060 }
1061
1062 static int dump_iommu_mappings(struct seq_file *s, void *data)
1063 {
1064         debug_dma_seq_print_mappings(s);
1065         return 0;
1066 }
1067
1068 static int dump_iommu_mappings_open(struct inode *inode, struct file *file)
1069 {
1070         return single_open(file, dump_iommu_mappings, NULL);
1071 }
1072
1073 static const struct file_operations dump_iommu_mappings_fops = {
1074         .open           = dump_iommu_mappings_open,
1075         .read           = seq_read,
1076         .llseek         = seq_lseek,
1077         .release        = single_release,
1078 };
1079
1080 #endif /* CONFIG_DEBUG_FS */
1081
1082 void dma_debugfs_platform_info(struct dentry *dent)
1083 {
1084         debugfs_create_file("dump_mappings", S_IRUGO, dent, NULL,
1085                             &dump_iommu_mappings_fops);
1086 }
1087
1088 #else /* !CONFIG_ARM_DMA_USE_IOMMU */
1089 static inline void dma_debugfs_platform_info(struct dentry *dent)
1090 {
1091 }
1092 #endif /* !CONFIG_ARM_DMA_USE_IOMMU */
1093
1094 #if defined(CONFIG_DMA_API_DEBUG)
1095 static inline void dma_debug_platform(void)
1096 {
1097 }
1098 #else /* !CONFIG_DMA_API_DEBUG */
1099 static void dma_debug_platform(void)
1100 {
1101         struct dentry *dent;
1102
1103         dent = debugfs_create_dir("dma-api", NULL);
1104         if (dent)
1105                 dma_debugfs_platform_info(dent);
1106 }
1107 #endif /* !CONFIG_DMA_API_DEBUG */
1108
1109 #define PREALLOC_DMA_DEBUG_ENTRIES      4096
1110
1111 static int __init dma_debug_do_init(void)
1112 {
1113         dma_debug_init(PREALLOC_DMA_DEBUG_ENTRIES);
1114         dma_debug_platform();
1115         return 0;
1116 }
1117 fs_initcall(dma_debug_do_init);
1118
1119 char *__weak debug_dma_platformdata(struct device *dev)
1120 {
1121         /* empty string by default */
1122         static char buf[1];
1123
1124         return buf;
1125 }
1126
1127 #ifdef CONFIG_ARM_DMA_USE_IOMMU
1128
1129 /* IOMMU */
1130
1131 static unsigned int prefetch_page_count = 1;
1132 static unsigned int gap_page_count = 1;
1133
1134 #define PF_PAGES_SIZE (prefetch_page_count << PAGE_SHIFT)
1135 #define PG_PAGES (prefetch_page_count + gap_page_count)
1136
1137 static struct page *iova_gap_pages;
1138 static phys_addr_t iova_gap_phys;
1139
1140 static int __init iova_gap_pages_init(void)
1141 {
1142         unsigned long order = get_order(PF_PAGES_SIZE);
1143
1144         iova_gap_pages = alloc_pages(GFP_KERNEL, order);
1145         if (WARN_ON(!iova_gap_pages)) {
1146                 prefetch_page_count = 0;
1147                 return 0;
1148         }
1149
1150         __dma_clear_buffer(iova_gap_pages, PAGE_SIZE << order);
1151         iova_gap_phys = page_to_phys(iova_gap_pages);
1152         return 0;
1153 }
1154 core_initcall(iova_gap_pages_init);
1155
1156 static void iommu_mapping_list_add(struct dma_iommu_mapping *mapping)
1157 {
1158         unsigned long flags;
1159
1160         spin_lock_irqsave(&iommu_mapping_list_lock, flags);
1161         list_add_tail(&mapping->list, &iommu_mapping_list);
1162         spin_unlock_irqrestore(&iommu_mapping_list_lock, flags);
1163 }
1164
1165 static void iommu_mapping_list_del(struct dma_iommu_mapping *mapping)
1166 {
1167         unsigned long flags;
1168
1169         spin_lock_irqsave(&iommu_mapping_list_lock, flags);
1170         list_del(&mapping->list);
1171         spin_unlock_irqrestore(&iommu_mapping_list_lock, flags);
1172 }
1173
1174 static inline int iommu_get_num_pf_pages(struct dma_iommu_mapping *mapping,
1175                                          struct dma_attrs *attrs)
1176 {
1177         /* XXX: give priority to DMA_ATTR_SKIP_IOVA_GAP */
1178         if (dma_get_attr(DMA_ATTR_SKIP_IOVA_GAP, attrs))
1179                         return 0;
1180
1181         /* XXX: currently we support only 1 prefetch page */
1182         WARN_ON(mapping->num_pf_page > prefetch_page_count);
1183
1184         return mapping->num_pf_page;
1185 }
1186
1187 static inline int iommu_gap_pg_count(struct dma_iommu_mapping *mapping,
1188                                      struct dma_attrs *attrs)
1189 {
1190         if (dma_get_attr(DMA_ATTR_SKIP_IOVA_GAP, attrs))
1191                 return 0;
1192
1193         return mapping->gap_page ? gap_page_count : 0;
1194 }
1195
1196 static int pg_iommu_map(struct dma_iommu_mapping *mapping, unsigned long iova,
1197                         phys_addr_t phys, size_t len, int prot)
1198 {
1199         int err;
1200         struct iommu_domain *domain = mapping->domain;
1201         struct dma_attrs *attrs = (struct dma_attrs *)prot;
1202         bool need_prefetch_page = !!iommu_get_num_pf_pages(mapping, attrs);
1203
1204         if (need_prefetch_page) {
1205                 err = iommu_map(domain, iova + len, iova_gap_phys,
1206                                 PF_PAGES_SIZE, prot);
1207                 if (err)
1208                         return err;
1209         }
1210
1211         err = iommu_map(domain, iova, phys, len, prot);
1212         if (err && need_prefetch_page)
1213                 iommu_unmap(domain, iova + len, PF_PAGES_SIZE);
1214
1215         return err;
1216 }
1217
1218 static size_t pg_iommu_unmap(struct dma_iommu_mapping *mapping,
1219                              unsigned long iova, size_t len, int prot)
1220 {
1221         struct dma_attrs *attrs = (struct dma_attrs *)prot;
1222         struct iommu_domain *domain = mapping->domain;
1223         bool need_prefetch_page = !!iommu_get_num_pf_pages(mapping, attrs);
1224
1225         if (need_prefetch_page) {
1226                 phys_addr_t phys_addr;
1227
1228                 phys_addr = iommu_iova_to_phys(domain, iova + len);
1229                 BUG_ON(phys_addr != iova_gap_phys);
1230                 iommu_unmap(domain, iova + len, PF_PAGES_SIZE);
1231         }
1232
1233         return iommu_unmap(domain, iova, len);
1234 }
1235
1236 static int pg_iommu_map_sg(struct dma_iommu_mapping *mapping,
1237                            unsigned long iova, struct scatterlist *sgl,
1238                            int nents, int prot)
1239 {
1240         int err;
1241         struct dma_attrs *attrs = (struct dma_attrs *)prot;
1242         struct iommu_domain *domain = mapping->domain;
1243         bool need_prefetch_page = !!iommu_get_num_pf_pages(mapping, attrs);
1244
1245         if (need_prefetch_page) {
1246                 err = iommu_map(domain, iova + (nents << PAGE_SHIFT),
1247                                 iova_gap_phys, PF_PAGES_SIZE, prot);
1248                 if (err)
1249                         return err;
1250         }
1251
1252         err = iommu_map_sg(domain, iova, sgl, nents, prot);
1253         if (err && need_prefetch_page)
1254                 iommu_unmap(domain, iova + (nents << PAGE_SHIFT), PF_PAGES_SIZE);
1255
1256         return err;
1257 }
1258
1259 static size_t arm_iommu_iova_get_free_total(struct device *dev)
1260 {
1261         struct dma_iommu_mapping *mapping = dev->archdata.mapping;
1262         unsigned long flags;
1263         size_t size = 0;
1264         unsigned long start = 0;
1265
1266         BUG_ON(!dev);
1267         BUG_ON(!mapping);
1268
1269         spin_lock_irqsave(&mapping->lock, flags);
1270         while (1) {
1271                 unsigned long end;
1272
1273                 start = bitmap_find_next_zero_area(mapping->bitmap,
1274                                                    mapping->bits, start, 1, 0);
1275                 if (start > mapping->bits)
1276                         break;
1277
1278                 end = find_next_bit(mapping->bitmap, mapping->bits, start);
1279                 size += end - start;
1280                 start = end;
1281         }
1282         spin_unlock_irqrestore(&mapping->lock, flags);
1283         return size << (mapping->order + PAGE_SHIFT);
1284 }
1285
1286 static size_t arm_iommu_iova_get_free_max(struct device *dev)
1287 {
1288         struct dma_iommu_mapping *mapping = dev->archdata.mapping;
1289         unsigned long flags;
1290         size_t max_free = 0;
1291         unsigned long start = 0;
1292
1293         spin_lock_irqsave(&mapping->lock, flags);
1294         while (1) {
1295                 unsigned long end;
1296
1297                 start = bitmap_find_next_zero_area(mapping->bitmap,
1298                                                    mapping->bits, start, 1, 0);
1299                 if (start > mapping->bits)
1300                         break;
1301
1302                 end = find_next_bit(mapping->bitmap, mapping->bits, start);
1303                 max_free = max_t(size_t, max_free, end - start);
1304                 start = end;
1305         }
1306         spin_unlock_irqrestore(&mapping->lock, flags);
1307         return max_free << (mapping->order + PAGE_SHIFT);
1308 }
1309
1310 static inline dma_addr_t __alloc_iova(struct dma_iommu_mapping *mapping,
1311                                       size_t size, struct dma_attrs *attrs)
1312 {
1313         unsigned int order = get_order(size);
1314         unsigned int align = 0;
1315         unsigned int count, start;
1316         unsigned long flags;
1317
1318         if (order > CONFIG_ARM_DMA_IOMMU_ALIGNMENT)
1319                 order = CONFIG_ARM_DMA_IOMMU_ALIGNMENT;
1320
1321         if (mapping->alignment && order > get_order(mapping->alignment))
1322                 order = get_order(mapping->alignment);
1323
1324         count = ((PAGE_ALIGN(size) >> PAGE_SHIFT) +
1325                  (1 << mapping->order) - 1) >> mapping->order;
1326
1327         count += iommu_get_num_pf_pages(mapping, attrs);
1328         count += iommu_gap_pg_count(mapping, attrs);
1329
1330         if (order > mapping->order)
1331                 align = (1 << (order - mapping->order)) - 1;
1332
1333         spin_lock_irqsave(&mapping->lock, flags);
1334         start = bitmap_find_next_zero_area(mapping->bitmap, mapping->bits, 0,
1335                                            count, align);
1336         if (start > mapping->bits) {
1337                 spin_unlock_irqrestore(&mapping->lock, flags);
1338                 return DMA_ERROR_CODE;
1339         }
1340
1341         bitmap_set(mapping->bitmap, start, count);
1342         spin_unlock_irqrestore(&mapping->lock, flags);
1343
1344         return mapping->base + (start << (mapping->order + PAGE_SHIFT));
1345 }
1346
1347 static dma_addr_t __alloc_iova_at(struct dma_iommu_mapping *mapping,
1348                                   dma_addr_t *iova, size_t size,
1349                                   struct dma_attrs *attrs)
1350 {
1351         unsigned int count, start, orig;
1352         unsigned long flags;
1353         size_t bytes;
1354
1355         count = ((PAGE_ALIGN(size) >> PAGE_SHIFT) +
1356                  (1 << mapping->order) - 1) >> mapping->order;
1357
1358         count += iommu_get_num_pf_pages(mapping, attrs);
1359         count += iommu_gap_pg_count(mapping, attrs);
1360
1361         bytes = count << (mapping->order + PAGE_SHIFT);
1362
1363         spin_lock_irqsave(&mapping->lock, flags);
1364
1365         if ((*iova < mapping->base) || (bytes > mapping->end - *iova)) {
1366                 *iova = -ENXIO;
1367                 goto err_out;
1368         }
1369
1370         orig = (*iova - mapping->base) >> (mapping->order + PAGE_SHIFT);
1371         start = bitmap_find_next_zero_area(mapping->bitmap, mapping->bits,
1372                                            orig, count, 0);
1373
1374         if ((start > mapping->bits) || (orig != start)) {
1375                 *iova = -EINVAL;
1376                 goto err_out;
1377         }
1378
1379         bitmap_set(mapping->bitmap, start, count);
1380         spin_unlock_irqrestore(&mapping->lock, flags);
1381
1382         return mapping->base + (start << (mapping->order + PAGE_SHIFT));
1383
1384 err_out:
1385         spin_unlock_irqrestore(&mapping->lock, flags);
1386         return DMA_ERROR_CODE;
1387 }
1388
1389 static dma_addr_t arm_iommu_iova_alloc_at(struct device *dev, dma_addr_t *iova,
1390                                           size_t size, struct dma_attrs *attrs)
1391 {
1392         struct dma_iommu_mapping *mapping = dev->archdata.mapping;
1393
1394         return __alloc_iova_at(mapping, iova, size, attrs);
1395 }
1396
1397 static dma_addr_t arm_iommu_iova_alloc(struct device *dev, size_t size,
1398                                        struct dma_attrs *attrs)
1399 {
1400         struct dma_iommu_mapping *mapping = dev->archdata.mapping;
1401
1402         return __alloc_iova(mapping, size, attrs);
1403 }
1404
1405 static inline void __free_iova(struct dma_iommu_mapping *mapping,
1406                                dma_addr_t addr, size_t size,
1407                                struct dma_attrs *attrs)
1408 {
1409         unsigned int start = (addr - mapping->base) >>
1410                              (mapping->order + PAGE_SHIFT);
1411         unsigned int count = ((size >> PAGE_SHIFT) +
1412                               (1 << mapping->order) - 1) >> mapping->order;
1413         unsigned long flags;
1414
1415         count += iommu_get_num_pf_pages(mapping, attrs);
1416         count += iommu_gap_pg_count(mapping, attrs);
1417
1418         spin_lock_irqsave(&mapping->lock, flags);
1419         bitmap_clear(mapping->bitmap, start, count);
1420         spin_unlock_irqrestore(&mapping->lock, flags);
1421 }
1422
1423 static void arm_iommu_iova_free(struct device *dev, dma_addr_t addr,
1424                                 size_t size, struct dma_attrs *attrs)
1425 {
1426         struct dma_iommu_mapping *mapping = dev->archdata.mapping;
1427
1428         __free_iova(mapping, addr, size, attrs);
1429 }
1430
1431 static struct page **__iommu_alloc_buffer(struct device *dev, size_t size,
1432                                           gfp_t gfp, struct dma_attrs *attrs)
1433 {
1434         struct page **pages;
1435         int count = size >> PAGE_SHIFT;
1436         int array_size = count * sizeof(struct page *);
1437         int i = 0;
1438
1439         if (array_size <= PAGE_SIZE)
1440                 pages = kzalloc(array_size,
1441                                 gfp & ~(__GFP_HIGHMEM | __GFP_DMA32));
1442         else
1443                 pages = vzalloc(array_size);
1444         if (!pages)
1445                 return NULL;
1446
1447         if (dma_get_attr(DMA_ATTR_FORCE_CONTIGUOUS, attrs))
1448         {
1449                 unsigned long order = get_order(size);
1450                 struct page *page;
1451
1452                 page = dma_alloc_from_contiguous(dev, count, order);
1453                 if (!page)
1454                         goto error;
1455
1456                 __dma_clear_buffer(page, size);
1457
1458                 for (i = 0; i < count; i++)
1459                         pages[i] = page + i;
1460
1461                 return pages;
1462         }
1463
1464         /*
1465          * IOMMU can map any pages, so himem can also be used here
1466          * unless some DMA'able area is explicitly required.
1467          */
1468         if (!(gfp & GFP_DMA) && !(gfp & GFP_DMA32))
1469                 gfp |= __GFP_HIGHMEM;
1470
1471         gfp |= __GFP_NOWARN;
1472         while (count) {
1473                 int j, order = __fls(count);
1474
1475                 pages[i] = alloc_pages(gfp, order);
1476                 while (!pages[i] && order)
1477                         pages[i] = alloc_pages(gfp, --order);
1478                 if (!pages[i])
1479                         goto error;
1480
1481                 if (order) {
1482                         split_page(pages[i], order);
1483                         j = 1 << order;
1484                         while (--j)
1485                                 pages[i + j] = pages[i] + j;
1486                 }
1487
1488                 __dma_clear_buffer(pages[i], PAGE_SIZE << order);
1489                 i += 1 << order;
1490                 count -= 1 << order;
1491         }
1492
1493         return pages;
1494 error:
1495         while (i--)
1496                 if (pages[i])
1497                         __free_pages(pages[i], 0);
1498         if (array_size <= PAGE_SIZE)
1499                 kfree(pages);
1500         else
1501                 vfree(pages);
1502         return NULL;
1503 }
1504
1505 static int __iommu_free_buffer(struct device *dev, struct page **pages,
1506                                size_t size, struct dma_attrs *attrs)
1507 {
1508         int count = size >> PAGE_SHIFT;
1509         int array_size = count * sizeof(struct page *);
1510         int i;
1511
1512         if (dma_get_attr(DMA_ATTR_FORCE_CONTIGUOUS, attrs)) {
1513                 dma_release_from_contiguous(dev, pages[0], count);
1514         } else {
1515                 for (i = 0; i < count; i++)
1516                         if (pages[i])
1517                                 __free_pages(pages[i], 0);
1518         }
1519
1520         if (array_size <= PAGE_SIZE)
1521                 kfree(pages);
1522         else
1523                 vfree(pages);
1524         return 0;
1525 }
1526
1527 /*
1528  * Create a CPU mapping for a specified pages
1529  */
1530 static void *
1531 __iommu_alloc_remap(struct page **pages, size_t size, gfp_t gfp, pgprot_t prot,
1532                     const void *caller)
1533 {
1534         unsigned int i, nr_pages = PAGE_ALIGN(size) >> PAGE_SHIFT;
1535         struct vm_struct *area;
1536         unsigned long p;
1537
1538         area = get_vm_area_caller(size, VM_ARM_DMA_CONSISTENT | VM_USERMAP,
1539                                   caller);
1540         if (!area)
1541                 return NULL;
1542
1543         area->pages = pages;
1544         area->nr_pages = nr_pages;
1545         p = (unsigned long)area->addr;
1546
1547         for (i = 0; i < nr_pages; i++) {
1548                 phys_addr_t phys = __pfn_to_phys(page_to_pfn(pages[i]));
1549                 if (ioremap_page_range(p, p + PAGE_SIZE, phys, prot))
1550                         goto err;
1551                 p += PAGE_SIZE;
1552         }
1553         return area->addr;
1554 err:
1555         unmap_kernel_range((unsigned long)area->addr, size);
1556         vunmap(area->addr);
1557         return NULL;
1558 }
1559
1560 /*
1561  * Create a mapping in device IO address space for specified pages
1562  */
1563 static dma_addr_t
1564 ____iommu_create_mapping(struct device *dev, dma_addr_t *req,
1565                          struct page **pages, size_t size,
1566                          struct dma_attrs *attrs)
1567 {
1568         struct dma_iommu_mapping *mapping = dev->archdata.mapping;
1569         unsigned int count = PAGE_ALIGN(size) >> PAGE_SHIFT;
1570         dma_addr_t dma_addr, iova;
1571         int i, ret = DMA_ERROR_CODE;
1572
1573         if (req)
1574                 dma_addr = __alloc_iova_at(mapping, req, size, attrs);
1575         else
1576                 dma_addr = __alloc_iova(mapping, size, attrs);
1577
1578         if (dma_addr == DMA_ERROR_CODE)
1579                 return dma_addr;
1580
1581         iova = dma_addr;
1582         for (i = 0; i < count; ) {
1583                 unsigned int next_pfn = page_to_pfn(pages[i]) + 1;
1584                 phys_addr_t phys = page_to_phys(pages[i]);
1585                 unsigned int len, j;
1586
1587                 for (j = i + 1; j < count; j++, next_pfn++)
1588                         if (page_to_pfn(pages[j]) != next_pfn)
1589                                 break;
1590
1591                 len = (j - i) << PAGE_SHIFT;
1592                 ret = iommu_map(mapping->domain, iova, phys, len, (int)attrs);
1593                 if (ret < 0)
1594                         goto fail;
1595                 iova += len;
1596                 i = j;
1597         }
1598
1599         if (iommu_get_num_pf_pages(mapping, attrs)) {
1600                 int err = iommu_map(mapping->domain, iova, iova_gap_phys,
1601                                     PF_PAGES_SIZE, (int)attrs);
1602                 if (err)
1603                         goto fail;
1604         }
1605
1606         return dma_addr;
1607 fail:
1608         iommu_unmap(mapping->domain, dma_addr, iova - dma_addr);
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         unsigned long nr_pages = PAGE_ALIGN(size) >> PAGE_SHIFT;
1754         unsigned long off = vma->vm_pgoff;
1755
1756         vma->vm_page_prot = __get_dma_pgprot(attrs, vma->vm_page_prot);
1757
1758         if (!pages)
1759                 return -ENXIO;
1760
1761         if (off >= nr_pages || (usize >> PAGE_SHIFT) > nr_pages - off)
1762                 return -ENXIO;
1763
1764         pages += off;
1765
1766         do {
1767                 int ret = vm_insert_page(vma, uaddr, *pages++);
1768                 if (ret) {
1769                         pr_err("Remapping memory failed: %d\n", ret);
1770                         return ret;
1771                 }
1772                 uaddr += PAGE_SIZE;
1773                 usize -= PAGE_SIZE;
1774         } while (usize > 0);
1775
1776         return 0;
1777 }
1778
1779 /*
1780  * free a page as defined by the above mapping.
1781  * Must not be called with IRQs disabled.
1782  */
1783 void arm_iommu_free_attrs(struct device *dev, size_t size, void *cpu_addr,
1784                           dma_addr_t handle, struct dma_attrs *attrs)
1785 {
1786         struct page **pages = __iommu_get_pages(cpu_addr, attrs);
1787         size = PAGE_ALIGN(size);
1788
1789         if (!pages) {
1790                 WARN(1, "trying to free invalid coherent area: %p\n", cpu_addr);
1791                 return;
1792         }
1793
1794         if (__in_atomic_pool(cpu_addr, size)) {
1795                 trace_dmadebug_free_attrs(dev, handle, size, NULL, cpu_addr);
1796                 __iommu_free_atomic(dev, cpu_addr, handle, size, attrs);
1797                 return;
1798         }
1799
1800         if (!dma_get_attr(DMA_ATTR_NO_KERNEL_MAPPING, attrs)) {
1801                 unmap_kernel_range((unsigned long)cpu_addr, size);
1802                 vunmap(cpu_addr);
1803         }
1804
1805         trace_dmadebug_free_attrs(dev, handle, size, pages, cpu_addr);
1806         __iommu_remove_mapping(dev, handle, size, attrs);
1807         __iommu_free_buffer(dev, pages, size, attrs);
1808 }
1809
1810 static int arm_iommu_get_sgtable(struct device *dev, struct sg_table *sgt,
1811                                  void *cpu_addr, dma_addr_t dma_addr,
1812                                  size_t size, struct dma_attrs *attrs)
1813 {
1814         unsigned int count = PAGE_ALIGN(size) >> PAGE_SHIFT;
1815         struct page **pages = __iommu_get_pages(cpu_addr, attrs);
1816
1817         if (!pages)
1818                 return -ENXIO;
1819
1820         return sg_alloc_table_from_pages(sgt, pages, count, 0, size,
1821                                          GFP_KERNEL);
1822 }
1823
1824 /*
1825  * Map a part of the scatter-gather list into contiguous io address space
1826  */
1827 static int __map_sg_chunk(struct device *dev, struct scatterlist *sg,
1828                           size_t size, dma_addr_t *handle,
1829                           enum dma_data_direction dir, struct dma_attrs *attrs,
1830                           bool is_coherent)
1831 {
1832         struct dma_iommu_mapping *mapping = dev->archdata.mapping;
1833         dma_addr_t iova, iova_base;
1834         int ret = 0;
1835         unsigned int count;
1836         struct scatterlist *s;
1837
1838         size = PAGE_ALIGN(size);
1839         *handle = DMA_ERROR_CODE;
1840
1841         iova_base = iova = __alloc_iova(mapping, size, attrs);
1842         if (iova == DMA_ERROR_CODE)
1843                 return -ENOMEM;
1844
1845         if (is_coherent || dma_get_attr(DMA_ATTR_SKIP_CPU_SYNC, attrs))
1846                 goto skip_cmaint;
1847
1848         for (count = 0, s = sg; count < (size >> PAGE_SHIFT); s = sg_next(s)) {
1849                 unsigned int len = PAGE_ALIGN(s->offset + s->length);
1850
1851                 __dma_page_cpu_to_dev(sg_page(s), s->offset, s->length, dir);
1852
1853                 count += len >> PAGE_SHIFT;
1854                 iova += len;
1855         }
1856
1857 skip_cmaint:
1858         count = size >> PAGE_SHIFT;
1859         ret = pg_iommu_map_sg(mapping, iova_base, sg, count, (int)attrs);
1860         if (WARN_ON(ret < 0))
1861                 goto fail;
1862
1863         *handle = iova_base;
1864
1865         return 0;
1866 fail:
1867         __free_iova(mapping, iova_base, size, attrs);
1868         return ret;
1869 }
1870
1871 static int __iommu_map_sg(struct device *dev, struct scatterlist *sg, int nents,
1872                      enum dma_data_direction dir, struct dma_attrs *attrs,
1873                      bool is_coherent)
1874 {
1875         struct scatterlist *s = sg, *dma = sg, *start = sg;
1876         int i, count = 0;
1877         unsigned int offset = s->offset;
1878         unsigned int size = s->offset + s->length;
1879         unsigned int max = dma_get_max_seg_size(dev);
1880
1881         for (i = 1; i < nents; i++) {
1882                 s = sg_next(s);
1883
1884                 s->dma_address = DMA_ERROR_CODE;
1885                 s->dma_length = 0;
1886
1887                 if (s->offset || (size & ~PAGE_MASK) || size + s->length > max) {
1888                         if (__map_sg_chunk(dev, start, size, &dma->dma_address,
1889                             dir, attrs, is_coherent) < 0)
1890                                 goto bad_mapping;
1891
1892                         dma->dma_address += offset;
1893                         dma->dma_length = size - offset;
1894
1895                         size = offset = s->offset;
1896                         start = s;
1897                         dma = sg_next(dma);
1898                         count += 1;
1899                 }
1900                 size += s->length;
1901         }
1902         if (__map_sg_chunk(dev, start, size, &dma->dma_address, dir, attrs,
1903                 is_coherent) < 0)
1904                 goto bad_mapping;
1905
1906         dma->dma_address += offset;
1907         dma->dma_length = size - offset;
1908
1909         trace_dmadebug_map_sg(dev, dma->dma_address, dma->dma_length,
1910                               sg_page(sg));
1911         return count+1;
1912
1913 bad_mapping:
1914         for_each_sg(sg, s, count, i)
1915                 __iommu_remove_mapping(dev, sg_dma_address(s), sg_dma_len(s),
1916                         attrs);
1917         return 0;
1918 }
1919
1920 /**
1921  * arm_coherent_iommu_map_sg - map a set of SG buffers for streaming mode DMA
1922  * @dev: valid struct device pointer
1923  * @sg: list of buffers
1924  * @nents: number of buffers to map
1925  * @dir: DMA transfer direction
1926  *
1927  * Map a set of i/o coherent buffers described by scatterlist in streaming
1928  * mode for DMA. The scatter gather list elements are merged together (if
1929  * possible) and tagged with the appropriate dma address and length. They are
1930  * obtained via sg_dma_{address,length}.
1931  */
1932 int arm_coherent_iommu_map_sg(struct device *dev, struct scatterlist *sg,
1933                 int nents, enum dma_data_direction dir, struct dma_attrs *attrs)
1934 {
1935         return __iommu_map_sg(dev, sg, nents, dir, attrs, true);
1936 }
1937
1938 /**
1939  * arm_iommu_map_sg - map a set of SG buffers for streaming mode DMA
1940  * @dev: valid struct device pointer
1941  * @sg: list of buffers
1942  * @nents: number of buffers to map
1943  * @dir: DMA transfer direction
1944  *
1945  * Map a set of buffers described by scatterlist in streaming mode for DMA.
1946  * The scatter gather list elements are merged together (if possible) and
1947  * tagged with the appropriate dma address and length. They are obtained via
1948  * sg_dma_{address,length}.
1949  */
1950 int arm_iommu_map_sg(struct device *dev, struct scatterlist *sg,
1951                 int nents, enum dma_data_direction dir, struct dma_attrs *attrs)
1952 {
1953         return __iommu_map_sg(dev, sg, nents, dir, attrs, false);
1954 }
1955
1956 static void __iommu_unmap_sg(struct device *dev, struct scatterlist *sg,
1957                 int nents, enum dma_data_direction dir, struct dma_attrs *attrs,
1958                 bool is_coherent)
1959 {
1960         struct scatterlist *s;
1961         int i;
1962
1963         for_each_sg(sg, s, nents, i) {
1964                 if (sg_dma_len(s))
1965                         __iommu_remove_mapping(dev, sg_dma_address(s),
1966                                                sg_dma_len(s), attrs);
1967                 if (!is_coherent &&
1968                     !dma_get_attr(DMA_ATTR_SKIP_CPU_SYNC, attrs))
1969                         __dma_page_dev_to_cpu(sg_page(s), s->offset,
1970                                               s->length, dir);
1971         }
1972
1973         trace_dmadebug_unmap_sg(dev, sg_dma_address(sg), sg_dma_len(sg),
1974                                 sg_page(sg));
1975 }
1976
1977 /**
1978  * arm_coherent_iommu_unmap_sg - unmap a set of SG buffers mapped by dma_map_sg
1979  * @dev: valid struct device pointer
1980  * @sg: list of buffers
1981  * @nents: number of buffers to unmap (same as was passed to dma_map_sg)
1982  * @dir: DMA transfer direction (same as was passed to dma_map_sg)
1983  *
1984  * Unmap a set of streaming mode DMA translations.  Again, CPU access
1985  * rules concerning calls here are the same as for dma_unmap_single().
1986  */
1987 void arm_coherent_iommu_unmap_sg(struct device *dev, struct scatterlist *sg,
1988                 int nents, enum dma_data_direction dir, struct dma_attrs *attrs)
1989 {
1990         __iommu_unmap_sg(dev, sg, nents, dir, attrs, true);
1991 }
1992
1993 /**
1994  * arm_iommu_unmap_sg - unmap a set of SG buffers mapped by dma_map_sg
1995  * @dev: valid struct device pointer
1996  * @sg: list of buffers
1997  * @nents: number of buffers to unmap (same as was passed to dma_map_sg)
1998  * @dir: DMA transfer direction (same as was passed to dma_map_sg)
1999  *
2000  * Unmap a set of streaming mode DMA translations.  Again, CPU access
2001  * rules concerning calls here are the same as for dma_unmap_single().
2002  */
2003 void arm_iommu_unmap_sg(struct device *dev, struct scatterlist *sg, int nents,
2004                         enum dma_data_direction dir, struct dma_attrs *attrs)
2005 {
2006         __iommu_unmap_sg(dev, sg, nents, dir, attrs, false);
2007 }
2008
2009 /**
2010  * arm_iommu_sync_sg_for_cpu
2011  * @dev: valid struct device pointer
2012  * @sg: list of buffers
2013  * @nents: number of buffers to map (returned from dma_map_sg)
2014  * @dir: DMA transfer direction (same as was passed to dma_map_sg)
2015  */
2016 void arm_iommu_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg,
2017                         int nents, enum dma_data_direction dir)
2018 {
2019         struct scatterlist *s;
2020         int i;
2021
2022         for_each_sg(sg, s, nents, i)
2023                 __dma_page_dev_to_cpu(sg_page(s), s->offset, s->length, dir);
2024
2025 }
2026
2027 /**
2028  * arm_iommu_sync_sg_for_device
2029  * @dev: valid struct device pointer
2030  * @sg: list of buffers
2031  * @nents: number of buffers to map (returned from dma_map_sg)
2032  * @dir: DMA transfer direction (same as was passed to dma_map_sg)
2033  */
2034 void arm_iommu_sync_sg_for_device(struct device *dev, struct scatterlist *sg,
2035                         int nents, enum dma_data_direction dir)
2036 {
2037         struct scatterlist *s;
2038         int i;
2039
2040         for_each_sg(sg, s, nents, i)
2041                 __dma_page_cpu_to_dev(sg_page(s), s->offset, s->length, dir);
2042 }
2043
2044
2045 /**
2046  * arm_coherent_iommu_map_page
2047  * @dev: valid struct device pointer
2048  * @page: page that buffer resides in
2049  * @offset: offset into page for start of buffer
2050  * @size: size of buffer to map
2051  * @dir: DMA transfer direction
2052  *
2053  * Coherent IOMMU aware version of arm_dma_map_page()
2054  */
2055 static dma_addr_t arm_coherent_iommu_map_page(struct device *dev, struct page *page,
2056              unsigned long offset, size_t size, enum dma_data_direction dir,
2057              struct dma_attrs *attrs)
2058 {
2059         struct dma_iommu_mapping *mapping = dev->archdata.mapping;
2060         dma_addr_t dma_addr;
2061         int ret, len = PAGE_ALIGN(size + offset);
2062
2063         dma_addr = __alloc_iova(mapping, len, attrs);
2064         if (dma_addr == DMA_ERROR_CODE)
2065                 return dma_addr;
2066
2067         ret = pg_iommu_map(mapping, dma_addr,
2068                            page_to_phys(page), len, (int)attrs);
2069         if (ret < 0)
2070                 goto fail;
2071
2072         trace_dmadebug_map_page(dev, dma_addr + offset, size, page);
2073         return dma_addr + offset;
2074 fail:
2075         __free_iova(mapping, dma_addr, len, attrs);
2076         return DMA_ERROR_CODE;
2077 }
2078
2079 /**
2080  * arm_iommu_map_page
2081  * @dev: valid struct device pointer
2082  * @page: page that buffer resides in
2083  * @offset: offset into page for start of buffer
2084  * @size: size of buffer to map
2085  * @dir: DMA transfer direction
2086  *
2087  * IOMMU aware version of arm_dma_map_page()
2088  */
2089 static dma_addr_t arm_iommu_map_page(struct device *dev, struct page *page,
2090              unsigned long offset, size_t size, enum dma_data_direction dir,
2091              struct dma_attrs *attrs)
2092 {
2093         if (!dma_get_attr(DMA_ATTR_SKIP_CPU_SYNC, attrs))
2094                 __dma_page_cpu_to_dev(page, offset, size, dir);
2095
2096         return arm_coherent_iommu_map_page(dev, page, offset, size, dir, attrs);
2097 }
2098
2099 static dma_addr_t arm_iommu_map_page_at(struct device *dev, struct page *page,
2100                  dma_addr_t dma_addr, unsigned long offset, size_t size,
2101                  enum dma_data_direction dir, struct dma_attrs *attrs)
2102 {
2103         struct dma_iommu_mapping *mapping = dev->archdata.mapping;
2104         int ret, len = PAGE_ALIGN(size + offset);
2105
2106         if (!dma_get_attr(DMA_ATTR_SKIP_CPU_SYNC, attrs))
2107                 __dma_page_cpu_to_dev(page, offset, size, dir);
2108
2109         ret = pg_iommu_map(mapping, dma_addr,
2110                            page_to_phys(page), len, (int)attrs);
2111         if (ret < 0)
2112                 return DMA_ERROR_CODE;
2113
2114         trace_dmadebug_map_page(dev, dma_addr, size, page);
2115         return dma_addr + offset;
2116 }
2117
2118 /**
2119  * arm_coherent_iommu_unmap_page
2120  * @dev: valid struct device pointer
2121  * @handle: DMA address of buffer
2122  * @size: size of buffer (same as passed to dma_map_page)
2123  * @dir: DMA transfer direction (same as passed to dma_map_page)
2124  *
2125  * Coherent IOMMU aware version of arm_dma_unmap_page()
2126  */
2127 static void arm_coherent_iommu_unmap_page(struct device *dev, dma_addr_t handle,
2128                 size_t size, enum dma_data_direction dir,
2129                 struct dma_attrs *attrs)
2130 {
2131         struct dma_iommu_mapping *mapping = dev->archdata.mapping;
2132         dma_addr_t iova = handle & PAGE_MASK;
2133         int offset = handle & ~PAGE_MASK;
2134         int len = PAGE_ALIGN(size + offset);
2135
2136         if (!iova)
2137                 return;
2138
2139         trace_dmadebug_unmap_page(dev, handle, size,
2140                   phys_to_page(iommu_iova_to_phys(mapping->domain, handle)));
2141         pg_iommu_unmap(mapping, iova, len, (int)attrs);
2142         if (!dma_get_attr(DMA_ATTR_SKIP_FREE_IOVA, attrs))
2143                 __free_iova(mapping, iova, len, attrs);
2144 }
2145
2146 /**
2147  * arm_iommu_unmap_page
2148  * @dev: valid struct device pointer
2149  * @handle: DMA address of buffer
2150  * @size: size of buffer (same as passed to dma_map_page)
2151  * @dir: DMA transfer direction (same as passed to dma_map_page)
2152  *
2153  * IOMMU aware version of arm_dma_unmap_page()
2154  */
2155 static void arm_iommu_unmap_page(struct device *dev, dma_addr_t handle,
2156                 size_t size, enum dma_data_direction dir,
2157                 struct dma_attrs *attrs)
2158 {
2159         struct dma_iommu_mapping *mapping = dev->archdata.mapping;
2160         dma_addr_t iova = handle & PAGE_MASK;
2161         struct page *page = phys_to_page(iommu_iova_to_phys(mapping->domain, iova));
2162         int offset = handle & ~PAGE_MASK;
2163         int len = PAGE_ALIGN(size + offset);
2164
2165         if (!iova)
2166                 return;
2167
2168         if (!dma_get_attr(DMA_ATTR_SKIP_CPU_SYNC, attrs))
2169                 __dma_page_dev_to_cpu(page, offset, size, dir);
2170
2171         trace_dmadebug_unmap_page(dev, handle, size,
2172                   phys_to_page(iommu_iova_to_phys(mapping->domain, handle)));
2173         pg_iommu_unmap(mapping, iova, len, (int)attrs);
2174         if (!dma_get_attr(DMA_ATTR_SKIP_FREE_IOVA, attrs))
2175                 __free_iova(mapping, iova, len, attrs);
2176 }
2177
2178 static void arm_iommu_sync_single_for_cpu(struct device *dev,
2179                 dma_addr_t handle, size_t size, enum dma_data_direction dir)
2180 {
2181         struct dma_iommu_mapping *mapping = dev->archdata.mapping;
2182         dma_addr_t iova = handle & PAGE_MASK;
2183         struct page *page = phys_to_page(iommu_iova_to_phys(mapping->domain, iova));
2184         unsigned int offset = handle & ~PAGE_MASK;
2185
2186         if (!iova)
2187                 return;
2188
2189         if (WARN_ON(!pfn_valid(page_to_pfn(page))))
2190                 return;
2191
2192         __dma_page_dev_to_cpu(page, offset, size, dir);
2193 }
2194
2195 static void arm_iommu_sync_single_for_device(struct device *dev,
2196                 dma_addr_t handle, size_t size, enum dma_data_direction dir)
2197 {
2198         struct dma_iommu_mapping *mapping = dev->archdata.mapping;
2199         dma_addr_t iova = handle & PAGE_MASK;
2200         struct page *page = phys_to_page(iommu_iova_to_phys(mapping->domain, iova));
2201         unsigned int offset = handle & ~PAGE_MASK;
2202
2203         if (!iova)
2204                 return;
2205
2206         if (WARN_ON(!pfn_valid(page_to_pfn(page))))
2207                 return;
2208
2209         __dma_page_cpu_to_dev(page, offset, size, dir);
2210 }
2211
2212 static phys_addr_t arm_iommu_iova_to_phys(struct device *dev, dma_addr_t iova)
2213 {
2214         struct dma_iommu_mapping *mapping = dev->archdata.mapping;
2215
2216         return iommu_iova_to_phys(mapping->domain, iova);
2217 }
2218
2219 struct dma_map_ops iommu_ops = {
2220         .alloc          = arm_iommu_alloc_attrs,
2221         .free           = arm_iommu_free_attrs,
2222         .mmap           = arm_iommu_mmap_attrs,
2223         .get_sgtable    = arm_iommu_get_sgtable,
2224
2225         .map_page               = arm_iommu_map_page,
2226         .map_page_at            = arm_iommu_map_page_at,
2227         .unmap_page             = arm_iommu_unmap_page,
2228         .sync_single_for_cpu    = arm_iommu_sync_single_for_cpu,
2229         .sync_single_for_device = arm_iommu_sync_single_for_device,
2230
2231         .map_sg                 = arm_iommu_map_sg,
2232         .unmap_sg               = arm_iommu_unmap_sg,
2233         .sync_sg_for_cpu        = arm_iommu_sync_sg_for_cpu,
2234         .sync_sg_for_device     = arm_iommu_sync_sg_for_device,
2235
2236         .set_dma_mask           = arm_dma_set_mask,
2237
2238         .iova_alloc             = arm_iommu_iova_alloc,
2239         .iova_alloc_at          = arm_iommu_iova_alloc_at,
2240         .iova_free              = arm_iommu_iova_free,
2241         .iova_get_free_total    = arm_iommu_iova_get_free_total,
2242         .iova_get_free_max      = arm_iommu_iova_get_free_max,
2243
2244         .iova_to_phys           = arm_iommu_iova_to_phys,
2245 };
2246
2247 struct dma_map_ops iommu_coherent_ops = {
2248         .alloc          = arm_iommu_alloc_attrs,
2249         .free           = arm_iommu_free_attrs,
2250         .mmap           = arm_iommu_mmap_attrs,
2251         .get_sgtable    = arm_iommu_get_sgtable,
2252
2253         .map_page       = arm_coherent_iommu_map_page,
2254         .unmap_page     = arm_coherent_iommu_unmap_page,
2255
2256         .map_sg         = arm_coherent_iommu_map_sg,
2257         .unmap_sg       = arm_coherent_iommu_unmap_sg,
2258
2259         .set_dma_mask   = arm_dma_set_mask,
2260 };
2261
2262 bool device_is_iommuable(struct device *dev)
2263 {
2264         return (dev->archdata.dma_ops == &iommu_ops) ||
2265                 (dev->archdata.dma_ops == &iommu_coherent_ops);
2266 }
2267
2268 static inline void __dummy_common(void)
2269 { WARN(1, "DMA API should be called after ->probe() is done.\n"); }
2270
2271 static void *__dummy_alloc_attrs(struct device *dev, size_t size,
2272                                  dma_addr_t *dma_handle, gfp_t gfp,
2273                                  struct dma_attrs *attrs)
2274 { __dummy_common(); return NULL; }
2275
2276 static void __dummy_free_attrs(struct device *dev, size_t size,
2277                                void *vaddr, dma_addr_t dma_handle,
2278                                struct dma_attrs *attrs)
2279 { __dummy_common(); }
2280
2281 static int __dummy_mmap_attrs(struct device *dev, struct vm_area_struct *vma,
2282                               void *cpu_addr, dma_addr_t dma_addr, size_t size,
2283                               struct dma_attrs *attrs)
2284 { __dummy_common(); return -ENXIO; }
2285
2286 static int __dummy_get_sgtable(struct device *dev, struct sg_table *sgt,
2287                                void *cpu_addr, dma_addr_t dma_addr,
2288                                size_t size, struct dma_attrs *attrs)
2289 { __dummy_common(); return -ENXIO; }
2290
2291 static dma_addr_t __dummy_map_page(struct device *dev, struct page *page,
2292                                    unsigned long offset, size_t size,
2293                                    enum dma_data_direction dir,
2294                                    struct dma_attrs *attrs)
2295 { __dummy_common(); return DMA_ERROR_CODE; }
2296
2297 static dma_addr_t __dummy_map_page_at(struct device *dev, struct page *page,
2298                                       dma_addr_t dma_handle,
2299                                       unsigned long offset, size_t size,
2300                                       enum dma_data_direction dir,
2301                                       struct dma_attrs *attrs)
2302 { __dummy_common(); return DMA_ERROR_CODE; }
2303
2304 static void __dummy_unmap_page(struct device *dev, dma_addr_t dma_handle,
2305                                size_t size, enum dma_data_direction dir,
2306                                struct dma_attrs *attrs)
2307 { __dummy_common(); }
2308
2309 static int __dummy_map_sg(struct device *dev, struct scatterlist *sg,
2310                           int nents, enum dma_data_direction dir,
2311                           struct dma_attrs *attrs)
2312 { __dummy_common(); return 0; }
2313
2314 static void __dummy_unmap_sg(struct device *dev,
2315                              struct scatterlist *sg, int nents,
2316                              enum dma_data_direction dir,
2317                              struct dma_attrs *attrs)
2318 { __dummy_common(); }
2319
2320 static void __dummy_sync_single_for_cpu(struct device *dev,
2321                                         dma_addr_t dma_handle, size_t size,
2322                                         enum dma_data_direction dir)
2323 { __dummy_common(); }
2324
2325 static void __dummy_sync_single_for_device(struct device *dev,
2326                                            dma_addr_t dma_handle, size_t size,
2327                                            enum dma_data_direction dir)
2328 { __dummy_common(); }
2329
2330 static void __dummy_sync_sg_for_cpu(struct device *dev,
2331                                     struct scatterlist *sg, int nents,
2332                                     enum dma_data_direction dir)
2333 { __dummy_common(); }
2334
2335 static void __dummy_sync_sg_for_device(struct device *dev,
2336                                        struct scatterlist *sg, int nents,
2337                                        enum dma_data_direction dir)
2338 { __dummy_common(); }
2339
2340 static dma_addr_t __dummy_iova_alloc(struct device *dev, size_t size,
2341                                      struct dma_attrs *attrs)
2342 { __dummy_common(); return DMA_ERROR_CODE; }
2343
2344 static dma_addr_t __dummy_iova_alloc_at(struct device *dev, dma_addr_t *dma_addr,
2345                                         size_t size, struct dma_attrs *attrs)
2346 { __dummy_common(); return DMA_ERROR_CODE; }
2347
2348 static void __dummy_iova_free(struct device *dev, dma_addr_t addr, size_t size,
2349                               struct dma_attrs *attrs)
2350 { __dummy_common(); }
2351
2352 static size_t __dummy_iova_get_free_total(struct device *dev)
2353 { __dummy_common(); return 0; }
2354
2355 static size_t __dummy_iova_get_free_max(struct device *dev)
2356 { __dummy_common(); return 0; }
2357
2358 static struct dma_map_ops __dummy_ops = {
2359         .alloc          = __dummy_alloc_attrs,
2360         .free           = __dummy_free_attrs,
2361         .mmap           = __dummy_mmap_attrs,
2362         .get_sgtable    = __dummy_get_sgtable,
2363
2364         .map_page               = __dummy_map_page,
2365         .map_page_at            = __dummy_map_page_at,
2366         .unmap_page             = __dummy_unmap_page,
2367         .sync_single_for_cpu    = __dummy_sync_single_for_cpu,
2368         .sync_single_for_device = __dummy_sync_single_for_device,
2369
2370         .map_sg                 = __dummy_map_sg,
2371         .unmap_sg               = __dummy_unmap_sg,
2372         .sync_sg_for_cpu        = __dummy_sync_sg_for_cpu,
2373         .sync_sg_for_device     = __dummy_sync_sg_for_device,
2374
2375         .iova_alloc             = __dummy_iova_alloc,
2376         .iova_alloc_at          = __dummy_iova_alloc_at,
2377         .iova_free              = __dummy_iova_free,
2378         .iova_get_free_total    = __dummy_iova_get_free_total,
2379         .iova_get_free_max      = __dummy_iova_get_free_max,
2380 };
2381
2382 void set_dummy_dma_ops(struct device *dev)
2383 {
2384         set_dma_ops(dev, &__dummy_ops);
2385 }
2386
2387 /**
2388  * arm_iommu_create_mapping
2389  * @bus: pointer to the bus holding the client device (for IOMMU calls)
2390  * @base: start address of the valid IO address space
2391  * @size: size of the valid IO address space
2392  * @order: accuracy of the IO addresses allocations
2393  *
2394  * Creates a mapping structure which holds information about used/unused
2395  * IO address ranges, which is required to perform memory allocation and
2396  * mapping with IOMMU aware functions.
2397  *
2398  * The client device need to be attached to the mapping with
2399  * arm_iommu_attach_device function.
2400  */
2401 struct dma_iommu_mapping *
2402 arm_iommu_create_mapping(struct bus_type *bus, dma_addr_t base, size_t size,
2403                          int order)
2404 {
2405         unsigned int count = size >> (PAGE_SHIFT + order);
2406         unsigned int bitmap_size = BITS_TO_LONGS(count) * sizeof(long);
2407         struct dma_iommu_mapping *mapping;
2408         int err = -ENOMEM;
2409
2410         if (!count)
2411                 return ERR_PTR(-EINVAL);
2412
2413         mapping = kzalloc(sizeof(struct dma_iommu_mapping), GFP_KERNEL);
2414         if (!mapping)
2415                 goto err;
2416
2417         mapping->bitmap = kzalloc(bitmap_size, GFP_KERNEL);
2418         if (!mapping->bitmap)
2419                 goto err2;
2420
2421         base = round_up(base, 1 << (order + PAGE_SHIFT));
2422         mapping->base = base;
2423         mapping->end = base + size;
2424         mapping->bits = BITS_PER_BYTE * bitmap_size;
2425         mapping->order = order;
2426         spin_lock_init(&mapping->lock);
2427
2428         mapping->domain = iommu_domain_alloc(bus);
2429         if (!mapping->domain)
2430                 goto err3;
2431
2432         kref_init(&mapping->kref);
2433
2434         iommu_mapping_list_add(mapping);
2435         return mapping;
2436 err3:
2437         kfree(mapping->bitmap);
2438 err2:
2439         kfree(mapping);
2440 err:
2441         return ERR_PTR(err);
2442 }
2443 EXPORT_SYMBOL_GPL(arm_iommu_create_mapping);
2444
2445 static void release_iommu_mapping(struct kref *kref)
2446 {
2447         struct dma_iommu_mapping *mapping =
2448                 container_of(kref, struct dma_iommu_mapping, kref);
2449
2450         iommu_mapping_list_del(mapping);
2451         iommu_domain_free(mapping->domain);
2452         kfree(mapping->bitmap);
2453         kfree(mapping);
2454 }
2455
2456 void arm_iommu_release_mapping(struct dma_iommu_mapping *mapping)
2457 {
2458         if (mapping)
2459                 kref_put(&mapping->kref, release_iommu_mapping);
2460 }
2461 EXPORT_SYMBOL_GPL(arm_iommu_release_mapping);
2462
2463 /**
2464  * arm_iommu_attach_device
2465  * @dev: valid struct device pointer
2466  * @mapping: io address space mapping structure (returned from
2467  *      arm_iommu_create_mapping)
2468  *
2469  * Attaches specified io address space mapping to the provided device,
2470  * this replaces the dma operations (dma_map_ops pointer) with the
2471  * IOMMU aware version. More than one client might be attached to
2472  * the same io address space mapping.
2473  */
2474 int arm_iommu_attach_device(struct device *dev,
2475                             struct dma_iommu_mapping *mapping)
2476 {
2477         int err;
2478         struct dma_map_ops *org_ops;
2479         struct dma_iommu_mapping *org_map;
2480
2481         org_ops = get_dma_ops(dev);
2482         set_dma_ops(dev, &iommu_ops);
2483
2484         org_map = dev->archdata.mapping;
2485         dev->archdata.mapping = mapping;
2486
2487         err = iommu_attach_device(mapping->domain, dev);
2488         if (err) {
2489                 set_dma_ops(dev, org_ops);
2490                 dev->archdata.mapping = org_map;
2491                 return err;
2492         }
2493
2494         kref_get(&mapping->kref);
2495
2496         pr_debug("Attached IOMMU controller to %s device.\n", dev_name(dev));
2497         return 0;
2498 }
2499 EXPORT_SYMBOL_GPL(arm_iommu_attach_device);
2500
2501 /**
2502  * arm_iommu_detach_device
2503  * @dev: valid struct device pointer
2504  *
2505  * Detaches the provided device from a previously attached map.
2506  * This voids the dma operations (dma_map_ops pointer)
2507  */
2508 void arm_iommu_detach_device(struct device *dev)
2509 {
2510         struct dma_iommu_mapping *mapping;
2511
2512         mapping = to_dma_iommu_mapping(dev);
2513         if (!mapping) {
2514                 dev_warn(dev, "Not attached\n");
2515                 return;
2516         }
2517
2518         iommu_detach_device(mapping->domain, dev);
2519         kref_put(&mapping->kref, release_iommu_mapping);
2520         mapping = NULL;
2521         set_dma_ops(dev, NULL);
2522
2523         pr_debug("Detached IOMMU controller from %s device.\n", dev_name(dev));
2524 }
2525 EXPORT_SYMBOL_GPL(arm_iommu_detach_device);
2526
2527 #endif