Linux 系统如何获取 CPU 主频

#ifdef CONFIG_X86_64
#define DECLARE_ARGS(val, low, high)	unsigned low, high
#define EAX_EDX_VAL(val, low, high)	((low) | ((u64)(high) << 32))
#define EAX_EDX_ARGS(val, low, high)	"a" (low), "d" (high)
#define EAX_EDX_RET(val, low, high)	"=a" (low), "=d" (high)
#else
#define DECLARE_ARGS(val, low, high)	unsigned long long val
#define EAX_EDX_VAL(val, low, high)	(val)
#define EAX_EDX_ARGS(val, low, high)	"A" (val)
#define EAX_EDX_RET(val, low, high)	"=A" (val)
#endif
static __always_inline unsigned long long __native_read_tsc(void)
{
    DECLARE_ARGS(val, low, high);
    asm volatile("rdtsc" : EAX_EDX_RET(val, low, high));
    return EAX_EDX_VAL(val, low, high);
}

#include <stdio.h>
int main()
{
    unsigned int low=0, high=0;
    asm volatile("rdtsc" : "=a"(low), "=d"(high));
    printf("0x%x 0x%x\n",high,low);
}

$ dmesg | grep -E "TSC|tsc"
tsc: Fast TSC calibration using PIT
tsc: Detected 3192.872 MHz processor
TSC deadline timer enabled
tsc: Refined TSC clocksource calibration: 3192.747 MHz
Switched to clocksource tsc

unsigned int __read_mostly cpu_khz;
EXPORT_SYMBOL(cpu_khz);
unsigned int __read_mostly tsc_khz;
EXPORT_SYMBOL(tsc_khz);

void __init tsc_init(void)
{
    ...
    tsc_khz = x86_platform.calibrate_tsc();
    cpu_khz = tsc_khz;
    if (!tsc_khz) {
        mark_tsc_unstable("could not calculate TSC khz");
        return;
    }
    printk("Detected %lu.%03lu MHz processor.\n",
            (unsigned long)cpu_khz / 1000,
            (unsigned long)cpu_khz % 1000);
    ...
}

/*
  读取 PIT 的 MSB ，判断 MSB 是否等于参数 val
*/
static inline int pit_verify_msb(unsigned char val)
{
    /* Ignore LSB */
    inb(0x42);
    return inb(0x42) == val;
}
/*
  这个函数通过一个 for 循环不断的读取和判断 PIT 和 TSC ，最终用 *tscp 返回 MSB==val 时的 TSC 的值，*deltap 返回是增量（ delta ：希腊字母第四个）
*/
static inline int pit_expect_msb(unsigned char val, u64 *tscp, unsigned long *deltap)
{
    int count;
    u64 tsc = 0, prev_tsc = 0;
    for (count = 0; count < 50000; count++) {
        if (!pit_verify_msb(val)) // PIT 的 MSB 等于 val 时跳出循环
            break;
        prev_tsc = tsc;
        tsc = get_cycles(); //读取 tsc 的值，最终是调用上一章提到的 __native_read_tsc() 函数
    }
    *deltap = get_cycles() - prev_tsc;
    *tscp = tsc;
    return count > 5;
}

