Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0
2 : : /*
3 : : * Arch specific cpu topology information
4 : : *
5 : : * Copyright (C) 2016, ARM Ltd.
6 : : * Written by: Juri Lelli, ARM Ltd.
7 : : */
8 : :
9 : : #include <linux/acpi.h>
10 : : #include <linux/cpu.h>
11 : : #include <linux/cpufreq.h>
12 : : #include <linux/device.h>
13 : : #include <linux/of.h>
14 : : #include <linux/slab.h>
15 : : #include <linux/string.h>
16 : : #include <linux/sched/topology.h>
17 : : #include <linux/cpuset.h>
18 : : #include <linux/cpumask.h>
19 : : #include <linux/init.h>
20 : : #include <linux/percpu.h>
21 : : #include <linux/sched.h>
22 : : #include <linux/smp.h>
23 : :
24 : : DEFINE_PER_CPU(unsigned long, freq_scale) = SCHED_CAPACITY_SCALE;
25 : :
26 : 14999 : void arch_set_freq_scale(struct cpumask *cpus, unsigned long cur_freq,
27 : : unsigned long max_freq)
28 : : {
29 : : unsigned long scale;
30 : : int i;
31 : :
32 : 14999 : scale = (cur_freq << SCHED_CAPACITY_SHIFT) / max_freq;
33 : :
34 [ + + ]: 89994 : for_each_cpu(i, cpus)
35 : 59996 : per_cpu(freq_scale, i) = scale;
36 : 14999 : }
37 : :
38 : : DEFINE_PER_CPU(unsigned long, cpu_scale) = SCHED_CAPACITY_SCALE;
39 : :
40 : 828 : void topology_set_cpu_scale(unsigned int cpu, unsigned long capacity)
41 : : {
42 : 828 : per_cpu(cpu_scale, cpu) = capacity;
43 : 828 : }
44 : :
45 : 0 : static ssize_t cpu_capacity_show(struct device *dev,
46 : : struct device_attribute *attr,
47 : : char *buf)
48 : : {
49 : : struct cpu *cpu = container_of(dev, struct cpu, dev);
50 : :
51 : 0 : return sprintf(buf, "%lu\n", topology_get_cpu_scale(cpu->dev.id));
52 : : }
53 : :
54 : : static void update_topology_flags_workfn(struct work_struct *work);
55 : : static DECLARE_WORK(update_topology_flags_work, update_topology_flags_workfn);
56 : :
57 : : static DEVICE_ATTR_RO(cpu_capacity);
58 : :
59 : 207 : static int register_cpu_capacity_sysctl(void)
60 : : {
61 : : int i;
62 : : struct device *cpu;
63 : :
64 [ + + ]: 1242 : for_each_possible_cpu(i) {
65 : 828 : cpu = get_cpu_device(i);
66 [ - + ]: 828 : if (!cpu) {
67 : 0 : pr_err("%s: too early to get CPU%d device!\n",
68 : : __func__, i);
69 : 0 : continue;
70 : : }
71 : 828 : device_create_file(cpu, &dev_attr_cpu_capacity);
72 : : }
73 : :
74 : 207 : return 0;
75 : : }
76 : : subsys_initcall(register_cpu_capacity_sysctl);
77 : :
78 : : static int update_topology;
79 : :
80 : 207 : int topology_update_cpu_topology(void)
81 : : {
82 : 207 : return update_topology;
83 : : }
84 : :
85 : : /*
86 : : * Updating the sched_domains can't be done directly from cpufreq callbacks
87 : : * due to locking, so queue the work for later.
88 : : */
89 : 0 : static void update_topology_flags_workfn(struct work_struct *work)
90 : : {
91 : 0 : update_topology = 1;
92 : 0 : rebuild_sched_domains();
93 : : pr_debug("sched_domain hierarchy rebuilt, flags updated\n");
94 : 0 : update_topology = 0;
95 : 0 : }
96 : :
97 : : static u32 capacity_scale;
98 : : static u32 *raw_capacity;
99 : :
100 : : static int free_raw_capacity(void)
101 : : {
102 : 207 : kfree(raw_capacity);
103 : 207 : raw_capacity = NULL;
104 : :
105 : : return 0;
106 : : }
107 : :
108 : 0 : void topology_normalize_cpu_scale(void)
109 : : {
110 : : u64 capacity;
111 : : int cpu;
112 : :
113 [ # # ]: 0 : if (!raw_capacity)
114 : 0 : return;
115 : :
116 : : pr_debug("cpu_capacity: capacity_scale=%u\n", capacity_scale);
117 [ # # ]: 0 : for_each_possible_cpu(cpu) {
118 : : pr_debug("cpu_capacity: cpu=%d raw_capacity=%u\n",
119 : : cpu, raw_capacity[cpu]);
120 : 0 : capacity = (raw_capacity[cpu] << SCHED_CAPACITY_SHIFT)
121 : 0 : / capacity_scale;
122 : : topology_set_cpu_scale(cpu, capacity);
123 : : pr_debug("cpu_capacity: CPU%d cpu_capacity=%lu\n",
124 : : cpu, topology_get_cpu_scale(cpu));
125 : : }
126 : : }
127 : :
128 : 828 : bool __init topology_parse_cpu_capacity(struct device_node *cpu_node, int cpu)
129 : : {
130 : : static bool cap_parsing_failed;
131 : : int ret;
132 : : u32 cpu_capacity;
133 : :
134 [ + + ]: 828 : if (cap_parsing_failed)
135 : : return false;
136 : :
137 : : ret = of_property_read_u32(cpu_node, "capacity-dmips-mhz",
138 : : &cpu_capacity);
139 [ - + ]: 207 : if (!ret) {
140 [ # # ]: 0 : if (!raw_capacity) {
141 : 0 : raw_capacity = kcalloc(num_possible_cpus(),
142 : : sizeof(*raw_capacity),
143 : : GFP_KERNEL);
144 [ # # ]: 0 : if (!raw_capacity) {
145 : 0 : cap_parsing_failed = true;
146 : 0 : return false;
147 : : }
148 : : }
149 : 0 : capacity_scale = max(cpu_capacity, capacity_scale);
150 : 0 : raw_capacity[cpu] = cpu_capacity;
151 : : pr_debug("cpu_capacity: %pOF cpu_capacity=%u (raw)\n",
152 : : cpu_node, raw_capacity[cpu]);
153 : : } else {
154 [ - + ]: 207 : if (raw_capacity) {
155 : 0 : pr_err("cpu_capacity: missing %pOF raw capacity\n",
156 : : cpu_node);
157 : 0 : pr_err("cpu_capacity: partial information: fallback to 1024 for all CPUs\n");
158 : : }
159 : 207 : cap_parsing_failed = true;
160 : : free_raw_capacity();
161 : : }
162 : :
163 : 207 : return !ret;
164 : : }
165 : :
166 : : #ifdef CONFIG_CPU_FREQ
167 : : static cpumask_var_t cpus_to_visit;
168 : : static void parsing_done_workfn(struct work_struct *work);
169 : : static DECLARE_WORK(parsing_done_work, parsing_done_workfn);
170 : :
171 : : static int
172 : 0 : init_cpu_capacity_callback(struct notifier_block *nb,
173 : : unsigned long val,
174 : : void *data)
175 : : {
176 : : struct cpufreq_policy *policy = data;
177 : : int cpu;
178 : :
179 [ # # ]: 0 : if (!raw_capacity)
180 : : return 0;
181 : :
182 [ # # ]: 0 : if (val != CPUFREQ_CREATE_POLICY)
183 : : return 0;
184 : :
185 : : pr_debug("cpu_capacity: init cpu capacity for CPUs [%*pbl] (to_visit=%*pbl)\n",
186 : : cpumask_pr_args(policy->related_cpus),
187 : : cpumask_pr_args(cpus_to_visit));
188 : :
189 : : cpumask_andnot(cpus_to_visit, cpus_to_visit, policy->related_cpus);
190 : :
191 [ # # ]: 0 : for_each_cpu(cpu, policy->related_cpus) {
192 : 0 : raw_capacity[cpu] = topology_get_cpu_scale(cpu) *
193 : 0 : policy->cpuinfo.max_freq / 1000UL;
194 : 0 : capacity_scale = max(raw_capacity[cpu], capacity_scale);
195 : : }
196 : :
197 [ # # ]: 0 : if (cpumask_empty(cpus_to_visit)) {
198 : 0 : topology_normalize_cpu_scale();
199 : : schedule_work(&update_topology_flags_work);
200 : : free_raw_capacity();
201 : : pr_debug("cpu_capacity: parsing done\n");
202 : : schedule_work(&parsing_done_work);
203 : : }
204 : :
205 : : return 0;
206 : : }
207 : :
208 : : static struct notifier_block init_cpu_capacity_notifier = {
209 : : .notifier_call = init_cpu_capacity_callback,
210 : : };
211 : :
212 : 207 : static int __init register_cpufreq_notifier(void)
213 : : {
214 : : int ret;
215 : :
216 : : /*
217 : : * on ACPI-based systems we need to use the default cpu capacity
218 : : * until we have the necessary code to parse the cpu capacity, so
219 : : * skip registering cpufreq notifier.
220 : : */
221 [ - + ]: 207 : if (!acpi_disabled || !raw_capacity)
222 : : return -EINVAL;
223 : :
224 : : if (!alloc_cpumask_var(&cpus_to_visit, GFP_KERNEL))
225 : : return -ENOMEM;
226 : :
227 : : cpumask_copy(cpus_to_visit, cpu_possible_mask);
228 : :
229 : 0 : ret = cpufreq_register_notifier(&init_cpu_capacity_notifier,
230 : : CPUFREQ_POLICY_NOTIFIER);
231 : :
232 : : if (ret)
233 : : free_cpumask_var(cpus_to_visit);
234 : :
235 : 0 : return ret;
236 : : }
237 : : core_initcall(register_cpufreq_notifier);
238 : :
239 : 0 : static void parsing_done_workfn(struct work_struct *work)
240 : : {
241 : 0 : cpufreq_unregister_notifier(&init_cpu_capacity_notifier,
242 : : CPUFREQ_POLICY_NOTIFIER);
243 : : free_cpumask_var(cpus_to_visit);
244 : 0 : }
245 : :
246 : : #else
247 : : core_initcall(free_raw_capacity);
248 : : #endif
249 : :
250 : : #if defined(CONFIG_ARM64) || defined(CONFIG_RISCV)
251 : : static int __init get_cpu_for_node(struct device_node *node)
252 : : {
253 : : struct device_node *cpu_node;
254 : : int cpu;
255 : :
256 : : cpu_node = of_parse_phandle(node, "cpu", 0);
257 : : if (!cpu_node)
258 : : return -1;
259 : :
260 : : cpu = of_cpu_node_to_id(cpu_node);
261 : : if (cpu >= 0)
262 : : topology_parse_cpu_capacity(cpu_node, cpu);
263 : : else
264 : : pr_crit("Unable to find CPU node for %pOF\n", cpu_node);
265 : :
266 : : of_node_put(cpu_node);
267 : : return cpu;
268 : : }
269 : :
270 : : static int __init parse_core(struct device_node *core, int package_id,
271 : : int core_id)
272 : : {
273 : : char name[10];
274 : : bool leaf = true;
275 : : int i = 0;
276 : : int cpu;
277 : : struct device_node *t;
278 : :
279 : : do {
280 : : snprintf(name, sizeof(name), "thread%d", i);
281 : : t = of_get_child_by_name(core, name);
282 : : if (t) {
283 : : leaf = false;
284 : : cpu = get_cpu_for_node(t);
285 : : if (cpu >= 0) {
286 : : cpu_topology[cpu].package_id = package_id;
287 : : cpu_topology[cpu].core_id = core_id;
288 : : cpu_topology[cpu].thread_id = i;
289 : : } else {
290 : : pr_err("%pOF: Can't get CPU for thread\n",
291 : : t);
292 : : of_node_put(t);
293 : : return -EINVAL;
294 : : }
295 : : of_node_put(t);
296 : : }
297 : : i++;
298 : : } while (t);
299 : :
300 : : cpu = get_cpu_for_node(core);
301 : : if (cpu >= 0) {
302 : : if (!leaf) {
303 : : pr_err("%pOF: Core has both threads and CPU\n",
304 : : core);
305 : : return -EINVAL;
306 : : }
307 : :
308 : : cpu_topology[cpu].package_id = package_id;
309 : : cpu_topology[cpu].core_id = core_id;
310 : : } else if (leaf) {
311 : : pr_err("%pOF: Can't get CPU for leaf core\n", core);
312 : : return -EINVAL;
313 : : }
314 : :
315 : : return 0;
316 : : }
317 : :
318 : : static int __init parse_cluster(struct device_node *cluster, int depth)
319 : : {
320 : : char name[10];
321 : : bool leaf = true;
322 : : bool has_cores = false;
323 : : struct device_node *c;
324 : : static int package_id __initdata;
325 : : int core_id = 0;
326 : : int i, ret;
327 : :
328 : : /*
329 : : * First check for child clusters; we currently ignore any
330 : : * information about the nesting of clusters and present the
331 : : * scheduler with a flat list of them.
332 : : */
333 : : i = 0;
334 : : do {
335 : : snprintf(name, sizeof(name), "cluster%d", i);
336 : : c = of_get_child_by_name(cluster, name);
337 : : if (c) {
338 : : leaf = false;
339 : : ret = parse_cluster(c, depth + 1);
340 : : of_node_put(c);
341 : : if (ret != 0)
342 : : return ret;
343 : : }
344 : : i++;
345 : : } while (c);
346 : :
347 : : /* Now check for cores */
348 : : i = 0;
349 : : do {
350 : : snprintf(name, sizeof(name), "core%d", i);
351 : : c = of_get_child_by_name(cluster, name);
352 : : if (c) {
353 : : has_cores = true;
354 : :
355 : : if (depth == 0) {
356 : : pr_err("%pOF: cpu-map children should be clusters\n",
357 : : c);
358 : : of_node_put(c);
359 : : return -EINVAL;
360 : : }
361 : :
362 : : if (leaf) {
363 : : ret = parse_core(c, package_id, core_id++);
364 : : } else {
365 : : pr_err("%pOF: Non-leaf cluster with core %s\n",
366 : : cluster, name);
367 : : ret = -EINVAL;
368 : : }
369 : :
370 : : of_node_put(c);
371 : : if (ret != 0)
372 : : return ret;
373 : : }
374 : : i++;
375 : : } while (c);
376 : :
377 : : if (leaf && !has_cores)
378 : : pr_warn("%pOF: empty cluster\n", cluster);
379 : :
380 : : if (leaf)
381 : : package_id++;
382 : :
383 : : return 0;
384 : : }
385 : :
386 : : static int __init parse_dt_topology(void)
387 : : {
388 : : struct device_node *cn, *map;
389 : : int ret = 0;
390 : : int cpu;
391 : :
392 : : cn = of_find_node_by_path("/cpus");
393 : : if (!cn) {
394 : : pr_err("No CPU information found in DT\n");
395 : : return 0;
396 : : }
397 : :
398 : : /*
399 : : * When topology is provided cpu-map is essentially a root
400 : : * cluster with restricted subnodes.
401 : : */
402 : : map = of_get_child_by_name(cn, "cpu-map");
403 : : if (!map)
404 : : goto out;
405 : :
406 : : ret = parse_cluster(map, 0);
407 : : if (ret != 0)
408 : : goto out_map;
409 : :
410 : : topology_normalize_cpu_scale();
411 : :
412 : : /*
413 : : * Check that all cores are in the topology; the SMP code will
414 : : * only mark cores described in the DT as possible.
415 : : */
416 : : for_each_possible_cpu(cpu)
417 : : if (cpu_topology[cpu].package_id == -1)
418 : : ret = -EINVAL;
419 : :
420 : : out_map:
421 : : of_node_put(map);
422 : : out:
423 : : of_node_put(cn);
424 : : return ret;
425 : : }
426 : : #endif
427 : :
428 : : /*
429 : : * cpu topology table
430 : : */
431 : : struct cpu_topology cpu_topology[NR_CPUS];
432 : : EXPORT_SYMBOL_GPL(cpu_topology);
433 : :
434 : 0 : const struct cpumask *cpu_coregroup_mask(int cpu)
435 : : {
436 : : const cpumask_t *core_mask = cpumask_of_node(cpu_to_node(cpu));
437 : :
438 : : /* Find the smaller of NUMA, core or LLC siblings */
439 [ # # ]: 0 : if (cpumask_subset(&cpu_topology[cpu].core_sibling, core_mask)) {
440 : : /* not numa in package, lets use the package siblings */
441 : 0 : core_mask = &cpu_topology[cpu].core_sibling;
442 : : }
443 [ # # ]: 0 : if (cpu_topology[cpu].llc_id != -1) {
444 [ # # ]: 0 : if (cpumask_subset(&cpu_topology[cpu].llc_sibling, core_mask))
445 : 0 : core_mask = &cpu_topology[cpu].llc_sibling;
446 : : }
447 : :
448 : 0 : return core_mask;
449 : : }
450 : :
451 : 828 : void update_siblings_masks(unsigned int cpuid)
452 : : {
453 : : struct cpu_topology *cpu_topo, *cpuid_topo = &cpu_topology[cpuid];
454 : : int cpu;
455 : :
456 : : /* update core and thread sibling masks */
457 [ + + ]: 3105 : for_each_online_cpu(cpu) {
458 : : cpu_topo = &cpu_topology[cpu];
459 : :
460 [ + - ]: 1449 : if (cpuid_topo->llc_id == cpu_topo->llc_id) {
461 : : cpumask_set_cpu(cpu, &cpuid_topo->llc_sibling);
462 : : cpumask_set_cpu(cpuid, &cpu_topo->llc_sibling);
463 : : }
464 : :
465 [ - + ]: 1449 : if (cpuid_topo->package_id != cpu_topo->package_id)
466 : 0 : continue;
467 : :
468 : : cpumask_set_cpu(cpuid, &cpu_topo->core_sibling);
469 : : cpumask_set_cpu(cpu, &cpuid_topo->core_sibling);
470 : :
471 [ + + ]: 1449 : if (cpuid_topo->core_id != cpu_topo->core_id)
472 : 1242 : continue;
473 : :
474 : : cpumask_set_cpu(cpuid, &cpu_topo->thread_sibling);
475 : : cpumask_set_cpu(cpu, &cpuid_topo->thread_sibling);
476 : : }
477 : 828 : }
478 : :
479 : 828 : static void clear_cpu_topology(int cpu)
480 : : {
481 : : struct cpu_topology *cpu_topo = &cpu_topology[cpu];
482 : :
483 : : cpumask_clear(&cpu_topo->llc_sibling);
484 : : cpumask_set_cpu(cpu, &cpu_topo->llc_sibling);
485 : :
486 : : cpumask_clear(&cpu_topo->core_sibling);
487 : : cpumask_set_cpu(cpu, &cpu_topo->core_sibling);
488 : : cpumask_clear(&cpu_topo->thread_sibling);
489 : : cpumask_set_cpu(cpu, &cpu_topo->thread_sibling);
490 : 828 : }
491 : :
492 : 207 : void __init reset_cpu_topology(void)
493 : : {
494 : : unsigned int cpu;
495 : :
496 [ + + ]: 1242 : for_each_possible_cpu(cpu) {
497 : : struct cpu_topology *cpu_topo = &cpu_topology[cpu];
498 : :
499 : 828 : cpu_topo->thread_id = -1;
500 : 828 : cpu_topo->core_id = -1;
501 : 828 : cpu_topo->package_id = -1;
502 : 828 : cpu_topo->llc_id = -1;
503 : :
504 : 828 : clear_cpu_topology(cpu);
505 : : }
506 : 207 : }
507 : :
508 : 0 : void remove_cpu_topology(unsigned int cpu)
509 : : {
510 : : int sibling;
511 : :
512 [ # # ]: 0 : for_each_cpu(sibling, topology_core_cpumask(cpu))
513 : 0 : cpumask_clear_cpu(cpu, topology_core_cpumask(sibling));
514 [ # # ]: 0 : for_each_cpu(sibling, topology_sibling_cpumask(cpu))
515 : 0 : cpumask_clear_cpu(cpu, topology_sibling_cpumask(sibling));
516 [ # # ]: 0 : for_each_cpu(sibling, topology_llc_cpumask(cpu))
517 : 0 : cpumask_clear_cpu(cpu, topology_llc_cpumask(sibling));
518 : :
519 : 0 : clear_cpu_topology(cpu);
520 : 0 : }
521 : :
522 : 0 : __weak int __init parse_acpi_topology(void)
523 : : {
524 : 0 : return 0;
525 : : }
526 : :
527 : : #if defined(CONFIG_ARM64) || defined(CONFIG_RISCV)
528 : : void __init init_cpu_topology(void)
529 : : {
530 : : reset_cpu_topology();
531 : :
532 : : /*
533 : : * Discard anything that was parsed if we hit an error so we
534 : : * don't use partial information.
535 : : */
536 : : if (parse_acpi_topology())
537 : : reset_cpu_topology();
538 : : else if (of_have_populated_dt() && parse_dt_topology())
539 : : reset_cpu_topology();
540 : : }
541 : : #endif
|
