aboutsummaryrefslogtreecommitdiffstats
path: root/arch/ppc64
diff options
context:
space:
mode:
authorPaul Mackerras <paulus@samba.org>2005-11-04 18:33:55 -0500
committerPaul Mackerras <paulus@samba.org>2005-11-04 18:33:55 -0500
commit5ad570786158e327a1c5d32dd3d66f26d8de6340 (patch)
tree0b4aafe469c72e5887ed0379d62a0ee390db3160 /arch/ppc64
parentc3df69cd854551cf70e9c63aa509c26621084f60 (diff)
powerpc: Merge smp.c and smp.h
This also moves setup_cpu_maps to setup-common.c (calling it smp_setup_cpu_maps) and uses it on both 32-bit and 64-bit. Signed-off-by: Paul Mackerras <paulus@samba.org>
Diffstat (limited to 'arch/ppc64')
-rw-r--r--arch/ppc64/kernel/Makefile1
-rw-r--r--arch/ppc64/kernel/smp.c568
2 files changed, 0 insertions, 569 deletions
diff --git a/arch/ppc64/kernel/Makefile b/arch/ppc64/kernel/Makefile
index f597c2954b71..c441aebe7648 100644
--- a/arch/ppc64/kernel/Makefile
+++ b/arch/ppc64/kernel/Makefile
@@ -33,7 +33,6 @@ obj-$(CONFIG_PPC_PSERIES) += udbg_16550.o
33obj-$(CONFIG_KEXEC) += machine_kexec.o 33obj-$(CONFIG_KEXEC) += machine_kexec.o
34obj-$(CONFIG_EEH) += eeh.o 34obj-$(CONFIG_EEH) += eeh.o
35obj-$(CONFIG_PROC_FS) += proc_ppc64.o 35obj-$(CONFIG_PROC_FS) += proc_ppc64.o
36obj-$(CONFIG_SMP) += smp.o
37obj-$(CONFIG_MODULES) += module.o 36obj-$(CONFIG_MODULES) += module.o
38ifneq ($(CONFIG_PPC_MERGE),y) 37ifneq ($(CONFIG_PPC_MERGE),y)
39obj-$(CONFIG_MODULES) += ppc_ksyms.o 38obj-$(CONFIG_MODULES) += ppc_ksyms.o
diff --git a/arch/ppc64/kernel/smp.c b/arch/ppc64/kernel/smp.c
deleted file mode 100644
index 017c12919832..000000000000
--- a/arch/ppc64/kernel/smp.c
+++ /dev/null
@@ -1,568 +0,0 @@
1/*
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
20#include <linux/config.h>
21#include <linux/kernel.h>
22#include <linux/module.h>
23#include <linux/sched.h>
24#include <linux/smp.h>
25#include <linux/interrupt.h>
26#include <linux/delay.h>
27#include <linux/init.h>
28#include <linux/spinlock.h>
29#include <linux/cache.h>
30#include <linux/err.h>
31#include <linux/sysdev.h>
32#include <linux/cpu.h>
33#include <linux/notifier.h>
34
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>
42#include <asm/paca.h>
43#include <asm/time.h>
44#include <asm/machdep.h>
45#include <asm/cputable.h>
46#include <asm/system.h>
47#include <asm/abs_addr.h>
48#include <asm/mpic.h>
49
50#ifdef DEBUG
51#define DBG(fmt...) udbg_printf(fmt)
52#else
53#define DBG(fmt...)
54#endif
55
56cpumask_t cpu_possible_map = CPU_MASK_NONE;
57cpumask_t cpu_online_map = CPU_MASK_NONE;
58cpumask_t cpu_sibling_map[NR_CPUS] = { [0 ... NR_CPUS-1] = CPU_MASK_NONE };
59
60EXPORT_SYMBOL(cpu_online_map);
61EXPORT_SYMBOL(cpu_possible_map);
62
63struct smp_ops_t *smp_ops;
64
65static volatile unsigned int cpu_callin_map[NR_CPUS];
66
67void smp_call_function_interrupt(void);
68
69int smt_enabled_at_boot = 1;
70
71#ifdef CONFIG_MPIC
72int __init smp_mpic_probe(void)
73{
74 int nr_cpus;
75
76 DBG("smp_mpic_probe()...\n");
77
78 nr_cpus = cpus_weight(cpu_possible_map);
79
80 DBG("nr_cpus: %d\n", nr_cpus);
81
82 if (nr_cpus > 1)
83 mpic_request_ipis();
84
85 return nr_cpus;
86}
87
88void __devinit smp_mpic_setup_cpu(int cpu)
89{
90 mpic_setup_this_cpu();
91}
92
93void __devinit smp_generic_kick_cpu(int nr)
94{
95 BUG_ON(nr < 0 || nr >= NR_CPUS);
96
97 /*
98 * The processor is currently spinning, waiting for the
99 * cpu_start field to become non-zero After we set cpu_start,
100 * the processor will continue on to secondary_start
101 */
102 paca[nr].cpu_start = 1;
103 smp_mb();
104}
105
106#endif /* CONFIG_MPIC */
107
108void smp_message_recv(int msg, struct pt_regs *regs)
109{
110 switch(msg) {
111 case PPC_MSG_CALL_FUNCTION:
112 smp_call_function_interrupt();
113 break;
114 case PPC_MSG_RESCHEDULE:
115 /* XXX Do we have to do this? */
116 set_need_resched();
117 break;
118#if 0
119 case PPC_MSG_MIGRATE_TASK:
120 /* spare */
121 break;
122#endif
123#ifdef CONFIG_DEBUGGER
124 case PPC_MSG_DEBUGGER_BREAK:
125 debugger_ipi(regs);
126 break;
127#endif
128 default:
129 printk("SMP %d: smp_message_recv(): unknown msg %d\n",
130 smp_processor_id(), msg);
131 break;
132 }
133}
134
135void smp_send_reschedule(int cpu)
136{
137 smp_ops->message_pass(cpu, PPC_MSG_RESCHEDULE);
138}
139
140#ifdef CONFIG_DEBUGGER
141void smp_send_debugger_break(int cpu)
142{
143 smp_ops->message_pass(cpu, PPC_MSG_DEBUGGER_BREAK);
144}
145#endif
146
147static void stop_this_cpu(void *dummy)
148{
149 local_irq_disable();
150 while (1)
151 ;
152}
153
154void smp_send_stop(void)
155{
156 smp_call_function(stop_this_cpu, NULL, 1, 0);
157}
158
159/*
160 * Structure and data for smp_call_function(). This is designed to minimise
161 * static memory requirements. It also looks cleaner.
162 * Stolen from the i386 version.
163 */
164static __cacheline_aligned_in_smp DEFINE_SPINLOCK(call_lock);
165
166static struct call_data_struct {
167 void (*func) (void *info);
168 void *info;
169 atomic_t started;
170 atomic_t finished;
171 int wait;
172} *call_data;
173
174/* delay of at least 8 seconds on 1GHz cpu */
175#define SMP_CALL_TIMEOUT (1UL << (30 + 3))
176
177/*
178 * This function sends a 'generic call function' IPI to all other CPUs
179 * in the system.
180 *
181 * [SUMMARY] Run a function on all other CPUs.
182 * <func> The function to run. This must be fast and non-blocking.
183 * <info> An arbitrary pointer to pass to the function.
184 * <nonatomic> currently unused.
185 * <wait> If true, wait (atomically) until function has completed on other CPUs.
186 * [RETURNS] 0 on success, else a negative status code. Does not return until
187 * remote CPUs are nearly ready to execute <<func>> or are or have executed.
188 *
189 * You must not call this function with disabled interrupts or from a
190 * hardware interrupt handler or from a bottom half handler.
191 */
192int smp_call_function (void (*func) (void *info), void *info, int nonatomic,
193 int wait)
194{
195 struct call_data_struct data;
196 int ret = -1, cpus;
197 unsigned long timeout;
198
199 /* Can deadlock when called with interrupts disabled */
200 WARN_ON(irqs_disabled());
201
202 data.func = func;
203 data.info = info;
204 atomic_set(&data.started, 0);
205 data.wait = wait;
206 if (wait)
207 atomic_set(&data.finished, 0);
208
209 spin_lock(&call_lock);
210 /* Must grab online cpu count with preempt disabled, otherwise
211 * it can change. */
212 cpus = num_online_cpus() - 1;
213 if (!cpus) {
214 ret = 0;
215 goto out;
216 }
217
218 call_data = &data;
219 smp_wmb();
220 /* Send a message to all other CPUs and wait for them to respond */
221 smp_ops->message_pass(MSG_ALL_BUT_SELF, PPC_MSG_CALL_FUNCTION);
222
223 /* Wait for response */
224 timeout = SMP_CALL_TIMEOUT;
225 while (atomic_read(&data.started) != cpus) {
226 HMT_low();
227 if (--timeout == 0) {
228 printk("smp_call_function on cpu %d: other cpus not "
229 "responding (%d)\n", smp_processor_id(),
230 atomic_read(&data.started));
231 debugger(NULL);
232 goto out;
233 }
234 }
235
236 if (wait) {
237 timeout = SMP_CALL_TIMEOUT;
238 while (atomic_read(&data.finished) != cpus) {
239 HMT_low();
240 if (--timeout == 0) {
241 printk("smp_call_function on cpu %d: other "
242 "cpus not finishing (%d/%d)\n",
243 smp_processor_id(),
244 atomic_read(&data.finished),
245 atomic_read(&data.started));
246 debugger(NULL);
247 goto out;
248 }
249 }
250 }
251
252 ret = 0;
253
254out:
255 call_data = NULL;
256 HMT_medium();
257 spin_unlock(&call_lock);
258 return ret;
259}
260
261EXPORT_SYMBOL(smp_call_function);
262
263void smp_call_function_interrupt(void)
264{
265 void (*func) (void *info);
266 void *info;
267 int wait;
268
269 /* call_data will be NULL if the sender timed out while
270 * waiting on us to receive the call.
271 */
272 if (!call_data)
273 return;
274
275 func = call_data->func;
276 info = call_data->info;
277 wait = call_data->wait;
278
279 if (!wait)
280 smp_mb__before_atomic_inc();
281
282 /*
283 * Notify initiating CPU that I've grabbed the data and am
284 * about to execute the function
285 */
286 atomic_inc(&call_data->started);
287 /*
288 * At this point the info structure may be out of scope unless wait==1
289 */
290 (*func)(info);
291 if (wait) {
292 smp_mb__before_atomic_inc();
293 atomic_inc(&call_data->finished);
294 }
295}
296
297extern struct gettimeofday_struct do_gtod;
298
299struct thread_info *current_set[NR_CPUS];
300
301DECLARE_PER_CPU(unsigned int, pvr);
302
303static void __devinit smp_store_cpu_info(int id)
304{
305 per_cpu(pvr, id) = mfspr(SPRN_PVR);
306}
307
308static void __init smp_create_idle(unsigned int cpu)
309{
310 struct task_struct *p;
311
312 /* create a process for the processor */
313 p = fork_idle(cpu);
314 if (IS_ERR(p))
315 panic("failed fork for CPU %u: %li", cpu, PTR_ERR(p));
316 paca[cpu].__current = p;
317 current_set[cpu] = p->thread_info;
318}
319
320void __init smp_prepare_cpus(unsigned int max_cpus)
321{
322 unsigned int cpu;
323
324 DBG("smp_prepare_cpus\n");
325
326 /*
327 * setup_cpu may need to be called on the boot cpu. We havent
328 * spun any cpus up but lets be paranoid.
329 */
330 BUG_ON(boot_cpuid != smp_processor_id());
331
332 /* Fixup boot cpu */
333 smp_store_cpu_info(boot_cpuid);
334 cpu_callin_map[boot_cpuid] = 1;
335
336#ifndef CONFIG_PPC_ISERIES
337 paca[boot_cpuid].next_jiffy_update_tb = tb_last_stamp = get_tb();
338
339 /*
340 * Should update do_gtod.stamp_xsec.
341 * For now we leave it which means the time can be some
342 * number of msecs off until someone does a settimeofday()
343 */
344 do_gtod.varp->tb_orig_stamp = tb_last_stamp;
345 systemcfg->tb_orig_stamp = tb_last_stamp;
346#endif
347
348 max_cpus = smp_ops->probe();
349
350 smp_space_timers(max_cpus);
351
352 for_each_cpu(cpu)
353 if (cpu != boot_cpuid)
354 smp_create_idle(cpu);
355}
356
357void __devinit smp_prepare_boot_cpu(void)
358{
359 BUG_ON(smp_processor_id() != boot_cpuid);
360
361 cpu_set(boot_cpuid, cpu_online_map);
362
363 paca[boot_cpuid].__current = current;
364 current_set[boot_cpuid] = current->thread_info;
365}
366
367#ifdef CONFIG_HOTPLUG_CPU
368/* State of each CPU during hotplug phases */
369DEFINE_PER_CPU(int, cpu_state) = { 0 };
370
371int generic_cpu_disable(void)
372{
373 unsigned int cpu = smp_processor_id();
374
375 if (cpu == boot_cpuid)
376 return -EBUSY;
377
378 systemcfg->processorCount--;
379 cpu_clear(cpu, cpu_online_map);
380 fixup_irqs(cpu_online_map);
381 return 0;
382}
383
384int generic_cpu_enable(unsigned int cpu)
385{
386 /* Do the normal bootup if we haven't
387 * already bootstrapped. */
388 if (system_state != SYSTEM_RUNNING)
389 return -ENOSYS;
390
391 /* get the target out of it's holding state */
392 per_cpu(cpu_state, cpu) = CPU_UP_PREPARE;
393 smp_wmb();
394
395 while (!cpu_online(cpu))
396 cpu_relax();
397
398 fixup_irqs(cpu_online_map);
399 /* counter the irq disable in fixup_irqs */
400 local_irq_enable();
401 return 0;
402}
403
404void generic_cpu_die(unsigned int cpu)
405{
406 int i;
407
408 for (i = 0; i < 100; i++) {
409 smp_rmb();
410 if (per_cpu(cpu_state, cpu) == CPU_DEAD)
411 return;
412 msleep(100);
413 }
414 printk(KERN_ERR "CPU%d didn't die...\n", cpu);
415}
416
417void generic_mach_cpu_die(void)
418{
419 unsigned int cpu;
420
421 local_irq_disable();
422 cpu = smp_processor_id();
423 printk(KERN_DEBUG "CPU%d offline\n", cpu);
424 __get_cpu_var(cpu_state) = CPU_DEAD;
425 smp_wmb();
426 while (__get_cpu_var(cpu_state) != CPU_UP_PREPARE)
427 cpu_relax();
428
429 flush_tlb_pending();
430 cpu_set(cpu, cpu_online_map);
431 local_irq_enable();
432}
433#endif
434
435static int __devinit cpu_enable(unsigned int cpu)
436{
437 if (smp_ops->cpu_enable)
438 return smp_ops->cpu_enable(cpu);
439
440 return -ENOSYS;
441}
442
443int __devinit __cpu_up(unsigned int cpu)
444{
445 int c;
446
447 if (!cpu_enable(cpu))
448 return 0;
449
450 if (smp_ops->cpu_bootable && !smp_ops->cpu_bootable(cpu))
451 return -EINVAL;
452
453 paca[cpu].default_decr = tb_ticks_per_jiffy;
454
455 /* Make sure callin-map entry is 0 (can be leftover a CPU
456 * hotplug
457 */
458 cpu_callin_map[cpu] = 0;
459
460 /* The information for processor bringup must
461 * be written out to main store before we release
462 * the processor.
463 */
464 smp_mb();
465
466 /* wake up cpus */
467 DBG("smp: kicking cpu %d\n", cpu);
468 smp_ops->kick_cpu(cpu);
469
470 /*
471 * wait to see if the cpu made a callin (is actually up).
472 * use this value that I found through experimentation.
473 * -- Cort
474 */
475 if (system_state < SYSTEM_RUNNING)
476 for (c = 5000; c && !cpu_callin_map[cpu]; c--)
477 udelay(100);
478#ifdef CONFIG_HOTPLUG_CPU
479 else
480 /*
481 * CPUs can take much longer to come up in the
482 * hotplug case. Wait five seconds.
483 */
484 for (c = 25; c && !cpu_callin_map[cpu]; c--) {
485 msleep(200);
486 }
487#endif
488
489 if (!cpu_callin_map[cpu]) {
490 printk("Processor %u is stuck.\n", cpu);
491 return -ENOENT;
492 }
493
494 printk("Processor %u found.\n", cpu);
495
496 if (smp_ops->give_timebase)
497 smp_ops->give_timebase();
498
499 /* Wait until cpu puts itself in the online map */
500 while (!cpu_online(cpu))
501 cpu_relax();
502
503 return 0;
504}
505
506
507/* Activate a secondary processor. */
508int __devinit start_secondary(void *unused)
509{
510 unsigned int cpu = smp_processor_id();
511
512 atomic_inc(&init_mm.mm_count);
513 current->active_mm = &init_mm;
514
515 smp_store_cpu_info(cpu);
516 set_dec(paca[cpu].default_decr);
517 cpu_callin_map[cpu] = 1;
518
519 smp_ops->setup_cpu(cpu);
520 if (smp_ops->take_timebase)
521 smp_ops->take_timebase();
522
523 spin_lock(&call_lock);
524 cpu_set(cpu, cpu_online_map);
525 spin_unlock(&call_lock);
526
527 local_irq_enable();
528
529 cpu_idle();
530 return 0;
531}
532
533int setup_profiling_timer(unsigned int multiplier)
534{
535 return 0;
536}
537
538void __init smp_cpus_done(unsigned int max_cpus)
539{
540 cpumask_t old_mask;
541
542 /* We want the setup_cpu() here to be called from CPU 0, but our
543 * init thread may have been "borrowed" by another CPU in the meantime
544 * se we pin us down to CPU 0 for a short while
545 */
546 old_mask = current->cpus_allowed;
547 set_cpus_allowed(current, cpumask_of_cpu(boot_cpuid));
548
549 smp_ops->setup_cpu(boot_cpuid);
550
551 set_cpus_allowed(current, old_mask);
552}
553
554#ifdef CONFIG_HOTPLUG_CPU
555int __cpu_disable(void)
556{
557 if (smp_ops->cpu_disable)
558 return smp_ops->cpu_disable();
559
560 return -ENOSYS;
561}
562
563void __cpu_die(unsigned int cpu)
564{
565 if (smp_ops->cpu_die)
566 smp_ops->cpu_die(cpu);
567}
568#endif