blob: 0ea99e3d4815733a74b8098864f3594839ed97eb [file] [log] [blame]
Michael Ellerman0332c2d2006-12-05 17:52:36 +11001/*
2 * pseries CPU Hotplug infrastructure.
3 *
Michael Ellerman413f7c42006-12-05 17:52:38 +11004 * Split out from arch/powerpc/platforms/pseries/setup.c
5 * arch/powerpc/kernel/rtas.c, and arch/powerpc/platforms/pseries/smp.c
Michael Ellerman0332c2d2006-12-05 17:52:36 +11006 *
7 * Peter Bergner, IBM March 2001.
8 * Copyright (C) 2001 IBM.
Michael Ellerman413f7c42006-12-05 17:52:38 +11009 * Dave Engebretsen, Peter Bergner, and
10 * Mike Corrigan {engebret|bergner|mikec}@us.ibm.com
11 * Plus various changes from other IBM teams...
Michael Ellerman0332c2d2006-12-05 17:52:36 +110012 *
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
21#include <linux/kernel.h>
Benjamin Herrenschmidt0b05ac62011-04-04 13:46:58 +100022#include <linux/interrupt.h>
Michael Ellerman0332c2d2006-12-05 17:52:36 +110023#include <linux/delay.h>
Paul Gortmaker62fe91b2011-05-27 14:25:11 -040024#include <linux/sched.h> /* for idle_task_exit */
Michael Ellerman0332c2d2006-12-05 17:52:36 +110025#include <linux/cpu.h>
Nathan Fontenot1cf3d8b2012-10-02 16:57:57 +000026#include <linux/of.h>
Michael Ellerman0332c2d2006-12-05 17:52:36 +110027#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>
Benjamin Herrenschmidt0b05ac62011-04-04 13:46:58 +100032#include <asm/xics.h>
Deepthi Dharwar212bebb2013-08-22 15:23:52 +053033#include <asm/plpar_wrappers.h>
34
Gautham R Shenoy3aa565f2009-10-29 19:22:53 +000035#include "offline_states.h"
Michael Ellerman0332c2d2006-12-05 17:52:36 +110036
37/* This version can't take the spinlock, because it never returns */
Tony Breeds41dd03a2014-02-20 21:13:52 +110038static int rtas_stop_self_token = RTAS_UNKNOWN_SERVICE;
Michael Ellerman0332c2d2006-12-05 17:52:36 +110039
Gautham R Shenoy3aa565f2009-10-29 19:22:53 +000040static DEFINE_PER_CPU(enum cpu_state_vals, preferred_offline_state) =
41 CPU_STATE_OFFLINE;
42static DEFINE_PER_CPU(enum cpu_state_vals, current_state) = CPU_STATE_OFFLINE;
43
44static enum cpu_state_vals default_offline_state = CPU_STATE_OFFLINE;
45
46static int cede_offline_enabled __read_mostly = 1;
47
48/*
49 * Enable/disable cede_offline when available.
50 */
51static int __init setup_cede_offline(char *str)
52{
53 if (!strcmp(str, "off"))
54 cede_offline_enabled = 0;
55 else if (!strcmp(str, "on"))
56 cede_offline_enabled = 1;
57 else
58 return 0;
59 return 1;
60}
61
62__setup("cede_offline=", setup_cede_offline);
63
64enum cpu_state_vals get_cpu_current_state(int cpu)
65{
66 return per_cpu(current_state, cpu);
67}
68
69void set_cpu_current_state(int cpu, enum cpu_state_vals state)
70{
71 per_cpu(current_state, cpu) = state;
72}
73
74enum cpu_state_vals get_preferred_offline_state(int cpu)
75{
76 return per_cpu(preferred_offline_state, cpu);
77}
78
79void set_preferred_offline_state(int cpu, enum cpu_state_vals state)
80{
81 per_cpu(preferred_offline_state, cpu) = state;
82}
83
84void set_default_offline_state(int cpu)
85{
86 per_cpu(preferred_offline_state, cpu) = default_offline_state;
87}
88
Michael Ellerman04da6af2006-12-05 17:52:37 +110089static void rtas_stop_self(void)
Michael Ellerman0332c2d2006-12-05 17:52:36 +110090{
Tony Breeds41dd03a2014-02-20 21:13:52 +110091 struct rtas_args args = {
92 .token = cpu_to_be32(rtas_stop_self_token),
93 .nargs = 0,
94 .nret = 1,
95 .rets = &args.args[0],
96 };
Michael Ellerman0332c2d2006-12-05 17:52:36 +110097
98 local_irq_disable();
99
Tony Breeds41dd03a2014-02-20 21:13:52 +1100100 BUG_ON(rtas_stop_self_token == RTAS_UNKNOWN_SERVICE);
Michael Ellerman0332c2d2006-12-05 17:52:36 +1100101
102 printk("cpu %u (hwid %u) Ready to die...\n",
103 smp_processor_id(), hard_smp_processor_id());
Tony Breeds41dd03a2014-02-20 21:13:52 +1100104 enter_rtas(__pa(&args));
Michael Ellerman0332c2d2006-12-05 17:52:36 +1100105
106 panic("Alas, I survived.\n");
107}
108
Michael Ellerman06ba30b2006-12-05 17:52:39 +1100109static void pseries_mach_cpu_die(void)
Michael Ellerman04da6af2006-12-05 17:52:37 +1100110{
Gautham R Shenoy3aa565f2009-10-29 19:22:53 +0000111 unsigned int cpu = smp_processor_id();
112 unsigned int hwcpu = hard_smp_processor_id();
113 u8 cede_latency_hint = 0;
114
Michael Ellerman04da6af2006-12-05 17:52:37 +1100115 local_irq_disable();
116 idle_task_exit();
Nathan Fontenotc3e85062008-02-07 07:37:31 +1100117 xics_teardown_cpu();
Gautham R Shenoy3aa565f2009-10-29 19:22:53 +0000118
119 if (get_preferred_offline_state(cpu) == CPU_STATE_INACTIVE) {
120 set_cpu_current_state(cpu, CPU_STATE_INACTIVE);
Brian King32d8ad42010-07-07 12:31:02 +0000121 if (ppc_md.suspend_disable_cpu)
122 ppc_md.suspend_disable_cpu();
123
Gautham R Shenoy3aa565f2009-10-29 19:22:53 +0000124 cede_latency_hint = 2;
125
126 get_lppaca()->idle = 1;
Anton Blanchardf13c13a2013-08-07 02:01:26 +1000127 if (!lppaca_shared_proc(get_lppaca()))
Gautham R Shenoy3aa565f2009-10-29 19:22:53 +0000128 get_lppaca()->donate_dedicated_cpu = 1;
129
Gautham R Shenoy3aa565f2009-10-29 19:22:53 +0000130 while (get_preferred_offline_state(cpu) == CPU_STATE_INACTIVE) {
Li Zhongfb912562012-10-17 21:30:13 +0000131 while (!prep_irq_for_idle()) {
132 local_irq_enable();
133 local_irq_disable();
134 }
135
Gautham R Shenoy3aa565f2009-10-29 19:22:53 +0000136 extended_cede_processor(cede_latency_hint);
Gautham R Shenoy3aa565f2009-10-29 19:22:53 +0000137 }
138
Li Zhongfb912562012-10-17 21:30:13 +0000139 local_irq_disable();
140
Anton Blanchardf13c13a2013-08-07 02:01:26 +1000141 if (!lppaca_shared_proc(get_lppaca()))
Gautham R Shenoy3aa565f2009-10-29 19:22:53 +0000142 get_lppaca()->donate_dedicated_cpu = 0;
143 get_lppaca()->idle = 0;
Vaidyanathan Srinivasan0212f262010-03-01 02:58:16 +0000144
145 if (get_preferred_offline_state(cpu) == CPU_STATE_ONLINE) {
Anton Blanchard598c8232011-07-25 01:46:34 +0000146 unregister_slb_shadow(hwcpu);
Vaidyanathan Srinivasan0212f262010-03-01 02:58:16 +0000147
Li Zhongfb912562012-10-17 21:30:13 +0000148 hard_irq_disable();
Vaidyanathan Srinivasan0212f262010-03-01 02:58:16 +0000149 /*
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 }
Gautham R Shenoy3aa565f2009-10-29 19:22:53 +0000156 }
157
Vaidyanathan Srinivasan0212f262010-03-01 02:58:16 +0000158 /* Requested state is CPU_STATE_OFFLINE at this point */
159 WARN_ON(get_preferred_offline_state(cpu) != CPU_STATE_OFFLINE);
Gautham R Shenoy3aa565f2009-10-29 19:22:53 +0000160
Vaidyanathan Srinivasan0212f262010-03-01 02:58:16 +0000161 set_cpu_current_state(cpu, CPU_STATE_OFFLINE);
Anton Blanchard598c8232011-07-25 01:46:34 +0000162 unregister_slb_shadow(hwcpu);
Vaidyanathan Srinivasan0212f262010-03-01 02:58:16 +0000163 rtas_stop_self();
Gautham R Shenoy3aa565f2009-10-29 19:22:53 +0000164
Michael Ellerman04da6af2006-12-05 17:52:37 +1100165 /* Should never get here... */
166 BUG();
167 for(;;);
168}
169
Michael Ellerman06ba30b2006-12-05 17:52:39 +1100170static int pseries_cpu_disable(void)
Michael Ellerman413f7c42006-12-05 17:52:38 +1100171{
172 int cpu = smp_processor_id();
173
Rusty Russellea0f1ca2009-09-24 09:34:48 -0600174 set_cpu_online(cpu, false);
Michael Ellerman413f7c42006-12-05 17:52:38 +1100175 vdso_data->processorCount--;
176
177 /*fix boot_cpuid here*/
178 if (cpu == boot_cpuid)
Anton Blanchard8729faa2010-04-26 15:32:42 +0000179 boot_cpuid = cpumask_any(cpu_online_mask);
Michael Ellerman413f7c42006-12-05 17:52:38 +1100180
181 /* FIXME: abstract this to not be platform specific later on */
182 xics_migrate_irqs_away();
183 return 0;
184}
185
Gautham R Shenoy3aa565f2009-10-29 19:22:53 +0000186/*
187 * pseries_cpu_die: Wait for the cpu to die.
188 * @cpu: logical processor id of the CPU whose death we're awaiting.
189 *
190 * This function is called from the context of the thread which is performing
191 * the cpu-offline. Here we wait for long enough to allow the cpu in question
192 * to self-destroy so that the cpu-offline thread can send the CPU_DEAD
193 * notifications.
194 *
195 * OTOH, pseries_mach_cpu_die() is called by the @cpu when it wants to
196 * self-destruct.
197 */
Michael Ellerman06ba30b2006-12-05 17:52:39 +1100198static void pseries_cpu_die(unsigned int cpu)
Michael Ellerman413f7c42006-12-05 17:52:38 +1100199{
200 int tries;
Gautham R Shenoy3aa565f2009-10-29 19:22:53 +0000201 int cpu_status = 1;
Michael Ellerman413f7c42006-12-05 17:52:38 +1100202 unsigned int pcpu = get_hard_smp_processor_id(cpu);
203
Gautham R Shenoy3aa565f2009-10-29 19:22:53 +0000204 if (get_preferred_offline_state(cpu) == CPU_STATE_INACTIVE) {
205 cpu_status = 1;
Benjamin Herrenschmidt940ce422010-07-31 15:04:15 +1000206 for (tries = 0; tries < 5000; tries++) {
Gautham R Shenoy3aa565f2009-10-29 19:22:53 +0000207 if (get_cpu_current_state(cpu) == CPU_STATE_INACTIVE) {
208 cpu_status = 0;
209 break;
210 }
Benjamin Herrenschmidt940ce422010-07-31 15:04:15 +1000211 msleep(1);
Gautham R Shenoy3aa565f2009-10-29 19:22:53 +0000212 }
213 } else if (get_preferred_offline_state(cpu) == CPU_STATE_OFFLINE) {
214
215 for (tries = 0; tries < 25; tries++) {
Michael Neulingf8b67692010-04-28 13:39:41 +0000216 cpu_status = smp_query_cpu_stopped(pcpu);
217 if (cpu_status == QCSS_STOPPED ||
218 cpu_status == QCSS_HARDWARE_ERROR)
Gautham R Shenoy3aa565f2009-10-29 19:22:53 +0000219 break;
220 cpu_relax();
221 }
Michael Ellerman413f7c42006-12-05 17:52:38 +1100222 }
Gautham R Shenoy3aa565f2009-10-29 19:22:53 +0000223
Michael Ellerman413f7c42006-12-05 17:52:38 +1100224 if (cpu_status != 0) {
225 printk("Querying DEAD? cpu %i (%i) shows %i\n",
226 cpu, pcpu, cpu_status);
227 }
228
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300229 /* Isolation and deallocation are definitely done by
Michael Ellerman413f7c42006-12-05 17:52:38 +1100230 * drslot_chrp_cpu. If they were not they would be
231 * done here. Change isolate state to Isolate and
232 * change allocation-state to Unusable.
233 */
234 paca[cpu].cpu_start = 0;
235}
236
237/*
Anton Blanchard828a6982010-04-26 15:32:44 +0000238 * Update cpu_present_mask and paca(s) for a new cpu node. The wrinkle
Michael Ellerman413f7c42006-12-05 17:52:38 +1100239 * here is that a cpu device node may represent up to two logical cpus
240 * in the SMT case. We must honor the assumption in other code that
241 * the logical ids for sibling SMT threads x and y are adjacent, such
242 * that x^1 == y and y^1 == x.
243 */
Michael Ellerman06ba30b2006-12-05 17:52:39 +1100244static int pseries_add_processor(struct device_node *np)
Michael Ellerman413f7c42006-12-05 17:52:38 +1100245{
246 unsigned int cpu;
Anton Blanchard8729faa2010-04-26 15:32:42 +0000247 cpumask_var_t candidate_mask, tmp;
Michael Ellerman413f7c42006-12-05 17:52:38 +1100248 int err = -ENOSPC, len, nthreads, i;
249 const u32 *intserv;
250
Stephen Rothwelle2eb6392007-04-03 22:26:41 +1000251 intserv = of_get_property(np, "ibm,ppc-interrupt-server#s", &len);
Michael Ellerman413f7c42006-12-05 17:52:38 +1100252 if (!intserv)
253 return 0;
254
Anton Blanchard8729faa2010-04-26 15:32:42 +0000255 zalloc_cpumask_var(&candidate_mask, GFP_KERNEL);
256 zalloc_cpumask_var(&tmp, GFP_KERNEL);
257
Michael Ellerman413f7c42006-12-05 17:52:38 +1100258 nthreads = len / sizeof(u32);
259 for (i = 0; i < nthreads; i++)
Anton Blanchard8729faa2010-04-26 15:32:42 +0000260 cpumask_set_cpu(i, tmp);
Michael Ellerman413f7c42006-12-05 17:52:38 +1100261
Gautham R Shenoy86ef5c92008-01-25 21:08:02 +0100262 cpu_maps_update_begin();
Michael Ellerman413f7c42006-12-05 17:52:38 +1100263
Anton Blanchard8729faa2010-04-26 15:32:42 +0000264 BUG_ON(!cpumask_subset(cpu_present_mask, cpu_possible_mask));
Michael Ellerman413f7c42006-12-05 17:52:38 +1100265
266 /* Get a bitmap of unoccupied slots. */
Anton Blanchard8729faa2010-04-26 15:32:42 +0000267 cpumask_xor(candidate_mask, cpu_possible_mask, cpu_present_mask);
268 if (cpumask_empty(candidate_mask)) {
Michael Ellerman413f7c42006-12-05 17:52:38 +1100269 /* If we get here, it most likely means that NR_CPUS is
270 * less than the partition's max processors setting.
271 */
272 printk(KERN_ERR "Cannot add cpu %s; this system configuration"
273 " supports %d logical cpus.\n", np->full_name,
Anton Blanchard8729faa2010-04-26 15:32:42 +0000274 cpumask_weight(cpu_possible_mask));
Michael Ellerman413f7c42006-12-05 17:52:38 +1100275 goto out_unlock;
276 }
277
Anton Blanchard8729faa2010-04-26 15:32:42 +0000278 while (!cpumask_empty(tmp))
279 if (cpumask_subset(tmp, candidate_mask))
Michael Ellerman413f7c42006-12-05 17:52:38 +1100280 /* Found a range where we can insert the new cpu(s) */
281 break;
282 else
Anton Blanchard8729faa2010-04-26 15:32:42 +0000283 cpumask_shift_left(tmp, tmp, nthreads);
Michael Ellerman413f7c42006-12-05 17:52:38 +1100284
Anton Blanchard8729faa2010-04-26 15:32:42 +0000285 if (cpumask_empty(tmp)) {
Anton Blanchard828a6982010-04-26 15:32:44 +0000286 printk(KERN_ERR "Unable to find space in cpu_present_mask for"
Michael Ellerman413f7c42006-12-05 17:52:38 +1100287 " processor %s with %d thread(s)\n", np->name,
288 nthreads);
289 goto out_unlock;
290 }
291
Anton Blanchard8729faa2010-04-26 15:32:42 +0000292 for_each_cpu(cpu, tmp) {
KOSAKI Motohiro104699c2011-04-28 05:07:23 +0000293 BUG_ON(cpu_present(cpu));
Rusty Russellea0f1ca2009-09-24 09:34:48 -0600294 set_cpu_present(cpu, true);
Michael Ellerman413f7c42006-12-05 17:52:38 +1100295 set_hard_smp_processor_id(cpu, *intserv++);
296 }
297 err = 0;
298out_unlock:
Gautham R Shenoy86ef5c92008-01-25 21:08:02 +0100299 cpu_maps_update_done();
Anton Blanchard8729faa2010-04-26 15:32:42 +0000300 free_cpumask_var(candidate_mask);
301 free_cpumask_var(tmp);
Michael Ellerman413f7c42006-12-05 17:52:38 +1100302 return err;
303}
304
305/*
306 * Update the present map for a cpu node which is going away, and set
307 * the hard id in the paca(s) to -1 to be consistent with boot time
308 * convention for non-present cpus.
309 */
Michael Ellerman06ba30b2006-12-05 17:52:39 +1100310static void pseries_remove_processor(struct device_node *np)
Michael Ellerman413f7c42006-12-05 17:52:38 +1100311{
312 unsigned int cpu;
313 int len, nthreads, i;
314 const u32 *intserv;
315
Stephen Rothwelle2eb6392007-04-03 22:26:41 +1000316 intserv = of_get_property(np, "ibm,ppc-interrupt-server#s", &len);
Michael Ellerman413f7c42006-12-05 17:52:38 +1100317 if (!intserv)
318 return;
319
320 nthreads = len / sizeof(u32);
321
Gautham R Shenoy86ef5c92008-01-25 21:08:02 +0100322 cpu_maps_update_begin();
Michael Ellerman413f7c42006-12-05 17:52:38 +1100323 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));
Rusty Russellea0f1ca2009-09-24 09:34:48 -0600328 set_cpu_present(cpu, false);
Michael Ellerman413f7c42006-12-05 17:52:38 +1100329 set_hard_smp_processor_id(cpu, -1);
330 break;
331 }
Anton Blanchard8729faa2010-04-26 15:32:42 +0000332 if (cpu >= nr_cpu_ids)
Michael Ellerman413f7c42006-12-05 17:52:38 +1100333 printk(KERN_WARNING "Could not find cpu to remove "
334 "with physical id 0x%x\n", intserv[i]);
335 }
Gautham R Shenoy86ef5c92008-01-25 21:08:02 +0100336 cpu_maps_update_done();
Michael Ellerman413f7c42006-12-05 17:52:38 +1100337}
338
Michael Ellerman06ba30b2006-12-05 17:52:39 +1100339static int pseries_smp_notifier(struct notifier_block *nb,
340 unsigned long action, void *node)
Michael Ellerman413f7c42006-12-05 17:52:38 +1100341{
Akinobu Mitade2780a2011-06-21 03:35:56 +0000342 int err = 0;
Michael Ellerman413f7c42006-12-05 17:52:38 +1100343
344 switch (action) {
Nathan Fontenot1cf3d8b2012-10-02 16:57:57 +0000345 case OF_RECONFIG_ATTACH_NODE:
Akinobu Mitade2780a2011-06-21 03:35:56 +0000346 err = pseries_add_processor(node);
Michael Ellerman413f7c42006-12-05 17:52:38 +1100347 break;
Nathan Fontenot1cf3d8b2012-10-02 16:57:57 +0000348 case OF_RECONFIG_DETACH_NODE:
Michael Ellerman06ba30b2006-12-05 17:52:39 +1100349 pseries_remove_processor(node);
Michael Ellerman413f7c42006-12-05 17:52:38 +1100350 break;
Michael Ellerman413f7c42006-12-05 17:52:38 +1100351 }
Akinobu Mitade2780a2011-06-21 03:35:56 +0000352 return notifier_from_errno(err);
Michael Ellerman413f7c42006-12-05 17:52:38 +1100353}
354
Michael Ellerman06ba30b2006-12-05 17:52:39 +1100355static struct notifier_block pseries_smp_nb = {
356 .notifier_call = pseries_smp_notifier,
Michael Ellerman413f7c42006-12-05 17:52:38 +1100357};
358
Gautham R Shenoy3aa565f2009-10-29 19:22:53 +0000359#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{
Gautham R Shenoy3aa565f2009-10-29 19:22:53 +0000369 memset(cede_parameters, 0, CEDE_LATENCY_PARAM_MAX_LENGTH);
Anton Blanchard20a8ab92010-02-07 13:52:05 +0000370 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);
Gautham R Shenoy3aa565f2009-10-29 19:22:53 +0000375}
376
Michael Ellerman0332c2d2006-12-05 17:52:36 +1100377static int __init pseries_cpu_hotplug_init(void)
378{
Olof Johansson64f27582007-10-10 10:38:24 +1000379 struct device_node *np;
380 const char *typep;
Gautham R Shenoy3aa565f2009-10-29 19:22:53 +0000381 int cpu;
Michael Neulingf8b67692010-04-28 13:39:41 +0000382 int qcss_tok;
Olof Johansson64f27582007-10-10 10:38:24 +1000383
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
Tony Breeds41dd03a2014-02-20 21:13:52 +1100395 rtas_stop_self_token = rtas_token("stop-self");
Michael Ellerman674fa672006-12-05 17:52:38 +1100396 qcss_tok = rtas_token("query-cpu-stopped-state");
397
Tony Breeds41dd03a2014-02-20 21:13:52 +1100398 if (rtas_stop_self_token == RTAS_UNKNOWN_SERVICE ||
Michael Ellerman674fa672006-12-05 17:52:38 +1100399 qcss_tok == RTAS_UNKNOWN_SERVICE) {
400 printk(KERN_INFO "CPU Hotplug not supported by firmware "
401 "- disabling.\n");
402 return 0;
403 }
Michael Ellerman0332c2d2006-12-05 17:52:36 +1100404
Michael Ellerman06ba30b2006-12-05 17:52:39 +1100405 ppc_md.cpu_die = pseries_mach_cpu_die;
406 smp_ops->cpu_disable = pseries_cpu_disable;
407 smp_ops->cpu_die = pseries_cpu_die;
Michael Ellerman413f7c42006-12-05 17:52:38 +1100408
409 /* Processors can be added/removed only on LPAR */
Gautham R Shenoy3aa565f2009-10-29 19:22:53 +0000410 if (firmware_has_feature(FW_FEATURE_LPAR)) {
Nathan Fontenot1cf3d8b2012-10-02 16:57:57 +0000411 of_reconfig_notifier_register(&pseries_smp_nb);
Gautham R Shenoy3aa565f2009-10-29 19:22:53 +0000412 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 }
Michael Ellerman413f7c42006-12-05 17:52:38 +1100420
Michael Ellerman0332c2d2006-12-05 17:52:36 +1100421 return 0;
422}
423arch_initcall(pseries_cpu_hotplug_init);