Geforce 8400显卡温度的获取

1 在安装完lm_sensors后，利用sensors命令显示结果如下：

nouveau-pci-0100
Adapter: PCI adapter
temp1:        +80.0°C  (high = +100.0°C, crit = +110.0°C)

说明通过内核可以读出显卡温度，并且内核提供了用户态接口文件(位于/sys/devices/pci0000:00/0000:00:01.0/0000.01.00.0/temp1_input)，而且pci总线上01:00.0对应显卡设备

2  确定显卡温度信息文件所在的系统位置
   系统监控信息都在/sys/class/hwmon目录下，通过ls –l /sys/class/hwmon显示其下面的情况
lrwxrwxrwx. 1 root root 0 Mar 23 13:24 /sys/class/hwmon/hwmon0 -> sys/devices/pci0000:00/0000:00:01.0/0000:01:00.0/hwmon/hwmon0
lrwxrwxrwx. 1 root root 0 Mar 23 13:25 /sys/class/hwmon/hwmon1 -> sys/devices/pci0000:00/0000:00:18.3/hwmon/hwmon1
通过红色部分，可以断定，显卡温度文件位于 sys/devices/pci0000:00/0000:00:01.0/0000:01:00.0目录下
3  查看该显卡的信息，说明pci 01:00.0设备确实为nvidia设备
$ lspci -s 01:00.0
01:00.0 VGA compatible controller: nVidia Corporation GT216 [GeForce GT 220] (rev a2)
4 确定显卡温度读取的内核函数
上面既然能够定位出显卡温度对应的文件，那么该文件的读操作函数即是内核读取显卡温度的函数，但是如何查找该函数呢？
4.1 确定nvidia显卡设备的驱动程序
方法一：在上面第2部中，得到了显卡温度信息文件所在的系统目录为：/sys/devices/pci0000:00/0000:00:01.0/0000:01:00.0，进入该显卡驱动目录下，里面的name文件即是显卡驱动的名称，为nouveau；方法二 sensors命令显示的第一行内容为：nouveau-pci-0100,各项依次表示：
驱动模块名称-总线类型-总线地址，所以显卡驱动程序为nouveau.ko
利用find /lib/modules/`uname -r` -name nouveau.ko得到该显卡驱动模块在系统源码中的相对位置


lib/modules/`uname -r`/kernel/drivers/gpu/drm/nouveau/nouveau.ko

4.2 在最新的内核源代码linux-3.3-2中查找该驱动对应的文件，确定对应的温度读取函数
nouveau初始化函数 nouveau_drv.c

static int __init nouveau_init(void)
{ 
...
nouveau_register_dsm_handler();
return drm_pci_init(&driver, &nouveau_pci_driver);
}

/**
* PCI device initialization. Called direct from modules at load time.
*
* \return zero on success or a negative number on failure.
*/
 6 int drm_pci_init(struct drm_driver *driver, struct pci_driver *pdriver)
{
struct pci_dev *pdev = NULL;
const struct pci_device_id *pid;
int i;

for (i = 0; pdriver->id_table[i].vendor != 0; i++) {
13 pid = &pdriver->id_table[i]; //pci_driver->id_table里保存了nvidia显卡相关的关键字，vendor，device，subvendor等等信息

/* Loop around setting up a DRM device for each PCI device
* matching our ID and device class. If we had the internal
* function that pci_get_subsys and pci_get_class used, we'd
* be able to just pass pid in instead of doing a two-stage
* thing.
*/
pdev = NULL;
22 while ((pdev =   //遍历pci总线上现在挂载的设备列表，如果nvidia显卡挂载在pci总线下，返回nvidia设备对应的struct pci_dev*结构
23 pci_get_subsys(pid->vendor, pid->device, pid->subvendor, 
24 pid->subdevice, pdev)) != NULL) {  
if ((pdev->class & pid->class_mask) != pid->class)
continue;

/* stealth mode requires a manual probe */
pci_dev_get(pdev);
30 drm_get_pci_dev(pdev, pid, driver);  //加载该pci对应的drm_driver驱动
}
}
return 0;
}

