一、内核时间
💦在编写驱动的时候有时候会用到定时器,除了使用硬件的定时器,内核中也提供了时间管理的API函数,至于这个系统节拍是怎么产生的不去过多的关注。
下面介绍下节拍率的概念:定时器提供时钟源,时钟源的频率可以设置, 设置好以后就周期性的产生定时中断,系统使用定时中断来计时。中断周期性产生的频率就是系统频率,也叫做节拍率(tick rate),比如 1000Hz,100Hz 等等说的就是系统节拍率。系统节拍率是可以设置的,单位是 Hz。
我们在编译 Linux 内核的时候可以通过图形化界面设置系统节拍率,按照如下路径打开配置界面:
在.config中可以看到有个宏定义CONFIG_HZ=100,这个就是代表着系统的节拍率为100Hz。
Linux 内核会使用 CONFIG_HZ 这个宏定义来设置自己的系统时钟。打开文件 include/asm-generic/param.h,有如下内容:
节拍率有不同选择,有高有低,各有优缺点如下:
①、高节拍率会提高系统时间精度,如果采用 100Hz 的节拍率,时间精度就是 10ms,采用1000Hz 的话时间精度就是 1ms,精度提高了 10 倍。高精度时钟的好处有很多,对于那些对时间要求严格的函数来说,能够以更高的精度运行,时间测量也更加准确。
②、高节拍率会导致中断的产生更加频繁,频繁的中断会加剧系统的负担,1000Hz 和 100Hz的系统节拍率相比,系统要花费 10 倍的“精力”去处理中断。中断服务函数占用处理器的时间增加,但是现在的处理器性能都很强大,所以采用 1000Hz 的系统节拍率并不会增加太大的负载压力。
二、节拍数
Linux 内核使用全局变量 jiffies 来记录系统从启动以来的系统节拍数,通过节拍数来实现定时功能,系统启动的时候会将 jiffies 初始化为 0,jiffies 定义在文件 include/linux/jiffies.h 中,定义如下:
76 extern u64 __jiffy_data jiffies_64;
77 extern unsigned long volatile __jiffy_data jiffies;
当我们访问 jiffies 的时候其实访问的是 jiffies_64 的低 32 位,使用 get_jiffies_64 这个函数可以获取 jiffies_64 的值。在 32 位的系统上读取 jiffies 的值,在 64 位的系统上 jiffes 和 jiffies_64表示同一个变量,因此也可以直接读取 jiffies 的值。所以不管是 32 位的系统还是 64 位系统,都可以使用 jiffies。
HZ 表示每秒的节拍数,jiffies 表示系统运行的 jiffies 节拍数,所以 jiffies/HZ 就是系统运行时间,单位为秒。 jiffies 是一个变量,是变量就有数据类型,所以不管是 32 位还是 64 位的 jiffies,都有溢出的风险,溢出以后会重新从 0 开始计数,相当于绕回来了,这个现象也叫做绕回。
假如 HZ 为最大值 1000 的时候,32 位的 jiffies 只需要 49.7 天就发生了绕回,对于 64 位的 jiffies 来说大概需要
5.8 亿年才能绕回,因此 jiffies_64 的绕回忽略不计。
所以处理 32 位 jiffies 的绕回就变得非常重要了,Linux 内核提供了API 函数来处理绕回。
代码格式如下:
1 unsigned long timeout;
2 timeout = jiffies + (2 * HZ); /* 超时的时间点 */
3
4 /*************************************
5 具体的代码
6 ************************************/
7
8 /* 判断有没有超时 */
9 if(time_before(jiffies, timeout)) {
10 /* 超时未发生 */
11 } else {
12 /* 超时发生 */
13 }
timeout 就是超时时间点,比如我们要判断代码执行时间是不是超过了 2 秒,那么超时时间点就是 jiffies+(2*HZ),如果 jiffies 大于 timeout 那就表示超时了,否则就是没有超时。
为了方便开发,Linux 内核提供了几个 jiffies 和 ms、us、ns 之间的转换函数:
三、内核定时器简
定时器是一个很常用的功能,需要周期性处理的工作都要用到定时器。Linux 内核定时器采用系统时钟来实现,并不是mcu硬件定时器。Linux 内核定时器使用很简单,只需要提供超时时间(相当于定时值)和定时处理函数即可,当超时时间到了以后设置的定时处理函数就会执行。如果想要实现周期性定时,那么就需要在定时处理函数中重新开启定时器。
Linux 内核使用 timer_list 结构体表示内核定时器,timer_list 定义在文件include/linux/timer.h 中,定义如下:
struct timer_list {
struct list_head entry;
unsigned long expires; /* 定时器超时时间,单位是节拍数 */
struct tvec_base *base;
void (*function)(unsigned long); /* 定时处理函数 */
unsigned long data; /* 要传递给 function 函数的参数 */
int slack;
};
要使用内核定时器首先要先定义一个 timer_list 变量,表示定时器,tiemr_list 结构体的expires 成员变量表示超时时间,单位为节拍数。比如我们现在需要定义一个周期为 2 秒的定时器,那么这个定时器的超时时间就是 jiffies+(2HZ),因此 expires=jiffies+(2HZ)。function 就是定时器超时以后的定时处理函数,我们要做的工作就放到这个函数里面,需要我们编写这个定时处理函数。
定时器的初始化前工作就配置完成,然后在使用Linux提供的API函数,操作定时器的开启,更改时间等操作。
1.init_timer 函数
init_timer 函数负责初始化 timer_list 类型变量,当我们定义了一个 timer_list 变量以后一定要先用 init_timer 初始化一下。init_timer 函数原型如下:
void init_timer(struct timer_list *timer)
函数参数和返回值含义如下:
timer:要初始化定时器。
返回值:没有返回值。
2.add_timer 函数
add_timer 函数用于向 Linux 内核注册定时器,使用 add_timer 函数向内核注册定时器以后,定时器就会开始运行,函数原型如下:
void add_timer(struct timer_list *timer)
函数参数和返回值含义如下:
timer:要注册的定时器。
返回值:没有返回值。
3.del_timer 函数
del_timer 函数用于删除一个定时器,不管定时器有没有被激活,都可以使用此函数删除。在多处理器系统上,定时器可能会在其他的处理器上运行,因此在调用 del_timer 函数删除定时器之前要先等待其他处理器的定时处理器函数退出。del_timer 函数原型如下:
int del_timer(struct timer_list * timer)
函数参数和返回值含义如下:
timer:要删除的定时器。
返回值:0,定时器还没被激活;1,定时器已经激活
4.del_timer_sync 函数
del_timer_sync 函数是 del_timer 函数的同步版,会等待其他处理器使用完定时器再删除,del_timer_sync 不能使用在中断中。del_timer_sync 函数原型如下所示:
int del_timer_sync(struct timer_list *timer)
函数参数和返回值含义如下:
timer:要删除的定时器。
返回值:0,定时器还没被激活;1,定时器已经激活。
5.mod_timer 函数
mod_timer 函数用于修改定时值,如果定时器还没有激活的话,mod_timer 函数会激活定时
器!函数原型如下:
int mod_timer(struct timer_list *timer, unsigned long expires)
函数参数和返回值含义如下:
timer:要修改超时时间(定时值)的定时器。
expires:修改后的超时时间。
返回值:0,调用 mod_timer 函数前定时器未被激活;1,调用 mod_timer 函数前定时器已被激活。
6.定时器使用格式如下
1 struct timer_list timer; /* 定义定时器 */
2
3 /* 定时器回调函数 */
4 void function(unsigned long arg)
5 {
6 /*
7 * 定时器处理代码
8 */
9
10 /* 如果需要定时器周期性运行的话就使用 mod_timer
11 * 函数重新设置超时值并且启动定时器。
12 */
13 mod_timer(&dev->timertest, jiffies + msecs_to_jiffies(2000));
14 }
15
16 /* 初始化函数 */
17 void init(void)
18 {
19 init_timer(&timer); /* 初始化定时器 */
20
21 timer.function = function; /* 设置定时处理函数 */
22 timer.expires=jffies + msecs_to_jiffies(2000);/* 超时时间 2 秒 */
23 timer.data = (unsigned long)&dev; /* 将设备结构体作为参数 */
24
25 add_timer(&timer); /* 启动定时器 */
26 }
27
28 /* 退出函数 */
29 void exit(void)
30 {
31 del_timer(&timer); /* 删除定时器 */
32 /* 或者使用 */
33 del_timer_sync(&timer);
34 }
四、定时器应用举例
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/export.h>
#include <linux/types.h>
#include <linux/uaccess.h> // copy_to_user() & copy_from_user
#include <asm/io.h> //ioremap
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/gpio.h>
#include <linux/of_gpio.h>
#include <linux/timer.h>
MODULE_AUTHOR("Jim Cromie <jim.cromie@gmail.com>");
MODULE_DESCRIPTION("NatSemi/Winbond PC-8736x GPIO Pin Driver");
MODULE_LICENSE("GPL");
#define DEVNAME "gpioled"
/*设备结构体*/
struct gpioled_dev{
dev_t devid;/*设备号*/
int major; /*主设备号*/
int minor; /*次设备号*/
struct cdev cdev;/*字符设备结构体*/
struct class *class;/*类*/
struct device *device;/*设备*/
struct device_node *node;/*设备节点*/
int led_gpio;
atomic_t lock; /*原子变量*/
struct timer_list timer;
int sta;
};
struct gpioled_dev gpioled;/*led结构体变量*/
static int gpioled_open(struct inode *inode, struct file *filp)
{
filp->private_data = &gpioled;
/* 通过判断原子变量的值来检查 LED 有没有被别的应用使用
当gpioled.lock小雨等于0时,表示驱动正在被使用 */
if(atomic_read(&gpioled.lock) <= 0)
{
return -EBUSY;
}else{
atomic_dec(&gpioled.lock);
}
printk("gpioled_open\n\r");
return 0;
}
static int gpioled_release(struct inode *inode, struct file *filp)
{
struct gpioled_dev *dev = (struct gpioled_dev *)filp->private_data;
/* 关闭的时候释放原子变量*/
atomic_inc(&dev->lock);
//printk("gpioled_open\n\r");
return 0;
}
static ssize_t gpioled_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos)
{
//struct gpioled *gpioled = (struct gpioled *)filp->private_data;
//printk("gpioled_open\n\r");
return 0;
}
static ssize_t gpioled_write(struct file *filp, const char __user *buf, size_t count, loff_t *f_pos)
{
struct gpioled_dev *dev = (struct gpioled_dev *)filp->private_data;
int ret = 0;
unsigned char databuff[1];
ret = copy_from_user(databuff, buf, count);
if(ret < 0)
{
printk("copy_from_user error\n\r");
return -EPERM;
}
if(databuff[0] == 0)
{
gpio_set_value(dev->led_gpio, 0);
}
if(databuff[0] == 1)
{
gpio_set_value(dev->led_gpio, 1);
}
//printk("gpioled_open\n\r");
return 0;
}
const struct file_operations gpioled_fops = {
//.owner = THIS_MODULE,
.open = gpioled_open,
.release = gpioled_release,
.read = gpioled_read,
.write = gpioled_write,
};
static void timer_func(unsigned long data)
{
struct gpioled_dev *dev = (struct gpioled_dev *)data;
static int sta = 1;
sta = !sta;
//dev->sta = !dev->sta;
//printk("timer function\n\r");
// gpio_set_value(dev->led_gpio,dev->sta);
gpio_set_value(dev->led_gpio,sta);
mod_timer(&dev->timer, jiffies + msecs_to_jiffies(1000));
}
static int __init gpioled_init(void)
{
/*注册*/
int ret = -1;
gpioled.sta = 1;
/*初始化原子变量*/
atomic_set(&gpioled.lock, 1);
/*设备号申请*/
if(gpioled.major){
gpioled.devid = MKDEV(gpioled.major,0);
ret = register_chrdev_region(gpioled.devid, 1, DEVNAME);
}else{
ret = alloc_chrdev_region(&gpioled.devid, 0, 1, DEVNAME);
gpioled.major = MAJOR(gpioled.devid);
gpioled.minor = MINOR(gpioled.devid);
}
if (ret < 0)
{
printk("alloc_chrdev_region failed\n");
goto devid_fail;
}
printk("major=%d, minor=%d\n", gpioled.major, gpioled.minor);
/*字符设备初始化*/
cdev_init(&gpioled.cdev,&gpioled_fops);
gpioled.cdev.owner = THIS_MODULE;
gpioled.cdev.ops = &gpioled_fops;
ret = cdev_add(&gpioled.cdev, gpioled.devid,1);
if (ret < 0)
{
printk("cdev_add failed\n");
goto cdev_add_fail;
}
/*类创建*/
gpioled.class = class_create(THIS_MODULE, DEVNAME);
if (IS_ERR(gpioled.class))
{
printk("class_create failed\n");
goto class_create_fail;
}
/*设备创建*/
gpioled.device = device_create(gpioled.class, NULL, gpioled.devid, NULL, DEVNAME);
if (IS_ERR(gpioled.device))
{
printk("device_create failed\n");
goto device_create_fail;
}
//获取设备属性信息
//1获取节点
gpioled.node = of_find_node_by_path("/gpioled");
if(gpioled.node == NULL)
{
printk("of_find_node_by_path error\n\r");
goto of_find_node_by_path_failed;
}
//2获取led灯gpio的编号
gpioled.led_gpio = of_get_named_gpio(gpioled.node,"led-gpios",0);
if(gpioled.led_gpio < 0)
{
printk("of_get_named_gpio error\n\r");
goto of_get_named_gpio_failed;
}
printk("of_get_named_gpio=%d\n\r",gpioled.led_gpio);
//3申请gpio,申请成功要记得释放
ret = gpio_request(gpioled.led_gpio, "led-gpio");
if (ret) {
printk("gpio_request failed\n");
goto gpio_request_failed;
}
//4使用io,设置输出
ret = gpio_direction_output(gpioled.led_gpio, 1);
if (ret) {
printk("gpio_direction_output failed\n");
goto gpio_direction_output_failed;
}
//5设置io为低电平
gpio_set_value(gpioled.led_gpio, 0);
/* 6、初始化 timer,设置定时器处理函数,还未设置周期,所有不会激活定时器 */
init_timer(&gpioled.timer);
gpioled.timer.data = (unsigned long)&gpioled;//传递给功能函数的参数
gpioled.timer.function = timer_func;
gpioled.timer.expires = jiffies + msecs_to_jiffies(1000);//500ms周期
add_timer(&gpioled.timer);
return 0;
gpio_direction_output_failed:
gpio_free(gpioled.led_gpio);
gpio_request_failed:
of_get_named_gpio_failed:
of_find_node_by_path_failed:
device_create_fail:
class_destroy(gpioled.class);
class_create_fail:
cdev_del(&gpioled.cdev);
cdev_add_fail:
unregister_chrdev_region(gpioled.devid, 1);
devid_fail:
return ret;
}
static void __exit gpioled_exit(void)
{
gpio_set_value(gpioled.led_gpio, 1);
del_timer_sync(&gpioled.timer);//删除定时器
/*注销*/
device_destroy(gpioled.class, gpioled.devid);
class_destroy(gpioled.class);
cdev_del(&gpioled.cdev);
unregister_chrdev_region(gpioled.devid, 1);
printk(KERN_INFO "gpioled_exit\n");
/*释放io*/
gpio_free(gpioled.led_gpio);
}
/*驱动入口函数和出口函数*/
module_init(gpioled_init);
module_exit(gpioled_exit);
五、定时器应用举例-使用ioctl函数
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/export.h>
#include <linux/types.h>
#include <linux/uaccess.h> // copy_to_user() & copy_from_user
#include <asm/io.h> //ioremap
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/gpio.h>
#include <linux/of_gpio.h>
#include <linux/timer.h>
MODULE_AUTHOR("Jim Cromie <jim.cromie@gmail.com>");
MODULE_DESCRIPTION("NatSemi/Winbond PC-8736x GPIO Pin Driver");
MODULE_LICENSE("GPL");
#define CLOSE_CMD _IO(0xEF,1) //关闭命令
#define OPEN_CMD _IO(0xEF,2) //打开命令
#define SET_CMD _IOW(0xEF,3,int) //设置周期命令
#define DEVNAME "gpioled"
/*设备结构体*/
struct gpioled_dev{
dev_t devid;/*设备号*/
int major; /*主设备号*/
int minor; /*次设备号*/
struct cdev cdev;/*字符设备结构体*/
struct class *class;/*类*/
struct device *device;/*设备*/
struct device_node *node;/*设备节点*/
int led_gpio;
atomic_t lock; /*原子变量*/
struct timer_list timer;/*定时器*/
int timer_period; /*定时器周期*/
int sta;
};
struct gpioled_dev gpioled;/*led结构体变量*/
static int gpioled_open(struct inode *inode, struct file *filp)
{
filp->private_data = &gpioled;
/* 通过判断原子变量的值来检查 LED 有没有被别的应用使用
当gpioled.lock小雨等于0时,表示驱动正在被使用 */
if(atomic_read(&gpioled.lock) <= 0)
{
return -EBUSY;
}else{
atomic_dec(&gpioled.lock);
}
printk("gpioled_open\n\r");
return 0;
}
static int gpioled_release(struct inode *inode, struct file *filp)
{
struct gpioled_dev *dev = (struct gpioled_dev *)filp->private_data;
/* 关闭的时候释放原子变量*/
atomic_inc(&dev->lock);
//printk("gpioled_open\n\r");
return 0;
}
static ssize_t gpioled_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos)
{
//struct gpioled *gpioled = (struct gpioled *)filp->private_data;
//printk("gpioled_open\n\r");
return 0;
}
//ioctl的cmd命令格式
//#define IPMICTL_SEND_COMMAND _IOR(IPMI_IOC_MAGIC, 13,struct ipmi_req)
static long gpioled_ioctl(struct file *filp, unsigned int cmd,unsigned long arg)
{
struct gpioled_dev *dev = (struct gpioled_dev *)filp->private_data;
int value;
int ret = 0;
switch (cmd) {
case CLOSE_CMD:
del_timer_sync(&dev->timer);
break;
case OPEN_CMD:
mod_timer(&dev->timer, jiffies + msecs_to_jiffies(dev->timer_period));
break;
case SET_CMD:
ret = copy_from_user(&value,(int *)arg,sizeof(int));
if(ret < 0){
return -EFAULT;
}
dev->timer_period = value;
mod_timer(&dev->timer, jiffies + msecs_to_jiffies(dev->timer_period));
break;
default:
break;
}
return 0;
}
const struct file_operations gpioled_fops = {
//.owner = THIS_MODULE,
.open = gpioled_open,
.release = gpioled_release,
.read = gpioled_read,
.unlocked_ioctl = gpioled_ioctl,
};
static void timer_func(unsigned long data)
{
struct gpioled_dev *dev = (struct gpioled_dev *)data;
static int sta = 1;
sta = !sta;
//dev->sta = !dev->sta;
//printk("timer function\n\r");
// gpio_set_value(dev->led_gpio,dev->sta);
gpio_set_value(dev->led_gpio,sta);
mod_timer(&dev->timer, jiffies + msecs_to_jiffies(gpioled.timer_period));
}
static int __init gpioled_init(void)
{
/*注册*/
int ret = -1;
gpioled.sta = 1;
/*初始化原子变量*/
atomic_set(&gpioled.lock, 1);
/*设备号申请*/
if(gpioled.major){
gpioled.devid = MKDEV(gpioled.major,0);
ret = register_chrdev_region(gpioled.devid, 1, DEVNAME);
}else{
ret = alloc_chrdev_region(&gpioled.devid, 0, 1, DEVNAME);
gpioled.major = MAJOR(gpioled.devid);
gpioled.minor = MINOR(gpioled.devid);
}
if (ret < 0)
{
printk("alloc_chrdev_region failed\n");
goto devid_fail;
}
printk("major=%d, minor=%d\n", gpioled.major, gpioled.minor);
/*字符设备初始化*/
cdev_init(&gpioled.cdev,&gpioled_fops);
gpioled.cdev.owner = THIS_MODULE;
gpioled.cdev.ops = &gpioled_fops;
ret = cdev_add(&gpioled.cdev, gpioled.devid,1);
if (ret < 0)
{
printk("cdev_add failed\n");
goto cdev_add_fail;
}
/*类创建*/
gpioled.class = class_create(THIS_MODULE, DEVNAME);
if (IS_ERR(gpioled.class))
{
printk("class_create failed\n");
goto class_create_fail;
}
/*设备创建*/
gpioled.device = device_create(gpioled.class, NULL, gpioled.devid, NULL, DEVNAME);
if (IS_ERR(gpioled.device))
{
printk("device_create failed\n");
goto device_create_fail;
}
//获取设备属性信息
//1获取节点
gpioled.node = of_find_node_by_path("/gpioled");
if(gpioled.node == NULL)
{
printk("of_find_node_by_path error\n\r");
goto of_find_node_by_path_failed;
}
//2获取led灯gpio的编号
gpioled.led_gpio = of_get_named_gpio(gpioled.node,"led-gpios",0);
if(gpioled.led_gpio < 0)
{
printk("of_get_named_gpio error\n\r");
goto of_get_named_gpio_failed;
}
printk("of_get_named_gpio=%d\n\r",gpioled.led_gpio);
//3申请gpio,申请成功要记得释放
ret = gpio_request(gpioled.led_gpio, "led-gpio");
if (ret) {
printk("gpio_request failed\n");
goto gpio_request_failed;
}
//4使用io,设置输出
ret = gpio_direction_output(gpioled.led_gpio, 1);
if (ret) {
printk("gpio_direction_output failed\n");
goto gpio_direction_output_failed;
}
//5设置io为低电平
gpio_set_value(gpioled.led_gpio, 0);
/* 6、初始化 timer,设置定时器处理函数,还未设置周期,所有不会激活定时器 */
init_timer(&gpioled.timer);
gpioled.timer_period = 1000;
gpioled.timer.data = (unsigned long)&gpioled;//传递给功能函数的参数
gpioled.timer.function = timer_func;
gpioled.timer.expires = jiffies + msecs_to_jiffies(gpioled.timer_period);//500ms周期
add_timer(&gpioled.timer);
return 0;
gpio_direction_output_failed:
gpio_free(gpioled.led_gpio);
gpio_request_failed:
of_get_named_gpio_failed:
of_find_node_by_path_failed:
device_create_fail:
class_destroy(gpioled.class);
class_create_fail:
cdev_del(&gpioled.cdev);
cdev_add_fail:
unregister_chrdev_region(gpioled.devid, 1);
devid_fail:
return ret;
}
static void __exit gpioled_exit(void)
{
gpio_set_value(gpioled.led_gpio, 1);
/*删除定时器*/
del_timer_sync(&gpioled.timer);
/*注销*/
device_destroy(gpioled.class, gpioled.devid);
class_destroy(gpioled.class);
cdev_del(&gpioled.cdev);
unregister_chrdev_region(gpioled.devid, 1);
printk(KERN_INFO "gpioled_exit\n");
/*释放io*/
gpio_free(gpioled.led_gpio);
}
/*驱动入口函数和出口函数*/
module_init(gpioled_init);
module_exit(gpioled_exit);