// 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_read_output *output){	struct cpuid_regs *regs = output->regs; 	for (int i = 0; i < e->maxcnt; i++, regs++)		memset(regs, 0, sizeof(*regs)); 	memset(output->info, 0, sizeof(*output->info));} /* * Leaf read functions: */ /* * Default CPUID read function * Satisfies the requirements stated at 'struct cpuid_parse_entry'->read(). */static voidcpuid_read_generic(const struct cpuid_parse_entry *e, const struct cpuid_read_output *output){	struct cpuid_regs *regs = output->regs; 	for (int i = 0; i < e->maxcnt; i++, regs++, output->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_read_output output = {			.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, &output); 		/*		 * 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, &output);	}} /* * 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 voidcpuid_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);}