2 * Copyright 2010 Tilera Corporation. All Rights Reserved.
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License
6 * as published by the Free Software Foundation, version 2.
8 * This program is distributed in the hope that it will be useful, but
9 * WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
11 * NON INFRINGEMENT. See the GNU General Public License for
15 #include <linux/module.h>
16 #include <linux/init.h>
17 #include <linux/kernel.h>
19 #include <linux/sched.h>
20 #include <linux/kernel_stat.h>
21 #include <linux/smp_lock.h>
22 #include <linux/bootmem.h>
23 #include <linux/notifier.h>
24 #include <linux/cpu.h>
25 #include <linux/percpu.h>
26 #include <linux/delay.h>
27 #include <linux/err.h>
28 #include <asm/mmu_context.h>
29 #include <asm/tlbflush.h>
30 #include <asm/sections.h>
33 * This assembly function is provided in entry.S.
34 * When called, it loops on a nap instruction forever.
35 * FIXME: should be in a header somewhere.
37 extern void smp_nap(void);
39 /* State of each CPU. */
40 DEFINE_PER_CPU(int, cpu_state) = { 0 };
42 /* The messaging code jumps to this pointer during boot-up */
43 unsigned long start_cpu_function_addr;
45 /* Called very early during startup to mark boot cpu as online */
46 void __init smp_prepare_boot_cpu(void)
48 int cpu = smp_processor_id();
49 set_cpu_online(cpu, 1);
50 set_cpu_present(cpu, 1);
51 __get_cpu_var(cpu_state) = CPU_ONLINE;
56 static void start_secondary(void);
59 * Called at the top of init() to launch all the other CPUs.
60 * They run free to complete their initialization and then wait
61 * until they get an IPI from the boot cpu to come online.
63 void __init smp_prepare_cpus(unsigned int max_cpus)
67 int boot_cpu = smp_processor_id();
69 current_thread_info()->cpu = boot_cpu;
72 * Pin this task to the boot CPU while we bring up the others,
73 * just to make sure we don't uselessly migrate as they come up.
75 rc = sched_setaffinity(current->pid, cpumask_of(boot_cpu));
77 printk("Couldn't set init affinity to boot cpu (%ld)\n", rc);
79 /* Print information about disabled and dataplane cpus. */
80 print_disabled_cpus();
83 * Tell the messaging subsystem how to respond to the
84 * startup message. We use a level of indirection to avoid
85 * confusing the linker with the fact that the messaging
86 * subsystem is calling __init code.
88 start_cpu_function_addr = (unsigned long) &online_secondary;
90 /* Set up thread context for all new processors. */
92 for (cpu = 0; cpu < NR_CPUS; ++cpu) {
93 struct task_struct *idle;
98 if (!cpu_possible(cpu)) {
100 * Make this processor do nothing on boot.
101 * Note that we don't give the boot_pc function
102 * a stack, so it has to be assembly code.
104 per_cpu(boot_sp, cpu) = 0;
105 per_cpu(boot_pc, cpu) = (unsigned long) smp_nap;
109 /* Create a new idle thread to run start_secondary() */
110 idle = fork_idle(cpu);
112 panic("failed fork for CPU %d", cpu);
113 idle->thread.pc = (unsigned long) start_secondary;
115 /* Make this thread the boot thread for this processor */
116 per_cpu(boot_sp, cpu) = task_ksp0(idle);
117 per_cpu(boot_pc, cpu) = idle->thread.pc;
121 BUG_ON(cpu_count > (max_cpus ? max_cpus : 1));
123 /* Fire up the other tiles, if any */
124 init_cpu_present(cpu_possible_mask);
125 if (cpumask_weight(cpu_present_mask) > 1) {
126 mb(); /* make sure all data is visible to new processors */
127 hv_start_all_tiles();
131 static __initdata struct cpumask init_affinity;
133 static __init int reset_init_affinity(void)
135 long rc = sched_setaffinity(current->pid, &init_affinity);
137 printk(KERN_WARNING "couldn't reset init affinity (%ld)\n",
141 late_initcall(reset_init_affinity);
143 struct cpumask cpu_started __cpuinitdata;
146 * Activate a secondary processor. Very minimal; don't add anything
147 * to this path without knowing what you're doing, since SMP booting
150 static void __cpuinit start_secondary(void)
152 int cpuid = smp_processor_id();
154 /* Set our thread pointer appropriately. */
155 set_my_cpu_offset(__per_cpu_offset[cpuid]);
160 * In large machines even this will slow us down, since we
161 * will be contending for for the printk spinlock.
163 /* printk(KERN_DEBUG "Initializing CPU#%d\n", cpuid); */
165 /* Initialize the current asid for our first page table. */
166 __get_cpu_var(current_asid) = min_asid;
168 /* Set up this thread as another owner of the init_mm */
169 atomic_inc(&init_mm.mm_count);
170 current->active_mm = &init_mm;
173 enter_lazy_tlb(&init_mm, current);
176 init_per_tile_IRQs();
178 /* Allow hypervisor messages to be received */
182 /* Indicate that we're ready to come up. */
183 /* Must not do this before we're ready to receive messages */
184 if (cpumask_test_and_set_cpu(cpuid, &cpu_started)) {
185 printk(KERN_WARNING "CPU#%d already started!\n", cpuid);
193 void setup_mpls(void); /* from kernel/setup.c */
194 void store_permanent_mappings(void);
197 * Bring a secondary processor online.
199 void __cpuinit online_secondary()
202 * low-memory mappings have been cleared, flush them from
203 * the local TLBs too.
207 BUG_ON(in_interrupt());
209 /* This must be done before setting cpu_online_mask */
213 * We need to hold call_lock, so there is no inconsistency
214 * between the time smp_call_function() determines number of
215 * IPI recipients, and the time when the determination is made
216 * for which cpus receive the IPI. Holding this
217 * lock helps us to not include this cpu in a currently in progress
218 * smp_call_function().
221 set_cpu_online(smp_processor_id(), 1);
223 __get_cpu_var(cpu_state) = CPU_ONLINE;
225 /* Set up MPLs for this processor */
229 /* Set up tile-timer clock-event device on this cpu */
234 store_permanent_mappings();
239 int __cpuinit __cpu_up(unsigned int cpu)
241 /* Wait 5s total for all CPUs for them to come online */
243 for (; !cpumask_test_cpu(cpu, &cpu_started); timeout++) {
244 if (timeout >= 50000) {
245 printk(KERN_INFO "skipping unresponsive cpu%d\n", cpu);
253 per_cpu(cpu_state, cpu) = CPU_UP_PREPARE;
255 /* Unleash the CPU! */
256 send_IPI_single(cpu, MSG_TAG_START_CPU);
257 while (!cpumask_test_cpu(cpu, cpu_online_mask))
262 static void panic_start_cpu(void)
264 panic("Received a MSG_START_CPU IPI after boot finished.");
267 void __init smp_cpus_done(unsigned int max_cpus)
271 /* Reset the response to a (now illegal) MSG_START_CPU IPI. */
272 start_cpu_function_addr = (unsigned long) &panic_start_cpu;
274 cpumask_copy(&init_affinity, cpu_online_mask);
277 * Pin ourselves to a single cpu in the initial affinity set
278 * so that kernel mappings for the rootfs are not in the dataplane,
279 * if set, and to avoid unnecessary migrating during bringup.
280 * Use the last cpu just in case the whole chip has been
281 * isolated from the scheduler, to keep init away from likely
282 * more useful user code. This also ensures that work scheduled
283 * via schedule_delayed_work() in the init routines will land
286 for (cpu = cpumask_first(&init_affinity);
287 (next = cpumask_next(cpu, &init_affinity)) < nr_cpu_ids;
290 rc = sched_setaffinity(current->pid, cpumask_of(cpu));
292 printk("Couldn't set init affinity to cpu %d (%d)\n", cpu, rc);