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