字符设备驱动-内核定时器

前言

写文章的目的是想通过记录自己的学习过程，以便以后使用到相关的知识点可以回顾和参考。

内核时间管理简介

一、宏定义HZ

Linux 内核中有大量的函数需要时间管理，比如周期性的调度程序、延时程序、对于我们驱动编写者来说最常用的定时器。硬件定时器提供时钟源，时钟源的频率可以设置， 设置好以后就周期性的产生定时中断，系统使用定时中断来计时。中断周期性产生的频率就是系统频率，也叫做节拍率(tick rate)(有的资料也叫系统频率)，比如 1000Hz，100Hz 等等说的就是系统节拍率。系统节拍率是可以设置的，单位是 Hz，我们在编译 Linux 内核的时候可以通过图形化界面设置系统节拍率，按照如下路径打开配置界面：
System Type —>
Timer frequency (1000 HZ) —>

可以看出可选的系统节拍率为 100Hz、250Hz、300Hz和1000Hz，默认情况下选择1000Hz。设置好以后打开内核根目录下的.config文件会有如下内容。

Linux会使用CONFIG_HZ来设置自己的系统时钟，打开文件 include/asm-generic/param.h，有如下内容：

里面定义了一个宏 HZ，宏 HZ 就是 CONFIG_HZ，因此 HZ=1000，后面编写 Linux
驱动的时候会常常用到 HZ，因为 HZ 表示一秒的节拍数，也就是频率。

二、变量 jiffies

Linux 内核使用全局变量 jiffies 来记录系统从启动以来的系统节拍数，系统启动的时候会将 jiffies 初始化为 0，jiffies 定义在文件 include/linux/jiffies.h 中，定义如下：

jiffies_64 和 jiffies 其实是同一个东西，jiffies_64 用于 64 位系统，而 jiffies 用于 32 位系统。为了兼容不同的硬件，jiffies 其实就是 jiffies_64 的低 32 位。
前面说了 HZ 表示每秒的节拍数，jiffies 表示系统运行的 jiffies 节拍数，所以 jiffies/HZ 就是系统运行时间，单位为秒。
为了方便开发，Linux 内核提供了几个 jiffies 和 ms、us、ns 之间的转换函数，如下图所示：

内核定时器简介

定时器是一个很常用的功能，需要周期性处理的工作都要用到定时器。Linux 内核定时器采用系统时钟来实现。它并不是我们在裸机中Timer硬件定时器。Linux 内核定时器使用很简单，只需要提供超时时间(相当于定时值)和定时处理函数即可，当超时时间到了以后设置的定时处理函数就会执行，和我们使用硬件定时器的套路一样，只是使用内核定时器不需要做一大堆的寄存器初始化工作。在使用内核定时器的时候要注意一点，内核定时器并不是周期性运行的，超时以后就会自动关闭，因此如果想要实现周期性定时，那么就需要在定时处理函数中重新开启定时器。

一、定时器的定义及其API函数

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 变量，表示定时器。定义好定时器以后还需要通过一系列的 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 函数前定时器已 被激活。

关于内核定时器常用的 API 函数就讲这些。

二、 Linux 内核短延时函数

有时候我们需要在内核中实现短延时，尤其是在 Linux 驱动中。Linux 内核提供了毫秒、微秒和纳秒延时函数，这三个函数如下图所示：

内核定时器实验

通过设置一个定时器来实现周期性的闪烁 LED 灯。

一、 驱动程序

#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/errno.h> 
#include <linux/gpio.h> 
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_gpio.h>
#include <asm/uaccess.h>
#include <asm/io.h>
#include <cfg_type.h>

#define CHRLED_CNT     1                    /* 设备号个数 */
#define CHRLED_NAME    "timer"              /* 名字 */
#define CLOSE_CMD      (_IO('T',0x1))       /* 关闭定时器 */
#define OPEN_CMD       (_IO('T',0x2))       /* 打开定时器 */
#define SETPERIOD_CMD  (_IO('T',0x3))       /* 设置定时器周期 */

