《[arm驱动]linux内核时钟》涉及内核驱动函数四个，内核结构体一个，分析了内核驱动函数一个；可参考的相关应用程序模板或内核驱动模板一个，可参考的相关应用程序模板或内核驱动一个

一、内核定时器
   意义:内核定时器是软件意义上的定时器，最终依赖定时器来实现。时钟中断处理程序会唤起Timer_softirq软中断，运行当前处理器上到期的所有定时器。
二、linux设备驱动编程
   linux内核提供一组函数，时钟数据结构；这组函数和数据结构使驱动工程师不用关心具体的软件定时器究竟对应着怎样的内核和硬件行为。
三、数据结构和函数:
   1)数据结构
结构体一）Linux在include/linux/timer.h头文件中定义了数据结构timer_list来描述一个内核定时器： 

1
2
3
4
5
6
7
struct  timer_list {
        struct  list_head list;  //定时器列表
        unsigned  long  expires;  //定时器到期时间，单位HZ等效与秒
        void  (*function)(unsigned  long );  //处理函数
        unsigned  long  data; //作为参数被输入定时器处理函数
        .................
    };

   2)定时器定义及处理函数
   a)定义一个内核定时器

1
struct  timer_list my_timer;

内核驱动函数一）b)初始化定时器的timer_list的entry中的next指针为null

1
void  init_timer(struct *timer_list timer);

内核源码一）init_timer内核源码

1
2
3
4
5
6
7
8
9
10
void  fastcall init_timer( struct  timer_list *timer)
{
     timer->entry.next = NULL;
     timer->base = __raw_get_cpu_var(tvec_bases);
#ifdef CONFIG_TIMER_STATS
     timer->start_site = NULL;
     timer->start_pid = -1;
     memset (timer->start_comm, 0, TASK_COMM_LEN);
#endif
}


内核驱动函数二)c)添加定时器

1
void  add_timer( struct  timer_list *timer)

内核驱动函数三)d)删除定时器

1
int  del_timer( struct  timer_list * timer)

内核驱动函数四)e)修改定时器的expire

1
int  mod_timer( struct  timer_list *timer, unsigned  long  expires)


模板一)四、内核定时器使用模板(结合虚拟内存)

a）结构体定义

1
2
3
4
5
#define TIMERDELAY 2
struct  VirtualDisk{
     struct  cdev cdev; //详细看cdev机制
     timer_list my_timer; //设备要用的定时器
};

b)结构体赋值，添加时钟，时钟要处理的函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/***********时钟函数，只需调用initMytimer************/
//完成工作后，往往会延后expires并将定时器再次添加到内核定时器链表，以便定时器能再次被触发
static  void  domytimer(unsigned  long  arg){ //just used by initMytimer function
     struct  VirtualDisk* myVirtualDiskp = ( struct  VirtualDisk *)(arg); //很重要
     //..........加上你还要做的代码............
     printk( "arg is %ld\n" , myVirtualDiskp->mytimer.expires); //打印现在的expires
     myVirtualDiskp->mytimer.expires = jiffies + (TIMERDELAY*HZ); //"HZ"等效与"秒"
     add_timer(&myVirtualDiskp->mytimer);
     //.......................
}
static  void  initMytimer( struct  VirtualDisk *myVirtualDiskp,  int  delay){
     init_timer(&myVirtualDiskp->mytimer);
     myVirtualDiskp->mytimer.data = (unsigned  long ) myVirtualDiskp;
     myVirtualDiskp->mytimer.function = &domytimer;
     myVirtualDiskp->mytimer.expires = jiffies + (delay*HZ);
     add_timer(&myVirtualDiskp->mytimer);
}
/***********************/

c)exit()或其他释放函数中删除时钟

1
if (VirtualDiskp)del_timer(&VirtualDiskp->mytimer);

