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

DEFINITIONS

1. pci_iommu_alloc
2. iommu_setup
3. pci_iommu_init
4. via_no_dac_cb
5. via_no_dac

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include <linux/dma-direct.h>
   3 #include <linux/dma-debug.h>
   4 #include <linux/iommu.h>
   5 #include <linux/dmar.h>
   6 #include <linux/export.h>
   7 #include <linux/memblock.h>
   8 #include <linux/gfp.h>
   9 #include <linux/pci.h>
  10 
  11 #include <asm/proto.h>
  12 #include <asm/dma.h>
  13 #include <asm/iommu.h>
  14 #include <asm/gart.h>
  15 #include <asm/calgary.h>
  16 #include <asm/x86_init.h>
  17 #include <asm/iommu_table.h>
  18 
  19 static bool disable_dac_quirk __read_mostly;
  20 
  21 const struct dma_map_ops *dma_ops;
  22 EXPORT_SYMBOL(dma_ops);
  23 
  24 #ifdef CONFIG_IOMMU_DEBUG
  25 int panic_on_overflow __read_mostly = 1;
  26 int force_iommu __read_mostly = 1;
  27 #else
  28 int panic_on_overflow __read_mostly = 0;
  29 int force_iommu __read_mostly = 0;
  30 #endif
  31 
  32 int iommu_merge __read_mostly = 0;
  33 
  34 int no_iommu __read_mostly;
  35 /* Set this to 1 if there is a HW IOMMU in the system */
  36 int iommu_detected __read_mostly = 0;
  37 
  38 extern struct iommu_table_entry __iommu_table[], __iommu_table_end[];
  39 
  40 void __init pci_iommu_alloc(void)
  41 {
  42         struct iommu_table_entry *p;
  43 
  44         sort_iommu_table(__iommu_table, __iommu_table_end);
  45         check_iommu_entries(__iommu_table, __iommu_table_end);
  46 
  47         for (p = __iommu_table; p < __iommu_table_end; p++) {
  48                 if (p && p->detect && p->detect() > 0) {
  49                         p->flags |= IOMMU_DETECTED;
  50                         if (p->early_init)
  51                                 p->early_init();
  52                         if (p->flags & IOMMU_FINISH_IF_DETECTED)
  53                                 break;
  54                 }
  55         }
  56 }
  57 
  58 /*
  59  * See <Documentation/x86/x86_64/boot-options.rst> for the iommu kernel
  60  * parameter documentation.
  61  */
  62 static __init int iommu_setup(char *p)
  63 {
  64         iommu_merge = 1;
  65 
  66         if (!p)
  67                 return -EINVAL;
  68 
  69         while (*p) {
  70                 if (!strncmp(p, "off", 3))
  71                         no_iommu = 1;
  72                 /* gart_parse_options has more force support */
  73                 if (!strncmp(p, "force", 5))
  74                         force_iommu = 1;
  75                 if (!strncmp(p, "noforce", 7)) {
  76                         iommu_merge = 0;
  77                         force_iommu = 0;
  78                 }
  79 
  80                 if (!strncmp(p, "biomerge", 8)) {
  81                         iommu_merge = 1;
  82                         force_iommu = 1;
  83                 }
  84                 if (!strncmp(p, "panic", 5))
  85                         panic_on_overflow = 1;
  86                 if (!strncmp(p, "nopanic", 7))
  87                         panic_on_overflow = 0;
  88                 if (!strncmp(p, "merge", 5)) {
  89                         iommu_merge = 1;
  90                         force_iommu = 1;
  91                 }
  92                 if (!strncmp(p, "nomerge", 7))
  93                         iommu_merge = 0;
  94                 if (!strncmp(p, "forcesac", 8))
  95                         pr_warn("forcesac option ignored.\n");
  96                 if (!strncmp(p, "allowdac", 8))
  97                         pr_warn("allowdac option ignored.\n");
  98                 if (!strncmp(p, "nodac", 5))
  99                         pr_warn("nodac option ignored.\n");
 100                 if (!strncmp(p, "usedac", 6)) {
 101                         disable_dac_quirk = true;
 102                         return 1;
 103                 }
 104 #ifdef CONFIG_SWIOTLB
 105                 if (!strncmp(p, "soft", 4))
 106                         swiotlb = 1;
 107 #endif
 108                 if (!strncmp(p, "pt", 2))
 109                         iommu_set_default_passthrough(true);
 110                 if (!strncmp(p, "nopt", 4))
 111                         iommu_set_default_translated(true);
 112 
 113                 gart_parse_options(p);
 114 
 115 #ifdef CONFIG_CALGARY_IOMMU
 116                 if (!strncmp(p, "calgary", 7))
 117                         use_calgary = 1;
 118 #endif /* CONFIG_CALGARY_IOMMU */
 119 
 120                 p += strcspn(p, ",");
 121                 if (*p == ',')
 122                         ++p;
 123         }
 124         return 0;
 125 }
 126 early_param("iommu", iommu_setup);
 127 
 128 static int __init pci_iommu_init(void)
 129 {
 130         struct iommu_table_entry *p;
 131 
 132         x86_init.iommu.iommu_init();
 133 
 134         for (p = __iommu_table; p < __iommu_table_end; p++) {
 135                 if (p && (p->flags & IOMMU_DETECTED) && p->late_init)
 136                         p->late_init();
 137         }
 138 
 139         return 0;
 140 }
 141 /* Must execute after PCI subsystem */
 142 rootfs_initcall(pci_iommu_init);
 143 
 144 #ifdef CONFIG_PCI
 145 /* Many VIA bridges seem to corrupt data for DAC. Disable it here */
 146 
 147 static int via_no_dac_cb(struct pci_dev *pdev, void *data)
 148 {
 149         pdev->dev.bus_dma_mask = DMA_BIT_MASK(32);
 150         return 0;
 151 }
 152 
 153 static void via_no_dac(struct pci_dev *dev)
 154 {
 155         if (!disable_dac_quirk) {
 156                 dev_info(&dev->dev, "disabling DAC on VIA PCI bridge\n");
 157                 pci_walk_bus(dev->subordinate, via_no_dac_cb, NULL);
 158         }
 159 }
 160 DECLARE_PCI_FIXUP_CLASS_FINAL(PCI_VENDOR_ID_VIA, PCI_ANY_ID,
 161                                 PCI_CLASS_BRIDGE_PCI, 8, via_no_dac);
 162 #endif