1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * SMP support for Hexagon
4 *
5 * Copyright (c) 2010-2012, The Linux Foundation. All rights reserved.
6 */
7
8 #include <linux/err.h>
9 #include <linux/errno.h>
10 #include <linux/kernel.h>
11 #include <linux/init.h>
12 #include <linux/interrupt.h>
13 #include <linux/module.h>
14 #include <linux/percpu.h>
15 #include <linux/sched/mm.h>
16 #include <linux/smp.h>
17 #include <linux/spinlock.h>
18 #include <linux/cpu.h>
19 #include <linux/mm_types.h>
20
21 #include <asm/time.h> /* timer_interrupt */
22 #include <asm/hexagon_vm.h>
23
24 #define BASE_IPI_IRQ 26
25
26 /*
27 * cpu_possible_mask needs to be filled out prior to setup_per_cpu_areas
28 * (which is prior to any of our smp_prepare_cpu crap), in order to set
29 * up the... per_cpu areas.
30 */
31
32 struct ipi_data {
33 unsigned long bits;
34 };
35
36 static DEFINE_PER_CPU(struct ipi_data, ipi_data);
37
__handle_ipi(unsigned long * ops,struct ipi_data * ipi,int cpu)38 static inline void __handle_ipi(unsigned long *ops, struct ipi_data *ipi,
39 int cpu)
40 {
41 unsigned long msg = 0;
42 do {
43 msg = find_next_bit(ops, BITS_PER_LONG, msg+1);
44
45 switch (msg) {
46
47 case IPI_TIMER:
48 ipi_timer();
49 break;
50
51 case IPI_CALL_FUNC:
52 generic_smp_call_function_interrupt();
53 break;
54
55 case IPI_CPU_STOP:
56 /*
57 * call vmstop()
58 */
59 __vmstop();
60 break;
61
62 case IPI_RESCHEDULE:
63 scheduler_ipi();
64 break;
65 }
66 } while (msg < BITS_PER_LONG);
67 }
68
69 /* Used for IPI call from other CPU's to unmask int */
smp_vm_unmask_irq(void * info)70 void smp_vm_unmask_irq(void *info)
71 {
72 __vmintop_locen((long) info);
73 }
74
75
76 /*
77 * This is based on Alpha's IPI stuff.
78 * Supposed to take (int, void*) as args now.
79 * Specifically, first arg is irq, second is the irq_desc.
80 */
81
handle_ipi(int irq,void * desc)82 static irqreturn_t handle_ipi(int irq, void *desc)
83 {
84 int cpu = smp_processor_id();
85 struct ipi_data *ipi = &per_cpu(ipi_data, cpu);
86 unsigned long ops;
87
88 while ((ops = xchg(&ipi->bits, 0)) != 0)
89 __handle_ipi(&ops, ipi, cpu);
90 return IRQ_HANDLED;
91 }
92
send_ipi(const struct cpumask * cpumask,enum ipi_message_type msg)93 void send_ipi(const struct cpumask *cpumask, enum ipi_message_type msg)
94 {
95 unsigned long flags;
96 unsigned long cpu;
97 unsigned long retval;
98
99 local_irq_save(flags);
100
101 for_each_cpu(cpu, cpumask) {
102 struct ipi_data *ipi = &per_cpu(ipi_data, cpu);
103
104 set_bit(msg, &ipi->bits);
105 /* Possible barrier here */
106 retval = __vmintop_post(BASE_IPI_IRQ+cpu);
107
108 if (retval != 0) {
109 printk(KERN_ERR "interrupt %ld not configured?\n",
110 BASE_IPI_IRQ+cpu);
111 }
112 }
113
114 local_irq_restore(flags);
115 }
116
117 /*
118 * interrupts should already be disabled from the VM
119 * SP should already be correct; need to set THREADINFO_REG
120 * to point to current thread info
121 */
122
start_secondary(void)123 static void start_secondary(void)
124 {
125 unsigned long thread_ptr;
126 unsigned int cpu, irq;
127
128 /* Calculate thread_info pointer from stack pointer */
129 __asm__ __volatile__(
130 "%0 = SP;\n"
131 : "=r" (thread_ptr)
132 );
133
134 thread_ptr = thread_ptr & ~(THREAD_SIZE-1);
135
136 __asm__ __volatile__(
137 QUOTED_THREADINFO_REG " = %0;\n"
138 :
139 : "r" (thread_ptr)
140 );
141
142 /* Set the memory struct */
143 mmgrab(&init_mm);
144 current->active_mm = &init_mm;
145
146 cpu = smp_processor_id();
147
148 irq = BASE_IPI_IRQ + cpu;
149 if (request_irq(irq, handle_ipi, IRQF_TRIGGER_RISING, "ipi_handler",
150 NULL))
151 pr_err("Failed to request irq %u (ipi_handler)\n", irq);
152
153 /* Register the clock_event dummy */
154 setup_percpu_clockdev();
155
156 printk(KERN_INFO "%s cpu %d\n", __func__, current_thread_info()->cpu);
157
158 notify_cpu_starting(cpu);
159
160 set_cpu_online(cpu, true);
161
162 local_irq_enable();
163
164 cpu_startup_entry(CPUHP_AP_ONLINE_IDLE);
165 }
166
167
168 /*
169 * called once for each present cpu
170 * apparently starts up the CPU and then
171 * maintains control until "cpu_online(cpu)" is set.
172 */
173
__cpu_up(unsigned int cpu,struct task_struct * idle)174 int __cpu_up(unsigned int cpu, struct task_struct *idle)
175 {
176 struct thread_info *thread = (struct thread_info *)idle->stack;
177 void *stack_start;
178
179 thread->cpu = cpu;
180
181 /* Boot to the head. */
182 stack_start = ((void *) thread) + THREAD_SIZE;
183 __vmstart(start_secondary, stack_start);
184
185 while (!cpu_online(cpu))
186 barrier();
187
188 return 0;
189 }
190
smp_cpus_done(unsigned int max_cpus)191 void __init smp_cpus_done(unsigned int max_cpus)
192 {
193 }
194
smp_prepare_cpus(unsigned int max_cpus)195 void __init smp_prepare_cpus(unsigned int max_cpus)
196 {
197 int i, irq = BASE_IPI_IRQ;
198
199 /*
200 * should eventually have some sort of machine
201 * descriptor that has this stuff
202 */
203
204 /* Right now, let's just fake it. */
205 for (i = 0; i < max_cpus; i++)
206 set_cpu_present(i, true);
207
208 /* Also need to register the interrupts for IPI */
209 if (max_cpus > 1) {
210 if (request_irq(irq, handle_ipi, IRQF_TRIGGER_RISING,
211 "ipi_handler", NULL))
212 pr_err("Failed to request irq %d (ipi_handler)\n", irq);
213 }
214 }
215
arch_smp_send_reschedule(int cpu)216 void arch_smp_send_reschedule(int cpu)
217 {
218 send_ipi(cpumask_of(cpu), IPI_RESCHEDULE);
219 }
220
smp_send_stop(void)221 void smp_send_stop(void)
222 {
223 struct cpumask targets;
224 cpumask_copy(&targets, cpu_online_mask);
225 cpumask_clear_cpu(smp_processor_id(), &targets);
226 send_ipi(&targets, IPI_CPU_STOP);
227 }
228
arch_send_call_function_single_ipi(int cpu)229 void arch_send_call_function_single_ipi(int cpu)
230 {
231 send_ipi(cpumask_of(cpu), IPI_CALL_FUNC);
232 }
233
arch_send_call_function_ipi_mask(const struct cpumask * mask)234 void arch_send_call_function_ipi_mask(const struct cpumask *mask)
235 {
236 send_ipi(mask, IPI_CALL_FUNC);
237 }
238
smp_start_cpus(void)239 void smp_start_cpus(void)
240 {
241 int i;
242
243 for (i = 0; i < NR_CPUS; i++)
244 set_cpu_possible(i, true);
245 }
246