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