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