[mirror_ubuntu-focal-kernel.git] / arch / mips / include / asm / smp.h

/*
 * This file is subject to the terms and conditions of the GNU General
 * Public License.  See the file "COPYING" in the main directory of this
 * archive for more details.
 *
 * Copyright (C) 2000 - 2001 by Kanoj Sarcar (kanoj@sgi.com)
 * Copyright (C) 2000 - 2001 by Silicon Graphics, Inc.
 * Copyright (C) 2000, 2001, 2002 Ralf Baechle
 * Copyright (C) 2000, 2001 Broadcom Corporation
 */
#ifndef __ASM_SMP_H
#define __ASM_SMP_H

#include <linux/bitops.h>
#include <linux/linkage.h>
#include <linux/smp.h>
#include <linux/threads.h>
#include <linux/cpumask.h>

#include <linux/atomic.h>
#include <asm/smp-ops.h>

extern int smp_num_siblings;
extern cpumask_t cpu_sibling_map[];
extern cpumask_t cpu_core_map[];
extern cpumask_t cpu_foreign_map[];

#define raw_smp_processor_id() (current_thread_info()->cpu)

/* Map from cpu id to sequential logical cpu number.  This will only
   not be idempotent when cpus failed to come on-line.	*/
extern int __cpu_number_map[NR_CPUS];
#define cpu_number_map(cpu)  __cpu_number_map[cpu]

/* The reverse map from sequential logical cpu number to cpu id.  */
extern int __cpu_logical_map[NR_CPUS];
#define cpu_logical_map(cpu)  __cpu_logical_map[cpu]

#define NO_PROC_ID	(-1)

#define SMP_RESCHEDULE_YOURSELF 0x1	/* XXX braindead */
#define SMP_CALL_FUNCTION	0x2
/* Octeon - Tell another core to flush its icache */
#define SMP_ICACHE_FLUSH	0x4
#define SMP_ASK_C0COUNT		0x8

/* Mask of CPUs which are currently definitely operating coherently */
extern cpumask_t cpu_coherent_mask;

extern asmlinkage void smp_bootstrap(void);

extern void calculate_cpu_foreign_map(void);

/*
 * this function sends a 'reschedule' IPI to another CPU.
 * it goes straight through and wastes no time serializing
 * anything. Worst case is that we lose a reschedule ...
 */
static inline void smp_send_reschedule(int cpu)
{
	extern const struct plat_smp_ops *mp_ops;	/* private */

	mp_ops->send_ipi_single(cpu, SMP_RESCHEDULE_YOURSELF);
}

#ifdef CONFIG_HOTPLUG_CPU
static inline int __cpu_disable(void)
{
	extern const struct plat_smp_ops *mp_ops;	/* private */

	return mp_ops->cpu_disable();
}

static inline void __cpu_die(unsigned int cpu)
{
	extern const struct plat_smp_ops *mp_ops;	/* private */

	mp_ops->cpu_die(cpu);
}

extern void play_dead(void);
#endif

/*
 * This function will set up the necessary IPIs for Linux to communicate
 * with the CPUs in mask.
 * Return 0 on success.
 */
int mips_smp_ipi_allocate(const struct cpumask *mask);

/*
 * This function will free up IPIs allocated with mips_smp_ipi_allocate to the
 * CPUs in mask, which must be a subset of the IPIs that have been configured.
 * Return 0 on success.
 */
int mips_smp_ipi_free(const struct cpumask *mask);

static inline void arch_send_call_function_single_ipi(int cpu)
{
	extern const struct plat_smp_ops *mp_ops;	/* private */

	mp_ops->send_ipi_mask(cpumask_of(cpu), SMP_CALL_FUNCTION);
}

static inline void arch_send_call_function_ipi_mask(const struct cpumask *mask)
{
	extern const struct plat_smp_ops *mp_ops;	/* private */

	mp_ops->send_ipi_mask(mask, SMP_CALL_FUNCTION);
}

#endif /* __ASM_SMP_H */
Commit	Line	Data
1da177e4 LT	1	/*
	2	* This file is subject to the terms and conditions of the GNU General
	3	* Public License. See the file "COPYING" in the main directory of this
	4	* archive for more details.
	5	*
	6	* Copyright (C) 2000 - 2001 by Kanoj Sarcar (kanoj@sgi.com)
	7	* Copyright (C) 2000 - 2001 by Silicon Graphics, Inc.
	8	* Copyright (C) 2000, 2001, 2002 Ralf Baechle
	9	* Copyright (C) 2000, 2001 Broadcom Corporation
	10	*/
	11	#ifndef __ASM_SMP_H
	12	#define __ASM_SMP_H
	13