其中nvidia显卡对应的匹配关键信息为：

static struct pci_device_id pciidlist[] = {
{
PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_ANY_ID),
.class = PCI_BASE_CLASS_DISPLAY << 16,
.class_mask = 0xff << 16,
},
{
PCI_DEVICE(PCI_VENDOR_ID_NVIDIA_SGS, PCI_ANY_ID),
.class = PCI_BASE_CLASS_DISPLAY << 16,
.class_mask = 0xff << 16,
},
{}
};

/*
* PCI_DEVICE - macro used to describe a specific pci device
* @vend: the 16 bit PCI Vendor ID
* @dev: the 16 bit PCI Device ID
*
* This macro is used to create a struct pci_device_id that matches a
* specific device. The subvendor and subdevice fields will be set to
* PCI_ANY_ID.
*
#define PCI_DEVICE(vend,dev) \
.vendor = (vend), .device = (dev), \
.subvendor = PCI_ANY_ID, .subdevice = PCI_ANY_ID
*/

匹配成功后，加载驱动过程如下所示：

　1　对显卡设备struct pci_dev结构进行初始化，该结构对应于pci bus总线，每个pci设备对应一个该设备。
　2　分配struct drm_device*显卡结构，该结构对应于特定的显卡驱动，并初始化
　3  建立struct pci_dev*和struct drm_device*关联，pci_dev*->struct device*->device_private* driver_data = 
     struct drm_device
  4 显卡设备和显卡驱动的关系并且执行显卡驱动的加载功能,即执行nouveau_load函数

int drm_get_pci_dev(struct pci_dev *pdev, const struct pci_device_id *ent,struct drm_driver *driver)

{

....
mutex_lock(&drm_global_mutex);
 7 if ((ret = drm_fill_in_dev(dev, ent, driver))) { struct drm_device和driver建立关系

printk(KERN_ERR "DRM: Fill_in_dev failed.\n");
goto err_g2;
}

if (dev->driver->load) {
14 ret = dev->driver->load(dev, ent->driver_data);
if (ret)
goto err_g4;
}
...
}

驱动装载过程：

int nouveau_load(struct drm_device *dev, unsigned long flags)

{

struct drm_nouveau_private *dev_priv;
uint32_t reg0, strap;
resource_size_t mmio_start_offs;
int ret;

dev_priv = kzalloc(sizeof(*dev_priv), GFP_KERNEL);

...

dev->dev_private = dev_priv;
dev_priv->dev = dev;

dev_priv->flags = flags & NOUVEAU_FLAGS;

NV_DEBUG(dev, "vendor: 0x%X device: 0x%X class: 0x%X\n",
dev->pci_vendor, dev->pci_device, dev->pdev->class);

/* resource 0 is mmio regs */
/* resource 1 is linear FB */
/* resource 2 is RAMIN (mmio regs + 0x1000000) */
/* resource 6 is bios */

/* map the mmio regs */
mmio_start_offs = pci_resource_start(dev->pdev, 0);        //显卡外设地址空间映射到内核虚存空间中
dev_priv->mmio = ioremap(mmio_start_offs, 0x00800000);
...

/* Time to determine the card architecture */
reg0 = nv_rd32(dev, NV03_PMC_BOOT_0);

/* We're dealing with >=NV10 */
if ((reg0 & 0x0f000000) > 0) {
/* Bit 27-20 contain the architecture in hex */
dev_priv->chipset = (reg0 & 0xff00000) >> 20;
/* NV04 or NV05 */
} else if ((reg0 & 0xff00fff0) == 0x20004000) {
if (reg0 & 0x00f00000)
dev_priv->chipset = 0x05;
else
dev_priv->chipset = 0x04;
} else
dev_priv->chipset = 0xff;

48 switch (dev_priv->chipset & 0xf0) {
case 0x00:
case 0x10:
case 0x20:
case 0x30:
dev_priv->card_type = dev_priv->chipset & 0xf0;
break;
case 0x40:
case 0x60:
dev_priv->card_type = NV_40;
break;
case 0x50:
case 0x80:
case 0x90:
case 0xa0:
63 dev_priv->card_type = NV_50;
break;
case 0xc0:
dev_priv->card_type = NV_C0;
break;
case 0xd0:
dev_priv->card_type = NV_D0;
break;
default:
NV_INFO(dev, "Unsupported chipset 0x%08x\n", reg0);
ret = -EINVAL;
goto err_mmio;
}

NV_INFO(dev, "Detected an NV%2x generation card (0x%08x)\n",
dev_priv->card_type, reg0);
...

/* For kernel modesetting, init card now and bring up fbcon */
ret = nouveau_card_init(dev);//nvidia特定类型显卡初始化过程
...
}

