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