[linux-2.6-block.git] / arch / powerpc / kernel / cputable.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 *  Copyright (C) 2001 Ben. Herrenschmidt (benh@kernel.crashing.org)
 *
 *  Modifications for ppc64:
 *      Copyright (C) 2003 Dave Engebretsen <engebret@us.ibm.com>
 */

#include <linux/string.h>
#include <linux/sched.h>
#include <linux/threads.h>
#include <linux/init.h>
#include <linux/export.h>
#include <linux/jump_label.h>
#include <linux/of.h>

#include <asm/cputable.h>
#include <asm/mce.h>
#include <asm/mmu.h>
#include <asm/setup.h>
#include <asm/cpu_setup.h>

static struct cpu_spec the_cpu_spec __ro_after_init;

struct cpu_spec *cur_cpu_spec __ro_after_init = NULL;
EXPORT_SYMBOL(cur_cpu_spec);

/* The platform string corresponding to the real PVR */
const char *powerpc_base_platform;

#include "cpu_specs.h"

void __init set_cur_cpu_spec(struct cpu_spec *s)
{
	struct cpu_spec *t = &the_cpu_spec;

	t = PTRRELOC(t);
	/*
	 * use memcpy() instead of *t = *s so that GCC replaces it
	 * by __memcpy() when KASAN is active
	 */
	memcpy(t, s, sizeof(*t));

	*PTRRELOC(&cur_cpu_spec) = &the_cpu_spec;
}

static struct cpu_spec * __init setup_cpu_spec(unsigned long offset,
					       struct cpu_spec *s)
{
	struct cpu_spec *t = &the_cpu_spec;
	struct cpu_spec old;

	t = PTRRELOC(t);
	old = *t;

	/*
	 * Copy everything, then do fixups. Use memcpy() instead of *t = *s
	 * so that GCC replaces it by __memcpy() when KASAN is active
	 */
	memcpy(t, s, sizeof(*t));

	/*
	 * If we are overriding a previous value derived from the real
	 * PVR with a new value obtained using a logical PVR value,
	 * don't modify the performance monitor fields.
	 */
	if (old.num_pmcs && !s->num_pmcs) {
		t->num_pmcs = old.num_pmcs;
		t->pmc_type = old.pmc_type;

		/*
		 * Let's ensure that the
		 * fix for the PMAO bug is enabled on compatibility mode.
		 */
		t->cpu_features |= old.cpu_features & CPU_FTR_PMAO_BUG;
	}

	/* Set kuap ON at startup, will be disabled later if cmdline has 'nosmap' */
	if (IS_ENABLED(CONFIG_PPC_KUAP) && IS_ENABLED(CONFIG_PPC32))
		t->mmu_features |= MMU_FTR_KUAP;

	*PTRRELOC(&cur_cpu_spec) = &the_cpu_spec;

	/*
	 * Set the base platform string once; assumes
	 * we're called with real pvr first.
	 */
	if (*PTRRELOC(&powerpc_base_platform) == NULL)
		*PTRRELOC(&powerpc_base_platform) = t->platform;

#if defined(CONFIG_PPC64) || defined(CONFIG_BOOKE)
	/* ppc64 and booke expect identify_cpu to also call setup_cpu for
	 * that processor. I will consolidate that at a later time, for now,
	 * just use #ifdef. We also don't need to PTRRELOC the function
	 * pointer on ppc64 and booke as we are running at 0 in real mode
	 * on ppc64 and reloc_offset is always 0 on booke.
	 */
	if (t->cpu_setup) {
		t->cpu_setup(offset, t);
	}
#endif /* CONFIG_PPC64 || CONFIG_BOOKE */

	return t;
}

struct cpu_spec * __init identify_cpu(unsigned long offset, unsigned int pvr)
{
	struct cpu_spec *s = cpu_specs;
	int i;

	BUILD_BUG_ON(!ARRAY_SIZE(cpu_specs));

	s = PTRRELOC(s);

	for (i = 0; i < ARRAY_SIZE(cpu_specs); i++,s++) {
		if ((pvr & s->pvr_mask) == s->pvr_value)
			return setup_cpu_spec(offset, s);
	}

	BUG();

	return NULL;
}

/*
 * Used by cpufeatures to get the name for CPUs with a PVR table.
 * If they don't hae a PVR table, cpufeatures gets the name from
 * cpu device-tree node.
 */
