projects/linux·blob master · refs

245 lines · 4.9 KiB

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
32struct ipi_data {
33 unsigned long bits;
34};
35
36static DEFINE_PER_CPU(struct ipi_data, ipi_data);
37
38static 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 */
70void 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
82static 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
93void 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
123static 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
174int __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
191void __init smp_cpus_done(unsigned int max_cpus)
192{
193}
194
195void __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
216void arch_smp_send_reschedule(int cpu)
217{
218 send_ipi(cpumask_of(cpu), IPI_RESCHEDULE);
219}
220
221void 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
229void arch_send_call_function_single_ipi(int cpu)
230{
231 send_ipi(cpumask_of(cpu), IPI_CALL_FUNC);
232}
233
234void arch_send_call_function_ipi_mask(const struct cpumask *mask)
235{
236 send_ipi(mask, IPI_CALL_FUNC);
237}
238
239void smp_start_cpus(void)
240{
241 int i;
242
243 for (i = 0; i < NR_CPUS; i++)
244 set_cpu_possible(i, true);
245}