2 * linux/arch/arm/kernel/smp.c
4 * Copyright (C) 2002 ARM Limited, All Rights Reserved.
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
10 #include <linux/config.h>
11 #include <linux/delay.h>
12 #include <linux/init.h>
13 #include <linux/spinlock.h>
14 #include <linux/sched.h>
15 #include <linux/interrupt.h>
16 #include <linux/cache.h>
17 #include <linux/profile.h>
18 #include <linux/errno.h>
20 #include <linux/cpu.h>
21 #include <linux/smp.h>
22 #include <linux/seq_file.h>
24 #include <asm/atomic.h>
25 #include <asm/cacheflush.h>
27 #include <asm/mmu_context.h>
28 #include <asm/pgtable.h>
29 #include <asm/pgalloc.h>
30 #include <asm/processor.h>
31 #include <asm/tlbflush.h>
32 #include <asm/ptrace.h>
35 * bitmask of present and online CPUs.
36 * The present bitmask indicates that the CPU is physically present.
37 * The online bitmask indicates that the CPU is up and running.
39 cpumask_t cpu_present_mask
;
40 cpumask_t cpu_online_map
;
43 * as from 2.5, kernels no longer have an init_tasks structure
44 * so we need some other way of telling a new secondary core
45 * where to place its SVC stack
47 struct secondary_data secondary_data
;
50 * structures for inter-processor calls
51 * - A collection of single bit ipi messages.
55 unsigned long ipi_count
;
59 static DEFINE_PER_CPU(struct ipi_data
, ipi_data
) = {
60 .lock
= SPIN_LOCK_UNLOCKED
,
70 struct smp_call_struct
{
71 void (*func
)(void *info
);
78 static struct smp_call_struct
* volatile smp_call_function_data
;
79 static DEFINE_SPINLOCK(smp_call_function_lock
);
81 int __init
__cpu_up(unsigned int cpu
)
83 struct task_struct
*idle
;
89 * Spawn a new process manually. Grab a pointer to
90 * its task struct so we can mess with it
92 idle
= fork_idle(cpu
);
94 printk(KERN_ERR
"CPU%u: fork() failed\n", cpu
);
99 * Allocate initial page tables to allow the new CPU to
100 * enable the MMU safely. This essentially means a set
101 * of our "standard" page tables, with the addition of
102 * a 1:1 mapping for the physical address of the kernel.
104 pgd
= pgd_alloc(&init_mm
);
105 pmd
= pmd_offset(pgd
, PHYS_OFFSET
);
106 *pmd
= __pmd((PHYS_OFFSET
& PGDIR_MASK
) |
107 PMD_TYPE_SECT
| PMD_SECT_AP_WRITE
);
110 * We need to tell the secondary core where to find
111 * its stack and the page tables.
113 secondary_data
.stack
= (void *)idle
->thread_info
+ THREAD_SIZE
- 8;
114 secondary_data
.pgdir
= virt_to_phys(pgd
);
118 * Now bring the CPU into our world.
120 ret
= boot_secondary(cpu
, idle
);
122 unsigned long timeout
;
125 * CPU was successfully started, wait for it
126 * to come online or time out.
128 timeout
= jiffies
+ HZ
;
129 while (time_before(jiffies
, timeout
)) {
137 if (!cpu_online(cpu
))
141 secondary_data
.stack
= 0;
142 secondary_data
.pgdir
= 0;
144 *pmd_offset(pgd
, PHYS_OFFSET
) = __pmd(0);
148 printk(KERN_CRIT
"cpu_up: processor %d failed to boot\n", cpu
);
150 * FIXME: We need to clean up the new idle thread. --rmk
158 * This is the secondary CPU boot entry. We're using this CPUs
159 * idle thread stack, but a set of temporary page tables.
161 asmlinkage
void __init
secondary_start_kernel(void)
163 struct mm_struct
*mm
= &init_mm
;
164 unsigned int cpu
= smp_processor_id();
166 printk("CPU%u: Booted secondary processor\n", cpu
);
169 * All kernel threads share the same mm context; grab a
170 * reference and switch to it.
172 atomic_inc(&mm
->mm_users
);
173 atomic_inc(&mm
->mm_count
);
174 current
->active_mm
= mm
;
175 cpu_set(cpu
, mm
->cpu_vm_mask
);
176 cpu_switch_mm(mm
->pgd
, mm
);
177 enter_lazy_tlb(mm
, current
);
182 * Give the platform a chance to do its own initialisation.
184 platform_secondary_init(cpu
);
187 * Enable local interrupts.
194 smp_store_cpu_info(cpu
);
197 * OK, now it's safe to let the boot CPU continue
199 cpu_set(cpu
, cpu_online_map
);
202 * OK, it's off to the idle thread for us
208 * Called by both boot and secondaries to move global data into
209 * per-processor storage.
211 void __init
smp_store_cpu_info(unsigned int cpuid
)
213 struct cpuinfo_arm
*cpu_info
= &per_cpu(cpu_data
, cpuid
);
215 cpu_info
->loops_per_jiffy
= loops_per_jiffy
;
218 void __init
smp_cpus_done(unsigned int max_cpus
)
221 unsigned long bogosum
= 0;
223 for_each_online_cpu(cpu
)
224 bogosum
+= per_cpu(cpu_data
, cpu
).loops_per_jiffy
;
226 printk(KERN_INFO
"SMP: Total of %d processors activated "
227 "(%lu.%02lu BogoMIPS).\n",
229 bogosum
/ (500000/HZ
),
230 (bogosum
/ (5000/HZ
)) % 100);
233 void __init
smp_prepare_boot_cpu(void)
235 unsigned int cpu
= smp_processor_id();
237 cpu_set(cpu
, cpu_present_mask
);
238 cpu_set(cpu
, cpu_online_map
);
241 static void send_ipi_message(cpumask_t callmap
, enum ipi_msg_type msg
)
246 local_irq_save(flags
);
248 for_each_cpu_mask(cpu
, callmap
) {
249 struct ipi_data
*ipi
= &per_cpu(ipi_data
, cpu
);
251 spin_lock(&ipi
->lock
);
252 ipi
->bits
|= 1 << msg
;
253 spin_unlock(&ipi
->lock
);
257 * Call the platform specific cross-CPU call function.
259 smp_cross_call(callmap
);
261 local_irq_restore(flags
);
265 * You must not call this function with disabled interrupts, from a
266 * hardware interrupt handler, nor from a bottom half handler.
268 int smp_call_function_on_cpu(void (*func
)(void *info
), void *info
, int retry
,
269 int wait
, cpumask_t callmap
)
271 struct smp_call_struct data
;
272 unsigned long timeout
;
279 cpu_clear(smp_processor_id(), callmap
);
280 if (cpus_empty(callmap
))
283 data
.pending
= callmap
;
285 data
.unfinished
= callmap
;
288 * try to get the mutex on smp_call_function_data
290 spin_lock(&smp_call_function_lock
);
291 smp_call_function_data
= &data
;
293 send_ipi_message(callmap
, IPI_CALL_FUNC
);
295 timeout
= jiffies
+ HZ
;
296 while (!cpus_empty(data
.pending
) && time_before(jiffies
, timeout
))
302 if (!cpus_empty(data
.pending
)) {
304 * this may be causing our panic - report it
307 "CPU%u: smp_call_function timeout for %p(%p)\n"
308 " callmap %lx pending %lx, %swait\n",
309 smp_processor_id(), func
, info
, callmap
, data
.pending
,
315 timeout
= jiffies
+ (5 * HZ
);
316 while (!cpus_empty(data
.pending
) && time_before(jiffies
, timeout
))
319 if (cpus_empty(data
.pending
))
320 printk(KERN_CRIT
" RESOLVED\n");
322 printk(KERN_CRIT
" STILL STUCK\n");
326 * whatever happened, we're done with the data, so release it
328 smp_call_function_data
= NULL
;
329 spin_unlock(&smp_call_function_lock
);
331 if (!cpus_empty(data
.pending
)) {
337 while (!cpus_empty(data
.unfinished
))
344 int smp_call_function(void (*func
)(void *info
), void *info
, int retry
,
347 return smp_call_function_on_cpu(func
, info
, retry
, wait
,
351 void show_ipi_list(struct seq_file
*p
)
357 for_each_online_cpu(cpu
)
358 seq_printf(p
, " %10lu", per_cpu(ipi_data
, cpu
).ipi_count
);
363 static void ipi_timer(struct pt_regs
*regs
)
365 int user
= user_mode(regs
);
368 profile_tick(CPU_PROFILING
, regs
);
369 update_process_times(user
);
374 * ipi_call_function - handle IPI from smp_call_function()
376 * Note that we copy data out of the cross-call structure and then
377 * let the caller know that we're here and have done with their data
379 static void ipi_call_function(unsigned int cpu
)
381 struct smp_call_struct
*data
= smp_call_function_data
;
382 void (*func
)(void *info
) = data
->func
;
383 void *info
= data
->info
;
384 int wait
= data
->wait
;
386 cpu_clear(cpu
, data
->pending
);
391 cpu_clear(cpu
, data
->unfinished
);
394 static DEFINE_SPINLOCK(stop_lock
);
397 * ipi_cpu_stop - handle IPI from smp_send_stop()
399 static void ipi_cpu_stop(unsigned int cpu
)
401 spin_lock(&stop_lock
);
402 printk(KERN_CRIT
"CPU%u: stopping\n", cpu
);
404 spin_unlock(&stop_lock
);
406 cpu_clear(cpu
, cpu_online_map
);
416 * Main handler for inter-processor interrupts
418 * For ARM, the ipimask now only identifies a single
419 * category of IPI (Bit 1 IPIs have been replaced by a
420 * different mechanism):
422 * Bit 0 - Inter-processor function call
424 void do_IPI(struct pt_regs
*regs
)
426 unsigned int cpu
= smp_processor_id();
427 struct ipi_data
*ipi
= &per_cpu(ipi_data
, cpu
);
434 spin_lock(&ipi
->lock
);
437 spin_unlock(&ipi
->lock
);
445 nextmsg
= msgs
& -msgs
;
447 nextmsg
= ffz(~nextmsg
);
456 * nothing more to do - eveything is
457 * done on the interrupt return path
462 ipi_call_function(cpu
);
470 printk(KERN_CRIT
"CPU%u: Unknown IPI message 0x%x\n",
478 void smp_send_reschedule(int cpu
)
480 send_ipi_message(cpumask_of_cpu(cpu
), IPI_RESCHEDULE
);
483 void smp_send_timer(void)
485 cpumask_t mask
= cpu_online_map
;
486 cpu_clear(smp_processor_id(), mask
);
487 send_ipi_message(mask
, IPI_TIMER
);
490 void smp_send_stop(void)
492 cpumask_t mask
= cpu_online_map
;
493 cpu_clear(smp_processor_id(), mask
);
494 send_ipi_message(mask
, IPI_CPU_STOP
);
500 int __init
setup_profiling_timer(unsigned int multiplier
)