1da177e4 LT	14	#include <linux/bitops.h>
1da177e4 LT	15	#include <linux/linkage.h>
631330f5	16	#include <linux/smp.h>
1da177e4 LT	17	#include <linux/threads.h>
1da177e4 LT	18	#include <linux/cpumask.h>
87353d8a	19
60063497	20	#include <linux/atomic.h>
87353d8a	21	#include <asm/smp-ops.h>
1da177e4	22
0ab7aefc RB	23	extern int smp_num_siblings;
0ab7aefc RB	24	extern cpumask_t cpu_sibling_map[];
bda4584c	25	extern cpumask_t cpu_core_map[];
640511ae	26	extern cpumask_t cpu_foreign_map[];
0ab7aefc	27
39c715b7	28	#define raw_smp_processor_id() (current_thread_info()->cpu)
1da177e4 LT	29
1da177e4 LT	30	/* Map from cpu id to sequential logical cpu number. This will only
70342287	31	not be idempotent when cpus failed to come on-line. */
1da177e4 LT	32	extern int __cpu_number_map[NR_CPUS];
	33	#define cpu_number_map(cpu) __cpu_number_map[cpu]
	34
	35	/* The reverse map from sequential logical cpu number to cpu id. */
	36	extern int __cpu_logical_map[NR_CPUS];
	37	#define cpu_logical_map(cpu) __cpu_logical_map[cpu]
	38
	39	#define NO_PROC_ID (-1)
	40
70342287	41	#define SMP_RESCHEDULE_YOURSELF 0x1 /* XXX braindead */
1da177e4	42	#define SMP_CALL_FUNCTION 0x2
ddcdb1b4 DD	43	/* Octeon - Tell another core to flush its icache */
ddcdb1b4 DD	44	#define SMP_ICACHE_FLUSH 0x4
c83c2eed	45	#define SMP_ASK_C0COUNT 0x8
ddcdb1b4	46
76306f42 PB	47	/* Mask of CPUs which are currently definitely operating coherently */
	48	extern cpumask_t cpu_coherent_mask;
	49
b745fcb9	50	extern asmlinkage void smp_bootstrap(void);
1da177e4	51
826e99be JH	52	extern void calculate_cpu_foreign_map(void);
826e99be JH	53
1da177e4 LT	54	/*
	55	* this function sends a 'reschedule' IPI to another CPU.
	56	* it goes straight through and wastes no time serializing
	57	* anything. Worst case is that we lose a reschedule ...
	58	*/
	59	static inline void smp_send_reschedule(int cpu)
	60	{
ff2c8252	61	extern const struct plat_smp_ops mp_ops; / private */
87353d8a RB	62
87353d8a RB	63	mp_ops->send_ipi_single(cpu, SMP_RESCHEDULE_YOURSELF);
1da177e4 LT	64	}
1da177e4 LT	65
1b2bc75c RB	66	#ifdef CONFIG_HOTPLUG_CPU
	67	static inline int __cpu_disable(void)
	68	{
ff2c8252	69	extern const struct plat_smp_ops mp_ops; / private */
1b2bc75c RB	70
	71	return mp_ops->cpu_disable();
	72	}
	73
	74	static inline void __cpu_die(unsigned int cpu)
	75	{
ff2c8252	76	extern const struct plat_smp_ops mp_ops; / private */
1b2bc75c RB	77
	78	mp_ops->cpu_die(cpu);
	79	}
	80
	81	extern void play_dead(void);
	82	#endif
	83
7688c539 MR	84	/*
	85	* This function will set up the necessary IPIs for Linux to communicate
	86	* with the CPUs in mask.
	87	* Return 0 on success.
	88	*/
	89	int mips_smp_ipi_allocate(const struct cpumask *mask);
	90
	91	/*
	92	* This function will free up IPIs allocated with mips_smp_ipi_allocate to the
	93	* CPUs in mask, which must be a subset of the IPIs that have been configured.
	94	* Return 0 on success.
	95	*/
	96	int mips_smp_ipi_free(const struct cpumask *mask);
	97
eef34ec5 RB	98	static inline void arch_send_call_function_single_ipi(int cpu)
eef34ec5 RB	99	{
ff2c8252	100	extern const struct plat_smp_ops mp_ops; / private */
eef34ec5	101
1ed1835f	102	mp_ops->send_ipi_mask(cpumask_of(cpu), SMP_CALL_FUNCTION);
eef34ec5 RB	103	}
	104
	105	static inline void arch_send_call_function_ipi_mask(const struct cpumask *mask)
	106	{
ff2c8252	107	extern const struct plat_smp_ops mp_ops; / private */
eef34ec5 RB	108
	109	mp_ops->send_ipi_mask(mask, SMP_CALL_FUNCTION);
	110	}
2f304c0a	111
1da177e4	112	#endif /* __ASM_SMP_H */