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