Merge git://git.kernel.org/pub/scm/linux/kernel/git/sam/kbuild
[linux-2.6] / arch / sh / kernel / smp.c
1 /*
2  * arch/sh/kernel/smp.c
3  *
4  * SMP support for the SuperH processors.
5  *
6  * Copyright (C) 2002, 2003 Paul Mundt
7  *
8  * This program is free software; you can redistribute it and/or modify it
9  * under the terms of the GNU General Public License as published by the
10  * Free Software Foundation; either version 2 of the License, or (at your
11  * option) any later version.
12  */
13 #include <linux/cache.h>
14 #include <linux/cpumask.h>
15 #include <linux/delay.h>
16 #include <linux/init.h>
17 #include <linux/interrupt.h>
18 #include <linux/spinlock.h>
19 #include <linux/threads.h>
20 #include <linux/module.h>
21 #include <linux/time.h>
22 #include <linux/timex.h>
23 #include <linux/sched.h>
24 #include <linux/module.h>
25
26 #include <asm/atomic.h>
27 #include <asm/processor.h>
28 #include <asm/system.h>
29 #include <asm/mmu_context.h>
30 #include <asm/smp.h>
31
32 /*
33  * This was written with the Sega Saturn (SMP SH-2 7604) in mind,
34  * but is designed to be usable regardless if there's an MMU
35  * present or not.
36  */
37 struct sh_cpuinfo cpu_data[NR_CPUS];
38
39 extern void per_cpu_trap_init(void);
40
41 cpumask_t cpu_possible_map;
42 EXPORT_SYMBOL(cpu_possible_map);
43
44 cpumask_t cpu_online_map;
45 static atomic_t cpus_booted = ATOMIC_INIT(0);
46
47 /* These are defined by the board-specific code. */
48
49 /*
50  * Cause the function described by call_data to be executed on the passed
51  * cpu.  When the function has finished, increment the finished field of
52  * call_data.
53  */
54 void __smp_send_ipi(unsigned int cpu, unsigned int action);
55
56 /*
57  * Find the number of available processors
58  */
59 unsigned int __smp_probe_cpus(void);
60
61 /*
62  * Start a particular processor
63  */
64 void __smp_slave_init(unsigned int cpu);
65
66 /*
67  * Run specified function on a particular processor.
68  */
69 void __smp_call_function(unsigned int cpu);
70
71 static inline void __init smp_store_cpu_info(unsigned int cpu)
72 {
73         cpu_data[cpu].loops_per_jiffy = loops_per_jiffy;
74 }
75
76 void __init smp_prepare_cpus(unsigned int max_cpus)
77 {
78         unsigned int cpu = smp_processor_id();
79         int i;
80
81         atomic_set(&cpus_booted, 1);
82         smp_store_cpu_info(cpu);
83         
84         for (i = 0; i < __smp_probe_cpus(); i++)
85                 cpu_set(i, cpu_possible_map);
86 }
87
88 void __devinit smp_prepare_boot_cpu(void)
89 {
90         unsigned int cpu = smp_processor_id();
91
92         cpu_set(cpu, cpu_online_map);
93         cpu_set(cpu, cpu_possible_map);
94 }
95
96 int __cpu_up(unsigned int cpu)
97 {
98         struct task_struct *tsk;
99
100         tsk = fork_idle(cpu);
101
102         if (IS_ERR(tsk))
103                 panic("Failed forking idle task for cpu %d\n", cpu);
104         
105         task_thread_info(tsk)->cpu = cpu;
106
107         cpu_set(cpu, cpu_online_map);
108
109         return 0;
110 }
111
112 int start_secondary(void *unused)
113 {
114         unsigned int cpu;
115
116         cpu = smp_processor_id();
117
118         atomic_inc(&init_mm.mm_count);
119         current->active_mm = &init_mm;
120
121         smp_store_cpu_info(cpu);
122
123         __smp_slave_init(cpu);
124         preempt_disable();
125         per_cpu_trap_init();
126         
127         atomic_inc(&cpus_booted);
128
129         cpu_idle();
130         return 0;
131 }
132
133 void __init smp_cpus_done(unsigned int max_cpus)
134 {
135         smp_mb();
136 }
137
138 void smp_send_reschedule(int cpu)
139 {
140         __smp_send_ipi(cpu, SMP_MSG_RESCHEDULE);
141 }
142
143 static void stop_this_cpu(void *unused)
144 {
145         cpu_clear(smp_processor_id(), cpu_online_map);
146         local_irq_disable();
147
148         for (;;)
149                 cpu_relax();
150 }
151
152 void smp_send_stop(void)
153 {
154         smp_call_function(stop_this_cpu, 0, 1, 0);
155 }
156
157
158 struct smp_fn_call_struct smp_fn_call = {
159         .lock           = SPIN_LOCK_UNLOCKED,
160         .finished       = ATOMIC_INIT(0),
161 };
162
163 /*
164  * The caller of this wants the passed function to run on every cpu.  If wait
165  * is set, wait until all cpus have finished the function before returning.
166  * The lock is here to protect the call structure.
167  * You must not call this function with disabled interrupts or from a
168  * hardware interrupt handler or from a bottom half handler.
169  */
170 int smp_call_function(void (*func)(void *info), void *info, int retry, int wait)
171 {
172         unsigned int nr_cpus = atomic_read(&cpus_booted);
173         int i;
174
175         if (nr_cpus < 2)
176                 return 0;
177
178         /* Can deadlock when called with interrupts disabled */
179         WARN_ON(irqs_disabled());
180
181         spin_lock(&smp_fn_call.lock);
182
183         atomic_set(&smp_fn_call.finished, 0);
184         smp_fn_call.fn = func;
185         smp_fn_call.data = info;
186
187         for (i = 0; i < nr_cpus; i++)
188                 if (i != smp_processor_id())
189                         __smp_call_function(i);
190
191         if (wait)
192                 while (atomic_read(&smp_fn_call.finished) != (nr_cpus - 1));
193
194         spin_unlock(&smp_fn_call.lock);
195
196         return 0;
197 }
198
199 /* Not really SMP stuff ... */
200 int setup_profiling_timer(unsigned int multiplier)
201 {
202         return 0;
203 }
204