深入浅出：Linux设备驱动之中断与定时器
原文出处： 时光漫步LH “我叮咛你的 你说 不会遗忘 你告诉我的 我也全部珍藏 对于我们来说 记忆是飘不落的日子 永远不会发黄 相聚的时候 总是很短 期待的时候 总是很长 岁月的溪水边 捡拾起多少闪亮的诗行 如果你要想念我 就望一望天上那 闪烁的繁星 有我寻觅你的 目光” 谢谢你，曾经来过~中断与定时器是我们再熟悉不过的问题了，我们在进行裸机开发学习的 时候，这几乎就是重难点，也
“我叮咛你的 你说 不会遗忘 你告诉我的 我也全部珍藏 对于我们来说 记忆是飘不落的日子 永远不会发黄 相聚的时候 总是很短 期待的时候 总是很长 岁月的溪水边 捡拾起多少闪亮的诗行 如果你要想念我 就望一望天上那 闪烁的繁星 有我寻觅你的 目光” 谢谢你，曾经来过~
中断与定时器是我们再熟悉不过的问题了，我们在进行裸机开发学习的 时候，这几乎就是重难点，也是每个程序必要的模块信息，那么在Linux中，我们又怎么实现延时、计数，和中断呢？
一、中断
1.概述
所谓中断是指cpu在执行程序的过程中，出现了某些突发事件急待处理，cpu必需暂停执行当前执行的程序，转去处理突发事件，处理完之后cpu又返回原程序位置并继续执行，根据中断来源，中断分为内部中断和外部中断，软中断指令等属于内部中断，中断还可以分为可屏蔽中断和不可以屏蔽中断。Linux 的中断处理分为顶半部和底半部，顶半部完成尽可能少得的比较紧急的功能，往往只是简单的完成“登记中断”的工作，就是将底半部处理程序挂到该设备的底半部处理队列中去，中断处理机制如下图：
2、中断编程
2.1 申请和释放中断
（1） 申请irq
|
1
|
int
request_irq
(
unsigned
int
irq
,
irq_handler_t
handler
,
unsigned
long
irqflags
,
const
char
*
devname
,
void
*
dev_id
)
|
irq 是要申请的中断号，handler是向系统登记的中断处理函数，irq_flags是中断处理的属性，可以指定中断的触发方式机处理方式，在处理方式方面，IRQF_DISABLED，表明中断处理程序是快速处理程序，快速处理程序被调用时屏蔽所有中断，IRQF_SHARED，表示多个设备共享中断（中断处理程序）。dev_id 在中断共享时会用到，一般设置为这个设备的结构体或者NULL.
（2） 释放irq
|
1
|
void
free_irq
(
unsigned
int
irq
,
void
*
dev_id
)
;
参数定义与
request_irq
(
)相同
|
2.2、使能屏蔽中断
(1) 屏蔽(3个)
void disable_irq (int irq);
void disable_irq_nosync (ing irq);//立即返回
void enable_irq (int irq);
void disable_irq_nosync(int irq)与void disable_irq(int irg)的区别是前者立即返回，后者等待目前中断处理完。
(2) 屏蔽所有中断
#define local_irq_save (flags)//屏蔽本cpu所有
void local_irq_disable (void) //屏蔽本cpu所有中断
前者会保留中断状态保存在flags中（flags为unsigned long类型）。
(3） 恢复中断
#define local_irq_restore (flags)
void local_irq_enable (void);
以local开头的方法作用范围是本cpu内。
2.3 底半部机制–实现机制主要有tasklet, 工作队列和软中断
（1） tasklet
|
1
2
3
4
5
|
void
my_tasklet_func
(
unsigned
long
)
;
DECLARE_TASKLET
(
my_tasklet
,
my_tasklet_func
,
data
)
;
/*定义一个tasklet结构my_tasklet, 与my_tasklet_func(data)函数相关联*/
tasklet_schedule
(
&
my_tasklet
)
;
/*使系统在适当的时候调度tasklet注册的函数*/
|
（2）工作队列
|
1
2
3
4
5
|
struct
work_struct
my_wq
;
void
my_wq_func
(
unsigned
long
)
;
INIT_WORK
(
&
my_wq
,
(
void
(
*
)
(
void
*
)
my_wq_func
,
NULL
)
;
／＊初始化工作队列并将其与处理函数绑定＊／
schedule_work
(
&
my_wq
)
;
/*调度工作队列执行*/
|
(3) 软中断（与通常说的软中断（软件指令引发的中断），比如arm的swi是完全不同的概念）
在linux内核中，用softirq_action结构体表征一个软中断，这个结构体包含软中断处理函数指针和传递给函数的参数。使用open_softirq()函数可以注册软中断对应的处理函数，而raise_softirq()函数可以触发一个软中断。软中断和tasklet 运行与软中断上下文，仍属于原子上下文的一种，而工作队列则运行与进程上下文。因此，软中断和tasklet处理函数中不能睡眠，而工作队列处理函数中允许睡眠。local_bh_disable() 和 local_bh_enable()是内核中用于禁止和使能软中断和tasklet底半部机制的函数。
2.4 中断共享
多个设备共享一根中断线的情况在硬件系统中广泛存在，共享中断的多个设备在申请中断时，都应该使用IRQF_SHARED标志，而且一个设备以IRQF_SHARED标志申请中断成功的前提是该中断未被申请或该中断虽然被申请了，但它之前申请该中断的设备都以IRQF_SHARED标志申请中断，尽管内核模块可以访问全局地址都可以作为request_irq(…,void *dev_id)的最后一个参数，但是社结构体被指针显然是可传入的最佳参数.
在中端到来时，会遍历共享此中断的所有中断处理程序，在中断处理程序顶半部中，应该根据硬件寄存器中的信息比照传入的dev_id参数判断是不是本设备的中断
共享中断模块
|
1
2
3
4
5
6
7
8
9
10
11
|
irqreturn_t
xxx_interrupt
(
int
irq
,
void
*
dev_id
,
struct
pt_regs
*
regs
)
{
.
.
.
int
status
=
read_int_status
(
)
;
//获知中断源
if
(
!
is_myint
(
dev_id
,
status
)
)
//判断是否为本设备
return
IRQ_NONE
;
//不是本设备中断立即返回
//是本设备中断进行处理
.
.
.
return
IRQ_HANDLED
;
//返回IRQ_HANDLED说明中断已被处理
}
.
.
.
|
二、定时器/时钟
1、概述
软件意义上的定时器最终依赖硬件定时器来实现，内核在时钟中断发生后检测个定时器释放到期，到期后的定时器处理函数将作为软中断底半部执行。驱动编程中，可以利用一组函数和数据结构来完成定时器触发工作或者某些周期性任务。
（1) 一个timer_list 结构体的实例对应一个定时器，其定义如下：
|
1
2
3
4
5
6
7
8
|
struct
timer_list
{
struct
list_head
entry
,
/*定时器列表*/
unsigned
long
expires
,
/*定时器到期时间*/
void
(
*
function
)
(
unsigned
long
)
,
/*定时器处理函数*/
unsigned
long
data
,
/*作为参数被传入定时器处理函数*/
struct
timer_base_s
*
base
,
.
.
.
}
;
|
如定义一个名为my_timer 的定时器：
|
1
|
struct
timer_list
my_timer
;
|
(2) 初始化定时器
|
1
2
3
4
|
void
init_timer
(
struct
timer_list
*
timer
)
;
TIMER_INITIALIZER
(
_function
,
_expires
,
_data
)
DEFINE_TIMER
(
_name
,
_function
,
_expires
,
_data
)
setup_timer
(
)
;
|
(3) 增加定时器
|
1
|
void
add_timer
(
struct
timer_list
*
timer
)
;
|
(4) 删除定时器
|
1
|
int
del_timer
(
struct
timer_list
*
timer
)
;
|
(5) 修改定时器的expire
|
1
|
int
mod_timer
(
struct
timer_list
*
timer
,
unsigned
long
expires
)
;
|
(6) 对于周期性的任务，linux内核还提供了一种delayed_work机制来完成，本质上用工作队列和定时器实现。
6.1,内核延时
linux内核中提供了如下3个函数分别进行纳秒，微妙和毫秒延时
|
1
2
3
|
void
ndelay
(
unsigned
long
nsecs
)
;
void
udelay
(
unsigned
long
usecs
)
;
void
mdelay
(
unsigned
long
msecs
)
;
|
上述延时实现的原理实质上是忙等待，毫秒延时比较cpu耗资源，对于毫秒级以上时延，内核提供了如下函数
|
1
2
3
|
void
msleep
(
unsigned
int
millisecs
)
;
unsigned
long
msleep_interruptible
(
unsigned
int
millisecs
)
;
void
ssleep
(
unsigned
int
seconds
)
;
|
上述函数将使得调用它的进程，睡眠参数指定的时间，unsigned long msleep_interruptible（）可以被信号打断，另两个不行
6.2、睡着延迟
睡着延迟在等待的时间到来之间进程处于睡眠状态，schedule_timeout()可以使当前任务睡眠指定的jiffies之后重新被调度，msleep（）和msleep_interruptible()就包含了schedule_timeout()实质上schedule_timeout()的实现原理是向系统添加一个定时器，在定时器处理函数中唤醒参数对应的进程，其中结合了sleep_on()和__set_current_state(TASK_INTERRUPTIBLE)等函数。
2、内核定时器使用模板
|
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
|
//设备结构体
struct
xxx_dev
{
struct
cdev
cdev
;
.
.
.
struct
timer_list
xxx_timer
;
//定义定时器
}
//驱动中某函数
xxx_funcl
(
.
.
.
)
{
struct
xxx_dev
*
dev
=
filp
->
private_data
;
.
.
.
//初始化定时器
init_timer
(
&
dev
->
xxx_time
)
;
dev
->
xxx_timer
.
function
=
&
xxx_do_timer
;
//定义定时器处理函数
dev
->
xxx_timer
.
data
=
(
unsigned
long
)
dev
;
//设备结构体指针作为定时器处理参数
dev
->
xxx_timer
.
expires
=
jiffies
+
delay
;
//定义到期时间
add_timer
(
&
dev
->
xxx_timer
)
;
//注册定时器
.
.
.
}
//驱动中某函数
xxx_func2
(
.
.
.
)
{
.
.
.
//删除中断
del_timer
(
&
dev
->
xxx_timer
)
;
.
.
.
}
//定时器处理函数
static
void
xxx_do_timer
(
unsigned
long
arg
)
{
struct
xxx_dev
*
dev
=
filp
->
private_data
;
.
.
.
dev
->
xxx_timer
.
expires
=
jiffies
+
delay
;
//重新设置定时时间
add_timer
(
&
dev
->
xxx_timer
)
;
.
.
.
}
|
HZ表示延时1s
3、实例–秒字符设备second_drv.c ，它在被打开时将初始化的定时器加到内核定时器链表中，每秒输出一次当前的jiffes,代码如下：
|
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
|
#include <linux/module.h>
#include <linux/types.h>
#include <linux/fs.h>
#include <linux/errno.h>
#include <linux/mm.h>
#include <linux/sched.h>
#include <linux/init.h>
#include <linux/cdev.h>
#include <asm/io.h>
#include <asm/system.h>
#include <asm/uaccess.h>
#include <linux/slab.h>
#define SECOND_MAJOR 248
static
int
second_major
=
SECOND_MAJOR
;
struct
second_dev
{
struct
cdev
cdev
;
atomic_t
counter
;
struct
timer_list
s_timer
;
}
;
struct
second_dev
*
second_devp
;
static
void
second_timer_handle
(
unsigned
long
arg
)
{
mod_timer
(
&
second_devp
->
s_timer
,
jiffies
+
HZ
)
;
atomic_inc
(
&
second_devp
->
counter
)
;
printk
(
KERN
_NOTICE
"current jiffies is %ld\n"
,
jiffies
)
;
}
int
second_open
(
struct
inode
*
inode
,
struct
file
*
filp
)
{
init_timer
(
&
second_devp
->
s_timer
)
;
second_devp
->
s_timer
.
function
=
&
second_timer_handle
;
second_devp
->
s_timer
.
expires
=
jiffies
+
HZ
;
add_timer
(
&
second_devp
->
s_timer
)
;
atomic_set
(
&
second_devp
->
counter
,
0
)
;
return
0
;
}
int
second_release
(
struct
inode
*
inode
,
struct
file
*
filp
)
{
del_timer
(
&
second_devp
->
s_timer
)
;
return
0
;
}
static
ssize_t
second_read
(
struct
file
*
filp
,
char
__user
*
buf
,
size_t
count
,
loff_t
*
ppos
)
{
int
counter
;
counter
=
atomic_read
(
&
second_devp
->
counter
)
;
if
(
put_user
(
counter
,
(
int
*
)
buf
)
)
return
-
EFAULT
;
else
return
sizeof
(
unsigned
int
)
;
}
static
const
struct
file_operations
second_fops
=
{
.
owner
=
THIS_MODULE
,
.
open
=
second_open
,
.
release
=
second_release
,
.
read
=
second_read
,
}
;
static
void
second_setup_cdev
(
struct
second_dev
*
dev
,
int
index
)
{
int
err
,
devno
=
MKDEV
(
second_major
,
index
)
;
cdev_init
(
&
dev
->
cdev
,
&
second_fops
)
;
dev
->
cdev
.
owner
=
THIS_MODULE
;
err
=
cdev_add
(
&
dev
->
cdev
,
devno
,
1
)
;
if
(
err
)
printk
(
KERN
_NOTICE
"Error %d adding CDEV %d"
,
err
,
index
)
;
}
int
second_init
(
void
)
{
int
ret
;
dev_t
devno
=
MKDEV
(
second_major
,
0
)
;
if
(
second_major
)
ret
=
register_chrdev_region
(
devno
,
1
,
"second"
)
;
else
{
return
alloc_chrdev_region
(
&
devno
,
0
,
1
,
"second"
)
;
second_major
=
MAJOR
(
devno
)
;
}
if
(
ret
<
0
)
return
ret
;
second_devp
=
kmalloc
(
sizeof
(
struct
second_dev
)
,
GFP_KERNEL
)
;
if
(
!
second_devp
)
{
ret
=
-
ENOMEM
;
goto
fail_malloc
;
}
memset
(
second_devp
,
0
,
sizeof
(
struct
second_dev
)
)
;
second_setup_cdev
(
second_devp
,
0
)
;
return
0
;
fail_malloc
:
unregister_chrdev_region
(
devno
,
1
)
;
return
ret
;
}
void
second_exit
(
void
)
{
cdev_del
(
&
second_devp
->
cdev
)
;
kfree
(
second_devp
)
;
unregister_chrdev_region
(
MKDEV
(
second_major
,
0
)
,
1
)
;
}
MODULE_AUTHOR
(
"Ljia-----Ljia"
)
;
MODULE_LICENSE
(
"Dual BSD/GPL"
)
;
module_param
(
second_major
,
int
,
S_IRUGO
)
;
module_init
(
second_init
)
;
module_exit
(
second_exit
)
;
|
在second的open()函数中，将启动定时器，此后每秒会再次运行定时器处理函数，且在release()函数中删除，编译驱动，加载并创建“/dev/second”设备文件节点之后，用以下程序打开，second_test会不断读取来自“/dev/second”设备文件以来经历的秒数。
|
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
|
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
int
main
(
void
)
{
int
fd
;
int
counter
=
0
;
int
old_counter
=
0
;
fd
=
open
(
"/dev/second"
,
O_RDONLY
)
;
if
(
fd
!=
-
1
)
{
while
(
1
)
{
read
(
fd
,
&
counter
,
sizeof
(
unsigned
int
)
)
;
if
(
counter
!=
old_counter
)
{
printf
(
"seconds after open /dev/second: %d\n"
,
counter
)
;
old_counter
=
counter
;
}
}
}
else
{
printf
(
"Device open failure\n"
)
;
}
return
0
;
}
|
运行second_test后，不断输出jiffes的值，如下
|
1
2
3
4
5
6
7
8
9
10
11
12
|
current
jiffes
is
17216
current
jiffes
is
17316
current
jiffes
is
17416
current
jiffes
is
17516
current
jiffes
is
17616
current
jiffes
is
17716
current
jiffes
is
17816
current
jiffes
is
17916
current
jiffes
is
17016
current
jiffes
is
17116
current
jiffes
is
17216
current
jiffes
is
17316
|
而应用程序将不断输出来自打开的“/dev/second”如下：
|
1
2
3
4
5
6
7
8
9
10
|
seconds
after
open
/
dev
/
second
:
1
seconds
after
open
/
dev
/
second
:
2
seconds
after
open
/
dev
/
second
:
3
seconds
after
open
/
dev
/
second
:
4
seconds
after
open
/
dev
/
second
:
5
seconds
after
open
/
dev
/
second
:
6
seconds
after
open
/
dev
/
second
:
7
seconds
after
open
/
dev
/
second
:
8
seconds
after
open
/
dev
/
second
:
9
seconds
after
open
/
dev
/
second
:
10
|
三、总结
Linux中断处理分为两个半部，上述都讲得很清楚了，这里强调以下，为了充分利用CPU资源，在对延时使用不是很精确的情况下，睡眠等待值得推荐。对于上述的几个例子，需要大家自己在Linux的操作中敲出来，并且编译，看输出的结果才能完全理解~
更多推荐
0
0- 0
已为社区贡献4条内容
所有评论(0)