void __init identify_cpu_name(unsigned int pvr)
{
	struct cpu_spec *s = cpu_specs;
	struct cpu_spec *t = &the_cpu_spec;
	int i;

	s = PTRRELOC(s);
	t = PTRRELOC(t);

	for (i = 0; i < ARRAY_SIZE(cpu_specs); i++,s++) {
		if ((pvr & s->pvr_mask) == s->pvr_value) {
			t->cpu_name = s->cpu_name;
			return;
		}
	}
}


#ifdef CONFIG_JUMP_LABEL_FEATURE_CHECKS
struct static_key_true cpu_feature_keys[NUM_CPU_FTR_KEYS] = {
			[0 ... NUM_CPU_FTR_KEYS - 1] = STATIC_KEY_TRUE_INIT
};
EXPORT_SYMBOL_GPL(cpu_feature_keys);

void __init cpu_feature_keys_init(void)
{
	int i;

	for (i = 0; i < NUM_CPU_FTR_KEYS; i++) {
		unsigned long f = 1ul << i;

		if (!(cur_cpu_spec->cpu_features & f))
			static_branch_disable(&cpu_feature_keys[i]);
	}
}

struct static_key_true mmu_feature_keys[NUM_MMU_FTR_KEYS] = {
			[0 ... NUM_MMU_FTR_KEYS - 1] = STATIC_KEY_TRUE_INIT
};
EXPORT_SYMBOL(mmu_feature_keys);

