powerpc: Remove call sites of MSG_ALL_BUT_SELF
[linux-2.6.git] / arch / powerpc / kernel / smp.c
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/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>
33 #include <linux/topology.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/time.h>
43 #include <asm/machdep.h>
44 #include <asm/cputhreads.h>
45 #include <asm/cputable.h>
46 #include <asm/system.h>
47 #include <asm/mpic.h>
48 #include <asm/vdso_datapage.h>
49 #ifdef CONFIG_PPC64
50 #include <asm/paca.h>
51 #endif
52
53 #ifdef DEBUG
54 #include <asm/udbg.h>
55 #define DBG(fmt...) udbg_printf(fmt)
56 #else
57 #define DBG(fmt...)
58 #endif
59
60
61 /* Store all idle threads, this can be reused instead of creating
62 * a new thread. Also avoids complicated thread destroy functionality
63 * for idle threads.
64 */
65 #ifdef CONFIG_HOTPLUG_CPU
66 /*
67  * Needed only for CONFIG_HOTPLUG_CPU because __cpuinitdata is
68  * removed after init for !CONFIG_HOTPLUG_CPU.
69  */
70 static DEFINE_PER_CPU(struct task_struct *, idle_thread_array);
71 #define get_idle_for_cpu(x)      (per_cpu(idle_thread_array, x))
72 #define set_idle_for_cpu(x, p)   (per_cpu(idle_thread_array, x) = (p))
73 #else
74 static struct task_struct *idle_thread_array[NR_CPUS] __cpuinitdata ;
75 #define get_idle_for_cpu(x)      (idle_thread_array[(x)])
76 #define set_idle_for_cpu(x, p)   (idle_thread_array[(x)] = (p))
77 #endif
78
79 struct thread_info *secondary_ti;
80
81 DEFINE_PER_CPU(cpumask_var_t, cpu_sibling_map);
82 DEFINE_PER_CPU(cpumask_var_t, cpu_core_map);
83
84 EXPORT_PER_CPU_SYMBOL(cpu_sibling_map);
85 EXPORT_PER_CPU_SYMBOL(cpu_core_map);
86
87 /* SMP operations for this machine */
88 struct smp_ops_t *smp_ops;
89
90 /* Can't be static due to PowerMac hackery */
91 volatile unsigned int cpu_callin_map[NR_CPUS];
92
93 int smt_enabled_at_boot = 1;
94
95 static void (*crash_ipi_function_ptr)(struct pt_regs *) = NULL;
96
97 #ifdef CONFIG_PPC64
98 int __devinit smp_generic_kick_cpu(int nr)
99 {
100         BUG_ON(nr < 0 || nr >= NR_CPUS);
101
102         /*
103          * The processor is currently spinning, waiting for the
104          * cpu_start field to become non-zero After we set cpu_start,
105          * the processor will continue on to secondary_start
106          */
107         paca[nr].cpu_start = 1;
108         smp_mb();
109
110         return 0;
111 }
112 #endif
113
114 void smp_message_recv(int msg)
115 {
116         switch(msg) {
117         case PPC_MSG_CALL_FUNCTION:
118                 generic_smp_call_function_interrupt();
119                 break;
120         case PPC_MSG_RESCHEDULE:
121                 /* we notice need_resched on exit */
122                 break;
123         case PPC_MSG_CALL_FUNC_SINGLE:
124                 generic_smp_call_function_single_interrupt();
125                 break;
126         case PPC_MSG_DEBUGGER_BREAK:
127                 if (crash_ipi_function_ptr) {
128                         crash_ipi_function_ptr(get_irq_regs());
129                         break;
130                 }
131 #ifdef CONFIG_DEBUGGER
132                 debugger_ipi(get_irq_regs());
133                 break;
134 #endif /* CONFIG_DEBUGGER */
135                 /* FALLTHROUGH */
136         default:
137                 printk("SMP %d: smp_message_recv(): unknown msg %d\n",
138                        smp_processor_id(), msg);
139                 break;
140         }
141 }
142
143 static irqreturn_t call_function_action(int irq, void *data)
144 {
145         generic_smp_call_function_interrupt();
146         return IRQ_HANDLED;
147 }
148
149 static irqreturn_t reschedule_action(int irq, void *data)
150 {
151         /* we just need the return path side effect of checking need_resched */
152         return IRQ_HANDLED;
153 }
154
155 static irqreturn_t call_function_single_action(int irq, void *data)
156 {
157         generic_smp_call_function_single_interrupt();
158         return IRQ_HANDLED;
159 }
160
161 static irqreturn_t debug_ipi_action(int irq, void *data)
162 {
163         smp_message_recv(PPC_MSG_DEBUGGER_BREAK);
164         return IRQ_HANDLED;
165 }
166
167 static irq_handler_t smp_ipi_action[] = {
168         [PPC_MSG_CALL_FUNCTION] =  call_function_action,
169         [PPC_MSG_RESCHEDULE] = reschedule_action,
170         [PPC_MSG_CALL_FUNC_SINGLE] = call_function_single_action,
171         [PPC_MSG_DEBUGGER_BREAK] = debug_ipi_action,
172 };
173
174 const char *smp_ipi_name[] = {
175         [PPC_MSG_CALL_FUNCTION] =  "ipi call function",
176         [PPC_MSG_RESCHEDULE] = "ipi reschedule",
177         [PPC_MSG_CALL_FUNC_SINGLE] = "ipi call function single",
178         [PPC_MSG_DEBUGGER_BREAK] = "ipi debugger",
179 };
180
181 /* optional function to request ipi, for controllers with >= 4 ipis */
182 int smp_request_message_ipi(int virq, int msg)
183 {
184         int err;
185
186         if (msg < 0 || msg > PPC_MSG_DEBUGGER_BREAK) {
187                 return -EINVAL;
188         }
189 #if !defined(CONFIG_DEBUGGER) && !defined(CONFIG_KEXEC)
190         if (msg == PPC_MSG_DEBUGGER_BREAK) {
191                 return 1;
192         }
193 #endif
194         err = request_irq(virq, smp_ipi_action[msg], IRQF_DISABLED|IRQF_PERCPU,
195                           smp_ipi_name[msg], 0);
196         WARN(err < 0, "unable to request_irq %d for %s (rc %d)\n",
197                 virq, smp_ipi_name[msg], err);
198
199         return err;
200 }
201
202 void smp_send_reschedule(int cpu)
203 {
204         if (likely(smp_ops))
205                 smp_ops->message_pass(cpu, PPC_MSG_RESCHEDULE);
206 }
207
208 void arch_send_call_function_single_ipi(int cpu)
209 {
210         smp_ops->message_pass(cpu, PPC_MSG_CALL_FUNC_SINGLE);
211 }
212
213 void arch_send_call_function_ipi_mask(const struct cpumask *mask)
214 {
215         unsigned int cpu;
216
217         for_each_cpu(cpu, mask)
218                 smp_ops->message_pass(cpu, PPC_MSG_CALL_FUNCTION);
219 }
220
221 #if defined(CONFIG_DEBUGGER) || defined(CONFIG_KEXEC)
222 void smp_send_debugger_break(void)
223 {
224         int cpu;
225         int me = raw_smp_processor_id();
226
227         if (unlikely(!smp_ops))
228                 return;
229
230         for_each_online_cpu(cpu)
231                 if (cpu != me)
232                         smp_ops->message_pass(cpu, PPC_MSG_DEBUGGER_BREAK);
233 }
234 #endif
235
236 #ifdef CONFIG_KEXEC
237 void crash_send_ipi(void (*crash_ipi_callback)(struct pt_regs *))
238 {
239         crash_ipi_function_ptr = crash_ipi_callback;
240         if (crash_ipi_callback) {
241                 mb();
242                 smp_send_debugger_break();
243         }
244 }
245 #endif
246
247 static void stop_this_cpu(void *dummy)
248 {
249         /* Remove this CPU */
250         set_cpu_online(smp_processor_id(), false);
251
252         local_irq_disable();
253         while (1)
254                 ;
255 }
256
257 void smp_send_stop(void)
258 {
259         smp_call_function(stop_this_cpu, NULL, 0);
260 }
261
262 struct thread_info *current_set[NR_CPUS];
263
264 static void __devinit smp_store_cpu_info(int id)
265 {
266         per_cpu(cpu_pvr, id) = mfspr(SPRN_PVR);
267 }
268
269 void __init smp_prepare_cpus(unsigned int max_cpus)
270 {
271         unsigned int cpu;
272
273         DBG("smp_prepare_cpus\n");
274
275         /* 
276          * setup_cpu may need to be called on the boot cpu. We havent
277          * spun any cpus up but lets be paranoid.
278          */
279         BUG_ON(boot_cpuid != smp_processor_id());
280
281         /* Fixup boot cpu */
282         smp_store_cpu_info(boot_cpuid);
283         cpu_callin_map[boot_cpuid] = 1;
284
285         for_each_possible_cpu(cpu) {
286                 zalloc_cpumask_var_node(&per_cpu(cpu_sibling_map, cpu),
287                                         GFP_KERNEL, cpu_to_node(cpu));
288                 zalloc_cpumask_var_node(&per_cpu(cpu_core_map, cpu),
289                                         GFP_KERNEL, cpu_to_node(cpu));
290         }
291
292         cpumask_set_cpu(boot_cpuid, cpu_sibling_mask(boot_cpuid));
293         cpumask_set_cpu(boot_cpuid, cpu_core_mask(boot_cpuid));
294
295         if (smp_ops)
296                 if (smp_ops->probe)
297                         max_cpus = smp_ops->probe();
298                 else
299                         max_cpus = NR_CPUS;
300         else
301                 max_cpus = 1;
302 }
303
304 void __devinit smp_prepare_boot_cpu(void)
305 {
306         BUG_ON(smp_processor_id() != boot_cpuid);
307 #ifdef CONFIG_PPC64
308         paca[boot_cpuid].__current = current;
309 #endif
310         current_set[boot_cpuid] = task_thread_info(current);
311 }
312
313 #ifdef CONFIG_HOTPLUG_CPU
314 /* State of each CPU during hotplug phases */
315 static DEFINE_PER_CPU(int, cpu_state) = { 0 };
316
317 int generic_cpu_disable(void)
318 {
319         unsigned int cpu = smp_processor_id();
320
321         if (cpu == boot_cpuid)
322                 return -EBUSY;
323
324         set_cpu_online(cpu, false);
325 #ifdef CONFIG_PPC64
326         vdso_data->processorCount--;
327 #endif
328         migrate_irqs();
329         return 0;
330 }
331
332 void generic_cpu_die(unsigned int cpu)
333 {
334         int i;
335
336         for (i = 0; i < 100; i++) {
337                 smp_rmb();
338                 if (per_cpu(cpu_state, cpu) == CPU_DEAD)
339                         return;
340                 msleep(100);
341         }
342         printk(KERN_ERR "CPU%d didn't die...\n", cpu);
343 }
344
345 void generic_mach_cpu_die(void)
346 {
347         unsigned int cpu;
348
349         local_irq_disable();
350         idle_task_exit();
351         cpu = smp_processor_id();
352         printk(KERN_DEBUG "CPU%d offline\n", cpu);
353         __get_cpu_var(cpu_state) = CPU_DEAD;
354         smp_wmb();
355         while (__get_cpu_var(cpu_state) != CPU_UP_PREPARE)
356                 cpu_relax();
357 }
358
359 void generic_set_cpu_dead(unsigned int cpu)
360 {
361         per_cpu(cpu_state, cpu) = CPU_DEAD;
362 }
363 #endif
364
365 struct create_idle {
366         struct work_struct work;
367         struct task_struct *idle;
368         struct completion done;
369         int cpu;
370 };
371
372 static void __cpuinit do_fork_idle(struct work_struct *work)
373 {
374         struct create_idle *c_idle =
375                 container_of(work, struct create_idle, work);
376
377         c_idle->idle = fork_idle(c_idle->cpu);
378         complete(&c_idle->done);
379 }
380
381 static int __cpuinit create_idle(unsigned int cpu)
382 {
383         struct thread_info *ti;
384         struct create_idle c_idle = {
385                 .cpu    = cpu,
386                 .done   = COMPLETION_INITIALIZER_ONSTACK(c_idle.done),
387         };
388         INIT_WORK_ONSTACK(&c_idle.work, do_fork_idle);
389
390         c_idle.idle = get_idle_for_cpu(cpu);
391
392         /* We can't use kernel_thread since we must avoid to
393          * reschedule the child. We use a workqueue because
394          * we want to fork from a kernel thread, not whatever
395          * userspace process happens to be trying to online us.
396          */
397         if (!c_idle.idle) {
398                 schedule_work(&c_idle.work);
399                 wait_for_completion(&c_idle.done);
400         } else
401                 init_idle(c_idle.idle, cpu);
402         if (IS_ERR(c_idle.idle)) {              
403                 pr_err("Failed fork for CPU %u: %li", cpu, PTR_ERR(c_idle.idle));
404                 return PTR_ERR(c_idle.idle);
405         }
406         ti = task_thread_info(c_idle.idle);
407
408 #ifdef CONFIG_PPC64
409         paca[cpu].__current = c_idle.idle;
410         paca[cpu].kstack = (unsigned long)ti + THREAD_SIZE - STACK_FRAME_OVERHEAD;
411 #endif
412         ti->cpu = cpu;
413         current_set[cpu] = ti;
414
415         return 0;
416 }
417
418 int __cpuinit __cpu_up(unsigned int cpu)
419 {
420         int rc, c;
421
422         secondary_ti = current_set[cpu];
423
424         if (smp_ops == NULL ||
425             (smp_ops->cpu_bootable && !smp_ops->cpu_bootable(cpu)))
426                 return -EINVAL;
427
428         /* Make sure we have an idle thread */
429         rc = create_idle(cpu);
430         if (rc)
431                 return rc;
432
433         /* Make sure callin-map entry is 0 (can be leftover a CPU
434          * hotplug
435          */
436         cpu_callin_map[cpu] = 0;
437
438         /* The information for processor bringup must
439          * be written out to main store before we release
440          * the processor.
441          */
442         smp_mb();
443
444         /* wake up cpus */
445         DBG("smp: kicking cpu %d\n", cpu);
446         rc = smp_ops->kick_cpu(cpu);
447         if (rc) {
448                 pr_err("smp: failed starting cpu %d (rc %d)\n", cpu, rc);
449                 return rc;
450         }
451
452         /*
453          * wait to see if the cpu made a callin (is actually up).
454          * use this value that I found through experimentation.
455          * -- Cort
456          */
457         if (system_state < SYSTEM_RUNNING)
458                 for (c = 50000; c && !cpu_callin_map[cpu]; c--)
459                         udelay(100);
460 #ifdef CONFIG_HOTPLUG_CPU
461         else
462                 /*
463                  * CPUs can take much longer to come up in the
464                  * hotplug case.  Wait five seconds.
465                  */
466                 for (c = 5000; c && !cpu_callin_map[cpu]; c--)
467                         msleep(1);
468 #endif
469
470         if (!cpu_callin_map[cpu]) {
471                 printk(KERN_ERR "Processor %u is stuck.\n", cpu);
472                 return -ENOENT;
473         }
474
475         DBG("Processor %u found.\n", cpu);
476
477         if (smp_ops->give_timebase)
478                 smp_ops->give_timebase();
479
480         /* Wait until cpu puts itself in the online map */
481         while (!cpu_online(cpu))
482                 cpu_relax();
483
484         return 0;
485 }
486
487 /* Return the value of the reg property corresponding to the given
488  * logical cpu.
489  */
490 int cpu_to_core_id(int cpu)
491 {
492         struct device_node *np;
493         const int *reg;
494         int id = -1;
495
496         np = of_get_cpu_node(cpu, NULL);
497         if (!np)
498                 goto out;
499
500         reg = of_get_property(np, "reg", NULL);
501         if (!reg)
502                 goto out;
503
504         id = *reg;
505 out:
506         of_node_put(np);
507         return id;
508 }
509
510 /* Helper routines for cpu to core mapping */
511 int cpu_core_index_of_thread(int cpu)
512 {
513         return cpu >> threads_shift;
514 }
515 EXPORT_SYMBOL_GPL(cpu_core_index_of_thread);
516
517 int cpu_first_thread_of_core(int core)
518 {
519         return core << threads_shift;
520 }
521 EXPORT_SYMBOL_GPL(cpu_first_thread_of_core);
522
523 /* Must be called when no change can occur to cpu_present_mask,
524  * i.e. during cpu online or offline.
525  */
526 static struct device_node *cpu_to_l2cache(int cpu)
527 {
528         struct device_node *np;
529         struct device_node *cache;
530
531         if (!cpu_present(cpu))
532                 return NULL;
533
534         np = of_get_cpu_node(cpu, NULL);
535         if (np == NULL)
536                 return NULL;
537
538         cache = of_find_next_cache_node(np);
539
540         of_node_put(np);
541
542         return cache;
543 }
544
545 /* Activate a secondary processor. */
546 void __devinit start_secondary(void *unused)
547 {
548         unsigned int cpu = smp_processor_id();
549         struct device_node *l2_cache;
550         int i, base;
551
552         atomic_inc(&init_mm.mm_count);
553         current->active_mm = &init_mm;
554
555         smp_store_cpu_info(cpu);
556         set_dec(tb_ticks_per_jiffy);
557         preempt_disable();
558         cpu_callin_map[cpu] = 1;
559
560         if (smp_ops->setup_cpu)
561                 smp_ops->setup_cpu(cpu);
562         if (smp_ops->take_timebase)
563                 smp_ops->take_timebase();
564
565         secondary_cpu_time_init();
566
567 #ifdef CONFIG_PPC64
568         if (system_state == SYSTEM_RUNNING)
569                 vdso_data->processorCount++;
570 #endif
571         ipi_call_lock();
572         notify_cpu_starting(cpu);
573         set_cpu_online(cpu, true);
574         /* Update sibling maps */
575         base = cpu_first_thread_sibling(cpu);
576         for (i = 0; i < threads_per_core; i++) {
577                 if (cpu_is_offline(base + i))
578                         continue;
579                 cpumask_set_cpu(cpu, cpu_sibling_mask(base + i));
580                 cpumask_set_cpu(base + i, cpu_sibling_mask(cpu));
581
582                 /* cpu_core_map should be a superset of
583                  * cpu_sibling_map even if we don't have cache
584                  * information, so update the former here, too.
585                  */
586                 cpumask_set_cpu(cpu, cpu_core_mask(base + i));
587                 cpumask_set_cpu(base + i, cpu_core_mask(cpu));
588         }
589         l2_cache = cpu_to_l2cache(cpu);
590         for_each_online_cpu(i) {
591                 struct device_node *np = cpu_to_l2cache(i);
592                 if (!np)
593                         continue;
594                 if (np == l2_cache) {
595                         cpumask_set_cpu(cpu, cpu_core_mask(i));
596                         cpumask_set_cpu(i, cpu_core_mask(cpu));
597                 }
598                 of_node_put(np);
599         }
600         of_node_put(l2_cache);
601         ipi_call_unlock();
602
603         local_irq_enable();
604
605         cpu_idle();
606
607         BUG();
608 }
609
610 int setup_profiling_timer(unsigned int multiplier)
611 {
612         return 0;
613 }
614
615 void __init smp_cpus_done(unsigned int max_cpus)
616 {
617         cpumask_var_t old_mask;
618
619         /* We want the setup_cpu() here to be called from CPU 0, but our
620          * init thread may have been "borrowed" by another CPU in the meantime
621          * se we pin us down to CPU 0 for a short while
622          */
623         alloc_cpumask_var(&old_mask, GFP_NOWAIT);
624         cpumask_copy(old_mask, tsk_cpus_allowed(current));
625         set_cpus_allowed_ptr(current, cpumask_of(boot_cpuid));
626         
627         if (smp_ops && smp_ops->setup_cpu)
628                 smp_ops->setup_cpu(boot_cpuid);
629
630         set_cpus_allowed_ptr(current, old_mask);
631
632         free_cpumask_var(old_mask);
633
634         if (smp_ops && smp_ops->bringup_done)
635                 smp_ops->bringup_done();
636
637         dump_numa_cpu_topology();
638
639 }
640
641 int arch_sd_sibling_asym_packing(void)
642 {
643         if (cpu_has_feature(CPU_FTR_ASYM_SMT)) {
644                 printk_once(KERN_INFO "Enabling Asymmetric SMT scheduling\n");
645                 return SD_ASYM_PACKING;
646         }
647         return 0;
648 }
649
650 #ifdef CONFIG_HOTPLUG_CPU
651 int __cpu_disable(void)
652 {
653         struct device_node *l2_cache;
654         int cpu = smp_processor_id();
655         int base, i;
656         int err;
657
658         if (!smp_ops->cpu_disable)
659                 return -ENOSYS;
660
661         err = smp_ops->cpu_disable();
662         if (err)
663                 return err;
664
665         /* Update sibling maps */
666         base = cpu_first_thread_sibling(cpu);
667         for (i = 0; i < threads_per_core; i++) {
668                 cpumask_clear_cpu(cpu, cpu_sibling_mask(base + i));
669                 cpumask_clear_cpu(base + i, cpu_sibling_mask(cpu));
670                 cpumask_clear_cpu(cpu, cpu_core_mask(base + i));
671                 cpumask_clear_cpu(base + i, cpu_core_mask(cpu));
672         }
673
674         l2_cache = cpu_to_l2cache(cpu);
675         for_each_present_cpu(i) {
676                 struct device_node *np = cpu_to_l2cache(i);
677                 if (!np)
678                         continue;
679                 if (np == l2_cache) {
680                         cpumask_clear_cpu(cpu, cpu_core_mask(i));
681                         cpumask_clear_cpu(i, cpu_core_mask(cpu));
682                 }
683                 of_node_put(np);
684         }
685         of_node_put(l2_cache);
686
687
688         return 0;
689 }
690
691 void __cpu_die(unsigned int cpu)
692 {
693         if (smp_ops->cpu_die)
694                 smp_ops->cpu_die(cpu);
695 }
696
697 static DEFINE_MUTEX(powerpc_cpu_hotplug_driver_mutex);
698
699 void cpu_hotplug_driver_lock()
700 {
701         mutex_lock(&powerpc_cpu_hotplug_driver_mutex);
702 }
703
704 void cpu_hotplug_driver_unlock()
705 {
706         mutex_unlock(&powerpc_cpu_hotplug_driver_mutex);
707 }
708
709 void cpu_die(void)
710 {
711         if (ppc_md.cpu_die)
712                 ppc_md.cpu_die();
713
714         /* If we return, we re-enter start_secondary */
715         start_secondary_resume();
716 }
717
718 #endif