[mirror_ubuntu-artful-kernel.git] / arch / hexagon / kernel / smp.c

/*
 * SMP support for Hexagon
 *
 * Copyright (c) 2010-2012, The Linux Foundation. All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 and
 * only version 2 as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301, USA.
 */

#include <linux/err.h>
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/module.h>
#include <linux/percpu.h>
#include <linux/sched/mm.h>
#include <linux/smp.h>
#include <linux/spinlock.h>
#include <linux/cpu.h>
#include <linux/mm_types.h>

#include <asm/time.h>    /*  timer_interrupt  */
#include <asm/hexagon_vm.h>

#define BASE_IPI_IRQ 26

/*
 * cpu_possible_mask needs to be filled out prior to setup_per_cpu_areas
 * (which is prior to any of our smp_prepare_cpu crap), in order to set
 * up the...  per_cpu areas.
 */

struct ipi_data {
	unsigned long bits;
};

static DEFINE_PER_CPU(struct ipi_data, ipi_data);

static inline void __handle_ipi(unsigned long *ops, struct ipi_data *ipi,
				int cpu)
{
	unsigned long msg = 0;
	do {
		msg = find_next_bit(ops, BITS_PER_LONG, msg+1);

		switch (msg) {

		case IPI_TIMER:
			ipi_timer();
			break;

		case IPI_CALL_FUNC:
			generic_smp_call_function_interrupt();
			break;

		case IPI_CPU_STOP:
			/*
			 * call vmstop()
			 */
			__vmstop();
			break;

		case IPI_RESCHEDULE:
			scheduler_ipi();
			break;
		}
	} while (msg < BITS_PER_LONG);
}

/*  Used for IPI call from other CPU's to unmask int  */
void smp_vm_unmask_irq(void *info)
{
	__vmintop_locen((long) info);
}


/*
 * This is based on Alpha's IPI stuff.
 * Supposed to take (int, void*) as args now.
 * Specifically, first arg is irq, second is the irq_desc.
 */

irqreturn_t handle_ipi(int irq, void *desc)
{
	int cpu = smp_processor_id();
	struct ipi_data *ipi = &per_cpu(ipi_data, cpu);
	unsigned long ops;

	while ((ops = xchg(&ipi->bits, 0)) != 0)
		__handle_ipi(&ops, ipi, cpu);
	return IRQ_HANDLED;
}

void send_ipi(const struct cpumask *cpumask, enum ipi_message_type msg)
{
	unsigned long flags;
	unsigned long cpu;
	unsigned long retval;

	local_irq_save(flags);

	for_each_cpu(cpu, cpumask) {
		struct ipi_data *ipi = &per_cpu(ipi_data, cpu);

		set_bit(msg, &ipi->bits);
		/*  Possible barrier here  */
		retval = __vmintop_post(BASE_IPI_IRQ+cpu);

		if (retval != 0) {
			printk(KERN_ERR "interrupt %ld not configured?\n",
				BASE_IPI_IRQ+cpu);
		}
	}

	local_irq_restore(flags);
}

static struct irqaction ipi_intdesc = {
	.handler = handle_ipi,
	.flags = IRQF_TRIGGER_RISING,
	.name = "ipi_handler"
};

void __init smp_prepare_boot_cpu(void)
{
}

/*
 * interrupts should already be disabled from the VM
 * SP should already be correct; need to set THREADINFO_REG
 * to point to current thread info
 */

void start_secondary(void)
{
	unsigned int cpu;
	unsigned long thread_ptr;

	/*  Calculate thread_info pointer from stack pointer  */
	__asm__ __volatile__(
		"%0 = SP;\n"
		: "=r" (thread_ptr)
	);

	thread_ptr = thread_ptr & ~(THREAD_SIZE-1);

	__asm__ __volatile__(
		QUOTED_THREADINFO_REG " = %0;\n"
		:
		: "r" (thread_ptr)
	);

	/*  Set the memory struct  */
	mmgrab(&init_mm);
	current->active_mm = &init_mm;

	cpu = smp_processor_id();

	setup_irq(BASE_IPI_IRQ + cpu, &ipi_intdesc);

	/*  Register the clock_event dummy  */
	setup_percpu_clockdev();

	printk(KERN_INFO "%s cpu %d\n", __func__, current_thread_info()->cpu);

	notify_cpu_starting(cpu);

	set_cpu_online(cpu, true);

	local_irq_enable();

	cpu_startup_entry(CPUHP_AP_ONLINE_IDLE);
}


/*
 * called once for each present cpu
 * apparently starts up the CPU and then
 * maintains control until "cpu_online(cpu)" is set.
 */

int __cpu_up(unsigned int cpu, struct task_struct *idle)
{
	struct thread_info *thread = (struct thread_info *)idle->stack;
	void *stack_start;

	thread->cpu = cpu;

	/*  Boot to the head.  */
	stack_start =  ((void *) thread) + THREAD_SIZE;
	__vmstart(start_secondary, stack_start);

	while (!cpu_online(cpu))
		barrier();

	return 0;
}

void __init smp_cpus_done(unsigned int max_cpus)
{
}

void __init smp_prepare_cpus(unsigned int max_cpus)
{
	int i;

	/*
	 * should eventually have some sort of machine
	 * descriptor that has this stuff
	 */

	/*  Right now, let's just fake it. */
	for (i = 0; i < max_cpus; i++)
		set_cpu_present(i, true);

	/*  Also need to register the interrupts for IPI  */
	if (max_cpus > 1)
		setup_irq(BASE_IPI_IRQ, &ipi_intdesc);
}

void smp_send_reschedule(int cpu)
{
	send_ipi(cpumask_of(cpu), IPI_RESCHEDULE);
}

void smp_send_stop(void)
{
	struct cpumask targets;
	cpumask_copy(&targets, cpu_online_mask);
	cpumask_clear_cpu(smp_processor_id(), &targets);
	send_ipi(&targets, IPI_CPU_STOP);
}

void arch_send_call_function_single_ipi(int cpu)
{
	send_ipi(cpumask_of(cpu), IPI_CALL_FUNC);
}

void arch_send_call_function_ipi_mask(const struct cpumask *mask)
{
	send_ipi(mask, IPI_CALL_FUNC);
}

int setup_profiling_timer(unsigned int multiplier)
{
	return -EINVAL;
}

void smp_start_cpus(void)
{
	int i;

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