blob: 0b47de07302d1306dcedf5dff3188a0a5514fd47 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * SMP support for ppc.
3 *
4 * Written by Cort Dougan (cort@cs.nmt.edu) borrowing a great
5 * deal of code from the sparc and intel versions.
6 *
7 * Copyright (C) 1999 Cort Dougan <cort@cs.nmt.edu>
8 *
9 * PowerPC-64 Support added by Dave Engebretsen, Peter Bergner, and
10 * Mike Corrigan {engebret|bergner|mikec}@us.ibm.com
11 *
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation; either version
15 * 2 of the License, or (at your option) any later version.
16 */
17
18#undef DEBUG
19
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include <linux/kernel.h>
21#include <linux/module.h>
22#include <linux/sched.h>
23#include <linux/smp.h>
24#include <linux/interrupt.h>
25#include <linux/delay.h>
26#include <linux/init.h>
27#include <linux/spinlock.h>
28#include <linux/cache.h>
29#include <linux/err.h>
30#include <linux/sysdev.h>
31#include <linux/cpu.h>
32#include <linux/notifier.h>
Anton Blanchard4b703a22005-12-13 06:56:47 +110033#include <linux/topology.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070034
35#include <asm/ptrace.h>
36#include <asm/atomic.h>
37#include <asm/irq.h>
38#include <asm/page.h>
39#include <asm/pgtable.h>
40#include <asm/prom.h>
41#include <asm/smp.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070042#include <asm/time.h>
43#include <asm/machdep.h>
Nathan Lynche2075f72008-07-27 15:24:52 +100044#include <asm/cputhreads.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070045#include <asm/cputable.h>
46#include <asm/system.h>
Stephen Rothwellbbeb3f42005-09-27 13:51:59 +100047#include <asm/mpic.h>
Benjamin Herrenschmidta7f290d2005-11-11 21:15:21 +110048#include <asm/vdso_datapage.h>
Paul Mackerras5ad57072005-11-05 10:33:55 +110049#ifdef CONFIG_PPC64
50#include <asm/paca.h>
51#endif
52
Linus Torvalds1da177e2005-04-16 15:20:36 -070053#ifdef DEBUG
Michael Ellermanf9e4ec52005-11-15 15:16:38 +110054#include <asm/udbg.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070055#define DBG(fmt...) udbg_printf(fmt)
56#else
57#define DBG(fmt...)
58#endif
59
Michael Ellermanf9e4ec52005-11-15 15:16:38 +110060struct thread_info *secondary_ti;
61
Mike Travisd5a74302007-10-16 01:24:05 -070062DEFINE_PER_CPU(cpumask_t, cpu_sibling_map) = CPU_MASK_NONE;
Nathan Lynch440a0852008-07-27 15:24:53 +100063DEFINE_PER_CPU(cpumask_t, cpu_core_map) = CPU_MASK_NONE;
Linus Torvalds1da177e2005-04-16 15:20:36 -070064
Mike Travisd5a74302007-10-16 01:24:05 -070065EXPORT_PER_CPU_SYMBOL(cpu_sibling_map);
Nathan Lynch440a0852008-07-27 15:24:53 +100066EXPORT_PER_CPU_SYMBOL(cpu_core_map);
Linus Torvalds1da177e2005-04-16 15:20:36 -070067
Paul Mackerras5ad57072005-11-05 10:33:55 +110068/* SMP operations for this machine */
Linus Torvalds1da177e2005-04-16 15:20:36 -070069struct smp_ops_t *smp_ops;
70
Benjamin Herrenschmidt7ccbe502009-06-18 23:30:07 +000071/* Can't be static due to PowerMac hackery */
72volatile unsigned int cpu_callin_map[NR_CPUS];
Linus Torvalds1da177e2005-04-16 15:20:36 -070073
Linus Torvalds1da177e2005-04-16 15:20:36 -070074int smt_enabled_at_boot = 1;
75
Michael Ellermancc532912005-12-04 18:39:43 +110076static void (*crash_ipi_function_ptr)(struct pt_regs *) = NULL;
77
Paul Mackerras5ad57072005-11-05 10:33:55 +110078#ifdef CONFIG_PPC64
Linus Torvalds1da177e2005-04-16 15:20:36 -070079void __devinit smp_generic_kick_cpu(int nr)
80{
81 BUG_ON(nr < 0 || nr >= NR_CPUS);
82
83 /*
84 * The processor is currently spinning, waiting for the
85 * cpu_start field to become non-zero After we set cpu_start,
86 * the processor will continue on to secondary_start
87 */
88 paca[nr].cpu_start = 1;
Anton Blanchard0d8d4d42005-05-01 08:58:47 -070089 smp_mb();
Linus Torvalds1da177e2005-04-16 15:20:36 -070090}
Paul Mackerras5ad57072005-11-05 10:33:55 +110091#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070092
David Howells7d12e782006-10-05 14:55:46 +010093void smp_message_recv(int msg)
Linus Torvalds1da177e2005-04-16 15:20:36 -070094{
95 switch(msg) {
96 case PPC_MSG_CALL_FUNCTION:
Jens Axboeb7d7a242008-06-26 11:22:13 +020097 generic_smp_call_function_interrupt();
Linus Torvalds1da177e2005-04-16 15:20:36 -070098 break;
Paul Mackerras5ad57072005-11-05 10:33:55 +110099 case PPC_MSG_RESCHEDULE:
Milton Miller22d660f2008-10-10 01:56:45 +0000100 /* we notice need_resched on exit */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101 break;
Jens Axboeb7d7a242008-06-26 11:22:13 +0200102 case PPC_MSG_CALL_FUNC_SINGLE:
103 generic_smp_call_function_single_interrupt();
104 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105 case PPC_MSG_DEBUGGER_BREAK:
Michael Ellermancc532912005-12-04 18:39:43 +1100106 if (crash_ipi_function_ptr) {
David Howells7d12e782006-10-05 14:55:46 +0100107 crash_ipi_function_ptr(get_irq_regs());
Michael Ellermancc532912005-12-04 18:39:43 +1100108 break;
109 }
110#ifdef CONFIG_DEBUGGER
David Howells7d12e782006-10-05 14:55:46 +0100111 debugger_ipi(get_irq_regs());
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112 break;
Michael Ellermancc532912005-12-04 18:39:43 +1100113#endif /* CONFIG_DEBUGGER */
114 /* FALLTHROUGH */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115 default:
116 printk("SMP %d: smp_message_recv(): unknown msg %d\n",
117 smp_processor_id(), msg);
118 break;
119 }
120}
121
Milton Miller25ddd732008-11-14 20:11:49 +0000122static irqreturn_t call_function_action(int irq, void *data)
123{
124 generic_smp_call_function_interrupt();
125 return IRQ_HANDLED;
126}
127
128static irqreturn_t reschedule_action(int irq, void *data)
129{
130 /* we just need the return path side effect of checking need_resched */
131 return IRQ_HANDLED;
132}
133
134static irqreturn_t call_function_single_action(int irq, void *data)
135{
136 generic_smp_call_function_single_interrupt();
137 return IRQ_HANDLED;
138}
139
140static irqreturn_t debug_ipi_action(int irq, void *data)
141{
142 smp_message_recv(PPC_MSG_DEBUGGER_BREAK);
143 return IRQ_HANDLED;
144}
145
146static irq_handler_t smp_ipi_action[] = {
147 [PPC_MSG_CALL_FUNCTION] = call_function_action,
148 [PPC_MSG_RESCHEDULE] = reschedule_action,
149 [PPC_MSG_CALL_FUNC_SINGLE] = call_function_single_action,
150 [PPC_MSG_DEBUGGER_BREAK] = debug_ipi_action,
151};
152
153const char *smp_ipi_name[] = {
154 [PPC_MSG_CALL_FUNCTION] = "ipi call function",
155 [PPC_MSG_RESCHEDULE] = "ipi reschedule",
156 [PPC_MSG_CALL_FUNC_SINGLE] = "ipi call function single",
157 [PPC_MSG_DEBUGGER_BREAK] = "ipi debugger",
158};
159
160/* optional function to request ipi, for controllers with >= 4 ipis */
161int smp_request_message_ipi(int virq, int msg)
162{
163 int err;
164
165 if (msg < 0 || msg > PPC_MSG_DEBUGGER_BREAK) {
166 return -EINVAL;
167 }
168#if !defined(CONFIG_DEBUGGER) && !defined(CONFIG_KEXEC)
169 if (msg == PPC_MSG_DEBUGGER_BREAK) {
170 return 1;
171 }
172#endif
173 err = request_irq(virq, smp_ipi_action[msg], IRQF_DISABLED|IRQF_PERCPU,
174 smp_ipi_name[msg], 0);
175 WARN(err < 0, "unable to request_irq %d for %s (rc %d)\n",
176 virq, smp_ipi_name[msg], err);
177
178 return err;
179}
180
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181void smp_send_reschedule(int cpu)
182{
Benjamin Herrenschmidt8cffc6a2006-07-04 14:09:36 +1000183 if (likely(smp_ops))
184 smp_ops->message_pass(cpu, PPC_MSG_RESCHEDULE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185}
186
Jens Axboeb7d7a242008-06-26 11:22:13 +0200187void arch_send_call_function_single_ipi(int cpu)
188{
189 smp_ops->message_pass(cpu, PPC_MSG_CALL_FUNC_SINGLE);
190}
191
192void arch_send_call_function_ipi(cpumask_t mask)
193{
194 unsigned int cpu;
195
196 for_each_cpu_mask(cpu, mask)
197 smp_ops->message_pass(cpu, PPC_MSG_CALL_FUNCTION);
198}
199
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200#ifdef CONFIG_DEBUGGER
201void smp_send_debugger_break(int cpu)
202{
Benjamin Herrenschmidt8cffc6a2006-07-04 14:09:36 +1000203 if (likely(smp_ops))
204 smp_ops->message_pass(cpu, PPC_MSG_DEBUGGER_BREAK);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205}
206#endif
207
Michael Ellermancc532912005-12-04 18:39:43 +1100208#ifdef CONFIG_KEXEC
209void crash_send_ipi(void (*crash_ipi_callback)(struct pt_regs *))
210{
211 crash_ipi_function_ptr = crash_ipi_callback;
Benjamin Herrenschmidt8cffc6a2006-07-04 14:09:36 +1000212 if (crash_ipi_callback && smp_ops) {
Michael Ellermancc532912005-12-04 18:39:43 +1100213 mb();
214 smp_ops->message_pass(MSG_ALL_BUT_SELF, PPC_MSG_DEBUGGER_BREAK);
215 }
216}
217#endif
218
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219static void stop_this_cpu(void *dummy)
220{
221 local_irq_disable();
222 while (1)
223 ;
224}
225
Satyam Sharma8fd76752007-09-18 09:43:40 +1000226void smp_send_stop(void)
227{
Jens Axboe8691e5a2008-06-06 11:18:06 +0200228 smp_call_function(stop_this_cpu, NULL, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229}
230
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231struct thread_info *current_set[NR_CPUS];
232
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233static void __devinit smp_store_cpu_info(int id)
234{
235 per_cpu(pvr, id) = mfspr(SPRN_PVR);
236}
237
238static void __init smp_create_idle(unsigned int cpu)
239{
240 struct task_struct *p;
241
242 /* create a process for the processor */
243 p = fork_idle(cpu);
244 if (IS_ERR(p))
245 panic("failed fork for CPU %u: %li", cpu, PTR_ERR(p));
Paul Mackerras5ad57072005-11-05 10:33:55 +1100246#ifdef CONFIG_PPC64
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247 paca[cpu].__current = p;
Paul Mackerras3b575062008-05-02 14:29:12 +1000248 paca[cpu].kstack = (unsigned long) task_thread_info(p)
249 + THREAD_SIZE - STACK_FRAME_OVERHEAD;
Paul Mackerras5ad57072005-11-05 10:33:55 +1100250#endif
Al Virob5e2fc12006-01-12 01:06:01 -0800251 current_set[cpu] = task_thread_info(p);
252 task_thread_info(p)->cpu = cpu;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253}
254
255void __init smp_prepare_cpus(unsigned int max_cpus)
256{
257 unsigned int cpu;
258
259 DBG("smp_prepare_cpus\n");
260
261 /*
262 * setup_cpu may need to be called on the boot cpu. We havent
263 * spun any cpus up but lets be paranoid.
264 */
265 BUG_ON(boot_cpuid != smp_processor_id());
266
267 /* Fixup boot cpu */
268 smp_store_cpu_info(boot_cpuid);
269 cpu_callin_map[boot_cpuid] = 1;
270
Benjamin Herrenschmidt8cffc6a2006-07-04 14:09:36 +1000271 if (smp_ops)
272 max_cpus = smp_ops->probe();
273 else
274 max_cpus = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275
276 smp_space_timers(max_cpus);
277
KAMEZAWA Hiroyuki0e551952006-03-28 14:50:51 -0800278 for_each_possible_cpu(cpu)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 if (cpu != boot_cpuid)
280 smp_create_idle(cpu);
281}
282
283void __devinit smp_prepare_boot_cpu(void)
284{
285 BUG_ON(smp_processor_id() != boot_cpuid);
286
287 cpu_set(boot_cpuid, cpu_online_map);
Nathan Lynche2075f72008-07-27 15:24:52 +1000288 cpu_set(boot_cpuid, per_cpu(cpu_sibling_map, boot_cpuid));
Nathan Lynch440a0852008-07-27 15:24:53 +1000289 cpu_set(boot_cpuid, per_cpu(cpu_core_map, boot_cpuid));
Paul Mackerras5ad57072005-11-05 10:33:55 +1100290#ifdef CONFIG_PPC64
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291 paca[boot_cpuid].__current = current;
Paul Mackerras5ad57072005-11-05 10:33:55 +1100292#endif
Al Virob5e2fc12006-01-12 01:06:01 -0800293 current_set[boot_cpuid] = task_thread_info(current);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294}
295
296#ifdef CONFIG_HOTPLUG_CPU
297/* State of each CPU during hotplug phases */
298DEFINE_PER_CPU(int, cpu_state) = { 0 };
299
300int generic_cpu_disable(void)
301{
302 unsigned int cpu = smp_processor_id();
303
304 if (cpu == boot_cpuid)
305 return -EBUSY;
306
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307 cpu_clear(cpu, cpu_online_map);
Paul Mackerras799d6042005-11-10 13:37:51 +1100308#ifdef CONFIG_PPC64
Benjamin Herrenschmidta7f290d2005-11-11 21:15:21 +1100309 vdso_data->processorCount--;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310 fixup_irqs(cpu_online_map);
Paul Mackerras094fe2e2005-11-10 14:26:12 +1100311#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312 return 0;
313}
314
315int generic_cpu_enable(unsigned int cpu)
316{
317 /* Do the normal bootup if we haven't
318 * already bootstrapped. */
319 if (system_state != SYSTEM_RUNNING)
320 return -ENOSYS;
321
322 /* get the target out of it's holding state */
323 per_cpu(cpu_state, cpu) = CPU_UP_PREPARE;
Anton Blanchard0d8d4d42005-05-01 08:58:47 -0700324 smp_wmb();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325
326 while (!cpu_online(cpu))
327 cpu_relax();
328
Paul Mackerras094fe2e2005-11-10 14:26:12 +1100329#ifdef CONFIG_PPC64
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330 fixup_irqs(cpu_online_map);
331 /* counter the irq disable in fixup_irqs */
332 local_irq_enable();
Paul Mackerras094fe2e2005-11-10 14:26:12 +1100333#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334 return 0;
335}
336
337void generic_cpu_die(unsigned int cpu)
338{
339 int i;
340
341 for (i = 0; i < 100; i++) {
Anton Blanchard0d8d4d42005-05-01 08:58:47 -0700342 smp_rmb();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343 if (per_cpu(cpu_state, cpu) == CPU_DEAD)
344 return;
345 msleep(100);
346 }
347 printk(KERN_ERR "CPU%d didn't die...\n", cpu);
348}
349
350void generic_mach_cpu_die(void)
351{
352 unsigned int cpu;
353
354 local_irq_disable();
355 cpu = smp_processor_id();
356 printk(KERN_DEBUG "CPU%d offline\n", cpu);
357 __get_cpu_var(cpu_state) = CPU_DEAD;
Anton Blanchard0d8d4d42005-05-01 08:58:47 -0700358 smp_wmb();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359 while (__get_cpu_var(cpu_state) != CPU_UP_PREPARE)
360 cpu_relax();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361 cpu_set(cpu, cpu_online_map);
362 local_irq_enable();
363}
364#endif
365
366static int __devinit cpu_enable(unsigned int cpu)
367{
Benjamin Herrenschmidt8cffc6a2006-07-04 14:09:36 +1000368 if (smp_ops && smp_ops->cpu_enable)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369 return smp_ops->cpu_enable(cpu);
370
371 return -ENOSYS;
372}
373
Gautham R Shenoyb282b6f2007-01-10 23:15:34 -0800374int __cpuinit __cpu_up(unsigned int cpu)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375{
376 int c;
377
Paul Mackerras5ad57072005-11-05 10:33:55 +1100378 secondary_ti = current_set[cpu];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 if (!cpu_enable(cpu))
380 return 0;
381
Benjamin Herrenschmidt8cffc6a2006-07-04 14:09:36 +1000382 if (smp_ops == NULL ||
383 (smp_ops->cpu_bootable && !smp_ops->cpu_bootable(cpu)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384 return -EINVAL;
385
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386 /* Make sure callin-map entry is 0 (can be leftover a CPU
387 * hotplug
388 */
389 cpu_callin_map[cpu] = 0;
390
391 /* The information for processor bringup must
392 * be written out to main store before we release
393 * the processor.
394 */
Anton Blanchard0d8d4d42005-05-01 08:58:47 -0700395 smp_mb();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396
397 /* wake up cpus */
398 DBG("smp: kicking cpu %d\n", cpu);
399 smp_ops->kick_cpu(cpu);
400
401 /*
402 * wait to see if the cpu made a callin (is actually up).
403 * use this value that I found through experimentation.
404 * -- Cort
405 */
406 if (system_state < SYSTEM_RUNNING)
Jon Loeligeree0339f2006-06-17 17:52:44 -0500407 for (c = 50000; c && !cpu_callin_map[cpu]; c--)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408 udelay(100);
409#ifdef CONFIG_HOTPLUG_CPU
410 else
411 /*
412 * CPUs can take much longer to come up in the
413 * hotplug case. Wait five seconds.
414 */
415 for (c = 25; c && !cpu_callin_map[cpu]; c--) {
416 msleep(200);
417 }
418#endif
419
420 if (!cpu_callin_map[cpu]) {
421 printk("Processor %u is stuck.\n", cpu);
422 return -ENOENT;
423 }
424
425 printk("Processor %u found.\n", cpu);
426
427 if (smp_ops->give_timebase)
428 smp_ops->give_timebase();
429
430 /* Wait until cpu puts itself in the online map */
431 while (!cpu_online(cpu))
432 cpu_relax();
433
434 return 0;
435}
436
Nathan Lynche9efed32008-07-27 15:24:54 +1000437/* Return the value of the reg property corresponding to the given
438 * logical cpu.
439 */
440int cpu_to_core_id(int cpu)
441{
442 struct device_node *np;
443 const int *reg;
444 int id = -1;
445
446 np = of_get_cpu_node(cpu, NULL);
447 if (!np)
448 goto out;
449
450 reg = of_get_property(np, "reg", NULL);
451 if (!reg)
452 goto out;
453
454 id = *reg;
455out:
456 of_node_put(np);
457 return id;
458}
459
Nathan Lynch440a0852008-07-27 15:24:53 +1000460/* Must be called when no change can occur to cpu_present_map,
461 * i.e. during cpu online or offline.
462 */
463static struct device_node *cpu_to_l2cache(int cpu)
464{
465 struct device_node *np;
Nathan Lynchb2ea25b2008-12-10 20:16:07 +0000466 struct device_node *cache;
Nathan Lynch440a0852008-07-27 15:24:53 +1000467
468 if (!cpu_present(cpu))
469 return NULL;
470
471 np = of_get_cpu_node(cpu, NULL);
472 if (np == NULL)
473 return NULL;
474
Nathan Lynchb2ea25b2008-12-10 20:16:07 +0000475 cache = of_find_next_cache_node(np);
476
Nathan Lynch440a0852008-07-27 15:24:53 +1000477 of_node_put(np);
478
Nathan Lynchb2ea25b2008-12-10 20:16:07 +0000479 return cache;
Nathan Lynch440a0852008-07-27 15:24:53 +1000480}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481
482/* Activate a secondary processor. */
483int __devinit start_secondary(void *unused)
484{
485 unsigned int cpu = smp_processor_id();
Nathan Lynch440a0852008-07-27 15:24:53 +1000486 struct device_node *l2_cache;
Nathan Lynche2075f72008-07-27 15:24:52 +1000487 int i, base;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488
489 atomic_inc(&init_mm.mm_count);
490 current->active_mm = &init_mm;
491
492 smp_store_cpu_info(cpu);
Paul Mackerras5ad57072005-11-05 10:33:55 +1100493 set_dec(tb_ticks_per_jiffy);
Andrew Mortone4d76e12005-11-09 15:45:30 -0800494 preempt_disable();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495 cpu_callin_map[cpu] = 1;
496
497 smp_ops->setup_cpu(cpu);
498 if (smp_ops->take_timebase)
499 smp_ops->take_timebase();
500
Nathan Lynch7d4d6152006-02-06 22:44:23 -0600501 if (system_state > SYSTEM_BOOTING)
Paul Mackerrasc6622f62006-02-24 10:06:59 +1100502 snapshot_timebase();
Nathan Lynch7d4d6152006-02-06 22:44:23 -0600503
Tony Breedsd831d0b2007-09-21 13:26:03 +1000504 secondary_cpu_time_init();
505
Jens Axboeb7d7a242008-06-26 11:22:13 +0200506 ipi_call_lock();
Manfred Spraule545a612008-09-07 16:57:22 +0200507 notify_cpu_starting(cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508 cpu_set(cpu, cpu_online_map);
Nathan Lynche2075f72008-07-27 15:24:52 +1000509 /* Update sibling maps */
510 base = cpu_first_thread_in_core(cpu);
511 for (i = 0; i < threads_per_core; i++) {
512 if (cpu_is_offline(base + i))
513 continue;
514 cpu_set(cpu, per_cpu(cpu_sibling_map, base + i));
515 cpu_set(base + i, per_cpu(cpu_sibling_map, cpu));
Nathan Lynch440a0852008-07-27 15:24:53 +1000516
517 /* cpu_core_map should be a superset of
518 * cpu_sibling_map even if we don't have cache
519 * information, so update the former here, too.
520 */
521 cpu_set(cpu, per_cpu(cpu_core_map, base +i));
522 cpu_set(base + i, per_cpu(cpu_core_map, cpu));
Nathan Lynche2075f72008-07-27 15:24:52 +1000523 }
Nathan Lynch440a0852008-07-27 15:24:53 +1000524 l2_cache = cpu_to_l2cache(cpu);
525 for_each_online_cpu(i) {
526 struct device_node *np = cpu_to_l2cache(i);
527 if (!np)
528 continue;
529 if (np == l2_cache) {
530 cpu_set(cpu, per_cpu(cpu_core_map, i));
531 cpu_set(i, per_cpu(cpu_core_map, cpu));
532 }
533 of_node_put(np);
534 }
535 of_node_put(l2_cache);
Jens Axboeb7d7a242008-06-26 11:22:13 +0200536 ipi_call_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537
538 local_irq_enable();
539
540 cpu_idle();
541 return 0;
542}
543
544int setup_profiling_timer(unsigned int multiplier)
545{
546 return 0;
547}
548
549void __init smp_cpus_done(unsigned int max_cpus)
550{
551 cpumask_t old_mask;
552
553 /* We want the setup_cpu() here to be called from CPU 0, but our
554 * init thread may have been "borrowed" by another CPU in the meantime
555 * se we pin us down to CPU 0 for a short while
556 */
557 old_mask = current->cpus_allowed;
558 set_cpus_allowed(current, cpumask_of_cpu(boot_cpuid));
559
Benjamin Herrenschmidt8cffc6a2006-07-04 14:09:36 +1000560 if (smp_ops)
561 smp_ops->setup_cpu(boot_cpuid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562
563 set_cpus_allowed(current, old_mask);
Anton Blanchard4b703a22005-12-13 06:56:47 +1100564
Paul Mackerrasc6622f62006-02-24 10:06:59 +1100565 snapshot_timebases();
566
Anton Blanchard4b703a22005-12-13 06:56:47 +1100567 dump_numa_cpu_topology();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568}
569
570#ifdef CONFIG_HOTPLUG_CPU
571int __cpu_disable(void)
572{
Nathan Lynch440a0852008-07-27 15:24:53 +1000573 struct device_node *l2_cache;
Nathan Lynche2075f72008-07-27 15:24:52 +1000574 int cpu = smp_processor_id();
575 int base, i;
576 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577
Nathan Lynche2075f72008-07-27 15:24:52 +1000578 if (!smp_ops->cpu_disable)
579 return -ENOSYS;
580
581 err = smp_ops->cpu_disable();
582 if (err)
583 return err;
584
585 /* Update sibling maps */
586 base = cpu_first_thread_in_core(cpu);
587 for (i = 0; i < threads_per_core; i++) {
588 cpu_clear(cpu, per_cpu(cpu_sibling_map, base + i));
589 cpu_clear(base + i, per_cpu(cpu_sibling_map, cpu));
Nathan Lynch440a0852008-07-27 15:24:53 +1000590 cpu_clear(cpu, per_cpu(cpu_core_map, base +i));
591 cpu_clear(base + i, per_cpu(cpu_core_map, cpu));
Nathan Lynche2075f72008-07-27 15:24:52 +1000592 }
593
Nathan Lynch440a0852008-07-27 15:24:53 +1000594 l2_cache = cpu_to_l2cache(cpu);
595 for_each_present_cpu(i) {
596 struct device_node *np = cpu_to_l2cache(i);
597 if (!np)
598 continue;
599 if (np == l2_cache) {
600 cpu_clear(cpu, per_cpu(cpu_core_map, i));
601 cpu_clear(i, per_cpu(cpu_core_map, cpu));
602 }
603 of_node_put(np);
604 }
605 of_node_put(l2_cache);
606
607
Nathan Lynche2075f72008-07-27 15:24:52 +1000608 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609}
610
611void __cpu_die(unsigned int cpu)
612{
613 if (smp_ops->cpu_die)
614 smp_ops->cpu_die(cpu);
615}
616#endif