特定类型显卡初始化过程

int nouveau_card_init(struct drm_device *dev){
...

/* Initialise internal driver API hooks */
ret = nouveau_init_engine_ptrs(dev);
...
}

static int nouveau_init_engine_ptrs(struct drm_device *dev)
{
struct drm_nouveau_private *dev_priv = dev->dev_private;
struct nouveau_engine *engine = &dev_priv->engine;

switch (dev_priv->chipset & 0xf0) {
...

case 0x50:
case 0x80: /* gotta love NVIDIA's consistency.. */
case 0x90:
case 0xa0:
engine->instmem.init     = nv50_instmem_init;
engine->instmem.takedown    = nv50_instmem_takedown;
engine->instmem.suspend     = nv50_instmem_suspend;
engine->instmem.resume     = nv50_instmem_resume;
engine->instmem.get     = nv50_instmem_get;
engine->instmem.put     = nv50_instmem_put;
engine->instmem.map     = nv50_instmem_map;
engine->instmem.unmap     = nv50_instmem_unmap;
if (dev_priv->chipset == 0x50)
engine->instmem.flush    = nv50_instmem_flush;
else
engine->instmem.flush    = nv84_instmem_flush;
engine->mc.init     = nv50_mc_init;
engine->mc.takedown     = nv50_mc_takedown;
engine->timer.init     = nv04_timer_init;
engine->timer.read     = nv04_timer_read;
engine->timer.takedown     = nv04_timer_takedown;
engine->fb.init     = nv50_fb_init;
engine->fb.takedown     = nv50_fb_takedown;
engine->fifo.channels     = 128;
engine->fifo.init     = nv50_fifo_init;
engine->fifo.takedown     = nv50_fifo_takedown;
engine->fifo.disable     = nv04_fifo_disable;
engine->fifo.enable     = nv04_fifo_enable;
engine->fifo.reassign     = nv04_fifo_reassign;
engine->fifo.channel_id     = nv50_fifo_channel_id;
engine->fifo.create_context    = nv50_fifo_create_context;
engine->fifo.destroy_context    = nv50_fifo_destroy_context;
engine->fifo.load_context    = nv50_fifo_load_context;
engine->fifo.unload_context    = nv50_fifo_unload_context;
engine->fifo.tlb_flush     = nv50_fifo_tlb_flush;
engine->display.early_init    = nv50_display_early_init;
engine->display.late_takedown    = nv50_display_late_takedown;
engine->display.create     = nv50_display_create;
engine->display.destroy     = nv50_display_destroy;
engine->display.init     = nv50_display_init;
engine->display.fini     = nv50_display_fini;
engine->gpio.init     = nv50_gpio_init;
engine->gpio.fini     = nv50_gpio_fini;
engine->gpio.drive     = nv50_gpio_drive;
engine->gpio.sense     = nv50_gpio_sense;
engine->gpio.irq_enable     = nv50_gpio_irq_enable;
switch (dev_priv->chipset) {
case 0x84:
case 0x86:
case 0x92:
case 0x94:
case 0x96:
case 0x98:
case 0xa0:
case 0xaa:
case 0xac:
case 0x50:
engine->pm.clocks_get    = nv50_pm_clocks_get;
engine->pm.clocks_pre    = nv50_pm_clocks_pre;
engine->pm.clocks_set    = nv50_pm_clocks_set;
break;
default:
engine->pm.clocks_get    = nva3_pm_clocks_get;
engine->pm.clocks_pre    = nva3_pm_clocks_pre;
engine->pm.clocks_set    = nva3_pm_clocks_set;
break;
}
engine->pm.voltage_get     = nouveau_voltage_gpio_get;
engine->pm.voltage_set     = nouveau_voltage_gpio_set;
if (dev_priv->chipset >= 0x84)
87 engine->pm.temp_get    = nv84_temp_get;，显卡类型的获取，见后面实现程序
else
engine->pm.temp_get    = nv40_temp_get;
engine->pm.pwm_get     = nv50_pm_pwm_get;
engine->pm.pwm_set     = nv50_pm_pwm_set;
engine->vram.init     = nv50_vram_init;
engine->vram.takedown     = nv50_vram_fini;
engine->vram.get     = nv50_vram_new;
engine->vram.put     = nv50_vram_del;
engine->vram.flags_valid    = nv50_vram_flags_valid;
break;
...
}

可见实际的读取温度的函数为nv84_temp_get，该函数定义如下：

int
nv84_temp_get(struct drm_device *dev)
{
return nv_rd32(dev, 0x20400);
}

static inline u32 nv_rd32(struct drm_device *dev, unsigned reg)
{
struct drm_nouveau_private *dev_priv = dev->dev_private;
return ioread32_native(dev_priv->mmio + reg);
}

#define ioread16_native ioread16be
#define iowrite16_native iowrite16be
#define ioread32_native ioread32be
#define iowrite32_native iowrite32be
#else /* def __BIG_ENDIAN */
#define ioread16_native ioread16
#define iowrite16_native iowrite16
#define ioread32_native ioread32      在头文件<asm-generic/iomap.h>中声明
#define iowrite32_native iowrite32
#endif /* def __BIG_ENDIAN else */

所以利用该函数即可实现温度信息的获取，也可以利用外设寄存器虚拟内存映射后形成的通用操作函数读取：
readl(mmio+reg); == ioread32_native(mmio+reg);
这种方式有如下形式：包含io.h头文件即可
define readb(addr) (*(volatile unsigned char *) __io_virt(addr))
#define readw(addr) (*(volatile unsigned short *) __io_virt(addr))
#define readl(addr) (*(volatile unsigned int *) __io_virt(addr))

#define writeb(b,addr) (*(volatile unsigned char *) __io_virt(addr) = (b))
#define writew(b,addr) (*(volatile unsigned short *) __io_virt(addr) = (b))
#define writel(b,addr) (*(volatile unsigned int *) __io_virt(addr) = (b))

#define memset_io(a,b,c) memset(__io_virt(a),(b),(c))
#define memcpy_fromio(a,b,c) memcpy((a),__io_virt(b),(c))
#define memcpy_toio(a,b,c) memcpy(__io_virt(a),(b),(c))

4 编写内核模块，实现显卡温度的读取


#include <linux/device.h> //inlcude bus_find_device,struct device
#include <linux/fs.h>
#include <linux/compiler.h> //__iomm
#include <asm-generic/iomap.h>//ioread32,ioread32be
#include <linux/types.h>
#include <net/net_namespace.h>
#include <linux/module.h>
#include <linux/kernel.h> /* We're doing kernel work */
#include <linux/pci.h> //pci_resource_start,first we should get struct pci_dev,function no_pci_devices
#include <asm/io.h> // include ioremap()
#include <linux/mod_devicetable.h> //include struct pci_device_id
/*
from nouveau_drv.c
struct pci_device_id {
__u32 vendor, device;     // Vendor and device ID or PCI_ANY_ID
__u32 subvendor, subdevice;    // Subsystem ID's or PCI_ANY_ID
__u32 class, class_mask;    // (class,subclass,prog-if) triplet
kernel_ulong_t driver_data;    // Data private to the driver
};
*/
#include <linux/pci.h> //include PCI_DEVICE(vend,dev)，to_pci_dev(n)
/*
* PCI_DEVICE - macro used to describe a specific pci device
* @vend: the 16 bit PCI Vendor ID
* @dev: the 16 bit PCI Device ID
*
* This macro is used to create a struct pci_device_id that matches a
* specific device. The subvendor and subdevice fields will be set to
* PCI_ANY_ID.
*
#define PCI_DEVICE(vend,dev) \
.vendor = (vend), .device = (dev), \
.subvendor = PCI_ANY_ID, .subdevice = PCI_ANY_ID
*/
#include <linux/pci_ids.h>//include PCI_VENDOR_ID_NVIDIA
MODULE_LICENSE("GPL");
MODULE_AUTHOR("JIAN ZHOU");
MODULE_DESCRIPTION("NVIDIA THERMAL");
static struct pci_device_id pciidlist[] = {
{
PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_ANY_ID),
.class = PCI_BASE_CLASS_DISPLAY << 16,
.class_mask = 0xff << 16,
},
{
PCI_DEVICE(PCI_VENDOR_ID_NVIDIA_SGS, PCI_ANY_ID),
.class = PCI_BASE_CLASS_DISPLAY << 16,
.class_mask = 0xff << 16,
},
{}
};