void __init mmu_feature_keys_init(void)
{
	int i;

	for (i = 0; i < NUM_MMU_FTR_KEYS; i++) {
		unsigned long f = 1ul << i;

		if (!(cur_cpu_spec->mmu_features & f))
			static_branch_disable(&mmu_feature_keys[i]);
	}
}
#endif
Commit	Line	Data
	1	// SPDX-License-Identifier: GPL-2.0-or-later
	2	/*
	3	* Copyright (C) 2001 Ben. Herrenschmidt (benh@kernel.crashing.org)
	4	*
	5	* Modifications for ppc64:
	6	* Copyright (C) 2003 Dave Engebretsen <engebret@us.ibm.com>
	7	*/
	8
	9	#include <linux/string.h>
	10	#include <linux/sched.h>
	11	#include <linux/threads.h>
	12	#include <linux/init.h>
	13	#include <linux/export.h>
	14	#include <linux/jump_label.h>
	15	#include <linux/of.h>
	16
	17	#include <asm/cputable.h>
	18	#include <asm/mce.h>
	19	#include <asm/mmu.h>
	20	#include <asm/setup.h>
	21	#include <asm/cpu_setup.h>
	22
	23	static struct cpu_spec the_cpu_spec __ro_after_init;
	24
	25	struct cpu_spec *cur_cpu_spec __ro_after_init = NULL;
	26	EXPORT_SYMBOL(cur_cpu_spec);
	27
	28	/* The platform string corresponding to the real PVR */
	29	const char *powerpc_base_platform;
	30
	31	#include "cpu_specs.h"
	32
	33	void __init set_cur_cpu_spec(struct cpu_spec *s)
	34	{
	35	struct cpu_spec *t = &the_cpu_spec;
	36
	37	t = PTRRELOC(t);
	38	/*
	39	* use memcpy() instead of t = s so that GCC replaces it
	40	* by __memcpy() when KASAN is active
	41	*/
	42	memcpy(t, s, sizeof(*t));
	43
	44	*PTRRELOC(&cur_cpu_spec) = &the_cpu_spec;
	45	}
	46
	47	static struct cpu_spec * __init setup_cpu_spec(unsigned long offset,
	48	struct cpu_spec *s)
	49	{
	50	struct cpu_spec *t = &the_cpu_spec;
	51	struct cpu_spec old;
	52
	53	t = PTRRELOC(t);
	54	old = *t;
	55
	56	/*
	57	* Copy everything, then do fixups. Use memcpy() instead of t = s
	58	* so that GCC replaces it by __memcpy() when KASAN is active
	59	*/
	60	memcpy(t, s, sizeof(*t));
	61
	62	/*
	63	* If we are overriding a previous value derived from the real
	64	* PVR with a new value obtained using a logical PVR value,
	65	* don't modify the performance monitor fields.
	66	*/
	67	if (old.num_pmcs && !s->num_pmcs) {
	68	t->num_pmcs = old.num_pmcs;
	69	t->pmc_type = old.pmc_type;
	70
	71	/*
	72	* Let's ensure that the
	73	* fix for the PMAO bug is enabled on compatibility mode.
	74	*/
	75	t->cpu_features \|= old.cpu_features & CPU_FTR_PMAO_BUG;
	76	}
	77
	78	/* Set kuap ON at startup, will be disabled later if cmdline has 'nosmap' */
	79	if (IS_ENABLED(CONFIG_PPC_KUAP) && IS_ENABLED(CONFIG_PPC32))
	80	t->mmu_features \|= MMU_FTR_KUAP;
	81
	82	*PTRRELOC(&cur_cpu_spec) = &the_cpu_spec;
	83
	84	/*
	85	* Set the base platform string once; assumes
	86	* we're called with real pvr first.
	87	*/
	88	if (*PTRRELOC(&powerpc_base_platform) == NULL)
	89	*PTRRELOC(&powerpc_base_platform) = t->platform;
	90
	91	#if defined(CONFIG_PPC64) \|\| defined(CONFIG_BOOKE)
	92	/* ppc64 and booke expect identify_cpu to also call setup_cpu for
	93	* that processor. I will consolidate that at a later time, for now,
	94	* just use #ifdef. We also don't need to PTRRELOC the function
	95	* pointer on ppc64 and booke as we are running at 0 in real mode
	96	* on ppc64 and reloc_offset is always 0 on booke.
	97	*/
	98	if (t->cpu_setup) {
	99	t->cpu_setup(offset, t);
	100	}
	101	#endif /* CONFIG_PPC64 \|\| CONFIG_BOOKE */
	102
	103	return t;
	104	}
	105
	106	struct cpu_spec * __init identify_cpu(unsigned long offset, unsigned int pvr)
	107	{
	108	struct cpu_spec *s = cpu_specs;
	109	int i;
	110
	111	BUILD_BUG_ON(!ARRAY_SIZE(cpu_specs));
	112
	113	s = PTRRELOC(s);
	114
	115	for (i = 0; i < ARRAY_SIZE(cpu_specs); i++,s++) {
	116	if ((pvr & s->pvr_mask) == s->pvr_value)
	117	return setup_cpu_spec(offset, s);
	118	}
	119
	120	BUG();
	121
	122	return NULL;
	123	}
	124
	125	/*
	126	* Used by cpufeatures to get the name for CPUs with a PVR table.
	127	* If they don't hae a PVR table, cpufeatures gets the name from
	128	* cpu device-tree node.
	129	*/
	130	void __init identify_cpu_name(unsigned int pvr)
	131	{
	132	struct cpu_spec *s = cpu_specs;
	133	struct cpu_spec *t = &the_cpu_spec;
	134	int i;
	135
	136	s = PTRRELOC(s);
	137	t = PTRRELOC(t);
	138
	139	for (i = 0; i < ARRAY_SIZE(cpu_specs); i++,s++) {
	140	if ((pvr & s->pvr_mask) == s->pvr_value) {
	141	t->cpu_name = s->cpu_name;
	142	return;
	143	}
	144	}
	145	}
	146
	147
	148	#ifdef CONFIG_JUMP_LABEL_FEATURE_CHECKS
	149	struct static_key_true cpu_feature_keys[NUM_CPU_FTR_KEYS] = {
	150	[0 ... NUM_CPU_FTR_KEYS - 1] = STATIC_KEY_TRUE_INIT
	151	};
	152	EXPORT_SYMBOL_GPL(cpu_feature_keys);
	153
	154	void __init cpu_feature_keys_init(void)
	155	{
	156	int i;
	157
	158	for (i = 0; i < NUM_CPU_FTR_KEYS; i++) {
	159	unsigned long f = 1ul << i;
	160
	161	if (!(cur_cpu_spec->cpu_features & f))
	162	static_branch_disable(&cpu_feature_keys[i]);
	163	}
	164	}
	165
	166	struct static_key_true mmu_feature_keys[NUM_MMU_FTR_KEYS] = {
	167	[0 ... NUM_MMU_FTR_KEYS - 1] = STATIC_KEY_TRUE_INIT
	168	};
	169	EXPORT_SYMBOL(mmu_feature_keys);
	170
	171	void __init mmu_feature_keys_init(void)
	172	{
	173	int i;
	174
	175	for (i = 0; i < NUM_MMU_FTR_KEYS; i++) {
	176	unsigned long f = 1ul << i;
	177
	178	if (!(cur_cpu_spec->mmu_features & f))
	179	static_branch_disable(&mmu_feature_keys[i]);
	180	}
	181	}
	182	#endif