/* 定义一个设备信息的结构体 */
struct timer_dev{
    dev_t devid;                    /* 设备号 */
    struct cdev cdev;               /* cdev */
    struct class *class;            /* 类 */
    struct device *device;          /* 设备 */
    int major;                      /* 主设备号 */
    int minor;                      /* 次设备号 */
    spinlock_t lock;                /* 定义一个自旋锁 */
    struct timer_list timer;        /* 定义一个定时器 */
    int timeperiod;                 /* 定时器周期 */
};

struct timer_dev timerdev;


/* 定义一个结构体存放gpio信息 */
struct led_gpio_info{
    unsigned int gpio;          /* GPIO标号 */
    const char *name;           /* 名字 */
};

static const struct led_gpio_info led_gpio_info_tbl[4]={
    {
        .gpio = PAD_GPIO_E+13,  /* 标号的形式 */
        .name = "gpioe13",
    },
    {
        .gpio = PAD_GPIO_C+17,
        .name = "gpioc17",
    },
    {
        .gpio = PAD_GPIO_C+8,
        .name = "gpioc8",
    },
    {
        .gpio = PAD_GPIO_C+7,
        .name = "gpioc7",
    },
};


static int timer_open(struct inode *inode, struct file *filp)
{
    int i;

    filp->private_data = &timerdev;  /* 设置私有数据 */
    //printk(KERN_EMERG "kernel open file ok!\r\n");

    /* 设置4个GPIO为输出模式, 默认关闭LED*/
    for(i=0;i<4;i++)
    {
        gpio_direction_output(led_gpio_info_tbl[i].gpio, 1);
    }

    return 0;
}

static long timer_unlocked_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
    struct timer_dev *dev = filp->private_data;
    //int period;
    unsigned long flags;

    switch(cmd){
        case CLOSE_CMD: /* 关闭定时器 */
            del_timer_sync(&dev->timer);
            break;
        case OPEN_CMD:
            mod_timer(&dev->timer, jiffies+msecs_to_jiffies(dev->timeperiod));
            break;
        case SETPERIOD_CMD:
            spin_lock_irqsave(&dev->lock, flags);   /* 上锁 */
            dev->timeperiod = arg;
            spin_unlock_irqrestore(&dev->lock, flags);  /* 解锁 */

            mod_timer(&dev->timer, jiffies+msecs_to_jiffies(dev->timeperiod));
            break;
        default:
            break;
    }
    return 0;
}

static int timer_release(struct inode *inode, struct file *filp)
{
    printk(KERN_EMERG "kernel close file ok!\r\n");
    return 0;
}

static struct file_operations led_fops = {
    .owner = THIS_MODULE,
    .open = timer_open,
    .release = timer_release,
    .unlocked_ioctl = timer_unlocked_ioctl,
};

/* timer的回调函数 */
void timer_function(unsigned long arg)
{   
    struct timer_dev *dev = (struct timer_dev*)arg;
    static int sta = 1;
    int i;

    sta = !sta;
    for(i=0;i<4;i++)
        gpio_set_value(led_gpio_info_tbl[i].gpio, sta);

    /* 重启定时器 */
    mod_timer(&dev->timer, jiffies+msecs_to_jiffies(dev->timeperiod));
}

