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