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 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 int dma_supported(struct device *dev, u64 mask)
 196 {
 197         struct dma_mapping_ops *ops = get_dma_ops(dev);
 198
 199 #ifdef CONFIG_PCI
 200         if (mask > 0xffffffff && forbid_dac > 0) {
 201                 dev_info(dev, "PCI: Disallowing DAC for device\n");
 202                 return 0;
 203         }
 204 #endif
 205
 206         if (ops->dma_supported)
 207                 return ops->dma_supported(dev, mask);
 208
 209         /* Copied from i386. Doesn't make much sense, because it will
 210            only work for pci_alloc_coherent.
 211            The caller just has to use GFP_DMA in this case. */
 212         if (mask < DMA_24BIT_MASK)
 213                 return 0;
 214
 215         /* Tell the device to use SAC when IOMMU force is on.  This
 216            allows the driver to use cheaper accesses in some cases.
 217
 218            Problem with this is that if we overflow the IOMMU area and
 219            return DAC as fallback address the device may not handle it
 220            correctly.
 221
 222            As a special case some controllers have a 39bit address
 223            mode that is as efficient as 32bit (aic79xx). Don't force
 224            SAC for these.  Assume all masks <= 40 bits are of this
 225            type. Normally this doesn't make any difference, but gives
 226            more gentle handling of IOMMU overflow. */
 227         if (iommu_sac_force && (mask >= DMA_40BIT_MASK)) {
 228                 dev_info(dev, "Force SAC with mask %Lx\n", mask);
 229                 return 0;
 230         }
 231
 232         return 1;
 233 }
 234 EXPORT_SYMBOL(dma_supported);
 235
 236 /* Allocate DMA memory on node near device */
 237 static noinline struct page *
 238 dma_alloc_pages(struct device *dev, gfp_t gfp, unsigned order)
 239 {
 240         int node;
 241
 242         node = dev_to_node(dev);
 243
 244         return alloc_pages_node(node, gfp, order);
 245 }
 246
 247 /*
 248  * Allocate memory for a coherent mapping.
 249  */
 250 void *
 251 dma_alloc_coherent(struct device *dev, size_t size, dma_addr_t *dma_handle,
 252                    gfp_t gfp)
 253 {
 254         struct dma_mapping_ops *ops = get_dma_ops(dev);
 255         void *memory = NULL;
 256         struct page *page;
 257         unsigned long dma_mask = 0;
 258         dma_addr_t bus;
 259         int noretry = 0;
 260
 261         /* ignore region specifiers */
 262         gfp &= ~(__GFP_DMA | __GFP_HIGHMEM | __GFP_DMA32);
 263
 264         if (dma_alloc_from_coherent(dev, size, dma_handle, &memory))
 265                 return memory;
 266
 267         if (!dev) {
 268                 dev = &fallback_dev;
 269                 gfp |= GFP_DMA;
 270         }
 271         dma_mask = dev->coherent_dma_mask;
 272         if (dma_mask == 0)
 273                 dma_mask = (gfp & GFP_DMA) ? DMA_24BIT_MASK : DMA_32BIT_MASK;
 274
 275         /* Device not DMA able */
 276         if (dev->dma_mask == NULL)
 277                 return NULL;
 278
 279         /* Don't invoke OOM killer or retry in lower 16MB DMA zone */
 280         if (gfp & __GFP_DMA)
 281                 noretry = 1;
 282
 283 #ifdef CONFIG_X86_64
 284         /* Why <=? Even when the mask is smaller than 4GB it is often
 285            larger than 16MB and in this case we have a chance of
 286            finding fitting memory in the next higher zone first. If
 287            not retry with true GFP_DMA. -AK */
 288         if (dma_mask <= DMA_32BIT_MASK && !(gfp & GFP_DMA)) {
 289                 gfp |= GFP_DMA32;
 290                 if (dma_mask < DMA_32BIT_MASK)
 291                         noretry = 1;
 292         }
 293 #endif
 294
 295  again:
 296         page = dma_alloc_pages(dev,
 297                 noretry ? gfp | __GFP_NORETRY : gfp, get_order(size));
 298         if (page == NULL)
 299                 return NULL;
 300
 301         {
 302                 int high, mmu;
 303                 bus = page_to_phys(page);
 304                 memory = page_address(page);
 305                 high = (bus + size) >= dma_mask;
 306                 mmu = high;
 307                 if (force_iommu && !(gfp & GFP_DMA))
 308                         mmu = 1;
 309                 else if (high) {
 310                         free_pages((unsigned long)memory,
 311                                    get_order(size));
 312
 313                         /* Don't use the 16MB ZONE_DMA unless absolutely
 314                            needed. It's better to use remapping first. */
 315                         if (dma_mask < DMA_32BIT_MASK && !(gfp & GFP_DMA)) {
 316                                 gfp = (gfp & ~GFP_DMA32) | GFP_DMA;
 317                                 goto again;
 318                         }
 319
 320                         /* Let low level make its own zone decisions */
 321                         gfp &= ~(GFP_DMA32|GFP_DMA);
 322
 323                         if (ops->alloc_coherent)
 324                                 return ops->alloc_coherent(dev, size,
 325                                                            dma_handle, gfp);
 326                         return NULL;
 327                 }
 328
 329                 memset(memory, 0, size);
 330                 if (!mmu) {
 331                         *dma_handle = bus;
 332                         return memory;
 333                 }
 334         }
 335
 336         if (ops->alloc_coherent) {
 337                 free_pages((unsigned long)memory, get_order(size));
 338                 gfp &= ~(GFP_DMA|GFP_DMA32);
 339                 return ops->alloc_coherent(dev, size, dma_handle, gfp);
 340         }
 341
 342         if (ops->map_simple) {
 343                 *dma_handle = ops->map_simple(dev, virt_to_phys(memory),
 344                                               size,
 345                                               PCI_DMA_BIDIRECTIONAL);
 346                 if (*dma_handle != bad_dma_address)
 347                         return memory;
 348         }
 349
 350         if (panic_on_overflow)
 351                 panic("dma_alloc_coherent: IOMMU overflow by %lu bytes\n",
 352                       (unsigned long)size);
 353         free_pages((unsigned long)memory, get_order(size));
 354         return NULL;
 355 }
 356 EXPORT_SYMBOL(dma_alloc_coherent);
 357
 358 /*
 359  * Unmap coherent memory.
 360  * The caller must ensure that the device has finished accessing the mapping.
 361  */
 362 void dma_free_coherent(struct device *dev, size_t size,
 363                          void *vaddr, dma_addr_t bus)
 364 {
 365         struct dma_mapping_ops *ops = get_dma_ops(dev);
 366
 367         int order = get_order(size);
 368         WARN_ON(irqs_disabled());       /* for portability */
 369         if (dma_release_from_coherent(dev, order, vaddr))
 370                 return;
 371         if (ops->unmap_single)
 372                 ops->unmap_single(dev, bus, size, 0);
 373         free_pages((unsigned long)vaddr, order);
 374 }
 375 EXPORT_SYMBOL(dma_free_coherent);
 376
 377 static int __init pci_iommu_init(void)
 378 {
 379         calgary_iommu_init();
 380
 381         intel_iommu_init();
 382
 383         amd_iommu_init();
 384
 385         gart_iommu_init();
 386
 387         no_iommu_init();
 388         return 0;
 389 }
 390
 391 void pci_iommu_shutdown(void)
 392 {
 393         gart_iommu_shutdown();
 394 }
 395 /* Must execute after PCI subsystem */
 396 fs_initcall(pci_iommu_init);
 397
 398 #ifdef CONFIG_PCI
 399 /* Many VIA bridges seem to corrupt data for DAC. Disable it here */
 400
 401 static __devinit void via_no_dac(struct pci_dev *dev)
 402 {
 403         if ((dev->class >> 8) == PCI_CLASS_BRIDGE_PCI && forbid_dac == 0) {
 404                 printk(KERN_INFO "PCI: VIA PCI bridge detected."
 405                                  "Disabling DAC.\n");
 406                 forbid_dac = 1;
 407         }
 408 }
 409 DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_VIA, PCI_ANY_ID, via_no_dac);
 410 #endif