xref: /openbmc/linux/arch/arm64/kernel/topology.c (revision 4da722ca)
1 /*
2  * arch/arm64/kernel/topology.c
3  *
4  * Copyright (C) 2011,2013,2014 Linaro Limited.
5  *
6  * Based on the arm32 version written by Vincent Guittot in turn based on
7  * arch/sh/kernel/topology.c
8  *
9  * This file is subject to the terms and conditions of the GNU General Public
10  * License.  See the file "COPYING" in the main directory of this archive
11  * for more details.
12  */
13 
14 #include <linux/arch_topology.h>
15 #include <linux/cpu.h>
16 #include <linux/cpumask.h>
17 #include <linux/init.h>
18 #include <linux/percpu.h>
19 #include <linux/node.h>
20 #include <linux/nodemask.h>
21 #include <linux/of.h>
22 #include <linux/sched.h>
23 #include <linux/sched/topology.h>
24 #include <linux/slab.h>
25 #include <linux/string.h>
26 
27 #include <asm/cpu.h>
28 #include <asm/cputype.h>
29 #include <asm/topology.h>
30 
31 static int __init get_cpu_for_node(struct device_node *node)
32 {
33 	struct device_node *cpu_node;
34 	int cpu;
35 
36 	cpu_node = of_parse_phandle(node, "cpu", 0);
37 	if (!cpu_node)
38 		return -1;
39 
40 	for_each_possible_cpu(cpu) {
41 		if (of_get_cpu_node(cpu, NULL) == cpu_node) {
42 			topology_parse_cpu_capacity(cpu_node, cpu);
43 			of_node_put(cpu_node);
44 			return cpu;
45 		}
46 	}
47 
48 	pr_crit("Unable to find CPU node for %s\n", cpu_node->full_name);
49 
50 	of_node_put(cpu_node);
51 	return -1;
52 }
53 
54 static int __init parse_core(struct device_node *core, int cluster_id,
55 			     int core_id)
56 {
57 	char name[10];
58 	bool leaf = true;
59 	int i = 0;
60 	int cpu;
61 	struct device_node *t;
62 
63 	do {
64 		snprintf(name, sizeof(name), "thread%d", i);
65 		t = of_get_child_by_name(core, name);
66 		if (t) {
67 			leaf = false;
68 			cpu = get_cpu_for_node(t);
69 			if (cpu >= 0) {
70 				cpu_topology[cpu].cluster_id = cluster_id;
71 				cpu_topology[cpu].core_id = core_id;
72 				cpu_topology[cpu].thread_id = i;
73 			} else {
74 				pr_err("%s: Can't get CPU for thread\n",
75 				       t->full_name);
76 				of_node_put(t);
77 				return -EINVAL;
78 			}
79 			of_node_put(t);
80 		}
81 		i++;
82 	} while (t);
83 
84 	cpu = get_cpu_for_node(core);
85 	if (cpu >= 0) {
86 		if (!leaf) {
87 			pr_err("%s: Core has both threads and CPU\n",
88 			       core->full_name);
89 			return -EINVAL;
90 		}
91 
92 		cpu_topology[cpu].cluster_id = cluster_id;
93 		cpu_topology[cpu].core_id = core_id;
94 	} else if (leaf) {
95 		pr_err("%s: Can't get CPU for leaf core\n", core->full_name);
96 		return -EINVAL;
97 	}
98 
99 	return 0;
100 }
101 
102 static int __init parse_cluster(struct device_node *cluster, int depth)
103 {
104 	char name[10];
105 	bool leaf = true;
106 	bool has_cores = false;
107 	struct device_node *c;
108 	static int cluster_id __initdata;
109 	int core_id = 0;
110 	int i, ret;
111 
112 	/*
113 	 * First check for child clusters; we currently ignore any
114 	 * information about the nesting of clusters and present the
115 	 * scheduler with a flat list of them.
116 	 */
117 	i = 0;
118 	do {
119 		snprintf(name, sizeof(name), "cluster%d", i);
120 		c = of_get_child_by_name(cluster, name);
121 		if (c) {
122 			leaf = false;
123 			ret = parse_cluster(c, depth + 1);
124 			of_node_put(c);
125 			if (ret != 0)
126 				return ret;
127 		}
128 		i++;
129 	} while (c);
130 
131 	/* Now check for cores */
132 	i = 0;
133 	do {
134 		snprintf(name, sizeof(name), "core%d", i);
135 		c = of_get_child_by_name(cluster, name);
136 		if (c) {
137 			has_cores = true;
138 
139 			if (depth == 0) {
140 				pr_err("%s: cpu-map children should be clusters\n",
141 				       c->full_name);
142 				of_node_put(c);
143 				return -EINVAL;
144 			}
145 
146 			if (leaf) {
147 				ret = parse_core(c, cluster_id, core_id++);
148 			} else {
149 				pr_err("%s: Non-leaf cluster with core %s\n",
150 				       cluster->full_name, name);
151 				ret = -EINVAL;
152 			}
153 
154 			of_node_put(c);
155 			if (ret != 0)
156 				return ret;
157 		}
158 		i++;
159 	} while (c);
160 
161 	if (leaf && !has_cores)
162 		pr_warn("%s: empty cluster\n", cluster->full_name);
163 
164 	if (leaf)
165 		cluster_id++;
166 
167 	return 0;
168 }
169 
170 static int __init parse_dt_topology(void)
171 {
172 	struct device_node *cn, *map;
173 	int ret = 0;
174 	int cpu;
175 
176 	cn = of_find_node_by_path("/cpus");
177 	if (!cn) {
178 		pr_err("No CPU information found in DT\n");
179 		return 0;
180 	}
181 
182 	/*
183 	 * When topology is provided cpu-map is essentially a root
184 	 * cluster with restricted subnodes.
185 	 */
186 	map = of_get_child_by_name(cn, "cpu-map");
187 	if (!map)
188 		goto out;
189 
190 	ret = parse_cluster(map, 0);
191 	if (ret != 0)
192 		goto out_map;
193 
194 	topology_normalize_cpu_scale();
195 
196 	/*
197 	 * Check that all cores are in the topology; the SMP code will
198 	 * only mark cores described in the DT as possible.
199 	 */
200 	for_each_possible_cpu(cpu)
201 		if (cpu_topology[cpu].cluster_id == -1)
202 			ret = -EINVAL;
203 
204 out_map:
205 	of_node_put(map);
206 out:
207 	of_node_put(cn);
208 	return ret;
209 }
210 
211 /*
212  * cpu topology table
213  */
214 struct cpu_topology cpu_topology[NR_CPUS];
215 EXPORT_SYMBOL_GPL(cpu_topology);
216 
217 const struct cpumask *cpu_coregroup_mask(int cpu)
218 {
219 	return &cpu_topology[cpu].core_sibling;
220 }
221 
222 static void update_siblings_masks(unsigned int cpuid)
223 {
224 	struct cpu_topology *cpu_topo, *cpuid_topo = &cpu_topology[cpuid];
225 	int cpu;
226 
227 	/* update core and thread sibling masks */
228 	for_each_possible_cpu(cpu) {
229 		cpu_topo = &cpu_topology[cpu];
230 
231 		if (cpuid_topo->cluster_id != cpu_topo->cluster_id)
232 			continue;
233 
234 		cpumask_set_cpu(cpuid, &cpu_topo->core_sibling);
235 		if (cpu != cpuid)
236 			cpumask_set_cpu(cpu, &cpuid_topo->core_sibling);
237 
238 		if (cpuid_topo->core_id != cpu_topo->core_id)
239 			continue;
240 
241 		cpumask_set_cpu(cpuid, &cpu_topo->thread_sibling);
242 		if (cpu != cpuid)
243 			cpumask_set_cpu(cpu, &cpuid_topo->thread_sibling);
244 	}
245 }
246 
247 void store_cpu_topology(unsigned int cpuid)
248 {
249 	struct cpu_topology *cpuid_topo = &cpu_topology[cpuid];
250 	u64 mpidr;
251 
252 	if (cpuid_topo->cluster_id != -1)
253 		goto topology_populated;
254 
255 	mpidr = read_cpuid_mpidr();
256 
257 	/* Uniprocessor systems can rely on default topology values */
258 	if (mpidr & MPIDR_UP_BITMASK)
259 		return;
260 
261 	/* Create cpu topology mapping based on MPIDR. */
262 	if (mpidr & MPIDR_MT_BITMASK) {
263 		/* Multiprocessor system : Multi-threads per core */
264 		cpuid_topo->thread_id  = MPIDR_AFFINITY_LEVEL(mpidr, 0);
265 		cpuid_topo->core_id    = MPIDR_AFFINITY_LEVEL(mpidr, 1);
266 		cpuid_topo->cluster_id = MPIDR_AFFINITY_LEVEL(mpidr, 2) |
267 					 MPIDR_AFFINITY_LEVEL(mpidr, 3) << 8;
268 	} else {
269 		/* Multiprocessor system : Single-thread per core */
270 		cpuid_topo->thread_id  = -1;
271 		cpuid_topo->core_id    = MPIDR_AFFINITY_LEVEL(mpidr, 0);
272 		cpuid_topo->cluster_id = MPIDR_AFFINITY_LEVEL(mpidr, 1) |
273 					 MPIDR_AFFINITY_LEVEL(mpidr, 2) << 8 |
274 					 MPIDR_AFFINITY_LEVEL(mpidr, 3) << 16;
275 	}
276 
277 	pr_debug("CPU%u: cluster %d core %d thread %d mpidr %#016llx\n",
278 		 cpuid, cpuid_topo->cluster_id, cpuid_topo->core_id,
279 		 cpuid_topo->thread_id, mpidr);
280 
281 topology_populated:
282 	update_siblings_masks(cpuid);
283 }
284 
285 static void __init reset_cpu_topology(void)
286 {
287 	unsigned int cpu;
288 
289 	for_each_possible_cpu(cpu) {
290 		struct cpu_topology *cpu_topo = &cpu_topology[cpu];
291 
292 		cpu_topo->thread_id = -1;
293 		cpu_topo->core_id = 0;
294 		cpu_topo->cluster_id = -1;
295 
296 		cpumask_clear(&cpu_topo->core_sibling);
297 		cpumask_set_cpu(cpu, &cpu_topo->core_sibling);
298 		cpumask_clear(&cpu_topo->thread_sibling);
299 		cpumask_set_cpu(cpu, &cpu_topo->thread_sibling);
300 	}
301 }
302 
303 void __init init_cpu_topology(void)
304 {
305 	reset_cpu_topology();
306 
307 	/*
308 	 * Discard anything that was parsed if we hit an error so we
309 	 * don't use partial information.
310 	 */
311 	if (of_have_populated_dt() && parse_dt_topology())
312 		reset_cpu_topology();
313 }
314