[PATCH] sched: disable preempt in idle tasks
[linux-2.6.git] / arch / ppc / 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  */
10
11 #include <linux/config.h>
12 #include <linux/kernel.h>
13 #include <linux/module.h>
14 #include <linux/sched.h>
15 #include <linux/smp.h>
16 #include <linux/smp_lock.h>
17 #include <linux/interrupt.h>
18 #include <linux/kernel_stat.h>
19 #include <linux/delay.h>
20 #include <linux/init.h>
21 #include <linux/spinlock.h>
22 #include <linux/cache.h>
23
24 #include <asm/ptrace.h>
25 #include <asm/atomic.h>
26 #include <asm/irq.h>
27 #include <asm/page.h>
28 #include <asm/pgtable.h>
29 #include <asm/io.h>
30 #include <asm/prom.h>
31 #include <asm/smp.h>
32 #include <asm/residual.h>
33 #include <asm/time.h>
34 #include <asm/thread_info.h>
35 #include <asm/tlbflush.h>
36 #include <asm/xmon.h>
37 #include <asm/machdep.h>
38
39 volatile int smp_commenced;
40 int smp_tb_synchronized;
41 struct cpuinfo_PPC cpu_data[NR_CPUS];
42 atomic_t ipi_recv;
43 atomic_t ipi_sent;
44 cpumask_t cpu_online_map;
45 cpumask_t cpu_possible_map;
46 int smp_hw_index[NR_CPUS];
47 struct thread_info *secondary_ti;
48 static struct task_struct *idle_tasks[NR_CPUS];
49
50 EXPORT_SYMBOL(cpu_online_map);
51 EXPORT_SYMBOL(cpu_possible_map);
52
53 /* SMP operations for this machine */
54 struct smp_ops_t *smp_ops;
55
56 /* all cpu mappings are 1-1 -- Cort */
57 volatile unsigned long cpu_callin_map[NR_CPUS];
58
59 int start_secondary(void *);
60 void smp_call_function_interrupt(void);
61 static int __smp_call_function(void (*func) (void *info), void *info,
62                                int wait, int target);
63
64 /* Low level assembly function used to backup CPU 0 state */
65 extern void __save_cpu_setup(void);
66
67 /* Since OpenPIC has only 4 IPIs, we use slightly different message numbers.
68  *
69  * Make sure this matches openpic_request_IPIs in open_pic.c, or what shows up
70  * in /proc/interrupts will be wrong!!! --Troy */
71 #define PPC_MSG_CALL_FUNCTION   0
72 #define PPC_MSG_RESCHEDULE      1
73 #define PPC_MSG_INVALIDATE_TLB  2
74 #define PPC_MSG_XMON_BREAK      3
75
76 static inline void
77 smp_message_pass(int target, int msg)
78 {
79         if (smp_ops) {
80                 atomic_inc(&ipi_sent);
81                 smp_ops->message_pass(target, msg);
82         }
83 }
84
85 /*
86  * Common functions
87  */
88 void smp_message_recv(int msg, struct pt_regs *regs)
89 {
90         atomic_inc(&ipi_recv);
91
92         switch( msg ) {
93         case PPC_MSG_CALL_FUNCTION:
94                 smp_call_function_interrupt();
95                 break;
96         case PPC_MSG_RESCHEDULE:
97                 set_need_resched();
98                 break;
99         case PPC_MSG_INVALIDATE_TLB:
100                 _tlbia();
101                 break;
102 #ifdef CONFIG_XMON
103         case PPC_MSG_XMON_BREAK:
104                 xmon(regs);
105                 break;
106 #endif /* CONFIG_XMON */
107         default:
108                 printk("SMP %d: smp_message_recv(): unknown msg %d\n",
109                        smp_processor_id(), msg);
110                 break;
111         }
112 }
113
114 /*
115  * 750's don't broadcast tlb invalidates so
116  * we have to emulate that behavior.
117  *   -- Cort
118  */
119 void smp_send_tlb_invalidate(int cpu)
120 {
121         if ( PVR_VER(mfspr(SPRN_PVR)) == 8 )
122                 smp_message_pass(MSG_ALL_BUT_SELF, PPC_MSG_INVALIDATE_TLB);
123 }
124
125 void smp_send_reschedule(int cpu)
126 {
127         /*
128          * This is only used if `cpu' is running an idle task,
129          * so it will reschedule itself anyway...
130          *
131          * This isn't the case anymore since the other CPU could be
132          * sleeping and won't reschedule until the next interrupt (such
133          * as the timer).
134          *  -- Cort
135          */
136         /* This is only used if `cpu' is running an idle task,
137            so it will reschedule itself anyway... */
138         smp_message_pass(cpu, PPC_MSG_RESCHEDULE);
139 }
140
141 #ifdef CONFIG_XMON
142 void smp_send_xmon_break(int cpu)
143 {
144         smp_message_pass(cpu, PPC_MSG_XMON_BREAK);
145 }
146 #endif /* CONFIG_XMON */
147
148 static void stop_this_cpu(void *dummy)
149 {
150         local_irq_disable();
151         while (1)
152                 ;
153 }
154
155 void smp_send_stop(void)
156 {
157         smp_call_function(stop_this_cpu, NULL, 1, 0);
158 }
159
160 /*
161  * Structure and data for smp_call_function(). This is designed to minimise
162  * static memory requirements. It also looks cleaner.
163  * Stolen from the i386 version.
164  */
165 static DEFINE_SPINLOCK(call_lock);
166
167 static struct call_data_struct {
168         void (*func) (void *info);
169         void *info;
170         atomic_t started;
171         atomic_t finished;
172         int wait;
173 } *call_data;
174
175 /*
176  * this function sends a 'generic call function' IPI to all other CPUs
177  * in the system.
178  */
179
180 int smp_call_function(void (*func) (void *info), void *info, int nonatomic,
181                       int wait)
182 /*
183  * [SUMMARY] Run a function on all other CPUs.
184  * <func> The function to run. This must be fast and non-blocking.
185  * <info> An arbitrary pointer to pass to the function.
186  * <nonatomic> currently unused.
187  * <wait> If true, wait (atomically) until function has completed on other CPUs.
188  * [RETURNS] 0 on success, else a negative status code. Does not return until
189  * remote CPUs are nearly ready to execute <<func>> or are or have executed.
190  *
191  * You must not call this function with disabled interrupts or from a
192  * hardware interrupt handler or from a bottom half handler.
193  */
194 {
195         /* FIXME: get cpu lock with hotplug cpus, or change this to
196            bitmask. --RR */
197         if (num_online_cpus() <= 1)
198                 return 0;
199         /* Can deadlock when called with interrupts disabled */
200         WARN_ON(irqs_disabled());
201         return __smp_call_function(func, info, wait, MSG_ALL_BUT_SELF);
202 }
203
204 static int __smp_call_function(void (*func) (void *info), void *info,
205                                int wait, int target)
206 {
207         struct call_data_struct data;
208         int ret = -1;
209         int timeout;
210         int ncpus = 1;
211
212         if (target == MSG_ALL_BUT_SELF)
213                 ncpus = num_online_cpus() - 1;
214         else if (target == MSG_ALL)
215                 ncpus = num_online_cpus();
216
217         data.func = func;
218         data.info = info;
219         atomic_set(&data.started, 0);
220         data.wait = wait;
221         if (wait)
222                 atomic_set(&data.finished, 0);
223
224         spin_lock(&call_lock);
225         call_data = &data;
226         /* Send a message to all other CPUs and wait for them to respond */
227         smp_message_pass(target, PPC_MSG_CALL_FUNCTION);
228
229         /* Wait for response */
230         timeout = 1000000;
231         while (atomic_read(&data.started) != ncpus) {
232                 if (--timeout == 0) {
233                         printk("smp_call_function on cpu %d: other cpus not responding (%d)\n",
234                                smp_processor_id(), atomic_read(&data.started));
235                         goto out;
236                 }
237                 barrier();
238                 udelay(1);
239         }
240
241         if (wait) {
242                 timeout = 1000000;
243                 while (atomic_read(&data.finished) != ncpus) {
244                         if (--timeout == 0) {
245                                 printk("smp_call_function on cpu %d: other cpus not finishing (%d/%d)\n",
246                                        smp_processor_id(), atomic_read(&data.finished), atomic_read(&data.started));
247                                 goto out;
248                         }
249                         barrier();
250                         udelay(1);
251                 }
252         }
253         ret = 0;
254
255  out:
256         spin_unlock(&call_lock);
257         return ret;
258 }
259
260 void smp_call_function_interrupt(void)
261 {
262         void (*func) (void *info) = call_data->func;
263         void *info = call_data->info;
264         int wait = call_data->wait;
265
266         /*
267          * Notify initiating CPU that I've grabbed the data and am
268          * about to execute the function
269          */
270         atomic_inc(&call_data->started);
271         /*
272          * At this point the info structure may be out of scope unless wait==1
273          */
274         (*func)(info);
275         if (wait)
276                 atomic_inc(&call_data->finished);
277 }
278
279 static void __devinit smp_store_cpu_info(int id)
280 {
281         struct cpuinfo_PPC *c = &cpu_data[id];
282
283         /* assume bogomips are same for everything */
284         c->loops_per_jiffy = loops_per_jiffy;
285         c->pvr = mfspr(SPRN_PVR);
286 }
287
288 void __init smp_prepare_cpus(unsigned int max_cpus)
289 {
290         int num_cpus, i, cpu;
291         struct task_struct *p;
292
293         /* Fixup boot cpu */
294         smp_store_cpu_info(smp_processor_id());
295         cpu_callin_map[smp_processor_id()] = 1;
296
297         if (smp_ops == NULL) {
298                 printk("SMP not supported on this machine.\n");
299                 return;
300         }
301
302         /* Probe platform for CPUs: always linear. */
303         num_cpus = smp_ops->probe();
304         for (i = 0; i < num_cpus; ++i)
305                 cpu_set(i, cpu_possible_map);
306
307         /* Backup CPU 0 state */
308         __save_cpu_setup();
309
310         for_each_cpu(cpu) {
311                 if (cpu == smp_processor_id())
312                         continue;
313                 /* create a process for the processor */
314                 p = fork_idle(cpu);
315                 if (IS_ERR(p))
316                         panic("failed fork for CPU %u: %li", cpu, PTR_ERR(p));
317                 p->thread_info->cpu = cpu;
318                 idle_tasks[cpu] = p;
319         }
320 }
321
322 void __devinit smp_prepare_boot_cpu(void)
323 {
324         cpu_set(smp_processor_id(), cpu_online_map);
325         cpu_set(smp_processor_id(), cpu_possible_map);
326 }
327
328 int __init setup_profiling_timer(unsigned int multiplier)
329 {
330         return 0;
331 }
332
333 /* Processor coming up starts here */
334 int __devinit start_secondary(void *unused)
335 {
336         int cpu;
337
338         atomic_inc(&init_mm.mm_count);
339         current->active_mm = &init_mm;
340
341         cpu = smp_processor_id();
342         smp_store_cpu_info(cpu);
343         set_dec(tb_ticks_per_jiffy);
344         preempt_disable();
345         cpu_callin_map[cpu] = 1;
346
347         printk("CPU %d done callin...\n", cpu);
348         smp_ops->setup_cpu(cpu);
349         printk("CPU %d done setup...\n", cpu);
350         smp_ops->take_timebase();
351         printk("CPU %d done timebase take...\n", cpu);
352
353         spin_lock(&call_lock);
354         cpu_set(cpu, cpu_online_map);
355         spin_unlock(&call_lock);
356
357         local_irq_enable();
358
359         cpu_idle();
360         return 0;
361 }
362
363 int __cpu_up(unsigned int cpu)
364 {
365         char buf[32];
366         int c;
367
368         secondary_ti = idle_tasks[cpu]->thread_info;
369         mb();
370
371         /*
372          * There was a cache flush loop here to flush the cache
373          * to memory for the first 8MB of RAM.  The cache flush
374          * has been pushed into the kick_cpu function for those
375          * platforms that need it.
376          */
377
378         /* wake up cpu */
379         smp_ops->kick_cpu(cpu);
380         
381         /*
382          * wait to see if the cpu made a callin (is actually up).
383          * use this value that I found through experimentation.
384          * -- Cort
385          */
386         for (c = 1000; c && !cpu_callin_map[cpu]; c--)
387                 udelay(100);
388
389         if (!cpu_callin_map[cpu]) {
390                 sprintf(buf, "didn't find cpu %u", cpu);
391                 if (ppc_md.progress) ppc_md.progress(buf, 0x360+cpu);
392                 printk("Processor %u is stuck.\n", cpu);
393                 return -ENOENT;
394         }
395
396         sprintf(buf, "found cpu %u", cpu);
397         if (ppc_md.progress) ppc_md.progress(buf, 0x350+cpu);
398         printk("Processor %d found.\n", cpu);
399
400         smp_ops->give_timebase();
401
402         /* Wait until cpu puts itself in the online map */
403         while (!cpu_online(cpu))
404                 cpu_relax();
405
406         return 0;
407 }
408
409 void smp_cpus_done(unsigned int max_cpus)
410 {
411         smp_ops->setup_cpu(0);
412 }