Merge tag 'iommu-updates-v3.6-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/joro/iommu

Pull IOMMU updates from Joerg Roedel:
 "The most important part of these updates is the IOMMU groups code
  enhancement written by Alex Williamson.  It abstracts the problem that
  a given hardware IOMMU can't isolate any given device from any other
  device (e.g.  32 bit PCI devices can't usually be isolated).  Devices
  that can't be isolated are grouped together.  This code is required
  for the upcoming VFIO framework.

  Another IOMMU-API change written by me is the introduction of domain
  attributes.  This makes it easier to handle GART-like IOMMUs with the
  IOMMU-API because now the start-address and the size of the domain
  address space can be queried.

  Besides that there are a few cleanups and fixes for the NVidia Tegra
  IOMMU drivers and the reworked init-code for the AMD IOMMU.  The
  latter is from my patch-set to support interrupt remapping.  The rest
  of this patch-set requires x86 changes which are not mergabe yet.  So
  full support for interrupt remapping with AMD IOMMUs will come in a
  future merge window."

* tag 'iommu-updates-v3.6-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/joro/iommu: (33 commits)
  iommu/amd: Fix hotplug with iommu=pt
  iommu/amd: Add missing spin_lock initialization
  iommu/amd: Convert iommu initialization to state machine
  iommu/amd: Introduce amd_iommu_init_dma routine
  iommu/amd: Move unmap_flush message to amd_iommu_init_dma_ops()
  iommu/amd: Split enable_iommus() routine
  iommu/amd: Introduce early_amd_iommu_init routine
  iommu/amd: Move informational prinks out of iommu_enable
  iommu/amd: Split out PCI related parts of IOMMU initialization
  iommu/amd: Use acpi_get_table instead of acpi_table_parse
  iommu/amd: Fix sparse warnings
  iommu/tegra: Don't call alloc_pdir with as->lock
  iommu/tegra: smmu: Fix unsleepable memory allocation at alloc_pdir()
  iommu/tegra: smmu: Remove unnecessary sanity check at alloc_pdir()
  iommu/exynos: Implement DOMAIN_ATTR_GEOMETRY attribute
  iommu/tegra: Implement DOMAIN_ATTR_GEOMETRY attribute
  iommu/msm: Implement DOMAIN_ATTR_GEOMETRY attribute
  iommu/omap: Implement DOMAIN_ATTR_GEOMETRY attribute
  iommu/vt-d: Implement DOMAIN_ATTR_GEOMETRY attribute
  iommu/amd: Implement DOMAIN_ATTR_GEOMETRY attribute
  ...

1 files changed, 58 insertions, 35 deletions

diff --git a/drivers/iommu/intel-iommu.c b/drivers/iommu/intel-iommu.c
index 2fb7d1598a68..7469b5346643 100644
--- a/drivers/iommu/intel-iommu.c
+++ b/drivers/iommu/intel-iommu.c
@@ -3932,6 +3932,10 @@ static int intel_iommu_domain_init(struct iommu_domain *domain)
         domain_update_iommu_cap(dmar_domain);
         domain->priv = dmar_domain;
 
+        domain->geometry.aperture_start = 0;
+        domain->geometry.aperture_end   = __DOMAIN_MAX_ADDR(dmar_domain->gaw);
+        domain->geometry.force_aperture = true;
+
         return 0;
 }
 
@@ -4090,52 +4094,70 @@ static int intel_iommu_domain_has_cap(struct iommu_domain *domain,
         return 0;
 }
 
-/*
- * Group numbers are arbitrary.  Device with the same group number
- * indicate the iommu cannot differentiate between them.  To avoid
- * tracking used groups we just use the seg|bus|devfn of the lowest
- * level we're able to differentiate devices
- */
-static int intel_iommu_device_group(struct device *dev, unsigned int *groupid)
+static void swap_pci_ref(struct pci_dev **from, struct pci_dev *to)
 {
-        struct pci_dev *pdev = to_pci_dev(dev);
-        struct pci_dev *bridge;
-        union {
-                struct {
-                        u8 devfn;
-                        u8 bus;
-                        u16 segment;
-                } pci;
-                u32 group;
-        } id;
+        pci_dev_put(*from);
+        *from = to;
+}
 
