5 files changed, 168 insertions, 26 deletions

diff --git a/drivers/iommu/amd_iommu_init.c b/drivers/iommu/amd_iommu_init.c
index bf51abb78dee..7acbf351e9af 100644
--- a/drivers/iommu/amd_iommu_init.c
+++ b/drivers/iommu/amd_iommu_init.c
@@ -99,7 +99,7 @@ struct ivhd_header {
         u64 mmio_phys;
         u16 pci_seg;
         u16 info;
-        u32 reserved;
+        u32 efr;
 } __attribute__((packed));
 
 /*
@@ -154,6 +154,7 @@ bool amd_iommu_iotlb_sup __read_mostly = true;
 u32 amd_iommu_max_pasids __read_mostly = ~0;
 
 bool amd_iommu_v2_present __read_mostly;
+bool amd_iommu_pc_present __read_mostly;
 
 bool amd_iommu_force_isolation __read_mostly;
 
@@ -369,23 +370,23 @@ static void iommu_disable(struct amd_iommu *iommu)
  * mapping and unmapping functions for the IOMMU MMIO space. Each AMD IOMMU in
  * the system has one.
  */
-static u8 __iomem * __init iommu_map_mmio_space(u64 address)
+static u8 __iomem * __init iommu_map_mmio_space(u64 address, u64 end)
 {
-        if (!request_mem_region(address, MMIO_REGION_LENGTH, "amd_iommu")) {
-                pr_err("AMD-Vi: Can not reserve memory region %llx for mmio\n",
-                        address);
+        if (!request_mem_region(address, end, "amd_iommu")) {
+                pr_err("AMD-Vi: Can not reserve memory region %llx-%llx for mmio\n",
+                        address, end);
                 pr_err("AMD-Vi: This is a BIOS bug. Please contact your hardware vendor\n");
                 return NULL;
         }
 
-        return (u8 __iomem *)ioremap_nocache(address, MMIO_REGION_LENGTH);
+        return (u8 __iomem *)ioremap_nocache(address, end);
 }
 
 static void __init iommu_unmap_mmio_space(struct amd_iommu *iommu)
 {
         if (iommu->mmio_base)
                 iounmap(iommu->mmio_base);
-        release_mem_region(iommu->mmio_phys, MMIO_REGION_LENGTH);
+        release_mem_region(iommu->mmio_phys, iommu->mmio_phys_end);
 }
 
 /****************************************************************************
@@ -1085,7 +1086,18 @@ static int __init init_iommu_one(struct amd_iommu *iommu, struct ivhd_header *h)
         iommu->cap_ptr = h->cap_ptr;
         iommu->pci_seg = h->pci_seg;
         iommu->mmio_phys = h->mmio_phys;
-        iommu->mmio_base = iommu_map_mmio_space(h->mmio_phys);
+
+        /* Check if IVHD EFR contains proper max banks/counters */
+        if ((h->efr != 0) &&
+            ((h->efr & (0xF << 13)) != 0) &&
+            ((h->efr & (0x3F << 17)) != 0)) {
+                iommu->mmio_phys_end = MMIO_REG_END_OFFSET;
+        } else {
+                iommu->mmio_phys_end = MMIO_CNTR_CONF_OFFSET;
+        }
+
+        iommu->mmio_base = iommu_map_mmio_space(iommu->mmio_phys,
+                                                iommu->mmio_phys_end);
         if (!iommu->mmio_base)
                 return -ENOMEM;
 
@@ -1160,6 +1172,33 @@ static int __init init_iommu_all(struct acpi_table_header *table)
         return 0;
 }
 
