4 * SMP support for the SuperH processors.
6 * Copyright (C) 2002 - 2007 Paul Mundt
7 * Copyright (C) 2006 - 2007 Akio Idehara
9 * This file is subject to the terms and conditions of the GNU General Public
10 * License. See the file "COPYING" in the main directory of this archive
13 #include <linux/err.h>
14 #include <linux/cache.h>
15 #include <linux/cpumask.h>
16 #include <linux/delay.h>
17 #include <linux/init.h>
18 #include <linux/spinlock.h>
20 #include <linux/module.h>
21 #include <linux/interrupt.h>
22 #include <asm/atomic.h>
23 #include <asm/processor.h>
24 #include <asm/system.h>
25 #include <asm/mmu_context.h>
27 #include <asm/cacheflush.h>
28 #include <asm/sections.h>
30 int __cpu_number_map
[NR_CPUS
]; /* Map physical to logical */
31 int __cpu_logical_map
[NR_CPUS
]; /* Map logical to physical */
33 cpumask_t cpu_possible_map
;
34 EXPORT_SYMBOL(cpu_possible_map
);
36 cpumask_t cpu_online_map
;
37 EXPORT_SYMBOL(cpu_online_map
);
39 static inline void __init
smp_store_cpu_info(unsigned int cpu
)
41 struct sh_cpuinfo
*c
= cpu_data
+ cpu
;
43 c
->loops_per_jiffy
= loops_per_jiffy
;
46 void __init
smp_prepare_cpus(unsigned int max_cpus
)
48 unsigned int cpu
= smp_processor_id();
50 init_new_context(current
, &init_mm
);
51 current_thread_info()->cpu
= cpu
;
52 plat_prepare_cpus(max_cpus
);
54 #ifndef CONFIG_HOTPLUG_CPU
55 cpu_present_map
= cpu_possible_map
;
59 void __devinit
smp_prepare_boot_cpu(void)
61 unsigned int cpu
= smp_processor_id();
63 __cpu_number_map
[0] = cpu
;
64 __cpu_logical_map
[0] = cpu
;
66 cpu_set(cpu
, cpu_online_map
);
67 cpu_set(cpu
, cpu_possible_map
);
70 asmlinkage
void __cpuinit
start_secondary(void)
73 struct mm_struct
*mm
= &init_mm
;
75 atomic_inc(&mm
->mm_count
);
76 atomic_inc(&mm
->mm_users
);
77 current
->active_mm
= mm
;
79 enter_lazy_tlb(mm
, current
);
85 notify_cpu_starting(smp_processor_id());
91 cpu
= smp_processor_id();
92 smp_store_cpu_info(cpu
);
94 cpu_set(cpu
, cpu_online_map
);
101 unsigned long bss_start
;
102 unsigned long bss_end
;
103 void *start_kernel_fn
;
108 int __cpuinit
__cpu_up(unsigned int cpu
)
110 struct task_struct
*tsk
;
111 unsigned long timeout
;
113 tsk
= fork_idle(cpu
);
115 printk(KERN_ERR
"Failed forking idle task for cpu %d\n", cpu
);
119 /* Fill in data in head.S for secondary cpus */
120 stack_start
.sp
= tsk
->thread
.sp
;
121 stack_start
.thread_info
= tsk
->stack
;
122 stack_start
.bss_start
= 0; /* don't clear bss for secondary cpus */
123 stack_start
.start_kernel_fn
= start_secondary
;
127 plat_start_cpu(cpu
, (unsigned long)_stext
);
129 timeout
= jiffies
+ HZ
;
130 while (time_before(jiffies
, timeout
)) {
143 void __init
smp_cpus_done(unsigned int max_cpus
)
145 unsigned long bogosum
= 0;
148 for_each_online_cpu(cpu
)
149 bogosum
+= cpu_data
[cpu
].loops_per_jiffy
;
151 printk(KERN_INFO
"SMP: Total of %d processors activated "
152 "(%lu.%02lu BogoMIPS).\n", num_online_cpus(),
153 bogosum
/ (500000/HZ
),
154 (bogosum
/ (5000/HZ
)) % 100);
157 void smp_send_reschedule(int cpu
)
159 plat_send_ipi(cpu
, SMP_MSG_RESCHEDULE
);
162 static void stop_this_cpu(void *unused
)
164 cpu_clear(smp_processor_id(), cpu_online_map
);
171 void smp_send_stop(void)
173 smp_call_function(stop_this_cpu
, 0, 0);
176 void arch_send_call_function_ipi(cpumask_t mask
)
180 for_each_cpu_mask(cpu
, mask
)
181 plat_send_ipi(cpu
, SMP_MSG_FUNCTION
);
184 void arch_send_call_function_single_ipi(int cpu
)
186 plat_send_ipi(cpu
, SMP_MSG_FUNCTION_SINGLE
);
189 /* Not really SMP stuff ... */
190 int setup_profiling_timer(unsigned int multiplier
)
195 static void flush_tlb_all_ipi(void *info
)
197 local_flush_tlb_all();
200 void flush_tlb_all(void)
202 on_each_cpu(flush_tlb_all_ipi
, 0, 1);
205 static void flush_tlb_mm_ipi(void *mm
)
207 local_flush_tlb_mm((struct mm_struct
*)mm
);
211 * The following tlb flush calls are invoked when old translations are
212 * being torn down, or pte attributes are changing. For single threaded
213 * address spaces, a new context is obtained on the current cpu, and tlb
214 * context on other cpus are invalidated to force a new context allocation
215 * at switch_mm time, should the mm ever be used on other cpus. For
216 * multithreaded address spaces, intercpu interrupts have to be sent.
217 * Another case where intercpu interrupts are required is when the target
218 * mm might be active on another cpu (eg debuggers doing the flushes on
219 * behalf of debugees, kswapd stealing pages from another process etc).
223 void flush_tlb_mm(struct mm_struct
*mm
)
227 if ((atomic_read(&mm
->mm_users
) != 1) || (current
->mm
!= mm
)) {
228 smp_call_function(flush_tlb_mm_ipi
, (void *)mm
, 1);
231 for (i
= 0; i
< num_online_cpus(); i
++)
232 if (smp_processor_id() != i
)
233 cpu_context(i
, mm
) = 0;
235 local_flush_tlb_mm(mm
);
240 struct flush_tlb_data
{
241 struct vm_area_struct
*vma
;
246 static void flush_tlb_range_ipi(void *info
)
248 struct flush_tlb_data
*fd
= (struct flush_tlb_data
*)info
;
250 local_flush_tlb_range(fd
->vma
, fd
->addr1
, fd
->addr2
);
253 void flush_tlb_range(struct vm_area_struct
*vma
,
254 unsigned long start
, unsigned long end
)
256 struct mm_struct
*mm
= vma
->vm_mm
;
259 if ((atomic_read(&mm
->mm_users
) != 1) || (current
->mm
!= mm
)) {
260 struct flush_tlb_data fd
;
265 smp_call_function(flush_tlb_range_ipi
, (void *)&fd
, 1);
268 for (i
= 0; i
< num_online_cpus(); i
++)
269 if (smp_processor_id() != i
)
270 cpu_context(i
, mm
) = 0;
272 local_flush_tlb_range(vma
, start
, end
);
276 static void flush_tlb_kernel_range_ipi(void *info
)
278 struct flush_tlb_data
*fd
= (struct flush_tlb_data
*)info
;
280 local_flush_tlb_kernel_range(fd
->addr1
, fd
->addr2
);
283 void flush_tlb_kernel_range(unsigned long start
, unsigned long end
)
285 struct flush_tlb_data fd
;
289 on_each_cpu(flush_tlb_kernel_range_ipi
, (void *)&fd
, 1);
292 static void flush_tlb_page_ipi(void *info
)
294 struct flush_tlb_data
*fd
= (struct flush_tlb_data
*)info
;
296 local_flush_tlb_page(fd
->vma
, fd
->addr1
);
299 void flush_tlb_page(struct vm_area_struct
*vma
, unsigned long page
)
302 if ((atomic_read(&vma
->vm_mm
->mm_users
) != 1) ||
303 (current
->mm
!= vma
->vm_mm
)) {
304 struct flush_tlb_data fd
;
308 smp_call_function(flush_tlb_page_ipi
, (void *)&fd
, 1);
311 for (i
= 0; i
< num_online_cpus(); i
++)
312 if (smp_processor_id() != i
)
313 cpu_context(i
, vma
->vm_mm
) = 0;
315 local_flush_tlb_page(vma
, page
);
319 static void flush_tlb_one_ipi(void *info
)
321 struct flush_tlb_data
*fd
= (struct flush_tlb_data
*)info
;
322 local_flush_tlb_one(fd
->addr1
, fd
->addr2
);
325 void flush_tlb_one(unsigned long asid
, unsigned long vaddr
)
327 struct flush_tlb_data fd
;
332 smp_call_function(flush_tlb_one_ipi
, (void *)&fd
, 1);
333 local_flush_tlb_one(asid
, vaddr
);