-        if (iommu_no_mapping(dev))
-                return -ENODEV;
+#define REQ_ACS_FLAGS   (PCI_ACS_SV | PCI_ACS_RR | PCI_ACS_CR | PCI_ACS_UF)
 
-        id.pci.segment = pci_domain_nr(pdev->bus);
-        id.pci.bus = pdev->bus->number;
-        id.pci.devfn = pdev->devfn;
+static int intel_iommu_add_device(struct device *dev)
+{
+        struct pci_dev *pdev = to_pci_dev(dev);
+        struct pci_dev *bridge, *dma_pdev;
+        struct iommu_group *group;
+        int ret;
 
-        if (!device_to_iommu(id.pci.segment, id.pci.bus, id.pci.devfn))
+        if (!device_to_iommu(pci_domain_nr(pdev->bus),
+                             pdev->bus->number, pdev->devfn))
                 return -ENODEV;
 
         bridge = pci_find_upstream_pcie_bridge(pdev);
         if (bridge) {
-                if (pci_is_pcie(bridge)) {
-                        id.pci.bus = bridge->subordinate->number;
-                        id.pci.devfn = 0;
-                } else {
-                        id.pci.bus = bridge->bus->number;
-                        id.pci.devfn = bridge->devfn;
-                }
+                if (pci_is_pcie(bridge))
+                        dma_pdev = pci_get_domain_bus_and_slot(
+                                                pci_domain_nr(pdev->bus),
+                                                bridge->subordinate->number, 0);
+                else
+                        dma_pdev = pci_dev_get(bridge);
+        } else
+                dma_pdev = pci_dev_get(pdev);
+
+        swap_pci_ref(&dma_pdev, pci_get_dma_source(dma_pdev));
+
+        if (dma_pdev->multifunction &&
+            !pci_acs_enabled(dma_pdev, REQ_ACS_FLAGS))
+                swap_pci_ref(&dma_pdev,
+                             pci_get_slot(dma_pdev->bus,
+                                          PCI_DEVFN(PCI_SLOT(dma_pdev->devfn),
+                                          0)));
+
+        while (!pci_is_root_bus(dma_pdev->bus)) {
+                if (pci_acs_path_enabled(dma_pdev->bus->self,
+                                         NULL, REQ_ACS_FLAGS))
+                        break;
+
+                swap_pci_ref(&dma_pdev, pci_dev_get(dma_pdev->bus->self));
+        }
+
+        group = iommu_group_get(&dma_pdev->dev);
+        pci_dev_put(dma_pdev);
+        if (!group) {
+                group = iommu_group_alloc();
+                if (IS_ERR(group))
+                        return PTR_ERR(group);
         }
 
-        if (!pdev->is_virtfn && iommu_group_mf)
-                id.pci.devfn = PCI_DEVFN(PCI_SLOT(id.pci.devfn), 0);
+        ret = iommu_group_add_device(group, dev);
 
-        *groupid = id.group;
+        iommu_group_put(group);
+        return ret;
+}
 
-        return 0;
+static void intel_iommu_remove_device(struct device *dev)
+{
+        iommu_group_remove_device(dev);
 }
 
 static struct iommu_ops intel_iommu_ops = {
@@ -4147,7 +4169,8 @@ static struct iommu_ops intel_iommu_ops = {
         .unmap          = intel_iommu_unmap,
         .iova_to_phys   = intel_iommu_iova_to_phys,
         .domain_has_cap = intel_iommu_domain_has_cap,
-        .device_group   = intel_iommu_device_group,
+        .add_device     = intel_iommu_add_device,
+        .remove_device  = intel_iommu_remove_device,
         .pgsize_bitmap  = INTEL_IOMMU_PGSIZES,
 };