+
+static void init_iommu_perf_ctr(struct amd_iommu *iommu)
+{
+        u64 val = 0xabcd, val2 = 0;
+
+        if (!iommu_feature(iommu, FEATURE_PC))
+                return;
+
+        amd_iommu_pc_present = true;
+
+        /* Check if the performance counters can be written to */
+        if ((0 != amd_iommu_pc_get_set_reg_val(0, 0, 0, 0, &val, true)) ||
+            (0 != amd_iommu_pc_get_set_reg_val(0, 0, 0, 0, &val2, false)) ||
+            (val != val2)) {
+                pr_err("AMD-Vi: Unable to write to IOMMU perf counter.\n");
+                amd_iommu_pc_present = false;
+                return;
+        }
+
+        pr_info("AMD-Vi: IOMMU performance counters supported\n");
+
+        val = readl(iommu->mmio_base + MMIO_CNTR_CONF_OFFSET);
+        iommu->max_banks = (u8) ((val >> 12) & 0x3f);
+        iommu->max_counters = (u8) ((val >> 7) & 0xf);
+}
+
+
 static int iommu_init_pci(struct amd_iommu *iommu)
 {
         int cap_ptr = iommu->cap_ptr;
@@ -1226,6 +1265,8 @@ static int iommu_init_pci(struct amd_iommu *iommu)
         if (iommu->cap & (1UL << IOMMU_CAP_NPCACHE))
                 amd_iommu_np_cache = true;
 
+        init_iommu_perf_ctr(iommu);
+
         if (is_rd890_iommu(iommu->dev)) {
                 int i, j;
 
@@ -1278,7 +1319,7 @@ static void print_iommu_info(void)
                                 if (iommu_feature(iommu, (1ULL << i)))
                                         pr_cont(" %s", feat_str[i]);
                         }
-                pr_cont("\n");
+                        pr_cont("\n");
                 }
         }
         if (irq_remapping_enabled)
@@ -2232,3 +2273,84 @@ bool amd_iommu_v2_supported(void)
         return amd_iommu_v2_present;
 }
 EXPORT_SYMBOL(amd_iommu_v2_supported);
