openrisc: add tick timer multi-core sync logic
[sfrench/cifs-2.6.git] / arch / openrisc / kernel / smp.c
1 /*
2  * Copyright (C) 2014 Stefan Kristiansson <stefan.kristiansson@saunalahti.fi>
3  * Copyright (C) 2017 Stafford Horne <shorne@gmail.com>
4  *
5  * Based on arm64 and arc implementations
6  * Copyright (C) 2013 ARM Ltd.
7  * Copyright (C) 2004, 2007-2010, 2011-2012 Synopsys, Inc. (www.synopsys.com)
8  *
9  * This file is licensed under the terms of the GNU General Public License
10  * version 2.  This program is licensed "as is" without any warranty of any
11  * kind, whether express or implied.
12  */
13
14 #include <linux/smp.h>
15 #include <linux/cpu.h>
16 #include <linux/sched.h>
17 #include <linux/irq.h>
18 #include <asm/cpuinfo.h>
19 #include <asm/mmu_context.h>
20 #include <asm/tlbflush.h>
21 #include <asm/cacheflush.h>
22 #include <asm/time.h>
23
24 static void (*smp_cross_call)(const struct cpumask *, unsigned int);
25
26 unsigned long secondary_release = -1;
27 struct thread_info *secondary_thread_info;
28
29 enum ipi_msg_type {
30         IPI_WAKEUP,
31         IPI_RESCHEDULE,
32         IPI_CALL_FUNC,
33         IPI_CALL_FUNC_SINGLE,
34 };
35
36 static DEFINE_SPINLOCK(boot_lock);
37
38 static void boot_secondary(unsigned int cpu, struct task_struct *idle)
39 {
40         /*
41          * set synchronisation state between this boot processor
42          * and the secondary one
43          */
44         spin_lock(&boot_lock);
45
46         secondary_release = cpu;
47         smp_cross_call(cpumask_of(cpu), IPI_WAKEUP);
48
49         /*
50          * now the secondary core is starting up let it run its
51          * calibrations, then wait for it to finish
52          */
53         spin_unlock(&boot_lock);
54 }
55
56 void __init smp_prepare_boot_cpu(void)
57 {
58 }
59
60 void __init smp_init_cpus(void)
61 {
62         int i;
63
64         for (i = 0; i < NR_CPUS; i++)
65                 set_cpu_possible(i, true);
66 }
67
68 void __init smp_prepare_cpus(unsigned int max_cpus)
69 {
70         int i;
71
72         /*
73          * Initialise the present map, which describes the set of CPUs
74          * actually populated at the present time.
75          */
76         for (i = 0; i < max_cpus; i++)
77                 set_cpu_present(i, true);
78 }
79
80 void __init smp_cpus_done(unsigned int max_cpus)
81 {
82 }
83
84 static DECLARE_COMPLETION(cpu_running);
85
86 int __cpu_up(unsigned int cpu, struct task_struct *idle)
87 {
88         if (smp_cross_call == NULL) {
89                 pr_warn("CPU%u: failed to start, IPI controller missing",
90                         cpu);
91                 return -EIO;
92         }
93
94         secondary_thread_info = task_thread_info(idle);
95         current_pgd[cpu] = init_mm.pgd;
96
97         boot_secondary(cpu, idle);
98         if (!wait_for_completion_timeout(&cpu_running,
99                                         msecs_to_jiffies(1000))) {
100                 pr_crit("CPU%u: failed to start\n", cpu);
101                 return -EIO;
102         }
103         synchronise_count_master(cpu);
104
105         return 0;
106 }
107
108 asmlinkage __init void secondary_start_kernel(void)
109 {
110         struct mm_struct *mm = &init_mm;
111         unsigned int cpu = smp_processor_id();
112         /*
113          * All kernel threads share the same mm context; grab a
114          * reference and switch to it.
115          */
116         atomic_inc(&mm->mm_count);
117         current->active_mm = mm;
118         cpumask_set_cpu(cpu, mm_cpumask(mm));
119
120         pr_info("CPU%u: Booted secondary processor\n", cpu);
121
122         setup_cpuinfo();
123         openrisc_clockevent_init();
124
125         notify_cpu_starting(cpu);
126
127         /*
128          * OK, now it's safe to let the boot CPU continue
129          */
130         set_cpu_online(cpu, true);
131         complete(&cpu_running);
132
133         synchronise_count_slave(cpu);
134
135         local_irq_enable();
136
137         preempt_disable();
138         /*
139          * OK, it's off to the idle thread for us
140          */
141         cpu_startup_entry(CPUHP_AP_ONLINE_IDLE);
142 }
143
144 void handle_IPI(unsigned int ipi_msg)
145 {
146         unsigned int cpu = smp_processor_id();
147
148         switch (ipi_msg) {
149         case IPI_WAKEUP:
150                 break;
151
152         case IPI_RESCHEDULE:
153                 scheduler_ipi();
154                 break;
155
156         case IPI_CALL_FUNC:
157                 generic_smp_call_function_interrupt();
158                 break;
159
160         case IPI_CALL_FUNC_SINGLE:
161                 generic_smp_call_function_single_interrupt();
162                 break;
163
164         default:
165                 WARN(1, "CPU%u: Unknown IPI message 0x%x\n", cpu, ipi_msg);
166                 break;
167         }
168 }
169
170 void smp_send_reschedule(int cpu)
171 {
172         smp_cross_call(cpumask_of(cpu), IPI_RESCHEDULE);
173 }
174
175 static void stop_this_cpu(void *dummy)
176 {
177         /* Remove this CPU */
178         set_cpu_online(smp_processor_id(), false);
179
180         local_irq_disable();
181         /* CPU Doze */
182         if (mfspr(SPR_UPR) & SPR_UPR_PMP)
183                 mtspr(SPR_PMR, mfspr(SPR_PMR) | SPR_PMR_DME);
184         /* If that didn't work, infinite loop */
185         while (1)
186                 ;
187 }
188
189 void smp_send_stop(void)
190 {
191         smp_call_function(stop_this_cpu, NULL, 0);
192 }
193
194 /* not supported, yet */
195 int setup_profiling_timer(unsigned int multiplier)
196 {
197         return -EINVAL;
198 }
199
200 void __init set_smp_cross_call(void (*fn)(const struct cpumask *, unsigned int))
201 {
202         smp_cross_call = fn;
203 }
204
205 void arch_send_call_function_single_ipi(int cpu)
206 {
207         smp_cross_call(cpumask_of(cpu), IPI_CALL_FUNC_SINGLE);
208 }
209
210 void arch_send_call_function_ipi_mask(const struct cpumask *mask)
211 {
212         smp_cross_call(mask, IPI_CALL_FUNC);
213 }
214
215 /* TLB flush operations - Performed on each CPU*/
216 static inline void ipi_flush_tlb_all(void *ignored)
217 {
218         local_flush_tlb_all();
219 }
220
221 void flush_tlb_all(void)
222 {
223         on_each_cpu(ipi_flush_tlb_all, NULL, 1);
224 }
225
226 /*
227  * FIXME: implement proper functionality instead of flush_tlb_all.
228  * *But*, as things currently stands, the local_tlb_flush_* functions will
229  * all boil down to local_tlb_flush_all anyway.
230  */
231 void flush_tlb_mm(struct mm_struct *mm)
232 {
233         on_each_cpu(ipi_flush_tlb_all, NULL, 1);
234 }
235
236 void flush_tlb_page(struct vm_area_struct *vma, unsigned long uaddr)
237 {
238         on_each_cpu(ipi_flush_tlb_all, NULL, 1);
239 }
240
241 void flush_tlb_range(struct vm_area_struct *vma,
242                      unsigned long start, unsigned long end)
243 {
244         on_each_cpu(ipi_flush_tlb_all, NULL, 1);
245 }
246
247 /* Instruction cache invalidate - performed on each cpu */
248 static void ipi_icache_page_inv(void *arg)
249 {
250         struct page *page = arg;
251
252         local_icache_page_inv(page);
253 }
254
255 void smp_icache_page_inv(struct page *page)
256 {
257         on_each_cpu(ipi_icache_page_inv, page, 1);
258 }
259 EXPORT_SYMBOL(smp_icache_page_inv);