实例一)五、完整代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
//“timerlist_drv”,"timerlist_"
#include <linux/module.h>//模块所需的大量符号和函数定义
#include <linux/kernel.h>
#include <linux/fs.h>//文件系统相关的函数和头文件
#include <linux/init.h> //指定初始化和清除函数
#include <linux/delay.h>
#include <linux/cdev.h> //cdev结构的头文件包含<linux/kdev_t.h>
#include <linux/device.h>
#include <linux/mm.h>
//#include <linux/sched.h>//包含驱动程序使用的大部分内核API的定义，包括睡眠函数以及各种变量声明
#include <asm/uaccess.h>//在内核和用户空间中移动数据的函数
#include <asm/irq.h>
#include <asm/io.h>
#include <asm/arch/regs-gpio.h>
#include <asm/hardware.h>
#include <linux/timer.h>  /*timer*/
#include <asm/uaccess.h>  /*jiffies*/
#define VIRTUALDISK_SIZE  0x1000//4k
#define MEM_CLEAR 0x1
#define VIRTUALDISK_MAJOR 250
/******timer *******/
#define TIMERDELAY 2
int  VirtualDisk_major = VIRTUALDISK_MAJOR;
struct  VirtualDisk{
     struct  cdev cdev; //详细看cdev机制
     unsigned  char  mem[VIRTUALDISK_SIZE ];
     long  count;           /*记录设备目前被多少设备打开*/
     struct  timer_list mytimer;
};
static  struct  class  *timerlist_class;
static  struct  class_device    *timerlist_class_dev;
struct  VirtualDisk *VirtualDiskp;
/*********timer opration*************/
static  void  domytimer(unsigned  long  arg){ //just used by follow function
     struct  VirtualDisk* myVirtualDiskp = ( struct  VirtualDisk *)(arg);
     printk( "arg is %ld\n" , myVirtualDiskp->mytimer.expires);
     myVirtualDiskp->mytimer.expires = jiffies + (TIMERDELAY*HZ);
     add_timer(&myVirtualDiskp->mytimer);
}
static  void  initMytimer( struct  VirtualDisk *myVirtualDiskp,  int  delay){
     init_timer(&myVirtualDiskp->mytimer);
     myVirtualDiskp->mytimer.data = (unsigned  long ) myVirtualDiskp;
     myVirtualDiskp->mytimer.function = &domytimer;
     myVirtualDiskp->mytimer.expires = jiffies + (delay*HZ);
     add_timer(&myVirtualDiskp->mytimer);
}
/*********timer opration over*************/
static  int  timerlist_drv_open( struct  inode *inode,  struct  file *file)
{
     printk( "timerlist_dev read\n" );
     file->private_data = VirtualDiskp;
     VirtualDiskp->count++;     /*增加设备打开次数*/
     return  0;
}
static  int  timerlist_drv_release( struct  inode *inode,  struct  file *file)
{
     printk( "timerlist_dev release\n" );
     VirtualDiskp->count--;   /*减少设备打开次数*/
     return  0;
}
/*seek文件定位函数：seek()函数对文件定位的起始地址可以是文件开头(SEEK_SET,0)、当前位置(SEEK_CUR,1)、文件尾(SEEK_END,2)*/
static  loff_t timerlist_drv_llseek( struct  file *file, loff_t offset,  int  origin){
     loff_t ret = 0; /*返回的位置偏移*/
   switch  (origin)
   {
     case  SEEK_SET:    /*相对文件开始位置偏移*/
       if  (offset < 0) /*offset不合法*/
       {
         ret =  - EINVAL;     /*无效的指针*/
         break ;
       }
       if  ((unsigned  int )offset > VIRTUALDISK_SIZE) /*偏移大于设备内存*/
       {
         ret =  - EINVAL;     /*无效的指针*/
         break ;
       }
       file->f_pos = (unsigned  int )offset;   /*更新文件指针位置*/
       ret = file->f_pos; /*返回的位置偏移*/
       break ;
     case  SEEK_CUR:    /*相对文件当前位置偏移*/
       if  ((file->f_pos + offset) > VIRTUALDISK_SIZE) /*偏移大于设备内存*/
       {
         ret =  - EINVAL; /*无效的指针*/
         break ;
       }
       if  ((file->f_pos + offset) < 0) /*指针不合法*/
       {
         ret =  - EINVAL; /*无效的指针*/
         break ;
       }
       file->f_pos += offset; /*更新文件指针位置*/
       ret = file->f_pos; /*返回的位置偏移*/
       break ;
     default :
       ret =  - EINVAL; /*无效的指针*/
       break ;
   }
   return  ret;
}
/*设备控制函数：ioctl()函数接受的MEM_CLEAR命令，这个命令将全局内存的有效数据长度清零，对于设备不支持的命令，ioctl()函数应该返回-EINVAL*/
static  int  timerlist_drv_ioctl( struct  inode *inode,  struct  file *file, unsigned  int  cmd, unsigned  long  arg){
      struct  VirtualDisk *devp = file->private_data; /*获得设备结构体指针*/
     switch  (cmd)
     {
     case  MEM_CLEAR: /*设备内存清零*/
       memset (devp->mem, 0, VIRTUALDISK_SIZE);
       printk(KERN_INFO  "VirtualDisk is set to zero\n" );
       break ;
     default :
       return   - EINVAL;
     }
     return  0;
}
/*读函数：读写函数主要是让设备结构体的mem[]数组与用户空间交互数据，并随着访问字节数变更返回用户的文件读写偏移位置*/
static  ssize_t timerlist_drv_read( struct  file *file,  const  char  __user *buf,  size_t  count, loff_t * ppos)
{
    printk( "timerlist_dev read\n" );
    unsigned  long  p =  *ppos;  /*记录文件指针偏移位置*/
   unsigned  int  countt = count; /*记录需要读取的字节数*/
   int  ret = 0;     /*返回值*/
   struct  VirtualDisk *devp = file->private_data;  /*获得设备结构体指针*/
   /*分析和获取有效的读长度*/
   if  (p >= VIRTUALDISK_SIZE )   /*要读取的偏移大于设备的内存空间*/
     return  countt ?  - ENXIO: 0; /*读取地址错误*/
   if  (countt > VIRTUALDISK_SIZE  - p) /*要读取的字节大于设备的内存空间*/
     countt = VIRTUALDISK_SIZE  - p; /*将要读取的字节数设为剩余的字节数*/
  /*内核空间->用户空间交换数据*/
   if  (copy_to_user(buf, ( void *)(devp->mem + p), countt))
   {
     ret =  - EFAULT;
   }
   else
   {
     *ppos += countt;
     ret = countt;
     printk( "read %d bytes(s) is  %ld\n" , countt, p);
   }
     printk( "bytes(s) is  %s\n" , buf);
initMytimer(devp, 2);
   return  ret;
}
/*
  file 是文件指针，count 是请求的传输数据长度，buff 参数是指向用户空间的缓冲区，这个缓冲区或者保存要写入的数据，或者是一个存放新读入数据的空缓冲区，该地址在内核空间不能直接读写，ppos 是一个指针指向一个"long offset type"对象, 它指出用户正在存取的文件位置. 返回值是一个"signed size type。写的位置相对于文件开头的偏移。
  */
