diff options
Diffstat (limited to 'src/VBox/Devices/PC/ipxe/src/arch/x86/core/cpuid_settings.c')
-rw-r--r-- | src/VBox/Devices/PC/ipxe/src/arch/x86/core/cpuid_settings.c | 266 |
1 files changed, 266 insertions, 0 deletions
diff --git a/src/VBox/Devices/PC/ipxe/src/arch/x86/core/cpuid_settings.c b/src/VBox/Devices/PC/ipxe/src/arch/x86/core/cpuid_settings.c new file mode 100644 index 00000000..0b67ee91 --- /dev/null +++ b/src/VBox/Devices/PC/ipxe/src/arch/x86/core/cpuid_settings.c @@ -0,0 +1,266 @@ +/* + * Copyright (C) 2013 Michael Brown <mbrown@fensystems.co.uk>. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of the + * License, or any later version. + * + * 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. + * + * You can also choose to distribute this program under the terms of + * the Unmodified Binary Distribution Licence (as given in the file + * COPYING.UBDL), provided that you have satisfied its requirements. + */ + +FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL ); + +#include <string.h> +#include <errno.h> +#include <byteswap.h> +#include <ipxe/init.h> +#include <ipxe/settings.h> +#include <ipxe/cpuid.h> + +/** @file + * + * x86 CPUID settings + * + * CPUID settings are numerically encoded as: + * + * Bit 31 Extended function + * Bits 30-24 (bit 22 = 1) Subfunction number + * (bit 22 = 0) Number of consecutive functions to call, minus one + * Bit 23 Return result as little-endian (used for strings) + * Bit 22 Interpret bits 30-24 as a subfunction number + * Bits 21-18 Unused + * Bits 17-16 Number of registers in register array, minus one + * Bits 15-8 Array of register indices. First entry in array is in + * bits 9-8. Indices are 0-%eax, 1-%ebx, 2-%ecx, 3-%edx. + * Bits 7-0 Starting function number (excluding "extended" bit) + * + * This encoding scheme is designed to allow the common case of + * extracting a single register from a single function to be encoded + * using "cpuid/<register>.<function>", e.g. "cpuid/2.0x80000001" to + * retrieve the value of %ecx from calling CPUID with %eax=0x80000001. + * + * A subfunction (i.e. an input value for %ecx) may be specified using + * "cpuid/<subfunction>.0x40.<register>.<function>". This slightly + * cumbersome syntax is required in order to maintain backwards + * compatibility with older scripts. + */ + +/** CPUID setting tag register indices */ +enum cpuid_registers { + CPUID_EAX = 0, + CPUID_EBX = 1, + CPUID_ECX = 2, + CPUID_EDX = 3, +}; + +/** CPUID setting tag flags */ +enum cpuid_flags { + CPUID_LITTLE_ENDIAN = 0x00800000UL, + CPUID_USE_SUBFUNCTION = 0x00400000UL, +}; + +/** + * Construct CPUID setting tag + * + * @v function Starting function number + * @v subfunction Subfunction, or number of consecutive functions minus 1 + * @v flags Flags + * @v num_registers Number of registers in register array + * @v register1 First register in register array (or zero, if empty) + * @v register2 Second register in register array (or zero, if empty) + * @v register3 Third register in register array (or zero, if empty) + * @v register4 Fourth register in register array (or zero, if empty) + * @ret tag Setting tag + */ +#define CPUID_TAG( function, subfunction, flags, num_registers, \ + register1, register2, register3, register4 ) \ + ( (function) | ( (subfunction) << 24 ) | (flags) | \ + ( ( (num_registers) - 1 ) << 16 ) | \ + ( (register1) << 8 ) | ( (register2) << 10 ) | \ + ( (register3) << 12 ) | ( (register4) << 14 ) ) + +/** + * Extract starting function number from CPUID setting tag + * + * @v tag Setting tag + * @ret function Starting function number + */ +#define CPUID_FUNCTION( tag ) ( (tag) & 0x800000ffUL ) + +/** + * Extract subfunction number from CPUID setting tag + * + * @v tag Setting tag + * @ret subfunction Subfunction number + */ +#define CPUID_SUBFUNCTION( tag ) ( ( (tag) >> 24 ) & 0x7f ) + +/** + * Extract register array from CPUID setting tag + * + * @v tag Setting tag + * @ret registers Register array + */ +#define CPUID_REGISTERS( tag ) ( ( (tag) >> 8 ) & 0xff ) + +/** + * Extract number of registers from CPUID setting tag + * + * @v tag Setting tag + * @ret num_registers Number of registers within register array + */ +#define CPUID_NUM_REGISTERS( tag ) ( ( ( (tag) >> 16 ) & 0x3 ) + 1 ) + +/** CPUID settings scope */ +static const struct settings_scope cpuid_settings_scope; + +/** + * Check applicability of CPUID setting + * + * @v settings Settings block + * @v setting Setting + * @ret applies Setting applies within this settings block + */ +static int cpuid_settings_applies ( struct settings *settings __unused, + const struct setting *setting ) { + + return ( setting->scope == &cpuid_settings_scope ); +} + +/** + * Fetch value of CPUID setting + * + * @v settings Settings block + * @v setting Setting to fetch + * @v data Buffer to fill with setting data + * @v len Length of buffer + * @ret len Length of setting data, or negative error + */ +static int cpuid_settings_fetch ( struct settings *settings, + struct setting *setting, + void *data, size_t len ) { + uint32_t function; + uint32_t subfunction; + uint32_t num_functions; + uint32_t registers; + uint32_t num_registers; + uint32_t buf[4]; + uint32_t output; + size_t frag_len; + size_t result_len = 0; + int rc; + + /* Call each function in turn */ + function = CPUID_FUNCTION ( setting->tag ); + subfunction = CPUID_SUBFUNCTION ( setting->tag ); + if ( setting->tag & CPUID_USE_SUBFUNCTION ) { + num_functions = 1; + } else { + num_functions = ( subfunction + 1 ); + subfunction = 0; + } + for ( ; num_functions-- ; function++ ) { + + /* Fail if this function is not supported */ + if ( ( rc = cpuid_supported ( function ) ) != 0 ) { + DBGC ( settings, "CPUID function %#08x not supported: " + "%s\n", function, strerror ( rc ) ); + return rc; + } + + /* Issue CPUID */ + cpuid ( function, subfunction, &buf[CPUID_EAX], + &buf[CPUID_EBX], &buf[CPUID_ECX], &buf[CPUID_EDX] ); + DBGC ( settings, "CPUID %#08x:%x => %#08x:%#08x:%#08x:%#08x\n", + function, subfunction, buf[0], buf[1], buf[2], buf[3] ); + + /* Copy results to buffer */ + registers = CPUID_REGISTERS ( setting->tag ); + num_registers = CPUID_NUM_REGISTERS ( setting->tag ); + for ( ; num_registers-- ; registers >>= 2 ) { + output = buf[ registers & 0x3 ]; + if ( ! ( setting->tag & CPUID_LITTLE_ENDIAN ) ) + output = cpu_to_be32 ( output ); + frag_len = sizeof ( output ); + if ( frag_len > len ) + frag_len = len; + memcpy ( data, &output, frag_len ); + data += frag_len; + len -= frag_len; + result_len += sizeof ( output ); + } + } + + /* Set type if not already specified */ + if ( ! setting->type ) + setting->type = &setting_type_hexraw; + + return result_len; +} + +/** CPUID settings operations */ +static struct settings_operations cpuid_settings_operations = { + .applies = cpuid_settings_applies, + .fetch = cpuid_settings_fetch, +}; + +/** CPUID settings */ +static struct settings cpuid_settings = { + .refcnt = NULL, + .siblings = LIST_HEAD_INIT ( cpuid_settings.siblings ), + .children = LIST_HEAD_INIT ( cpuid_settings.children ), + .op = &cpuid_settings_operations, + .default_scope = &cpuid_settings_scope, +}; + +/** Initialise CPUID settings */ +static void cpuid_settings_init ( void ) { + int rc; + + if ( ( rc = register_settings ( &cpuid_settings, NULL, + "cpuid" ) ) != 0 ) { + DBG ( "CPUID could not register settings: %s\n", + strerror ( rc ) ); + return; + } +} + +/** CPUID settings initialiser */ +struct init_fn cpuid_settings_init_fn __init_fn ( INIT_NORMAL ) = { + .initialise = cpuid_settings_init, +}; + +/** CPU vendor setting */ +const struct setting cpuvendor_setting __setting ( SETTING_HOST_EXTRA, + cpuvendor ) = { + .name = "cpuvendor", + .description = "CPU vendor", + .tag = CPUID_TAG ( CPUID_VENDOR_ID, 0, CPUID_LITTLE_ENDIAN, 3, + CPUID_EBX, CPUID_EDX, CPUID_ECX, 0 ), + .type = &setting_type_string, + .scope = &cpuid_settings_scope, +}; + +/** CPU model setting */ +const struct setting cpumodel_setting __setting ( SETTING_HOST_EXTRA, + cpumodel ) = { + .name = "cpumodel", + .description = "CPU model", + .tag = CPUID_TAG ( CPUID_MODEL, 2, CPUID_LITTLE_ENDIAN, 4, + CPUID_EAX, CPUID_EBX, CPUID_ECX, CPUID_EDX ), + .type = &setting_type_string, + .scope = &cpuid_settings_scope, +}; |