arch/x86/kernel/pci-dma.c

   1 #include <linux/dma-mapping.h>
   2 #include <linux/dma-debug.h>
   3 #include <linux/dmar.h>
   4 #include <linux/export.h>
   5 #include <linux/bootmem.h>
   6 #include <linux/gfp.h>
   7 #include <linux/pci.h>
   8 #include <linux/kmemleak.h>
   9
  10 #include <asm/proto.h>
  11 #include <asm/dma.h>
  12 #include <asm/iommu.h>
  13 #include <asm/gart.h>
  14 #include <asm/calgary.h>
  15 #include <asm/x86_init.h>
  16 #include <asm/iommu_table.h>
  17
  18 static int forbid_dac __read_mostly;
  19
  20 struct dma_map_ops *dma_ops = &nommu_dma_ops;
  21 EXPORT_SYMBOL(dma_ops);
  22
  23 static int iommu_sac_force __read_mostly;
  24
  25 #ifdef CONFIG_IOMMU_DEBUG
  26 int panic_on_overflow __read_mostly = 1;
  27 int force_iommu __read_mostly = 1;
  28 #else
  29 int panic_on_overflow __read_mostly = 0;
  30 int force_iommu __read_mostly = 0;
  31 #endif
  32
  33 int iommu_merge __read_mostly = 0;
  34
  35 int no_iommu __read_mostly;
  36 /* Set this to 1 if there is a HW IOMMU in the system */
  37 int iommu_detected __read_mostly = 0;
  38
  39 /*
  40  * This variable becomes 1 if iommu=pt is passed on the kernel command line.
  41  * If this variable is 1, IOMMU implementations do no DMA translation for
  42  * devices and allow every device to access to whole physical memory. This is
  43  * useful if a user wants to use an IOMMU only for KVM device assignment to
  44  * guests and not for driver dma translation.
  45  */
  46 int iommu_pass_through __read_mostly;
  47
  48 extern struct iommu_table_entry __iommu_table[], __iommu_table_end[];
  49
  50 /* Dummy device used for NULL arguments (normally ISA). */
  51 struct device x86_dma_fallback_dev = {
  52         .init_name = "fallback device",
  53         .coherent_dma_mask = ISA_DMA_BIT_MASK,
  54         .dma_mask = &x86_dma_fallback_dev.coherent_dma_mask,
  55 };
  56 EXPORT_SYMBOL(x86_dma_fallback_dev);
  57
  58 /* Number of entries preallocated for DMA-API debugging */
  59 #define PREALLOC_DMA_DEBUG_ENTRIES       65536
  60
  61 int dma_set_mask(struct device *dev, u64 mask)
  62 {
  63         if (!dev->dma_mask || !dma_supported(dev, mask))
  64                 return -EIO;
  65
  66         *dev->dma_mask = mask;
  67
  68         return 0;
  69 }
  70 EXPORT_SYMBOL(dma_set_mask);
  71
  72 void __init pci_iommu_alloc(void)
  73 {
  74         struct iommu_table_entry *p;
  75
  76         sort_iommu_table(__iommu_table, __iommu_table_end);
  77         check_iommu_entries(__iommu_table, __iommu_table_end);
  78
  79         for (p = __iommu_table; p < __iommu_table_end; p++) {
  80                 if (p && p->detect && p->detect() > 0) {
  81                         p->flags |= IOMMU_DETECTED;
  82                         if (p->early_init)
  83                                 p->early_init();
  84                         if (p->flags & IOMMU_FINISH_IF_DETECTED)
  85                                 break;
  86                 }
  87         }
  88 }
  89 void *dma_generic_alloc_coherent(struct device *dev, size_t size,
  90                                  dma_addr_t *dma_addr, gfp_t flag,
  91                                  struct dma_attrs *attrs)
  92 {
  93         unsigned long dma_mask;
  94         struct page *page;
  95         unsigned int count = PAGE_ALIGN(size) >> PAGE_SHIFT;
  96         dma_addr_t addr;
  97
  98         dma_mask = dma_alloc_coherent_mask(dev, flag);
  99
 100         flag &= ~__GFP_ZERO;
 101 again:
 102         page = NULL;
 103         /* CMA can be used only in the context which permits sleeping */
 104         if (flag & __GFP_WAIT) {
 105                 page = dma_alloc_from_contiguous(dev, count, get_order(size));
 106                 if (page && page_to_phys(page) + size > dma_mask) {
 107                         dma_release_from_contiguous(dev, page, count);
 108                         page = NULL;
 109                 }
 110         }
 111         /* fallback */
 112         if (!page)
 113                 page = alloc_pages_node(dev_to_node(dev), flag, get_order(size));
 114         if (!page)
 115                 return NULL;
 116
 117         addr = page_to_phys(page);
 118         if (addr + size > dma_mask) {
 119                 __free_pages(page, get_order(size));
 120
 121                 if (dma_mask < DMA_BIT_MASK(32) && !(flag & GFP_DMA)) {
 122                         flag = (flag & ~GFP_DMA32) | GFP_DMA;
 123                         goto again;
 124                 }
 125
 126                 return NULL;
 127         }
 128         memset(page_address(page), 0, size);
 129         *dma_addr = addr;
 130         return page_address(page);
 131 }
 132
 133 void dma_generic_free_coherent(struct device *dev, size_t size, void *vaddr,
 134                                dma_addr_t dma_addr, struct dma_attrs *attrs)
 135 {
 136         unsigned int count = PAGE_ALIGN(size) >> PAGE_SHIFT;
 137         struct page *page = virt_to_page(vaddr);
 138
 139         if (!dma_release_from_contiguous(dev, page, count))
 140                 free_pages((unsigned long)vaddr, get_order(size));
 141 }
 142
 143 bool arch_dma_alloc_attrs(struct device **dev, gfp_t *gfp)
 144 {
 145         *gfp = dma_alloc_coherent_gfp_flags(*dev, *gfp);
 146         *gfp &= ~(__GFP_DMA | __GFP_HIGHMEM | __GFP_DMA32);
 147
 148         if (!*dev)
 149                 *dev = &x86_dma_fallback_dev;
 150         if (!is_device_dma_capable(*dev))
 151                 return false;
 152         return true;
 153
 154 }
 155 EXPORT_SYMBOL(arch_dma_alloc_attrs);
 156
 157 /*
 158  * See <Documentation/x86/x86_64/boot-options.txt> for the iommu kernel
 159  * parameter documentation.
 160  */
 161 static __init int iommu_setup(char *p)
 162 {
 163         iommu_merge = 1;
 164
 165         if (!p)
 166                 return -EINVAL;
 167
 168         while (*p) {
 169                 if (!strncmp(p, "off", 3))
 170                         no_iommu = 1;
 171                 /* gart_parse_options has more force support */
 172                 if (!strncmp(p, "force", 5))
 173                         force_iommu = 1;
 174                 if (!strncmp(p, "noforce", 7)) {
 175                         iommu_merge = 0;
 176                         force_iommu = 0;
 177                 }
 178
 179                 if (!strncmp(p, "biomerge", 8)) {
 180                         iommu_merge = 1;
 181                         force_iommu = 1;
 182                 }
 183                 if (!strncmp(p, "panic", 5))
 184                         panic_on_overflow = 1;
 185                 if (!strncmp(p, "nopanic", 7))
 186                         panic_on_overflow = 0;
 187                 if (!strncmp(p, "merge", 5)) {
 188                         iommu_merge = 1;
 189                         force_iommu = 1;
 190                 }
 191                 if (!strncmp(p, "nomerge", 7))
 192                         iommu_merge = 0;
 193                 if (!strncmp(p, "forcesac", 8))
 194                         iommu_sac_force = 1;
 195                 if (!strncmp(p, "allowdac", 8))
 196                         forbid_dac = 0;
 197                 if (!strncmp(p, "nodac", 5))
 198                         forbid_dac = 1;
 199                 if (!strncmp(p, "usedac", 6)) {
 200                         forbid_dac = -1;
 201                         return 1;
 202                 }
 203 #ifdef CONFIG_SWIOTLB
 204                 if (!strncmp(p, "soft", 4))
 205                         swiotlb = 1;
 206 #endif
 207                 if (!strncmp(p, "pt", 2))
 208                         iommu_pass_through = 1;
 209
 210                 gart_parse_options(p);
 211
 212 #ifdef CONFIG_CALGARY_IOMMU
 213                 if (!strncmp(p, "calgary", 7))
 214                         use_calgary = 1;
 215 #endif /* CONFIG_CALGARY_IOMMU */
 216
 217                 p += strcspn(p, ",");
 218                 if (*p == ',')
 219                         ++p;
 220         }
 221         return 0;
 222 }
 223 early_param("iommu", iommu_setup);
 224
 225 int dma_supported(struct device *dev, u64 mask)
 226 {
 227         struct dma_map_ops *ops = get_dma_ops(dev);
 228
 229 #ifdef CONFIG_PCI
 230         if (mask > 0xffffffff && forbid_dac > 0) {
 231                 dev_info(dev, "PCI: Disallowing DAC for device\n");
 232                 return 0;
 233         }
 234 #endif
 235
 236         if (ops->dma_supported)
 237                 return ops->dma_supported(dev, mask);
 238
 239         /* Copied from i386. Doesn't make much sense, because it will
 240            only work for pci_alloc_coherent.
 241            The caller just has to use GFP_DMA in this case. */
 242         if (mask < DMA_BIT_MASK(24))
 243                 return 0;
 244
 245         /* Tell the device to use SAC when IOMMU force is on.  This
 246            allows the driver to use cheaper accesses in some cases.
 247
 248            Problem with this is that if we overflow the IOMMU area and
 249            return DAC as fallback address the device may not handle it
 250            correctly.
 251
 252            As a special case some controllers have a 39bit address
 253            mode that is as efficient as 32bit (aic79xx). Don't force
 254            SAC for these.  Assume all masks <= 40 bits are of this
 255            type. Normally this doesn't make any difference, but gives
 256            more gentle handling of IOMMU overflow. */
 257         if (iommu_sac_force && (mask >= DMA_BIT_MASK(40))) {
 258                 dev_info(dev, "Force SAC with mask %Lx\n", mask);
 259                 return 0;
 260         }
 261
 262         return 1;
 263 }
 264 EXPORT_SYMBOL(dma_supported);
 265
 266 static int __init pci_iommu_init(void)
 267 {
 268         struct iommu_table_entry *p;
 269         dma_debug_init(PREALLOC_DMA_DEBUG_ENTRIES);
 270
 271 #ifdef CONFIG_PCI
 272         dma_debug_add_bus(&pci_bus_type);
 273 #endif
 274         x86_init.iommu.iommu_init();
 275
 276         for (p = __iommu_table; p < __iommu_table_end; p++) {
 277                 if (p && (p->flags & IOMMU_DETECTED) && p->late_init)
 278                         p->late_init();
 279         }
 280
 281         return 0;
 282 }
 283 /* Must execute after PCI subsystem */
 284 rootfs_initcall(pci_iommu_init);
 285
 286 #ifdef CONFIG_PCI
 287 /* Many VIA bridges seem to corrupt data for DAC. Disable it here */
 288
 289 static void via_no_dac(struct pci_dev *dev)
 290 {
 291         if (forbid_dac == 0) {
 292                 dev_info(&dev->dev, "disabling DAC on VIA PCI bridge\n");
 293                 forbid_dac = 1;
 294         }
 295 }
 296 DECLARE_PCI_FIXUP_CLASS_FINAL(PCI_VENDOR_ID_VIA, PCI_ANY_ID,
 297                                 PCI_CLASS_BRIDGE_PCI, 8, via_no_dac);
 298 #endif