arch/x86/kernel/pci-dma-xen.c

   1 #include <linux/dma-mapping.h>
   2 #include <linux/dma-debug.h>
   3 #include <linux/dmar.h>
   4 #include <linux/bootmem.h>
   5 #include <linux/pci.h>
   6 #include <linux/kmemleak.h>
   7
   8 #include <asm/proto.h>
   9 #include <asm/dma.h>
  10 #include <asm/iommu.h>
  11 #include <asm/gart.h>
  12 #include <asm/calgary.h>
  13 #include <asm/amd_iommu.h>
  14
  15 static int forbid_dac __read_mostly;
  16
  17 struct dma_map_ops *dma_ops;
  18 EXPORT_SYMBOL(dma_ops);
  19
  20 static int iommu_sac_force __read_mostly;
  21
  22 #ifdef CONFIG_IOMMU_DEBUG
  23 int panic_on_overflow __read_mostly = 1;
  24 int force_iommu __read_mostly = 1;
  25 #else
  26 int panic_on_overflow __read_mostly = 0;
  27 int force_iommu __read_mostly = 0;
  28 #endif
  29
  30 int iommu_merge __read_mostly = 0;
  31
  32 int no_iommu __read_mostly;
  33 /* Set this to 1 if there is a HW IOMMU in the system */
  34 int iommu_detected __read_mostly = 0;
  35
  36 /*
  37  * This variable becomes 1 if iommu=pt is passed on the kernel command line.
  38  * If this variable is 1, IOMMU implementations do no DMA translation for
  39  * devices and allow every device to access to whole physical memory. This is
  40  * useful if a user want to use an IOMMU only for KVM device assignment to
  41  * guests and not for driver dma translation.
  42  */
  43 int iommu_pass_through __read_mostly;
  44
  45 dma_addr_t bad_dma_address __read_mostly = 0;
  46 EXPORT_SYMBOL(bad_dma_address);
  47
  48 /* Dummy device used for NULL arguments (normally ISA). */
  49 struct device x86_dma_fallback_dev = {
  50         .init_name = "fallback device",
  51         .coherent_dma_mask = ISA_DMA_BIT_MASK,
  52         .dma_mask = &x86_dma_fallback_dev.coherent_dma_mask,
  53 };
  54 EXPORT_SYMBOL(x86_dma_fallback_dev);
  55
  56 /* Number of entries preallocated for DMA-API debugging */
  57 #define PREALLOC_DMA_DEBUG_ENTRIES       32768
  58
  59 int dma_set_mask(struct device *dev, u64 mask)
  60 {
  61         if (!dev->dma_mask || !dma_supported(dev, mask))
  62                 return -EIO;
  63
  64         *dev->dma_mask = mask;
  65
  66         return 0;
  67 }
  68 EXPORT_SYMBOL(dma_set_mask);
  69
  70 #if defined(CONFIG_X86_64) && !defined(CONFIG_XEN)
  71 static __initdata void *dma32_bootmem_ptr;
  72 static unsigned long dma32_bootmem_size __initdata = (128ULL<<20);
  73
  74 static int __init parse_dma32_size_opt(char *p)
  75 {
  76         if (!p)
  77                 return -EINVAL;
  78         dma32_bootmem_size = memparse(p, &p);
  79         return 0;
  80 }
  81 early_param("dma32_size", parse_dma32_size_opt);
  82
  83 void __init dma32_reserve_bootmem(void)
  84 {
  85         unsigned long size, align;
  86         if (max_pfn <= MAX_DMA32_PFN)
  87                 return;
  88
  89         /*
  90          * check aperture_64.c allocate_aperture() for reason about
  91          * using 512M as goal
  92          */
  93         align = 64ULL<<20;
  94         size = roundup(dma32_bootmem_size, align);
  95         dma32_bootmem_ptr = __alloc_bootmem_nopanic(size, align,
  96                                  512ULL<<20);
  97         /*
  98          * Kmemleak should not scan this block as it may not be mapped via the
  99          * kernel direct mapping.
 100          */
 101         kmemleak_ignore(dma32_bootmem_ptr);
 102         if (dma32_bootmem_ptr)
 103                 dma32_bootmem_size = size;
 104         else
 105                 dma32_bootmem_size = 0;
 106 }
 107 static void __init dma32_free_bootmem(void)
 108 {
 109
 110         if (max_pfn <= MAX_DMA32_PFN)
 111                 return;
 112
 113         if (!dma32_bootmem_ptr)
 114                 return;
 115
 116         free_bootmem(__pa(dma32_bootmem_ptr), dma32_bootmem_size);
 117
 118         dma32_bootmem_ptr = NULL;
 119         dma32_bootmem_size = 0;
 120 }
 121 #endif
 122
 123 static struct dma_map_ops swiotlb_dma_ops = {
 124         .alloc_coherent = dma_generic_alloc_coherent,
 125         .free_coherent = dma_generic_free_coherent,
 126         .mapping_error = swiotlb_dma_mapping_error,
 127         .map_page = swiotlb_map_page,
 128         .unmap_page = swiotlb_unmap_page,
 129         .sync_single_for_cpu = swiotlb_sync_single_for_cpu,
 130         .sync_single_for_device = swiotlb_sync_single_for_device,
 131         .sync_single_range_for_cpu = swiotlb_sync_single_range_for_cpu,
 132         .sync_single_range_for_device = swiotlb_sync_single_range_for_device,
 133         .sync_sg_for_cpu = swiotlb_sync_sg_for_cpu,
 134         .sync_sg_for_device = swiotlb_sync_sg_for_device,
 135         .map_sg = swiotlb_map_sg_attrs,
 136         .unmap_sg = swiotlb_unmap_sg_attrs,
 137         .dma_supported = swiotlb_dma_supported
 138 };
 139
 140 void __init pci_iommu_alloc(void)
 141 {
 142 #if defined(CONFIG_X86_64) && !defined(CONFIG_XEN)
 143         /* free the range so iommu could get some range less than 4G */
 144         dma32_free_bootmem();
 145 #endif
 146
 147         /*
 148          * The order of these functions is important for
 149          * fall-back/fail-over reasons
 150          */
 151         gart_iommu_hole_init();
 152
 153         detect_calgary();
 154
 155         detect_intel_iommu();
 156
 157         amd_iommu_detect();
 158
 159         swiotlb_init();
 160         if (swiotlb) {
 161                 printk(KERN_INFO "PCI-DMA: Using software bounce buffering for IO (SWIOTLB)\n");
 162                 dma_ops = &swiotlb_dma_ops;
 163         }
 164 }
 165
 166 void *dma_generic_alloc_coherent(struct device *dev, size_t size,
 167                                  dma_addr_t *dma_addr, gfp_t flag)
 168 {
 169         unsigned long dma_mask;
 170         struct page *page;
 171 #ifndef CONFIG_XEN
 172         dma_addr_t addr;
 173 #else
 174         void *memory;
 175 #endif
 176         unsigned int order = get_order(size);
 177
 178         dma_mask = dma_alloc_coherent_mask(dev, flag);
 179
 180 #ifndef CONFIG_XEN
 181         flag |= __GFP_ZERO;
 182 again:
 183 #else
 184         flag &= ~(__GFP_DMA | __GFP_DMA32);
 185 #endif
 186         page = alloc_pages_node(dev_to_node(dev), flag, order);
 187         if (!page)
 188                 return NULL;
 189
 190 #ifndef CONFIG_XEN
 191         addr = page_to_phys(page);
 192         if (addr + size > dma_mask) {
 193                 __free_pages(page, order);
 194
 195                 if (dma_mask < DMA_BIT_MASK(32) && !(flag & GFP_DMA)) {
 196                         flag = (flag & ~GFP_DMA32) | GFP_DMA;
 197                         goto again;
 198                 }
 199
 200                 return NULL;
 201         }
 202
 203         *dma_addr = addr;
 204         return page_address(page);
 205 #else
 206         memory = page_address(page);
 207         if (xen_create_contiguous_region((unsigned long)memory, order,
 208                                          fls64(dma_mask))) {
 209                 __free_pages(page, order);
 210                 return NULL;
 211         }
 212
 213         *dma_addr = virt_to_bus(memory);
 214         return memset(memory, 0, size);
 215 #endif
 216 }
 217
 218 #ifdef CONFIG_XEN
 219 void dma_generic_free_coherent(struct device *dev, size_t size, void *vaddr,
 220                                dma_addr_t dma_addr)
 221 {
 222         unsigned int order = get_order(size);
 223         unsigned long va = (unsigned long)vaddr;
 224
 225         xen_destroy_contiguous_region(va, order);
 226         free_pages(va, order);
 227 }
 228 #endif
 229
 230 /*
 231  * See <Documentation/x86_64/boot-options.txt> for the iommu kernel parameter
 232  * documentation.
 233  */
 234 static __init int iommu_setup(char *p)
 235 {
 236         iommu_merge = 1;
 237
 238         if (!p)
 239                 return -EINVAL;
 240
 241         while (*p) {
 242                 if (!strncmp(p, "off", 3))
 243                         no_iommu = 1;
 244                 /* gart_parse_options has more force support */
 245                 if (!strncmp(p, "force", 5))
 246                         force_iommu = 1;
 247                 if (!strncmp(p, "noforce", 7)) {
 248                         iommu_merge = 0;
 249                         force_iommu = 0;
 250                 }
 251
 252                 if (!strncmp(p, "biomerge", 8)) {
 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                 if (!strncmp(p, "usedac", 6)) {
 273                         forbid_dac = -1;
 274                         return 1;
 275                 }
 276 #ifdef CONFIG_SWIOTLB
 277                 if (!strncmp(p, "soft", 4))
 278                         swiotlb = 1;
 279 #endif
 280                 if (!strncmp(p, "pt", 2))
 281                         iommu_pass_through = 1;
 282
 283                 gart_parse_options(p);
 284
 285 #ifdef CONFIG_CALGARY_IOMMU
 286                 if (!strncmp(p, "calgary", 7))
 287                         use_calgary = 1;
 288 #endif /* CONFIG_CALGARY_IOMMU */
 289
 290                 p += strcspn(p, ",");
 291                 if (*p == ',')
 292                         ++p;
 293         }
 294         return 0;
 295 }
 296 early_param("iommu", iommu_setup);
 297
 298 static int check_pages_physically_contiguous(unsigned long pfn,
 299                                              unsigned int offset,
 300                                              size_t length)
 301 {
 302         unsigned long next_mfn;
 303         int i;
 304         int nr_pages;
 305
 306         next_mfn = pfn_to_mfn(pfn);
 307         nr_pages = (offset + length + PAGE_SIZE-1) >> PAGE_SHIFT;
 308
 309         for (i = 1; i < nr_pages; i++) {
 310                 if (pfn_to_mfn(++pfn) != ++next_mfn)
 311                         return 0;
 312         }
 313         return 1;
 314 }
 315
 316 int range_straddles_page_boundary(paddr_t p, size_t size)
 317 {
 318         unsigned long pfn = p >> PAGE_SHIFT;
 319         unsigned int offset = p & ~PAGE_MASK;
 320
 321         return ((offset + size > PAGE_SIZE) &&
 322                 !check_pages_physically_contiguous(pfn, offset, size));
 323 }
 324
 325 int dma_supported(struct device *dev, u64 mask)
 326 {
 327         struct dma_map_ops *ops = get_dma_ops(dev);
 328
 329 #ifdef CONFIG_PCI
 330         if (mask > 0xffffffff && forbid_dac > 0) {
 331                 dev_info(dev, "PCI: Disallowing DAC for device\n");
 332                 return 0;
 333         }
 334 #endif
 335
 336         if (ops->dma_supported)
 337                 return ops->dma_supported(dev, mask);
 338
 339         /* Copied from i386. Doesn't make much sense, because it will
 340            only work for pci_alloc_coherent.
 341            The caller just has to use GFP_DMA in this case. */
 342         if (mask < DMA_BIT_MASK(24))
 343                 return 0;
 344
 345         /* Tell the device to use SAC when IOMMU force is on.  This
 346            allows the driver to use cheaper accesses in some cases.
 347
 348            Problem with this is that if we overflow the IOMMU area and
 349            return DAC as fallback address the device may not handle it
 350            correctly.
 351
 352            As a special case some controllers have a 39bit address
 353            mode that is as efficient as 32bit (aic79xx). Don't force
 354            SAC for these.  Assume all masks <= 40 bits are of this
 355            type. Normally this doesn't make any difference, but gives
 356            more gentle handling of IOMMU overflow. */
 357         if (iommu_sac_force && (mask >= DMA_BIT_MASK(40))) {
 358                 dev_info(dev, "Force SAC with mask %Lx\n", mask);
 359                 return 0;
 360         }
 361
 362         return 1;
 363 }
 364 EXPORT_SYMBOL(dma_supported);
 365
 366 static int __init pci_iommu_init(void)
 367 {
 368         dma_debug_init(PREALLOC_DMA_DEBUG_ENTRIES);
 369
 370 #ifdef CONFIG_PCI
 371         dma_debug_add_bus(&pci_bus_type);
 372 #endif
 373
 374         calgary_iommu_init();
 375
 376         intel_iommu_init();
 377
 378         amd_iommu_init();
 379
 380         gart_iommu_init();
 381
 382         no_iommu_init();
 383         return 0;
 384 }
 385
 386 void pci_iommu_shutdown(void)
 387 {
 388         gart_iommu_shutdown();
 389
 390         amd_iommu_shutdown();
 391 }
 392 /* Must execute after PCI subsystem */
 393 rootfs_initcall(pci_iommu_init);
 394
 395 #ifdef CONFIG_PCI
 396 /* Many VIA bridges seem to corrupt data for DAC. Disable it here */
 397
 398 static __devinit void via_no_dac(struct pci_dev *dev)
 399 {
 400         if ((dev->class >> 8) == PCI_CLASS_BRIDGE_PCI && forbid_dac == 0) {
 401                 dev_info(&dev->dev, "disabling DAC on VIA PCI bridge\n");
 402                 forbid_dac = 1;
 403         }
 404 }
 405 DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_VIA, PCI_ANY_ID, via_no_dac);
 406
 407 /*
 408  * MCP51 PCI bridge corrupts data for DAC.  Disable it.  Reported in
 409  * bnc#463829.
 410  */
 411 static __devinit void mcp51_no_dac(struct pci_dev *dev)
 412 {
 413         if (forbid_dac == 0) {
 414                 printk(KERN_INFO
 415                        "PCI: MCP51 PCI bridge detected. Disabling DAC.\n");
 416                 forbid_dac = 1;
 417         }
 418 }
 419 DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_NVIDIA, 0x026f, mcp51_no_dac);
 420 #endif