lib/swiotlb.c

   1 /*
   2  * Dynamic DMA mapping support.
   3  *
   4  * This implementation is a fallback for platforms that do not support
   5  * I/O TLBs (aka DMA address translation hardware).
   6  * Copyright (C) 2000 Asit Mallick <Asit.K.Mallick@intel.com>
   7  * Copyright (C) 2000 Goutham Rao <goutham.rao@intel.com>
   8  * Copyright (C) 2000, 2003 Hewlett-Packard Co
   9  *      David Mosberger-Tang <davidm@hpl.hp.com>
  10  *
  11  * 03/05/07 davidm      Switch from PCI-DMA to generic device DMA API.
  12  * 00/12/13 davidm      Rename to swiotlb.c and add mark_clean() to avoid
  13  *                      unnecessary i-cache flushing.
  14  * 04/07/.. ak          Better overflow handling. Assorted fixes.
  15  * 05/09/10 linville    Add support for syncing ranges, support syncing for
  16  *                      DMA_BIDIRECTIONAL mappings, miscellaneous cleanup.
  17  */
  18
  19 #include <linux/cache.h>
  20 #include <linux/dma-mapping.h>
  21 #include <linux/mm.h>
  22 #include <linux/module.h>
  23 #include <linux/spinlock.h>
  24 #include <linux/swiotlb.h>
  25 #include <linux/string.h>
  26 #include <linux/swiotlb.h>
  27 #include <linux/types.h>
  28 #include <linux/ctype.h>
  29 #include <linux/highmem.h>
  30
  31 #include <asm/io.h>
  32 #include <asm/dma.h>
  33 #include <asm/scatterlist.h>
  34
  35 #include <linux/init.h>
  36 #include <linux/bootmem.h>
  37 #include <linux/iommu-helper.h>
  38
  39 #define OFFSET(val,align) ((unsigned long)      \
  40                            ( (val) & ( (align) - 1)))
  41
  42 #define SLABS_PER_PAGE (1 << (PAGE_SHIFT - IO_TLB_SHIFT))
  43
  44 /*
  45  * Minimum IO TLB size to bother booting with.  Systems with mainly
  46  * 64bit capable cards will only lightly use the swiotlb.  If we can't
  47  * allocate a contiguous 1MB, we're probably in trouble anyway.
  48  */
  49 #define IO_TLB_MIN_SLABS ((1<<20) >> IO_TLB_SHIFT)
  50
  51 /*
  52  * Enumeration for sync targets
  53  */
  54 enum dma_sync_target {
  55         SYNC_FOR_CPU = 0,
  56         SYNC_FOR_DEVICE = 1,
  57 };
  58
  59 int swiotlb_force;
  60
  61 /*
  62  * Used to do a quick range check in swiotlb_unmap_single and
  63  * swiotlb_sync_single_*, to see if the memory was in fact allocated by this
  64  * API.
  65  */
  66 static char *io_tlb_start, *io_tlb_end;
  67
  68 /*
  69  * The number of IO TLB blocks (in groups of 64) betweeen io_tlb_start and
  70  * io_tlb_end.  This is command line adjustable via setup_io_tlb_npages.
  71  */
  72 static unsigned long io_tlb_nslabs;
  73
  74 /*
  75  * When the IOMMU overflows we return a fallback buffer. This sets the size.
  76  */
  77 static unsigned long io_tlb_overflow = 32*1024;
  78
  79 void *io_tlb_overflow_buffer;
  80
  81 /*
  82  * This is a free list describing the number of free entries available from
  83  * each index
  84  */
  85 static unsigned int *io_tlb_list;
  86 static unsigned int io_tlb_index;
  87
  88 /*
  89  * We need to save away the original address corresponding to a mapped entry
  90  * for the sync operations.
  91  */
  92 static struct swiotlb_phys_addr {
  93         struct page *page;
  94         unsigned int offset;
  95 } *io_tlb_orig_addr;
  96
  97 /*
  98  * Protect the above data structures in the map and unmap calls
  99  */
 100 static DEFINE_SPINLOCK(io_tlb_lock);
 101
 102 static int __init
 103 setup_io_tlb_npages(char *str)
 104 {
 105         if (isdigit(*str)) {
 106                 io_tlb_nslabs = simple_strtoul(str, &str, 0);
 107                 /* avoid tail segment of size < IO_TLB_SEGSIZE */
 108                 io_tlb_nslabs = ALIGN(io_tlb_nslabs, IO_TLB_SEGSIZE);
 109         }
 110         if (*str == ',')
 111                 ++str;
 112         if (!strcmp(str, "force"))
 113                 swiotlb_force = 1;
 114         return 1;
 115 }
 116 __setup("swiotlb=", setup_io_tlb_npages);
 117 /* make io_tlb_overflow tunable too? */
 118
 119 void * __weak swiotlb_alloc_boot(size_t size, unsigned long nslabs)
 120 {
 121         return alloc_bootmem_low_pages(size);
 122 }
 123
 124 void * __weak swiotlb_alloc(unsigned order, unsigned long nslabs)
 125 {
 126         return (void *)__get_free_pages(GFP_DMA | __GFP_NOWARN, order);
 127 }
 128
 129 dma_addr_t __weak swiotlb_phys_to_bus(phys_addr_t paddr)
 130 {
 131         return paddr;
 132 }
 133
 134 phys_addr_t __weak swiotlb_bus_to_phys(dma_addr_t baddr)
 135 {
 136         return baddr;
 137 }
 138
 139 static dma_addr_t swiotlb_virt_to_bus(volatile void *address)
 140 {
 141         return swiotlb_phys_to_bus(virt_to_phys(address));
 142 }
 143
 144 static void *swiotlb_bus_to_virt(dma_addr_t address)
 145 {
 146         return phys_to_virt(swiotlb_bus_to_phys(address));
 147 }
 148
 149 int __weak swiotlb_arch_range_needs_mapping(void *ptr, size_t size)
 150 {
 151         return 0;
 152 }
 153
 154 static dma_addr_t swiotlb_sg_to_bus(struct scatterlist *sg)
 155 {
 156         return swiotlb_phys_to_bus(page_to_phys(sg_page(sg)) + sg->offset);
 157 }
 158
 159 static void swiotlb_print_info(unsigned long bytes)
 160 {
 161         phys_addr_t pstart, pend;
 162         dma_addr_t bstart, bend;
 163
 164         pstart = virt_to_phys(io_tlb_start);
 165         pend = virt_to_phys(io_tlb_end);
 166
 167         bstart = swiotlb_phys_to_bus(pstart);
 168         bend = swiotlb_phys_to_bus(pend);
 169
 170         printk(KERN_INFO "Placing %luMB software IO TLB between %p - %p\n",
 171                bytes >> 20, io_tlb_start, io_tlb_end);
 172         if (pstart != bstart || pend != bend)
 173                 printk(KERN_INFO "software IO TLB at phys %#llx - %#llx"
 174                        " bus %#llx - %#llx\n",
 175                        (unsigned long long)pstart,
 176                        (unsigned long long)pend,
 177                        (unsigned long long)bstart,
 178                        (unsigned long long)bend);
 179         else
 180                 printk(KERN_INFO "software IO TLB at phys %#llx - %#llx\n",
 181                        (unsigned long long)pstart,
 182                        (unsigned long long)pend);
 183 }
 184
 185 /*
 186  * Statically reserve bounce buffer space and initialize bounce buffer data
 187  * structures for the software IO TLB used to implement the DMA API.
 188  */
 189 void __init
 190 swiotlb_init_with_default_size(size_t default_size)
 191 {
 192         unsigned long i, bytes;
 193
 194         if (!io_tlb_nslabs) {
 195                 io_tlb_nslabs = (default_size >> IO_TLB_SHIFT);
 196                 io_tlb_nslabs = ALIGN(io_tlb_nslabs, IO_TLB_SEGSIZE);
 197         }
 198
 199         bytes = io_tlb_nslabs << IO_TLB_SHIFT;
 200
 201         /*
 202          * Get IO TLB memory from the low pages
 203          */
 204         io_tlb_start = swiotlb_alloc_boot(bytes, io_tlb_nslabs);
 205         if (!io_tlb_start)
 206                 panic("Cannot allocate SWIOTLB buffer");
 207         io_tlb_end = io_tlb_start + bytes;
 208
 209         /*
 210          * Allocate and initialize the free list array.  This array is used
 211          * to find contiguous free memory regions of size up to IO_TLB_SEGSIZE
 212          * between io_tlb_start and io_tlb_end.
 213          */
 214         io_tlb_list = alloc_bootmem(io_tlb_nslabs * sizeof(int));
 215         for (i = 0; i < io_tlb_nslabs; i++)
 216                 io_tlb_list[i] = IO_TLB_SEGSIZE - OFFSET(i, IO_TLB_SEGSIZE);
 217         io_tlb_index = 0;
 218         io_tlb_orig_addr = alloc_bootmem(io_tlb_nslabs * sizeof(struct swiotlb_phys_addr));
 219
 220         /*
 221          * Get the overflow emergency buffer
 222          */
 223         io_tlb_overflow_buffer = alloc_bootmem_low(io_tlb_overflow);
 224         if (!io_tlb_overflow_buffer)
 225                 panic("Cannot allocate SWIOTLB overflow buffer!\n");
 226
 227         swiotlb_print_info(bytes);
 228 }
 229
 230 void __init
 231 swiotlb_init(void)
 232 {
 233         swiotlb_init_with_default_size(64 * (1<<20));   /* default to 64MB */
 234 }
 235
 236 /*
 237  * Systems with larger DMA zones (those that don't support ISA) can
 238  * initialize the swiotlb later using the slab allocator if needed.
 239  * This should be just like above, but with some error catching.
 240  */
 241 int
 242 swiotlb_late_init_with_default_size(size_t default_size)
 243 {
 244         unsigned long i, bytes, req_nslabs = io_tlb_nslabs;
 245         unsigned int order;
 246
 247         if (!io_tlb_nslabs) {
 248                 io_tlb_nslabs = (default_size >> IO_TLB_SHIFT);
 249                 io_tlb_nslabs = ALIGN(io_tlb_nslabs, IO_TLB_SEGSIZE);
 250         }
 251
 252         /*
 253          * Get IO TLB memory from the low pages
 254          */
 255         order = get_order(io_tlb_nslabs << IO_TLB_SHIFT);
 256         io_tlb_nslabs = SLABS_PER_PAGE << order;
 257         bytes = io_tlb_nslabs << IO_TLB_SHIFT;
 258
 259         while ((SLABS_PER_PAGE << order) > IO_TLB_MIN_SLABS) {
 260                 io_tlb_start = swiotlb_alloc(order, io_tlb_nslabs);
 261                 if (io_tlb_start)
 262                         break;
 263                 order--;
 264         }
 265
 266         if (!io_tlb_start)
 267                 goto cleanup1;
 268
 269         if (order != get_order(bytes)) {
 270                 printk(KERN_WARNING "Warning: only able to allocate %ld MB "
 271                        "for software IO TLB\n", (PAGE_SIZE << order) >> 20);
 272                 io_tlb_nslabs = SLABS_PER_PAGE << order;
 273                 bytes = io_tlb_nslabs << IO_TLB_SHIFT;
 274         }
 275         io_tlb_end = io_tlb_start + bytes;
 276         memset(io_tlb_start, 0, bytes);
 277
 278         /*
 279          * Allocate and initialize the free list array.  This array is used
 280          * to find contiguous free memory regions of size up to IO_TLB_SEGSIZE
 281          * between io_tlb_start and io_tlb_end.
 282          */
 283         io_tlb_list = (unsigned int *)__get_free_pages(GFP_KERNEL,
 284                                       get_order(io_tlb_nslabs * sizeof(int)));
 285         if (!io_tlb_list)
 286                 goto cleanup2;
 287
 288         for (i = 0; i < io_tlb_nslabs; i++)
 289                 io_tlb_list[i] = IO_TLB_SEGSIZE - OFFSET(i, IO_TLB_SEGSIZE);
 290         io_tlb_index = 0;
 291
 292         io_tlb_orig_addr = (struct swiotlb_phys_addr *)__get_free_pages(GFP_KERNEL,
 293                                    get_order(io_tlb_nslabs * sizeof(struct swiotlb_phys_addr)));
 294         if (!io_tlb_orig_addr)
 295                 goto cleanup3;
 296
 297         memset(io_tlb_orig_addr, 0, io_tlb_nslabs * sizeof(struct swiotlb_phys_addr));
 298
 299         /*
 300          * Get the overflow emergency buffer
 301          */
 302         io_tlb_overflow_buffer = (void *)__get_free_pages(GFP_DMA,
 303                                                   get_order(io_tlb_overflow));
 304         if (!io_tlb_overflow_buffer)
 305                 goto cleanup4;
 306
 307         swiotlb_print_info(bytes);
 308
 309         return 0;
 310
 311 cleanup4:
 312         free_pages((unsigned long)io_tlb_orig_addr, get_order(io_tlb_nslabs *
 313                                                               sizeof(char *)));
 314         io_tlb_orig_addr = NULL;
 315 cleanup3:
 316         free_pages((unsigned long)io_tlb_list, get_order(io_tlb_nslabs *
 317                                                          sizeof(int)));
 318         io_tlb_list = NULL;
 319 cleanup2:
 320         io_tlb_end = NULL;
 321         free_pages((unsigned long)io_tlb_start, order);
 322         io_tlb_start = NULL;
 323 cleanup1:
 324         io_tlb_nslabs = req_nslabs;
 325         return -ENOMEM;
 326 }
 327
 328 static int
 329 address_needs_mapping(struct device *hwdev, dma_addr_t addr, size_t size)
 330 {
 331         return !is_buffer_dma_capable(dma_get_mask(hwdev), addr, size);
 332 }
 333
 334 static inline int range_needs_mapping(void *ptr, size_t size)
 335 {
 336         return swiotlb_force || swiotlb_arch_range_needs_mapping(ptr, size);
 337 }
 338
 339 static int is_swiotlb_buffer(char *addr)
 340 {
 341         return addr >= io_tlb_start && addr < io_tlb_end;
 342 }
 343
 344 static struct swiotlb_phys_addr swiotlb_bus_to_phys_addr(char *dma_addr)
 345 {
 346         int index = (dma_addr - io_tlb_start) >> IO_TLB_SHIFT;
 347         struct swiotlb_phys_addr buffer = io_tlb_orig_addr[index];
 348         buffer.offset += (long)dma_addr & ((1 << IO_TLB_SHIFT) - 1);
 349         buffer.page += buffer.offset >> PAGE_SHIFT;
 350         buffer.offset &= PAGE_SIZE - 1;
 351         return buffer;
 352 }
 353
 354 static void
 355 __sync_single(struct swiotlb_phys_addr buffer, char *dma_addr, size_t size, int dir)
 356 {
 357         if (PageHighMem(buffer.page)) {
 358                 size_t len, bytes;
 359                 char *dev, *host, *kmp;
 360
 361                 len = size;
 362                 while (len != 0) {
 363                         unsigned long flags;
 364
 365                         bytes = len;
 366                         if ((bytes + buffer.offset) > PAGE_SIZE)
 367                                 bytes = PAGE_SIZE - buffer.offset;
 368                         local_irq_save(flags); /* protects KM_BOUNCE_READ */
 369                         kmp  = kmap_atomic(buffer.page, KM_BOUNCE_READ);
 370                         dev  = dma_addr + size - len;
 371                         host = kmp + buffer.offset;
 372                         if (dir == DMA_FROM_DEVICE)
 373                                 memcpy(host, dev, bytes);
 374                         else
 375                                 memcpy(dev, host, bytes);
 376                         kunmap_atomic(kmp, KM_BOUNCE_READ);
 377                         local_irq_restore(flags);
 378                         len -= bytes;
 379                         buffer.page++;
 380                         buffer.offset = 0;
 381                 }
 382         } else {
 383                 void *v = page_address(buffer.page) + buffer.offset;
 384
 385                 if (dir == DMA_TO_DEVICE)
 386                         memcpy(dma_addr, v, size);
 387                 else
 388                         memcpy(v, dma_addr, size);
 389         }
 390 }
 391
 392 /*
 393  * Allocates bounce buffer and returns its kernel virtual address.
 394  */
 395 static void *
 396 map_single(struct device *hwdev, struct swiotlb_phys_addr buffer, size_t size, int dir)
 397 {
 398         unsigned long flags;
 399         char *dma_addr;
 400         unsigned int nslots, stride, index, wrap;
 401         int i;
 402         unsigned long start_dma_addr;
 403         unsigned long mask;
 404         unsigned long offset_slots;
 405         unsigned long max_slots;
 406         struct swiotlb_phys_addr slot_buf;
 407
 408         mask = dma_get_seg_boundary(hwdev);
 409         start_dma_addr = swiotlb_virt_to_bus(io_tlb_start) & mask;
 410
 411         offset_slots = ALIGN(start_dma_addr, 1 << IO_TLB_SHIFT) >> IO_TLB_SHIFT;
 412
 413         /*
 414          * Carefully handle integer overflow which can occur when mask == ~0UL.
 415          */
 416         max_slots = mask + 1
 417                     ? ALIGN(mask + 1, 1 << IO_TLB_SHIFT) >> IO_TLB_SHIFT
 418                     : 1UL << (BITS_PER_LONG - IO_TLB_SHIFT);
 419
 420         /*
 421          * For mappings greater than a page, we limit the stride (and
 422          * hence alignment) to a page size.
 423          */
 424         nslots = ALIGN(size, 1 << IO_TLB_SHIFT) >> IO_TLB_SHIFT;
 425         if (size > PAGE_SIZE)
 426                 stride = (1 << (PAGE_SHIFT - IO_TLB_SHIFT));
 427         else
 428                 stride = 1;
 429
 430         BUG_ON(!nslots);
 431
 432         /*
 433          * Find suitable number of IO TLB entries size that will fit this
 434          * request and allocate a buffer from that IO TLB pool.
 435          */
 436         spin_lock_irqsave(&io_tlb_lock, flags);
 437         index = ALIGN(io_tlb_index, stride);
 438         if (index >= io_tlb_nslabs)
 439                 index = 0;
 440         wrap = index;
 441
 442         do {
 443                 while (iommu_is_span_boundary(index, nslots, offset_slots,
 444                                               max_slots)) {
 445                         index += stride;
 446                         if (index >= io_tlb_nslabs)
 447                                 index = 0;
 448                         if (index == wrap)
 449                                 goto not_found;
 450                 }
 451
 452                 /*
 453                  * If we find a slot that indicates we have 'nslots' number of
 454                  * contiguous buffers, we allocate the buffers from that slot
 455                  * and mark the entries as '0' indicating unavailable.
 456                  */
 457                 if (io_tlb_list[index] >= nslots) {
 458                         int count = 0;
 459
 460                         for (i = index; i < (int) (index + nslots); i++)
 461                                 io_tlb_list[i] = 0;
 462                         for (i = index - 1; (OFFSET(i, IO_TLB_SEGSIZE) != IO_TLB_SEGSIZE - 1) && io_tlb_list[i]; i--)
 463                                 io_tlb_list[i] = ++count;
 464                         dma_addr = io_tlb_start + (index << IO_TLB_SHIFT);
 465
 466                         /*
 467                          * Update the indices to avoid searching in the next
 468                          * round.
 469                          */
 470                         io_tlb_index = ((index + nslots) < io_tlb_nslabs
 471                                         ? (index + nslots) : 0);
 472
 473                         goto found;
 474                 }
 475                 index += stride;
 476                 if (index >= io_tlb_nslabs)
 477                         index = 0;
 478         } while (index != wrap);
 479
 480 not_found:
 481         spin_unlock_irqrestore(&io_tlb_lock, flags);
 482         return NULL;
 483 found:
 484         spin_unlock_irqrestore(&io_tlb_lock, flags);
 485
 486         /*
 487          * Save away the mapping from the original address to the DMA address.
 488          * This is needed when we sync the memory.  Then we sync the buffer if
 489          * needed.
 490          */
 491         slot_buf = buffer;
 492         for (i = 0; i < nslots; i++) {
 493                 slot_buf.page += slot_buf.offset >> PAGE_SHIFT;
 494                 slot_buf.offset &= PAGE_SIZE - 1;
 495                 io_tlb_orig_addr[index+i] = slot_buf;
 496                 slot_buf.offset += 1 << IO_TLB_SHIFT;
 497         }
 498         if (dir == DMA_TO_DEVICE || dir == DMA_BIDIRECTIONAL)
 499                 __sync_single(buffer, dma_addr, size, DMA_TO_DEVICE);
 500
 501         return dma_addr;
 502 }
 503
 504 /*
 505  * dma_addr is the kernel virtual address of the bounce buffer to unmap.
 506  */
 507 static void
 508 unmap_single(struct device *hwdev, char *dma_addr, size_t size, int dir)
 509 {
 510         unsigned long flags;
 511         int i, count, nslots = ALIGN(size, 1 << IO_TLB_SHIFT) >> IO_TLB_SHIFT;
 512         int index = (dma_addr - io_tlb_start) >> IO_TLB_SHIFT;
 513         struct swiotlb_phys_addr buffer = swiotlb_bus_to_phys_addr(dma_addr);
 514
 515         /*
 516          * First, sync the memory before unmapping the entry
 517          */
 518         if ((dir == DMA_FROM_DEVICE) || (dir == DMA_BIDIRECTIONAL))
 519                 /*
 520                  * bounce... copy the data back into the original buffer * and
 521                  * delete the bounce buffer.
 522                  */
 523                 __sync_single(buffer, dma_addr, size, DMA_FROM_DEVICE);
 524
 525         /*
 526          * Return the buffer to the free list by setting the corresponding
 527          * entries to indicate the number of contigous entries available.
 528          * While returning the entries to the free list, we merge the entries
 529          * with slots below and above the pool being returned.
 530          */
 531         spin_lock_irqsave(&io_tlb_lock, flags);
 532         {
 533                 count = ((index + nslots) < ALIGN(index + 1, IO_TLB_SEGSIZE) ?
 534                          io_tlb_list[index + nslots] : 0);
 535                 /*
 536                  * Step 1: return the slots to the free list, merging the
 537                  * slots with superceeding slots
 538                  */
 539                 for (i = index + nslots - 1; i >= index; i--)
 540                         io_tlb_list[i] = ++count;
 541                 /*
 542                  * Step 2: merge the returned slots with the preceding slots,
 543                  * if available (non zero)
 544                  */
 545                 for (i = index - 1; (OFFSET(i, IO_TLB_SEGSIZE) != IO_TLB_SEGSIZE -1) && io_tlb_list[i]; i--)
 546                         io_tlb_list[i] = ++count;
 547         }
 548         spin_unlock_irqrestore(&io_tlb_lock, flags);
 549 }
 550
 551 static void
 552 sync_single(struct device *hwdev, char *dma_addr, size_t size,
 553             int dir, int target)
 554 {
 555         struct swiotlb_phys_addr buffer = swiotlb_bus_to_phys_addr(dma_addr);
 556
 557         switch (target) {
 558         case SYNC_FOR_CPU:
 559                 if (likely(dir == DMA_FROM_DEVICE || dir == DMA_BIDIRECTIONAL))
 560                         __sync_single(buffer, dma_addr, size, DMA_FROM_DEVICE);
 561                 else
 562                         BUG_ON(dir != DMA_TO_DEVICE);
 563                 break;
 564         case SYNC_FOR_DEVICE:
 565                 if (likely(dir == DMA_TO_DEVICE || dir == DMA_BIDIRECTIONAL))
 566                         __sync_single(buffer, dma_addr, size, DMA_TO_DEVICE);
 567                 else
 568                         BUG_ON(dir != DMA_FROM_DEVICE);
 569                 break;
 570         default:
 571                 BUG();
 572         }
 573 }
 574
 575 void *
 576 swiotlb_alloc_coherent(struct device *hwdev, size_t size,
 577                        dma_addr_t *dma_handle, gfp_t flags)
 578 {
 579         dma_addr_t dev_addr;
 580         void *ret;
 581         int order = get_order(size);
 582         u64 dma_mask = DMA_32BIT_MASK;
 583
 584         if (hwdev && hwdev->coherent_dma_mask)
 585                 dma_mask = hwdev->coherent_dma_mask;
 586
 587         ret = (void *)__get_free_pages(flags, order);
 588         if (ret && !is_buffer_dma_capable(dma_mask, swiotlb_virt_to_bus(ret), size)) {
 589                 /*
 590                  * The allocated memory isn't reachable by the device.
 591                  * Fall back on swiotlb_map_single().
 592                  */
 593                 free_pages((unsigned long) ret, order);
 594                 ret = NULL;
 595         }
 596         if (!ret) {
 597                 /*
 598                  * We are either out of memory or the device can't DMA
 599                  * to GFP_DMA memory; fall back on
 600                  * swiotlb_map_single(), which will grab memory from
 601                  * the lowest available address range.
 602                  */
 603                 struct swiotlb_phys_addr buffer;
 604                 buffer.page = virt_to_page(NULL);
 605                 buffer.offset = 0;
 606                 ret = map_single(hwdev, buffer, size, DMA_FROM_DEVICE);
 607                 if (!ret)
 608                         return NULL;
 609         }
 610
 611         memset(ret, 0, size);
 612         dev_addr = swiotlb_virt_to_bus(ret);
 613
 614         /* Confirm address can be DMA'd by device */
 615         if (!is_buffer_dma_capable(dma_mask, dev_addr, size)) {
 616                 printk("hwdev DMA mask = 0x%016Lx, dev_addr = 0x%016Lx\n",
 617                        (unsigned long long)dma_mask,
 618                        (unsigned long long)dev_addr);
 619
 620                 /* DMA_TO_DEVICE to avoid memcpy in unmap_single */
 621                 unmap_single(hwdev, ret, size, DMA_TO_DEVICE);
 622                 return NULL;
 623         }
 624         *dma_handle = dev_addr;
 625         return ret;
 626 }
 627
 628 void
 629 swiotlb_free_coherent(struct device *hwdev, size_t size, void *vaddr,
 630                       dma_addr_t dma_handle)
 631 {
 632         WARN_ON(irqs_disabled());
 633         if (!is_swiotlb_buffer(vaddr))
 634                 free_pages((unsigned long) vaddr, get_order(size));
 635         else
 636                 /* DMA_TO_DEVICE to avoid memcpy in unmap_single */
 637                 unmap_single(hwdev, vaddr, size, DMA_TO_DEVICE);
 638 }
 639
 640 static void
 641 swiotlb_full(struct device *dev, size_t size, int dir, int do_panic)
 642 {
 643         /*
 644          * Ran out of IOMMU space for this operation. This is very bad.
 645          * Unfortunately the drivers cannot handle this operation properly.
 646          * unless they check for dma_mapping_error (most don't)
 647          * When the mapping is small enough return a static buffer to limit
 648          * the damage, or panic when the transfer is too big.
 649          */
 650         printk(KERN_ERR "DMA: Out of SW-IOMMU space for %zu bytes at "
 651                "device %s\n", size, dev ? dev->bus_id : "?");
 652
 653         if (size > io_tlb_overflow && do_panic) {
 654                 if (dir == DMA_FROM_DEVICE || dir == DMA_BIDIRECTIONAL)
 655                         panic("DMA: Memory would be corrupted\n");
 656                 if (dir == DMA_TO_DEVICE || dir == DMA_BIDIRECTIONAL)
 657                         panic("DMA: Random memory would be DMAed\n");
 658         }
 659 }
 660
 661 /*
 662  * Map a single buffer of the indicated size for DMA in streaming mode.  The
 663  * physical address to use is returned.
 664  *
 665  * Once the device is given the dma address, the device owns this memory until
 666  * either swiotlb_unmap_single or swiotlb_dma_sync_single is performed.
 667  */
 668 dma_addr_t
 669 swiotlb_map_single_attrs(struct device *hwdev, void *ptr, size_t size,
 670                          int dir, struct dma_attrs *attrs)
 671 {
 672         dma_addr_t dev_addr = swiotlb_virt_to_bus(ptr);
 673         void *map;
 674         struct swiotlb_phys_addr buffer;
 675
 676         BUG_ON(dir == DMA_NONE);
 677         /*
 678          * If the pointer passed in happens to be in the device's DMA window,
 679          * we can safely return the device addr and not worry about bounce
 680          * buffering it.
 681          */
 682         if (!address_needs_mapping(hwdev, dev_addr, size) &&
 683             !range_needs_mapping(ptr, size))
 684                 return dev_addr;
 685
 686         /*
 687          * Oh well, have to allocate and map a bounce buffer.
 688          */
 689         buffer.page   = virt_to_page(ptr);
 690         buffer.offset = (unsigned long)ptr & ~PAGE_MASK;
 691         map = map_single(hwdev, buffer, size, dir);
 692         if (!map) {
 693                 swiotlb_full(hwdev, size, dir, 1);
 694                 map = io_tlb_overflow_buffer;
 695         }
 696
 697         dev_addr = swiotlb_virt_to_bus(map);
 698
 699         /*
 700          * Ensure that the address returned is DMA'ble
 701          */
 702         if (address_needs_mapping(hwdev, dev_addr, size))
 703                 panic("map_single: bounce buffer is not DMA'ble");
 704
 705         return dev_addr;
 706 }
 707 EXPORT_SYMBOL(swiotlb_map_single_attrs);
 708
 709 dma_addr_t
 710 swiotlb_map_single(struct device *hwdev, void *ptr, size_t size, int dir)
 711 {
 712         return swiotlb_map_single_attrs(hwdev, ptr, size, dir, NULL);
 713 }
 714
 715 /*
 716  * Unmap a single streaming mode DMA translation.  The dma_addr and size must
 717  * match what was provided for in a previous swiotlb_map_single call.  All
 718  * other usages are undefined.
 719  *
 720  * After this call, reads by the cpu to the buffer are guaranteed to see
 721  * whatever the device wrote there.
 722  */
 723 void
 724 swiotlb_unmap_single_attrs(struct device *hwdev, dma_addr_t dev_addr,
 725                            size_t size, int dir, struct dma_attrs *attrs)
 726 {
 727         char *dma_addr = swiotlb_bus_to_virt(dev_addr);
 728
 729         BUG_ON(dir == DMA_NONE);
 730         if (is_swiotlb_buffer(dma_addr))
 731                 unmap_single(hwdev, dma_addr, size, dir);
 732         else if (dir == DMA_FROM_DEVICE)
 733                 dma_mark_clean(dma_addr, size);
 734 }
 735 EXPORT_SYMBOL(swiotlb_unmap_single_attrs);
 736
 737 void
 738 swiotlb_unmap_single(struct device *hwdev, dma_addr_t dev_addr, size_t size,
 739                      int dir)
 740 {
 741         return swiotlb_unmap_single_attrs(hwdev, dev_addr, size, dir, NULL);
 742 }
 743 /*
 744  * Make physical memory consistent for a single streaming mode DMA translation
 745  * after a transfer.
 746  *
 747  * If you perform a swiotlb_map_single() but wish to interrogate the buffer
 748  * using the cpu, yet do not wish to teardown the dma mapping, you must
 749  * call this function before doing so.  At the next point you give the dma
 750  * address back to the card, you must first perform a
 751  * swiotlb_dma_sync_for_device, and then the device again owns the buffer
 752  */
 753 static void
 754 swiotlb_sync_single(struct device *hwdev, dma_addr_t dev_addr,
 755                     size_t size, int dir, int target)
 756 {
 757         char *dma_addr = swiotlb_bus_to_virt(dev_addr);
 758
 759         BUG_ON(dir == DMA_NONE);
 760         if (is_swiotlb_buffer(dma_addr))
 761                 sync_single(hwdev, dma_addr, size, dir, target);
 762         else if (dir == DMA_FROM_DEVICE)
 763                 dma_mark_clean(dma_addr, size);
 764 }
 765
 766 void
 767 swiotlb_sync_single_for_cpu(struct device *hwdev, dma_addr_t dev_addr,
 768                             size_t size, int dir)
 769 {
 770         swiotlb_sync_single(hwdev, dev_addr, size, dir, SYNC_FOR_CPU);
 771 }
 772
 773 void
 774 swiotlb_sync_single_for_device(struct device *hwdev, dma_addr_t dev_addr,
 775                                size_t size, int dir)
 776 {
 777         swiotlb_sync_single(hwdev, dev_addr, size, dir, SYNC_FOR_DEVICE);
 778 }
 779
 780 /*
 781  * Same as above, but for a sub-range of the mapping.
 782  */
 783 static void
 784 swiotlb_sync_single_range(struct device *hwdev, dma_addr_t dev_addr,
 785                           unsigned long offset, size_t size,
 786                           int dir, int target)
 787 {
 788         char *dma_addr = swiotlb_bus_to_virt(dev_addr) + offset;
 789
 790         BUG_ON(dir == DMA_NONE);
 791         if (is_swiotlb_buffer(dma_addr))
 792                 sync_single(hwdev, dma_addr, size, dir, target);
 793         else if (dir == DMA_FROM_DEVICE)
 794                 dma_mark_clean(dma_addr, size);
 795 }
 796
 797 void
 798 swiotlb_sync_single_range_for_cpu(struct device *hwdev, dma_addr_t dev_addr,
 799                                   unsigned long offset, size_t size, int dir)
 800 {
 801         swiotlb_sync_single_range(hwdev, dev_addr, offset, size, dir,
 802                                   SYNC_FOR_CPU);
 803 }
 804
 805 void
 806 swiotlb_sync_single_range_for_device(struct device *hwdev, dma_addr_t dev_addr,
 807                                      unsigned long offset, size_t size, int dir)
 808 {
 809         swiotlb_sync_single_range(hwdev, dev_addr, offset, size, dir,
 810                                   SYNC_FOR_DEVICE);
 811 }
 812
 813 void swiotlb_unmap_sg_attrs(struct device *, struct scatterlist *, int, int,
 814                             struct dma_attrs *);
 815 /*
 816  * Map a set of buffers described by scatterlist in streaming mode for DMA.
 817  * This is the scatter-gather version of the above swiotlb_map_single
 818  * interface.  Here the scatter gather list elements are each tagged with the
 819  * appropriate dma address and length.  They are obtained via
 820  * sg_dma_{address,length}(SG).
 821  *
 822  * NOTE: An implementation may be able to use a smaller number of
 823  *       DMA address/length pairs than there are SG table elements.
 824  *       (for example via virtual mapping capabilities)
 825  *       The routine returns the number of addr/length pairs actually
 826  *       used, at most nents.
 827  *
 828  * Device ownership issues as mentioned above for swiotlb_map_single are the
 829  * same here.
 830  */
 831 int
 832 swiotlb_map_sg_attrs(struct device *hwdev, struct scatterlist *sgl, int nelems,
 833                      int dir, struct dma_attrs *attrs)
 834 {
 835         struct scatterlist *sg;
 836         struct swiotlb_phys_addr buffer;
 837         dma_addr_t dev_addr;
 838         int i;
 839
 840         BUG_ON(dir == DMA_NONE);
 841
 842         for_each_sg(sgl, sg, nelems, i) {
 843                 dev_addr = swiotlb_sg_to_bus(sg);
 844                 if (range_needs_mapping(sg_virt(sg), sg->length) ||
 845                     address_needs_mapping(hwdev, dev_addr, sg->length)) {
 846                         void *map;
 847                         buffer.page   = sg_page(sg);
 848                         buffer.offset = sg->offset;
 849                         map = map_single(hwdev, buffer, sg->length, dir);
 850                         if (!map) {
 851                                 /* Don't panic here, we expect map_sg users
 852                                    to do proper error handling. */
 853                                 swiotlb_full(hwdev, sg->length, dir, 0);
 854                                 swiotlb_unmap_sg_attrs(hwdev, sgl, i, dir,
 855                                                        attrs);
 856                                 sgl[0].dma_length = 0;
 857                                 return 0;
 858                         }
 859                         sg->dma_address = swiotlb_virt_to_bus(map);
 860                 } else
 861                         sg->dma_address = dev_addr;
 862                 sg->dma_length = sg->length;
 863         }
 864         return nelems;
 865 }
 866 EXPORT_SYMBOL(swiotlb_map_sg_attrs);
 867
 868 int
 869 swiotlb_map_sg(struct device *hwdev, struct scatterlist *sgl, int nelems,
 870                int dir)
 871 {
 872         return swiotlb_map_sg_attrs(hwdev, sgl, nelems, dir, NULL);
 873 }
 874
 875 /*
 876  * Unmap a set of streaming mode DMA translations.  Again, cpu read rules
 877  * concerning calls here are the same as for swiotlb_unmap_single() above.
 878  */
 879 void
 880 swiotlb_unmap_sg_attrs(struct device *hwdev, struct scatterlist *sgl,
 881                        int nelems, int dir, struct dma_attrs *attrs)
 882 {
 883         struct scatterlist *sg;
 884         int i;
 885
 886         BUG_ON(dir == DMA_NONE);
 887
 888         for_each_sg(sgl, sg, nelems, i) {
 889                 if (sg->dma_address != swiotlb_sg_to_bus(sg))
 890                         unmap_single(hwdev, swiotlb_bus_to_virt(sg->dma_address),
 891                                      sg->dma_length, dir);
 892                 else if (dir == DMA_FROM_DEVICE)
 893                         dma_mark_clean(swiotlb_bus_to_virt(sg->dma_address), sg->dma_length);
 894         }
 895 }
 896 EXPORT_SYMBOL(swiotlb_unmap_sg_attrs);
 897
 898 void
 899 swiotlb_unmap_sg(struct device *hwdev, struct scatterlist *sgl, int nelems,
 900                  int dir)
 901 {
 902         return swiotlb_unmap_sg_attrs(hwdev, sgl, nelems, dir, NULL);
 903 }
 904
 905 /*
 906  * Make physical memory consistent for a set of streaming mode DMA translations
 907  * after a transfer.
 908  *
 909  * The same as swiotlb_sync_single_* but for a scatter-gather list, same rules
 910  * and usage.
 911  */
 912 static void
 913 swiotlb_sync_sg(struct device *hwdev, struct scatterlist *sgl,
 914                 int nelems, int dir, int target)
 915 {
 916         struct scatterlist *sg;
 917         int i;
 918
 919         BUG_ON(dir == DMA_NONE);
 920
 921         for_each_sg(sgl, sg, nelems, i) {
 922                 if (sg->dma_address != swiotlb_sg_to_bus(sg))
 923                         sync_single(hwdev, swiotlb_bus_to_virt(sg->dma_address),
 924                                     sg->dma_length, dir, target);
 925                 else if (dir == DMA_FROM_DEVICE)
 926                         dma_mark_clean(swiotlb_bus_to_virt(sg->dma_address), sg->dma_length);
 927         }
 928 }
 929
 930 void
 931 swiotlb_sync_sg_for_cpu(struct device *hwdev, struct scatterlist *sg,
 932                         int nelems, int dir)
 933 {
 934         swiotlb_sync_sg(hwdev, sg, nelems, dir, SYNC_FOR_CPU);
 935 }
 936
 937 void
 938 swiotlb_sync_sg_for_device(struct device *hwdev, struct scatterlist *sg,
 939                            int nelems, int dir)
 940 {
 941         swiotlb_sync_sg(hwdev, sg, nelems, dir, SYNC_FOR_DEVICE);
 942 }
 943
 944 int
 945 swiotlb_dma_mapping_error(struct device *hwdev, dma_addr_t dma_addr)
 946 {
 947         return (dma_addr == swiotlb_virt_to_bus(io_tlb_overflow_buffer));
 948 }
 949
 950 /*
 951  * Return whether the given device DMA address mask can be supported
 952  * properly.  For example, if your device can only drive the low 24-bits
 953  * during bus mastering, then you would pass 0x00ffffff as the mask to
 954  * this function.
 955  */
 956 int
 957 swiotlb_dma_supported(struct device *hwdev, u64 mask)
 958 {
 959         return swiotlb_virt_to_bus(io_tlb_end - 1) <= mask;
 960 }
 961
 962 EXPORT_SYMBOL(swiotlb_map_single);
 963 EXPORT_SYMBOL(swiotlb_unmap_single);
 964 EXPORT_SYMBOL(swiotlb_map_sg);
 965 EXPORT_SYMBOL(swiotlb_unmap_sg);
 966 EXPORT_SYMBOL(swiotlb_sync_single_for_cpu);
 967 EXPORT_SYMBOL(swiotlb_sync_single_for_device);
 968 EXPORT_SYMBOL_GPL(swiotlb_sync_single_range_for_cpu);
 969 EXPORT_SYMBOL_GPL(swiotlb_sync_single_range_for_device);
 970 EXPORT_SYMBOL(swiotlb_sync_sg_for_cpu);
 971 EXPORT_SYMBOL(swiotlb_sync_sg_for_device);
 972 EXPORT_SYMBOL(swiotlb_dma_mapping_error);
 973 EXPORT_SYMBOL(swiotlb_alloc_coherent);
 974 EXPORT_SYMBOL(swiotlb_free_coherent);
 975 EXPORT_SYMBOL(swiotlb_dma_supported);