intel core 2 duo温度读取
1 目的：实现intel core 2 duo cpu的温度检测
2 分析：
对于intel处理器，每个处理器核心有Digital Thermal Sensors(DTS 数字敏感传感器),该数字传感器的检测值不依赖于外围电路，仅仅取决于 cpu核心的热度，其取值存储于cpu上的一个特殊寄存器中，该寄存器称为Model Specific Register 0x19c(MSR),可以通过rdmsr指令读取，内核代码coretemp.c文件实现了该文件的读取，插入coretemp.ko模块后，可以通过/sys/devices/platform/coretemp.0/目录下的temp1_input、temp2_input等文件读取，温度值基本与lm-sensors读取值一致（lm-sensors基于该内核驱动模块实现的）。
3 hwmon/coretemp.c文件导读，注：该检测文件的对应文档信息在/documation/hdware/coretemp文件下
3.1 前期工作
对于intel core 2 duo cpu而言，coretemp.c中包含特定架构的头文件为x86/include/asm/process.h
在process.h中定义了cpu_data数据结构：
1 DECLARE_PER_CPU(struct cpuinfo_x86, cpu_info); 2 #define cpu_data(cpu) per_cpu(cpu_info, cpu)；
所以cpu_data(0)即为第1个cpu对应的struct cpuinfo_x86结构，该结构定义如下：
1 /* 2 * CPU type and hardware bug flags. Kept separately for each CPU. 3 * Members of this structure are referenced in head.S, so think twice 4 * before touching them. [mj] 5 */ 6 注：该结构应该可以通过cat /proc/cpuinfo来获取 7 struct cpuinfo_x86 { 8 __u8 x86; /* CPU family */ == X86 9 __u8 x86_vendor; /* CPU vendor */ == X86_VENDOR_INTEL 10 __u8 x86_model; == 6,14,15,22,23,26 11 __u8 x86_mask; 12 #ifdef CONFIG_X86_32 13 char wp_works_ok; /* It doesn't on 386's */ 14 15 /* Problems on some 486Dx4's and old 386's: */ 16 char hlt_works_ok; 17 char hard_math; 18 char rfu; 19 char fdiv_bug; 20 char f00f_bug; 21 char coma_bug; 22 char pad0; 23 #else 24 /* Number of 4K pages in DTLB/ITLB combined(in pages): */ 25 int x86_tlbsize; 26 __u8 x86_virt_bits; 27 __u8 x86_phys_bits; 28 #endif 29 /* CPUID returned core id bits: */ 30 __u8 x86_coreid_bits; 31 /* Max extended CPUID function supported: */ 32 __u32 extended_cpuid_level; 33 /* Maximum supported CPUID level, -1=no CPUID: */ 34 int cpuid_level; 35 __u32 x86_capability[NCAPINTS]; 36 char x86_vendor_id[16]; //genuineIntel 37 char x86_model_id[64]; //intel core 2 duo cpu Txxx 38 /* in KB - valid for CPUS which support this call: */ 39 int x86_cache_size; 40 int x86_cache_alignment; /* In bytes */ 41 int x86_power; 42 unsigned long loops_per_jiffy; 43 #ifdef CONFIG_SMP 44 /* cpus sharing the last level cache: */ 45 cpumask_t llc_shared_map; 46 #endif 47 /* cpuid returned max cores value: */ 48 u16 x86_max_cores; 49 u16 apicid; 50 u16 initial_apicid; 51 u16 x86_clflush_size; 52 #ifdef CONFIG_SMP 53 /* number of cores as seen by the OS: */ 54 u16 booted_cores; 55 /* Physical processor id: */ 56 u16 phys_proc_id; 57 /* Core id: */ 58 u16 cpu_core_id; 59 /* Index into per_cpu list: */ 60 u16 cpu_index; 61 #endif 62 } __attribute__((__aligned__(SMP_CACHE_BYTES)));
3.2 模块插入后，驱动加载原理和检测过程
3.2.1 cpu温度探测驱动加载原理
A 该模块的初始函数如下：
1 static int __init coretemp_init(void) 2 { 3 int i, err = -ENODEV; 4 struct pdev_entry *p, *n; 5 6 /* quick check if we run Intel */ 7 if (cpu_data(0).x86_vendor != X86_VENDOR_INTEL) 8 goto exit; 9 10 err = platform_driver_register(&coretemp_driver); //获取每个cpu核心温度信息的驱动结构，当加载驱动后，在/sys/devices/platform/coretemp.o下建立各个检测文件 11 if (err) 12 goto exit; 13 14 for_each_online_cpu(i) { 15 struct cpuinfo_x86 *c = &cpu_data(i); 16 17 /* check if family 6, models 0xe, 0xf, 0x16, 0x17, 0x1A */ 18 if ((c->cpuid_level < 0) || (c->x86 != 0x6) || 19 !((c->x86_model == 0xe) || (c->x86_model == 0xf) || 20 (c->x86_model == 0x16) || (c->x86_model == 0x17) || 21 (c->x86_model == 0x1A))) { 22 23 /* supported CPU not found, but report the unknown 24 family 6 CPU */ 25 if ((c->x86 == 0x6) && (c->x86_model > 0xf)) 26 printk(KERN_WARNING DRVNAME ": Unknown CPU " 27 "model %x\n", c->x86_model); 28 continue; 29 } 30 31 err = coretemp_device_add(i); //在/sys/devices/platform/coretemp.0下建立coretemp.0与sysfs中其他目录的连接关系，每个cpu对应一个目录，双核cpu对应一个目录
32 if (err) 33 goto exit_devices_unreg; 34 } 35 if (list_empty(&pdev_list)) { 36 err = -ENODEV; 37 goto exit_driver_unreg; 38 } 39 40 #ifdef CONFIG_HOTPLUG_CPU 41 register_hotcpu_notifier(&coretemp_cpu_notifier); 42 #endif 43 return 0; 44 ...... 45 }
B probe实现原理-->建立用户实现温度读取的sys文件接口过程
C 层次关系建立过程-->建立coretemp驱动与sys目录其他层次的连接关系
3.2.2 温度检测函数的实现
1 static ssize_t show_temp(struct device *dev, 2 struct device_attribute *devattr, char *buf) 3 { 4 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 5 struct coretemp_data *data = coretemp_update_device(dev); 6 int err; 7 8 if (attr->index == SHOW_TEMP) 9 err = data->valid ? sprintf(buf, "%d\n", data->temp) : -EAGAIN; 10 else if (attr->index == SHOW_TJMAX) 11 err = sprintf(buf, "%d\n", data->tjmax); 12 else 13 err = sprintf(buf, "%d\n", data->ttarget); 14 return err; 15 }
每个cpu核心对应一个coretemp_data结构，该结构信息如下：
1 struct coretemp_data { 2 struct device *hwmon_dev; 3 struct mutex update_lock; 4 const char *name; 5 u32 id; cpu编号 6 char valid; /* zero until following fields are valid */ 7 unsigned long last_updated; /* in jiffies */ 8 int temp; 当前检测的温度，= real*1000 9 int tjmax; 该cpu的最大温度值，在probe过程中，通过调用adjust_tjmax来修改，一般=100，
当为移动设备的cpu且rdmsr_safe_on_cpu(id, 0xee, &eax, &edx)，eax=40000000，时，将adjust_tjmax=85
10 int ttarget; 11 u8 alarm; 12 };
实际cpu温度的获取过程
1 static struct coretemp_data *coretemp_update_device(struct device *dev) 2 { 3 struct coretemp_data *data = dev_get_drvdata(dev); 4 5 mutex_lock(&data->update_lock); 6 7 if (!data->valid || time_after(jiffies, data->last_updated + HZ)) { 8 u32 eax, edx; 9 10 data->valid = 0; 11 rdmsr_on_cpu(data->id, MSR_IA32_THERM_STATUS, &eax, &edx); //获取该cpu上的温度数据主函数，eax最高位置1，且17位-23位共7位存储温度的信息delta 12 data->alarm = (eax >> 5) & 1; //MSR_IA32_THERM_STATUS = 0x19c 13 /* update only if data has been valid */ 14 if (eax & 0x80000000) { 15 data->temp = data->tjmax - (((eax >> 16) //实际的温度temp = data->temp/1000 =（100 000 - delta*1000）/1000,delta 从0-127，一般从0-100
16 & 0x7f) * 1000); 17 data->valid = 1; 18 } else { 19 dev_dbg(dev, "Temperature data invalid (0x%x)\n", eax); 20 } 21 data->last_updated = jiffies; 22 } 23 24 mutex_unlock(&data->update_lock); 25 return data;
特定cpu温度寄存器上数据读取过程
1 int rdmsr_on_cpu(unsigned int cpu, u32 msr_no, u32 *l, u32 *h) //该函数定义于arch/x86/lib/msr-on-cpu.c中 2 { 3 int err; 4 struct msr_info rv; 5 6 rv.msr_no = msr_no;//保存端口号 7 err = smp_call_function_single(cpu, __rdmsr_on_cpu, &rv, 1); 将反馈信息l、h和端口号打包到结构体msr_info中，并调用smp_call_function_single函数 8 *l = rv.l; //smp_call_function_single函数只是确保将__rdmsr_on_cpu函数发送到特定的处理器cpu上，然后又该处理器调用__rdmsr_on_cpu来实现该cpu温度的读取操作 9 *h = rv.h; //所以关键还是__rdmsr_on_cpu 10 11 return err; 12 }
1 /* 注：该函数是导出的，当内核模块要求某个函数在特定cpu上执行时，可以调用这个函数实现，所以将其放在这里 2 * smp_call_function_single - Run a function on a specific CPU 3 * @func: The function to run. This must be fast and non-blocking. 4 * @info: An arbitrary pointer to pass to the function. 5 * @wait: If true, wait until function has completed on other CPUs. 6 * 7 * Returns 0 on success, else a negative status code. Note that @wait 8 * will be implicitly turned on in case of allocation failures, since 9 * we fall back to on-stack allocation. 10 */ 11 int smp_call_function_single(int cpu, void (*func) (void *info), void *info, 12 int wait) 13 { 14 struct call_single_data d; 15 unsigned long flags; 16 /* prevent preemption and reschedule on another processor, 17 as well as CPU removal */ 18 int me = get_cpu(); 19 int err = 0; 20 21 /* Can deadlock when called with interrupts disabled */ 22 WARN_ON(irqs_disabled()); 23 24 if (cpu == me) { 25 local_irq_save(flags); 26 func(info); 27 local_irq_restore(flags); 28 } else if ((unsigned)cpu < NR_CPUS && cpu_online(cpu)) { 29 struct call_single_data *data = NULL; 30 31 if (!wait) { 32 data = kmalloc(sizeof(*data), GFP_ATOMIC); 33 if (data) 34 data->flags = CSD_FLAG_ALLOC; 35 } 36 if (!data) { 37 data = &d; 38 data->flags = CSD_FLAG_WAIT; 39 } 40 41 data->func = func; 42 data->info = info; 43 generic_exec_single(cpu, data); 44 } else { 45 err = -ENXIO; /* CPU not online */ 46 } 47 48 put_cpu(); 49 return err; 50 } 51 EXPORT_SYMBOL(smp_call_function_single);
实际上当前cpu执行实际温度获取操作为：
1 static void __rdmsr_on_cpu(void *info) 2 { 3 struct msr_info *rv = info; 4 5 rdmsr(rv->msr_no, rv->l, rv->h); 6 }
在文件x86/asm/include/msr.h文件中，定义如下
/* * Access to machine-specific registers (available on 586 and better only) * Note: the rd* operations modify the parameters directly (without using * pointer indirection), this allows gcc to optimize better */ #define rdmsr(msr, val1, val2) \ do { \ u64 __val = native_read_msr((msr)); \ (val1) = (u32)__val; \ (val2) = (u32)(__val >> 32); \ } while (0)
1 static inline unsigned long long native_read_msr(unsigned int msr) 2 { 3 DECLARE_ARGS(val, low, high); 4 5 asm volatile("rdmsr" : EAX_EDX_RET(val, low, high) : "c" (msr)); 6 return EAX_EDX_VAL(val, low, high); 7 }
在X86_32位系统中，实质上为函数：
1 static inline unsigned long long native_read_msr(unsigned int msr) 2 { 3 unsigned long long val; 4 5 asm volatile("rdmsr" : "A"(val) : "c" (msr)); 6 return (val); 7 }
可见，实质上读取该cpu核心温度的函数是以0x19c来读取msr寄存器