+
+/****************************************************************************
+ *
+ * IOMMU EFR Performance Counter support functionality. This code allows
+ * access to the IOMMU PC functionality.
+ *
+ ****************************************************************************/
+
+u8 amd_iommu_pc_get_max_banks(u16 devid)
+{
+        struct amd_iommu *iommu;
+        u8 ret = 0;
+
+        /* locate the iommu governing the devid */
+        iommu = amd_iommu_rlookup_table[devid];
+        if (iommu)
+                ret = iommu->max_banks;
+
+        return ret;
+}
+EXPORT_SYMBOL(amd_iommu_pc_get_max_banks);
+
+bool amd_iommu_pc_supported(void)
+{
+        return amd_iommu_pc_present;
+}
+EXPORT_SYMBOL(amd_iommu_pc_supported);
+
+u8 amd_iommu_pc_get_max_counters(u16 devid)
+{
+        struct amd_iommu *iommu;
+        u8 ret = 0;
+
+        /* locate the iommu governing the devid */
+        iommu = amd_iommu_rlookup_table[devid];
+        if (iommu)
+                ret = iommu->max_counters;
+
+        return ret;
+}
+EXPORT_SYMBOL(amd_iommu_pc_get_max_counters);
+
+int amd_iommu_pc_get_set_reg_val(u16 devid, u8 bank, u8 cntr, u8 fxn,
+                                    u64 *value, bool is_write)
+{
+        struct amd_iommu *iommu;
+        u32 offset;
+        u32 max_offset_lim;
+
+        /* Make sure the IOMMU PC resource is available */
+        if (!amd_iommu_pc_present)
+                return -ENODEV;
+
+        /* Locate the iommu associated with the device ID */
+        iommu = amd_iommu_rlookup_table[devid];
+
+        /* Check for valid iommu and pc register indexing */
+        if (WARN_ON((iommu == NULL) || (fxn > 0x28) || (fxn & 7)))
+                return -ENODEV;
+
+        offset = (u32)(((0x40|bank) << 12) | (cntr << 8) | fxn);
+
+        /* Limit the offset to the hw defined mmio region aperture */
+        max_offset_lim = (u32)(((0x40|iommu->max_banks) << 12) |
+                                (iommu->max_counters << 8) | 0x28);
+        if ((offset < MMIO_CNTR_REG_OFFSET) ||
+            (offset > max_offset_lim))
+                return -EINVAL;
+
+        if (is_write) {
+                writel((u32)*value, iommu->mmio_base + offset);
+                writel((*value >> 32), iommu->mmio_base + offset + 4);
+        } else {
+                *value = readl(iommu->mmio_base + offset + 4);
+                *value <<= 32;
+                *value = readl(iommu->mmio_base + offset);
+        }
+
+        return 0;
+}
+EXPORT_SYMBOL(amd_iommu_pc_get_set_reg_val);
diff --git a/drivers/iommu/amd_iommu_proto.h b/drivers/iommu/amd_iommu_proto.h
index c294961bdd36..95ed6deae47f 100644
--- a/drivers/iommu/amd_iommu_proto.h
+++ b/drivers/iommu/amd_iommu_proto.h
@@ -56,6 +56,13 @@ extern int amd_iommu_domain_set_gcr3(struct iommu_domain *dom, int pasid,
 extern int amd_iommu_domain_clear_gcr3(struct iommu_domain *dom, int pasid);
 extern struct iommu_domain *amd_iommu_get_v2_domain(struct pci_dev *pdev);
 
+/* IOMMU Performance Counter functions */
+extern bool amd_iommu_pc_supported(void);
+extern u8 amd_iommu_pc_get_max_banks(u16 devid);
+extern u8 amd_iommu_pc_get_max_counters(u16 devid);
+extern int amd_iommu_pc_get_set_reg_val(u16 devid, u8 bank, u8 cntr, u8 fxn,
+                                    u64 *value, bool is_write);
+
 #define PPR_SUCCESS                     0x0
 #define PPR_INVALID                     0x1
 #define PPR_FAILURE                     0xf
diff --git a/drivers/iommu/amd_iommu_types.h b/drivers/iommu/amd_iommu_types.h
index 0285a215df16..e400fbe411de 100644
--- a/drivers/iommu/amd_iommu_types.h
+++ b/drivers/iommu/amd_iommu_types.h
@@ -38,9 +38,6 @@
 #define ALIAS_TABLE_ENTRY_SIZE          2
 #define RLOOKUP_TABLE_ENTRY_SIZE        (sizeof(void *))
 
-/* Length of the MMIO region for the AMD IOMMU */
-#define MMIO_REGION_LENGTH       0x4000
-
 /* Capability offsets used by the driver */
 #define MMIO_CAP_HDR_OFFSET     0x00
 #define MMIO_RANGE_OFFSET       0x0c
@@ -78,6 +75,10 @@
 #define MMIO_STATUS_OFFSET      0x2020
 #define MMIO_PPR_HEAD_OFFSET    0x2030
 #define MMIO_PPR_TAIL_OFFSET    0x2038
+#define MMIO_CNTR_CONF_OFFSET   0x4000
+#define MMIO_CNTR_REG_OFFSET    0x40000
+#define MMIO_REG_END_OFFSET     0x80000
+
 
 
 /* Extended Feature Bits */
@@ -507,6 +508,10 @@ struct amd_iommu {
 
         /* physical address of MMIO space */
         u64 mmio_phys;
+
+        /* physical end address of MMIO space */
+        u64 mmio_phys_end;
+
         /* virtual address of MMIO space */
         u8 __iomem *mmio_base;
 
@@ -584,6 +589,10 @@ struct amd_iommu {
 
         /* The l2 indirect registers */
         u32 stored_l2[0x83];
+
+        /* The maximum PC banks and counters/bank (PCSup=1) */
+        u8 max_banks;
+        u8 max_counters;
 };
 
 struct devid_map {
diff --git a/drivers/iommu/irq_remapping.c b/drivers/iommu/irq_remapping.c
index dcfea4e39be7..39f81aeefcd6 100644
--- a/drivers/iommu/irq_remapping.c
+++ b/drivers/iommu/irq_remapping.c
@@ -51,26 +51,27 @@ static void irq_remapping_disable_io_apic(void)
 
 static int do_setup_msi_irqs(struct pci_dev *dev, int nvec)
 {
-        int node, ret, sub_handle, index = 0;
+        int node, ret, sub_handle, nvec_pow2, index = 0;
         unsigned int irq;
         struct msi_desc *msidesc;
 
-        nvec = __roundup_pow_of_two(nvec);
-
         WARN_ON(!list_is_singular(&dev->msi_list));
         msidesc = list_entry(dev->msi_list.next, struct msi_desc, list);
         WARN_ON(msidesc->irq);
         WARN_ON(msidesc->msi_attrib.multiple);
+        WARN_ON(msidesc->nvec_used);
 
         node = dev_to_node(&dev->dev);
         irq = __create_irqs(get_nr_irqs_gsi(), nvec, node);
         if (irq == 0)
                 return -ENOSPC;
 
-        msidesc->msi_attrib.multiple = ilog2(nvec);
+        nvec_pow2 = __roundup_pow_of_two(nvec);
+        msidesc->nvec_used = nvec;
+        msidesc->msi_attrib.multiple = ilog2(nvec_pow2);
         for (sub_handle = 0; sub_handle < nvec; sub_handle++) {
                 if (!sub_handle) {
-                        index = msi_alloc_remapped_irq(dev, irq, nvec);
+                        index = msi_alloc_remapped_irq(dev, irq, nvec_pow2);
                         if (index < 0) {
                                 ret = index;
                                 goto error;
@@ -95,6 +96,7 @@ error:
          * IRQs from tearing down again in default_teardown_msi_irqs()
          */
         msidesc->irq = 0;
+        msidesc->nvec_used = 0;
         msidesc->msi_attrib.multiple = 0;
 
         return ret;
diff --git a/drivers/iommu/msm_iommu_dev.c b/drivers/iommu/msm_iommu_dev.c
index 8e8fb079852d..9144a6beed92 100644
--- a/drivers/iommu/msm_iommu_dev.c
+++ b/drivers/iommu/msm_iommu_dev.c
@@ -29,7 +29,6 @@
 
 #include <mach/iommu_hw-8xxx.h>
 #include <mach/iommu.h>
-#include <mach/clk.h>
 
 struct iommu_ctx_iter_data {
         /* input */
@@ -160,7 +159,7 @@ static int msm_iommu_probe(struct platform_device *pdev)
                 goto fail;
         }
 
-        ret = clk_enable(iommu_pclk);
+        ret = clk_prepare_enable(iommu_pclk);
         if (ret)
                 goto fail_enable;
 
@@ -168,9 +167,9 @@ static int msm_iommu_probe(struct platform_device *pdev)
 
         if (!IS_ERR(iommu_clk)) {
                 if (clk_get_rate(iommu_clk) == 0)
-                        clk_set_min_rate(iommu_clk, 1);
+                        clk_set_rate(iommu_clk, 1);
 
-                ret = clk_enable(iommu_clk);
+                ret = clk_prepare_enable(iommu_clk);
                 if (ret) {
                         clk_put(iommu_clk);
                         goto fail_pclk;
@@ -261,7 +260,7 @@ fail_clk:
                 clk_put(iommu_clk);
         }
 fail_pclk:
-        clk_disable(iommu_pclk);
+        clk_disable_unprepare(iommu_pclk);
 fail_enable:
         clk_put(iommu_pclk);
 fail:
@@ -275,8 +274,11 @@ static int msm_iommu_remove(struct platform_device *pdev)
 
         drv = platform_get_drvdata(pdev);
         if (drv) {
-                if (drv->clk)
+                if (drv->clk) {
+                        clk_unprepare(drv->clk);
                         clk_put(drv->clk);
+                }
+                clk_unprepare(drv->pclk);
                 clk_put(drv->pclk);
                 memset(drv, 0, sizeof(*drv));
                 kfree(drv);
@@ -314,14 +316,14 @@ static int msm_iommu_ctx_probe(struct platform_device *pdev)
         INIT_LIST_HEAD(&ctx_drvdata->attached_elm);
         platform_set_drvdata(pdev, ctx_drvdata);
 
-        ret = clk_enable(drvdata->pclk);
+        ret = clk_prepare_enable(drvdata->pclk);
         if (ret)
                 goto fail;
 
         if (drvdata->clk) {
-                ret = clk_enable(drvdata->clk);
+                ret = clk_prepare_enable(drvdata->clk);
                 if (ret) {
-                        clk_disable(drvdata->pclk);
+                        clk_disable_unprepare(drvdata->pclk);
                         goto fail;
                 }
         }