Merge branch 'timers-fixes-for-linus' of git://git.kernel.org/pub/scm/linux/kernel...
[linux-2.6] / arch / sparc / kernel / smp_32.c
1 /* smp.c: Sparc SMP support.
2  *
3  * Copyright (C) 1996 David S. Miller (davem@caip.rutgers.edu)
4  * Copyright (C) 1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
5  * Copyright (C) 2004 Keith M Wesolowski (wesolows@foobazco.org)
6  */
7
8 #include <asm/head.h>
9
10 #include <linux/kernel.h>
11 #include <linux/sched.h>
12 #include <linux/threads.h>
13 #include <linux/smp.h>
14 #include <linux/interrupt.h>
15 #include <linux/kernel_stat.h>
16 #include <linux/init.h>
17 #include <linux/spinlock.h>
18 #include <linux/mm.h>
19 #include <linux/fs.h>
20 #include <linux/seq_file.h>
21 #include <linux/cache.h>
22 #include <linux/delay.h>
23
24 #include <asm/ptrace.h>
25 #include <asm/atomic.h>
26
27 #include <asm/irq.h>
28 #include <asm/page.h>
29 #include <asm/pgalloc.h>
30 #include <asm/pgtable.h>
31 #include <asm/oplib.h>
32 #include <asm/cacheflush.h>
33 #include <asm/tlbflush.h>
34 #include <asm/cpudata.h>
35
36 #include "irq.h"
37
38 volatile unsigned long cpu_callin_map[NR_CPUS] __cpuinitdata = {0,};
39 unsigned char boot_cpu_id = 0;
40 unsigned char boot_cpu_id4 = 0; /* boot_cpu_id << 2 */
41
42 cpumask_t smp_commenced_mask = CPU_MASK_NONE;
43
44 /* The only guaranteed locking primitive available on all Sparc
45  * processors is 'ldstub [%reg + immediate], %dest_reg' which atomically
46  * places the current byte at the effective address into dest_reg and
47  * places 0xff there afterwards.  Pretty lame locking primitive
48  * compared to the Alpha and the Intel no?  Most Sparcs have 'swap'
49  * instruction which is much better...
50  */
51
52 void __cpuinit smp_store_cpu_info(int id)
53 {
54         int cpu_node;
55
56         cpu_data(id).udelay_val = loops_per_jiffy;
57
58         cpu_find_by_mid(id, &cpu_node);
59         cpu_data(id).clock_tick = prom_getintdefault(cpu_node,
60                                                      "clock-frequency", 0);
61         cpu_data(id).prom_node = cpu_node;
62         cpu_data(id).mid = cpu_get_hwmid(cpu_node);
63
64         if (cpu_data(id).mid < 0)
65                 panic("No MID found for CPU%d at node 0x%08d", id, cpu_node);
66 }
67
68 void __init smp_cpus_done(unsigned int max_cpus)
69 {
70         extern void smp4m_smp_done(void);
71         extern void smp4d_smp_done(void);
72         unsigned long bogosum = 0;
73         int cpu, num;
74
75         for (cpu = 0, num = 0; cpu < NR_CPUS; cpu++)
76                 if (cpu_online(cpu)) {
77                         num++;
78                         bogosum += cpu_data(cpu).udelay_val;
79                 }
80
81         printk("Total of %d processors activated (%lu.%02lu BogoMIPS).\n",
82                 num, bogosum/(500000/HZ),
83                 (bogosum/(5000/HZ))%100);
84
85         switch(sparc_cpu_model) {
86         case sun4:
87                 printk("SUN4\n");
88                 BUG();
89                 break;
90         case sun4c:
91                 printk("SUN4C\n");
92                 BUG();
93                 break;
94         case sun4m:
95                 smp4m_smp_done();
96                 break;
97         case sun4d:
98                 smp4d_smp_done();
99                 break;
100         case sun4e:
101                 printk("SUN4E\n");
102                 BUG();
103                 break;
104         case sun4u:
105                 printk("SUN4U\n");
106                 BUG();
107                 break;
108         default:
109                 printk("UNKNOWN!\n");
110                 BUG();
111                 break;
112         };
113 }
114
115 void cpu_panic(void)
116 {
117         printk("CPU[%d]: Returns from cpu_idle!\n", smp_processor_id());
118         panic("SMP bolixed\n");
119 }
120
121 struct linux_prom_registers smp_penguin_ctable __cpuinitdata = { 0 };
122
123 void smp_send_reschedule(int cpu)
124 {
125         /* See sparc64 */
126 }
127
128 void smp_send_stop(void)
129 {
130 }
131
132 void smp_flush_cache_all(void)
133 {
134         xc0((smpfunc_t) BTFIXUP_CALL(local_flush_cache_all));
135         local_flush_cache_all();
136 }
137
138 void smp_flush_tlb_all(void)
139 {
140         xc0((smpfunc_t) BTFIXUP_CALL(local_flush_tlb_all));
141         local_flush_tlb_all();
142 }
143
144 void smp_flush_cache_mm(struct mm_struct *mm)
145 {
146         if(mm->context != NO_CONTEXT) {
147                 cpumask_t cpu_mask = mm->cpu_vm_mask;
148                 cpu_clear(smp_processor_id(), cpu_mask);
149                 if (!cpus_empty(cpu_mask))
150                         xc1((smpfunc_t) BTFIXUP_CALL(local_flush_cache_mm), (unsigned long) mm);
151                 local_flush_cache_mm(mm);
152         }
153 }
154
155 void smp_flush_tlb_mm(struct mm_struct *mm)
156 {
157         if(mm->context != NO_CONTEXT) {
158                 cpumask_t cpu_mask = mm->cpu_vm_mask;
159                 cpu_clear(smp_processor_id(), cpu_mask);
160                 if (!cpus_empty(cpu_mask)) {
161                         xc1((smpfunc_t) BTFIXUP_CALL(local_flush_tlb_mm), (unsigned long) mm);
162                         if(atomic_read(&mm->mm_users) == 1 && current->active_mm == mm)
163                                 mm->cpu_vm_mask = cpumask_of_cpu(smp_processor_id());
164                 }
165                 local_flush_tlb_mm(mm);
166         }
167 }
168
169 void smp_flush_cache_range(struct vm_area_struct *vma, unsigned long start,
170                            unsigned long end)
171 {
172         struct mm_struct *mm = vma->vm_mm;
173
174         if (mm->context != NO_CONTEXT) {
175                 cpumask_t cpu_mask = mm->cpu_vm_mask;
176                 cpu_clear(smp_processor_id(), cpu_mask);
177                 if (!cpus_empty(cpu_mask))
178                         xc3((smpfunc_t) BTFIXUP_CALL(local_flush_cache_range), (unsigned long) vma, start, end);
179                 local_flush_cache_range(vma, start, end);
180         }
181 }
182
183 void smp_flush_tlb_range(struct vm_area_struct *vma, unsigned long start,
184                          unsigned long end)
185 {
186         struct mm_struct *mm = vma->vm_mm;
187
188         if (mm->context != NO_CONTEXT) {
189                 cpumask_t cpu_mask = mm->cpu_vm_mask;
190                 cpu_clear(smp_processor_id(), cpu_mask);
191                 if (!cpus_empty(cpu_mask))
192                         xc3((smpfunc_t) BTFIXUP_CALL(local_flush_tlb_range), (unsigned long) vma, start, end);
193                 local_flush_tlb_range(vma, start, end);
194         }
195 }
196
197 void smp_flush_cache_page(struct vm_area_struct *vma, unsigned long page)
198 {
199         struct mm_struct *mm = vma->vm_mm;
200
201         if(mm->context != NO_CONTEXT) {
202                 cpumask_t cpu_mask = mm->cpu_vm_mask;
203                 cpu_clear(smp_processor_id(), cpu_mask);
204                 if (!cpus_empty(cpu_mask))
205                         xc2((smpfunc_t) BTFIXUP_CALL(local_flush_cache_page), (unsigned long) vma, page);
206                 local_flush_cache_page(vma, page);
207         }
208 }
209
210 void smp_flush_tlb_page(struct vm_area_struct *vma, unsigned long page)
211 {
212         struct mm_struct *mm = vma->vm_mm;
213
214         if(mm->context != NO_CONTEXT) {
215                 cpumask_t cpu_mask = mm->cpu_vm_mask;
216                 cpu_clear(smp_processor_id(), cpu_mask);
217                 if (!cpus_empty(cpu_mask))
218                         xc2((smpfunc_t) BTFIXUP_CALL(local_flush_tlb_page), (unsigned long) vma, page);
219                 local_flush_tlb_page(vma, page);
220         }
221 }
222
223 void smp_reschedule_irq(void)
224 {
225         set_need_resched();
226 }
227
228 void smp_flush_page_to_ram(unsigned long page)
229 {
230         /* Current theory is that those who call this are the one's
231          * who have just dirtied their cache with the pages contents
232          * in kernel space, therefore we only run this on local cpu.
233          *
234          * XXX This experiment failed, research further... -DaveM
235          */
236 #if 1
237         xc1((smpfunc_t) BTFIXUP_CALL(local_flush_page_to_ram), page);
238 #endif
239         local_flush_page_to_ram(page);
240 }
241
242 void smp_flush_sig_insns(struct mm_struct *mm, unsigned long insn_addr)
243 {
244         cpumask_t cpu_mask = mm->cpu_vm_mask;
245         cpu_clear(smp_processor_id(), cpu_mask);
246         if (!cpus_empty(cpu_mask))
247                 xc2((smpfunc_t) BTFIXUP_CALL(local_flush_sig_insns), (unsigned long) mm, insn_addr);
248         local_flush_sig_insns(mm, insn_addr);
249 }
250
251 extern unsigned int lvl14_resolution;
252
253 /* /proc/profile writes can call this, don't __init it please. */
254 static DEFINE_SPINLOCK(prof_setup_lock);
255
256 int setup_profiling_timer(unsigned int multiplier)
257 {
258         int i;
259         unsigned long flags;
260
261         /* Prevent level14 ticker IRQ flooding. */
262         if((!multiplier) || (lvl14_resolution / multiplier) < 500)
263                 return -EINVAL;
264
265         spin_lock_irqsave(&prof_setup_lock, flags);
266         for_each_possible_cpu(i) {
267                 load_profile_irq(i, lvl14_resolution / multiplier);
268                 prof_multiplier(i) = multiplier;
269         }
270         spin_unlock_irqrestore(&prof_setup_lock, flags);
271
272         return 0;
273 }
274
275 void __init smp_prepare_cpus(unsigned int max_cpus)
276 {
277         extern void __init smp4m_boot_cpus(void);
278         extern void __init smp4d_boot_cpus(void);
279         int i, cpuid, extra;
280
281         printk("Entering SMP Mode...\n");
282
283         extra = 0;
284         for (i = 0; !cpu_find_by_instance(i, NULL, &cpuid); i++) {
285                 if (cpuid >= NR_CPUS)
286                         extra++;
287         }
288         /* i = number of cpus */
289         if (extra && max_cpus > i - extra)
290                 printk("Warning: NR_CPUS is too low to start all cpus\n");
291
292         smp_store_cpu_info(boot_cpu_id);
293
294         switch(sparc_cpu_model) {
295         case sun4:
296                 printk("SUN4\n");
297                 BUG();
298                 break;
299         case sun4c:
300                 printk("SUN4C\n");
301                 BUG();
302                 break;
303         case sun4m:
304                 smp4m_boot_cpus();
305                 break;
306         case sun4d:
307                 smp4d_boot_cpus();
308                 break;
309         case sun4e:
310                 printk("SUN4E\n");
311                 BUG();
312                 break;
313         case sun4u:
314                 printk("SUN4U\n");
315                 BUG();
316                 break;
317         default:
318                 printk("UNKNOWN!\n");
319                 BUG();
320                 break;
321         };
322 }
323
324 /* Set this up early so that things like the scheduler can init
325  * properly.  We use the same cpu mask for both the present and
326  * possible cpu map.
327  */
328 void __init smp_setup_cpu_possible_map(void)
329 {
330         int instance, mid;
331
332         instance = 0;
333         while (!cpu_find_by_instance(instance, NULL, &mid)) {
334                 if (mid < NR_CPUS) {
335                         cpu_set(mid, cpu_possible_map);
336                         cpu_set(mid, cpu_present_map);
337                 }
338                 instance++;
339         }
340 }
341
342 void __init smp_prepare_boot_cpu(void)
343 {
344         int cpuid = hard_smp_processor_id();
345
346         if (cpuid >= NR_CPUS) {
347                 prom_printf("Serious problem, boot cpu id >= NR_CPUS\n");
348                 prom_halt();
349         }
350         if (cpuid != 0)
351                 printk("boot cpu id != 0, this could work but is untested\n");
352
353         current_thread_info()->cpu = cpuid;
354         cpu_set(cpuid, cpu_online_map);
355         cpu_set(cpuid, cpu_possible_map);
356 }
357
358 int __cpuinit __cpu_up(unsigned int cpu)
359 {
360         extern int __cpuinit smp4m_boot_one_cpu(int);
361         extern int __cpuinit smp4d_boot_one_cpu(int);
362         int ret=0;
363
364         switch(sparc_cpu_model) {
365         case sun4:
366                 printk("SUN4\n");
367                 BUG();
368                 break;
369         case sun4c:
370                 printk("SUN4C\n");
371                 BUG();
372                 break;
373         case sun4m:
374                 ret = smp4m_boot_one_cpu(cpu);
375                 break;
376         case sun4d:
377                 ret = smp4d_boot_one_cpu(cpu);
378                 break;
379         case sun4e:
380                 printk("SUN4E\n");
381                 BUG();
382                 break;
383         case sun4u:
384                 printk("SUN4U\n");
385                 BUG();
386                 break;
387         default:
388                 printk("UNKNOWN!\n");
389                 BUG();
390                 break;
391         };
392
393         if (!ret) {
394                 cpu_set(cpu, smp_commenced_mask);
395                 while (!cpu_online(cpu))
396                         mb();
397         }
398         return ret;
399 }
400
401 void smp_bogo(struct seq_file *m)
402 {
403         int i;
404         
405         for_each_online_cpu(i) {
406                 seq_printf(m,
407                            "Cpu%dBogo\t: %lu.%02lu\n",
408                            i,
409                            cpu_data(i).udelay_val/(500000/HZ),
410                            (cpu_data(i).udelay_val/(5000/HZ))%100);
411         }
412 }
413
414 void smp_info(struct seq_file *m)
415 {
416         int i;
417
418         seq_printf(m, "State:\n");
419         for_each_online_cpu(i)
420                 seq_printf(m, "CPU%d\t\t: online\n", i);
421 }