arch/arm/mm/dma-mapping.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  *  linux/arch/arm/mm/dma-mapping.c
   4  *
   5  *  Copyright (C) 2000-2004 Russell King
   6  *
   7  *  DMA uncached mapping support.
   8  */
   9 #include <linux/module.h>
  10 #include <linux/mm.h>
  11 #include <linux/genalloc.h>
  12 #include <linux/gfp.h>
  13 #include <linux/errno.h>
  14 #include <linux/list.h>
  15 #include <linux/init.h>
  16 #include <linux/device.h>
  17 #include <linux/dma-direct.h>
  18 #include <linux/dma-map-ops.h>
  19 #include <linux/highmem.h>
  20 #include <linux/memblock.h>
  21 #include <linux/slab.h>
  22 #include <linux/iommu.h>
  23 #include <linux/io.h>
  24 #include <linux/vmalloc.h>
  25 #include <linux/sizes.h>
  26 #include <linux/cma.h>
  27
  28 #include <asm/memory.h>
  29 #include <asm/highmem.h>
  30 #include <asm/cacheflush.h>
  31 #include <asm/tlbflush.h>
  32 #include <asm/mach/arch.h>
  33 #include <asm/dma-iommu.h>
  34 #include <asm/mach/map.h>
  35 #include <asm/system_info.h>
  36 #include <asm/xen/xen-ops.h>
  37
  38 #include "dma.h"
  39 #include "mm.h"
  40
  41 struct arm_dma_alloc_args {
  42         struct device *dev;
  43         size_t size;
  44         gfp_t gfp;
  45         pgprot_t prot;
  46         const void *caller;
  47         bool want_vaddr;
  48         int coherent_flag;
  49 };
  50
  51 struct arm_dma_free_args {
  52         struct device *dev;
  53         size_t size;
  54         void *cpu_addr;
  55         struct page *page;
  56         bool want_vaddr;
  57 };
  58
  59 #define NORMAL      0
  60 #define COHERENT    1
  61
  62 struct arm_dma_allocator {
  63         void *(*alloc)(struct arm_dma_alloc_args *args,
  64                        struct page **ret_page);
  65         void (*free)(struct arm_dma_free_args *args);
  66 };
  67
  68 struct arm_dma_buffer {
  69         struct list_head list;
  70         void *virt;
  71         struct arm_dma_allocator *allocator;
  72 };
  73
  74 static LIST_HEAD(arm_dma_bufs);
  75 static DEFINE_SPINLOCK(arm_dma_bufs_lock);
  76
  77 static struct arm_dma_buffer *arm_dma_buffer_find(void *virt)
  78 {
  79         struct arm_dma_buffer *buf, *found = NULL;
  80         unsigned long flags;
  81
  82         spin_lock_irqsave(&arm_dma_bufs_lock, flags);
  83         list_for_each_entry(buf, &arm_dma_bufs, list) {
  84                 if (buf->virt == virt) {
  85                         list_del(&buf->list);
  86                         found = buf;
  87                         break;
  88                 }
  89         }
  90         spin_unlock_irqrestore(&arm_dma_bufs_lock, flags);
  91         return found;
  92 }
  93
  94 /*
  95  * The DMA API is built upon the notion of "buffer ownership".  A buffer
  96  * is either exclusively owned by the CPU (and therefore may be accessed
  97  * by it) or exclusively owned by the DMA device.  These helper functions
  98  * represent the transitions between these two ownership states.
  99  *
 100  * Note, however, that on later ARMs, this notion does not work due to
 101  * speculative prefetches.  We model our approach on the assumption that
 102  * the CPU does do speculative prefetches, which means we clean caches
 103  * before transfers and delay cache invalidation until transfer completion.
 104  *
 105  */
 106
 107 static void __dma_clear_buffer(struct page *page, size_t size, int coherent_flag)
 108 {
 109         /*
 110          * Ensure that the allocated pages are zeroed, and that any data
 111          * lurking in the kernel direct-mapped region is invalidated.
 112          */
 113         if (PageHighMem(page)) {
 114                 phys_addr_t base = __pfn_to_phys(page_to_pfn(page));
 115                 phys_addr_t end = base + size;
 116                 while (size > 0) {
 117                         void *ptr = kmap_atomic(page);
 118                         memset(ptr, 0, PAGE_SIZE);
 119                         if (coherent_flag != COHERENT)
 120                                 dmac_flush_range(ptr, ptr + PAGE_SIZE);
 121                         kunmap_atomic(ptr);
 122                         page++;
 123                         size -= PAGE_SIZE;
 124                 }
 125                 if (coherent_flag != COHERENT)
 126                         outer_flush_range(base, end);
 127         } else {
 128                 void *ptr = page_address(page);
 129                 memset(ptr, 0, size);
 130                 if (coherent_flag != COHERENT) {
 131                         dmac_flush_range(ptr, ptr + size);
 132                         outer_flush_range(__pa(ptr), __pa(ptr) + size);
 133                 }
 134         }
 135 }
 136
 137 /*
 138  * Allocate a DMA buffer for 'dev' of size 'size' using the
 139  * specified gfp mask.  Note that 'size' must be page aligned.
 140  */
 141 static struct page *__dma_alloc_buffer(struct device *dev, size_t size,
 142                                        gfp_t gfp, int coherent_flag)
 143 {
 144         unsigned long order = get_order(size);
 145         struct page *page, *p, *e;
 146
 147         page = alloc_pages(gfp, order);
 148         if (!page)
 149                 return NULL;
 150
 151         /*
 152          * Now split the huge page and free the excess pages
 153          */
 154         split_page(page, order);
 155         for (p = page + (size >> PAGE_SHIFT), e = page + (1 << order); p < e; p++)
 156                 __free_page(p);
 157
 158         __dma_clear_buffer(page, size, coherent_flag);
 159
 160         return page;
 161 }
 162
 163 /*
 164  * Free a DMA buffer.  'size' must be page aligned.
 165  */
 166 static void __dma_free_buffer(struct page *page, size_t size)
 167 {
 168         struct page *e = page + (size >> PAGE_SHIFT);
 169
 170         while (page < e) {
 171                 __free_page(page);
 172                 page++;
 173         }
 174 }
 175
 176 static void *__alloc_from_contiguous(struct device *dev, size_t size,
 177                                      pgprot_t prot, struct page **ret_page,
 178                                      const void *caller, bool want_vaddr,
 179                                      int coherent_flag, gfp_t gfp);
 180
 181 static void *__alloc_remap_buffer(struct device *dev, size_t size, gfp_t gfp,
 182                                  pgprot_t prot, struct page **ret_page,
 183                                  const void *caller, bool want_vaddr);
 184
 185 #define DEFAULT_DMA_COHERENT_POOL_SIZE  SZ_256K
 186 static struct gen_pool *atomic_pool __ro_after_init;
 187
 188 static size_t atomic_pool_size __initdata = DEFAULT_DMA_COHERENT_POOL_SIZE;
 189
 190 static int __init early_coherent_pool(char *p)
 191 {
 192         atomic_pool_size = memparse(p, &p);
 193         return 0;
 194 }
 195 early_param("coherent_pool", early_coherent_pool);
 196
 197 /*
 198  * Initialise the coherent pool for atomic allocations.
 199  */
 200 static int __init atomic_pool_init(void)
 201 {
 202         pgprot_t prot = pgprot_dmacoherent(PAGE_KERNEL);
 203         gfp_t gfp = GFP_KERNEL | GFP_DMA;
 204         struct page *page;
 205         void *ptr;
 206
 207         atomic_pool = gen_pool_create(PAGE_SHIFT, -1);
 208         if (!atomic_pool)
 209                 goto out;
 210         /*
 211          * The atomic pool is only used for non-coherent allocations
 212          * so we must pass NORMAL for coherent_flag.
 213          */
 214         if (dev_get_cma_area(NULL))
 215                 ptr = __alloc_from_contiguous(NULL, atomic_pool_size, prot,
 216                                       &page, atomic_pool_init, true, NORMAL,
 217                                       GFP_KERNEL);
 218         else
 219                 ptr = __alloc_remap_buffer(NULL, atomic_pool_size, gfp, prot,
 220                                            &page, atomic_pool_init, true);
 221         if (ptr) {
 222                 int ret;
 223
 224                 ret = gen_pool_add_virt(atomic_pool, (unsigned long)ptr,
 225                                         page_to_phys(page),
 226                                         atomic_pool_size, -1);
 227                 if (ret)
 228                         goto destroy_genpool;
 229
 230                 gen_pool_set_algo(atomic_pool,
 231                                 gen_pool_first_fit_order_align,
 232                                 NULL);
 233                 pr_info("DMA: preallocated %zu KiB pool for atomic coherent allocations\n",
 234                        atomic_pool_size / 1024);
 235                 return 0;
 236         }
 237
 238 destroy_genpool:
 239         gen_pool_destroy(atomic_pool);
 240         atomic_pool = NULL;
 241 out:
 242         pr_err("DMA: failed to allocate %zu KiB pool for atomic coherent allocation\n",
 243                atomic_pool_size / 1024);
 244         return -ENOMEM;
 245 }
 246 /*
 247  * CMA is activated by core_initcall, so we must be called after it.
 248  */
 249 postcore_initcall(atomic_pool_init);
 250
 251 #ifdef CONFIG_CMA_AREAS
 252 struct dma_contig_early_reserve {
 253         phys_addr_t base;
 254         unsigned long size;
 255 };
 256
 257 static struct dma_contig_early_reserve dma_mmu_remap[MAX_CMA_AREAS] __initdata;
 258
 259 static int dma_mmu_remap_num __initdata;
 260
 261 void __init dma_contiguous_early_fixup(phys_addr_t base, unsigned long size)
 262 {
 263         dma_mmu_remap[dma_mmu_remap_num].base = base;
 264         dma_mmu_remap[dma_mmu_remap_num].size = size;
 265         dma_mmu_remap_num++;
 266 }
 267
 268 void __init dma_contiguous_remap(void)
 269 {
 270         int i;
 271         for (i = 0; i < dma_mmu_remap_num; i++) {
 272                 phys_addr_t start = dma_mmu_remap[i].base;
 273                 phys_addr_t end = start + dma_mmu_remap[i].size;
 274                 struct map_desc map;
 275                 unsigned long addr;
 276
 277                 if (end > arm_lowmem_limit)
 278                         end = arm_lowmem_limit;
 279                 if (start >= end)
 280                         continue;
 281
 282                 map.pfn = __phys_to_pfn(start);
 283                 map.virtual = __phys_to_virt(start);
 284                 map.length = end - start;
 285                 map.type = MT_MEMORY_DMA_READY;
 286
 287                 /*
 288                  * Clear previous low-memory mapping to ensure that the
 289                  * TLB does not see any conflicting entries, then flush
 290                  * the TLB of the old entries before creating new mappings.
 291                  *
 292                  * This ensures that any speculatively loaded TLB entries
 293                  * (even though they may be rare) can not cause any problems,
 294                  * and ensures that this code is architecturally compliant.
 295                  */
 296                 for (addr = __phys_to_virt(start); addr < __phys_to_virt(end);
 297                      addr += PMD_SIZE)
 298                         pmd_clear(pmd_off_k(addr));
 299
 300                 flush_tlb_kernel_range(__phys_to_virt(start),
 301                                        __phys_to_virt(end));
 302
 303                 iotable_init(&map, 1);
 304         }
 305 }
 306 #endif
 307
 308 static int __dma_update_pte(pte_t *pte, unsigned long addr, void *data)
 309 {
 310         struct page *page = virt_to_page(addr);
 311         pgprot_t prot = *(pgprot_t *)data;
 312
 313         set_pte_ext(pte, mk_pte(page, prot), 0);
 314         return 0;
 315 }
 316
 317 static void __dma_remap(struct page *page, size_t size, pgprot_t prot)
 318 {
 319         unsigned long start = (unsigned long) page_address(page);
 320         unsigned end = start + size;
 321
 322         apply_to_page_range(&init_mm, start, size, __dma_update_pte, &prot);
 323         flush_tlb_kernel_range(start, end);
 324 }
 325
 326 static void *__alloc_remap_buffer(struct device *dev, size_t size, gfp_t gfp,
 327                                  pgprot_t prot, struct page **ret_page,
 328                                  const void *caller, bool want_vaddr)
 329 {
 330         struct page *page;
 331         void *ptr = NULL;
 332         /*
 333          * __alloc_remap_buffer is only called when the device is
 334          * non-coherent
 335          */
 336         page = __dma_alloc_buffer(dev, size, gfp, NORMAL);
 337         if (!page)
 338                 return NULL;
 339         if (!want_vaddr)
 340                 goto out;
 341
 342         ptr = dma_common_contiguous_remap(page, size, prot, caller);
 343         if (!ptr) {
 344                 __dma_free_buffer(page, size);
 345                 return NULL;
 346         }
 347
 348  out:
 349         *ret_page = page;
 350         return ptr;
 351 }
 352
 353 static void *__alloc_from_pool(size_t size, struct page **ret_page)
 354 {
 355         unsigned long val;
 356         void *ptr = NULL;
 357
 358         if (!atomic_pool) {
 359                 WARN(1, "coherent pool not initialised!\n");
 360                 return NULL;
 361         }
 362
 363         val = gen_pool_alloc(atomic_pool, size);
 364         if (val) {
 365                 phys_addr_t phys = gen_pool_virt_to_phys(atomic_pool, val);
 366
 367                 *ret_page = phys_to_page(phys);
 368                 ptr = (void *)val;
 369         }
 370
 371         return ptr;
 372 }
 373
 374 static bool __in_atomic_pool(void *start, size_t size)
 375 {
 376         return gen_pool_has_addr(atomic_pool, (unsigned long)start, size);
 377 }
 378
 379 static int __free_from_pool(void *start, size_t size)
 380 {
 381         if (!__in_atomic_pool(start, size))
 382                 return 0;
 383
 384         gen_pool_free(atomic_pool, (unsigned long)start, size);
 385
 386         return 1;
 387 }
 388
 389 static void *__alloc_from_contiguous(struct device *dev, size_t size,
 390                                      pgprot_t prot, struct page **ret_page,
 391                                      const void *caller, bool want_vaddr,
 392                                      int coherent_flag, gfp_t gfp)
 393 {
 394         unsigned long order = get_order(size);
 395         size_t count = size >> PAGE_SHIFT;
 396         struct page *page;
 397         void *ptr = NULL;
 398
 399         page = dma_alloc_from_contiguous(dev, count, order, gfp & __GFP_NOWARN);
 400         if (!page)
 401                 return NULL;
 402
 403         __dma_clear_buffer(page, size, coherent_flag);
 404
 405         if (!want_vaddr)
 406                 goto out;
 407
 408         if (PageHighMem(page)) {
 409                 ptr = dma_common_contiguous_remap(page, size, prot, caller);
 410                 if (!ptr) {
 411                         dma_release_from_contiguous(dev, page, count);
 412                         return NULL;
 413                 }
 414         } else {
 415                 __dma_remap(page, size, prot);
 416                 ptr = page_address(page);
 417         }
 418
 419  out:
 420         *ret_page = page;
 421         return ptr;
 422 }
 423
 424 static void __free_from_contiguous(struct device *dev, struct page *page,
 425                                    void *cpu_addr, size_t size, bool want_vaddr)
 426 {
 427         if (want_vaddr) {
 428                 if (PageHighMem(page))
 429                         dma_common_free_remap(cpu_addr, size);
 430                 else
 431                         __dma_remap(page, size, PAGE_KERNEL);
 432         }
 433         dma_release_from_contiguous(dev, page, size >> PAGE_SHIFT);
 434 }
 435
 436 static inline pgprot_t __get_dma_pgprot(unsigned long attrs, pgprot_t prot)
 437 {
 438         prot = (attrs & DMA_ATTR_WRITE_COMBINE) ?
 439                         pgprot_writecombine(prot) :
 440                         pgprot_dmacoherent(prot);
 441         return prot;
 442 }
 443
 444 static void *__alloc_simple_buffer(struct device *dev, size_t size, gfp_t gfp,
 445                                    struct page **ret_page)
 446 {
 447         struct page *page;
 448         /* __alloc_simple_buffer is only called when the device is coherent */
 449         page = __dma_alloc_buffer(dev, size, gfp, COHERENT);
 450         if (!page)
 451                 return NULL;
 452
 453         *ret_page = page;
 454         return page_address(page);
 455 }
 456
 457 static void *simple_allocator_alloc(struct arm_dma_alloc_args *args,
 458                                     struct page **ret_page)
 459 {
 460         return __alloc_simple_buffer(args->dev, args->size, args->gfp,
 461                                      ret_page);
 462 }
 463
 464 static void simple_allocator_free(struct arm_dma_free_args *args)
 465 {
 466         __dma_free_buffer(args->page, args->size);
 467 }
 468
 469 static struct arm_dma_allocator simple_allocator = {
 470         .alloc = simple_allocator_alloc,
 471         .free = simple_allocator_free,
 472 };
 473
 474 static void *cma_allocator_alloc(struct arm_dma_alloc_args *args,
 475                                  struct page **ret_page)
 476 {
 477         return __alloc_from_contiguous(args->dev, args->size, args->prot,
 478                                        ret_page, args->caller,
 479                                        args->want_vaddr, args->coherent_flag,
 480                                        args->gfp);
 481 }
 482
 483 static void cma_allocator_free(struct arm_dma_free_args *args)
 484 {
 485         __free_from_contiguous(args->dev, args->page, args->cpu_addr,
 486                                args->size, args->want_vaddr);
 487 }
 488
 489 static struct arm_dma_allocator cma_allocator = {
 490         .alloc = cma_allocator_alloc,
 491         .free = cma_allocator_free,
 492 };
 493
 494 static void *pool_allocator_alloc(struct arm_dma_alloc_args *args,
 495                                   struct page **ret_page)
 496 {
 497         return __alloc_from_pool(args->size, ret_page);
 498 }
 499
 500 static void pool_allocator_free(struct arm_dma_free_args *args)
 501 {
 502         __free_from_pool(args->cpu_addr, args->size);
 503 }
 504
 505 static struct arm_dma_allocator pool_allocator = {
 506         .alloc = pool_allocator_alloc,
 507         .free = pool_allocator_free,
 508 };
 509
 510 static void *remap_allocator_alloc(struct arm_dma_alloc_args *args,
 511                                    struct page **ret_page)
 512 {
 513         return __alloc_remap_buffer(args->dev, args->size, args->gfp,
 514                                     args->prot, ret_page, args->caller,
 515                                     args->want_vaddr);
 516 }
 517
 518 static void remap_allocator_free(struct arm_dma_free_args *args)
 519 {
 520         if (args->want_vaddr)
 521                 dma_common_free_remap(args->cpu_addr, args->size);
 522
 523         __dma_free_buffer(args->page, args->size);
 524 }
 525
 526 static struct arm_dma_allocator remap_allocator = {
 527         .alloc = remap_allocator_alloc,
 528         .free = remap_allocator_free,
 529 };
 530
 531 static void *__dma_alloc(struct device *dev, size_t size, dma_addr_t *handle,
 532                          gfp_t gfp, pgprot_t prot, bool is_coherent,
 533                          unsigned long attrs, const void *caller)
 534 {
 535         u64 mask = min_not_zero(dev->coherent_dma_mask, dev->bus_dma_limit);
 536         struct page *page = NULL;
 537         void *addr;
 538         bool allowblock, cma;
 539         struct arm_dma_buffer *buf;
 540         struct arm_dma_alloc_args args = {
 541                 .dev = dev,
 542                 .size = PAGE_ALIGN(size),
 543                 .gfp = gfp,
 544                 .prot = prot,
 545                 .caller = caller,
 546                 .want_vaddr = ((attrs & DMA_ATTR_NO_KERNEL_MAPPING) == 0),
 547                 .coherent_flag = is_coherent ? COHERENT : NORMAL,
 548         };
 549
 550 #ifdef CONFIG_DMA_API_DEBUG
 551         u64 limit = (mask + 1) & ~mask;
 552         if (limit && size >= limit) {
 553                 dev_warn(dev, "coherent allocation too big (requested %#x mask %#llx)\n",
 554                         size, mask);
 555                 return NULL;
 556         }
 557 #endif
 558
 559         buf = kzalloc(sizeof(*buf),
 560                       gfp & ~(__GFP_DMA | __GFP_DMA32 | __GFP_HIGHMEM));
 561         if (!buf)
 562                 return NULL;
 563
 564         if (mask < 0xffffffffULL)
 565                 gfp |= GFP_DMA;
 566
 567         /*
 568          * Following is a work-around (a.k.a. hack) to prevent pages
 569          * with __GFP_COMP being passed to split_page() which cannot
 570          * handle them.  The real problem is that this flag probably
 571          * should be 0 on ARM as it is not supported on this
 572          * platform; see CONFIG_HUGETLBFS.
 573          */
 574         gfp &= ~(__GFP_COMP);
 575         args.gfp = gfp;
 576
 577         *handle = DMA_MAPPING_ERROR;
 578         allowblock = gfpflags_allow_blocking(gfp);
 579         cma = allowblock ? dev_get_cma_area(dev) : NULL;
 580
 581         if (cma)
 582                 buf->allocator = &cma_allocator;
 583         else if (is_coherent)
 584                 buf->allocator = &simple_allocator;
 585         else if (allowblock)
 586                 buf->allocator = &remap_allocator;
 587         else
 588                 buf->allocator = &pool_allocator;
 589
 590         addr = buf->allocator->alloc(&args, &page);
 591
 592         if (page) {
 593                 unsigned long flags;
 594
 595                 *handle = phys_to_dma(dev, page_to_phys(page));
 596                 buf->virt = args.want_vaddr ? addr : page;
 597
 598                 spin_lock_irqsave(&arm_dma_bufs_lock, flags);
 599                 list_add(&buf->list, &arm_dma_bufs);
 600                 spin_unlock_irqrestore(&arm_dma_bufs_lock, flags);
 601         } else {
 602                 kfree(buf);
 603         }
 604
 605         return args.want_vaddr ? addr : page;
 606 }
 607
 608 /*
 609  * Free a buffer as defined by the above mapping.
 610  */
 611 static void __arm_dma_free(struct device *dev, size_t size, void *cpu_addr,
 612                            dma_addr_t handle, unsigned long attrs,
 613                            bool is_coherent)
 614 {
 615         struct page *page = phys_to_page(dma_to_phys(dev, handle));
 616         struct arm_dma_buffer *buf;
 617         struct arm_dma_free_args args = {
 618                 .dev = dev,
 619                 .size = PAGE_ALIGN(size),
 620                 .cpu_addr = cpu_addr,
 621                 .page = page,
 622                 .want_vaddr = ((attrs & DMA_ATTR_NO_KERNEL_MAPPING) == 0),
 623         };
 624
 625         buf = arm_dma_buffer_find(cpu_addr);
 626         if (WARN(!buf, "Freeing invalid buffer %p\n", cpu_addr))
 627                 return;
 628
 629         buf->allocator->free(&args);
 630         kfree(buf);
 631 }
 632
 633 static void dma_cache_maint_page(struct page *page, unsigned long offset,
 634         size_t size, enum dma_data_direction dir,
 635         void (*op)(const void *, size_t, int))
 636 {
 637         unsigned long pfn;
 638         size_t left = size;
 639
 640         pfn = page_to_pfn(page) + offset / PAGE_SIZE;
 641         offset %= PAGE_SIZE;
 642
 643         /*
 644          * A single sg entry may refer to multiple physically contiguous
 645          * pages.  But we still need to process highmem pages individually.
 646          * If highmem is not configured then the bulk of this loop gets
 647          * optimized out.
 648          */
 649         do {
 650                 size_t len = left;
 651                 void *vaddr;
 652
 653                 page = pfn_to_page(pfn);
 654
 655                 if (PageHighMem(page)) {
 656                         if (len + offset > PAGE_SIZE)
 657                                 len = PAGE_SIZE - offset;
 658
 659                         if (cache_is_vipt_nonaliasing()) {
 660                                 vaddr = kmap_atomic(page);
 661                                 op(vaddr + offset, len, dir);
 662                                 kunmap_atomic(vaddr);
 663                         } else {
 664                                 vaddr = kmap_high_get(page);
 665                                 if (vaddr) {
 666                                         op(vaddr + offset, len, dir);
 667                                         kunmap_high(page);
 668                                 }
 669                         }
 670                 } else {
 671                         vaddr = page_address(page) + offset;
 672                         op(vaddr, len, dir);
 673                 }
 674                 offset = 0;
 675                 pfn++;
 676                 left -= len;
 677         } while (left);
 678 }
 679
 680 /*
 681  * Make an area consistent for devices.
 682  * Note: Drivers should NOT use this function directly.
 683  * Use the driver DMA support - see dma-mapping.h (dma_sync_*)
 684  */
 685 static void __dma_page_cpu_to_dev(struct page *page, unsigned long off,
 686         size_t size, enum dma_data_direction dir)
 687 {
 688         phys_addr_t paddr;
 689
 690         dma_cache_maint_page(page, off, size, dir, dmac_map_area);
 691
 692         paddr = page_to_phys(page) + off;
 693         if (dir == DMA_FROM_DEVICE) {
 694                 outer_inv_range(paddr, paddr + size);
 695         } else {
 696                 outer_clean_range(paddr, paddr + size);
 697         }
 698         /* FIXME: non-speculating: flush on bidirectional mappings? */
 699 }
 700
 701 static void __dma_page_dev_to_cpu(struct page *page, unsigned long off,
 702         size_t size, enum dma_data_direction dir)
 703 {
 704         phys_addr_t paddr = page_to_phys(page) + off;
 705
 706         /* FIXME: non-speculating: not required */
 707         /* in any case, don't bother invalidating if DMA to device */
 708         if (dir != DMA_TO_DEVICE) {
 709                 outer_inv_range(paddr, paddr + size);
 710
 711                 dma_cache_maint_page(page, off, size, dir, dmac_unmap_area);
 712         }
 713
 714         /*
 715          * Mark the D-cache clean for these pages to avoid extra flushing.
 716          */
 717         if (dir != DMA_TO_DEVICE && size >= PAGE_SIZE) {
 718                 unsigned long pfn;
 719                 size_t left = size;
 720
 721                 pfn = page_to_pfn(page) + off / PAGE_SIZE;
 722                 off %= PAGE_SIZE;
 723                 if (off) {
 724                         pfn++;
 725                         left -= PAGE_SIZE - off;
 726                 }
 727                 while (left >= PAGE_SIZE) {
 728                         page = pfn_to_page(pfn++);
 729                         set_bit(PG_dcache_clean, &page->flags);
 730                         left -= PAGE_SIZE;
 731                 }
 732         }
 733 }
 734
 735 #ifdef CONFIG_ARM_DMA_USE_IOMMU
 736
 737 static int __dma_info_to_prot(enum dma_data_direction dir, unsigned long attrs)
 738 {
 739         int prot = 0;
 740
 741         if (attrs & DMA_ATTR_PRIVILEGED)
 742                 prot |= IOMMU_PRIV;
 743
 744         switch (dir) {
 745         case DMA_BIDIRECTIONAL:
 746                 return prot | IOMMU_READ | IOMMU_WRITE;
 747         case DMA_TO_DEVICE:
 748                 return prot | IOMMU_READ;
 749         case DMA_FROM_DEVICE:
 750                 return prot | IOMMU_WRITE;
 751         default:
 752                 return prot;
 753         }
 754 }
 755
 756 /* IOMMU */
 757
 758 static int extend_iommu_mapping(struct dma_iommu_mapping *mapping);
 759
 760 static inline dma_addr_t __alloc_iova(struct dma_iommu_mapping *mapping,
 761                                       size_t size)
 762 {
 763         unsigned int order = get_order(size);
 764         unsigned int align = 0;
 765         unsigned int count, start;
 766         size_t mapping_size = mapping->bits << PAGE_SHIFT;
 767         unsigned long flags;
 768         dma_addr_t iova;
 769         int i;
 770
 771         if (order > CONFIG_ARM_DMA_IOMMU_ALIGNMENT)
 772                 order = CONFIG_ARM_DMA_IOMMU_ALIGNMENT;
 773
 774         count = PAGE_ALIGN(size) >> PAGE_SHIFT;
 775         align = (1 << order) - 1;
 776
 777         spin_lock_irqsave(&mapping->lock, flags);
 778         for (i = 0; i < mapping->nr_bitmaps; i++) {
 779                 start = bitmap_find_next_zero_area(mapping->bitmaps[i],
 780                                 mapping->bits, 0, count, align);
 781
 782                 if (start > mapping->bits)
 783                         continue;
 784
 785                 bitmap_set(mapping->bitmaps[i], start, count);
 786                 break;
 787         }
 788
 789         /*
 790          * No unused range found. Try to extend the existing mapping
 791          * and perform a second attempt to reserve an IO virtual
 792          * address range of size bytes.
 793          */
 794         if (i == mapping->nr_bitmaps) {
 795                 if (extend_iommu_mapping(mapping)) {
 796                         spin_unlock_irqrestore(&mapping->lock, flags);
 797                         return DMA_MAPPING_ERROR;
 798                 }
 799
 800                 start = bitmap_find_next_zero_area(mapping->bitmaps[i],
 801                                 mapping->bits, 0, count, align);
 802
 803                 if (start > mapping->bits) {
 804                         spin_unlock_irqrestore(&mapping->lock, flags);
 805                         return DMA_MAPPING_ERROR;
 806                 }
 807
 808                 bitmap_set(mapping->bitmaps[i], start, count);
 809         }
 810         spin_unlock_irqrestore(&mapping->lock, flags);
 811
 812         iova = mapping->base + (mapping_size * i);
 813         iova += start << PAGE_SHIFT;
 814
 815         return iova;
 816 }
 817
 818 static inline void __free_iova(struct dma_iommu_mapping *mapping,
 819                                dma_addr_t addr, size_t size)
 820 {
 821         unsigned int start, count;
 822         size_t mapping_size = mapping->bits << PAGE_SHIFT;
 823         unsigned long flags;
 824         dma_addr_t bitmap_base;
 825         u32 bitmap_index;
 826
 827         if (!size)
 828                 return;
 829
 830         bitmap_index = (u32) (addr - mapping->base) / (u32) mapping_size;
 831         BUG_ON(addr < mapping->base || bitmap_index > mapping->extensions);
 832
 833         bitmap_base = mapping->base + mapping_size * bitmap_index;
 834
 835         start = (addr - bitmap_base) >> PAGE_SHIFT;
 836
 837         if (addr + size > bitmap_base + mapping_size) {
 838                 /*
 839                  * The address range to be freed reaches into the iova
 840                  * range of the next bitmap. This should not happen as
 841                  * we don't allow this in __alloc_iova (at the
 842                  * moment).
 843                  */
 844                 BUG();
 845         } else
 846                 count = size >> PAGE_SHIFT;
 847
 848         spin_lock_irqsave(&mapping->lock, flags);
 849         bitmap_clear(mapping->bitmaps[bitmap_index], start, count);
 850         spin_unlock_irqrestore(&mapping->lock, flags);
 851 }
 852
 853 /* We'll try 2M, 1M, 64K, and finally 4K; array must end with 0! */
 854 static const int iommu_order_array[] = { 9, 8, 4, 0 };
 855
 856 static struct page **__iommu_alloc_buffer(struct device *dev, size_t size,
 857                                           gfp_t gfp, unsigned long attrs,
 858                                           int coherent_flag)
 859 {
 860         struct page **pages;
 861         int count = size >> PAGE_SHIFT;
 862         int array_size = count * sizeof(struct page *);
 863         int i = 0;
 864         int order_idx = 0;
 865
 866         if (array_size <= PAGE_SIZE)
 867                 pages = kzalloc(array_size, GFP_KERNEL);
 868         else
 869                 pages = vzalloc(array_size);
 870         if (!pages)
 871                 return NULL;
 872
 873         if (attrs & DMA_ATTR_FORCE_CONTIGUOUS)
 874         {
 875                 unsigned long order = get_order(size);
 876                 struct page *page;
 877
 878                 page = dma_alloc_from_contiguous(dev, count, order,
 879                                                  gfp & __GFP_NOWARN);
 880                 if (!page)
 881                         goto error;
 882
 883                 __dma_clear_buffer(page, size, coherent_flag);
 884
 885                 for (i = 0; i < count; i++)
 886                         pages[i] = page + i;
 887
 888                 return pages;
 889         }
 890
 891         /* Go straight to 4K chunks if caller says it's OK. */
 892         if (attrs & DMA_ATTR_ALLOC_SINGLE_PAGES)
 893                 order_idx = ARRAY_SIZE(iommu_order_array) - 1;
 894
 895         /*
 896          * IOMMU can map any pages, so himem can also be used here
 897          */
 898         gfp |= __GFP_NOWARN | __GFP_HIGHMEM;
 899
 900         while (count) {
 901                 int j, order;
 902
 903                 order = iommu_order_array[order_idx];
 904
 905                 /* Drop down when we get small */
 906                 if (__fls(count) < order) {
 907                         order_idx++;
 908                         continue;
 909                 }
 910
 911                 if (order) {
 912                         /* See if it's easy to allocate a high-order chunk */
 913                         pages[i] = alloc_pages(gfp | __GFP_NORETRY, order);
 914
 915                         /* Go down a notch at first sign of pressure */
 916                         if (!pages[i]) {
 917                                 order_idx++;
 918                                 continue;
 919                         }
 920                 } else {
 921                         pages[i] = alloc_pages(gfp, 0);
 922                         if (!pages[i])
 923                                 goto error;
 924                 }
 925
 926                 if (order) {
 927                         split_page(pages[i], order);
 928                         j = 1 << order;
 929                         while (--j)
 930                                 pages[i + j] = pages[i] + j;
 931                 }
 932
 933                 __dma_clear_buffer(pages[i], PAGE_SIZE << order, coherent_flag);
 934                 i += 1 << order;
 935                 count -= 1 << order;
 936         }
 937
 938         return pages;
 939 error:
 940         while (i--)
 941                 if (pages[i])
 942                         __free_pages(pages[i], 0);
 943         kvfree(pages);
 944         return NULL;
 945 }
 946
 947 static int __iommu_free_buffer(struct device *dev, struct page **pages,
 948                                size_t size, unsigned long attrs)
 949 {
 950         int count = size >> PAGE_SHIFT;
 951         int i;
 952
 953         if (attrs & DMA_ATTR_FORCE_CONTIGUOUS) {
 954                 dma_release_from_contiguous(dev, pages[0], count);
 955         } else {
 956                 for (i = 0; i < count; i++)
 957                         if (pages[i])
 958                                 __free_pages(pages[i], 0);
 959         }
 960
 961         kvfree(pages);
 962         return 0;
 963 }
 964
 965 /*
 966  * Create a mapping in device IO address space for specified pages
 967  */
 968 static dma_addr_t
 969 __iommu_create_mapping(struct device *dev, struct page **pages, size_t size,
 970                        unsigned long attrs)
 971 {
 972         struct dma_iommu_mapping *mapping = to_dma_iommu_mapping(dev);
 973         unsigned int count = PAGE_ALIGN(size) >> PAGE_SHIFT;
 974         dma_addr_t dma_addr, iova;
 975         int i;
 976
 977         dma_addr = __alloc_iova(mapping, size);
 978         if (dma_addr == DMA_MAPPING_ERROR)
 979                 return dma_addr;
 980
 981         iova = dma_addr;
 982         for (i = 0; i < count; ) {
 983                 int ret;
 984
 985                 unsigned int next_pfn = page_to_pfn(pages[i]) + 1;
 986                 phys_addr_t phys = page_to_phys(pages[i]);
 987                 unsigned int len, j;
 988
 989                 for (j = i + 1; j < count; j++, next_pfn++)
 990                         if (page_to_pfn(pages[j]) != next_pfn)
 991                                 break;
 992
 993                 len = (j - i) << PAGE_SHIFT;
 994                 ret = iommu_map(mapping->domain, iova, phys, len,
 995                                 __dma_info_to_prot(DMA_BIDIRECTIONAL, attrs));
 996                 if (ret < 0)
 997                         goto fail;
 998                 iova += len;
 999                 i = j;
1000         }
1001         return dma_addr;
1002 fail:
1003         iommu_unmap(mapping->domain, dma_addr, iova-dma_addr);
1004         __free_iova(mapping, dma_addr, size);
1005         return DMA_MAPPING_ERROR;
1006 }
1007
1008 static int __iommu_remove_mapping(struct device *dev, dma_addr_t iova, size_t size)
1009 {
1010         struct dma_iommu_mapping *mapping = to_dma_iommu_mapping(dev);
1011
1012         /*
1013          * add optional in-page offset from iova to size and align
1014          * result to page size
1015          */
1016         size = PAGE_ALIGN((iova & ~PAGE_MASK) + size);
1017         iova &= PAGE_MASK;
1018
1019         iommu_unmap(mapping->domain, iova, size);
1020         __free_iova(mapping, iova, size);
1021         return 0;
1022 }
1023
1024 static struct page **__atomic_get_pages(void *addr)
1025 {
1026         struct page *page;
1027         phys_addr_t phys;
1028
1029         phys = gen_pool_virt_to_phys(atomic_pool, (unsigned long)addr);
1030         page = phys_to_page(phys);
1031
1032         return (struct page **)page;
1033 }
1034
1035 static struct page **__iommu_get_pages(void *cpu_addr, unsigned long attrs)
1036 {
1037         if (__in_atomic_pool(cpu_addr, PAGE_SIZE))
1038                 return __atomic_get_pages(cpu_addr);
1039
1040         if (attrs & DMA_ATTR_NO_KERNEL_MAPPING)
1041                 return cpu_addr;
1042
1043         return dma_common_find_pages(cpu_addr);
1044 }
1045
1046 static void *__iommu_alloc_simple(struct device *dev, size_t size, gfp_t gfp,
1047                                   dma_addr_t *handle, int coherent_flag,
1048                                   unsigned long attrs)
1049 {
1050         struct page *page;
1051         void *addr;
1052
1053         if (coherent_flag  == COHERENT)
1054                 addr = __alloc_simple_buffer(dev, size, gfp, &page);
1055         else
1056                 addr = __alloc_from_pool(size, &page);
1057         if (!addr)
1058                 return NULL;
1059
1060         *handle = __iommu_create_mapping(dev, &page, size, attrs);
1061         if (*handle == DMA_MAPPING_ERROR)
1062                 goto err_mapping;
1063
1064         return addr;
1065
1066 err_mapping:
1067         __free_from_pool(addr, size);
1068         return NULL;
1069 }
1070
1071 static void __iommu_free_atomic(struct device *dev, void *cpu_addr,
1072                         dma_addr_t handle, size_t size, int coherent_flag)
1073 {
1074         __iommu_remove_mapping(dev, handle, size);
1075         if (coherent_flag == COHERENT)
1076                 __dma_free_buffer(virt_to_page(cpu_addr), size);
1077         else
1078                 __free_from_pool(cpu_addr, size);
1079 }
1080
1081 static void *arm_iommu_alloc_attrs(struct device *dev, size_t size,
1082             dma_addr_t *handle, gfp_t gfp, unsigned long attrs)
1083 {
1084         pgprot_t prot = __get_dma_pgprot(attrs, PAGE_KERNEL);
1085         struct page **pages;
1086         void *addr = NULL;
1087         int coherent_flag = dev->dma_coherent ? COHERENT : NORMAL;
1088
1089         *handle = DMA_MAPPING_ERROR;
1090         size = PAGE_ALIGN(size);
1091
1092         if (coherent_flag  == COHERENT || !gfpflags_allow_blocking(gfp))
1093                 return __iommu_alloc_simple(dev, size, gfp, handle,
1094                                             coherent_flag, attrs);
1095
1096         /*
1097          * Following is a work-around (a.k.a. hack) to prevent pages
1098          * with __GFP_COMP being passed to split_page() which cannot
1099          * handle them.  The real problem is that this flag probably
1100          * should be 0 on ARM as it is not supported on this
1101          * platform; see CONFIG_HUGETLBFS.
1102          */
1103         gfp &= ~(__GFP_COMP);
1104
1105         pages = __iommu_alloc_buffer(dev, size, gfp, attrs, coherent_flag);
1106         if (!pages)
1107                 return NULL;
1108
1109         *handle = __iommu_create_mapping(dev, pages, size, attrs);
1110         if (*handle == DMA_MAPPING_ERROR)
1111                 goto err_buffer;
1112
1113         if (attrs & DMA_ATTR_NO_KERNEL_MAPPING)
1114                 return pages;
1115
1116         addr = dma_common_pages_remap(pages, size, prot,
1117                                    __builtin_return_address(0));
1118         if (!addr)
1119                 goto err_mapping;
1120
1121         return addr;
1122
1123 err_mapping:
1124         __iommu_remove_mapping(dev, *handle, size);
1125 err_buffer:
1126         __iommu_free_buffer(dev, pages, size, attrs);
1127         return NULL;
1128 }
1129
1130 static int arm_iommu_mmap_attrs(struct device *dev, struct vm_area_struct *vma,
1131                     void *cpu_addr, dma_addr_t dma_addr, size_t size,
1132                     unsigned long attrs)
1133 {
1134         struct page **pages = __iommu_get_pages(cpu_addr, attrs);
1135         unsigned long nr_pages = PAGE_ALIGN(size) >> PAGE_SHIFT;
1136         int err;
1137
1138         if (!pages)
1139                 return -ENXIO;
1140
1141         if (vma->vm_pgoff >= nr_pages)
1142                 return -ENXIO;
1143
1144         if (!dev->dma_coherent)
1145                 vma->vm_page_prot = __get_dma_pgprot(attrs, vma->vm_page_prot);
1146
1147         err = vm_map_pages(vma, pages, nr_pages);
1148         if (err)
1149                 pr_err("Remapping memory failed: %d\n", err);
1150
1151         return err;
1152 }
1153
1154 /*
1155  * free a page as defined by the above mapping.
1156  * Must not be called with IRQs disabled.
1157  */
1158 static void arm_iommu_free_attrs(struct device *dev, size_t size, void *cpu_addr,
1159         dma_addr_t handle, unsigned long attrs)
1160 {
1161         int coherent_flag = dev->dma_coherent ? COHERENT : NORMAL;
1162         struct page **pages;
1163         size = PAGE_ALIGN(size);
1164
1165         if (coherent_flag == COHERENT || __in_atomic_pool(cpu_addr, size)) {
1166                 __iommu_free_atomic(dev, cpu_addr, handle, size, coherent_flag);
1167                 return;
1168         }
1169
1170         pages = __iommu_get_pages(cpu_addr, attrs);
1171         if (!pages) {
1172                 WARN(1, "trying to free invalid coherent area: %p\n", cpu_addr);
1173                 return;
1174         }
1175
1176         if ((attrs & DMA_ATTR_NO_KERNEL_MAPPING) == 0)
1177                 dma_common_free_remap(cpu_addr, size);
1178
1179         __iommu_remove_mapping(dev, handle, size);
1180         __iommu_free_buffer(dev, pages, size, attrs);
1181 }
1182
1183 static int arm_iommu_get_sgtable(struct device *dev, struct sg_table *sgt,
1184                                  void *cpu_addr, dma_addr_t dma_addr,
1185                                  size_t size, unsigned long attrs)
1186 {
1187         unsigned int count = PAGE_ALIGN(size) >> PAGE_SHIFT;
1188         struct page **pages = __iommu_get_pages(cpu_addr, attrs);
1189
1190         if (!pages)
1191                 return -ENXIO;
1192
1193         return sg_alloc_table_from_pages(sgt, pages, count, 0, size,
1194                                          GFP_KERNEL);
1195 }
1196
1197 /*
1198  * Map a part of the scatter-gather list into contiguous io address space
1199  */
1200 static int __map_sg_chunk(struct device *dev, struct scatterlist *sg,
1201                           size_t size, dma_addr_t *handle,
1202                           enum dma_data_direction dir, unsigned long attrs)
1203 {
1204         struct dma_iommu_mapping *mapping = to_dma_iommu_mapping(dev);
1205         dma_addr_t iova, iova_base;
1206         int ret = 0;
1207         unsigned int count;
1208         struct scatterlist *s;
1209         int prot;
1210
1211         size = PAGE_ALIGN(size);
1212         *handle = DMA_MAPPING_ERROR;
1213
1214         iova_base = iova = __alloc_iova(mapping, size);
1215         if (iova == DMA_MAPPING_ERROR)
1216                 return -ENOMEM;
1217
1218         for (count = 0, s = sg; count < (size >> PAGE_SHIFT); s = sg_next(s)) {
1219                 phys_addr_t phys = page_to_phys(sg_page(s));
1220                 unsigned int len = PAGE_ALIGN(s->offset + s->length);
1221
1222                 if (!dev->dma_coherent && !(attrs & DMA_ATTR_SKIP_CPU_SYNC))
1223                         __dma_page_cpu_to_dev(sg_page(s), s->offset, s->length, dir);
1224
1225                 prot = __dma_info_to_prot(dir, attrs);
1226
1227                 ret = iommu_map(mapping->domain, iova, phys, len, prot);
1228                 if (ret < 0)
1229                         goto fail;
1230                 count += len >> PAGE_SHIFT;
1231                 iova += len;
1232         }
1233         *handle = iova_base;
1234
1235         return 0;
1236 fail:
1237         iommu_unmap(mapping->domain, iova_base, count * PAGE_SIZE);
1238         __free_iova(mapping, iova_base, size);
1239         return ret;
1240 }
1241
1242 /**
1243  * arm_iommu_map_sg - map a set of SG buffers for streaming mode DMA
1244  * @dev: valid struct device pointer
1245  * @sg: list of buffers
1246  * @nents: number of buffers to map
1247  * @dir: DMA transfer direction
1248  *
1249  * Map a set of buffers described by scatterlist in streaming mode for DMA.
1250  * The scatter gather list elements are merged together (if possible) and
1251  * tagged with the appropriate dma address and length. They are obtained via
1252  * sg_dma_{address,length}.
1253  */
1254 static int arm_iommu_map_sg(struct device *dev, struct scatterlist *sg,
1255                 int nents, enum dma_data_direction dir, unsigned long attrs)
1256 {
1257         struct scatterlist *s = sg, *dma = sg, *start = sg;
1258         int i, count = 0, ret;
1259         unsigned int offset = s->offset;
1260         unsigned int size = s->offset + s->length;
1261         unsigned int max = dma_get_max_seg_size(dev);
1262
1263         for (i = 1; i < nents; i++) {
1264                 s = sg_next(s);
1265
1266                 s->dma_length = 0;
1267
1268                 if (s->offset || (size & ~PAGE_MASK) || size + s->length > max) {
1269                         ret = __map_sg_chunk(dev, start, size,
1270                                              &dma->dma_address, dir, attrs);
1271                         if (ret < 0)
1272                                 goto bad_mapping;
1273
1274                         dma->dma_address += offset;
1275                         dma->dma_length = size - offset;
1276
1277                         size = offset = s->offset;
1278                         start = s;
1279                         dma = sg_next(dma);
1280                         count += 1;
1281                 }
1282                 size += s->length;
1283         }
1284         ret = __map_sg_chunk(dev, start, size, &dma->dma_address, dir, attrs);
1285         if (ret < 0)
1286                 goto bad_mapping;
1287
1288         dma->dma_address += offset;
1289         dma->dma_length = size - offset;
1290
1291         return count+1;
1292
1293 bad_mapping:
1294         for_each_sg(sg, s, count, i)
1295                 __iommu_remove_mapping(dev, sg_dma_address(s), sg_dma_len(s));
1296         if (ret == -ENOMEM)
1297                 return ret;
1298         return -EINVAL;
1299 }
1300
1301 /**
1302  * arm_iommu_unmap_sg - unmap a set of SG buffers mapped by dma_map_sg
1303  * @dev: valid struct device pointer
1304  * @sg: list of buffers
1305  * @nents: number of buffers to unmap (same as was passed to dma_map_sg)
1306  * @dir: DMA transfer direction (same as was passed to dma_map_sg)
1307  *
1308  * Unmap a set of streaming mode DMA translations.  Again, CPU access
1309  * rules concerning calls here are the same as for dma_unmap_single().
1310  */
1311 static void arm_iommu_unmap_sg(struct device *dev,
1312                                struct scatterlist *sg, int nents,
1313                                enum dma_data_direction dir,
1314                                unsigned long attrs)
1315 {
1316         struct scatterlist *s;
1317         int i;
1318
1319         for_each_sg(sg, s, nents, i) {
1320                 if (sg_dma_len(s))
1321                         __iommu_remove_mapping(dev, sg_dma_address(s),
1322                                                sg_dma_len(s));
1323                 if (!dev->dma_coherent && !(attrs & DMA_ATTR_SKIP_CPU_SYNC))
1324                         __dma_page_dev_to_cpu(sg_page(s), s->offset,
1325                                               s->length, dir);
1326         }
1327 }
1328
1329 /**
1330  * arm_iommu_sync_sg_for_cpu
1331  * @dev: valid struct device pointer
1332  * @sg: list of buffers
1333  * @nents: number of buffers to map (returned from dma_map_sg)
1334  * @dir: DMA transfer direction (same as was passed to dma_map_sg)
1335  */
1336 static void arm_iommu_sync_sg_for_cpu(struct device *dev,
1337                         struct scatterlist *sg,
1338                         int nents, enum dma_data_direction dir)
1339 {
1340         struct scatterlist *s;
1341         int i;
1342
1343         if (dev->dma_coherent)
1344                 return;
1345
1346         for_each_sg(sg, s, nents, i)
1347                 __dma_page_dev_to_cpu(sg_page(s), s->offset, s->length, dir);
1348
1349 }
1350
1351 /**
1352  * arm_iommu_sync_sg_for_device
1353  * @dev: valid struct device pointer
1354  * @sg: list of buffers
1355  * @nents: number of buffers to map (returned from dma_map_sg)
1356  * @dir: DMA transfer direction (same as was passed to dma_map_sg)
1357  */
1358 static void arm_iommu_sync_sg_for_device(struct device *dev,
1359                         struct scatterlist *sg,
1360                         int nents, enum dma_data_direction dir)
1361 {
1362         struct scatterlist *s;
1363         int i;
1364
1365         if (dev->dma_coherent)
1366                 return;
1367
1368         for_each_sg(sg, s, nents, i)
1369                 __dma_page_cpu_to_dev(sg_page(s), s->offset, s->length, dir);
1370 }
1371
1372 /**
1373  * arm_iommu_map_page
1374  * @dev: valid struct device pointer
1375  * @page: page that buffer resides in
1376  * @offset: offset into page for start of buffer
1377  * @size: size of buffer to map
1378  * @dir: DMA transfer direction
1379  *
1380  * IOMMU aware version of arm_dma_map_page()
1381  */
1382 static dma_addr_t arm_iommu_map_page(struct device *dev, struct page *page,
1383              unsigned long offset, size_t size, enum dma_data_direction dir,
1384              unsigned long attrs)
1385 {
1386         struct dma_iommu_mapping *mapping = to_dma_iommu_mapping(dev);
1387         dma_addr_t dma_addr;
1388         int ret, prot, len = PAGE_ALIGN(size + offset);
1389
1390         if (!dev->dma_coherent && !(attrs & DMA_ATTR_SKIP_CPU_SYNC))
1391                 __dma_page_cpu_to_dev(page, offset, size, dir);
1392
1393         dma_addr = __alloc_iova(mapping, len);
1394         if (dma_addr == DMA_MAPPING_ERROR)
1395                 return dma_addr;
1396
1397         prot = __dma_info_to_prot(dir, attrs);
1398
1399         ret = iommu_map(mapping->domain, dma_addr, page_to_phys(page), len, prot);
1400         if (ret < 0)
1401                 goto fail;
1402
1403         return dma_addr + offset;
1404 fail:
1405         __free_iova(mapping, dma_addr, len);
1406         return DMA_MAPPING_ERROR;
1407 }
1408
1409 /**
1410  * arm_iommu_unmap_page
1411  * @dev: valid struct device pointer
1412  * @handle: DMA address of buffer
1413  * @size: size of buffer (same as passed to dma_map_page)
1414  * @dir: DMA transfer direction (same as passed to dma_map_page)
1415  *
1416  * IOMMU aware version of arm_dma_unmap_page()
1417  */
1418 static void arm_iommu_unmap_page(struct device *dev, dma_addr_t handle,
1419                 size_t size, enum dma_data_direction dir, unsigned long attrs)
1420 {
1421         struct dma_iommu_mapping *mapping = to_dma_iommu_mapping(dev);
1422         dma_addr_t iova = handle & PAGE_MASK;
1423         struct page *page;
1424         int offset = handle & ~PAGE_MASK;
1425         int len = PAGE_ALIGN(size + offset);
1426
1427         if (!iova)
1428                 return;
1429
1430         if (!dev->dma_coherent && !(attrs & DMA_ATTR_SKIP_CPU_SYNC)) {
1431                 page = phys_to_page(iommu_iova_to_phys(mapping->domain, iova));
1432                 __dma_page_dev_to_cpu(page, offset, size, dir);
1433         }
1434
1435         iommu_unmap(mapping->domain, iova, len);
1436         __free_iova(mapping, iova, len);
1437 }
1438
1439 /**
1440  * arm_iommu_map_resource - map a device resource for DMA
1441  * @dev: valid struct device pointer
1442  * @phys_addr: physical address of resource
1443  * @size: size of resource to map
1444  * @dir: DMA transfer direction
1445  */
1446 static dma_addr_t arm_iommu_map_resource(struct device *dev,
1447                 phys_addr_t phys_addr, size_t size,
1448                 enum dma_data_direction dir, unsigned long attrs)
1449 {
1450         struct dma_iommu_mapping *mapping = to_dma_iommu_mapping(dev);
1451         dma_addr_t dma_addr;
1452         int ret, prot;
1453         phys_addr_t addr = phys_addr & PAGE_MASK;
1454         unsigned int offset = phys_addr & ~PAGE_MASK;
1455         size_t len = PAGE_ALIGN(size + offset);
1456
1457         dma_addr = __alloc_iova(mapping, len);
1458         if (dma_addr == DMA_MAPPING_ERROR)
1459                 return dma_addr;
1460
1461         prot = __dma_info_to_prot(dir, attrs) | IOMMU_MMIO;
1462
1463         ret = iommu_map(mapping->domain, dma_addr, addr, len, prot);
1464         if (ret < 0)
1465                 goto fail;
1466
1467         return dma_addr + offset;
1468 fail:
1469         __free_iova(mapping, dma_addr, len);
1470         return DMA_MAPPING_ERROR;
1471 }
1472
1473 /**
1474  * arm_iommu_unmap_resource - unmap a device DMA resource
1475  * @dev: valid struct device pointer
1476  * @dma_handle: DMA address to resource
1477  * @size: size of resource to map
1478  * @dir: DMA transfer direction
1479  */
1480 static void arm_iommu_unmap_resource(struct device *dev, dma_addr_t dma_handle,
1481                 size_t size, enum dma_data_direction dir,
1482                 unsigned long attrs)
1483 {
1484         struct dma_iommu_mapping *mapping = to_dma_iommu_mapping(dev);
1485         dma_addr_t iova = dma_handle & PAGE_MASK;
1486         unsigned int offset = dma_handle & ~PAGE_MASK;
1487         size_t len = PAGE_ALIGN(size + offset);
1488
1489         if (!iova)
1490                 return;
1491
1492         iommu_unmap(mapping->domain, iova, len);
1493         __free_iova(mapping, iova, len);
1494 }
1495
1496 static void arm_iommu_sync_single_for_cpu(struct device *dev,
1497                 dma_addr_t handle, size_t size, enum dma_data_direction dir)
1498 {
1499         struct dma_iommu_mapping *mapping = to_dma_iommu_mapping(dev);
1500         dma_addr_t iova = handle & PAGE_MASK;
1501         struct page *page;
1502         unsigned int offset = handle & ~PAGE_MASK;
1503
1504         if (dev->dma_coherent || !iova)
1505                 return;
1506
1507         page = phys_to_page(iommu_iova_to_phys(mapping->domain, iova));
1508         __dma_page_dev_to_cpu(page, offset, size, dir);
1509 }
1510
1511 static void arm_iommu_sync_single_for_device(struct device *dev,
1512                 dma_addr_t handle, size_t size, enum dma_data_direction dir)
1513 {
1514         struct dma_iommu_mapping *mapping = to_dma_iommu_mapping(dev);
1515         dma_addr_t iova = handle & PAGE_MASK;
1516         struct page *page;
1517         unsigned int offset = handle & ~PAGE_MASK;
1518
1519         if (dev->dma_coherent || !iova)
1520                 return;
1521
1522         page = phys_to_page(iommu_iova_to_phys(mapping->domain, iova));
1523         __dma_page_cpu_to_dev(page, offset, size, dir);
1524 }
1525
1526 static const struct dma_map_ops iommu_ops = {
1527         .alloc          = arm_iommu_alloc_attrs,
1528         .free           = arm_iommu_free_attrs,
1529         .mmap           = arm_iommu_mmap_attrs,
1530         .get_sgtable    = arm_iommu_get_sgtable,
1531
1532         .map_page               = arm_iommu_map_page,
1533         .unmap_page             = arm_iommu_unmap_page,
1534         .sync_single_for_cpu    = arm_iommu_sync_single_for_cpu,
1535         .sync_single_for_device = arm_iommu_sync_single_for_device,
1536
1537         .map_sg                 = arm_iommu_map_sg,
1538         .unmap_sg               = arm_iommu_unmap_sg,
1539         .sync_sg_for_cpu        = arm_iommu_sync_sg_for_cpu,
1540         .sync_sg_for_device     = arm_iommu_sync_sg_for_device,
1541
1542         .map_resource           = arm_iommu_map_resource,
1543         .unmap_resource         = arm_iommu_unmap_resource,
1544 };
1545
1546 /**
1547  * arm_iommu_create_mapping
1548  * @bus: pointer to the bus holding the client device (for IOMMU calls)
1549  * @base: start address of the valid IO address space
1550  * @size: maximum size of the valid IO address space
1551  *
1552  * Creates a mapping structure which holds information about used/unused
1553  * IO address ranges, which is required to perform memory allocation and
1554  * mapping with IOMMU aware functions.
1555  *
1556  * The client device need to be attached to the mapping with
1557  * arm_iommu_attach_device function.
1558  */
1559 struct dma_iommu_mapping *
1560 arm_iommu_create_mapping(struct bus_type *bus, dma_addr_t base, u64 size)
1561 {
1562         unsigned int bits = size >> PAGE_SHIFT;
1563         unsigned int bitmap_size = BITS_TO_LONGS(bits) * sizeof(long);
1564         struct dma_iommu_mapping *mapping;
1565         int extensions = 1;
1566         int err = -ENOMEM;
1567
1568         /* currently only 32-bit DMA address space is supported */
1569         if (size > DMA_BIT_MASK(32) + 1)
1570                 return ERR_PTR(-ERANGE);
1571
1572         if (!bitmap_size)
1573                 return ERR_PTR(-EINVAL);
1574
1575         if (bitmap_size > PAGE_SIZE) {
1576                 extensions = bitmap_size / PAGE_SIZE;
1577                 bitmap_size = PAGE_SIZE;
1578         }
1579
1580         mapping = kzalloc(sizeof(struct dma_iommu_mapping), GFP_KERNEL);
1581         if (!mapping)
1582                 goto err;
1583
1584         mapping->bitmap_size = bitmap_size;
1585         mapping->bitmaps = kcalloc(extensions, sizeof(unsigned long *),
1586                                    GFP_KERNEL);
1587         if (!mapping->bitmaps)
1588                 goto err2;
1589
1590         mapping->bitmaps[0] = kzalloc(bitmap_size, GFP_KERNEL);
1591         if (!mapping->bitmaps[0])
1592                 goto err3;
1593
1594         mapping->nr_bitmaps = 1;
1595         mapping->extensions = extensions;
1596         mapping->base = base;
1597         mapping->bits = BITS_PER_BYTE * bitmap_size;
1598
1599         spin_lock_init(&mapping->lock);
1600
1601         mapping->domain = iommu_domain_alloc(bus);
1602         if (!mapping->domain)
1603                 goto err4;
1604
1605         kref_init(&mapping->kref);
1606         return mapping;
1607 err4:
1608         kfree(mapping->bitmaps[0]);
1609 err3:
1610         kfree(mapping->bitmaps);
1611 err2:
1612         kfree(mapping);
1613 err:
1614         return ERR_PTR(err);
1615 }
1616 EXPORT_SYMBOL_GPL(arm_iommu_create_mapping);
1617
1618 static void release_iommu_mapping(struct kref *kref)
1619 {
1620         int i;
1621         struct dma_iommu_mapping *mapping =
1622                 container_of(kref, struct dma_iommu_mapping, kref);
1623
1624         iommu_domain_free(mapping->domain);
1625         for (i = 0; i < mapping->nr_bitmaps; i++)
1626                 kfree(mapping->bitmaps[i]);
1627         kfree(mapping->bitmaps);
1628         kfree(mapping);
1629 }
1630
1631 static int extend_iommu_mapping(struct dma_iommu_mapping *mapping)
1632 {
1633         int next_bitmap;
1634
1635         if (mapping->nr_bitmaps >= mapping->extensions)
1636                 return -EINVAL;
1637
1638         next_bitmap = mapping->nr_bitmaps;
1639         mapping->bitmaps[next_bitmap] = kzalloc(mapping->bitmap_size,
1640                                                 GFP_ATOMIC);
1641         if (!mapping->bitmaps[next_bitmap])
1642                 return -ENOMEM;
1643
1644         mapping->nr_bitmaps++;
1645
1646         return 0;
1647 }
1648
1649 void arm_iommu_release_mapping(struct dma_iommu_mapping *mapping)
1650 {
1651         if (mapping)
1652                 kref_put(&mapping->kref, release_iommu_mapping);
1653 }
1654 EXPORT_SYMBOL_GPL(arm_iommu_release_mapping);
1655
1656 static int __arm_iommu_attach_device(struct device *dev,
1657                                      struct dma_iommu_mapping *mapping)
1658 {
1659         int err;
1660
1661         err = iommu_attach_device(mapping->domain, dev);
1662         if (err)
1663                 return err;
1664
1665         kref_get(&mapping->kref);
1666         to_dma_iommu_mapping(dev) = mapping;
1667
1668         pr_debug("Attached IOMMU controller to %s device.\n", dev_name(dev));
1669         return 0;
1670 }
1671
1672 /**
1673  * arm_iommu_attach_device
1674  * @dev: valid struct device pointer
1675  * @mapping: io address space mapping structure (returned from
1676  *      arm_iommu_create_mapping)
1677  *
1678  * Attaches specified io address space mapping to the provided device.
1679  * This replaces the dma operations (dma_map_ops pointer) with the
1680  * IOMMU aware version.
1681  *
1682  * More than one client might be attached to the same io address space
1683  * mapping.
1684  */
1685 int arm_iommu_attach_device(struct device *dev,
1686                             struct dma_iommu_mapping *mapping)
1687 {
1688         int err;
1689
1690         err = __arm_iommu_attach_device(dev, mapping);
1691         if (err)
1692                 return err;
1693
1694         set_dma_ops(dev, &iommu_ops);
1695         return 0;
1696 }
1697 EXPORT_SYMBOL_GPL(arm_iommu_attach_device);
1698
1699 /**
1700  * arm_iommu_detach_device
1701  * @dev: valid struct device pointer
1702  *
1703  * Detaches the provided device from a previously attached map.
1704  * This overwrites the dma_ops pointer with appropriate non-IOMMU ops.
1705  */
1706 void arm_iommu_detach_device(struct device *dev)
1707 {
1708         struct dma_iommu_mapping *mapping;
1709
1710         mapping = to_dma_iommu_mapping(dev);
1711         if (!mapping) {
1712                 dev_warn(dev, "Not attached\n");
1713                 return;
1714         }
1715
1716         iommu_detach_device(mapping->domain, dev);
1717         kref_put(&mapping->kref, release_iommu_mapping);
1718         to_dma_iommu_mapping(dev) = NULL;
1719         set_dma_ops(dev, NULL);
1720
1721         pr_debug("Detached IOMMU controller from %s device.\n", dev_name(dev));
1722 }
1723 EXPORT_SYMBOL_GPL(arm_iommu_detach_device);
1724
1725 static void arm_setup_iommu_dma_ops(struct device *dev, u64 dma_base, u64 size,
1726                                     const struct iommu_ops *iommu, bool coherent)
1727 {
1728         struct dma_iommu_mapping *mapping;
1729
1730         mapping = arm_iommu_create_mapping(dev->bus, dma_base, size);
1731         if (IS_ERR(mapping)) {
1732                 pr_warn("Failed to create %llu-byte IOMMU mapping for device %s\n",
1733                                 size, dev_name(dev));
1734                 return;
1735         }
1736
1737         if (__arm_iommu_attach_device(dev, mapping)) {
1738                 pr_warn("Failed to attached device %s to IOMMU_mapping\n",
1739                                 dev_name(dev));
1740                 arm_iommu_release_mapping(mapping);
1741                 return;
1742         }
1743
1744         set_dma_ops(dev, &iommu_ops);
1745 }
1746
1747 static void arm_teardown_iommu_dma_ops(struct device *dev)
1748 {
1749         struct dma_iommu_mapping *mapping = to_dma_iommu_mapping(dev);
1750
1751         if (!mapping)
1752                 return;
1753
1754         arm_iommu_detach_device(dev);
1755         arm_iommu_release_mapping(mapping);
1756 }
1757
1758 #else
1759
1760 static void arm_setup_iommu_dma_ops(struct device *dev, u64 dma_base, u64 size,
1761                                     const struct iommu_ops *iommu, bool coherent)
1762 {
1763 }
1764
1765 static void arm_teardown_iommu_dma_ops(struct device *dev) { }
1766
1767 #endif  /* CONFIG_ARM_DMA_USE_IOMMU */
1768
1769 void arch_setup_dma_ops(struct device *dev, u64 dma_base, u64 size,
1770                         const struct iommu_ops *iommu, bool coherent)
1771 {
1772         dev->archdata.dma_coherent = coherent;
1773         dev->dma_coherent = coherent;
1774
1775         /*
1776          * Don't override the dma_ops if they have already been set. Ideally
1777          * this should be the only location where dma_ops are set, remove this
1778          * check when all other callers of set_dma_ops will have disappeared.
1779          */
1780         if (dev->dma_ops)
1781                 return;
1782
1783         if (iommu)
1784                 arm_setup_iommu_dma_ops(dev, dma_base, size, iommu, coherent);
1785
1786         xen_setup_dma_ops(dev);
1787         dev->archdata.dma_ops_setup = true;
1788 }
1789
1790 void arch_teardown_dma_ops(struct device *dev)
1791 {
1792         if (!dev->archdata.dma_ops_setup)
1793                 return;
1794
1795         arm_teardown_iommu_dma_ops(dev);
1796         /* Let arch_setup_dma_ops() start again from scratch upon re-probe */
1797         set_dma_ops(dev, NULL);
1798 }
1799
1800 void arch_sync_dma_for_device(phys_addr_t paddr, size_t size,
1801                 enum dma_data_direction dir)
1802 {
1803         __dma_page_cpu_to_dev(phys_to_page(paddr), paddr & (PAGE_SIZE - 1),
1804                               size, dir);
1805 }
1806
1807 void arch_sync_dma_for_cpu(phys_addr_t paddr, size_t size,
1808                 enum dma_data_direction dir)
1809 {
1810         __dma_page_dev_to_cpu(phys_to_page(paddr), paddr & (PAGE_SIZE - 1),
1811                               size, dir);
1812 }
1813
1814 void *arch_dma_alloc(struct device *dev, size_t size, dma_addr_t *dma_handle,
1815                 gfp_t gfp, unsigned long attrs)
1816 {
1817         return __dma_alloc(dev, size, dma_handle, gfp,
1818                            __get_dma_pgprot(attrs, PAGE_KERNEL), false,
1819                            attrs, __builtin_return_address(0));
1820 }
1821
1822 void arch_dma_free(struct device *dev, size_t size, void *cpu_addr,
1823                 dma_addr_t dma_handle, unsigned long attrs)
1824 {
1825         __arm_dma_free(dev, size, cpu_addr, dma_handle, attrs, false);
1826 }