1 /*
2 * Copyright 2010 Tilera Corporation. All Rights Reserved.
3 *
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.
7 *
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
12 * more details.
13 */
14
15 #include <linux/module.h>
16 #include <linux/init.h>
17 #include <linux/kernel.h>
18 #include <linux/mm.h>
19 #include <linux/sched/mm.h>
20 #include <linux/sched/task.h>
21 #include <linux/kernel_stat.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 <linux/irq.h>
29 #include <asm/mmu_context.h>
30 #include <asm/tlbflush.h>
31 #include <asm/sections.h>
32
33 /* State of each CPU. */
34 static DEFINE_PER_CPU(int, cpu_state) = { 0 };
35
36 /* The messaging code jumps to this pointer during boot-up */
37 unsigned long start_cpu_function_addr;
38
39 /* Called very early during startup to mark boot cpu as online */
smp_prepare_boot_cpu(void)40 void __init smp_prepare_boot_cpu(void)
41 {
42 int cpu = smp_processor_id();
43 set_cpu_online(cpu, 1);
44 set_cpu_present(cpu, 1);
45 __this_cpu_write(cpu_state, CPU_ONLINE);
46
47 init_messaging();
48 }
49
50 static void start_secondary(void);
51
52 /*
53 * Called at the top of init() to launch all the other CPUs.
54 * They run free to complete their initialization and then wait
55 * until they get an IPI from the boot cpu to come online.
56 */
smp_prepare_cpus(unsigned int max_cpus)57 void __init smp_prepare_cpus(unsigned int max_cpus)
58 {
59 long rc;
60 int cpu, cpu_count;
61 int boot_cpu = smp_processor_id();
62
63 current_thread_info()->cpu = boot_cpu;
64
65 /*
66 * Pin this task to the boot CPU while we bring up the others,
67 * just to make sure we don't uselessly migrate as they come up.
68 */
69 rc = sched_setaffinity(current->pid, cpumask_of(boot_cpu));
70 if (rc != 0)
71 pr_err("Couldn't set init affinity to boot cpu (%ld)\n", rc);
72
73 /* Print information about disabled and dataplane cpus. */
74 print_disabled_cpus();
75
76 /*
77 * Tell the messaging subsystem how to respond to the
78 * startup message. We use a level of indirection to avoid
79 * confusing the linker with the fact that the messaging
80 * subsystem is calling __init code.
81 */
82 start_cpu_function_addr = (unsigned long) &online_secondary;
83
84 /* Set up thread context for all new processors. */
85 cpu_count = 1;
86 for (cpu = 0; cpu < NR_CPUS; ++cpu) {
87 struct task_struct *idle;
88
89 if (cpu == boot_cpu)
90 continue;
91
92 if (!cpu_possible(cpu)) {
93 /*
94 * Make this processor do nothing on boot.
95 * Note that we don't give the boot_pc function
96 * a stack, so it has to be assembly code.
97 */
98 per_cpu(boot_sp, cpu) = 0;
99 per_cpu(boot_pc, cpu) = (unsigned long) smp_nap;
100 continue;
101 }
102
103 /* Create a new idle thread to run start_secondary() */
104 idle = fork_idle(cpu);
105 if (IS_ERR(idle))
106 panic("failed fork for CPU %d", cpu);
107 idle->thread.pc = (unsigned long) start_secondary;
108
109 /* Make this thread the boot thread for this processor */
110 per_cpu(boot_sp, cpu) = task_ksp0(idle);
111 per_cpu(boot_pc, cpu) = idle->thread.pc;
112
113 ++cpu_count;
114 }
115 BUG_ON(cpu_count > (max_cpus ? max_cpus : 1));
116
117 /* Fire up the other tiles, if any */
118 init_cpu_present(cpu_possible_mask);
119 if (cpumask_weight(cpu_present_mask) > 1) {
120 mb(); /* make sure all data is visible to new processors */
121 hv_start_all_tiles();
122 }
123 }
124
125 static __initdata struct cpumask init_affinity;
126
reset_init_affinity(void)127 static __init int reset_init_affinity(void)
128 {
129 long rc = sched_setaffinity(current->pid, &init_affinity);
130 if (rc != 0)
131 pr_warn("couldn't reset init affinity (%ld)\n", rc);
132 return 0;
133 }
134 late_initcall(reset_init_affinity);
135
136 static struct cpumask cpu_started;
137
138 /*
139 * Activate a secondary processor. Very minimal; don't add anything
140 * to this path without knowing what you're doing, since SMP booting
141 * is pretty fragile.
142 */
start_secondary(void)143 static void start_secondary(void)
144 {
145 int cpuid;
146
147 preempt_disable();
148
149 cpuid = smp_processor_id();
150
151 /* Set our thread pointer appropriately. */
152 set_my_cpu_offset(__per_cpu_offset[cpuid]);
153
154 /*
155 * In large machines even this will slow us down, since we
156 * will be contending for for the printk spinlock.
157 */
158 /* printk(KERN_DEBUG "Initializing CPU#%d\n", cpuid); */
159
160 /* Initialize the current asid for our first page table. */
161 __this_cpu_write(current_asid, min_asid);
162
163 /* Set up this thread as another owner of the init_mm */
164 mmgrab(&init_mm);
165 current->active_mm = &init_mm;
166 if (current->mm)
167 BUG();
168 enter_lazy_tlb(&init_mm, current);
169
170 /* Allow hypervisor messages to be received */
171 init_messaging();
172 local_irq_enable();
173
174 /* Indicate that we're ready to come up. */
175 /* Must not do this before we're ready to receive messages */
176 if (cpumask_test_and_set_cpu(cpuid, &cpu_started)) {
177 pr_warn("CPU#%d already started!\n", cpuid);
178 for (;;)
179 local_irq_enable();
180 }
181
182 smp_nap();
183 }
184
185 /*
186 * Bring a secondary processor online.
187 */
online_secondary(void)188 void online_secondary(void)
189 {
190 /*
191 * low-memory mappings have been cleared, flush them from
192 * the local TLBs too.
193 */
194 local_flush_tlb();
195
196 BUG_ON(in_interrupt());
197
198 /* This must be done before setting cpu_online_mask */
199 wmb();
200
201 notify_cpu_starting(smp_processor_id());
202
203 set_cpu_online(smp_processor_id(), 1);
204 __this_cpu_write(cpu_state, CPU_ONLINE);
205
206 /* Set up tile-specific state for this cpu. */
207 setup_cpu(0);
208
209 /* Set up tile-timer clock-event device on this cpu */
210 setup_tile_timer();
211
212 cpu_startup_entry(CPUHP_AP_ONLINE_IDLE);
213 }
214
__cpu_up(unsigned int cpu,struct task_struct * tidle)215 int __cpu_up(unsigned int cpu, struct task_struct *tidle)
216 {
217 /* Wait 5s total for all CPUs for them to come online */
218 static int timeout;
219 for (; !cpumask_test_cpu(cpu, &cpu_started); timeout++) {
220 if (timeout >= 50000) {
221 pr_info("skipping unresponsive cpu%d\n", cpu);
222 local_irq_enable();
223 return -EIO;
224 }
225 udelay(100);
226 }
227
228 local_irq_enable();
229 per_cpu(cpu_state, cpu) = CPU_UP_PREPARE;
230
231 /* Unleash the CPU! */
232 send_IPI_single(cpu, MSG_TAG_START_CPU);
233 while (!cpumask_test_cpu(cpu, cpu_online_mask))
234 cpu_relax();
235 return 0;
236 }
237
panic_start_cpu(void)238 static void panic_start_cpu(void)
239 {
240 panic("Received a MSG_START_CPU IPI after boot finished.");
241 }
242
smp_cpus_done(unsigned int max_cpus)243 void __init smp_cpus_done(unsigned int max_cpus)
244 {
245 int cpu, next, rc;
246
247 /* Reset the response to a (now illegal) MSG_START_CPU IPI. */
248 start_cpu_function_addr = (unsigned long) &panic_start_cpu;
249
250 cpumask_copy(&init_affinity, cpu_online_mask);
251
252 /*
253 * Pin ourselves to a single cpu in the initial affinity set
254 * so that kernel mappings for the rootfs are not in the dataplane,
255 * if set, and to avoid unnecessary migrating during bringup.
256 * Use the last cpu just in case the whole chip has been
257 * isolated from the scheduler, to keep init away from likely
258 * more useful user code. This also ensures that work scheduled
259 * via schedule_delayed_work() in the init routines will land
260 * on this cpu.
261 */
262 for (cpu = cpumask_first(&init_affinity);
263 (next = cpumask_next(cpu, &init_affinity)) < nr_cpu_ids;
264 cpu = next)
265 ;
266 rc = sched_setaffinity(current->pid, cpumask_of(cpu));
267 if (rc != 0)
268 pr_err("Couldn't set init affinity to cpu %d (%d)\n", cpu, rc);
269 }
270