内核定时器的应用

好的帖子：https://blog.csdn.net/haozhao_blog/article/details/24198661

https://blog.csdn.net/jidonghui/article/details/7449546

 

定时器有啥作用？

LINUX内核定时器是内核用来控制在未来某个时间点（基于jiffies）调度执行某个函数的一种机制，其实现位于 <linux/timer.h> 和 kernel/timer.c 文件中。

被调度的函数肯定是异步执行的，它类似于一种“软件中断”，而且是处于非进程的上下文中，所以调度函数必须遵守以下规则：

1) 没有 current 指针、不允许访问用户空间。因为没有进程上下文，相关代码和被中断的进程没有任何联系。

2) 不能执行休眠（或可能引起休眠的函数）和调度。

3) 任何被访问的数据结构都应该针对并发访问进行保护，以防止竞争条件。

内核定时器的调度函数运行过一次后就不会再被运行了（相当于自动注销），但可以通过在被调度的函数中重新调度自己来周期运行。

在SMP系统中，调度函数总是在注册它的同一CPU上运行，以尽可能获得缓存的局域性。

过程：1、初始化

2、注册

3、注销

定时器API

内核定时器的数据结构

struct timer_list {

    struct list_head entry;

    unsigned long expires;

    void (*function)(unsigned long);

    unsigned long data;

    struct tvec_base *base;

    /* ... */

};

其中 expires 字段表示期望定时器执行的 jiffies 值，到达该 jiffies 值时，将调用 function 函数，并传递 data 作为参数。当一个定时器被注册到内核之后，entry 字段用来连接该定时器到一个内核链表中。base 字段是内核内部实现所用的。

需要注意的是 expires 的值是32位的，因为内核定时器并不适用于长的未来时间点。

初始化

在使用 struct timer_list 之前，需要初始化该数据结构，确保所有的字段都被正确地设置。初始化有两种方法。

方法一：

DEFINE_TIMER(timer_name, function_name, expires_value, data);

该宏会静态创建一个名叫 timer_name 内核定时器，并初始化其 function, expires, name 和 base 字段。

方法二：

struct timer_list mytimer;

setup_timer(&mytimer, (*function)(unsigned long), unsigned long data);

mytimer.expires = jiffies + 5*HZ;

方法3：

struct timer_list mytimer;

init_timer(&mytimer);    

  mytimer ->timer.expires = jiffies + 5*HZ;

  mytimer ->timer.data = (unsigned long) dev;

  mytimer ->timer.function = &corkscrew_timer; /* timer handler */

通过init_timer()动态地定义一个定时器，此后，将处理函数的地址和参数绑定给一个timer_list，

注意，无论用哪种方法初始化，其本质都只是给字段赋值，所以只要在运行 add_timer() 之前，expires, function 和 data 字段都可以直接再修改。

关于上面这些宏和函数的定义，参见 include/linux/timer.h。

注册

定时器要生效，还必须被连接到内核专门的链表中，这可以通过 add_timer(struct timer_list *timer) 来实现。

重新注册

要修改一个定时器的调度时间，可以通过调用 mod_timer(struct timer_list *timer, unsigned long expires)。mod_timer() 会重新注册定时器到内核，而不管定时器函数是否被运行过。

注销

注销一个定时器，可以通过 del_timer(struct timer_list *timer) 或 del_timer_sync(struct timer_list *timer)。其中 del_timer_sync 是用在 SMP 系统上的（在非SMP系统上，它等于del_timer），当要被注销的定时器函数正在另一个 cpu 上运行时，del_timer_sync() 会等待其运行完，所以这个函数会休眠。另外还应避免它和被调度的函数争用同一个锁。对于一个已经被运行过且没有重新注册自己的定时器而言，注销函数其实也没什么事可做。

 

int timer_pending(const struct timer_list *timer)

这个函数用来判断一个定时器是否被添加到了内核链表中以等待被调度运行。注意，当一个定时器函数即将要被运行前，内核会把相应的定时器从内核链表中删除（相当于注销）

 

