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 | ||
21 | #include <linux/kernel.h> | |
22 | #include <linux/delay.h> | |
23 | #include <linux/cpu.h> | |
24 | #include <asm/system.h> | |
25 | #include <asm/prom.h> | |
26 | #include <asm/rtas.h> | |
27 | #include <asm/firmware.h> | |
28 | #include <asm/machdep.h> | |
29 | #include <asm/vdso_datapage.h> | |
30 | #include <asm/pSeries_reconfig.h> | |
31 | #include "xics.h" | |
32 | ||
33 | /* This version can't take the spinlock, because it never returns */ | |
34 | static struct rtas_args rtas_stop_self_args = { | |
35 | .token = RTAS_UNKNOWN_SERVICE, | |
36 | .nargs = 0, | |
37 | .nret = 1, | |
38 | .rets = &rtas_stop_self_args.args[0], | |
39 | }; | |
40 | ||
04da6af9 | 41 | static void rtas_stop_self(void) |
0332c2d4 ME |
42 | { |
43 | struct rtas_args *args = &rtas_stop_self_args; | |
44 | ||
45 | local_irq_disable(); | |
46 | ||
47 | BUG_ON(args->token == RTAS_UNKNOWN_SERVICE); | |
48 | ||
49 | printk("cpu %u (hwid %u) Ready to die...\n", | |
50 | smp_processor_id(), hard_smp_processor_id()); | |
51 | enter_rtas(__pa(args)); | |
52 | ||
53 | panic("Alas, I survived.\n"); | |
54 | } | |
55 | ||
06ba30b6 | 56 | static void pseries_mach_cpu_die(void) |
04da6af9 ME |
57 | { |
58 | local_irq_disable(); | |
59 | idle_task_exit(); | |
60 | xics_teardown_cpu(0); | |
61 | rtas_stop_self(); | |
62 | /* Should never get here... */ | |
63 | BUG(); | |
64 | for(;;); | |
65 | } | |
66 | ||
674fa677 ME |
67 | static int qcss_tok; /* query-cpu-stopped-state token */ |
68 | ||
413f7c40 ME |
69 | /* Get state of physical CPU. |
70 | * Return codes: | |
71 | * 0 - The processor is in the RTAS stopped state | |
72 | * 1 - stop-self is in progress | |
73 | * 2 - The processor is not in the RTAS stopped state | |
74 | * -1 - Hardware Error | |
75 | * -2 - Hardware Busy, Try again later. | |
76 | */ | |
77 | static int query_cpu_stopped(unsigned int pcpu) | |
78 | { | |
674fa677 | 79 | int cpu_status, status; |
413f7c40 | 80 | |
413f7c40 ME |
81 | status = rtas_call(qcss_tok, 1, 2, &cpu_status, pcpu); |
82 | if (status != 0) { | |
83 | printk(KERN_ERR | |
84 | "RTAS query-cpu-stopped-state failed: %i\n", status); | |
85 | return status; | |
86 | } | |
87 | ||
88 | return cpu_status; | |
89 | } | |
90 | ||
06ba30b6 | 91 | static int pseries_cpu_disable(void) |
413f7c40 ME |
92 | { |
93 | int cpu = smp_processor_id(); | |
94 | ||
95 | cpu_clear(cpu, cpu_online_map); | |
96 | vdso_data->processorCount--; | |
97 | ||
98 | /*fix boot_cpuid here*/ | |
99 | if (cpu == boot_cpuid) | |
100 | boot_cpuid = any_online_cpu(cpu_online_map); | |
101 | ||
102 | /* FIXME: abstract this to not be platform specific later on */ | |
103 | xics_migrate_irqs_away(); | |
104 | return 0; | |
105 | } | |
106 | ||
06ba30b6 | 107 | static void pseries_cpu_die(unsigned int cpu) |
413f7c40 ME |
108 | { |
109 | int tries; | |
110 | int cpu_status; | |
111 | unsigned int pcpu = get_hard_smp_processor_id(cpu); | |
112 | ||
113 | for (tries = 0; tries < 25; tries++) { | |
114 | cpu_status = query_cpu_stopped(pcpu); | |
115 | if (cpu_status == 0 || cpu_status == -1) | |
116 | break; | |
117 | msleep(200); | |
118 | } | |
119 | if (cpu_status != 0) { | |
120 | printk("Querying DEAD? cpu %i (%i) shows %i\n", | |
121 | cpu, pcpu, cpu_status); | |
122 | } | |
123 | ||
124 | /* Isolation and deallocation are definatly done by | |
125 | * drslot_chrp_cpu. If they were not they would be | |
126 | * done here. Change isolate state to Isolate and | |
127 | * change allocation-state to Unusable. | |
128 | */ | |
129 | paca[cpu].cpu_start = 0; | |
130 | } | |
131 | ||
132 | /* | |
133 | * Update cpu_present_map and paca(s) for a new cpu node. The wrinkle | |
134 | * here is that a cpu device node may represent up to two logical cpus | |
135 | * in the SMT case. We must honor the assumption in other code that | |
136 | * the logical ids for sibling SMT threads x and y are adjacent, such | |
137 | * that x^1 == y and y^1 == x. | |
138 | */ | |
06ba30b6 | 139 | static int pseries_add_processor(struct device_node *np) |
413f7c40 ME |
140 | { |
141 | unsigned int cpu; | |
142 | cpumask_t candidate_map, tmp = CPU_MASK_NONE; | |
143 | int err = -ENOSPC, len, nthreads, i; | |
144 | const u32 *intserv; | |
145 | ||
e2eb6392 | 146 | intserv = of_get_property(np, "ibm,ppc-interrupt-server#s", &len); |
413f7c40 ME |
147 | if (!intserv) |
148 | return 0; | |
149 | ||
150 | nthreads = len / sizeof(u32); | |
151 | for (i = 0; i < nthreads; i++) | |
152 | cpu_set(i, tmp); | |
153 | ||
154 | lock_cpu_hotplug(); | |
155 | ||
156 | BUG_ON(!cpus_subset(cpu_present_map, cpu_possible_map)); | |
157 | ||
158 | /* Get a bitmap of unoccupied slots. */ | |
159 | cpus_xor(candidate_map, cpu_possible_map, cpu_present_map); | |
160 | if (cpus_empty(candidate_map)) { | |
161 | /* If we get here, it most likely means that NR_CPUS is | |
162 | * less than the partition's max processors setting. | |
163 | */ | |
164 | printk(KERN_ERR "Cannot add cpu %s; this system configuration" | |
165 | " supports %d logical cpus.\n", np->full_name, | |
166 | cpus_weight(cpu_possible_map)); | |
167 | goto out_unlock; | |
168 | } | |
169 | ||
170 | while (!cpus_empty(tmp)) | |
171 | if (cpus_subset(tmp, candidate_map)) | |
172 | /* Found a range where we can insert the new cpu(s) */ | |
173 | break; | |
174 | else | |
175 | cpus_shift_left(tmp, tmp, nthreads); | |
176 | ||
177 | if (cpus_empty(tmp)) { | |
178 | printk(KERN_ERR "Unable to find space in cpu_present_map for" | |
179 | " processor %s with %d thread(s)\n", np->name, | |
180 | nthreads); | |
181 | goto out_unlock; | |
182 | } | |
183 | ||
184 | for_each_cpu_mask(cpu, tmp) { | |
185 | BUG_ON(cpu_isset(cpu, cpu_present_map)); | |
186 | cpu_set(cpu, cpu_present_map); | |
187 | set_hard_smp_processor_id(cpu, *intserv++); | |
188 | } | |
189 | err = 0; | |
190 | out_unlock: | |
191 | unlock_cpu_hotplug(); | |
192 | return err; | |
193 | } | |
194 | ||
195 | /* | |
196 | * Update the present map for a cpu node which is going away, and set | |
197 | * the hard id in the paca(s) to -1 to be consistent with boot time | |
198 | * convention for non-present cpus. | |
199 | */ | |
06ba30b6 | 200 | static void pseries_remove_processor(struct device_node *np) |
413f7c40 ME |
201 | { |
202 | unsigned int cpu; | |
203 | int len, nthreads, i; | |
204 | const u32 *intserv; | |
205 | ||
e2eb6392 | 206 | intserv = of_get_property(np, "ibm,ppc-interrupt-server#s", &len); |
413f7c40 ME |
207 | if (!intserv) |
208 | return; | |
209 | ||
210 | nthreads = len / sizeof(u32); | |
211 | ||
212 | lock_cpu_hotplug(); | |
213 | for (i = 0; i < nthreads; i++) { | |
214 | for_each_present_cpu(cpu) { | |
215 | if (get_hard_smp_processor_id(cpu) != intserv[i]) | |
216 | continue; | |
217 | BUG_ON(cpu_online(cpu)); | |
218 | cpu_clear(cpu, cpu_present_map); | |
219 | set_hard_smp_processor_id(cpu, -1); | |
220 | break; | |
221 | } | |
222 | if (cpu == NR_CPUS) | |
223 | printk(KERN_WARNING "Could not find cpu to remove " | |
224 | "with physical id 0x%x\n", intserv[i]); | |
225 | } | |
226 | unlock_cpu_hotplug(); | |
227 | } | |
228 | ||
06ba30b6 ME |
229 | static int pseries_smp_notifier(struct notifier_block *nb, |
230 | unsigned long action, void *node) | |
413f7c40 ME |
231 | { |
232 | int err = NOTIFY_OK; | |
233 | ||
234 | switch (action) { | |
235 | case PSERIES_RECONFIG_ADD: | |
06ba30b6 | 236 | if (pseries_add_processor(node)) |
413f7c40 ME |
237 | err = NOTIFY_BAD; |
238 | break; | |
239 | case PSERIES_RECONFIG_REMOVE: | |
06ba30b6 | 240 | pseries_remove_processor(node); |
413f7c40 ME |
241 | break; |
242 | default: | |
243 | err = NOTIFY_DONE; | |
244 | break; | |
245 | } | |
246 | return err; | |
247 | } | |
248 | ||
06ba30b6 ME |
249 | static struct notifier_block pseries_smp_nb = { |
250 | .notifier_call = pseries_smp_notifier, | |
413f7c40 ME |
251 | }; |
252 | ||
0332c2d4 ME |
253 | static int __init pseries_cpu_hotplug_init(void) |
254 | { | |
255 | rtas_stop_self_args.token = rtas_token("stop-self"); | |
674fa677 | 256 | qcss_tok = rtas_token("query-cpu-stopped-state"); |
0332c2d4 | 257 | |
674fa677 ME |
258 | if (rtas_stop_self_args.token == RTAS_UNKNOWN_SERVICE || |
259 | qcss_tok == RTAS_UNKNOWN_SERVICE) { | |
260 | printk(KERN_INFO "CPU Hotplug not supported by firmware " | |
261 | "- disabling.\n"); | |
262 | return 0; | |
263 | } | |
04da6af9 | 264 | |
06ba30b6 ME |
265 | ppc_md.cpu_die = pseries_mach_cpu_die; |
266 | smp_ops->cpu_disable = pseries_cpu_disable; | |
267 | smp_ops->cpu_die = pseries_cpu_die; | |
413f7c40 ME |
268 | |
269 | /* Processors can be added/removed only on LPAR */ | |
270 | if (firmware_has_feature(FW_FEATURE_LPAR)) | |
06ba30b6 | 271 | pSeries_reconfig_notifier_register(&pseries_smp_nb); |
413f7c40 | 272 | |
0332c2d4 ME |
273 | return 0; |
274 | } | |
275 | arch_initcall(pseries_cpu_hotplug_init); |