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