/*
  这个宏确定的是迭代次数，也就是获取多少次 PIT 的 MSB 。
  我们的目标是最大错误率为 500ppm（实际上真正的误差要小得多），但是耗时不能超过 50ms ，
  MAX_QUICK_PIT_MS * PIT_TICK_RATE / 1000  得到的是 50ms 内的时钟周期个数，也就是计数器减少的数值，
  最后除以 256 是因为我们只取 MSB 。 
*/
#define MAX_QUICK_PIT_MS 50
#define MAX_QUICK_PIT_ITERATIONS (MAX_QUICK_PIT_MS * PIT_TICK_RATE / 1000 / 256) //=233
static unsigned long quick_pit_calibrate(void)
{
    int i;
    u64 tsc, delta;
    unsigned long d1, d2;

    /* 关闭蜂鸣器 */
    outb((inb(0x61) & ~0x02) | 0x01, 0x61);
    /*
      计数器 2 , 读写方式是先低后高，工作模式是 0 , 二进制计数
      当计数器工作模式设为 0 后，该计数器的输出信号立即变为低电平，且计数过程中一直保持低电平。在经初值寄存器赋初值后，开始计数，在每个 CLK 时钟下降沿，计数器进行减 1 计数，当计数减到 0 时，OUT 输出信号变为高电平，且一直保持到该计数器重新赋初值。该信号可以作为中断请求信号。
      0 模式无自动装入计数初始值的功能，若要继续计数，则需要重新写入计数初始值。在计数期间，装入新的初始值，计数器会在初始值写入后重新开始计数。
    */
    outb(0xb0, 0x43);

    /* 从 0xffff 开始计数 */
    outb(0xff, 0x42);
    outb(0xff, 0x42);

    /*
      这里需要一个微小的延时，最简单的方法是第一次 PIT
    */
    pit_verify_msb(0);

    /*
      下面通过一个迭代过程测量出一段时间(50ms)内 TSC 的增长
      每次循环，PIT 都会减少 256 , i 次循环就是 (I * 256 / PIT_TICK_RATE) 秒
      delta 记录的是循环过程中 TSC 数值的增长
      循环结束后，用这两个数值计算主频
    */
    if (pit_expect_msb(0xff, &tsc, &d1)) {
        for (i = 1; i <= MAX_QUICK_PIT_ITERATIONS; i++) {
            if (!pit_expect_msb(0xff-i, &delta, &d2))
                break;
            delta -= tsc;
            if (d1+d2 >= delta >> 11) //确保误差小于 500ppm ，不理解
                continue;
            if (!pit_verify_msb(0xfe - i))  //再次检测 PIT 的 MSB ，确保 PIT 的值已经是 0xfe-i
                break;
            goto success;
        }
    }
    printk("Fast TSC calibration failed\n");
    return 0;
success:
    /*
	  kHz = ticks / time-in-seconds / 1000;
	  kHz = (t2 - t1) / (I * 256 / PIT_TICK_RATE) / 1000
	  kHz = ((t2 - t1) * PIT_TICK_RATE) / (I * 256 * 1000)
      主频通过 delta 返回
    */
    delta *= PIT_TICK_RATE;
    do_div(delta, i*256*1000); // do_div() 是内核的 64 位除法函数，结果保持在第一参数，返回余数
    printk("Fast TSC calibration using PIT\n");
    return delta;
}

    static const struct file_operations proc_cpuinfo_operations = {
        .open		= cpuinfo_open,
        .read		= seq_read,
        .llseek		= seq_lseek,
        .release	= seq_release,
    };

    static int __init proc_cpuinfo_init(void)
    {
        proc_create("cpuinfo", 0, NULL, &proc_cpuinfo_operations);
        return 0;
    }

    static int show_cpuinfo(struct seq_file *m, void *v)
    {
        struct cpuinfo_x86 *c = v;
        unsigned int cpu;
        int i;

        cpu = c->cpu_index;
        seq_printf(m, "processor\t: %u\n"
            "vendor_id\t: %s\n"
            "cpu family\t: %d\n"
            "model\t\t: %u\n"
            "model name\t: %s\n",
            cpu,
            c->x86_vendor_id[0] ? c->x86_vendor_id : "unknown",
            c->x86,
            c->x86_model,
            c->x86_model_id[0] ? c->x86_model_id : "unknown");
        ...
    }

    static inline void cpuid(unsigned int op,
                unsigned int *eax, unsigned int *ebx,
                unsigned int *ecx, unsigned int *edx)
    {
        *eax = op;
        *ecx = 0;
        __cpuid(eax, ebx, ecx, edx);
    }

    static inline void native_cpuid(unsigned int *eax, unsigned int *ebx,
                    unsigned int *ecx, unsigned int *edx)
    {
        /* ecx is often an input as well as an output. */
        asm volatile("cpuid"
            : "=a" (*eax),
            "=b" (*ebx),
            "=c" (*ecx),
            "=d" (*edx)
            : "0" (*eax), "2" (*ecx)
            : "memory");
    }

if (cpu_has(c, X86_FEATURE_TSC)) {
	unsigned int freq = cpufreq_quick_get(cpu);
	if (!freq)
		freq = cpu_khz;
	seq_printf(m, "cpu MHz\t\t: %u.%03u\n", freq / 1000, (freq % 1000));
}