const static struct pci_dev* nvidiaDev;
void __iomem* mmio; //the cpu virtual address mapped to nvidia pci address
#ifdef __BEG_ENDIAN
#define ioread32_native ioread32be
#else
#define ioread32_native ioread32
#endif
 60 static inline u32 nv_rd32(void __iomem* mmio,unsigned reg) //读取温度的主函数
 61 {
 62 return readl(mmio+reg);//ioread32_native(mmio+reg);
 63 }

static ssize_t getTemp(struct file* file,char __user* userbuf,size_t bytes,loff_t* off)
{
u32 temp = -2;

if(*off)
return 0;
if(mmio)
temp = nv_rd32(mmio,0x20400);
sprintf(userbuf,"%s,temp:%d\n",nvidiaDev->driver->name,temp);
*off = strlen(userbuf);
return *off;
}

static struct file_operations my_file_ops =
{
.owner = THIS_MODULE,
.read = getTemp,
};
static struct bus_type* pci_bus_types = (struct bus_type*)0xc17f4640;
static int match_pci_dev_by_id(struct device* pdev,void*data)
{
struct pci_dev* dev = to_pci_dev(pdev);
struct pci_device_id * id = data;
if ((id->vendor == PCI_ANY_ID || id->vendor == dev->vendor) && \
(id->device == PCI_ANY_ID || id->device == dev->device) && \
(id->subvendor == PCI_ANY_ID || id->subvendor == dev->subsystem_vendor) &&
(id->subdevice == PCI_ANY_ID || id->subdevice == dev->subsystem_device) && \
!((id->class ^ dev->class) & id->class_mask))
return 1;
else
return 0;

}
struct pci_dev *pci_get_subsyss(const struct pci_device_id* id ,struct pci_dev *from)
{
struct device* dev_start = NULL,*dev=NULL;
struct pci_dev* pdev = NULL;
/* pci_find_subsys() can be called on the ide_setup() path,
* super-early in boot. But the down_read() will enable local
* interrupts, which can cause some machines to crash. So here we
* detect and flag that situation and bail out early.
*/
if (unlikely(no_pci_devices()))
return NULL;

printk("in pci_get_subsyss\n");

if(from)
dev_start = &from->dev;

dev = bus_find_device(pci_bus_types,dev_start,(void*)id,match_pci_dev_by_id);
if(dev)
pdev = to_pci_dev(dev);
if (from)
pci_dev_put(from);
printk("leaving pci_get_subsyss\n");
return pdev;
}
static void getNvidiaDevice(void)
{
struct pci_dev* pdev = NULL;
const struct pci_device_id* pid;
int i;
printk("in getNvidiaDevice\n");
for (i = 0; i < 2; i++)
{

pid = &pciidlist[i];

/* Loop around setting up a DRM device for each PCI device
* matching our ID and device class. If we had the internal
* function that pci_get_subsys and pci_get_class used, we'd
* be able to just pass pid in instead of doing a two-stage
* thing.
*/
pdev = NULL;
while ((pdev = pci_get_subsyss(pid, pdev)) != NULL) {
if ((pdev->class & pid->class_mask) != pid->class)
continue;
/* stealth mode requires a manual probe */
else
break;
//drm_get_pci_dev(pdev, pid, driver);
}
if (pdev && pdev->driver && strstr(pdev->driver->name,"nouveau"))//查找nvidia显卡对应的显卡驱动，此时显卡驱动已经装载在系统，可以匹配
{
pci_dev_get(pdev); //get the pci_dev for nvidia
nvidiaDev = pdev;
return;
}
}
printk("leaving getNvidiaDevice\n");
}
struct device_private {
struct klist klist_children;
struct klist_node knode_parent;
struct klist_node knode_driver;
struct klist_node knode_bus;
void *driver_data;
struct device *device;
};
#ifndef NV03_PMC_BOOT_0
#define NV03_PMC_BOOT_0 0x00000000
#endif
static __init int in(void)
{

struct proc_dir_entry *entry;
resource_size_t mmio_start_offs;
uint32_t reg0 = 0;
int chipset = 0;
entry = create_proc_entry("nvidiaTemp", 0, init_net.proc_net);
if (entry) {
entry->proc_fops = &my_file_ops;
}
getNvidiaDevice();
//fill nvidiaDev
if(nvidiaDev)
{
mmio_start_offs = pci_resource_start(nvidiaDev,0);
mmio = ioremap(mmio_start_offs,0x00800000);//8

reg0 = nv_rd32(mmio, NV03_PMC_BOOT_0);
/* We're dealing with >=NV10 */
189 if ((reg0 & 0x0f000000) > 0)
{
/* Bit 27-20 contain the architecture in hex */
chipset = (reg0 & 0xff00000) >> 20;
/* NV04 or NV05 */
}
else if ((reg0 & 0xff00fff0) == 0x20004000)
{
if (reg0 & 0x00f00000)
chipset = 0x05;
else
chipset = 0x04;
}
else
chipset = 0xff;

205 printk(KERN_INFO "nvidia local address:%lx,mapped address:%lx!,chipset:%x\n",(unsigned long)mmio_start_offs,(unsigned long)mmio,chipset);
}
printk(KERN_INFO "Initialze TEMP success!\n");
return 0;
}
/**
* This function is called when the module is unloaded.
*
*/
static __exit void out(void)
{
remove_proc_entry("nvidiaTemp", init_net.proc_net);
if(nvidiaDev)
pci_dev_put((struct pci_dev*)nvidiaDev);
if(mmio)
iounmap(mmio);
printk(KERN_INFO "Remove my_seq_proc success!\n");
}
module_init(in);
module_exit(out);
/*显示如下
[65517.412294] in getNvidiaDevice
[65517.412305] in pci_get_subsyss
[65517.412320] leaving pci_get_subsyss
229 [65517.414604] nvidia local address:fd000000,mapped address:fb380000!,chipset:86 可以看出，机器的显卡芯片类型为86
[65517.414610] Initialze TEMP success!
root@ubuntu:/media/Kingston/nouveauTempature# modinfo b.ko
filename: b.ko
description: NVIDIA THERMAL
author: JIAN ZHOU
license: GPL
srcversion: 493E700B5A3FD79435A5989
depends: 
vermagic: 3.2.0-6-generic SMP mod_unload modversions 686 
*/

 

