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 <asm/prom.h>
27#include <asm/rtas.h>
28#include <asm/firmware.h>
29#include <asm/machdep.h>
30#include <asm/vdso_datapage.h>
31#include <asm/pSeries_reconfig.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 extended_cede_processor(cede_latency_hint);
131 }
132
133 if (!get_lppaca()->shared_proc)
134 get_lppaca()->donate_dedicated_cpu = 0;
135 get_lppaca()->idle = 0;
136
137 if (get_preferred_offline_state(cpu) == CPU_STATE_ONLINE) {
138 unregister_slb_shadow(hwcpu);
139
140
141
142
143
144
145 start_secondary_resume();
146 }
147 }
148
149
150 WARN_ON(get_preferred_offline_state(cpu) != CPU_STATE_OFFLINE);
151
152 set_cpu_current_state(cpu, CPU_STATE_OFFLINE);
153 unregister_slb_shadow(hwcpu);
154 rtas_stop_self();
155
156
157 BUG();
158 for(;;);
159}
160
161static int pseries_cpu_disable(void)
162{
163 int cpu = smp_processor_id();
164
165 set_cpu_online(cpu, false);
166 vdso_data->processorCount--;
167
168
169 if (cpu == boot_cpuid)
170 boot_cpuid = cpumask_any(cpu_online_mask);
171
172
173 xics_migrate_irqs_away();
174 return 0;
175}
176
177
178
179
180
181
182
183
184
185
186
187
188
189static void pseries_cpu_die(unsigned int cpu)
190{
191 int tries;
192 int cpu_status = 1;
193 unsigned int pcpu = get_hard_smp_processor_id(cpu);
194
195 if (get_preferred_offline_state(cpu) == CPU_STATE_INACTIVE) {
196 cpu_status = 1;
197 for (tries = 0; tries < 5000; tries++) {
198 if (get_cpu_current_state(cpu) == CPU_STATE_INACTIVE) {
199 cpu_status = 0;
200 break;
201 }
202 msleep(1);
203 }
204 } else if (get_preferred_offline_state(cpu) == CPU_STATE_OFFLINE) {
205
206 for (tries = 0; tries < 25; tries++) {
207 cpu_status = smp_query_cpu_stopped(pcpu);
208 if (cpu_status == QCSS_STOPPED ||
209 cpu_status == QCSS_HARDWARE_ERROR)
210 break;
211 cpu_relax();
212 }
213 }
214
215 if (cpu_status != 0) {
216 printk("Querying DEAD? cpu %i (%i) shows %i\n",
217 cpu, pcpu, cpu_status);
218 }
219
220
221
222
223
224
225 paca[cpu].cpu_start = 0;
226}
227
228
229
230
231
232
233
234
235static int pseries_add_processor(struct device_node *np)
236{
237 unsigned int cpu;
238 cpumask_var_t candidate_mask, tmp;
239 int err = -ENOSPC, len, nthreads, i;
240 const u32 *intserv;
241
242 intserv = of_get_property(np, "ibm,ppc-interrupt-server#s", &len);
243 if (!intserv)
244 return 0;
245
246 zalloc_cpumask_var(&candidate_mask, GFP_KERNEL);
247 zalloc_cpumask_var(&tmp, GFP_KERNEL);
248
249 nthreads = len / sizeof(u32);
250 for (i = 0; i < nthreads; i++)
251 cpumask_set_cpu(i, tmp);
252
253 cpu_maps_update_begin();
254
255 BUG_ON(!cpumask_subset(cpu_present_mask, cpu_possible_mask));
256
257
258 cpumask_xor(candidate_mask, cpu_possible_mask, cpu_present_mask);
259 if (cpumask_empty(candidate_mask)) {
260
261
262
263 printk(KERN_ERR "Cannot add cpu %s; this system configuration"
264 " supports %d logical cpus.\n", np->full_name,
265 cpumask_weight(cpu_possible_mask));
266 goto out_unlock;
267 }
268
269 while (!cpumask_empty(tmp))
270 if (cpumask_subset(tmp, candidate_mask))
271
272 break;
273 else
274 cpumask_shift_left(tmp, tmp, nthreads);
275
276 if (cpumask_empty(tmp)) {
277 printk(KERN_ERR "Unable to find space in cpu_present_mask for"
278 " processor %s with %d thread(s)\n", np->name,
279 nthreads);
280 goto out_unlock;
281 }
282
283 for_each_cpu(cpu, tmp) {
284 BUG_ON(cpu_present(cpu));
285 set_cpu_present(cpu, true);
286 set_hard_smp_processor_id(cpu, *intserv++);
287 }
288 err = 0;
289out_unlock:
290 cpu_maps_update_done();
291 free_cpumask_var(candidate_mask);
292 free_cpumask_var(tmp);
293 return err;
294}
295
296
297
298
299
300
301static void pseries_remove_processor(struct device_node *np)
302{
303 unsigned int cpu;
304 int len, nthreads, i;
305 const u32 *intserv;
306
307 intserv = of_get_property(np, "ibm,ppc-interrupt-server#s", &len);
308 if (!intserv)
309 return;
310
311 nthreads = len / sizeof(u32);
312
313 cpu_maps_update_begin();
314 for (i = 0; i < nthreads; i++) {
315 for_each_present_cpu(cpu) {
316 if (get_hard_smp_processor_id(cpu) != intserv[i])
317 continue;
318 BUG_ON(cpu_online(cpu));
319 set_cpu_present(cpu, false);
320 set_hard_smp_processor_id(cpu, -1);
321 break;
322 }
323 if (cpu >= nr_cpu_ids)
324 printk(KERN_WARNING "Could not find cpu to remove "
325 "with physical id 0x%x\n", intserv[i]);
326 }
327 cpu_maps_update_done();
328}
329
330static int pseries_smp_notifier(struct notifier_block *nb,
331 unsigned long action, void *node)
332{
333 int err = 0;
334
335 switch (action) {
336 case PSERIES_RECONFIG_ADD:
337 err = pseries_add_processor(node);
338 break;
339 case PSERIES_RECONFIG_REMOVE:
340 pseries_remove_processor(node);
341 break;
342 }
343 return notifier_from_errno(err);
344}
345
346static struct notifier_block pseries_smp_nb = {
347 .notifier_call = pseries_smp_notifier,
348};
349
350#define MAX_CEDE_LATENCY_LEVELS 4
351#define CEDE_LATENCY_PARAM_LENGTH 10
352#define CEDE_LATENCY_PARAM_MAX_LENGTH \
353 (MAX_CEDE_LATENCY_LEVELS * CEDE_LATENCY_PARAM_LENGTH * sizeof(char))
354#define CEDE_LATENCY_TOKEN 45
355
356static char cede_parameters[CEDE_LATENCY_PARAM_MAX_LENGTH];
357
358static int parse_cede_parameters(void)
359{
360 memset(cede_parameters, 0, CEDE_LATENCY_PARAM_MAX_LENGTH);
361 return rtas_call(rtas_token("ibm,get-system-parameter"), 3, 1,
362 NULL,
363 CEDE_LATENCY_TOKEN,
364 __pa(cede_parameters),
365 CEDE_LATENCY_PARAM_MAX_LENGTH);
366}
367
368static int __init pseries_cpu_hotplug_init(void)
369{
370 struct device_node *np;
371 const char *typep;
372 int cpu;
373 int qcss_tok;
374
375 for_each_node_by_name(np, "interrupt-controller") {
376 typep = of_get_property(np, "compatible", NULL);
377 if (strstr(typep, "open-pic")) {
378 of_node_put(np);
379
380 printk(KERN_INFO "CPU Hotplug not supported on "
381 "systems using MPIC\n");
382 return 0;
383 }
384 }
385
386 rtas_stop_self_args.token = rtas_token("stop-self");
387 qcss_tok = rtas_token("query-cpu-stopped-state");
388
389 if (rtas_stop_self_args.token == RTAS_UNKNOWN_SERVICE ||
390 qcss_tok == RTAS_UNKNOWN_SERVICE) {
391 printk(KERN_INFO "CPU Hotplug not supported by firmware "
392 "- disabling.\n");
393 return 0;
394 }
395
396 ppc_md.cpu_die = pseries_mach_cpu_die;
397 smp_ops->cpu_disable = pseries_cpu_disable;
398 smp_ops->cpu_die = pseries_cpu_die;
399
400
401 if (firmware_has_feature(FW_FEATURE_LPAR)) {
402 pSeries_reconfig_notifier_register(&pseries_smp_nb);
403 cpu_maps_update_begin();
404 if (cede_offline_enabled && parse_cede_parameters() == 0) {
405 default_offline_state = CPU_STATE_INACTIVE;
406 for_each_online_cpu(cpu)
407 set_default_offline_state(cpu);
408 }
409 cpu_maps_update_done();
410 }
411
412 return 0;
413}
414arch_initcall(pseries_cpu_hotplug_init);
415