]>
Commit | Line | Data |
---|---|---|
2874c5fd | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
0332c2d4 ME |
2 | /* |
3 | * pseries CPU Hotplug infrastructure. | |
4 | * | |
413f7c40 ME |
5 | * Split out from arch/powerpc/platforms/pseries/setup.c |
6 | * arch/powerpc/kernel/rtas.c, and arch/powerpc/platforms/pseries/smp.c | |
0332c2d4 ME |
7 | * |
8 | * Peter Bergner, IBM March 2001. | |
9 | * Copyright (C) 2001 IBM. | |
413f7c40 ME |
10 | * Dave Engebretsen, Peter Bergner, and |
11 | * Mike Corrigan {engebret|bergner|mikec}@us.ibm.com | |
12 | * Plus various changes from other IBM teams... | |
0332c2d4 ME |
13 | * |
14 | * Copyright (C) 2006 Michael Ellerman, IBM Corporation | |
0332c2d4 ME |
15 | */ |
16 | ||
e666ae0b NF |
17 | #define pr_fmt(fmt) "pseries-hotplug-cpu: " fmt |
18 | ||
0332c2d4 | 19 | #include <linux/kernel.h> |
0b05ac6e | 20 | #include <linux/interrupt.h> |
0332c2d4 | 21 | #include <linux/delay.h> |
62fe91bb | 22 | #include <linux/sched.h> /* for idle_task_exit */ |
ef8bd77f | 23 | #include <linux/sched/hotplug.h> |
0332c2d4 | 24 | #include <linux/cpu.h> |
1cf3d8b3 | 25 | #include <linux/of.h> |
ac713800 | 26 | #include <linux/slab.h> |
0332c2d4 ME |
27 | #include <asm/prom.h> |
28 | #include <asm/rtas.h> | |
29 | #include <asm/firmware.h> | |
30 | #include <asm/machdep.h> | |
31 | #include <asm/vdso_datapage.h> | |
0b05ac6e | 32 | #include <asm/xics.h> |
eac1e731 | 33 | #include <asm/xive.h> |
212bebb4 | 34 | #include <asm/plpar_wrappers.h> |
1d9a0907 | 35 | #include <asm/topology.h> |
212bebb4 | 36 | |
183deeea | 37 | #include "pseries.h" |
3aa565f5 | 38 | #include "offline_states.h" |
0332c2d4 ME |
39 | |
40 | /* This version can't take the spinlock, because it never returns */ | |
41dd03a9 | 41 | static int rtas_stop_self_token = RTAS_UNKNOWN_SERVICE; |
0332c2d4 | 42 | |
3aa565f5 GS |
43 | static DEFINE_PER_CPU(enum cpu_state_vals, preferred_offline_state) = |
44 | CPU_STATE_OFFLINE; | |
45 | static DEFINE_PER_CPU(enum cpu_state_vals, current_state) = CPU_STATE_OFFLINE; | |
46 | ||
47 | static enum cpu_state_vals default_offline_state = CPU_STATE_OFFLINE; | |
48 | ||
4cc7ecb7 | 49 | static bool cede_offline_enabled __read_mostly = true; |
3aa565f5 GS |
50 | |
51 | /* | |
52 | * Enable/disable cede_offline when available. | |
53 | */ | |
54 | static int __init setup_cede_offline(char *str) | |
55 | { | |
4cc7ecb7 | 56 | return (kstrtobool(str, &cede_offline_enabled) == 0); |
3aa565f5 GS |
57 | } |
58 | ||
59 | __setup("cede_offline=", setup_cede_offline); | |
60 | ||
61 | enum cpu_state_vals get_cpu_current_state(int cpu) | |
62 | { | |
63 | return per_cpu(current_state, cpu); | |
64 | } | |
65 | ||
66 | void set_cpu_current_state(int cpu, enum cpu_state_vals state) | |
67 | { | |
68 | per_cpu(current_state, cpu) = state; | |
69 | } | |
70 | ||
71 | enum cpu_state_vals get_preferred_offline_state(int cpu) | |
72 | { | |
73 | return per_cpu(preferred_offline_state, cpu); | |
74 | } | |
75 | ||
76 | void set_preferred_offline_state(int cpu, enum cpu_state_vals state) | |
77 | { | |
78 | per_cpu(preferred_offline_state, cpu) = state; | |
79 | } | |
80 | ||
81 | void set_default_offline_state(int cpu) | |
82 | { | |
83 | per_cpu(preferred_offline_state, cpu) = default_offline_state; | |
84 | } | |
85 | ||
04da6af9 | 86 | static void rtas_stop_self(void) |
0332c2d4 | 87 | { |
b2e8590f | 88 | static struct rtas_args args; |
4fb8d027 | 89 | |
0332c2d4 ME |
90 | local_irq_disable(); |
91 | ||
41dd03a9 | 92 | BUG_ON(rtas_stop_self_token == RTAS_UNKNOWN_SERVICE); |
0332c2d4 | 93 | |
b2e8590f | 94 | rtas_call_unlocked(&args, rtas_stop_self_token, 0, 1, NULL); |
0332c2d4 ME |
95 | |
96 | panic("Alas, I survived.\n"); | |
97 | } | |
98 | ||
06ba30b6 | 99 | static void pseries_mach_cpu_die(void) |
04da6af9 | 100 | { |
3aa565f5 GS |
101 | unsigned int cpu = smp_processor_id(); |
102 | unsigned int hwcpu = hard_smp_processor_id(); | |
103 | u8 cede_latency_hint = 0; | |
104 | ||
04da6af9 ME |
105 | local_irq_disable(); |
106 | idle_task_exit(); | |
eac1e731 CLG |
107 | if (xive_enabled()) |
108 | xive_teardown_cpu(); | |
109 | else | |
110 | xics_teardown_cpu(); | |
3aa565f5 GS |
111 | |
112 | if (get_preferred_offline_state(cpu) == CPU_STATE_INACTIVE) { | |
113 | set_cpu_current_state(cpu, CPU_STATE_INACTIVE); | |
32d8ad4e BK |
114 | if (ppc_md.suspend_disable_cpu) |
115 | ppc_md.suspend_disable_cpu(); | |
116 | ||
3aa565f5 GS |
117 | cede_latency_hint = 2; |
118 | ||
119 | get_lppaca()->idle = 1; | |
f13c13a0 | 120 | if (!lppaca_shared_proc(get_lppaca())) |
3aa565f5 GS |
121 | get_lppaca()->donate_dedicated_cpu = 1; |
122 | ||
3aa565f5 | 123 | while (get_preferred_offline_state(cpu) == CPU_STATE_INACTIVE) { |
fb912568 LZ |
124 | while (!prep_irq_for_idle()) { |
125 | local_irq_enable(); | |
126 | local_irq_disable(); | |
127 | } | |
128 | ||
3aa565f5 | 129 | extended_cede_processor(cede_latency_hint); |
3aa565f5 GS |
130 | } |
131 | ||
fb912568 LZ |
132 | local_irq_disable(); |
133 | ||
f13c13a0 | 134 | if (!lppaca_shared_proc(get_lppaca())) |
3aa565f5 GS |
135 | get_lppaca()->donate_dedicated_cpu = 0; |
136 | get_lppaca()->idle = 0; | |
3aa565f5 | 137 | |
0212f260 | 138 | if (get_preferred_offline_state(cpu) == CPU_STATE_ONLINE) { |
598c8231 | 139 | unregister_slb_shadow(hwcpu); |
3aa565f5 | 140 | |
fb912568 | 141 | hard_irq_disable(); |
0212f260 VS |
142 | /* |
143 | * Call to start_secondary_resume() will not return. | |
144 | * Kernel stack will be reset and start_secondary() | |
145 | * will be called to continue the online operation. | |
146 | */ | |
147 | start_secondary_resume(); | |
148 | } | |
149 | } | |
3aa565f5 | 150 | |
0212f260 VS |
151 | /* Requested state is CPU_STATE_OFFLINE at this point */ |
152 | WARN_ON(get_preferred_offline_state(cpu) != CPU_STATE_OFFLINE); | |
3aa565f5 | 153 | |
0212f260 | 154 | set_cpu_current_state(cpu, CPU_STATE_OFFLINE); |
598c8231 | 155 | unregister_slb_shadow(hwcpu); |
0212f260 | 156 | rtas_stop_self(); |
3aa565f5 | 157 | |
04da6af9 ME |
158 | /* Should never get here... */ |
159 | BUG(); | |
160 | for(;;); | |
161 | } | |
162 | ||
06ba30b6 | 163 | static int pseries_cpu_disable(void) |
413f7c40 ME |
164 | { |
165 | int cpu = smp_processor_id(); | |
166 | ||
ea0f1cab | 167 | set_cpu_online(cpu, false); |
413f7c40 ME |
168 | vdso_data->processorCount--; |
169 | ||
170 | /*fix boot_cpuid here*/ | |
171 | if (cpu == boot_cpuid) | |
8729faaa | 172 | boot_cpuid = cpumask_any(cpu_online_mask); |
413f7c40 ME |
173 | |
174 | /* FIXME: abstract this to not be platform specific later on */ | |
eac1e731 CLG |
175 | if (xive_enabled()) |
176 | xive_smp_disable_cpu(); | |
177 | else | |
178 | xics_migrate_irqs_away(); | |
413f7c40 ME |
179 | return 0; |
180 | } | |
181 | ||
3aa565f5 GS |
182 | /* |
183 | * pseries_cpu_die: Wait for the cpu to die. | |
184 | * @cpu: logical processor id of the CPU whose death we're awaiting. | |
185 | * | |
186 | * This function is called from the context of the thread which is performing | |
187 | * the cpu-offline. Here we wait for long enough to allow the cpu in question | |
188 | * to self-destroy so that the cpu-offline thread can send the CPU_DEAD | |
189 | * notifications. | |
190 | * | |
191 | * OTOH, pseries_mach_cpu_die() is called by the @cpu when it wants to | |
192 | * self-destruct. | |
193 | */ | |
06ba30b6 | 194 | static void pseries_cpu_die(unsigned int cpu) |
413f7c40 ME |
195 | { |
196 | int tries; | |
3aa565f5 | 197 | int cpu_status = 1; |
413f7c40 ME |
198 | unsigned int pcpu = get_hard_smp_processor_id(cpu); |
199 | ||
3aa565f5 GS |
200 | if (get_preferred_offline_state(cpu) == CPU_STATE_INACTIVE) { |
201 | cpu_status = 1; | |
940ce422 | 202 | for (tries = 0; tries < 5000; tries++) { |
3aa565f5 GS |
203 | if (get_cpu_current_state(cpu) == CPU_STATE_INACTIVE) { |
204 | cpu_status = 0; | |
205 | break; | |
206 | } | |
940ce422 | 207 | msleep(1); |
3aa565f5 GS |
208 | } |
209 | } else if (get_preferred_offline_state(cpu) == CPU_STATE_OFFLINE) { | |
210 | ||
211 | for (tries = 0; tries < 25; tries++) { | |
f8b67691 MN |
212 | cpu_status = smp_query_cpu_stopped(pcpu); |
213 | if (cpu_status == QCSS_STOPPED || | |
214 | cpu_status == QCSS_HARDWARE_ERROR) | |
3aa565f5 GS |
215 | break; |
216 | cpu_relax(); | |
217 | } | |
413f7c40 | 218 | } |
3aa565f5 | 219 | |
413f7c40 ME |
220 | if (cpu_status != 0) { |
221 | printk("Querying DEAD? cpu %i (%i) shows %i\n", | |
222 | cpu, pcpu, cpu_status); | |
223 | } | |
224 | ||
25985edc | 225 | /* Isolation and deallocation are definitely done by |
413f7c40 ME |
226 | * drslot_chrp_cpu. If they were not they would be |
227 | * done here. Change isolate state to Isolate and | |
228 | * change allocation-state to Unusable. | |
229 | */ | |
d2e60075 | 230 | paca_ptrs[cpu]->cpu_start = 0; |
413f7c40 ME |
231 | } |
232 | ||
233 | /* | |
828a6986 | 234 | * Update cpu_present_mask and paca(s) for a new cpu node. The wrinkle |
413f7c40 ME |
235 | * here is that a cpu device node may represent up to two logical cpus |
236 | * in the SMT case. We must honor the assumption in other code that | |
237 | * the logical ids for sibling SMT threads x and y are adjacent, such | |
238 | * that x^1 == y and y^1 == x. | |
239 | */ | |
06ba30b6 | 240 | static int pseries_add_processor(struct device_node *np) |
413f7c40 ME |
241 | { |
242 | unsigned int cpu; | |
8729faaa | 243 | cpumask_var_t candidate_mask, tmp; |
413f7c40 | 244 | int err = -ENOSPC, len, nthreads, i; |
d6f1e7ab | 245 | const __be32 *intserv; |
413f7c40 | 246 | |
e2eb6392 | 247 | intserv = of_get_property(np, "ibm,ppc-interrupt-server#s", &len); |
413f7c40 ME |
248 | if (!intserv) |
249 | return 0; | |
250 | ||
8729faaa AB |
251 | zalloc_cpumask_var(&candidate_mask, GFP_KERNEL); |
252 | zalloc_cpumask_var(&tmp, GFP_KERNEL); | |
253 | ||
413f7c40 ME |
254 | nthreads = len / sizeof(u32); |
255 | for (i = 0; i < nthreads; i++) | |
8729faaa | 256 | cpumask_set_cpu(i, tmp); |
413f7c40 | 257 | |
86ef5c9a | 258 | cpu_maps_update_begin(); |
413f7c40 | 259 | |
8729faaa | 260 | BUG_ON(!cpumask_subset(cpu_present_mask, cpu_possible_mask)); |
413f7c40 ME |
261 | |
262 | /* Get a bitmap of unoccupied slots. */ | |
8729faaa AB |
263 | cpumask_xor(candidate_mask, cpu_possible_mask, cpu_present_mask); |
264 | if (cpumask_empty(candidate_mask)) { | |
413f7c40 ME |
265 | /* If we get here, it most likely means that NR_CPUS is |
266 | * less than the partition's max processors setting. | |
267 | */ | |
b7c670d6 RH |
268 | printk(KERN_ERR "Cannot add cpu %pOF; this system configuration" |
269 | " supports %d logical cpus.\n", np, | |
53a448c3 | 270 | num_possible_cpus()); |
413f7c40 ME |
271 | goto out_unlock; |
272 | } | |
273 | ||
8729faaa AB |
274 | while (!cpumask_empty(tmp)) |
275 | if (cpumask_subset(tmp, candidate_mask)) | |
413f7c40 ME |
276 | /* Found a range where we can insert the new cpu(s) */ |
277 | break; | |
278 | else | |
8729faaa | 279 | cpumask_shift_left(tmp, tmp, nthreads); |
413f7c40 | 280 | |
8729faaa | 281 | if (cpumask_empty(tmp)) { |
828a6986 | 282 | printk(KERN_ERR "Unable to find space in cpu_present_mask for" |
b9ef7b4b | 283 | " processor %pOFn with %d thread(s)\n", np, |
413f7c40 ME |
284 | nthreads); |
285 | goto out_unlock; | |
286 | } | |
287 | ||
8729faaa | 288 | for_each_cpu(cpu, tmp) { |
104699c0 | 289 | BUG_ON(cpu_present(cpu)); |
ea0f1cab | 290 | set_cpu_present(cpu, true); |
d6f1e7ab | 291 | set_hard_smp_processor_id(cpu, be32_to_cpu(*intserv++)); |
413f7c40 ME |
292 | } |
293 | err = 0; | |
294 | out_unlock: | |
86ef5c9a | 295 | cpu_maps_update_done(); |
8729faaa AB |
296 | free_cpumask_var(candidate_mask); |
297 | free_cpumask_var(tmp); | |
413f7c40 ME |
298 | return err; |
299 | } | |
300 | ||
301 | /* | |
302 | * Update the present map for a cpu node which is going away, and set | |
303 | * the hard id in the paca(s) to -1 to be consistent with boot time | |
304 | * convention for non-present cpus. | |
305 | */ | |
06ba30b6 | 306 | static void pseries_remove_processor(struct device_node *np) |
413f7c40 ME |
307 | { |
308 | unsigned int cpu; | |
309 | int len, nthreads, i; | |
e36d1227 TF |
310 | const __be32 *intserv; |
311 | u32 thread; | |
413f7c40 | 312 | |
e2eb6392 | 313 | intserv = of_get_property(np, "ibm,ppc-interrupt-server#s", &len); |
413f7c40 ME |
314 | if (!intserv) |
315 | return; | |
316 | ||
317 | nthreads = len / sizeof(u32); | |
318 | ||
86ef5c9a | 319 | cpu_maps_update_begin(); |
413f7c40 | 320 | for (i = 0; i < nthreads; i++) { |
e36d1227 | 321 | thread = be32_to_cpu(intserv[i]); |
413f7c40 | 322 | for_each_present_cpu(cpu) { |
e36d1227 | 323 | if (get_hard_smp_processor_id(cpu) != thread) |
413f7c40 ME |
324 | continue; |
325 | BUG_ON(cpu_online(cpu)); | |
ea0f1cab | 326 | set_cpu_present(cpu, false); |
413f7c40 | 327 | set_hard_smp_processor_id(cpu, -1); |
1d9a0907 | 328 | update_numa_cpu_lookup_table(cpu, -1); |
413f7c40 ME |
329 | break; |
330 | } | |
8729faaa | 331 | if (cpu >= nr_cpu_ids) |
413f7c40 | 332 | printk(KERN_WARNING "Could not find cpu to remove " |
e36d1227 | 333 | "with physical id 0x%x\n", thread); |
413f7c40 | 334 | } |
86ef5c9a | 335 | cpu_maps_update_done(); |
413f7c40 ME |
336 | } |
337 | ||
183deeea NF |
338 | static int dlpar_online_cpu(struct device_node *dn) |
339 | { | |
340 | int rc = 0; | |
341 | unsigned int cpu; | |
342 | int len, nthreads, i; | |
343 | const __be32 *intserv; | |
344 | u32 thread; | |
345 | ||
346 | intserv = of_get_property(dn, "ibm,ppc-interrupt-server#s", &len); | |
347 | if (!intserv) | |
348 | return -EINVAL; | |
349 | ||
350 | nthreads = len / sizeof(u32); | |
351 | ||
352 | cpu_maps_update_begin(); | |
353 | for (i = 0; i < nthreads; i++) { | |
354 | thread = be32_to_cpu(intserv[i]); | |
355 | for_each_present_cpu(cpu) { | |
356 | if (get_hard_smp_processor_id(cpu) != thread) | |
357 | continue; | |
358 | BUG_ON(get_cpu_current_state(cpu) | |
359 | != CPU_STATE_OFFLINE); | |
360 | cpu_maps_update_done(); | |
cee5405d | 361 | timed_topology_update(1); |
e67e02a5 | 362 | find_and_online_cpu_nid(cpu); |
183deeea NF |
363 | rc = device_online(get_cpu_device(cpu)); |
364 | if (rc) | |
365 | goto out; | |
366 | cpu_maps_update_begin(); | |
367 | ||
368 | break; | |
369 | } | |
370 | if (cpu == num_possible_cpus()) | |
371 | printk(KERN_WARNING "Could not find cpu to online " | |
372 | "with physical id 0x%x\n", thread); | |
373 | } | |
374 | cpu_maps_update_done(); | |
375 | ||
376 | out: | |
377 | return rc; | |
378 | ||
379 | } | |
380 | ||
381 | static bool dlpar_cpu_exists(struct device_node *parent, u32 drc_index) | |
382 | { | |
383 | struct device_node *child = NULL; | |
384 | u32 my_drc_index; | |
385 | bool found; | |
386 | int rc; | |
387 | ||
388 | /* Assume cpu doesn't exist */ | |
389 | found = false; | |
390 | ||
391 | for_each_child_of_node(parent, child) { | |
392 | rc = of_property_read_u32(child, "ibm,my-drc-index", | |
393 | &my_drc_index); | |
394 | if (rc) | |
395 | continue; | |
396 | ||
397 | if (my_drc_index == drc_index) { | |
398 | of_node_put(child); | |
399 | found = true; | |
400 | break; | |
401 | } | |
402 | } | |
403 | ||
404 | return found; | |
405 | } | |
406 | ||
90edf184 NF |
407 | static bool valid_cpu_drc_index(struct device_node *parent, u32 drc_index) |
408 | { | |
409 | bool found = false; | |
410 | int rc, index; | |
411 | ||
412 | index = 0; | |
413 | while (!found) { | |
414 | u32 drc; | |
415 | ||
416 | rc = of_property_read_u32_index(parent, "ibm,drc-indexes", | |
417 | index++, &drc); | |
418 | if (rc) | |
419 | break; | |
420 | ||
421 | if (drc == drc_index) | |
422 | found = true; | |
423 | } | |
424 | ||
425 | return found; | |
426 | } | |
427 | ||
d98389f3 | 428 | static ssize_t dlpar_cpu_add(u32 drc_index) |
183deeea NF |
429 | { |
430 | struct device_node *dn, *parent; | |
e666ae0b NF |
431 | int rc, saved_rc; |
432 | ||
433 | pr_debug("Attempting to add CPU, drc index: %x\n", drc_index); | |
183deeea | 434 | |
183deeea | 435 | parent = of_find_node_by_path("/cpus"); |
e666ae0b NF |
436 | if (!parent) { |
437 | pr_warn("Failed to find CPU root node \"/cpus\"\n"); | |
183deeea | 438 | return -ENODEV; |
e666ae0b | 439 | } |
183deeea NF |
440 | |
441 | if (dlpar_cpu_exists(parent, drc_index)) { | |
442 | of_node_put(parent); | |
e666ae0b | 443 | pr_warn("CPU with drc index %x already exists\n", drc_index); |
183deeea NF |
444 | return -EINVAL; |
445 | } | |
446 | ||
90edf184 NF |
447 | if (!valid_cpu_drc_index(parent, drc_index)) { |
448 | of_node_put(parent); | |
449 | pr_warn("Cannot find CPU (drc index %x) to add.\n", drc_index); | |
450 | return -EINVAL; | |
451 | } | |
452 | ||
183deeea NF |
453 | rc = dlpar_acquire_drc(drc_index); |
454 | if (rc) { | |
e666ae0b NF |
455 | pr_warn("Failed to acquire DRC, rc: %d, drc index: %x\n", |
456 | rc, drc_index); | |
183deeea NF |
457 | of_node_put(parent); |
458 | return -EINVAL; | |
459 | } | |
460 | ||
461 | dn = dlpar_configure_connector(cpu_to_be32(drc_index), parent); | |
e666ae0b NF |
462 | if (!dn) { |
463 | pr_warn("Failed call to configure-connector, drc index: %x\n", | |
464 | drc_index); | |
465 | dlpar_release_drc(drc_index); | |
087ff6a5 | 466 | of_node_put(parent); |
183deeea | 467 | return -EINVAL; |
e666ae0b | 468 | } |
183deeea | 469 | |
215ee763 | 470 | rc = dlpar_attach_node(dn, parent); |
087ff6a5 TD |
471 | |
472 | /* Regardless we are done with parent now */ | |
473 | of_node_put(parent); | |
474 | ||
183deeea | 475 | if (rc) { |
e666ae0b | 476 | saved_rc = rc; |
b9ef7b4b RH |
477 | pr_warn("Failed to attach node %pOFn, rc: %d, drc index: %x\n", |
478 | dn, rc, drc_index); | |
e666ae0b NF |
479 | |
480 | rc = dlpar_release_drc(drc_index); | |
481 | if (!rc) | |
482 | dlpar_free_cc_nodes(dn); | |
483 | ||
484 | return saved_rc; | |
183deeea NF |
485 | } |
486 | ||
487 | rc = dlpar_online_cpu(dn); | |
e666ae0b NF |
488 | if (rc) { |
489 | saved_rc = rc; | |
b9ef7b4b RH |
490 | pr_warn("Failed to online cpu %pOFn, rc: %d, drc index: %x\n", |
491 | dn, rc, drc_index); | |
e666ae0b NF |
492 | |
493 | rc = dlpar_detach_node(dn); | |
494 | if (!rc) | |
495 | dlpar_release_drc(drc_index); | |
496 | ||
497 | return saved_rc; | |
498 | } | |
499 | ||
b9ef7b4b | 500 | pr_debug("Successfully added CPU %pOFn, drc index: %x\n", dn, |
e666ae0b | 501 | drc_index); |
d98389f3 | 502 | return rc; |
183deeea NF |
503 | } |
504 | ||
505 | static int dlpar_offline_cpu(struct device_node *dn) | |
506 | { | |
507 | int rc = 0; | |
508 | unsigned int cpu; | |
509 | int len, nthreads, i; | |
510 | const __be32 *intserv; | |
511 | u32 thread; | |
512 | ||
513 | intserv = of_get_property(dn, "ibm,ppc-interrupt-server#s", &len); | |
514 | if (!intserv) | |
515 | return -EINVAL; | |
516 | ||
517 | nthreads = len / sizeof(u32); | |
518 | ||
519 | cpu_maps_update_begin(); | |
520 | for (i = 0; i < nthreads; i++) { | |
521 | thread = be32_to_cpu(intserv[i]); | |
522 | for_each_present_cpu(cpu) { | |
523 | if (get_hard_smp_processor_id(cpu) != thread) | |
524 | continue; | |
525 | ||
526 | if (get_cpu_current_state(cpu) == CPU_STATE_OFFLINE) | |
527 | break; | |
528 | ||
529 | if (get_cpu_current_state(cpu) == CPU_STATE_ONLINE) { | |
530 | set_preferred_offline_state(cpu, | |
531 | CPU_STATE_OFFLINE); | |
532 | cpu_maps_update_done(); | |
cee5405d | 533 | timed_topology_update(1); |
183deeea NF |
534 | rc = device_offline(get_cpu_device(cpu)); |
535 | if (rc) | |
536 | goto out; | |
537 | cpu_maps_update_begin(); | |
538 | break; | |
539 | ||
540 | } | |
541 | ||
542 | /* | |
543 | * The cpu is in CPU_STATE_INACTIVE. | |
544 | * Upgrade it's state to CPU_STATE_OFFLINE. | |
545 | */ | |
546 | set_preferred_offline_state(cpu, CPU_STATE_OFFLINE); | |
547 | BUG_ON(plpar_hcall_norets(H_PROD, thread) | |
548 | != H_SUCCESS); | |
549 | __cpu_die(cpu); | |
550 | break; | |
551 | } | |
552 | if (cpu == num_possible_cpus()) | |
553 | printk(KERN_WARNING "Could not find cpu to offline with physical id 0x%x\n", thread); | |
554 | } | |
555 | cpu_maps_update_done(); | |
556 | ||
557 | out: | |
558 | return rc; | |
559 | ||
560 | } | |
561 | ||
d98389f3 NF |
562 | static ssize_t dlpar_cpu_remove(struct device_node *dn, u32 drc_index) |
563 | { | |
564 | int rc; | |
565 | ||
b9ef7b4b RH |
566 | pr_debug("Attempting to remove CPU %pOFn, drc index: %x\n", |
567 | dn, drc_index); | |
e666ae0b | 568 | |
d98389f3 | 569 | rc = dlpar_offline_cpu(dn); |
e666ae0b | 570 | if (rc) { |
b9ef7b4b | 571 | pr_warn("Failed to offline CPU %pOFn, rc: %d\n", dn, rc); |
d98389f3 | 572 | return -EINVAL; |
e666ae0b | 573 | } |
d98389f3 NF |
574 | |
575 | rc = dlpar_release_drc(drc_index); | |
e666ae0b | 576 | if (rc) { |
b9ef7b4b RH |
577 | pr_warn("Failed to release drc (%x) for CPU %pOFn, rc: %d\n", |
578 | drc_index, dn, rc); | |
e666ae0b | 579 | dlpar_online_cpu(dn); |
d98389f3 | 580 | return rc; |
e666ae0b | 581 | } |
d98389f3 NF |
582 | |
583 | rc = dlpar_detach_node(dn); | |
e666ae0b NF |
584 | if (rc) { |
585 | int saved_rc = rc; | |
d98389f3 | 586 | |
b9ef7b4b | 587 | pr_warn("Failed to detach CPU %pOFn, rc: %d", dn, rc); |
e666ae0b NF |
588 | |
589 | rc = dlpar_acquire_drc(drc_index); | |
590 | if (!rc) | |
591 | dlpar_online_cpu(dn); | |
592 | ||
593 | return saved_rc; | |
594 | } | |
595 | ||
596 | pr_debug("Successfully removed CPU, drc index: %x\n", drc_index); | |
597 | return 0; | |
d98389f3 NF |
598 | } |
599 | ||
ac713800 NF |
600 | static struct device_node *cpu_drc_index_to_dn(u32 drc_index) |
601 | { | |
602 | struct device_node *dn; | |
603 | u32 my_index; | |
604 | int rc; | |
605 | ||
606 | for_each_node_by_type(dn, "cpu") { | |
607 | rc = of_property_read_u32(dn, "ibm,my-drc-index", &my_index); | |
608 | if (rc) | |
609 | continue; | |
610 | ||
611 | if (my_index == drc_index) | |
612 | break; | |
613 | } | |
614 | ||
615 | return dn; | |
616 | } | |
617 | ||
618 | static int dlpar_cpu_remove_by_index(u32 drc_index) | |
619 | { | |
620 | struct device_node *dn; | |
621 | int rc; | |
622 | ||
623 | dn = cpu_drc_index_to_dn(drc_index); | |
624 | if (!dn) { | |
625 | pr_warn("Cannot find CPU (drc index %x) to remove\n", | |
626 | drc_index); | |
627 | return -ENODEV; | |
628 | } | |
629 | ||
630 | rc = dlpar_cpu_remove(dn, drc_index); | |
631 | of_node_put(dn); | |
632 | return rc; | |
633 | } | |
634 | ||
635 | static int find_dlpar_cpus_to_remove(u32 *cpu_drcs, int cpus_to_remove) | |
636 | { | |
637 | struct device_node *dn; | |
638 | int cpus_found = 0; | |
639 | int rc; | |
640 | ||
641 | /* We want to find cpus_to_remove + 1 CPUs to ensure we do not | |
642 | * remove the last CPU. | |
643 | */ | |
644 | for_each_node_by_type(dn, "cpu") { | |
645 | cpus_found++; | |
646 | ||
647 | if (cpus_found > cpus_to_remove) { | |
648 | of_node_put(dn); | |
649 | break; | |
650 | } | |
651 | ||
652 | /* Note that cpus_found is always 1 ahead of the index | |
653 | * into the cpu_drcs array, so we use cpus_found - 1 | |
654 | */ | |
655 | rc = of_property_read_u32(dn, "ibm,my-drc-index", | |
656 | &cpu_drcs[cpus_found - 1]); | |
657 | if (rc) { | |
b9ef7b4b RH |
658 | pr_warn("Error occurred getting drc-index for %pOFn\n", |
659 | dn); | |
ac713800 NF |
660 | of_node_put(dn); |
661 | return -1; | |
662 | } | |
663 | } | |
664 | ||
665 | if (cpus_found < cpus_to_remove) { | |
666 | pr_warn("Failed to find enough CPUs (%d of %d) to remove\n", | |
667 | cpus_found, cpus_to_remove); | |
668 | } else if (cpus_found == cpus_to_remove) { | |
669 | pr_warn("Cannot remove all CPUs\n"); | |
670 | } | |
671 | ||
672 | return cpus_found; | |
673 | } | |
674 | ||
675 | static int dlpar_cpu_remove_by_count(u32 cpus_to_remove) | |
676 | { | |
677 | u32 *cpu_drcs; | |
678 | int cpus_found; | |
679 | int cpus_removed = 0; | |
680 | int i, rc; | |
681 | ||
682 | pr_debug("Attempting to hot-remove %d CPUs\n", cpus_to_remove); | |
683 | ||
684 | cpu_drcs = kcalloc(cpus_to_remove, sizeof(*cpu_drcs), GFP_KERNEL); | |
685 | if (!cpu_drcs) | |
686 | return -EINVAL; | |
687 | ||
688 | cpus_found = find_dlpar_cpus_to_remove(cpu_drcs, cpus_to_remove); | |
689 | if (cpus_found <= cpus_to_remove) { | |
690 | kfree(cpu_drcs); | |
691 | return -EINVAL; | |
692 | } | |
693 | ||
694 | for (i = 0; i < cpus_to_remove; i++) { | |
695 | rc = dlpar_cpu_remove_by_index(cpu_drcs[i]); | |
696 | if (rc) | |
697 | break; | |
698 | ||
699 | cpus_removed++; | |
700 | } | |
701 | ||
702 | if (cpus_removed != cpus_to_remove) { | |
703 | pr_warn("CPU hot-remove failed, adding back removed CPUs\n"); | |
704 | ||
705 | for (i = 0; i < cpus_removed; i++) | |
706 | dlpar_cpu_add(cpu_drcs[i]); | |
707 | ||
708 | rc = -EINVAL; | |
709 | } else { | |
710 | rc = 0; | |
711 | } | |
712 | ||
713 | kfree(cpu_drcs); | |
714 | return rc; | |
715 | } | |
716 | ||
90edf184 NF |
717 | static int find_dlpar_cpus_to_add(u32 *cpu_drcs, u32 cpus_to_add) |
718 | { | |
719 | struct device_node *parent; | |
720 | int cpus_found = 0; | |
721 | int index, rc; | |
722 | ||
723 | parent = of_find_node_by_path("/cpus"); | |
724 | if (!parent) { | |
725 | pr_warn("Could not find CPU root node in device tree\n"); | |
726 | kfree(cpu_drcs); | |
727 | return -1; | |
728 | } | |
729 | ||
730 | /* Search the ibm,drc-indexes array for possible CPU drcs to | |
731 | * add. Note that the format of the ibm,drc-indexes array is | |
732 | * the number of entries in the array followed by the array | |
733 | * of drc values so we start looking at index = 1. | |
734 | */ | |
735 | index = 1; | |
736 | while (cpus_found < cpus_to_add) { | |
737 | u32 drc; | |
738 | ||
739 | rc = of_property_read_u32_index(parent, "ibm,drc-indexes", | |
740 | index++, &drc); | |
741 | if (rc) | |
742 | break; | |
743 | ||
744 | if (dlpar_cpu_exists(parent, drc)) | |
745 | continue; | |
746 | ||
747 | cpu_drcs[cpus_found++] = drc; | |
748 | } | |
749 | ||
750 | of_node_put(parent); | |
751 | return cpus_found; | |
752 | } | |
753 | ||
754 | static int dlpar_cpu_add_by_count(u32 cpus_to_add) | |
755 | { | |
756 | u32 *cpu_drcs; | |
757 | int cpus_added = 0; | |
758 | int cpus_found; | |
759 | int i, rc; | |
760 | ||
761 | pr_debug("Attempting to hot-add %d CPUs\n", cpus_to_add); | |
762 | ||
763 | cpu_drcs = kcalloc(cpus_to_add, sizeof(*cpu_drcs), GFP_KERNEL); | |
764 | if (!cpu_drcs) | |
765 | return -EINVAL; | |
766 | ||
767 | cpus_found = find_dlpar_cpus_to_add(cpu_drcs, cpus_to_add); | |
768 | if (cpus_found < cpus_to_add) { | |
769 | pr_warn("Failed to find enough CPUs (%d of %d) to add\n", | |
770 | cpus_found, cpus_to_add); | |
771 | kfree(cpu_drcs); | |
772 | return -EINVAL; | |
773 | } | |
774 | ||
775 | for (i = 0; i < cpus_to_add; i++) { | |
776 | rc = dlpar_cpu_add(cpu_drcs[i]); | |
777 | if (rc) | |
778 | break; | |
779 | ||
780 | cpus_added++; | |
781 | } | |
782 | ||
783 | if (cpus_added < cpus_to_add) { | |
784 | pr_warn("CPU hot-add failed, removing any added CPUs\n"); | |
785 | ||
786 | for (i = 0; i < cpus_added; i++) | |
787 | dlpar_cpu_remove_by_index(cpu_drcs[i]); | |
788 | ||
789 | rc = -EINVAL; | |
790 | } else { | |
791 | rc = 0; | |
792 | } | |
793 | ||
794 | kfree(cpu_drcs); | |
795 | return rc; | |
796 | } | |
797 | ||
81b61324 NF |
798 | int dlpar_cpu_readd(int cpu) |
799 | { | |
800 | struct device_node *dn; | |
801 | struct device *dev; | |
802 | u32 drc_index; | |
803 | int rc; | |
804 | ||
805 | dev = get_cpu_device(cpu); | |
806 | dn = dev->of_node; | |
807 | ||
808 | rc = of_property_read_u32(dn, "ibm,my-drc-index", &drc_index); | |
809 | ||
810 | rc = dlpar_cpu_remove_by_index(drc_index); | |
811 | if (!rc) | |
812 | rc = dlpar_cpu_add(drc_index); | |
813 | ||
814 | return rc; | |
815 | } | |
816 | ||
ac713800 NF |
817 | int dlpar_cpu(struct pseries_hp_errorlog *hp_elog) |
818 | { | |
819 | u32 count, drc_index; | |
820 | int rc; | |
821 | ||
822 | count = hp_elog->_drc_u.drc_count; | |
823 | drc_index = hp_elog->_drc_u.drc_index; | |
824 | ||
825 | lock_device_hotplug(); | |
826 | ||
827 | switch (hp_elog->action) { | |
828 | case PSERIES_HP_ELOG_ACTION_REMOVE: | |
829 | if (hp_elog->id_type == PSERIES_HP_ELOG_ID_DRC_COUNT) | |
830 | rc = dlpar_cpu_remove_by_count(count); | |
831 | else if (hp_elog->id_type == PSERIES_HP_ELOG_ID_DRC_INDEX) | |
832 | rc = dlpar_cpu_remove_by_index(drc_index); | |
833 | else | |
834 | rc = -EINVAL; | |
835 | break; | |
90edf184 NF |
836 | case PSERIES_HP_ELOG_ACTION_ADD: |
837 | if (hp_elog->id_type == PSERIES_HP_ELOG_ID_DRC_COUNT) | |
838 | rc = dlpar_cpu_add_by_count(count); | |
839 | else if (hp_elog->id_type == PSERIES_HP_ELOG_ID_DRC_INDEX) | |
840 | rc = dlpar_cpu_add(drc_index); | |
841 | else | |
842 | rc = -EINVAL; | |
843 | break; | |
ac713800 NF |
844 | default: |
845 | pr_err("Invalid action (%d) specified\n", hp_elog->action); | |
846 | rc = -EINVAL; | |
847 | break; | |
848 | } | |
849 | ||
850 | unlock_device_hotplug(); | |
851 | return rc; | |
852 | } | |
853 | ||
d98389f3 NF |
854 | #ifdef CONFIG_ARCH_CPU_PROBE_RELEASE |
855 | ||
856 | static ssize_t dlpar_cpu_probe(const char *buf, size_t count) | |
857 | { | |
858 | u32 drc_index; | |
859 | int rc; | |
860 | ||
861 | rc = kstrtou32(buf, 0, &drc_index); | |
862 | if (rc) | |
863 | return -EINVAL; | |
864 | ||
865 | rc = dlpar_cpu_add(drc_index); | |
866 | ||
867 | return rc ? rc : count; | |
868 | } | |
869 | ||
183deeea NF |
870 | static ssize_t dlpar_cpu_release(const char *buf, size_t count) |
871 | { | |
872 | struct device_node *dn; | |
873 | u32 drc_index; | |
874 | int rc; | |
875 | ||
876 | dn = of_find_node_by_path(buf); | |
877 | if (!dn) | |
878 | return -EINVAL; | |
879 | ||
880 | rc = of_property_read_u32(dn, "ibm,my-drc-index", &drc_index); | |
881 | if (rc) { | |
882 | of_node_put(dn); | |
883 | return -EINVAL; | |
884 | } | |
885 | ||
d98389f3 | 886 | rc = dlpar_cpu_remove(dn, drc_index); |
183deeea NF |
887 | of_node_put(dn); |
888 | ||
d98389f3 | 889 | return rc ? rc : count; |
183deeea NF |
890 | } |
891 | ||
892 | #endif /* CONFIG_ARCH_CPU_PROBE_RELEASE */ | |
893 | ||
06ba30b6 | 894 | static int pseries_smp_notifier(struct notifier_block *nb, |
f5242e5a | 895 | unsigned long action, void *data) |
413f7c40 | 896 | { |
f5242e5a | 897 | struct of_reconfig_data *rd = data; |
de2780a3 | 898 | int err = 0; |
413f7c40 ME |
899 | |
900 | switch (action) { | |
1cf3d8b3 | 901 | case OF_RECONFIG_ATTACH_NODE: |
f5242e5a | 902 | err = pseries_add_processor(rd->dn); |
413f7c40 | 903 | break; |
1cf3d8b3 | 904 | case OF_RECONFIG_DETACH_NODE: |
f5242e5a | 905 | pseries_remove_processor(rd->dn); |
413f7c40 | 906 | break; |
413f7c40 | 907 | } |
de2780a3 | 908 | return notifier_from_errno(err); |
413f7c40 ME |
909 | } |
910 | ||
06ba30b6 ME |
911 | static struct notifier_block pseries_smp_nb = { |
912 | .notifier_call = pseries_smp_notifier, | |
413f7c40 ME |
913 | }; |
914 | ||
3aa565f5 GS |
915 | #define MAX_CEDE_LATENCY_LEVELS 4 |
916 | #define CEDE_LATENCY_PARAM_LENGTH 10 | |
917 | #define CEDE_LATENCY_PARAM_MAX_LENGTH \ | |
918 | (MAX_CEDE_LATENCY_LEVELS * CEDE_LATENCY_PARAM_LENGTH * sizeof(char)) | |
919 | #define CEDE_LATENCY_TOKEN 45 | |
920 | ||
921 | static char cede_parameters[CEDE_LATENCY_PARAM_MAX_LENGTH]; | |
922 | ||
923 | static int parse_cede_parameters(void) | |
924 | { | |
3aa565f5 | 925 | memset(cede_parameters, 0, CEDE_LATENCY_PARAM_MAX_LENGTH); |
20a8ab97 AB |
926 | return rtas_call(rtas_token("ibm,get-system-parameter"), 3, 1, |
927 | NULL, | |
928 | CEDE_LATENCY_TOKEN, | |
929 | __pa(cede_parameters), | |
930 | CEDE_LATENCY_PARAM_MAX_LENGTH); | |
3aa565f5 GS |
931 | } |
932 | ||
0332c2d4 ME |
933 | static int __init pseries_cpu_hotplug_init(void) |
934 | { | |
3aa565f5 | 935 | int cpu; |
f8b67691 | 936 | int qcss_tok; |
64f27585 | 937 | |
183deeea NF |
938 | #ifdef CONFIG_ARCH_CPU_PROBE_RELEASE |
939 | ppc_md.cpu_probe = dlpar_cpu_probe; | |
940 | ppc_md.cpu_release = dlpar_cpu_release; | |
941 | #endif /* CONFIG_ARCH_CPU_PROBE_RELEASE */ | |
942 | ||
41dd03a9 | 943 | rtas_stop_self_token = rtas_token("stop-self"); |
674fa677 | 944 | qcss_tok = rtas_token("query-cpu-stopped-state"); |
0332c2d4 | 945 | |
41dd03a9 | 946 | if (rtas_stop_self_token == RTAS_UNKNOWN_SERVICE || |
674fa677 ME |
947 | qcss_tok == RTAS_UNKNOWN_SERVICE) { |
948 | printk(KERN_INFO "CPU Hotplug not supported by firmware " | |
949 | "- disabling.\n"); | |
950 | return 0; | |
951 | } | |
04da6af9 | 952 | |
06ba30b6 ME |
953 | ppc_md.cpu_die = pseries_mach_cpu_die; |
954 | smp_ops->cpu_disable = pseries_cpu_disable; | |
955 | smp_ops->cpu_die = pseries_cpu_die; | |
413f7c40 ME |
956 | |
957 | /* Processors can be added/removed only on LPAR */ | |
3aa565f5 | 958 | if (firmware_has_feature(FW_FEATURE_LPAR)) { |
1cf3d8b3 | 959 | of_reconfig_notifier_register(&pseries_smp_nb); |
3aa565f5 GS |
960 | cpu_maps_update_begin(); |
961 | if (cede_offline_enabled && parse_cede_parameters() == 0) { | |
962 | default_offline_state = CPU_STATE_INACTIVE; | |
963 | for_each_online_cpu(cpu) | |
964 | set_default_offline_state(cpu); | |
965 | } | |
966 | cpu_maps_update_done(); | |
967 | } | |
413f7c40 | 968 | |
0332c2d4 ME |
969 | return 0; |
970 | } | |
d2a36071 | 971 | machine_arch_initcall(pseries, pseries_cpu_hotplug_init); |