arch/x86/kernel/pci-dma.c

   1 #include <linux/dma-mapping.h>
   2 #include <linux/dmar.h>
   3 #include <linux/bootmem.h>
   4 #include <linux/pci.h>
   5
   6 #include <asm/proto.h>
   7 #include <asm/dma.h>
   8 #include <asm/gart.h>
   9 #include <asm/calgary.h>
  10
  11 int forbid_dac __read_mostly;
  12 EXPORT_SYMBOL(forbid_dac);
  13
  14 const struct dma_mapping_ops *dma_ops;
  15 EXPORT_SYMBOL(dma_ops);
  16
  17 static int iommu_sac_force __read_mostly;
  18
  19 #ifdef CONFIG_IOMMU_DEBUG
  20 int panic_on_overflow __read_mostly = 1;
  21 int force_iommu __read_mostly = 1;
  22 #else
  23 int panic_on_overflow __read_mostly = 0;
  24 int force_iommu __read_mostly = 0;
  25 #endif
  26
  27 int iommu_merge __read_mostly = 0;
  28
  29 int no_iommu __read_mostly;
  30 /* Set this to 1 if there is a HW IOMMU in the system */
  31 int iommu_detected __read_mostly = 0;
  32
  33 /* This tells the BIO block layer to assume merging. Default to off
  34    because we cannot guarantee merging later. */
  35 int iommu_bio_merge __read_mostly = 0;
  36 EXPORT_SYMBOL(iommu_bio_merge);
  37
  38 dma_addr_t bad_dma_address __read_mostly = 0;
  39 EXPORT_SYMBOL(bad_dma_address);
  40
  41 /* Dummy device used for NULL arguments (normally ISA). Better would
  42    be probably a smaller DMA mask, but this is bug-to-bug compatible
  43    to older i386. */
  44 struct device fallback_dev = {
  45         .bus_id = "fallback device",
  46         .coherent_dma_mask = DMA_32BIT_MASK,
  47         .dma_mask = &fallback_dev.coherent_dma_mask,
  48 };
  49
  50 int dma_set_mask(struct device *dev, u64 mask)
  51 {
  52         if (!dev->dma_mask || !dma_supported(dev, mask))
  53                 return -EIO;
  54
  55         *dev->dma_mask = mask;
  56
  57         return 0;
  58 }
  59 EXPORT_SYMBOL(dma_set_mask);
  60
  61 #ifdef CONFIG_X86_64
  62 static __initdata void *dma32_bootmem_ptr;
  63 static unsigned long dma32_bootmem_size __initdata = (128ULL<<20);
  64
  65 static int __init parse_dma32_size_opt(char *p)
  66 {
  67         if (!p)
  68                 return -EINVAL;
  69         dma32_bootmem_size = memparse(p, &p);
  70         return 0;
  71 }
  72 early_param("dma32_size", parse_dma32_size_opt);
  73
  74 void __init dma32_reserve_bootmem(void)
  75 {
  76         unsigned long size, align;
  77         if (end_pfn <= MAX_DMA32_PFN)
  78                 return;
  79
  80         /*
  81          * check aperture_64.c allocate_aperture() for reason about
  82          * using 512M as goal
  83          */
  84         align = 64ULL<<20;
  85         size = round_up(dma32_bootmem_size, align);
  86         dma32_bootmem_ptr = __alloc_bootmem_nopanic(size, align,
  87                                  512ULL<<20);
  88         if (dma32_bootmem_ptr)
  89                 dma32_bootmem_size = size;
  90         else
  91                 dma32_bootmem_size = 0;
  92 }
  93 static void __init dma32_free_bootmem(void)
  94 {
  95
  96         if (end_pfn <= MAX_DMA32_PFN)
  97                 return;
  98
  99         if (!dma32_bootmem_ptr)
 100                 return;
 101
 102         free_bootmem(__pa(dma32_bootmem_ptr), dma32_bootmem_size);
 103
 104         dma32_bootmem_ptr = NULL;
 105         dma32_bootmem_size = 0;
 106 }
 107
 108 void __init pci_iommu_alloc(void)
 109 {
 110         /* free the range so iommu could get some range less than 4G */
 111         dma32_free_bootmem();
 112         /*
 113          * The order of these functions is important for
 114          * fall-back/fail-over reasons
 115          */
 116 #ifdef CONFIG_GART_IOMMU
 117         gart_iommu_hole_init();
 118 #endif
 119
 120 #ifdef CONFIG_CALGARY_IOMMU
 121         detect_calgary();
 122 #endif
 123
 124         detect_intel_iommu();
 125
 126 #ifdef CONFIG_SWIOTLB
 127         pci_swiotlb_init();
 128 #endif
 129 }
 130 #endif
 131
 132 /*
 133  * See <Documentation/x86_64/boot-options.txt> for the iommu kernel parameter
 134  * documentation.
 135  */
 136 static __init int iommu_setup(char *p)
 137 {
 138         iommu_merge = 1;
 139
 140         if (!p)
 141                 return -EINVAL;
 142
 143         while (*p) {
 144                 if (!strncmp(p, "off", 3))
 145                         no_iommu = 1;
 146                 /* gart_parse_options has more force support */
 147                 if (!strncmp(p, "force", 5))
 148                         force_iommu = 1;
 149                 if (!strncmp(p, "noforce", 7)) {
 150                         iommu_merge = 0;
 151                         force_iommu = 0;
 152                 }
 153
 154                 if (!strncmp(p, "biomerge", 8)) {
 155                         iommu_bio_merge = 4096;
 156                         iommu_merge = 1;
 157                         force_iommu = 1;
 158                 }
 159                 if (!strncmp(p, "panic", 5))
 160                         panic_on_overflow = 1;
 161                 if (!strncmp(p, "nopanic", 7))
 162                         panic_on_overflow = 0;
 163                 if (!strncmp(p, "merge", 5)) {
 164                         iommu_merge = 1;
 165                         force_iommu = 1;
 166                 }
 167                 if (!strncmp(p, "nomerge", 7))
 168                         iommu_merge = 0;
 169                 if (!strncmp(p, "forcesac", 8))
 170                         iommu_sac_force = 1;
 171                 if (!strncmp(p, "allowdac", 8))
 172                         forbid_dac = 0;
 173                 if (!strncmp(p, "nodac", 5))
 174                         forbid_dac = -1;
 175                 if (!strncmp(p, "usedac", 6)) {
 176                         forbid_dac = -1;
 177                         return 1;
 178                 }
 179 #ifdef CONFIG_SWIOTLB
 180                 if (!strncmp(p, "soft", 4))
 181                         swiotlb = 1;
 182 #endif
 183
 184 #ifdef CONFIG_GART_IOMMU
 185                 gart_parse_options(p);
 186 #endif
 187
 188 #ifdef CONFIG_CALGARY_IOMMU
 189                 if (!strncmp(p, "calgary", 7))
 190                         use_calgary = 1;
 191 #endif /* CONFIG_CALGARY_IOMMU */
 192
 193                 p += strcspn(p, ",");
 194                 if (*p == ',')
 195                         ++p;
 196         }
 197         return 0;
 198 }
 199 early_param("iommu", iommu_setup);
 200
 201 #ifdef CONFIG_X86_32
 202 int dma_declare_coherent_memory(struct device *dev, dma_addr_t bus_addr,
 203                                 dma_addr_t device_addr, size_t size, int flags)
 204 {
 205         void __iomem *mem_base = NULL;
 206         int pages = size >> PAGE_SHIFT;
 207         int bitmap_size = BITS_TO_LONGS(pages) * sizeof(long);
 208
 209         if ((flags & (DMA_MEMORY_MAP | DMA_MEMORY_IO)) == 0)
 210                 goto out;
 211         if (!size)
 212                 goto out;
 213         if (dev->dma_mem)
 214                 goto out;
 215
 216         /* FIXME: this routine just ignores DMA_MEMORY_INCLUDES_CHILDREN */
 217
 218         mem_base = ioremap(bus_addr, size);
 219         if (!mem_base)
 220                 goto out;
 221
 222         dev->dma_mem = kzalloc(sizeof(struct dma_coherent_mem), GFP_KERNEL);
 223         if (!dev->dma_mem)
 224                 goto out;
 225         dev->dma_mem->bitmap = kzalloc(bitmap_size, GFP_KERNEL);
 226         if (!dev->dma_mem->bitmap)
 227                 goto free1_out;
 228
 229         dev->dma_mem->virt_base = mem_base;
 230         dev->dma_mem->device_base = device_addr;
 231         dev->dma_mem->size = pages;
 232         dev->dma_mem->flags = flags;
 233
 234         if (flags & DMA_MEMORY_MAP)
 235                 return DMA_MEMORY_MAP;
 236
 237         return DMA_MEMORY_IO;
 238
 239  free1_out:
 240         kfree(dev->dma_mem);
 241  out:
 242         if (mem_base)
 243                 iounmap(mem_base);
 244         return 0;
 245 }
 246 EXPORT_SYMBOL(dma_declare_coherent_memory);
 247
 248 void dma_release_declared_memory(struct device *dev)
 249 {
 250         struct dma_coherent_mem *mem = dev->dma_mem;
 251
 252         if (!mem)
 253                 return;
 254         dev->dma_mem = NULL;
 255         iounmap(mem->virt_base);
 256         kfree(mem->bitmap);
 257         kfree(mem);
 258 }
 259 EXPORT_SYMBOL(dma_release_declared_memory);
 260
 261 void *dma_mark_declared_memory_occupied(struct device *dev,
 262                                         dma_addr_t device_addr, size_t size)
 263 {
 264         struct dma_coherent_mem *mem = dev->dma_mem;
 265         int pos, err;
 266         int pages = (size + (device_addr & ~PAGE_MASK) + PAGE_SIZE - 1);
 267
 268         pages >>= PAGE_SHIFT;
 269
 270         if (!mem)
 271                 return ERR_PTR(-EINVAL);
 272
 273         pos = (device_addr - mem->device_base) >> PAGE_SHIFT;
 274         err = bitmap_allocate_region(mem->bitmap, pos, get_order(pages));
 275         if (err != 0)
 276                 return ERR_PTR(err);
 277         return mem->virt_base + (pos << PAGE_SHIFT);
 278 }
 279 EXPORT_SYMBOL(dma_mark_declared_memory_occupied);
 280
 281 static int dma_alloc_from_coherent_mem(struct device *dev, ssize_t size,
 282                                        dma_addr_t *dma_handle, void **ret)
 283 {
 284         struct dma_coherent_mem *mem = dev ? dev->dma_mem : NULL;
 285         int order = get_order(size);
 286
 287         if (mem) {
 288                 int page = bitmap_find_free_region(mem->bitmap, mem->size,
 289                                                      order);
 290                 if (page >= 0) {
 291                         *dma_handle = mem->device_base + (page << PAGE_SHIFT);
 292                         *ret = mem->virt_base + (page << PAGE_SHIFT);
 293                         memset(*ret, 0, size);
 294                 }
 295                 if (mem->flags & DMA_MEMORY_EXCLUSIVE)
 296                         *ret = NULL;
 297         }
 298         return (mem != NULL);
 299 }
 300
 301 static int dma_release_coherent(struct device *dev, int order, void *vaddr)
 302 {
 303         struct dma_coherent_mem *mem = dev ? dev->dma_mem : NULL;
 304
 305         if (mem && vaddr >= mem->virt_base && vaddr <
 306                    (mem->virt_base + (mem->size << PAGE_SHIFT))) {
 307                 int page = (vaddr - mem->virt_base) >> PAGE_SHIFT;
 308
 309                 bitmap_release_region(mem->bitmap, page, order);
 310                 return 1;
 311         }
 312         return 0;
 313 }
 314 #else
 315 #define dma_alloc_from_coherent_mem(dev, size, handle, ret) (0)
 316 #define dma_release_coherent(dev, order, vaddr) (0)
 317 #endif /* CONFIG_X86_32 */
 318
 319 int dma_supported(struct device *dev, u64 mask)
 320 {
 321 #ifdef CONFIG_PCI
 322         if (mask > 0xffffffff && forbid_dac > 0) {
 323                 printk(KERN_INFO "PCI: Disallowing DAC for device %s\n",
 324                                  dev->bus_id);
 325                 return 0;
 326         }
 327 #endif
 328
 329         if (dma_ops->dma_supported)
 330                 return dma_ops->dma_supported(dev, mask);
 331
 332         /* Copied from i386. Doesn't make much sense, because it will
 333            only work for pci_alloc_coherent.
 334            The caller just has to use GFP_DMA in this case. */
 335         if (mask < DMA_24BIT_MASK)
 336                 return 0;
 337
 338         /* Tell the device to use SAC when IOMMU force is on.  This
 339            allows the driver to use cheaper accesses in some cases.
 340
 341            Problem with this is that if we overflow the IOMMU area and
 342            return DAC as fallback address the device may not handle it
 343            correctly.
 344
 345            As a special case some controllers have a 39bit address
 346            mode that is as efficient as 32bit (aic79xx). Don't force
 347            SAC for these.  Assume all masks <= 40 bits are of this
 348            type. Normally this doesn't make any difference, but gives
 349            more gentle handling of IOMMU overflow. */
 350         if (iommu_sac_force && (mask >= DMA_40BIT_MASK)) {
 351                 printk(KERN_INFO "%s: Force SAC with mask %Lx\n",
 352                                  dev->bus_id, mask);
 353                 return 0;
 354         }
 355
 356         return 1;
 357 }
 358 EXPORT_SYMBOL(dma_supported);
 359
 360 /* Allocate DMA memory on node near device */
 361 static noinline struct page *
 362 dma_alloc_pages(struct device *dev, gfp_t gfp, unsigned order)
 363 {
 364         int node;
 365
 366         node = dev_to_node(dev);
 367
 368         return alloc_pages_node(node, gfp, order);
 369 }
 370
 371 /*
 372  * Allocate memory for a coherent mapping.
 373  */
 374 void *
 375 dma_alloc_coherent(struct device *dev, size_t size, dma_addr_t *dma_handle,
 376                    gfp_t gfp)
 377 {
 378         void *memory = NULL;
 379         struct page *page;
 380         unsigned long dma_mask = 0;
 381         dma_addr_t bus;
 382         int noretry = 0;
 383
 384         /* ignore region specifiers */
 385         gfp &= ~(__GFP_DMA | __GFP_HIGHMEM | __GFP_DMA32);
 386
 387         if (dma_alloc_from_coherent_mem(dev, size, dma_handle, &memory))
 388                 return memory;
 389
 390         if (!dev) {
 391                 dev = &fallback_dev;
 392                 gfp |= GFP_DMA;
 393         }
 394         dma_mask = dev->coherent_dma_mask;
 395         if (dma_mask == 0)
 396                 dma_mask = (gfp & GFP_DMA) ? DMA_24BIT_MASK : DMA_32BIT_MASK;
 397
 398         /* Device not DMA able */
 399         if (dev->dma_mask == NULL)
 400                 return NULL;
 401
 402         /* Don't invoke OOM killer or retry in lower 16MB DMA zone */
 403         if (gfp & __GFP_DMA)
 404                 noretry = 1;
 405
 406 #ifdef CONFIG_X86_64
 407         /* Why <=? Even when the mask is smaller than 4GB it is often
 408            larger than 16MB and in this case we have a chance of
 409            finding fitting memory in the next higher zone first. If
 410            not retry with true GFP_DMA. -AK */
 411         if (dma_mask <= DMA_32BIT_MASK && !(gfp & GFP_DMA)) {
 412                 gfp |= GFP_DMA32;
 413                 if (dma_mask < DMA_32BIT_MASK)
 414                         noretry = 1;
 415         }
 416 #endif
 417
 418  again:
 419         page = dma_alloc_pages(dev,
 420                 noretry ? gfp | __GFP_NORETRY : gfp, get_order(size));
 421         if (page == NULL)
 422                 return NULL;
 423
 424         {
 425                 int high, mmu;
 426                 bus = page_to_phys(page);
 427                 memory = page_address(page);
 428                 high = (bus + size) >= dma_mask;
 429                 mmu = high;
 430                 if (force_iommu && !(gfp & GFP_DMA))
 431                         mmu = 1;
 432                 else if (high) {
 433                         free_pages((unsigned long)memory,
 434                                    get_order(size));
 435
 436                         /* Don't use the 16MB ZONE_DMA unless absolutely
 437                            needed. It's better to use remapping first. */
 438                         if (dma_mask < DMA_32BIT_MASK && !(gfp & GFP_DMA)) {
 439                                 gfp = (gfp & ~GFP_DMA32) | GFP_DMA;
 440                                 goto again;
 441                         }
 442
 443                         /* Let low level make its own zone decisions */
 444                         gfp &= ~(GFP_DMA32|GFP_DMA);
 445
 446                         if (dma_ops->alloc_coherent)
 447                                 return dma_ops->alloc_coherent(dev, size,
 448                                                            dma_handle, gfp);
 449                         return NULL;
 450                 }
 451
 452                 memset(memory, 0, size);
 453                 if (!mmu) {
 454                         *dma_handle = bus;
 455                         return memory;
 456                 }
 457         }
 458
 459         if (dma_ops->alloc_coherent) {
 460                 free_pages((unsigned long)memory, get_order(size));
 461                 gfp &= ~(GFP_DMA|GFP_DMA32);
 462                 return dma_ops->alloc_coherent(dev, size, dma_handle, gfp);
 463         }
 464
 465         if (dma_ops->map_simple) {
 466                 *dma_handle = dma_ops->map_simple(dev, virt_to_phys(memory),
 467                                               size,
 468                                               PCI_DMA_BIDIRECTIONAL);
 469                 if (*dma_handle != bad_dma_address)
 470                         return memory;
 471         }
 472
 473         if (panic_on_overflow)
 474                 panic("dma_alloc_coherent: IOMMU overflow by %lu bytes\n",
 475                       (unsigned long)size);
 476         free_pages((unsigned long)memory, get_order(size));
 477         return NULL;
 478 }
 479 EXPORT_SYMBOL(dma_alloc_coherent);
 480
 481 /*
 482  * Unmap coherent memory.
 483  * The caller must ensure that the device has finished accessing the mapping.
 484  */
 485 void dma_free_coherent(struct device *dev, size_t size,
 486                          void *vaddr, dma_addr_t bus)
 487 {
 488         int order = get_order(size);
 489         WARN_ON(irqs_disabled());       /* for portability */
 490         if (dma_release_coherent(dev, order, vaddr))
 491                 return;
 492         if (dma_ops->unmap_single)
 493                 dma_ops->unmap_single(dev, bus, size, 0);
 494         free_pages((unsigned long)vaddr, order);
 495 }
 496 EXPORT_SYMBOL(dma_free_coherent);
 497
 498 static int __init pci_iommu_init(void)
 499 {
 500 #ifdef CONFIG_CALGARY_IOMMU
 501         calgary_iommu_init();
 502 #endif
 503
 504         intel_iommu_init();
 505
 506 #ifdef CONFIG_GART_IOMMU
 507         gart_iommu_init();
 508 #endif
 509
 510         no_iommu_init();
 511         return 0;
 512 }
 513
 514 void pci_iommu_shutdown(void)
 515 {
 516         gart_iommu_shutdown();
 517 }
 518 /* Must execute after PCI subsystem */
 519 fs_initcall(pci_iommu_init);
 520
 521 #ifdef CONFIG_PCI
 522 /* Many VIA bridges seem to corrupt data for DAC. Disable it here */
 523
 524 static __devinit void via_no_dac(struct pci_dev *dev)
 525 {
 526         if ((dev->class >> 8) == PCI_CLASS_BRIDGE_PCI && forbid_dac == 0) {
 527                 printk(KERN_INFO "PCI: VIA PCI bridge detected."
 528                                  "Disabling DAC.\n");
 529                 forbid_dac = 1;
 530         }
 531 }
 532 DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_VIA, PCI_ANY_ID, via_no_dac);
 533 #endif