--------------------------------程序分析----------------------------------------------

1 #include <linux/module.h>

2 #include <linux/init.h>

3 #include <linux/major.h>

4 #include <linux/cdev.h>

5 #include <linux/device.h>

6 #include <linux/types.h>

7 #include <linux/fs.h>

8 #include <asm/uaccess.h>

9 #include <linux/io.h>

10 #include <linux/sched.h>

11 //#include <asm/irq.h>

12 #include <linux/gpio.h>

13 #include <linux/interrupt.h>

14 #include <linux/input.h>

15

16 #define TAG "timer"

17 #define INT_GPIO 91

18 #define MY_KEY_CODE KEY_T

19

20 struct timer_list key_timer_list; //定义结构体

21

22 static int irq;

23 static struct input_dev *kinput;

24 static int prevalue;

25 static int value;

26

27 volatile unsigned long *tlmm_gpio_cfg;

28 volatile unsigned long *tlmm_in_out;

29

30 static void key_timer_func(unsigned long data)

31 {

32 printk(TAG"%s\n", __func__);

33 value = *tlmm_in_out;

34 value &= 0x1;

35

36 if (value == prevalue) {

37 if (value) {

38 input_report_key(kinput, MY_KEY_CODE, 0);

39 input_sync(kinput);

40 printk(TAG"key is release\n");

41 } else {

42 input_report_key(kinput, MY_KEY_CODE, 1);

43 input_sync(kinput);

44 printk(TAG"key is press\n");

45 }

46

47 }

48 }

49

50 static irqreturn_t key_irq_thread(int irq, void *data)

51 {

52 printk(TAG"%s\n", __func__);

53 prevalue = *tlmm_in_out;

54 prevalue &= 0x1;

55 /*内核通过函数mod_timer来实现已经激活的定时器超时时间：

56 mod_timer(&key_timer_list, jiffies + msecs_to_jiffies(10));

57

58 return IRQ_HANDLED;

59 }

60

61 static int my_key_init(void)

62 {

63 int retval;

64

65 printk(TAG"%s %d\n", __func__, __LINE__);

66

67 kinput = input_allocate_device();

68 if (!kinput)

69 return -ENOMEM;

70 kinput->name = "keyt";

71 __set_bit(EV_KEY, kinput->evbit);

72 __set_bit(MY_KEY_CODE, kinput->keybit);

73

74 retval = input_register_device(kinput);

75 if(retval)

76 goto input_register_error;

77

78 tlmm_gpio_cfg = (volatile unsigned long *)ioremap(0x105B000, 8);

79 tlmm_in_out = tlmm_gpio_cfg + 1;

80 *tlmm_gpio_cfg |= 0x3;

81

82 irq = gpio_to_irq(INT_GPIO);

83 printk(TAG"%s irq is %d\n", __func__, irq);

84 retval = request_threaded_irq(irq, NULL, key_irq_thread, IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING |IRQF_ONESHOT, "vol_k ey", NULL);

85 printk(TAG"%s ret is %d\n", __func__, retval);

86 /*通过init_timer()动态地定义一个定时器，此后，将处理函数的地址和参数绑定给一个timer_list

87 init_timer(&key_timer_list);

88

89 key_timer_list.function = key_timer_func;

90

91 return 0;

92

93 input_register_error:

94 input_free_device(kinput);

95 return retval;

96 }

97

98 static void key_exit(void)

99 {

/*从激活的定时器链表中去除一个定时器

/**如果需要在定时器超时前停止定时器，可以使用del_timer函数：

100 del_timer(&key_timer_list);

101 free_irq(irq, NULL);

102 input_unregister_device(kinput);

103 printk(TAG"%s %d\n", __func__, __LINE__);

104 }

105

106 module_init(my_key_init);

107 module_exit(key_exit);

108 MODULE_LICENSE("GPL");