static  ssize_t timerlist_drv_write( struct  file *file,  const  char  __user *buf,  size_t  count, loff_t * ppos)
{
     printk( "timerlist_dev write\n" );
      unsigned  long  p =  *ppos;  /*记录文件指针偏移位置*/
   int  ret = 0;   /*返回值*/
   unsigned  int  countt = count; /*记录需要写入的字节数*/
   struct  VirtualDisk *devp = file->private_data;  /*获得设备结构体指针*/
   /*分析和获取有效的写长度*/
   if  (p >= VIRTUALDISK_SIZE ) /*要写入的偏移大于设备的内存空间*/
     return  countt ?  - ENXIO: 0; /*写入地址错误*/
   if  (countt > VIRTUALDISK_SIZE  - p) /*要写入的字节大于设备的内存空间*/
     countt = VIRTUALDISK_SIZE  - p; /*将要写入的字节数设为剩余的字节数*/
   /*用户空间->内核空间*/
   if  (copy_from_user(devp->mem + p, buf, countt))
     ret =  - EFAULT;
   else
   {
     *ppos += countt; /*增加偏移位置*/
     ret = countt; /*返回实际的写入字节数*/
     printk( "written %d bytes(s) from%ld\n" , countt, p);
   }
   return  ret;
     return  0;
}
static  struct  file_operations timerlist_drv_fops = {
     .owner  =   THIS_MODULE,     /* 这是一个宏，推向编译模块时自动创建的__this_module变量 */
     .read = timerlist_drv_read,
     .write    =    timerlist_drv_write, 
     .open   =   timerlist_drv_open,
     .release = timerlist_drv_release,
     .llseek = timerlist_drv_llseek,
     .ioctl = timerlist_drv_ioctl,
};
  /*将 cdev 结构嵌入一个你自己的设备特定的结构,你应当初始化你已经分配的结构使用以上函数，有一个其他的 struct cdev 成员你需要初始化. 象 file_operations 结构,struct cdev 有一个拥有者成员,应当设置为 THIS_MODULE，一旦 cdev 结构建立, 最后的步骤是把它告诉内核, 调用:
    cdev_add(&dev->cdev, devno, 1);*/
