1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * platform_device probing code for ARM performance counters. 4 * 5 * Copyright (C) 2009 picoChip Designs, Ltd., Jamie Iles 6 * Copyright (C) 2010 ARM Ltd., Will Deacon <will.deacon@arm.com> 7 */ 8 #define pr_fmt(fmt) "hw perfevents: " fmt 9 10 #include <linux/bug.h> 11 #include <linux/cpumask.h> 12 #include <linux/device.h> 13 #include <linux/errno.h> 14 #include <linux/irq.h> 15 #include <linux/irqdesc.h> 16 #include <linux/kconfig.h> 17 #include <linux/of.h> 18 #include <linux/of_device.h> 19 #include <linux/percpu.h> 20 #include <linux/perf/arm_pmu.h> 21 #include <linux/platform_device.h> 22 #include <linux/printk.h> 23 #include <linux/smp.h> 24 25 static int probe_current_pmu(struct arm_pmu *pmu, 26 const struct pmu_probe_info *info) 27 { 28 int cpu = get_cpu(); 29 unsigned int cpuid = read_cpuid_id(); 30 int ret = -ENODEV; 31 32 pr_info("probing PMU on CPU %d\n", cpu); 33 34 for (; info->init != NULL; info++) { 35 if ((cpuid & info->mask) != info->cpuid) 36 continue; 37 ret = info->init(pmu); 38 break; 39 } 40 41 put_cpu(); 42 return ret; 43 } 44 45 static int pmu_parse_percpu_irq(struct arm_pmu *pmu, int irq) 46 { 47 int cpu, ret; 48 struct pmu_hw_events __percpu *hw_events = pmu->hw_events; 49 50 ret = irq_get_percpu_devid_partition(irq, &pmu->supported_cpus); 51 if (ret) 52 return ret; 53 54 for_each_cpu(cpu, &pmu->supported_cpus) 55 per_cpu(hw_events->irq, cpu) = irq; 56 57 return 0; 58 } 59 60 static bool pmu_has_irq_affinity(struct device_node *node) 61 { 62 return !!of_find_property(node, "interrupt-affinity", NULL); 63 } 64 65 static int pmu_parse_irq_affinity(struct device_node *node, int i) 66 { 67 struct device_node *dn; 68 int cpu; 69 70 /* 71 * If we don't have an interrupt-affinity property, we guess irq 72 * affinity matches our logical CPU order, as we used to assume. 73 * This is fragile, so we'll warn in pmu_parse_irqs(). 74 */ 75 if (!pmu_has_irq_affinity(node)) 76 return i; 77 78 dn = of_parse_phandle(node, "interrupt-affinity", i); 79 if (!dn) { 80 pr_warn("failed to parse interrupt-affinity[%d] for %pOFn\n", 81 i, node); 82 return -EINVAL; 83 } 84 85 cpu = of_cpu_node_to_id(dn); 86 if (cpu < 0) { 87 pr_warn("failed to find logical CPU for %pOFn\n", dn); 88 cpu = nr_cpu_ids; 89 } 90 91 of_node_put(dn); 92 93 return cpu; 94 } 95 96 static int pmu_parse_irqs(struct arm_pmu *pmu) 97 { 98 int i = 0, num_irqs; 99 struct platform_device *pdev = pmu->plat_device; 100 struct pmu_hw_events __percpu *hw_events = pmu->hw_events; 101 102 num_irqs = platform_irq_count(pdev); 103 if (num_irqs < 0) { 104 pr_err("unable to count PMU IRQs\n"); 105 return num_irqs; 106 } 107 108 /* 109 * In this case we have no idea which CPUs are covered by the PMU. 110 * To match our prior behaviour, we assume all CPUs in this case. 111 */ 112 if (num_irqs == 0) { 113 pr_warn("no irqs for PMU, sampling events not supported\n"); 114 pmu->pmu.capabilities |= PERF_PMU_CAP_NO_INTERRUPT; 115 cpumask_setall(&pmu->supported_cpus); 116 return 0; 117 } 118 119 if (num_irqs == 1) { 120 int irq = platform_get_irq(pdev, 0); 121 if (irq && irq_is_percpu_devid(irq)) 122 return pmu_parse_percpu_irq(pmu, irq); 123 } 124 125 if (nr_cpu_ids != 1 && !pmu_has_irq_affinity(pdev->dev.of_node)) { 126 pr_warn("no interrupt-affinity property for %pOF, guessing.\n", 127 pdev->dev.of_node); 128 } 129 130 for (i = 0; i < num_irqs; i++) { 131 int cpu, irq; 132 133 irq = platform_get_irq(pdev, i); 134 if (WARN_ON(irq <= 0)) 135 continue; 136 137 if (irq_is_percpu_devid(irq)) { 138 pr_warn("multiple PPIs or mismatched SPI/PPI detected\n"); 139 return -EINVAL; 140 } 141 142 cpu = pmu_parse_irq_affinity(pdev->dev.of_node, i); 143 if (cpu < 0) 144 return cpu; 145 if (cpu >= nr_cpu_ids) 146 continue; 147 148 if (per_cpu(hw_events->irq, cpu)) { 149 pr_warn("multiple PMU IRQs for the same CPU detected\n"); 150 return -EINVAL; 151 } 152 153 per_cpu(hw_events->irq, cpu) = irq; 154 cpumask_set_cpu(cpu, &pmu->supported_cpus); 155 } 156 157 return 0; 158 } 159 160 static int armpmu_request_irqs(struct arm_pmu *armpmu) 161 { 162 struct pmu_hw_events __percpu *hw_events = armpmu->hw_events; 163 int cpu, err = 0; 164 165 for_each_cpu(cpu, &armpmu->supported_cpus) { 166 int irq = per_cpu(hw_events->irq, cpu); 167 if (!irq) 168 continue; 169 170 err = armpmu_request_irq(irq, cpu); 171 if (err) 172 break; 173 } 174 175 return err; 176 } 177 178 static void armpmu_free_irqs(struct arm_pmu *armpmu) 179 { 180 int cpu; 181 struct pmu_hw_events __percpu *hw_events = armpmu->hw_events; 182 183 for_each_cpu(cpu, &armpmu->supported_cpus) { 184 int irq = per_cpu(hw_events->irq, cpu); 185 186 armpmu_free_irq(irq, cpu); 187 } 188 } 189 190 int arm_pmu_device_probe(struct platform_device *pdev, 191 const struct of_device_id *of_table, 192 const struct pmu_probe_info *probe_table) 193 { 194 const struct of_device_id *of_id; 195 armpmu_init_fn init_fn; 196 struct device_node *node = pdev->dev.of_node; 197 struct arm_pmu *pmu; 198 int ret = -ENODEV; 199 200 pmu = armpmu_alloc(); 201 if (!pmu) 202 return -ENOMEM; 203 204 pmu->plat_device = pdev; 205 206 ret = pmu_parse_irqs(pmu); 207 if (ret) 208 goto out_free; 209 210 if (node && (of_id = of_match_node(of_table, pdev->dev.of_node))) { 211 init_fn = of_id->data; 212 213 pmu->secure_access = of_property_read_bool(pdev->dev.of_node, 214 "secure-reg-access"); 215 216 /* arm64 systems boot only as non-secure */ 217 if (IS_ENABLED(CONFIG_ARM64) && pmu->secure_access) { 218 pr_warn("ignoring \"secure-reg-access\" property for arm64\n"); 219 pmu->secure_access = false; 220 } 221 222 ret = init_fn(pmu); 223 } else if (probe_table) { 224 cpumask_setall(&pmu->supported_cpus); 225 ret = probe_current_pmu(pmu, probe_table); 226 } 227 228 if (ret) { 229 pr_info("%pOF: failed to probe PMU!\n", node); 230 goto out_free; 231 } 232 233 ret = armpmu_request_irqs(pmu); 234 if (ret) 235 goto out_free_irqs; 236 237 ret = armpmu_register(pmu); 238 if (ret) 239 goto out_free; 240 241 return 0; 242 243 out_free_irqs: 244 armpmu_free_irqs(pmu); 245 out_free: 246 pr_info("%pOF: failed to register PMU devices!\n", node); 247 armpmu_free(pmu); 248 return ret; 249 } 250