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