cpuid.c

/*
 * cpuid.c --
 *
 *		Implements CPUID querying functions
 *
 */
#include "cpuid.h"

cpuid_t cpuid_data0;
cpuid_t cpuid_data80;

unsigned num_logical_cpus = 1;		// number of logical cpus per physical package
unsigned num_cores_per_package = 1;  // number of cores in each physical cpu package
unsigned num_hyper_threads_per_core = 1;		// number of hyper-threads per core

void cpuid_get(unsigned n, cpuid_t *data) {
	data->eax = n;
	GET_CPUID(data->eax, data->ebx, data->ecx, data->edx);
}


/*  cpuid_get_vendor_string ---
 *
 *  This function gets the vendor string from the processor's cpuid instruction
 *  and passes it back to the caller in an easy to use structure.
 */
cpuid_vendor_string_t
cpuid_get_vendor_string(void) {
	static cpuid_vendor_string_t v;

	/* Note: the string gets passed in EBX-EDX-ECX, not the intuitive order. */
	v.uint32_array[0] = cpuid_data0.ebx;
	v.uint32_array[1] = cpuid_data0.edx;
	v.uint32_array[2] = cpuid_data0.ecx;
	v.char_array[CPUID_VENDOR_STR_LENGTH-1] = '\0';
	return v;
}

/*  cpuid_get_version ---
 *
 *  This function reads the processors version information using CPUID and puts
 *  it into a union for easy use by the caller.
 */
cpuid_version_t
cpuid_get_version(void) {
	cpuid_version_t v;
	uint32_t junkEBX = 0, junkECX = 0, junkEDX = 0;
	v.flat = 0x1;
	GET_CPUID(v.flat, junkEBX, junkECX, junkEDX);
	return v;
}


cpuid_feature_flags_t
cpuid_get_feature_flags(void) {
	cpuid_feature_flags_t f;
	uint32_t junkEAX = 0x1, junkEBX = 0;
	GET_CPUID(junkEAX, junkEBX, f.uint32_array[1], f.uint32_array[0]);
	return f;
}

/*
 *-----------------------------------------------------------------------------
 *
 * cpuid_get_ext_feature_flags --
 *
 *	 Passes back the caller the extended feature flags supported by
 *	 this CPU.  This can be used, among other things, to determine if the
 *	 processor supports long mode.
 *
 * Results:
 *	 Returns TRUE if the processor supports the extended feature flags
 *	 CPUID node, and FALSE otherwise.
 *
 * Side effects:
 *	 Calls CPUID a couple of times.
 *
 *-----------------------------------------------------------------------------
 */

bool cpuid_get_ext_feature_flags(cpuid_ext_feature_flags_t *f) { // OUT: Flags for this CPU
	uint32_t eax, ebx, ecx;

	if (cpuid_data80.eax < 0x80000001) {
		// Extended feature flags not supported on this CPU
		return FALSE;
	}
	eax = CPUID_EXTENDED_FEATURE;
	GET_CPUID(eax, ebx, ecx, f->flat);
	return TRUE;
}

#define CHAR_TO_INT(a,b,c,d) ((a) + (b) * 0x100 + (c) * 0x10000 + (d) * 0x1000000)

bool cpuid_is_vendor_amd(void) {
	return cpuid_data0.ebx == CHAR_TO_INT('A', 'u', 't', 'h')
		&& cpuid_data0.edx == CHAR_TO_INT('e', 'n', 't', 'i')
		&& cpuid_data0.ecx == CHAR_TO_INT('c', 'A', 'M', 'D');
}


bool cpuid_is_vendor_intel(void) {
	return cpuid_data0.ebx == CHAR_TO_INT('G', 'e', 'n', 'u')
		&& cpuid_data0.edx == CHAR_TO_INT('i', 'n', 'e', 'I')
		&& cpuid_data0.ecx == CHAR_TO_INT('n', 't', 'e', 'l');
}

/*
 *-----------------------------------------------------------------------------
 *
 * cpuid_is_family_p4 --
 *
 *	 Returns TRUE if the processor we're running on is an Intel processor
 *	 of the P4 family.
 *
 * Results:
 *	 The obvious.
 *
 *-----------------------------------------------------------------------------
 */

