arch/x86/kernel/pci-dma_64.c

   1 /*
   2  * Dynamic DMA mapping support.
   3  */
   4
   5 #include <linux/types.h>
   6 #include <linux/mm.h>
   7 #include <linux/string.h>
   8 #include <linux/pci.h>
   9 #include <linux/module.h>
  10 #include <linux/dmar.h>
  11 #include <asm/io.h>
  12 #include <asm/gart.h>
  13 #include <asm/calgary.h>
  14
  15 int iommu_merge __read_mostly = 1;
  16 EXPORT_SYMBOL(iommu_merge);
  17
  18 dma_addr_t bad_dma_address __read_mostly;
  19 EXPORT_SYMBOL(bad_dma_address);
  20
  21 /* This tells the BIO block layer to assume merging. Default to off
  22    because we cannot guarantee merging later. */
  23 int iommu_bio_merge __read_mostly = 0;
  24 EXPORT_SYMBOL(iommu_bio_merge);
  25
  26 static int iommu_sac_force __read_mostly = 0;
  27
  28 int no_iommu __read_mostly;
  29 #ifdef CONFIG_IOMMU_DEBUG
  30 int panic_on_overflow __read_mostly = 1;
  31 int force_iommu __read_mostly = 1;
  32 #else
  33 int panic_on_overflow __read_mostly = 0;
  34 int force_iommu __read_mostly= 0;
  35 #endif
  36
  37 /* Set this to 1 if there is a HW IOMMU in the system */
  38 int iommu_detected __read_mostly = 0;
  39
  40 /* Dummy device used for NULL arguments (normally ISA). Better would
  41    be probably a smaller DMA mask, but this is bug-to-bug compatible
  42    to i386. */
  43 struct device fallback_dev = {
  44         .bus_id = "fallback device",
  45         .coherent_dma_mask = DMA_32BIT_MASK,
  46         .dma_mask = &fallback_dev.coherent_dma_mask,
  47 };
  48
  49 /* Allocate DMA memory on node near device */
  50 noinline static void *
  51 dma_alloc_pages(struct device *dev, gfp_t gfp, unsigned order)
  52 {
  53         struct page *page;
  54         int node;
  55
  56         node = dev_to_node(dev);
  57         if (node == -1)
  58                 node = numa_node_id();
  59
  60         if (node < first_node(node_online_map))
  61                 node = first_node(node_online_map);
  62
  63         page = alloc_pages_node(node, gfp, order);
  64         return page ? page_address(page) : NULL;
  65 }
  66
  67 /*
  68  * Allocate memory for a coherent mapping.
  69  */
  70 void *
  71 dma_alloc_coherent(struct device *dev, size_t size, dma_addr_t *dma_handle,
  72                    gfp_t gfp)
  73 {
  74         void *memory;
  75         unsigned long dma_mask = 0;
  76         u64 bus;
  77
  78         if (!dev)
  79                 dev = &fallback_dev;
  80         dma_mask = dev->coherent_dma_mask;
  81         if (dma_mask == 0)
  82                 dma_mask = DMA_32BIT_MASK;
  83
  84         /* Device not DMA able */
  85         if (dev->dma_mask == NULL)
  86                 return NULL;
  87
  88         /* Don't invoke OOM killer */
  89         gfp |= __GFP_NORETRY;
  90
  91         /* Kludge to make it bug-to-bug compatible with i386. i386
  92            uses the normal dma_mask for alloc_coherent. */
  93         dma_mask &= *dev->dma_mask;
  94
  95         /* Why <=? Even when the mask is smaller than 4GB it is often
  96            larger than 16MB and in this case we have a chance of
  97            finding fitting memory in the next higher zone first. If
  98            not retry with true GFP_DMA. -AK */
  99         if (dma_mask <= DMA_32BIT_MASK)
 100                 gfp |= GFP_DMA32;
 101
 102  again:
 103         memory = dma_alloc_pages(dev, gfp, get_order(size));
 104         if (memory == NULL)
 105                 return NULL;
 106
 107         {
 108                 int high, mmu;
 109                 bus = virt_to_bus(memory);
 110                 high = (bus + size) >= dma_mask;
 111                 mmu = high;
 112                 if (force_iommu && !(gfp & GFP_DMA))
 113                         mmu = 1;
 114                 else if (high) {
 115                         free_pages((unsigned long)memory,
 116                                    get_order(size));
 117
 118                         /* Don't use the 16MB ZONE_DMA unless absolutely
 119                            needed. It's better to use remapping first. */
 120                         if (dma_mask < DMA_32BIT_MASK && !(gfp & GFP_DMA)) {
 121                                 gfp = (gfp & ~GFP_DMA32) | GFP_DMA;
 122                                 goto again;
 123                         }
 124
 125                         /* Let low level make its own zone decisions */
 126                         gfp &= ~(GFP_DMA32|GFP_DMA);
 127
 128                         if (dma_ops->alloc_coherent)
 129                                 return dma_ops->alloc_coherent(dev, size,
 130                                                            dma_handle, gfp);
 131                         return NULL;
 132                 }
 133
 134                 memset(memory, 0, size);
 135                 if (!mmu) {
 136                         *dma_handle = virt_to_bus(memory);
 137                         return memory;
 138                 }
 139         }
 140
 141         if (dma_ops->alloc_coherent) {
 142                 free_pages((unsigned long)memory, get_order(size));
 143                 gfp &= ~(GFP_DMA|GFP_DMA32);
 144                 return dma_ops->alloc_coherent(dev, size, dma_handle, gfp);
 145         }
 146
 147         if (dma_ops->map_simple) {
 148                 *dma_handle = dma_ops->map_simple(dev, memory,
 149                                               size,
 150                                               PCI_DMA_BIDIRECTIONAL);
 151                 if (*dma_handle != bad_dma_address)
 152                         return memory;
 153         }
 154
 155         if (panic_on_overflow)
 156                 panic("dma_alloc_coherent: IOMMU overflow by %lu bytes\n",size);
 157         free_pages((unsigned long)memory, get_order(size));
 158         return NULL;
 159 }
 160 EXPORT_SYMBOL(dma_alloc_coherent);
 161
 162 /*
 163  * Unmap coherent memory.
 164  * The caller must ensure that the device has finished accessing the mapping.
 165  */
 166 void dma_free_coherent(struct device *dev, size_t size,
 167                          void *vaddr, dma_addr_t bus)
 168 {
 169         WARN_ON(irqs_disabled());       /* for portability */
 170         if (dma_ops->unmap_single)
 171                 dma_ops->unmap_single(dev, bus, size, 0);
 172         free_pages((unsigned long)vaddr, get_order(size));
 173 }
 174 EXPORT_SYMBOL(dma_free_coherent);
 175
 176 static int forbid_dac __read_mostly;
 177
 178 int dma_supported(struct device *dev, u64 mask)
 179 {
 180 #ifdef CONFIG_PCI
 181         if (mask > 0xffffffff && forbid_dac > 0) {
 182
 183
 184
 185                 printk(KERN_INFO "PCI: Disallowing DAC for device %s\n", dev->bus_id);
 186                 return 0;
 187         }
 188 #endif
 189
 190         if (dma_ops->dma_supported)
 191                 return dma_ops->dma_supported(dev, mask);
 192
 193         /* Copied from i386. Doesn't make much sense, because it will
 194            only work for pci_alloc_coherent.
 195            The caller just has to use GFP_DMA in this case. */
 196         if (mask < DMA_24BIT_MASK)
 197                 return 0;
 198
 199         /* Tell the device to use SAC when IOMMU force is on.  This
 200            allows the driver to use cheaper accesses in some cases.
 201
 202            Problem with this is that if we overflow the IOMMU area and
 203            return DAC as fallback address the device may not handle it
 204            correctly.
 205
 206            As a special case some controllers have a 39bit address
 207            mode that is as efficient as 32bit (aic79xx). Don't force
 208            SAC for these.  Assume all masks <= 40 bits are of this
 209            type. Normally this doesn't make any difference, but gives
 210            more gentle handling of IOMMU overflow. */
 211         if (iommu_sac_force && (mask >= DMA_40BIT_MASK)) {
 212                 printk(KERN_INFO "%s: Force SAC with mask %Lx\n", dev->bus_id,mask);
 213                 return 0;
 214         }
 215
 216         return 1;
 217 }
 218 EXPORT_SYMBOL(dma_supported);
 219
 220 int dma_set_mask(struct device *dev, u64 mask)
 221 {
 222         if (!dev->dma_mask || !dma_supported(dev, mask))
 223                 return -EIO;
 224         *dev->dma_mask = mask;
 225         return 0;
 226 }
 227 EXPORT_SYMBOL(dma_set_mask);
 228
 229 /*
 230  * See <Documentation/x86_64/boot-options.txt> for the iommu kernel parameter
 231  * documentation.
 232  */
 233 __init int iommu_setup(char *p)
 234 {
 235         iommu_merge = 1;
 236
 237         if (!p)
 238                 return -EINVAL;
 239
 240         while (*p) {
 241                 if (!strncmp(p,"off",3))
 242                         no_iommu = 1;
 243                 /* gart_parse_options has more force support */
 244                 if (!strncmp(p,"force",5))
 245                         force_iommu = 1;
 246                 if (!strncmp(p,"noforce",7)) {
 247                         iommu_merge = 0;
 248                         force_iommu = 0;
 249                 }
 250
 251                 if (!strncmp(p, "biomerge",8)) {
 252                         iommu_bio_merge = 4096;
 253                         iommu_merge = 1;
 254                         force_iommu = 1;
 255                 }
 256                 if (!strncmp(p, "panic",5))
 257                         panic_on_overflow = 1;
 258                 if (!strncmp(p, "nopanic",7))
 259                         panic_on_overflow = 0;
 260                 if (!strncmp(p, "merge",5)) {
 261                         iommu_merge = 1;
 262                         force_iommu = 1;
 263                 }
 264                 if (!strncmp(p, "nomerge",7))
 265                         iommu_merge = 0;
 266                 if (!strncmp(p, "forcesac",8))
 267                         iommu_sac_force = 1;
 268                 if (!strncmp(p, "allowdac", 8))
 269                         forbid_dac = 0;
 270                 if (!strncmp(p, "nodac", 5))
 271                         forbid_dac = -1;
 272
 273 #ifdef CONFIG_SWIOTLB
 274                 if (!strncmp(p, "soft",4))
 275                         swiotlb = 1;
 276 #endif
 277
 278 #ifdef CONFIG_GART_IOMMU
 279                 gart_parse_options(p);
 280 #endif
 281
 282 #ifdef CONFIG_CALGARY_IOMMU
 283                 if (!strncmp(p, "calgary", 7))
 284                         use_calgary = 1;
 285 #endif /* CONFIG_CALGARY_IOMMU */
 286
 287                 p += strcspn(p, ",");
 288                 if (*p == ',')
 289                         ++p;
 290         }
 291         return 0;
 292 }
 293 early_param("iommu", iommu_setup);
 294
 295 void __init pci_iommu_alloc(void)
 296 {
 297         /*
 298          * The order of these functions is important for
 299          * fall-back/fail-over reasons
 300          */
 301 #ifdef CONFIG_GART_IOMMU
 302         gart_iommu_hole_init();
 303 #endif
 304
 305 #ifdef CONFIG_CALGARY_IOMMU
 306         detect_calgary();
 307 #endif
 308
 309         detect_intel_iommu();
 310
 311 #ifdef CONFIG_SWIOTLB
 312         pci_swiotlb_init();
 313 #endif
 314 }
 315
 316 static int __init pci_iommu_init(void)
 317 {
 318 #ifdef CONFIG_CALGARY_IOMMU
 319         calgary_iommu_init();
 320 #endif
 321
 322         intel_iommu_init();
 323
 324 #ifdef CONFIG_GART_IOMMU
 325         gart_iommu_init();
 326 #endif
 327
 328         no_iommu_init();
 329         return 0;
 330 }
 331
 332 void pci_iommu_shutdown(void)
 333 {
 334         gart_iommu_shutdown();
 335 }
 336
 337 #ifdef CONFIG_PCI
 338 /* Many VIA bridges seem to corrupt data for DAC. Disable it here */
 339
 340 static __devinit void via_no_dac(struct pci_dev *dev)
 341 {
 342         if ((dev->class >> 8) == PCI_CLASS_BRIDGE_PCI && forbid_dac == 0) {
 343                 printk(KERN_INFO "PCI: VIA PCI bridge detected. Disabling DAC.\n");
 344                 forbid_dac = 1;
 345         }
 346 }
 347 DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_VIA, PCI_ANY_ID, via_no_dac);
 348 #endif
 349 /* Must execute after PCI subsystem */
 350 fs_initcall(pci_iommu_init);