| 1 | /*␊ |
| 2 | * Copyright 2008 Islam Ahmed Zaid. All rights reserved. <azismed@gmail.com>␊ |
| 3 | * AsereBLN: 2009: cleanup and bugfix␊ |
| 4 | */␊ |
| 5 | ␊ |
| 6 | #include "libsaio.h"␊ |
| 7 | #include "platform.h"␊ |
| 8 | #include "cpu.h"␊ |
| 9 | #include "bootstruct.h"␊ |
| 10 | #include "boot.h"␊ |
| 11 | ␊ |
| 12 | #ifndef DEBUG_CPU␊ |
| 13 | #define DEBUG_CPU 0␊ |
| 14 | #endif␊ |
| 15 | ␊ |
| 16 | #if DEBUG_CPU␊ |
| 17 | #define DBG(x...)␉␉printf(x)␊ |
| 18 | #else␊ |
| 19 | #define DBG(x...)␉␉msglog(x)␊ |
| 20 | #endif␊ |
| 21 | ␊ |
| 22 | /*␊ |
| 23 | * timeRDTSC()␊ |
| 24 | * This routine sets up PIT counter 2 to count down 1/20 of a second.␊ |
| 25 | * It pauses until the value is latched in the counter␊ |
| 26 | * and then reads the time stamp counter to return to the caller.␊ |
| 27 | */␊ |
| 28 | uint64_t timeRDTSC(void)␊ |
| 29 | {␊ |
| 30 | ␉int␉␉attempts = 0;␊ |
| 31 | ␉uint64_t latchTime;␊ |
| 32 | ␉uint64_t␉saveTime,intermediate;␊ |
| 33 | ␉unsigned int timerValue, lastValue;␊ |
| 34 | ␉//boolean_t␉int_enabled;␊ |
| 35 | ␉/*␊ |
| 36 | ␉ * Table of correction factors to account for␊ |
| 37 | ␉ *␉ - timer counter quantization errors, and␊ |
| 38 | ␉ *␉ - undercounts 0..5␊ |
| 39 | ␉ */␊ |
| 40 | #define SAMPLE_CLKS_EXACT␉(((double) CLKNUM) / 20.0)␊ |
| 41 | #define SAMPLE_CLKS_INT␉␉((int) CLKNUM / 20)␊ |
| 42 | #define SAMPLE_NSECS␉␉(2000000000LL)␊ |
| 43 | #define SAMPLE_MULTIPLIER␉(((double)SAMPLE_NSECS)*SAMPLE_CLKS_EXACT)␊ |
| 44 | #define ROUND64(x)␉␉((uint64_t)((x) + 0.5))␊ |
| 45 | ␉uint64_t␉scale[6] = {␊ |
| 46 | ␉␉ROUND64(SAMPLE_MULTIPLIER/(double)(SAMPLE_CLKS_INT-0)), ␊ |
| 47 | ␉␉ROUND64(SAMPLE_MULTIPLIER/(double)(SAMPLE_CLKS_INT-1)), ␊ |
| 48 | ␉␉ROUND64(SAMPLE_MULTIPLIER/(double)(SAMPLE_CLKS_INT-2)), ␊ |
| 49 | ␉␉ROUND64(SAMPLE_MULTIPLIER/(double)(SAMPLE_CLKS_INT-3)), ␊ |
| 50 | ␉␉ROUND64(SAMPLE_MULTIPLIER/(double)(SAMPLE_CLKS_INT-4)), ␊ |
| 51 | ␉␉ROUND64(SAMPLE_MULTIPLIER/(double)(SAMPLE_CLKS_INT-5))␊ |
| 52 | ␉};␊ |
| 53 | ␊ |
| 54 | ␉//int_enabled = ml_set_interrupts_enabled(FALSE);␊ |
| 55 | ␊ |
| 56 | restart:␊ |
| 57 | ␉if (attempts >= 9) // increase to up to 9 attempts.␊ |
| 58 | ␉{␊ |
| 59 | ␉ // This will flash-reboot. TODO: Use tscPanic instead.␊ |
| 60 | ␉␉printf("Timestamp counter calibation failed with %d attempts\n", attempts);␊ |
| 61 | ␉}␊ |
| 62 | ␉attempts++;␊ |
| 63 | ␉enable_PIT2();␉␉// turn on PIT2␊ |
| 64 | ␉set_PIT2(0);␉␉// reset timer 2 to be zero␊ |
| 65 | ␉latchTime = rdtsc64();␉// get the time stamp to time␊ |
| 66 | ␉latchTime = get_PIT2(&timerValue) - latchTime; // time how long this takes␊ |
| 67 | ␉set_PIT2(SAMPLE_CLKS_INT);␉// set up the timer for (almost) 1/20th a second␊ |
| 68 | ␉saveTime = rdtsc64();␉// now time how long a 20th a second is...␊ |
| 69 | ␉get_PIT2(&lastValue);␊ |
| 70 | ␉get_PIT2(&lastValue);␉// read twice, first value may be unreliable␊ |
| 71 | ␉do {␊ |
| 72 | ␉␉intermediate = get_PIT2(&timerValue);␊ |
| 73 | ␉␉if (timerValue > lastValue)␊ |
| 74 | ␉␉{␊ |
| 75 | ␉␉␉// Timer wrapped␊ |
| 76 | ␉␉␉set_PIT2(0);␊ |
| 77 | ␉␉␉disable_PIT2();␊ |
| 78 | ␉␉␉goto restart;␊ |
| 79 | ␉␉}␊ |
| 80 | ␉␉lastValue = timerValue;␊ |
| 81 | ␉} while (timerValue > 5);␊ |
| 82 | ␉printf("timerValue␉ %d\n",timerValue);␊ |
| 83 | ␉printf("intermediate 0x%016llx\n",intermediate);␊ |
| 84 | ␉printf("saveTime␉ 0x%016llx\n",saveTime);␊ |
| 85 | ␊ |
| 86 | ␉intermediate -= saveTime;␉␉// raw count for about 1/20 second␊ |
| 87 | ␉intermediate *= scale[timerValue];␉// rescale measured time spent␊ |
| 88 | ␉intermediate /= SAMPLE_NSECS;␉// so its exactly 1/20 a second␊ |
| 89 | ␉intermediate += latchTime;␉␉// add on our save fudge␊ |
| 90 | ␊ |
| 91 | ␉set_PIT2(0);␉␉␉// reset timer 2 to be zero␊ |
| 92 | ␉disable_PIT2();␉␉␉// turn off PIT 2␊ |
| 93 | ␊ |
| 94 | ␉//ml_set_interrupts_enabled(int_enabled);␊ |
| 95 | ␉return intermediate;␊ |
| 96 | }␊ |
| 97 | ␊ |
| 98 | /*␊ |
| 99 | * DFE: Measures the TSC frequency in Hz (64-bit) using the ACPI PM timer␊ |
| 100 | */␊ |
| 101 | static uint64_t measure_tsc_frequency(void)␊ |
| 102 | {␊ |
| 103 | ␉uint64_t tscStart;␊ |
| 104 | ␉uint64_t tscEnd;␊ |
| 105 | ␉uint64_t tscDelta = 0xffffffffffffffffULL;␊ |
| 106 | ␉unsigned long pollCount;␊ |
| 107 | ␉uint64_t retval = 0;␊ |
| 108 | ␉int i;␊ |
| 109 | ␊ |
| 110 | ␉/* Time how many TSC ticks elapse in 30 msec using the 8254 PIT␊ |
| 111 | ␉ * counter 2. We run this loop 3 times to make sure the cache␊ |
| 112 | ␉ * is hot and we take the minimum delta from all of the runs.␊ |
| 113 | ␉ * That is to say that we're biased towards measuring the minimum␊ |
| 114 | ␉ * number of TSC ticks that occur while waiting for the timer to␊ |
| 115 | ␉ * expire. That theoretically helps avoid inconsistencies when␊ |
| 116 | ␉ * running under a VM if the TSC is not virtualized and the host␊ |
| 117 | ␉ * steals time.␉ The TSC is normally virtualized for VMware.␊ |
| 118 | ␉ */␊ |
| 119 | ␉for(i = 0; i < 10; ++i)␊ |
| 120 | ␉{␊ |
| 121 | ␉␉enable_PIT2();␊ |
| 122 | ␉␉set_PIT2_mode0(CALIBRATE_LATCH);␊ |
| 123 | ␉␉tscStart = rdtsc64();␊ |
| 124 | ␉␉pollCount = poll_PIT2_gate();␊ |
| 125 | ␉␉tscEnd = rdtsc64();␊ |
| 126 | ␉␉/* The poll loop must have run at least a few times for accuracy */␊ |
| 127 | ␉␉if (pollCount <= 1) {␊ |
| 128 | ␉␉␉continue;␊ |
| 129 | ␉␉}␊ |
| 130 | ␉␉/* The TSC must increment at LEAST once every millisecond.␊ |
| 131 | ␉␉ * We should have waited exactly 30 msec so the TSC delta should␊ |
| 132 | ␉␉ * be >= 30. Anything less and the processor is way too slow.␊ |
| 133 | ␉␉ */␊ |
| 134 | ␉␉if ((tscEnd - tscStart) <= CALIBRATE_TIME_MSEC) {␊ |
| 135 | ␉␉␉continue;␊ |
| 136 | ␉␉}␊ |
| 137 | ␉␉// tscDelta = MIN(tscDelta, (tscEnd - tscStart))␊ |
| 138 | ␉␉if ( (tscEnd - tscStart) < tscDelta ) {␊ |
| 139 | ␉␉␉tscDelta = tscEnd - tscStart;␊ |
| 140 | ␉␉}␊ |
| 141 | ␉}␊ |
| 142 | ␉/* tscDelta is now the least number of TSC ticks the processor made in␊ |
| 143 | ␉ * a timespan of 0.03 s (e.g. 30 milliseconds)␊ |
| 144 | ␉ * Linux thus divides by 30 which gives the answer in kiloHertz because␊ |
| 145 | ␉ * 1 / ms = kHz. But we're xnu and most of the rest of the code uses␊ |
| 146 | ␉ * Hz so we need to convert our milliseconds to seconds. Since we're␊ |
| 147 | ␉ * dividing by the milliseconds, we simply multiply by 1000.␊ |
| 148 | ␉ */␊ |
| 149 | ␊ |
| 150 | ␉/* Unlike linux, we're not limited to 32-bit, but we do need to take care␊ |
| 151 | ␉ * that we're going to multiply by 1000 first so we do need at least some␊ |
| 152 | ␉ * arithmetic headroom. For now, 32-bit should be enough.␊ |
| 153 | ␉ * Also unlike Linux, our compiler can do 64-bit integer arithmetic.␊ |
| 154 | ␉ */␊ |
| 155 | ␉if (tscDelta > (1ULL<<32)) {␊ |
| 156 | ␉␉retval = 0;␊ |
| 157 | ␉} else {␊ |
| 158 | ␉␉retval = tscDelta * 1000 / 30;␊ |
| 159 | ␉}␊ |
| 160 | ␉disable_PIT2();␊ |
| 161 | ␉return retval;␊ |
| 162 | }␊ |
| 163 | ␊ |
| 164 | /*␊ |
| 165 | * Original comment/code:␊ |
| 166 | * "DFE: Measures the Max Performance Frequency in Hz (64-bit)"␊ |
| 167 | *␊ |
| 168 | * Measures the Actual Performance Frequency in Hz (64-bit)␊ |
| 169 | * (just a naming change, mperf --> aperf )␊ |
| 170 | */␊ |
| 171 | static uint64_t measure_aperf_frequency(void)␊ |
| 172 | {␊ |
| 173 | ␉uint64_t aperfStart;␊ |
| 174 | ␉uint64_t aperfEnd;␊ |
| 175 | ␉uint64_t aperfDelta = 0xffffffffffffffffULL;␊ |
| 176 | ␉unsigned long pollCount;␊ |
| 177 | ␉uint64_t retval = 0;␊ |
| 178 | ␉int i;␊ |
| 179 | ␊ |
| 180 | ␉/* Time how many APERF ticks elapse in 30 msec using the 8254 PIT␊ |
| 181 | ␉ * counter 2. We run this loop 3 times to make sure the cache␊ |
| 182 | ␉ * is hot and we take the minimum delta from all of the runs.␊ |
| 183 | ␉ * That is to say that we're biased towards measuring the minimum␊ |
| 184 | ␉ * number of APERF ticks that occur while waiting for the timer to␊ |
| 185 | ␉ * expire.␊ |
| 186 | ␉ */␊ |
| 187 | ␉for(i = 0; i < 10; ++i)␊ |
| 188 | ␉{␊ |
| 189 | ␉␉enable_PIT2();␊ |
| 190 | ␉␉set_PIT2_mode0(CALIBRATE_LATCH);␊ |
| 191 | ␉␉aperfStart = rdmsr64(MSR_AMD_APERF);␊ |
| 192 | ␉␉pollCount = poll_PIT2_gate();␊ |
| 193 | ␉␉aperfEnd = rdmsr64(MSR_AMD_APERF);␊ |
| 194 | ␉␉/* The poll loop must have run at least a few times for accuracy */␊ |
| 195 | ␉␉if (pollCount <= 1) {␊ |
| 196 | ␉␉␉continue;␊ |
| 197 | ␉␉}␊ |
| 198 | ␉␉/* The TSC must increment at LEAST once every millisecond.␊ |
| 199 | ␉␉ * We should have waited exactly 30 msec so the APERF delta should␊ |
| 200 | ␉␉ * be >= 30. Anything less and the processor is way too slow.␊ |
| 201 | ␉␉ */␊ |
| 202 | ␉␉if ((aperfEnd - aperfStart) <= CALIBRATE_TIME_MSEC) {␊ |
| 203 | ␉␉␉continue;␊ |
| 204 | ␉␉}␊ |
| 205 | ␉␉// tscDelta = MIN(tscDelta, (tscEnd - tscStart))␊ |
| 206 | ␉␉if ( (aperfEnd - aperfStart) < aperfDelta ) {␊ |
| 207 | ␉␉␉aperfDelta = aperfEnd - aperfStart;␊ |
| 208 | ␉␉}␊ |
| 209 | ␉}␊ |
| 210 | ␉/* mperfDelta is now the least number of MPERF ticks the processor made in␊ |
| 211 | ␉ * a timespan of 0.03 s (e.g. 30 milliseconds)␊ |
| 212 | ␉ */␊ |
| 213 | ␊ |
| 214 | ␉if (aperfDelta > (1ULL<<32)) {␊ |
| 215 | ␉␉retval = 0;␊ |
| 216 | ␉} else {␊ |
| 217 | ␉␉retval = aperfDelta * 1000 / 30;␊ |
| 218 | ␉}␊ |
| 219 | ␉disable_PIT2();␊ |
| 220 | ␉return retval;␊ |
| 221 | }␊ |
| 222 | ␊ |
| 223 | /*␊ |
| 224 | * Calculates the FSB and CPU frequencies using specific MSRs for each CPU␊ |
| 225 | * - multi. is read from a specific MSR. In the case of Intel, there is:␊ |
| 226 | *␉ a max multi. (used to calculate the FSB freq.),␊ |
| 227 | *␉ and a current multi. (used to calculate the CPU freq.)␊ |
| 228 | * - fsbFrequency = tscFrequency / multi␊ |
| 229 | * - cpuFrequency = fsbFrequency * multi␊ |
| 230 | */␊ |
| 231 | void scan_cpu(PlatformInfo_t *p)␊ |
| 232 | {␊ |
| 233 | ␉uint64_t␉tscFrequency = 0;␊ |
| 234 | ␉uint64_t␉fsbFrequency = 0;␊ |
| 235 | ␉uint64_t␉cpuFrequency =0;␊ |
| 236 | ␉uint64_t␉msr = 0;␊ |
| 237 | ␉uint64_t␉flex_ratio = 0;␊ |
| 238 | ␉uint32_t␉max_ratio = 0;␊ |
| 239 | ␉uint32_t␉min_ratio = 0;␊ |
| 240 | ␉uint8_t␉␉bus_ratio_max = 0;␊ |
| 241 | ␉uint8_t␉␉bus_ratio_min = 0;␊ |
| 242 | ␉uint8_t␉␉currdiv = 0;␊ |
| 243 | ␉uint8_t␉␉currcoef = 0;␊ |
| 244 | ␉uint8_t␉␉maxdiv = 0;␊ |
| 245 | ␉uint8_t␉␉maxcoef = 0;␊ |
| 246 | ␊ |
| 247 | ␉const char␉*newratio;␊ |
| 248 | ␉int␉␉len = 0;␊ |
| 249 | ␉␊ |
| 250 | ␉/* get cpuid values */␊ |
| 251 | ␉do_cpuid(0x00000000, p->CPU.CPUID[CPUID_0]);␊ |
| 252 | ␉do_cpuid(0x00000001, p->CPU.CPUID[CPUID_1]);␊ |
| 253 | ␉do_cpuid(0x00000002, p->CPU.CPUID[CPUID_2]);␊ |
| 254 | ␉do_cpuid(0x00000003, p->CPU.CPUID[CPUID_3]);␊ |
| 255 | ␉do_cpuid2(0x00000004, 0, p->CPU.CPUID[CPUID_4]);␊ |
| 256 | ␉do_cpuid(0x80000000, p->CPU.CPUID[CPUID_80]);␊ |
| 257 | ␉if (p->CPU.CPUID[CPUID_0][0] >= 0x5) {␉␉␊ |
| 258 | ␉␉do_cpuid(5, p->CPU.CPUID[CPUID_5]); ␉␊ |
| 259 | ␉}␉␊ |
| 260 | ␉if (p->CPU.CPUID[CPUID_0][0] >= 6) {␊ |
| 261 | ␉␉do_cpuid(6, p->CPU.CPUID[CPUID_6]);␉␉␊ |
| 262 | ␉}␊ |
| 263 | ␉if ((p->CPU.CPUID[CPUID_80][0] & 0x0000000f) >= 8) {␊ |
| 264 | ␉␉do_cpuid(0x80000008, p->CPU.CPUID[CPUID_88]);␊ |
| 265 | ␉␉do_cpuid(0x80000001, p->CPU.CPUID[CPUID_81]);␊ |
| 266 | ␉} else if ((p->CPU.CPUID[CPUID_80][0] & 0x0000000f) >= 1) {␊ |
| 267 | ␉␉do_cpuid(0x80000001, p->CPU.CPUID[CPUID_81]);␊ |
| 268 | ␉}␊ |
| 269 | ␉␊ |
| 270 | #if DEBUG_CPU␊ |
| 271 | ␉{␊ |
| 272 | ␉␉int␉␉i;␊ |
| 273 | ␉␉printf("CPUID Raw Values:\n");␊ |
| 274 | ␉␉for (i=0; i<CPUID_MAX; i++) {␊ |
| 275 | ␉␉␉printf("%02d: %08x-%08x-%08x-%08x\n", i,␊ |
| 276 | ␉␉␉␉ p->CPU.CPUID[i][0], p->CPU.CPUID[i][1],␊ |
| 277 | ␉␉␉␉ p->CPU.CPUID[i][2], p->CPU.CPUID[i][3]);␊ |
| 278 | ␉␉}␊ |
| 279 | ␉}␊ |
| 280 | #endif␊ |
| 281 | ␊ |
| 282 | /*␊ |
| 283 | EAX (Intel):␊ |
| 284 | 31 28 27 20 19 16 1514 1312 11 8 7 4 3 0␊ |
| 285 | +--------+----------------+--------+----+----+--------+--------+--------+␊ |
| 286 | |########|Extended family |Extmodel|####|type|familyid| model |stepping|␊ |
| 287 | +--------+----------------+--------+----+----+--------+--------+--------+␊ |
| 288 | ␊ |
| 289 | EAX (AMD):␊ |
| 290 | 31 28 27 20 19 16 1514 1312 11 8 7 4 3 0␊ |
| 291 | +--------+----------------+--------+----+----+--------+--------+--------+␊ |
| 292 | |########|Extended family |Extmodel|####|####|familyid| model |stepping|␊ |
| 293 | +--------+----------------+--------+----+----+--------+--------+--------+␊ |
| 294 | */␊ |
| 295 | ␊ |
| 296 | ␉p->CPU.Vendor␉␉= p->CPU.CPUID[CPUID_0][1];␊ |
| 297 | ␉p->CPU.Signature␉= p->CPU.CPUID[CPUID_1][0];␊ |
| 298 | ␉p->CPU.Stepping␉␉= bitfield(p->CPU.CPUID[CPUID_1][0], 3, 0); // stepping = cpu_feat_eax & 0xF;␊ |
| 299 | ␉p->CPU.Model␉␉= bitfield(p->CPU.CPUID[CPUID_1][0], 7, 4); // model = (cpu_feat_eax >> 4) & 0xF;␊ |
| 300 | ␉p->CPU.Family␉␉= bitfield(p->CPU.CPUID[CPUID_1][0], 11, 8); // family = (cpu_feat_eax >> 8) & 0xF;␊ |
| 301 | ␉//p->CPU.Type␉␉= bitfield(p->CPU.CPUID[CPUID_1][0], 13, 12); // type = (cpu_feat_eax >> 12) & 0x3;␊ |
| 302 | ␉p->CPU.ExtModel␉␉= bitfield(p->CPU.CPUID[CPUID_1][0], 19, 16); // ext_model = (cpu_feat_eax >> 16) & 0xF;␊ |
| 303 | ␉p->CPU.ExtFamily␉= bitfield(p->CPU.CPUID[CPUID_1][0], 27, 20); // ext_family = (cpu_feat_eax >> 20) & 0xFF;␊ |
| 304 | ␉p->CPU.Model += (p->CPU.ExtModel << 4);␊ |
| 305 | ␉␊ |
| 306 | ␉if (p->CPU.Vendor == CPUID_VENDOR_INTEL &&␊ |
| 307 | ␉␉p->CPU.Family == 0x06 &&␊ |
| 308 | ␉␉p->CPU.Model >= CPU_MODEL_NEHALEM &&␊ |
| 309 | ␉␉p->CPU.Model != CPU_MODEL_ATOM␉␉// MSR is *NOT* available on the Intel Atom CPU␊ |
| 310 | ␉␉) {␊ |
| 311 | ␉␉msr = rdmsr64(MSR_CORE_THREAD_COUNT);␉␉␉␉␉// MacMan: Undocumented MSR in Nehalem and newer CPUs␊ |
| 312 | ␉␉p->CPU.NoCores␉␉= bitfield((uint32_t)msr, 31, 16);␉// MacMan: Using undocumented MSR to get actual values␊ |
| 313 | ␉␉p->CPU.NoThreads␉= bitfield((uint32_t)msr, 15, 0);␉// MacMan: Using undocumented MSR to get actual values␊ |
| 314 | ␉} else if (p->CPU.Vendor == CPUID_VENDOR_AMD) {␊ |
| 315 | ␉␉p->CPU.NoThreads␉= bitfield(p->CPU.CPUID[CPUID_1][1], 23, 16);␊ |
| 316 | ␉␉p->CPU.NoCores␉␉= bitfield(p->CPU.CPUID[CPUID_88][2], 7, 0) + 1;␊ |
| 317 | ␉} else {␊ |
| 318 | ␉␉// Use previous method for Cores and Threads␊ |
| 319 | ␉␉p->CPU.NoThreads␉= bitfield(p->CPU.CPUID[CPUID_1][1], 23, 16);␊ |
| 320 | ␉␉p->CPU.NoCores␉␉= bitfield(p->CPU.CPUID[CPUID_4][0], 31, 26) + 1;␊ |
| 321 | ␉}␊ |
| 322 | ␉␊ |
| 323 | ␉/* get brand string (if supported) */␊ |
| 324 | ␉/* Copyright: from Apple's XNU cpuid.c */␊ |
| 325 | ␉if (p->CPU.CPUID[CPUID_80][0] > 0x80000004) {␊ |
| 326 | ␉␉uint32_t␉reg[4];␊ |
| 327 | ␉␉char␉␉str[128], *s;␊ |
| 328 | ␉␉/*␊ |
| 329 | ␉␉ * The brand string 48 bytes (max), guaranteed to␊ |
| 330 | ␉␉ * be NULL terminated.␊ |
| 331 | ␉␉ */␊ |
| 332 | ␉␉do_cpuid(0x80000002, reg);␊ |
| 333 | ␉␉bcopy((char *)reg, &str[0], 16);␊ |
| 334 | ␉␉do_cpuid(0x80000003, reg);␊ |
| 335 | ␉␉bcopy((char *)reg, &str[16], 16);␊ |
| 336 | ␉␉do_cpuid(0x80000004, reg);␊ |
| 337 | ␉␉bcopy((char *)reg, &str[32], 16);␊ |
| 338 | ␉␉for (s = str; *s != '\0'; s++) {␊ |
| 339 | ␉␉␉if (*s != ' ') {␊ |
| 340 | break;␊ |
| 341 | }␊ |
| 342 | ␉␉}␊ |
| 343 | ␉␉␊ |
| 344 | ␉␉strlcpy(p->CPU.BrandString, s, sizeof(p->CPU.BrandString));␊ |
| 345 | ␉␉␊ |
| 346 | ␉␉if (!strncmp(p->CPU.BrandString, CPU_STRING_UNKNOWN, MIN(sizeof(p->CPU.BrandString), strlen(CPU_STRING_UNKNOWN) + 1))) {␊ |
| 347 | ␉␉␉/*␊ |
| 348 | ␉␉␉ * This string means we have a firmware-programmable brand string,␊ |
| 349 | ␉␉␉ * and the firmware couldn't figure out what sort of CPU we have.␊ |
| 350 | ␉␉␉ */␊ |
| 351 | ␉␉␉p->CPU.BrandString[0] = '\0';␊ |
| 352 | ␉␉}␊ |
| 353 | ␉}␊ |
| 354 | ␉␊ |
| 355 | ␉/* setup features */␊ |
| 356 | ␉if ((bit(23) & p->CPU.CPUID[CPUID_1][3]) != 0) {␊ |
| 357 | ␉␉p->CPU.Features |= CPU_FEATURE_MMX;␊ |
| 358 | ␉}␊ |
| 359 | ␉if ((bit(25) & p->CPU.CPUID[CPUID_1][3]) != 0) {␊ |
| 360 | ␉␉p->CPU.Features |= CPU_FEATURE_SSE;␊ |
| 361 | ␉}␊ |
| 362 | ␉if ((bit(26) & p->CPU.CPUID[CPUID_1][3]) != 0) {␊ |
| 363 | ␉␉p->CPU.Features |= CPU_FEATURE_SSE2;␊ |
| 364 | ␉}␊ |
| 365 | ␉if ((bit(0) & p->CPU.CPUID[CPUID_1][2]) != 0) {␊ |
| 366 | ␉␉p->CPU.Features |= CPU_FEATURE_SSE3;␊ |
| 367 | ␉}␊ |
| 368 | ␉if ((bit(19) & p->CPU.CPUID[CPUID_1][2]) != 0) {␊ |
| 369 | ␉␉p->CPU.Features |= CPU_FEATURE_SSE41;␊ |
| 370 | ␉}␊ |
| 371 | ␉if ((bit(20) & p->CPU.CPUID[CPUID_1][2]) != 0) {␊ |
| 372 | ␉␉p->CPU.Features |= CPU_FEATURE_SSE42;␊ |
| 373 | ␉}␊ |
| 374 | ␉if ((bit(29) & p->CPU.CPUID[CPUID_81][3]) != 0) {␊ |
| 375 | ␉␉p->CPU.Features |= CPU_FEATURE_EM64T;␊ |
| 376 | ␉}␊ |
| 377 | ␉if ((bit(5) & p->CPU.CPUID[CPUID_1][3]) != 0) {␊ |
| 378 | ␉␉p->CPU.Features |= CPU_FEATURE_MSR;␊ |
| 379 | ␉}␊ |
| 380 | ␉//if ((bit(28) & p->CPU.CPUID[CPUID_1][3]) != 0) {␊ |
| 381 | ␉if (p->CPU.NoThreads > p->CPU.NoCores) {␊ |
| 382 | ␉␉p->CPU.Features |= CPU_FEATURE_HTT;␊ |
| 383 | ␉}␊ |
| 384 | ␊ |
| 385 | ␉tscFrequency = measure_tsc_frequency();␊ |
| 386 | ␉/* if usual method failed */␊ |
| 387 | ␉if ( tscFrequency < 1000 ) { //TEST␊ |
| 388 | ␉tscFrequency = timeRDTSC() * 20;␊ |
| 389 | ␉}␊ |
| 390 | ␉fsbFrequency = 0;␊ |
| 391 | ␉cpuFrequency = 0;␊ |
| 392 | ␊ |
| 393 | ␉if ((p->CPU.Vendor == CPUID_VENDOR_INTEL) && ((p->CPU.Family == 0x06) || (p->CPU.Family == 0x0f))) {␊ |
| 394 | ␉␉int intelCPU = p->CPU.Model;␊ |
| 395 | ␉␉if ((p->CPU.Family == 0x06 && p->CPU.Model >= 0x0c) || (p->CPU.Family == 0x0f && p->CPU.Model >= 0x03)) {␊ |
| 396 | ␉␉␉/* Nehalem CPU model */␊ |
| 397 | ␉␉␉if (p->CPU.Family == 0x06 && (␊ |
| 398 | p->CPU.Model == CPU_MODEL_NEHALEM ||␊ |
| 399 | ␉␉␉␉␉p->CPU.Model == CPU_MODEL_FIELDS ||␊ |
| 400 | ␉␉␉␉␉p->CPU.Model == CPU_MODEL_DALES ||␊ |
| 401 | ␉␉␉␉␉p->CPU.Model == CPU_MODEL_DALES_32NM ||␊ |
| 402 | ␉␉␉␉␉p->CPU.Model == CPU_MODEL_WESTMERE ||␊ |
| 403 | ␉␉␉␉␉p->CPU.Model == CPU_MODEL_NEHALEM_EX ||␊ |
| 404 | ␉␉␉␉␉p->CPU.Model == CPU_MODEL_WESTMERE_EX ||␊ |
| 405 | ␉␉␉␉␉p->CPU.Model == CPU_MODEL_SANDYBRIDGE ||␊ |
| 406 | ␉␉␉␉␉p->CPU.Model == CPU_MODEL_JAKETOWN ||␊ |
| 407 | ␉␉␉␉␉p->CPU.Model == CPU_MODEL_IVYBRIDGE ||␊ |
| 408 | p->CPU.Model == CPU_MODEL_IVYBRIDGE_XEON||␊ |
| 409 | p->CPU.Model == CPU_MODEL_HASWELL ||␊ |
| 410 | ␉␉␉␉␉p->CPU.Model == CPU_MODEL_HASWELL_SVR ||␊ |
| 411 | ␉␉␉␉␉p->CPU.Model == CPU_MODEL_HASWELL_ULT ||␊ |
| 412 | ␉␉␉␉␉p->CPU.Model == CPU_MODEL_CRYSTALWELL ||␊ |
| 413 | ␉␉␉␉␉p->CPU.Model == CPU_MODEL_BROADWELL )){␊ |
| 414 | ␉␉␉␉msr = rdmsr64(MSR_PLATFORM_INFO);␊ |
| 415 | //␉␉␉␉DBG("msr(%d): platform_info %08x\n", __LINE__, bitfield(msr, 31, 0));␊ |
| 416 | ␉␉␉␉bus_ratio_max = bitfield(msr, 15, 8);␉//MacMan: Changed bitfield to match Apple tsc.c␊ |
| 417 | ␉␉␉␉bus_ratio_min = bitfield(msr, 47, 40);␉//MacMan: Changed bitfield to match Apple tsc.c␊ |
| 418 | ␉␉␉␉msr = rdmsr64(MSR_FLEX_RATIO);␊ |
| 419 | //␉␉␉␉DBG("msr(%d): flex_ratio %08x\n", __LINE__, bitfield(msr, 31, 0));␊ |
| 420 | ␉␉␉␉if (bitfield(msr, 16, 16)) {␊ |
| 421 | ␉␉␉␉␉flex_ratio = bitfield(msr, 15, 8);␉//MacMan: Changed bitfield to match Apple tsc.c␊ |
| 422 | ␉␉␉␉␉if (flex_ratio == 0) {␊ |
| 423 | ␉␉␉␉␉␉/* Clear bit 16 (evidently the presence bit) */␊ |
| 424 | ␉␉␉␉␉␉wrmsr64(MSR_FLEX_RATIO, (msr & 0xFFFFFFFFFFFEFFFFULL));␊ |
| 425 | ␉␉␉␉␉␉msr = rdmsr64(MSR_FLEX_RATIO);␊ |
| 426 | //␉␉␉␉␉␉verbose("Unusable flex ratio detected. Patched MSR now %08x\n", bitfield(msr, 31, 0));␊ |
| 427 | ␉␉␉␉␉} else {␊ |
| 428 | ␉␉␉␉␉␉if (bus_ratio_max > flex_ratio) {␊ |
| 429 | ␉␉␉␉␉␉␉bus_ratio_max = flex_ratio;␊ |
| 430 | ␉␉␉␉␉␉}␊ |
| 431 | ␉␉␉␉␉}␊ |
| 432 | ␉␉␉␉}␊ |
| 433 | ␉␉␉␉␊ |
| 434 | ␉␉␉␉if (bus_ratio_max) {␊ |
| 435 | ␉␉␉␉␉fsbFrequency = (tscFrequency / bus_ratio_max);␊ |
| 436 | ␉␉␉␉}␊ |
| 437 | ␉␉␉␉//MacMan: Turbo Ratio Limit␊ |
| 438 | ␉␉␉␉switch (intelCPU) ␊ |
| 439 | ␉␉␉␉{␊ |
| 440 | ␉␉␉␉␉case CPU_MODEL_WESTMERE_EX: // Intel Xeon E7␊ |
| 441 | ␉␉␉␉␉case CPU_MODEL_NEHALEM_EX: // Intel Xeon X75xx, Xeon X65xx, Xeon E75xx, Xeon E65xx␊ |
| 442 | ␉␉␉␉␉{␊ |
| 443 | ␉␉␉␉␉␉cpuFrequency = tscFrequency;␊ |
| 444 | ␉␉␉␉␉␉DBG("cpu.c (%d)CPU_MODEL_NEHALEM_EX or CPU_MODEL_WESTMERE_EX Found\n", __LINE__);␊ |
| 445 | ␉␉␉␉␉␉break;␊ |
| 446 | ␉␉␉␉␉}␊ |
| 447 | ␉␉␉␉␉case CPU_MODEL_SANDYBRIDGE: // Intel Core i3, i5, i7 LGA1155 (32nm)␊ |
| 448 | ␉␉␉␉␉case CPU_MODEL_IVYBRIDGE: // Intel Core i3, i5, i7 LGA1155 (22nm)␊ |
| 449 | ␉␉␉␉␉case CPU_MODEL_JAKETOWN: // Intel Core i7, Xeon E5 LGA2011 (32nm)␊ |
| 450 | case CPU_MODEL_IVYBRIDGE_XEON: // Intel Core i7, Xeon E5 LGA2011 (22nm)␊ |
| 451 | case CPU_MODEL_HASWELL: // Intel Core i3, i5, i7, Xeon E3 LGA1050 (22nm)␊ |
| 452 | case CPU_MODEL_HASWELL_ULT:␊ |
| 453 | case CPU_MODEL_CRYSTALWELL:␊ |
| 454 | case CPU_MODEL_BROADWELL:␊ |
| 455 | ␉␉␉␉␉{␊ |
| 456 | ␉␉␉␉␉␉msr = rdmsr64(MSR_IA32_PERF_STATUS);␊ |
| 457 | ␉␉␉␉␉␉currcoef = bitfield(msr, 15, 8);␊ |
| 458 | ␉␉␉␉␉␉cpuFrequency = currcoef * fsbFrequency;␊ |
| 459 | ␉␉␉␉␉␉maxcoef = bus_ratio_max;␊ |
| 460 | ␉␉␉␉␉␉break;␊ |
| 461 | ␉␉␉␉␉}␊ |
| 462 | ␉␉␉␉␉default:␊ |
| 463 | ␉␉␉␉␉{␊ |
| 464 | ␉␉␉␉␉␉msr = rdmsr64(MSR_IA32_PERF_STATUS);␊ |
| 465 | ␉␉␉␉␉␉currcoef = bitfield(msr, 7, 0);␊ |
| 466 | ␉␉␉␉␉␉cpuFrequency = currcoef * fsbFrequency;␊ |
| 467 | ␉␉␉␉␉␉maxcoef = bus_ratio_max;␊ |
| 468 | ␉␉␉␉␉␉break;␊ |
| 469 | ␉␉␉␉␉}␊ |
| 470 | ␉␉␉␉}␊ |
| 471 | ␊ |
| 472 | ␉␉␉␉if ((getValueForKey(kbusratio, &newratio, &len, &bootInfo->chameleonConfig)) && (len <= 4)) {␊ |
| 473 | ␉␉␉␉␉max_ratio = atoi(newratio);␊ |
| 474 | ␉␉␉␉␉max_ratio = (max_ratio * 10);␊ |
| 475 | ␉␉␉␉␉if (len >= 3) {␊ |
| 476 | max_ratio = (max_ratio + 5);␊ |
| 477 | }␊ |
| 478 | ␊ |
| 479 | ␉␉␉␉␉verbose("Bus-Ratio: min=%d, max=%s\n", bus_ratio_min, newratio);␊ |
| 480 | ␉␉␉␉␉␊ |
| 481 | ␉␉␉␉␉// extreme overclockers may love 320 ;)␊ |
| 482 | ␉␉␉␉␉if ((max_ratio >= min_ratio) && (max_ratio <= 320)) {␊ |
| 483 | ␉␉␉␉␉␉cpuFrequency = (fsbFrequency * max_ratio) / 10;␊ |
| 484 | ␉␉␉␉␉␉if (len >= 3) {␊ |
| 485 | maxdiv = 1;␊ |
| 486 | } else {␊ |
| 487 | maxdiv = 0;␊ |
| 488 | }␊ |
| 489 | ␉␉␉␉␉} else {␊ |
| 490 | ␉␉␉␉␉␉max_ratio = (bus_ratio_max * 10);␊ |
| 491 | ␉␉␉␉␉}␊ |
| 492 | ␉␉␉␉}␊ |
| 493 | ␉␉␉␉p->CPU.MaxRatio = bus_ratio_max;␊ |
| 494 | ␉␉␉␉p->CPU.MinRatio = bus_ratio_min;␊ |
| 495 | ␉␉␉} else {␊ |
| 496 | ␉␉␉␉msr = rdmsr64(MSR_IA32_PERF_STATUS);␊ |
| 497 | ␉␉␉␉DBG("msr(%d): ia32_perf_stat 0x%08x\n", __LINE__, bitfield(msr, 31, 0));␊ |
| 498 | ␉␉␉␉currcoef = bitfield(msr, 15, 8); //MacMan: Fixed bitfield to Intel documentation␊ |
| 499 | ␉␉␉␉/* Non-integer bus ratio for the max-multi*/␊ |
| 500 | ␉␉␉␉maxdiv = bitfield(msr, 46, 46);␊ |
| 501 | ␉␉␉␉/* Non-integer bus ratio for the current-multi (undocumented)*/␊ |
| 502 | ␉␉␉␉currdiv = bitfield(msr, 14, 14);␊ |
| 503 | ␉␉␉␉␊ |
| 504 | ␉␉␉␉// This will always be model >= 3␊ |
| 505 | ␉␉␉␉if ((p->CPU.Family == 0x06 && p->CPU.Model >= 0x0e) || (p->CPU.Family == 0x0f)) {␊ |
| 506 | ␉␉␉␉␉/* On these models, maxcoef defines TSC freq */␊ |
| 507 | ␉␉␉␉␉maxcoef = bitfield(msr, 44, 40);␊ |
| 508 | ␉␉␉␉} else {␊ |
| 509 | ␉␉␉␉␉/* On lower models, currcoef defines TSC freq */␊ |
| 510 | ␉␉␉␉␉/* XXX */␊ |
| 511 | ␉␉␉␉␉maxcoef = currcoef;␊ |
| 512 | ␉␉␉␉}␊ |
| 513 | ␉␉␉␉␊ |
| 514 | ␉␉␉␉if (maxcoef) {␊ |
| 515 | ␉␉␉␉␉if (maxdiv) {␊ |
| 516 | ␉␉␉␉␉␉fsbFrequency = ((tscFrequency * 2) / ((maxcoef * 2) + 1));␊ |
| 517 | ␉␉␉␉␉} else {␊ |
| 518 | ␉␉␉␉␉␉fsbFrequency = (tscFrequency / maxcoef);␊ |
| 519 | ␉␉␉␉␉}␊ |
| 520 | ␉␉␉␉␉if (currdiv) {␊ |
| 521 | ␉␉␉␉␉␉cpuFrequency = (fsbFrequency * ((currcoef * 2) + 1) / 2);␊ |
| 522 | ␉␉␉␉␉} else {␊ |
| 523 | ␉␉␉␉␉␉cpuFrequency = (fsbFrequency * currcoef);␊ |
| 524 | ␉␉␉␉␉}␊ |
| 525 | ␉␉␉␉␉DBG("max: %d%s current: %d%s\n", maxcoef, maxdiv ? ".5" : "",currcoef, currdiv ? ".5" : "");␊ |
| 526 | ␉␉␉␉}␊ |
| 527 | ␉␉␉}␊ |
| 528 | ␉␉}␊ |
| 529 | ␉␉/* Mobile CPU */␊ |
| 530 | ␉␉if (rdmsr64(MSR_IA32_PLATFORM_ID) & (1<<28)) {␊ |
| 531 | ␉␉␉p->CPU.Features |= CPU_FEATURE_MOBILE;␊ |
| 532 | ␉␉}␊ |
| 533 | ␉} else if ((p->CPU.Vendor == CPUID_VENDOR_AMD) && (p->CPU.Family == 0x0f)) {␊ |
| 534 | ␉␉switch(p->CPU.ExtFamily) {␊ |
| 535 | ␉␉␉case 0x00: /* K8 */␊ |
| 536 | ␉␉␉␉msr = rdmsr64(K8_FIDVID_STATUS);␊ |
| 537 | ␉␉␉␉maxcoef = bitfield(msr, 21, 16) / 2 + 4;␊ |
| 538 | ␉␉␉␉currcoef = bitfield(msr, 5, 0) / 2 + 4;␊ |
| 539 | ␉␉␉␉break;␊ |
| 540 | ␉␉␉␉␊ |
| 541 | ␉␉␉case 0x01: /* K10 */␊ |
| 542 | ␉␉␉␉msr = rdmsr64(K10_COFVID_STATUS);␊ |
| 543 | ␉␉␉␉do_cpuid2(0x00000006, 0, p->CPU.CPUID[CPUID_6]);␊ |
| 544 | ␉␉␉␉// EffFreq: effective frequency interface␊ |
| 545 | ␉␉␉␉if (bitfield(p->CPU.CPUID[CPUID_6][2], 0, 0) == 1) {␊ |
| 546 | ␉␉␉␉␉//uint64_t mperf = measure_mperf_frequency();␊ |
| 547 | ␉␉␉␉␉uint64_t aperf = measure_aperf_frequency();␊ |
| 548 | ␉␉␉␉␉cpuFrequency = aperf;␊ |
| 549 | ␉␉␉␉}␊ |
| 550 | ␉␉␉␉// NOTE: tsc runs at the maccoeff (non turbo)␊ |
| 551 | ␉␉␉␉//␉␉␉*not* at the turbo frequency.␊ |
| 552 | ␉␉␉␉maxcoef␉ = bitfield(msr, 54, 49) / 2 + 4;␊ |
| 553 | ␉␉␉␉currcoef = bitfield(msr, 5, 0) + 0x10;␊ |
| 554 | ␉␉␉␉currdiv = 2 << bitfield(msr, 8, 6);␊ |
| 555 | ␉␉␉␉␊ |
| 556 | ␉␉␉␉break;␊ |
| 557 | ␉␉␉␉␊ |
| 558 | ␉␉␉case 0x05: /* K14 */␊ |
| 559 | ␉␉␉␉msr = rdmsr64(K10_COFVID_STATUS);␊ |
| 560 | ␉␉␉␉currcoef = (bitfield(msr, 54, 49) + 0x10) << 2;␊ |
| 561 | ␉␉␉␉currdiv = (bitfield(msr, 8, 4) + 1) << 2;␊ |
| 562 | ␉␉␉␉currdiv += bitfield(msr, 3, 0);␊ |
| 563 | ␉␉␉␉␊ |
| 564 | ␉␉␉␉break;␊ |
| 565 | ␉␉␉␉␊ |
| 566 | ␉␉␉case 0x02: /* K11 */␊ |
| 567 | ␉␉␉␉// not implimented␊ |
| 568 | ␉␉␉␉break;␊ |
| 569 | ␉␉}␊ |
| 570 | ␉␉␊ |
| 571 | ␉␉if (maxcoef) {␊ |
| 572 | ␉␉␉if (currdiv) {␊ |
| 573 | ␉␉␉␉if (!currcoef) {␊ |
| 574 | currcoef = maxcoef;␊ |
| 575 | }␊ |
| 576 | ␊ |
| 577 | ␉␉␉␉if (!cpuFrequency) {␊ |
| 578 | ␉␉␉␉␉fsbFrequency = ((tscFrequency * currdiv) / currcoef);␊ |
| 579 | ␉␉␉␉} else {␊ |
| 580 | ␉␉␉␉␉fsbFrequency = ((cpuFrequency * currdiv) / currcoef);␊ |
| 581 | ␉␉␉␉}␊ |
| 582 | ␉␉␉␉DBG("%d.%d\n", currcoef / currdiv, ((currcoef % currdiv) * 100) / currdiv);␊ |
| 583 | ␉␉␉} else {␊ |
| 584 | ␉␉␉␉if (!cpuFrequency) {␊ |
| 585 | ␉␉␉␉␉fsbFrequency = (tscFrequency / maxcoef);␊ |
| 586 | ␉␉␉␉} else {␊ |
| 587 | ␉␉␉␉␉fsbFrequency = (cpuFrequency / maxcoef);␊ |
| 588 | }␊ |
| 589 | ␉␉␉␉DBG("%d\n", currcoef);␊ |
| 590 | ␉␉␉}␊ |
| 591 | ␉␉} else if (currcoef) {␊ |
| 592 | ␉␉␉if (currdiv) {␊ |
| 593 | ␉␉␉␉fsbFrequency = ((tscFrequency * currdiv) / currcoef);␊ |
| 594 | ␉␉␉␉DBG("%d.%d\n", currcoef / currdiv, ((currcoef % currdiv) * 100) / currdiv);␊ |
| 595 | ␉␉␉} else {␊ |
| 596 | ␉␉␉␉fsbFrequency = (tscFrequency / currcoef);␊ |
| 597 | ␉␉␉␉DBG("%d\n", currcoef);␊ |
| 598 | ␉␉␉}␊ |
| 599 | ␉␉}␊ |
| 600 | ␉␉if (!cpuFrequency) cpuFrequency = tscFrequency;␊ |
| 601 | ␉}␊ |
| 602 | ␉␊ |
| 603 | #if 0␊ |
| 604 | ␉if (!fsbFrequency) {␊ |
| 605 | ␉␉fsbFrequency = (DEFAULT_FSB * 1000);␊ |
| 606 | ␉␉cpuFrequency = tscFrequency;␊ |
| 607 | ␉␉DBG("0 ! using the default value for FSB !\n");␊ |
| 608 | ␉}␊ |
| 609 | #endif␊ |
| 610 | ␉␊ |
| 611 | ␉p->CPU.MaxCoef = maxcoef;␊ |
| 612 | ␉if (maxdiv == 0){␊ |
| 613 | ␉␉p->CPU.MaxDiv = bus_ratio_max;␊ |
| 614 | ␉} else {␊ |
| 615 | ␉␉p->CPU.MaxDiv = maxdiv;␊ |
| 616 | ␉}␊ |
| 617 | ␉p->CPU.CurrCoef = currcoef;␊ |
| 618 | ␉if (currdiv == 0){␊ |
| 619 | ␉␉p->CPU.CurrDiv = currcoef;␊ |
| 620 | ␉} else {␊ |
| 621 | ␉␉p->CPU.CurrDiv = currdiv;␊ |
| 622 | ␉}␊ |
| 623 | ␉p->CPU.TSCFrequency = tscFrequency;␊ |
| 624 | ␉p->CPU.FSBFrequency = fsbFrequency;␊ |
| 625 | ␉p->CPU.CPUFrequency = cpuFrequency;␊ |
| 626 | ␉␊ |
| 627 | ␉// keep formatted with spaces instead of tabs␊ |
| 628 | ␉DBG("CPU: Brand String: %s\n", p->CPU.BrandString);␊ |
| 629 | ␉DBG("CPU: Vendor: 0x%x\n",␉␉␉␉ p->CPU.Vendor);␊ |
| 630 | ␉DBG("CPU: Family / ExtFamily: 0x%x / 0x%x\n",␉␉ p->CPU.Family, p->CPU.ExtFamily);␊ |
| 631 | ␉DBG("CPU: Model / ExtModel / Stepping: 0x%x / 0x%x / 0x%x\n", p->CPU.Model, p->CPU.ExtModel, p->CPU.Stepping);␊ |
| 632 | ␉DBG("CPU: Number of Cores / Threads: %d / %d\n", p->CPU.NoCores, p->CPU.NoThreads);␊ |
| 633 | ␉DBG("CPU: Features: 0x%08x\n", p->CPU.Features);␊ |
| 634 | ␉DBG("CPU: TSC Frequency: %d MHz\n", p->CPU.TSCFrequency / 1000000);␊ |
| 635 | ␉DBG("CPU: FSB Frequency: %d MHz\n", p->CPU.FSBFrequency / 1000000);␊ |
| 636 | ␉DBG("CPU: CPU Frequency: %d MHz\n", p->CPU.CPUFrequency / 1000000);␊ |
| 637 | ␉DBG("CPU: Minimum Bus Ratio: %d\n", p->CPU.MinRatio);␊ |
| 638 | ␉DBG("CPU: Maximum Bus Ratio: %d\n", p->CPU.MaxRatio);␊ |
| 639 | ␉DBG("CPU: Current Bus Ratio: %d\n", p->CPU.CurrCoef);␊ |
| 640 | //␉DBG("CPU: Maximum Multiplier: %d\n",␉␉␉␉ p->CPU.MaxCoef);␊ |
| 641 | //␉DBG("CPU: Maximum Divider: %d\n",␉␉␉␉ p->CPU.MaxDiv);␊ |
| 642 | //␉DBG("CPU: Current Divider: %d\n",␉␉␉␉ p->CPU.CurrDiv);␊ |
| 643 | ␊ |
| 644 | #if DEBUG_CPU␊ |
| 645 | ␉pause();␊ |
| 646 | #endif␊ |
| 647 | }␊ |
| 648 | |