static  void  VirtualDisk_setup_cdev( struct  VirtualDisk *dev,  int  minorIndex){
     int  err;
     int  devno = MKDEV(VirtualDisk_major, minorIndex);
     cdev_init(&dev->cdev, &timerlist_drv_fops);
     dev->cdev.owner = THIS_MODULE;
     err = cdev_add(&dev->cdev, devno, 1);
     if (err){
     printk( "error %d cdev file added\n" , err);
     }
}
static  int  timerlist_drv_init( void )
{
     int  result;
     dev_t devno = MKDEV(VirtualDisk_major, 0);
     if (VirtualDisk_major){
     result = register_chrdev_region(devno, 1,  "timerlist_dev" );
     } else {
     result = alloc_chrdev_region(&devno, 0, 1,  "timerlist_dev" );
     VirtualDisk_major = MAJOR(devno);
     }
     if (result < 0 ){
     return  result;
     }
     VirtualDiskp = kmalloc( sizeof ( struct  VirtualDisk), GFP_KERNEL);
     if (!VirtualDiskp){
     result = -ENOMEM;
     goto  fail_malloc;
     }
     memset (VirtualDiskp, 0,  sizeof ( struct  VirtualDisk));
     VirtualDisk_setup_cdev(VirtualDiskp, 0);
     timerlist_class = class_create(THIS_MODULE,  "timerlist_drv" );
     if  (IS_ERR(timerlist_class))
         return  PTR_ERR(timerlist_class);
     timerlist_class_dev = class_device_create(timerlist_class, NULL, MKDEV(VirtualDisk_major, 0), NULL,  "timerlist_dev" );  /* /dev/xyz */
     if  (IS_ERR(timerlist_class_dev))
         return  PTR_ERR(timerlist_class_dev);
     return  0;
     fail_malloc:
         unregister_chrdev_region(devno, 1);
         return  result;
}
static  void  timerlist_drv_exit( void )
{
     if (VirtualDiskp)del_timer(&VirtualDiskp->mytimer);
     cdev_del(&VirtualDiskp->cdev);
     kfree(VirtualDiskp);
     unregister_chrdev_region(MKDEV(VirtualDisk_major, 0), 1);
     class_device_unregister(timerlist_class_dev);
     class_destroy(timerlist_class);
}
module_init(timerlist_drv_init);
module_exit(timerlist_drv_exit);
MODULE_LICENSE( "GPL" );

本文转自lilin9105 51CTO博客，原文链接：http://blog.51cto.com/7071976/1391830，如需转载请自行联系原作者