PPC fixes for SMP; also fix the stack overflow detection, remove
[opensuse:kernel.git] / arch / ppc / kernel / smp.c
1 /*
2  * BK Id: %F% %I% %G% %U% %#%
3  */
4 /*
5  * Smp support for ppc.
6  *
7  * Written by Cort Dougan (cort@cs.nmt.edu) borrowing a great
8  * deal of code from the sparc and intel versions.
9  *
10  * Copyright (C) 1999 Cort Dougan <cort@cs.nmt.edu>
11  *
12  */
13
14 #include <linux/config.h>
15 #include <linux/kernel.h>
16 #include <linux/sched.h>
17 #include <linux/smp.h>
18 #include <linux/smp_lock.h>
19 #include <linux/interrupt.h>
20 #include <linux/kernel_stat.h>
21 #include <linux/delay.h>
22 #define __KERNEL_SYSCALLS__
23 #include <linux/unistd.h>
24 #include <linux/init.h>
25 #include <linux/spinlock.h>
26 #include <linux/cache.h>
27
28 #include <asm/ptrace.h>
29 #include <asm/atomic.h>
30 #include <asm/irq.h>
31 #include <asm/page.h>
32 #include <asm/pgtable.h>
33 #include <asm/hardirq.h>
34 #include <asm/softirq.h>
35 #include <asm/io.h>
36 #include <asm/prom.h>
37 #include <asm/smp.h>
38 #include <asm/residual.h>
39 #include <asm/time.h>
40 #include <asm/thread_info.h>
41
42 int smp_threads_ready;
43 volatile int smp_commenced;
44 int smp_num_cpus = 1;
45 int smp_tb_synchronized;
46 struct cpuinfo_PPC cpu_data[NR_CPUS];
47 struct klock_info_struct klock_info = { KLOCK_CLEAR, 0 };
48 atomic_t ipi_recv;
49 atomic_t ipi_sent;
50 spinlock_t kernel_flag __cacheline_aligned_in_smp = SPIN_LOCK_UNLOCKED;
51 unsigned int prof_multiplier[NR_CPUS];
52 unsigned int prof_counter[NR_CPUS];
53 unsigned long cache_decay_ticks;
54 static int max_cpus __initdata = NR_CPUS;
55 unsigned long cpu_online_map;
56 int smp_hw_index[NR_CPUS];
57 static struct smp_ops_t *smp_ops;
58 struct thread_info *secondary_ti;
59
60 /* all cpu mappings are 1-1 -- Cort */
61 volatile unsigned long cpu_callin_map[NR_CPUS];
62
63 #define TB_SYNC_PASSES 4
64 volatile unsigned long __initdata tb_sync_flag = 0;
65 volatile unsigned long __initdata tb_offset = 0;
66
67 int start_secondary(void *);
68 extern int cpu_idle(void *unused);
69 void smp_call_function_interrupt(void);
70 void smp_message_pass(int target, int msg, unsigned long data, int wait);
71 static int __smp_call_function(void (*func) (void *info), void *info,
72                                int wait, int target);
73
74 #ifdef CONFIG_PPC_ISERIES
75 extern void smp_iSeries_space_timers( unsigned nr );
76 #endif
77
78 /* Since OpenPIC has only 4 IPIs, we use slightly different message numbers.
79  * 
80  * Make sure this matches openpic_request_IPIs in open_pic.c, or what shows up
81  * in /proc/interrupts will be wrong!!! --Troy */
82 #define PPC_MSG_CALL_FUNCTION   0
83 #define PPC_MSG_RESCHEDULE      1
84 #define PPC_MSG_INVALIDATE_TLB  2
85 #define PPC_MSG_XMON_BREAK      3
86
87 #define smp_message_pass(t,m,d,w) \
88     do { if (smp_ops) \
89              atomic_inc(&ipi_sent); \
90              smp_ops->message_pass((t),(m),(d),(w)); \
91        } while(0)
92
93 /* 
94  * Common functions
95  */
96 void smp_local_timer_interrupt(struct pt_regs * regs)
97 {
98         int cpu = smp_processor_id();
99
100         if (!--prof_counter[cpu]) {
101                 update_process_times(user_mode(regs));
102                 prof_counter[cpu]=prof_multiplier[cpu];
103         }
104 }
105
106 void smp_message_recv(int msg, struct pt_regs *regs)
107 {
108         atomic_inc(&ipi_recv);
109         
110         switch( msg ) {
111         case PPC_MSG_CALL_FUNCTION:
112                 smp_call_function_interrupt();
113                 break;
114         case PPC_MSG_RESCHEDULE: 
115                 set_need_resched();
116                 break;
117         case PPC_MSG_INVALIDATE_TLB:
118                 _tlbia();
119                 break;
120 #ifdef CONFIG_XMON
121         case PPC_MSG_XMON_BREAK:
122                 xmon(regs);
123                 break;
124 #endif /* CONFIG_XMON */
125         default:
126                 printk("SMP %d: smp_message_recv(): unknown msg %d\n",
127                        smp_processor_id(), msg);
128                 break;
129         }
130 }
131
132 /*
133  * 750's don't broadcast tlb invalidates so
134  * we have to emulate that behavior.
135  *   -- Cort
136  */
137 void smp_send_tlb_invalidate(int cpu)
138 {
139         if ( PVR_VER(mfspr(PVR)) == 8 )
140                 smp_message_pass(MSG_ALL_BUT_SELF, PPC_MSG_INVALIDATE_TLB, 0, 0);
141 }
142
143 void smp_send_reschedule(int cpu)
144 {
145         /*
146          * This is only used if `cpu' is running an idle task,
147          * so it will reschedule itself anyway...
148          *
149          * This isn't the case anymore since the other CPU could be
150          * sleeping and won't reschedule until the next interrupt (such
151          * as the timer).
152          *  -- Cort
153          */
154         /* This is only used if `cpu' is running an idle task,
155            so it will reschedule itself anyway... */
156         smp_message_pass(cpu, PPC_MSG_RESCHEDULE, 0, 0);
157 }
158
159 #ifdef CONFIG_XMON
160 void smp_send_xmon_break(int cpu)
161 {
162         smp_message_pass(cpu, PPC_MSG_XMON_BREAK, 0, 0);
163 }
164 #endif /* CONFIG_XMON */
165
166 static void stop_this_cpu(void *dummy)
167 {
168         __cli();
169         while (1)
170                 ;
171 }
172
173 void smp_send_stop(void)
174 {
175         smp_call_function(stop_this_cpu, NULL, 1, 0);
176         smp_num_cpus = 1;
177 }
178
179 /*
180  * Structure and data for smp_call_function(). This is designed to minimise
181  * static memory requirements. It also looks cleaner.
182  * Stolen from the i386 version.
183  */
184 static spinlock_t call_lock = SPIN_LOCK_UNLOCKED;
185
186 static struct call_data_struct {
187         void (*func) (void *info);
188         void *info;
189         atomic_t started;
190         atomic_t finished;
191         int wait;
192 } *call_data;
193
194 /*
195  * this function sends a 'generic call function' IPI to all other CPUs
196  * in the system.
197  */
198
199 int smp_call_function(void (*func) (void *info), void *info, int nonatomic,
200                       int wait)
201 /*
202  * [SUMMARY] Run a function on all other CPUs.
203  * <func> The function to run. This must be fast and non-blocking.
204  * <info> An arbitrary pointer to pass to the function.
205  * <nonatomic> currently unused.
206  * <wait> If true, wait (atomically) until function has completed on other CPUs.
207  * [RETURNS] 0 on success, else a negative status code. Does not return until
208  * remote CPUs are nearly ready to execute <<func>> or are or have executed.
209  *
210  * You must not call this function with disabled interrupts or from a
211  * hardware interrupt handler, you may call it from a bottom half handler.
212  */
213 {
214         if (smp_num_cpus <= 1)
215                 return 0;
216         return __smp_call_function(func, info, wait, MSG_ALL_BUT_SELF);
217 }
218
219 static int __smp_call_function(void (*func) (void *info), void *info,
220                                int wait, int target)
221 {
222         struct call_data_struct data;
223         int ret = -1;
224         int timeout;
225         int ncpus = 1;
226
227         if (target == MSG_ALL_BUT_SELF)
228                 ncpus = smp_num_cpus - 1;
229         else if (target == MSG_ALL)
230                 ncpus = smp_num_cpus;
231
232         data.func = func;
233         data.info = info;
234         atomic_set(&data.started, 0);
235         data.wait = wait;
236         if (wait)
237                 atomic_set(&data.finished, 0);
238
239         spin_lock_bh(&call_lock);
240         call_data = &data;
241         /* Send a message to all other CPUs and wait for them to respond */
242         smp_message_pass(target, PPC_MSG_CALL_FUNCTION, 0, 0);
243
244         /* Wait for response */
245         timeout = 1000000;
246         while (atomic_read(&data.started) != ncpus) {
247                 if (--timeout == 0) {
248                         printk("smp_call_function on cpu %d: other cpus not responding (%d)\n",
249                                smp_processor_id(), atomic_read(&data.started));
250                         goto out;
251                 }
252                 barrier();
253                 udelay(1);
254         }
255
256         if (wait) {
257                 timeout = 1000000;
258                 while (atomic_read(&data.finished) != ncpus) {
259                         if (--timeout == 0) {
260                                 printk("smp_call_function on cpu %d: other cpus not finishing (%d/%d)\n",
261                                        smp_processor_id(), atomic_read(&data.finished), atomic_read(&data.started));
262                                 goto out;
263                         }
264                         barrier();
265                         udelay(1);
266                 }
267         }
268         ret = 0;
269
270  out:
271         spin_unlock_bh(&call_lock);
272         return ret;
273 }
274
275 void smp_call_function_interrupt(void)
276 {
277         void (*func) (void *info) = call_data->func;
278         void *info = call_data->info;
279         int wait = call_data->wait;
280
281         /*
282          * Notify initiating CPU that I've grabbed the data and am
283          * about to execute the function
284          */
285         atomic_inc(&call_data->started);
286         /*
287          * At this point the info structure may be out of scope unless wait==1
288          */
289         (*func)(info);
290         if (wait)
291                 atomic_inc(&call_data->finished);
292 }
293
294 /*
295  * Task migration callback.
296  */
297 void smp_task_migration_interrupt(void *new_task)
298 {
299         task_t *p;
300
301         p = new_task;
302         sched_task_migrated(p);
303 }
304
305 /*
306  * This function sends a 'task migration' IPI to another CPU.
307  * Must be called from syscall contexts, with interrupts *enabled*.
308  */
309 void smp_migrate_task(int cpu, task_t *p)
310 {
311         __smp_call_function(smp_task_migration_interrupt, p, 0, cpu);
312 }
313
314 void __init smp_boot_cpus(void)
315 {
316         int i, cpu_nr;
317         struct task_struct *p;
318
319         printk("Entering SMP Mode...\n");
320         smp_num_cpus = 1;
321         smp_store_cpu_info(0);
322         cpu_online_map = 1UL;
323
324         /*
325          * assume for now that the first cpu booted is
326          * cpu 0, the master -- Cort
327          */
328         cpu_callin_map[0] = 1;
329
330         for (i = 0; i < NR_CPUS; i++) {
331                 prof_counter[i] = 1;
332                 prof_multiplier[i] = 1;
333         }
334
335         /*
336          * XXX very rough.
337          */
338         cache_decay_ticks = HZ/100;
339
340         smp_ops = ppc_md.smp_ops;
341         if (smp_ops == NULL) {
342                 printk("SMP not supported on this machine.\n");
343                 return;
344         }
345
346         /* Probe platform for CPUs */
347         cpu_nr = smp_ops->probe();
348
349         /*
350          * only check for cpus we know exist.  We keep the callin map
351          * with cpus at the bottom -- Cort
352          */
353         if (cpu_nr > max_cpus)
354                 cpu_nr = max_cpus;
355 #ifdef CONFIG_PPC_ISERIES
356         smp_iSeries_space_timers( cpu_nr );
357 #endif
358         for (i = 1; i < cpu_nr; i++) {
359                 int c;
360                 struct pt_regs regs;
361                 
362                 /* create a process for the processor */
363                 /* only regs.msr is actually used, and 0 is OK for it */
364                 memset(&regs, 0, sizeof(struct pt_regs));
365                 if (do_fork(CLONE_VM|CLONE_PID, 0, &regs, 0) < 0)
366                         panic("failed fork for CPU %d", i);
367                 p = init_task.prev_task;
368                 if (!p)
369                         panic("No idle task for CPU %d", i);
370                 init_idle(p, i);
371                 unhash_process(p);
372
373                 secondary_ti = p->thread_info;
374                 p->thread_info->cpu = i;
375
376                 /*
377                  * There was a cache flush loop here to flush the cache
378                  * to memory for the first 8MB of RAM.  The cache flush
379                  * has been pushed into the kick_cpu function for those
380                  * platforms that need it.
381                  */
382
383                 /* wake up cpus */
384                 smp_ops->kick_cpu(i);
385                 
386                 /*
387                  * wait to see if the cpu made a callin (is actually up).
388                  * use this value that I found through experimentation.
389                  * -- Cort
390                  */
391                 for (c = 1000; c && !cpu_callin_map[i]; c--)
392                         udelay(100);
393                 
394                 if (cpu_callin_map[i]) {
395                         char buf[32];
396                         sprintf(buf, "found cpu %d", i);
397                         if (ppc_md.progress) ppc_md.progress(buf, 0x350+i);
398                         printk("Processor %d found.\n", i);
399                         smp_num_cpus++;
400                 } else {
401                         char buf[32];
402                         sprintf(buf, "didn't find cpu %d", i);
403                         if (ppc_md.progress) ppc_md.progress(buf, 0x360+i);
404                         printk("Processor %d is stuck.\n", i);
405                 }
406         }
407
408         /* Setup CPU 0 last (important) */
409         smp_ops->setup_cpu(0);
410         
411         if (smp_num_cpus < 2)
412                 smp_tb_synchronized = 1;
413 }
414
415 void __init smp_software_tb_sync(int cpu)
416 {
417 #define PASSES 4        /* 4 passes.. */
418         int pass;
419         int i, j;
420
421         /* stop - start will be the number of timebase ticks it takes for cpu0
422          * to send a message to all others and the first reponse to show up.
423          *
424          * ASSUMPTION: this time is similiar for all cpus
425          * ASSUMPTION: the time to send a one-way message is ping/2
426          */
427         register unsigned long start = 0;
428         register unsigned long stop = 0;
429         register unsigned long temp = 0;
430
431         set_tb(0, 0);
432
433         /* multiple passes to get in l1 cache.. */
434         for (pass = 2; pass < 2+PASSES; pass++){
435                 if (cpu == 0){
436                         mb();
437                         for (i = j = 1; i < smp_num_cpus; i++, j++){
438                                 /* skip stuck cpus */
439                                 while (!cpu_callin_map[j])
440                                         ++j;
441                                 while (cpu_callin_map[j] != pass)
442                                         barrier();
443                         }
444                         mb();
445                         tb_sync_flag = pass;
446                         start = get_tbl();      /* start timing */
447                         while (tb_sync_flag)
448                                 mb();
449                         stop = get_tbl();       /* end timing */
450                         /* theoretically, the divisor should be 2, but
451                          * I get better results on my dual mtx. someone
452                          * please report results on other smp machines..
453                          */
454                         tb_offset = (stop-start)/4;
455                         mb();
456                         tb_sync_flag = pass;
457                         udelay(10);
458                         mb();
459                         tb_sync_flag = 0;
460                         mb();
461                         set_tb(0,0);
462                         mb();
463                 } else {
464                         cpu_callin_map[cpu] = pass;
465                         mb();
466                         while (!tb_sync_flag)
467                                 mb();           /* wait for cpu0 */
468                         mb();
469                         tb_sync_flag = 0;       /* send response for timing */
470                         mb();
471                         while (!tb_sync_flag)
472                                 mb();
473                         temp = tb_offset;       /* make sure offset is loaded */
474                         while (tb_sync_flag)
475                                 mb();
476                         set_tb(0,temp);         /* now, set the timebase */
477                         mb();
478                 }
479         }
480         if (cpu == 0) {
481                 smp_tb_synchronized = 1;
482                 printk("smp_software_tb_sync: %d passes, final offset: %ld\n",
483                         PASSES, tb_offset);
484         }
485         /* so time.c doesn't get confused */
486         set_dec(tb_ticks_per_jiffy);
487         last_jiffy_stamp(cpu) = 0;
488 }
489
490 void __init smp_commence(void)
491 {
492         /*
493          *      Lets the callin's below out of their loop.
494          */
495         if (ppc_md.progress) ppc_md.progress("smp_commence", 0x370);
496         wmb();
497         smp_commenced = 1;
498
499         /* if the smp_ops->setup_cpu function has not already synched the
500          * timebases with a nicer hardware-based method, do so now
501          *
502          * I am open to suggestions for improvements to this method
503          * -- Troy <hozer@drgw.net>
504          *
505          * NOTE: if you are debugging, set smp_tb_synchronized for now
506          * since if this code runs pretty early and needs all cpus that
507          * reported in in smp_callin_map to be working
508          *
509          * NOTE2: this code doesn't seem to work on > 2 cpus. -- paulus/BenH
510          */
511         if (!smp_tb_synchronized && smp_num_cpus == 2) {
512                 unsigned long flags;
513                 __save_and_cli(flags);  
514                 smp_software_tb_sync(0);
515                 __restore_flags(flags);
516         }
517 }
518
519 void __init smp_callin(void)
520 {
521         int cpu = smp_processor_id();
522         
523         smp_store_cpu_info(cpu);
524         set_dec(tb_ticks_per_jiffy);
525         cpu_callin_map[cpu] = 1;
526
527         smp_ops->setup_cpu(cpu);
528
529         /*
530          * This cpu is now "online".  Only set them online
531          * before they enter the loop below since write access
532          * to the below variable is _not_ guaranteed to be
533          * atomic.
534          *   -- Cort <cort@fsmlabs.com>
535          */
536         cpu_online_map |= 1UL << smp_processor_id();
537         
538         while (!smp_commenced)
539                 barrier();
540
541         /* see smp_commence for more info */
542         if (!smp_tb_synchronized && smp_num_cpus == 2) {
543                 smp_software_tb_sync(cpu);
544         }
545         __sti();
546 }
547
548 /* intel needs this */
549 void __init initialize_secondary(void)
550 {
551 }
552
553 /* Activate a secondary processor. */
554 int __init start_secondary(void *unused)
555 {
556         atomic_inc(&init_mm.mm_count);
557         current->active_mm = &init_mm;
558         smp_callin();
559         return cpu_idle(NULL);
560 }
561
562 void __init smp_setup(char *str, int *ints)
563 {
564 }
565
566 int __init setup_profiling_timer(unsigned int multiplier)
567 {
568         return 0;
569 }
570
571 void __init smp_store_cpu_info(int id)
572 {
573         struct cpuinfo_PPC *c = &cpu_data[id];
574
575         /* assume bogomips are same for everything */
576         c->loops_per_jiffy = loops_per_jiffy;
577         c->pvr = mfspr(PVR);
578 }
579
580 static int __init maxcpus(char *str)
581 {
582         get_option(&str, &max_cpus);
583         return 1;
584 }
585
586 __setup("maxcpus=", maxcpus);