2 * SMP support for Hexagon
4 * Copyright (c) 2010-2012, The Linux Foundation. All rights reserved.
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 and
8 * only version 2 as published by the Free Software Foundation.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
21 #include <linux/err.h>
22 #include <linux/errno.h>
23 #include <linux/kernel.h>
24 #include <linux/init.h>
25 #include <linux/interrupt.h>
26 #include <linux/module.h>
27 #include <linux/percpu.h>
28 #include <linux/sched.h>
29 #include <linux/smp.h>
30 #include <linux/spinlock.h>
31 #include <linux/cpu.h>
33 #include <asm/time.h> /* timer_interrupt */
34 #include <asm/hexagon_vm.h>
36 #define BASE_IPI_IRQ 26
39 * cpu_possible_mask needs to be filled out prior to setup_per_cpu_areas
40 * (which is prior to any of our smp_prepare_cpu crap), in order to set
41 * up the... per_cpu areas.
48 static DEFINE_PER_CPU(struct ipi_data
, ipi_data
);
50 static inline void __handle_ipi(unsigned long *ops
, struct ipi_data
*ipi
,
53 unsigned long msg
= 0;
55 msg
= find_next_bit(ops
, BITS_PER_LONG
, msg
+1);
64 generic_smp_call_function_interrupt();
67 case IPI_CALL_FUNC_SINGLE
:
68 generic_smp_call_function_single_interrupt();
82 } while (msg
< BITS_PER_LONG
);
85 /* Used for IPI call from other CPU's to unmask int */
86 void smp_vm_unmask_irq(void *info
)
88 __vmintop_locen((long) info
);
93 * This is based on Alpha's IPI stuff.
94 * Supposed to take (int, void*) as args now.
95 * Specifically, first arg is irq, second is the irq_desc.
98 irqreturn_t
handle_ipi(int irq
, void *desc
)
100 int cpu
= smp_processor_id();
101 struct ipi_data
*ipi
= &per_cpu(ipi_data
, cpu
);
104 while ((ops
= xchg(&ipi
->bits
, 0)) != 0)
105 __handle_ipi(&ops
, ipi
, cpu
);
109 void send_ipi(const struct cpumask
*cpumask
, enum ipi_message_type msg
)
113 unsigned long retval
;
115 local_irq_save(flags
);
117 for_each_cpu(cpu
, cpumask
) {
118 struct ipi_data
*ipi
= &per_cpu(ipi_data
, cpu
);
120 set_bit(msg
, &ipi
->bits
);
121 /* Possible barrier here */
122 retval
= __vmintop_post(BASE_IPI_IRQ
+cpu
);
125 printk(KERN_ERR
"interrupt %ld not configured?\n",
130 local_irq_restore(flags
);
133 static struct irqaction ipi_intdesc
= {
134 .handler
= handle_ipi
,
135 .flags
= IRQF_TRIGGER_RISING
,
136 .name
= "ipi_handler"
139 void __init
smp_prepare_boot_cpu(void)
144 * interrupts should already be disabled from the VM
145 * SP should already be correct; need to set THREADINFO_REG
146 * to point to current thread info
149 void __cpuinit
start_secondary(void)
152 unsigned long thread_ptr
;
154 /* Calculate thread_info pointer from stack pointer */
155 __asm__
__volatile__(
160 thread_ptr
= thread_ptr
& ~(THREAD_SIZE
-1);
162 __asm__
__volatile__(
163 QUOTED_THREADINFO_REG
" = %0;\n"
168 /* Set the memory struct */
169 atomic_inc(&init_mm
.mm_count
);
170 current
->active_mm
= &init_mm
;
172 cpu
= smp_processor_id();
174 setup_irq(BASE_IPI_IRQ
+ cpu
, &ipi_intdesc
);
176 /* Register the clock_event dummy */
177 setup_percpu_clockdev();
179 printk(KERN_INFO
"%s cpu %d\n", __func__
, current_thread_info()->cpu
);
181 notify_cpu_starting(cpu
);
183 set_cpu_online(cpu
, true);
187 cpu_startup_entry(CPUHP_ONLINE
);
192 * called once for each present cpu
193 * apparently starts up the CPU and then
194 * maintains control until "cpu_online(cpu)" is set.
197 int __cpuinit
__cpu_up(unsigned int cpu
, struct task_struct
*idle
)
199 struct thread_info
*thread
= (struct thread_info
*)idle
->stack
;
204 /* Boot to the head. */
205 stack_start
= ((void *) thread
) + THREAD_SIZE
;
206 __vmstart(start_secondary
, stack_start
);
208 while (!cpu_online(cpu
))
214 void __init
smp_cpus_done(unsigned int max_cpus
)
218 void __init
smp_prepare_cpus(unsigned int max_cpus
)
223 * should eventually have some sort of machine
224 * descriptor that has this stuff
227 /* Right now, let's just fake it. */
228 for (i
= 0; i
< max_cpus
; i
++)
229 set_cpu_present(i
, true);
231 /* Also need to register the interrupts for IPI */
233 setup_irq(BASE_IPI_IRQ
, &ipi_intdesc
);
236 void smp_send_reschedule(int cpu
)
238 send_ipi(cpumask_of(cpu
), IPI_RESCHEDULE
);
241 void smp_send_stop(void)
243 struct cpumask targets
;
244 cpumask_copy(&targets
, cpu_online_mask
);
245 cpumask_clear_cpu(smp_processor_id(), &targets
);
246 send_ipi(&targets
, IPI_CPU_STOP
);
249 void arch_send_call_function_single_ipi(int cpu
)
251 send_ipi(cpumask_of(cpu
), IPI_CALL_FUNC_SINGLE
);
254 void arch_send_call_function_ipi_mask(const struct cpumask
*mask
)
256 send_ipi(mask
, IPI_CALL_FUNC
);
259 int setup_profiling_timer(unsigned int multiplier
)
264 void smp_start_cpus(void)
268 for (i
= 0; i
< NR_CPUS
; i
++)
269 set_cpu_possible(i
, true);