/* 驱动入口函数 */
static int __init timer_init(void)
{
    int retvalue;
    int i;

    /* 初始化 LED */
    /* 申请GPIO */
    for(i=0; i<4; i++)
    	gpio_request(led_gpio_info_tbl[i].gpio, led_gpio_info_tbl[i].name);

    /* 申请设备号 */
    if(timerdev.major){
        /* 如果自定义了设备号 */
        timerdev.devid = MKDEV(timerdev.major, 0); 
        retvalue = register_chrdev_region(timerdev.devid, CHRLED_CNT, CHRLED_NAME);
    }else{
        /* 否则,动态申请设备号 */
        retvalue = alloc_chrdev_region(&timerdev.devid, 0, CHRLED_CNT, CHRLED_NAME);
        timerdev.major = MAJOR(timerdev.devid);
        timerdev.minor = MINOR(timerdev.devid);
    }

    printk(KERN_EMERG "led_major = %d\r\n",timerdev.major);
	printk(KERN_EMERG "led_minor = %d\r\n",timerdev.minor);
    
    if(retvalue < 0){
        printk(KERN_EMERG "kernel register chrdev failed!\r\n");
        return -EIO;
    }

    /* 字符设备初始化 */
    timerdev.cdev.owner = THIS_MODULE;
    cdev_init(&timerdev.cdev, &led_fops);

    /* 把字符设备添加到内核 */
    cdev_add(&timerdev.cdev, timerdev.devid, CHRLED_CNT);

    /* 创建类 */
    timerdev.class = class_create(THIS_MODULE, CHRLED_NAME);

    /* 创建设备 */
    timerdev.device = device_create(timerdev.class, NULL, timerdev.devid, NULL, CHRLED_NAME);

    /* 初始化定时器 */
    timerdev.timeperiod = 1000;         /* 默认的周期 */
    init_timer(&timerdev.timer);
    timerdev.timer.function = timer_function;                               /* 定时器处理函数 */
    timerdev.timer.data = (unsigned long)&timerdev;                         /* 传给function的参数 */
    timerdev.timer.expires = jiffies+msecs_to_jiffies(timerdev.timeperiod); /* 超时时间 */
    add_timer(&timerdev.timer);     /* 启动定时器 */

    return 0;
}

/* 驱动出口函数 */
static void __exit timer_exit(void)
{
    int i;
	/* 释放GPIO */
    for(i=0; i<4; i++)
		gpio_free(led_gpio_info_tbl[i].gpio);

    /* 删除设备 */
    device_destroy(timerdev.class, timerdev.devid);

    /* 删除类 */
    class_destroy(timerdev.class);

    /* 把字符设备从内核中删除 */
    cdev_del(&timerdev.cdev);

    /* 注销字符设备驱动 */
    unregister_chrdev_region(timerdev.devid, CHRLED_CNT);

    /* 删除定时器 */
    del_timer_sync(&timerdev.timer);
}

module_init(timer_init);
module_exit(timer_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("xzj");

二、 应用程序

#include "stdio.h"
#include "unistd.h"
#include "sys/types.h"
#include "sys/stat.h"
#include "fcntl.h"
#include "stdlib.h"
#include "string.h"
#include "sys/ioctl.h"

//#define LEDOFF 0
//#define LEDON 1

#define CLOSE_CMD      (_IO('T',0x1))       /* 关闭定时器 */
#define OPEN_CMD       (_IO('T',0x2))       /* 打开定时器 */
#define SETPERIOD_CMD  (_IO('T',0x3))       /* 设置定时器周期 */

int main(int argc , char *argv[])
{
    int fd, retvalue, ret;
    char *filename;
    unsigned char str[100];
    unsigned int cmd;
    unsigned int arg;

    if(argc != 2){
        printf("Error Usage!\r\n");
        return -1;
    }

    filename = argv[1];

    /* 打开驱动文件 */
    fd = open(filename, O_RDWR);
    if(fd < 0){
        printf("Can't open file %s\r\n", filename);
        return -1;
    }

    while(1){
        printf("Input the cmd:");
        ret = scanf("%d",&cmd);
        if(ret != 1){
            fgets(str,100,stdin);		/* 防止卡死 */
        }

        if(cmd == 1)
            cmd = CLOSE_CMD;
        else if(cmd == 2)
            cmd = OPEN_CMD;
        else if(cmd == 3){
            cmd = SETPERIOD_CMD;
            printf("Input timer period:");
            ret = scanf("%d",&arg);
            if(ret != 1){
                fgets(str,100,stdin);	/* 防止卡死 */
            }
        }
        ioctl(fd, cmd, arg);
    }

    /* 关闭设备 */
    retvalue = close(fd);
    if(retvalue < 0){
        printf("Can't close file %s\r\n", filename);
        return -1;
    }

    return 0;
}

三、 测试

在开发板终端输入如下命令：

1：关闭定时器
2：启动定时器
3：改变定时器周期

通过改变定时器周期，能观察到LED闪烁频率的变化。