在我的笔记本中，可以正常读取显卡温度

附录：一些弯路
1 版本不一致问题
刚开始时，测试的笔记本linux内核为3.2.0-6版本，而用source insight分析的代码版本为2.6.28版本，实质上nouveau显卡驱动模块在2.6.33版本中才加入到系统源码中，且在内核版本2.6.35时，里面并没有提供读取显卡温度的函数[这里很简单，只要进入linux2.6.35/driver/gpu/drm目录下，然后利用grep -R "temp.*input" .查看即可，相反3.3.2版本中提供了相应内容接口]。所以以为显卡温度的获取函数在目录linux2.6.35/driver/hwmon目录下，毕竟该目录都是硬件传感器监控信息，然后Grep –R temp_input ../hwmon找出了hwmon目录下所有有关temp1_input的文件，然后又通过grep -R “_driver)” .|grep pci找出了pci设备对应的驱动文件，如下图所示：


然后对这些文件进行分析，无法找到思路，实际想想，获取温度信息的函数归根结底还是要通过显卡驱动主题部分代码实现，而当时分析的linux2.6.35，好不容易找到了显卡驱动目录，但是就是没有与温度相关的信息文件，只能用英文关键词[英文很重要，百度更懂中文，所以查学术型东西很烂，因为中国人基本就没有好的学术论文，当然也没有丰富详细的英文资料]google，发现了网址http://lists.freedesktop.org/archives/nouveau/2009-November/004087.html，然后意识到，肯定是神奇的最新版本中[因为我的系统内核为3.2.0中有读取显卡传感器的函数]中有读取显卡传感器的函数，下载最新版本3.3.2，然后分析，果然找到了，走了好多弯路
2 关于风扇转速、电压等硬件信息无法读取信息
从上面的分析可以看出,要从内核里面读取风扇转速、电压的传感器信息，相应的内核驱动支持是必不可少的，一般情况下，成功读取比如cpu风扇转速信息需要3个条件：首先，硬件得提供实时获取cpu风扇转速的传感器和对应的存储寄存器，此时转速信息会存储在cpu对应寄存器中，这一部分大多数硬件制造商应该都提供；其次内核中必须提供读取该寄存器信息的驱动程序，可以通过一条汇编指令实现[如何外设I/O采用端口映射]，亦可以通过普通的读取虚存地址实现[外设I/O采用内存映射实现]，这一部分，随着内核版本的不同，有很大差别，lm_sensors中的sensors-detect命令即对各个硬件接口进行探测，查看是否有内核驱动模块能支持对应硬件传感器信息，如果无法读出，说明当前版本的内核没有相应的读取函数，此时只能查看相关硬件文档，自己实现该部分传感器信息的读取、或者自己下载别人实现的函数文件；最后使用sensors、xsensors、nvclock_gtk等用户态应用软件通过系统接口读取内核提供的来自寄存器并经过内核处理的数值，然后进行转化，以用户可以理解的方式来显示显卡温度、cpu温度等信息
3 
  GNU
GPU英文全称Graphic Processing Unit，中文翻译为“图形处理器”。GPU是相对于CPU的一个概念，由于在现代的计算机中（特别是家用系统，游戏的发烧友）图形的处理变得越来越重要，需要一个专门的图形的核心处理器
　DRM
Direct Rendering Manager——直接渲染管理器，它通过增加直接渲染所必要的内核模块来为显卡增加3D加速功能,2D显示芯片在处理3D图像和特效时主要依赖CPU的处理能力，称为“软加速”。3D显示芯片是将三维图像和特效处理功能集中在显示芯片内，也即所谓的“硬件加速”功能