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