bool cpuid_is_family_p4(void) {
	cpuid_version_t v = cpuid_get_version();

	return cpuid_is_vendor_intel() && v.bits.family == CPUID_FAMILY_EXTENDED &&
		v.bits.extendedFamily == CPUID_EXTENDED_FAMILY_PENTIUM4;
}

/*
 *-----------------------------------------------------------------------------
 *
 * cpuid_is_family_p6 --
 *
 *	 Returns TRUE if the processor we're running on belongs to the P6 family.
 *
 * Results:
 *	 The obvious.
 *
 *-----------------------------------------------------------------------------
 */

bool cpuid_is_family_p6(void) {
	cpuid_version_t v = cpuid_get_version();

	return cpuid_is_vendor_intel() && v.bits.family == CPUID_FAMILY_P6;
}

/*
 *-----------------------------------------------------------------------------
 *
 * cpuid_is_family_opteron --
 *
 *	 Returns TRUE if the processor we're running on belongs to the
 *	 Opteron family.
 *
 *-----------------------------------------------------------------------------
 */

bool cpuid_is_family_opteron(void) {
	cpuid_version_t v = cpuid_get_version();
	return cpuid_is_vendor_amd() && CPUID_FAMILY_IS_OPTERON(v.flat);
}

/*
 *-----------------------------------------------------------------------------
 *
 * cpuid_init --
 *
 *	 Executes CPUID and caches values in cpuid_data0 abd cpuid_data80.
 *
 *-----------------------------------------------------------------------------
 */
void cpuid_init(void) {
	//bool htt = FALSE;
	cpuid_t id1;

	/* First get the basic cpuid information on what the
	 * type of the processor is , i.e intel or amd etc
	 * and how much of extra cpuid information is available
	 * with the processor
	 */
	cpuid_data0.eax = 0;
	GET_CPUID(cpuid_data0.eax, cpuid_data0.ebx,
		  cpuid_data0.ecx, cpuid_data0.edx);


	/* Find out if hyper-threading is available and there is more than one
	 * logical processor.  See section 7.6.3 in Intel IA-32 volume III.
	 */
	cpuid_get(1, &id1);

	if (cpuid_is_vendor_intel()) {
		if (cpuid_is_family_p6()) {
			// Extended CPUID features not supported on PIII
			return;
		}
		if (cpuid_is_family_p4()) {
			/*
			 * Multi-core processors have the HT feature bit set (even if they
			 * don't support HT).
			 * The number of HT is the total number, not per-core number.
			 * The number of cores is off by 1, i.e. single-core reports 0.
			 */
			//htt = id1.edx & CPUID_FEATURE_COMMON_ID1EDX_HT;
			if (id1.edx & CPUID_FEATURE_COMMON_ID1EDX_HT) {
				num_hyper_threads_per_core = (id1.ebx >> 16) & 0xff;
				if (cpuid_max_func() >= 4) {
			 cpuid_t id4;
			 cpuid_get(4, &id4);
			 num_cores_per_package = ((id4.eax >> 26) & 0x3f) + 1;
					num_hyper_threads_per_core /=  num_cores_per_package;
				}
			}
		}
	} else if (cpuid_is_vendor_amd()) {
		cpuid_data80.eax = 0x80000000;
		GET_CPUID(cpuid_data80.eax, cpuid_data80.ebx,
		  cpuid_data80.ecx, cpuid_data80.edx);
		if (cpuid_max_ext_func() >= 0x80000008) {
	/* Number of cores is reported in extended function 0x80000008
	 * For legacy multi-core support, AMD CPUs report the number of cores as
	 * hyper-threads. Adjust the numbers to reflect that there are no
	 * threads. */
	cpuid_t id88;
	cpuid_get(0x80000008, &id88);
	num_cores_per_package = id88.ecx & 0xff;
	num_hyper_threads_per_core = 1;
		}
	} else {
		/* Unknown cpu type. we use the defaults */
	}
}