xref: /kernel/linux/linux-6.6/arch/hexagon/kernel/smp.c (revision 62306a36) 
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
82irqreturn_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
117void __init smp_prepare_boot_cpu(void)
118{
119}
120
121/*
122 * interrupts should already be disabled from the VM
123 * SP should already be correct; need to set THREADINFO_REG
124 * to point to current thread info
125 */
126
127void start_secondary(void)
128{
129	unsigned long thread_ptr;
130	unsigned int cpu, irq;
131
132	/*  Calculate thread_info pointer from stack pointer  */
133	__asm__ __volatile__(
134		"%0 = SP;\n"
135		: "=r" (thread_ptr)
136	);
137
138	thread_ptr = thread_ptr & ~(THREAD_SIZE-1);
139
140	__asm__ __volatile__(
141		QUOTED_THREADINFO_REG " = %0;\n"
142		:
143		: "r" (thread_ptr)
144	);
145
146	/*  Set the memory struct  */
147	mmgrab(&init_mm);
148	current->active_mm = &init_mm;
149
150	cpu = smp_processor_id();
151
152	irq = BASE_IPI_IRQ + cpu;
153	if (request_irq(irq, handle_ipi, IRQF_TRIGGER_RISING, "ipi_handler",
154			NULL))
155		pr_err("Failed to request irq %u (ipi_handler)\n", irq);
156
157	/*  Register the clock_event dummy  */
158	setup_percpu_clockdev();
159
160	printk(KERN_INFO "%s cpu %d\n", __func__, current_thread_info()->cpu);
161
162	notify_cpu_starting(cpu);
163
164	set_cpu_online(cpu, true);
165
166	local_irq_enable();
167
168	cpu_startup_entry(CPUHP_AP_ONLINE_IDLE);
169}
170
171
172/*
173 * called once for each present cpu
174 * apparently starts up the CPU and then
175 * maintains control until "cpu_online(cpu)" is set.
176 */
177
178int __cpu_up(unsigned int cpu, struct task_struct *idle)
179{
180	struct thread_info *thread = (struct thread_info *)idle->stack;
181	void *stack_start;
182
183	thread->cpu = cpu;
184
185	/*  Boot to the head.  */
186	stack_start =  ((void *) thread) + THREAD_SIZE;
187	__vmstart(start_secondary, stack_start);
188
189	while (!cpu_online(cpu))
190		barrier();
191
192	return 0;
193}
194
195void __init smp_cpus_done(unsigned int max_cpus)
196{
197}
198
199void __init smp_prepare_cpus(unsigned int max_cpus)
200{
201	int i, irq = BASE_IPI_IRQ;
202
203	/*
204	 * should eventually have some sort of machine
205	 * descriptor that has this stuff
206	 */
207
208	/*  Right now, let's just fake it. */
209	for (i = 0; i < max_cpus; i++)
210		set_cpu_present(i, true);
211
212	/*  Also need to register the interrupts for IPI  */
213	if (max_cpus > 1) {
214		if (request_irq(irq, handle_ipi, IRQF_TRIGGER_RISING,
215				"ipi_handler", NULL))
216			pr_err("Failed to request irq %d (ipi_handler)\n", irq);
217	}
218}
219
220void arch_smp_send_reschedule(int cpu)
221{
222	send_ipi(cpumask_of(cpu), IPI_RESCHEDULE);
223}
224
225void smp_send_stop(void)
226{
227	struct cpumask targets;
228	cpumask_copy(&targets, cpu_online_mask);
229	cpumask_clear_cpu(smp_processor_id(), &targets);
230	send_ipi(&targets, IPI_CPU_STOP);
231}
232
233void arch_send_call_function_single_ipi(int cpu)
234{
235	send_ipi(cpumask_of(cpu), IPI_CALL_FUNC);
236}
237
238void arch_send_call_function_ipi_mask(const struct cpumask *mask)
239{
240	send_ipi(mask, IPI_CALL_FUNC);
241}
242
243void smp_start_cpus(void)
244{
245	int i;
246
247	for (i = 0; i < NR_CPUS; i++)
248		set_cpu_possible(i, true);
249}
250