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