1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21#include <linux/kernel.h>
22#include <linux/interrupt.h>
23#include <linux/delay.h>
24#include <linux/sched.h>
25#include <linux/cpu.h>
26#include <linux/of.h>
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>
32#include <asm/xics.h>
33#include <asm/plpar_wrappers.h>
34
35#include "offline_states.h"
36
37
38static struct rtas_args rtas_stop_self_args = {
39 .token = RTAS_UNKNOWN_SERVICE,
40 .nargs = 0,
41 .nret = 1,
42 .rets = &rtas_stop_self_args.args[0],
43};
44
45static DEFINE_PER_CPU(enum cpu_state_vals, preferred_offline_state) =
46 CPU_STATE_OFFLINE;
47static DEFINE_PER_CPU(enum cpu_state_vals, current_state) = CPU_STATE_OFFLINE;
48
49static enum cpu_state_vals default_offline_state = CPU_STATE_OFFLINE;
50
51static int cede_offline_enabled __read_mostly = 1;
52
53
54
55
56static int __init setup_cede_offline(char *str)
57{
58 if (!strcmp(str, "off"))
59 cede_offline_enabled = 0;
60 else if (!strcmp(str, "on"))
61 cede_offline_enabled = 1;
62 else
63 return 0;
64 return 1;
65}
66
67__setup("cede_offline=", setup_cede_offline);
68
69enum cpu_state_vals get_cpu_current_state(int cpu)
70{
71 return per_cpu(current_state, cpu);
72}
73
74void set_cpu_current_state(int cpu, enum cpu_state_vals state)
75{
76 per_cpu(current_state, cpu) = state;
77}
78
79enum cpu_state_vals get_preferred_offline_state(int cpu)
80{
81 return per_cpu(preferred_offline_state, cpu);
82}
83
84void set_preferred_offline_state(int cpu, enum cpu_state_vals state)
85{
86 per_cpu(preferred_offline_state, cpu) = state;
87}
88
89void set_default_offline_state(int cpu)
90{
91 per_cpu(preferred_offline_state, cpu) = default_offline_state;
92}
93
94static void rtas_stop_self(void)
95{
96 struct rtas_args *args = &rtas_stop_self_args;
97
98 local_irq_disable();
99
100 BUG_ON(args->token == RTAS_UNKNOWN_SERVICE);
101
102 printk("cpu %u (hwid %u) Ready to die...\n",
103 smp_processor_id(), hard_smp_processor_id());
104 enter_rtas(__pa(args));
105
106 panic("Alas, I survived.\n");
107}
108
109static void pseries_mach_cpu_die(void)
110{
111 unsigned int cpu = smp_processor_id();
112 unsigned int hwcpu = hard_smp_processor_id();
113 u8 cede_latency_hint = 0;
114
115 local_irq_disable();
116 idle_task_exit();
117 xics_teardown_cpu();
118
119 if (get_preferred_offline_state(cpu) == CPU_STATE_INACTIVE) {
120 set_cpu_current_state(cpu, CPU_STATE_INACTIVE);
121 if (ppc_md.suspend_disable_cpu)
122 ppc_md.suspend_disable_cpu();
123
124 cede_latency_hint = 2;
125
126 get_lppaca()->idle = 1;
127 if (!lppaca_shared_proc(get_lppaca()))
128 get_lppaca()->donate_dedicated_cpu = 1;
129
130 while (get_preferred_offline_state(cpu) == CPU_STATE_INACTIVE) {
131 while (!prep_irq_for_idle()) {
132 local_irq_enable();
133 local_irq_disable();
134 }
135
136 extended_cede_processor(cede_latency_hint);
137 }
138
139 local_irq_disable();
140
141 if (!lppaca_shared_proc(get_lppaca()))
142 get_lppaca()->donate_dedicated_cpu = 0;
143 get_lppaca()->idle = 0;
144
145 if (get_preferred_offline_state(cpu) == CPU_STATE_ONLINE) {
146 unregister_slb_shadow(hwcpu);
147
148 hard_irq_disable();
149
150
151
152
153
154 start_secondary_resume();
155 }
156 }
157
158
159 WARN_ON(get_preferred_offline_state(cpu) != CPU_STATE_OFFLINE);
160
161 set_cpu_current_state(cpu, CPU_STATE_OFFLINE);
162 unregister_slb_shadow(hwcpu);
163 rtas_stop_self();
164
165
166 BUG();
167 for(;;);
168}
169
170static int pseries_cpu_disable(void)
171{
172 int cpu = smp_processor_id();
173
174 set_cpu_online(cpu, false);
175 vdso_data->processorCount--;
176
177
178 if (cpu == boot_cpuid)
179 boot_cpuid = cpumask_any(cpu_online_mask);
180
181
182 xics_migrate_irqs_away();
183 return 0;
184}
185
186
187
188
189
190
191
192
193
194
195
196
197
198static void pseries_cpu_die(unsigned int cpu)
199{
200 int tries;
201 int cpu_status = 1;
202 unsigned int pcpu = get_hard_smp_processor_id(cpu);
203
204 if (get_preferred_offline_state(cpu) == CPU_STATE_INACTIVE) {
205 cpu_status = 1;
206 for (tries = 0; tries < 5000; tries++) {
207 if (get_cpu_current_state(cpu) == CPU_STATE_INACTIVE) {
208 cpu_status = 0;
209 break;
210 }
211 msleep(1);
212 }
213 } else if (get_preferred_offline_state(cpu) == CPU_STATE_OFFLINE) {
214
215 for (tries = 0; tries < 25; tries++) {
216 cpu_status = smp_query_cpu_stopped(pcpu);
217 if (cpu_status == QCSS_STOPPED ||
218 cpu_status == QCSS_HARDWARE_ERROR)
219 break;
220 cpu_relax();
221 }
222 }
223
224 if (cpu_status != 0) {
225 printk("Querying DEAD? cpu %i (%i) shows %i\n",
226 cpu, pcpu, cpu_status);
227 }
228
229
230
231
232
233
234 paca[cpu].cpu_start = 0;
235}
236
237
238
239
240
241
242
243
244static int pseries_add_processor(struct device_node *np)
245{
246 unsigned int cpu;
247 cpumask_var_t candidate_mask, tmp;
248 int err = -ENOSPC, len, nthreads, i;
249 const u32 *intserv;
250
251 intserv = of_get_property(np, "ibm,ppc-interrupt-server#s", &len);
252 if (!intserv)
253 return 0;
254
255 zalloc_cpumask_var(&candidate_mask, GFP_KERNEL);
256 zalloc_cpumask_var(&tmp, GFP_KERNEL);
257
258 nthreads = len / sizeof(u32);
259 for (i = 0; i < nthreads; i++)
260 cpumask_set_cpu(i, tmp);
261
262 cpu_maps_update_begin();
263
264 BUG_ON(!cpumask_subset(cpu_present_mask, cpu_possible_mask));
265
266
267 cpumask_xor(candidate_mask, cpu_possible_mask, cpu_present_mask);
268 if (cpumask_empty(candidate_mask)) {
269
270
271
272 printk(KERN_ERR "Cannot add cpu %s; this system configuration"
273 " supports %d logical cpus.\n", np->full_name,
274 cpumask_weight(cpu_possible_mask));
275 goto out_unlock;
276 }
277
278 while (!cpumask_empty(tmp))
279 if (cpumask_subset(tmp, candidate_mask))
280
281 break;
282 else
283 cpumask_shift_left(tmp, tmp, nthreads);
284
285 if (cpumask_empty(tmp)) {
286 printk(KERN_ERR "Unable to find space in cpu_present_mask for"
287 " processor %s with %d thread(s)\n", np->name,
288 nthreads);
289 goto out_unlock;
290 }
291
292 for_each_cpu(cpu, tmp) {
293 BUG_ON(cpu_present(cpu));
294 set_cpu_present(cpu, true);
295 set_hard_smp_processor_id(cpu, *intserv++);
296 }
297 err = 0;
298out_unlock:
299 cpu_maps_update_done();
300 free_cpumask_var(candidate_mask);
301 free_cpumask_var(tmp);
302 return err;
303}
304
305
306
307
308
309
310static void pseries_remove_processor(struct device_node *np)
311{
312 unsigned int cpu;
313 int len, nthreads, i;
314 const u32 *intserv;
315
316 intserv = of_get_property(np, "ibm,ppc-interrupt-server#s", &len);
317 if (!intserv)
318 return;
319
320 nthreads = len / sizeof(u32);
321
322 cpu_maps_update_begin();
323 for (i = 0; i < nthreads; i++) {
324 for_each_present_cpu(cpu) {
325 if (get_hard_smp_processor_id(cpu) != intserv[i])
326 continue;
327 BUG_ON(cpu_online(cpu));
328 set_cpu_present(cpu, false);
329 set_hard_smp_processor_id(cpu, -1);
330 break;
331 }
332 if (cpu >= nr_cpu_ids)
333 printk(KERN_WARNING "Could not find cpu to remove "
334 "with physical id 0x%x\n", intserv[i]);
335 }
336 cpu_maps_update_done();
337}
338
339static int pseries_smp_notifier(struct notifier_block *nb,
340 unsigned long action, void *node)
341{
342 int err = 0;
343
344 switch (action) {
345 case OF_RECONFIG_ATTACH_NODE:
346 err = pseries_add_processor(node);
347 break;
348 case OF_RECONFIG_DETACH_NODE:
349 pseries_remove_processor(node);
350 break;
351 }
352 return notifier_from_errno(err);
353}
354
355static struct notifier_block pseries_smp_nb = {
356 .notifier_call = pseries_smp_notifier,
357};
358
359#define MAX_CEDE_LATENCY_LEVELS 4
360#define CEDE_LATENCY_PARAM_LENGTH 10
361#define CEDE_LATENCY_PARAM_MAX_LENGTH \
362 (MAX_CEDE_LATENCY_LEVELS * CEDE_LATENCY_PARAM_LENGTH * sizeof(char))
363#define CEDE_LATENCY_TOKEN 45
364
365static char cede_parameters[CEDE_LATENCY_PARAM_MAX_LENGTH];
366
367static int parse_cede_parameters(void)
368{
369 memset(cede_parameters, 0, CEDE_LATENCY_PARAM_MAX_LENGTH);
370 return rtas_call(rtas_token("ibm,get-system-parameter"), 3, 1,
371 NULL,
372 CEDE_LATENCY_TOKEN,
373 __pa(cede_parameters),
374 CEDE_LATENCY_PARAM_MAX_LENGTH);
375}
376
377static int __init pseries_cpu_hotplug_init(void)
378{
379 struct device_node *np;
380 const char *typep;
381 int cpu;
382 int qcss_tok;
383
384 for_each_node_by_name(np, "interrupt-controller") {
385 typep = of_get_property(np, "compatible", NULL);
386 if (strstr(typep, "open-pic")) {
387 of_node_put(np);
388
389 printk(KERN_INFO "CPU Hotplug not supported on "
390 "systems using MPIC\n");
391 return 0;
392 }
393 }
394
395 rtas_stop_self_args.token = rtas_token("stop-self");
396 qcss_tok = rtas_token("query-cpu-stopped-state");
397
398 if (rtas_stop_self_args.token == RTAS_UNKNOWN_SERVICE ||
399 qcss_tok == RTAS_UNKNOWN_SERVICE) {
400 printk(KERN_INFO "CPU Hotplug not supported by firmware "
401 "- disabling.\n");
402 return 0;
403 }
404
405 ppc_md.cpu_die = pseries_mach_cpu_die;
406 smp_ops->cpu_disable = pseries_cpu_disable;
407 smp_ops->cpu_die = pseries_cpu_die;
408
409
410 if (firmware_has_feature(FW_FEATURE_LPAR)) {
411 of_reconfig_notifier_register(&pseries_smp_nb);
412 cpu_maps_update_begin();
413 if (cede_offline_enabled && parse_cede_parameters() == 0) {
414 default_offline_state = CPU_STATE_INACTIVE;
415 for_each_online_cpu(cpu)
416 set_default_offline_state(cpu);
417 }
418 cpu_maps_update_done();
419 }
420
421 return 0;
422}
423arch_initcall(pseries_cpu_hotplug_init);
424