// SPDX-License-Identifier: GPL-2.0-or-later/* * CPUID parser; for populating the system's CPUID tables. */ #include <linux/kernel.h> #include <asm/cpuid/api.h>#include <asm/processor.h> #include "cpuid_parser.h" /* Clear a single CPUID table entry */static void cpuid_clear(const struct cpuid_parse_entry *e, const struct cpuid_output *out){	struct cpuid_regs *regs = out->regs; 	for (int i = 0; i < e->maxcnt; i++, regs++)		memset(regs, 0, sizeof(*regs)); 	memset(out->info, 0, sizeof(*out->info));} /* * Leaf read functions: */ /* * Default CPUID read function * Satisfies the requirements stated at 'struct cpuid_parse_entry'->read(). */static void cpuid_read_generic(const struct cpuid_parse_entry *e, const struct cpuid_output *out){	struct cpuid_regs *regs = out->regs; 	for (int i = 0; i < e->maxcnt; i++, regs++, out->info->nr_entries++)		cpuid_read_subleaf(e->leaf, e->subleaf + i, regs);} /* * CPUID parser table: */ static const struct cpuid_parse_entry cpuid_parse_entries[] = {	CPUID_PARSE_ENTRIES}; /* * Leaf-independent parser code: */ static unsigned int cpuid_range_max_leaf(const struct cpuid_table *t, unsigned int range){	const struct leaf_0x0_0 *l0 = __cpuid_table_subleaf(t, 0x0, 0); 	switch (range) {	case CPUID_BASE_START:	return l0  ?  l0->max_std_leaf : 0;	default:		return 0;	}} static void __cpuid_reset_table(struct cpuid_table *t, const struct cpuid_parse_entry entries[],				unsigned int nr_entries, unsigned int start, unsigned int end, bool fill){	const struct cpuid_parse_entry *entry = entries;	unsigned int range = CPUID_RANGE(start); 	for (unsigned int i = 0; i < nr_entries; i++, entry++) {		struct cpuid_output out = {			.regs = cpuid_table_regs_p(t, entry->regs_offs),			.info = cpuid_table_info_p(t, entry->info_offs),		}; 		if (entry->leaf < start || entry->leaf > end)			continue; 		cpuid_clear(entry, &out); 		/*		 * Read the range's anchor leaf unconditionally so that the cached		 * maximum valid leaf value is available for the remaining entries.		 */		if (fill && (entry->leaf == range || entry->leaf <= cpuid_range_max_leaf(t, range)))			entry->read(entry, &out);	}} /* * Zero all cached CPUID entries within [@start-@end] range.  This is needed when * certain operations like MSR writes induce changes to the CPU's CPUID layout. */static void __cpuid_zero_table(struct cpuid_table *t, const struct cpuid_parse_entry entries[],			       unsigned int nr_entries, unsigned int start, unsigned int end){	__cpuid_reset_table(t, entries, nr_entries, start, end, false);} static void __cpuid_fill_table(struct cpuid_table *t, const struct cpuid_parse_entry entries[],			       unsigned int nr_entries, unsigned int start, unsigned int end){	__cpuid_reset_table(t, entries, nr_entries, start, end, true);} static void cpuid_fill_table(struct cpuid_table *t, const struct cpuid_parse_entry entries[],			     unsigned int nr_entries){	static const struct {		unsigned int start;		unsigned int end;	} ranges[] = {		{ CPUID_BASE_START, CPUID_BASE_END },	}; 	for (unsigned int i = 0; i < ARRAY_SIZE(ranges); i++)		__cpuid_fill_table(t, entries, nr_entries, ranges[i].start, ranges[i].end);} static void __cpuid_scan_cpu_full(struct cpuinfo_x86 *c){	unsigned int nr_entries = ARRAY_SIZE(cpuid_parse_entries);	struct cpuid_table *table = &c->cpuid; 	cpuid_fill_table(table, cpuid_parse_entries, nr_entries);} static void __cpuid_scan_cpu_partial(struct cpuinfo_x86 *c, unsigned int start_leaf,				     unsigned int end_leaf){	unsigned int nr_entries = ARRAY_SIZE(cpuid_parse_entries);	struct cpuid_table *table = &c->cpuid; 	__cpuid_zero_table(table, cpuid_parse_entries, nr_entries, start_leaf, end_leaf);	__cpuid_fill_table(table, cpuid_parse_entries, nr_entries, start_leaf, end_leaf);} /* * Call-site APIs: */ /** * cpuid_scan_cpu() - Populate current CPU's CPUID table * @c:		CPU capability structure associated with the current CPU * * Populate the CPUID table embedded within @c with parsed CPUID data.  All CPUID * instructions are invoked locally, so this must be called on the CPU associated * with @c. */void cpuid_scan_cpu(struct cpuinfo_x86 *c){	__cpuid_scan_cpu_full(c);} /** * cpuid_refresh_range() - Rescan a CPUID table's leaf range * @c:		CPU capability structure associated with the current CPU * @start:	Start of leaf range to be re-scanned * @end:	End of leaf range */void cpuid_refresh_range(struct cpuinfo_x86 *c, u32 start, u32 end){	if (WARN_ON_ONCE(start > end))		return; 	if (WARN_ON_ONCE(CPUID_RANGE(start) != CPUID_RANGE(end)))		return; 	__cpuid_scan_cpu_partial(c, start, end);} /** * cpuid_refresh_leaf() - Rescan a CPUID table's leaf * @c:		CPU capability structure associated with the current CPU * @leaf:	Leaf to be re-scanned */void cpuid_refresh_leaf(struct cpuinfo_x86 *c, u32 leaf){	cpuid_refresh_range(c, leaf, leaf);}