Linux中断实验
7 H8 J. @0 z* O7 r0 @; W. s4 k不管是单片机裸机实验还是Linux下的驱动实验，中断都是频繁使用的功能，在裸机中使用中断我们需要做一大堆的工作，比如配置寄存器，使能IRQ等等。但是Linux内核提供了完善的中断框架，我们只需要申请中断，然后注册中断处理函数即可，使用非常方便，不需要一系列复杂的寄存器配置。本章我们就来学习一下如何在Linux下使用中断。
) S! R, ^- r5 t) M5 O
* l& N8 z1 O. J) }0 A1 r& Q31.1 Linux中断简介
31.1.1 Linux中断API函数
先来回顾一下裸机实验里面中断的处理方法：
①、使能中断，初始化相应的寄存器。
②、注册中断服务函数，也就是向irqTable数组的指定标号处写入中断服务函数
②、中断发生以后进入IRQ中断服务函数，在IRQ中断服务函数在数组irqTable里面查找具体的中断处理函数，找到以后执行相应的中断处理函数。
% P! }8 o# ~+ l$ ]* s" a在Linux内核中也提供了大量的中断相关的API函数，我们来看一下这些跟中断有关的API函数：
1、中断号
每个中断都有一个中断号，通过中断号即可区分不同的中断，有的资料也把中断号叫做中断线。在Linux内核中使用一个int变量表示中断号，关于中断号我们已经在第十七章讲解过了。
2、request_irq函数
在Linux内核中要想使用某个中断是需要申请的，request_irq函数用于申请中断，request_irq函数可能会导致睡眠，因此不能在中断上下文或者其他禁止睡眠的代码段中使用request_irq函数。request_irq函数会激活(使能)中断，所以不需要我们手动去使能中断，request_irq函数原型如下：
int request_irq(unsigned int irq,
. r' h3 |* B$ P! P5 L6 h+ {irq_handler_t handler,
unsigned long flags,
const char *name,
void *dev)
4 [0 `9 _$ O) D5 y1 W3 i函数参数和返回值含义如下：
2 [. G1 X$ Z7 f% Z; {/ G1 xirq：要申请中断的中断号。
handler：中断处理函数，当中断发生以后就会执行此中断处理函数。
9 i  H2 J/ ^3 V# }flags：中断标志，可以在文件include/linux/interrupt.h里面查看所有的中断标志，这里我们介绍几个常用的中断标志，如表31.1.1.1所示：
6 y3 w2 [: \2 r+ K% k! V


表31.1.1.1 常用的中断标志
比如STM32MP157开发板上的KEY0使用PG3，按下KEY0以后为低电平，因此可以设置为下降沿触发，也就是将flags设置为IRQF_TRIGGER_FALLING。表31.1.1.1中的这些标志可以通过“|”来实现多种组合。
name：中断名字，设置以后可以在/proc/interrupts文件中看到对应的中断名字。
% V' S0 p5 M' i/ I, D5 X. idev：如果将flags设置为IRQF_SHARED的话，dev用来区分不同的中断，一般情况下将dev设置为设备结构体，dev会传递给中断处理函数irq_handler_t的第二个参数。
, y0 H# A4 B" I4 H; w返回值：0 中断申请成功，其他负值 中断申请失败，如果返回-EBUSY的话表示中断已经被申请了。
* T! h& n% G' b) F# O# ~  w: j3、free_irq函数
使用中断的时候需要通过request_irq函数申请，使用完成以后就要通过free_irq函数释放掉相应的中断。如果中断不是共享的，那么free_irq会删除中断处理函数并且禁止中断。free_irq函数原型如下所示：
void free_irq(unsigned int irq,
void *dev)
" I: M# x' J8 h4 v% I3 j- |$ a函数参数和返回值含义如下：
) @, i$ @' w1 C; U9 virq：要释放的中断。
dev：如果中断设置为共享(IRQF_SHARED)的话，此参数用来区分具体的中断。共享中断只有在释放最后中断处理函数的时候才会被禁止掉。
9 O, W$ H. `2 p返回值：无。
4、中断处理函数
使用request_irq函数申请中断的时候需要设置中断处理函数，中断处理函数格式如下所示：
irqreturn_t (*irq_handler_t) (int, void *)
第一个参数是要中断处理函数要相应的中断号。第二个参数是一个指向void的指针，也就是个通用指针，需要与request_irq函数的dev参数保持一致。用于区分共享中断的不同设备，dev也可以指向设备数据结构。中断处理函数的返回值为irqreturn_t类型，irqreturn_t类型定义如下所示：

1. 示例代码31.1.1.1 irqreturn_t结构
   
2. 1 enum irqreturn {
   - d4 f9 x) f' J
3. 2          IRQ_NONE                = (0 << 0),
   
4. 3          IRQ_HANDLED             = (1 << 0),
   
5. 4          IRQ_WAKE_THREAD          = (1 << 1),
   
6. 5 };
   3 p5 I  K  V: s
7. 6
   
8. 7 typedef enum irqreturn irqreturn_t;

复制代码

可以看出irqreturn_t是个枚举类型，一共有三种返回值。一般中断服务函数返回值使用如下形式：
' T. ~  _, F) m6 k
' l  h) p8 X) Kreturn IRQ_RETVAL(IRQ_HANDLED)
5、中断使能与禁止函数
' }& |. ]/ o% P1 c1 Q$ X2 m! s* D常用的中断使用和禁止函数如下所示：
void enable_irq(unsigned int irq)
void disable_irq(unsigned int irq)
enable_irq和disable_irq用于使能和禁止指定的中断，irq就是要禁止的中断号。disable_irq函数要等到当前正在执行的中断处理函数执行完才返回，因此使用者需要保证不会产生新的中断，并且确保所有已经开始执行的中断处理程序已经全部退出。在这种情况下，可以使用另外一个中断禁止函数：
void disable_irq_nosync(unsigned int irq)
disable_irq_nosync函数调用以后立即返回，不会等待当前中断处理程序执行完毕。上面三个函数都是使能或者禁止某一个中断，有时候我们需要关闭当前处理器的整个中断系统，也就是在学习STM32的时候常说的关闭全局中断，这个时候可以使用如下两个函数：
2 U( Z* P5 v! `local_irq_enable()
local_irq_disable()
9 G* p# W1 j4 b( v: plocal_irq_enable用于使能当前处理器中断系统，local_irq_disable用于禁止当前处理器中断系统。假如A任务调用local_irq_disable关闭全局中断10S，当关闭了2S的时候B任务开始运行，B任务也调用local_irq_disable关闭全局中断3S，3秒以后B任务调用local_irq_enable函数将全局中断打开了。此时才过去2+3=5秒的时间，然后全局中断就被打开了，此时A任务要关闭10S全局中断的愿望就破灭了，然后A任务就“生气了”，结果很严重，可能系统都要被A任务整崩溃。为了解决这个问题，B任务不能直接简单粗暴的通过local_irq_enable函数来打开全局中断，而是将中断状态恢复到以前的状态，要考虑到别的任务的感受，此时就要用到下面两个函数：
: g: L1 T* Y5 a$ Ulocal_irq_save(flags)
( E* N% t- n) ^5 E* A2 o+ @+ E" Z  Mlocal_irq_restore(flags)
# r& O4 G3 L6 A# {! X这两个函数是一对，local_irq_save函数用于禁止中断，并且将中断状态保存在flags中。local_irq_restore用于恢复中断，将中断到flags状态。
( d! H, ?3 ]- W' h' {5 f, \31.1.2 上半部与下半部
在有些资料中也将上半部和下半部称为顶半部和底半部，都是一个意思。我们在使用request_irq申请中断的时候注册的中断服务函数属于中断处理的上半部，只要中断触发，那么中断处理函数就会执行。我们都知道中断处理函数一定要快点执行完毕，越短越好，但是现实往往是残酷的，有些中断处理过程就是比较费时间，我们必须要对其进行处理，缩小中断处理函数的执行时间。比如电容触摸屏通过中断通知SOC有触摸事件发生，SOC响应中断，然后通过IIC接口读取触摸坐标值并将其上报给系统。但是我们都知道IIC的速度最高也只有400Kbit/S，所以在中断中通过IIC读取数据就会浪费时间。我们可以将通过IIC读取触摸数据的操作暂后执行，中断处理函数仅仅相应中断，然后清除中断标志位即可。这个时候中断处理过程就分为了两部分：
上半部：上半部就是中断处理函数，那些处理过程比较快，不会占用很长时间的处理就可以放在上半部完成。
下半部：如果中断处理过程比较耗时，那么就将这些比较耗时的代码提出来，交给下半部去执行，这样中断处理函数就会快进快出。
6 L4 ~1 |- e3 G8 P9 n: J因此，Linux内核将中断分为上半部和下半部的主要目的就是实现中断处理函数的快进快出，那些对时间敏感、执行速度快的操作可以放到中断处理函数中，也就是上半部。剩下的所有工作都可以放到下半部去执行，比如在上半部将数据拷贝到内存中，关于数据的具体处理就可以放到下半部去执行。至于哪些代码属于上半部，哪些代码属于下半部并没有明确的规定，一切根据实际使用情况去判断，这个就很考验驱动编写人员的功底了。这里有一些可以借鉴的参考点：
, n/ ]$ J4 e) M9 L0 L①、如果要处理的内容不希望被其他中断打断，那么可以放到上半部。
②、如果要处理的任务对时间敏感，可以放到上半部。
③、如果要处理的任务与硬件有关，可以放到上半部
④、除了上述三点以外的其他任务，优先考虑放到下半部。
上半部处理很简单，直接编写中断处理函数就行了，关键是下半部该怎么做呢？Linux内核提供了多种下半部机制，接下来我们来学习一下这些下半部机制。
0 i- W: B7 F  q8 i5 W" W% E1、软中断
# U5 K! _' d1 Y4 B一开始Linux内核提供了“bottom half”机制来实现下半部，简称“BH”。后面引入了软中断和tasklet来替代“BH”机制，完全可以使用软中断和tasklet来替代BH，从2.5版本的Linux内核开始BH已经被抛弃了。Linux内核使用结构体softirq_action表示软中断， softirq_action结构体定义在文件include/linux/interrupt.h中，内容如下：

1. 示例代码31.1.2.1 softirq_action结构体
   0 T! j7 @) g8 M! b& {
2. 541 struct softirq_action
   
3. 542 {
   
4. 543     void    (*action)(struct softirq_action *);
   
5. 544 };

复制代码

" c4 W4 {/ s' x* l! n% A, H9 Z在kernel/softirq.c文件中一共定义了10个软中断，如下所示：
- {8 P' K9 V: X, ]% ~: v& G
, j1 Z, F9 X: [5 \2 {示例代码31.1.2.2 softirq_vec数组
2 {$ @. q2 w% q5 h% H. d+ M9 }9 zstatic struct softirq_action softirq_vec[NR_SOFTIRQS];
NR_SOFTIRQS是枚举类型，定义在文件include/linux/interrupt.h中，定义如下：

1. 示例代码31.1.2.3 softirq_vec数组
   
2. enum
   5 E2 U5 H+ q6 ]
3. {
   % v" A4 [- X6 {4 G# r6 M! P( O
4.     HI_SOFTIRQ=0,                   /* 高优先级软中断                 */
   
5.     TIMER_SOFTIRQ,                  /* 定时器软中断                         */
   
6.     NET_TX_SOFTIRQ,                 /* 网络数据发送软中断         */
   5 J6 z5 S8 J* `
7.     NET_RX_SOFTIRQ,                 /* 网络数据接收软中断         */
   4 p. i3 P% C" a2 o* ?4 m1 r) w7 ^
8.     BLOCK_SOFTIRQ,         
   
9.     IRQ_POLL_SOFTIRQ,   
   
10.     TASKLET_SOFTIRQ,                /* tasklet软中断                 */
    
11.     SCHED_SOFTIRQ,                  /* 调度软中断                         */
    * A# l, d$ Q7 F6 `7 j
12.     HRTIMER_SOFTIRQ,                /* 高精度定时器软中断        */
    
13.     RCU_SOFTIRQ,                    /* RCU软中断                        */
    4 r7 B! R6 y2 V' P% m0 c4 k- g4 S& `
14. 
    
15.     NR_SOFTIRQS
    9 U1 H5 l; i. Q. T9 I  Y5 J  b% p
16. };
    

复制代码

可以看出，一共有10个软中断，因此NR_SOFTIRQS为10，因此数组softirq_vec有10个元素。softirq_action结构体中的action成员变量就是软中断的服务函数，数组softirq_vec是个全局数组，因此所有的CPU(对于SMP系统而言)都可以访问到，每个CPU都有自己的触发和控制机制，并且只执行自己所触发的软中断。但是各个CPU所执行的软中断服务函数确是相同的，都是数组softirq_vec中定义的action函数。要使用软中断，必须先使用open_softirq函数注册对应的软中断处理函数，open_softirq函数原型如下：

" G$ ]5 u0 m2 _9 @: `8 Q6 ]void open_softirq(int nr, void (*action)(struct softirq_action *))
函数参数和返回值含义如下：
nr：要开启的软中断，在示例代码31.1.2.3中选择要开启的软中断。
, n/ b( M* j% Gaction：软中断对应的处理函数。
返回值：没有返回值。
( U/ j' }0 _1 m' j- t注册好软中断以后需要通过raise_softirq函数触发，raise_softirq函数原型如下：
void raise_softirq(unsigned int nr)
- _9 o" _/ `) P函数参数和返回值含义如下：
nr：要触发的软中断，在示例代码31.1.2.3中选择要注册的软中断。
返回值：没有返回值。
软中断必须在编译的时候静态注册！Linux内核使用softirq_init函数初始化软中断，softirq_init函数定义在kernel/softirq.c文件里面，函数内容如下：

1. 示例代码31.1.2.4 softirq_init函数内容
   
2. 575 void __init softirq_init(void)
   % {& C- i% e0 ?& C/ F2 {
3. 576 {
   
4. 577     int cpu;
   
5. 578
   
6. 579     for_each_possible_cpu(cpu) {
   
7. 580         per_cpu(tasklet_vec, cpu).tail =
   2 T! q! ^) v: n4 k( l6 j! o( A
8. 581             &per_cpu(tasklet_vec, cpu).head;
   
9. 582         per_cpu(tasklet_hi_vec, cpu).tail =
   
10. 583             &per_cpu(tasklet_hi_vec, cpu).head;
    
11. 584     }
    & d# o7 Z) Y6 c2 Z* Y2 x
12. 585
    
13. 586     open_softirq(TASKLET_SOFTIRQ, tasklet_action);
    3 P$ Z3 p: p% T. ^$ s& C! z& q
14. 587     open_softirq(HI_SOFTIRQ, tasklet_hi_action);
    ; q5 a& x0 j: G" A2 F& ^: z' d+ b
15. 588 }

复制代码

从示例代码31.1.2.4可以看出，softirq_init函数默认会打开TASKLET_SOFTIRQ和HI_SOFTIRQ。
2、tasklet
tasklet是利用软中断来实现的另外一种下半部机制，在软中断和tasklet之间，建议大家使用tasklet。tasklet_struct结构体如下所示：
& g8 Z6 Y. @. R) s, ?: M

1. 示例代码31.1.2.5 tasklet_struct结构体
   , `3 X4 R* ]& i) C# v* F
2. 592 struct tasklet_struct
   
3. 593 {
   
4. 594     struct tasklet_struct *next;    /* 下一个tasklet                         */
   
5. 595     unsigned long state;                    /* tasklet状态                            */
   8 S6 U# p7 }% C3 T) Z! ]3 F9 t) R) L
6. 596     atomic_t count;                         /* 计数器，记录对tasklet的引用数 */
   ! E* T( o8 W+ }
7. 597     void (*func)(unsigned long);           /* tasklet执行的函数                 */
   2 D# y0 u: T* L' `! C
8. 598     unsigned long data;                     /* 函数func的参数                         */
   1 W; L" q& M9 L8 f7 B% F# q, _0 n
9. 599 };

复制代码

7 M& x% ^/ Z7 ^% r* K第597行的func函数就是tasklet要执行的处理函数，用户实现具体的函数内容，相当于中断处理函数。如果要使用tasklet，必须先定义一个tasklet_struct变量，然后使用tasklet_init函数对其进行初始化，taskled_init函数原型如下：
  w( `0 q6 K3 X5 Svoid tasklet_init(struct tasklet_struct *t,
9 q2 ], j5 O1 d" l& X8 y! b/ n$ ?void (*func)(unsigned long),
8 {/ M1 _1 k6 m: s; Vunsigned long data);
函数参数和返回值含义如下：
t：要初始化的tasklet
9 P; J+ C8 t/ G: E; ufunc：tasklet的处理函数。
, o2 R# ~) y0 q2 {2 Qdata：要传递给func函数的参数
返回值：没有返回值。
7 a4 \, X3 t% F- {也可以使用宏DECLARE_TASKLET来一次性完成tasklet的定义和初始化， DECLARE_TASKLET定义在include/linux/interrupt.h文件中，定义如下:
  o6 ?$ `( Y7 a# G" _* qDECLARE_TASKLET(name, func, data)
其中name为要定义的tasklet名字，其实就是tasklet_struct类型的变量名，func就是tasklet的处理函数，data是传递给func函数的参数。
在上半部，也就是中断处理函数中调用tasklet_schedule函数就能使tasklet在合适的时间运行，tasklet_schedule函数原型如下：
: W2 p0 q- B( @& p( v5 h6 {void tasklet_schedule(struct tasklet_struct *t)
函数参数和返回值含义如下：
t：要调度的tasklet，也就是DECLARE_TASKLET宏里面的name。
返回值：没有返回值。
关于tasklet的参考使用示例如下所示：
1 z# c; T2 N# U% F+ d% P$ d" N
+ _& c4 P' @9 [  E) B# V4 T1 u

1. 示例代码31.1.2.7 tasklet使用示例
   
2. /* 定义taselet                         */
   
3. struct tasklet_struct testtasklet;
   : H" ~' T7 v0 b; B' d
4. 
   7 m( R: \  N, E. w! O$ O% C2 A
5. /* tasklet处理函数                 */
   
6. void testtasklet_func(unsigned long data)
   
7. {
   9 v& Y+ b8 r, b, k4 z# x# V
8.     /* tasklet具体处理内容 */
   1 q: `/ S8 n8 l/ R7 @# Q
9. }
   # c9 C6 w3 S( i5 |6 P
10. 
    ) K2 j, |8 m4 O$ t5 v, d
11. /* 中断处理函数 */
    
12. irqreturn_t test_handler(int irq, void *dev_id)
    
13. {
    
14.     ......
    
15.     /* 调度tasklet                 */
    
16.     tasklet_schedule(&testtasklet);
    6 B5 @9 P0 v# K
17.     ......
    5 j1 O) B) ~1 Z8 E- D! X
18. }
    5 N) I9 e/ x! K2 n. Q$ T
19. 
    1 _! v( L" _/ k- [' ?1 w- @
20. /* 驱动入口函数                                 */
    
21. static int __init xxxx_init(void)
    
22. {
    
23.     ......
    6 c' u0 z) C5 J8 f% V' {
24.     /* 初始化tasklet                 */
    
25.     tasklet_init(&testtasklet, testtasklet_func, data);
    
26.     /* 注册中断处理函数                 */
    0 v) g+ @/ ]# V  Q5 I5 w* @
27.     request_irq(xxx_irq, test_handler, 0, "xxx", &xxx_dev);
    - {! B) o* Z& O; K
28.     ......
    
29. }
    

复制代码

# A+ E! ]  H7 }. }& z4 H3 c0 o2、工作队列
工作队列是另外一种下半部执行方式，工作队列在进程上下文执行，工作队列将要推后的工作交给一个内核线程去执行，因为工作队列工作在进程上下文，因此工作队列允许睡眠或重新调度。因此如果你要推后的工作可以睡眠那么就可以选择工作队列，否则的话就只能选择软中断或tasklet。
2 x" z" r1 Z) r/ R: K1 y0 @, WLinux内核使用work_struct结构体表示一个工作，内容如下(省略掉条件编译)：
! c; r/ M4 V1 c6 ?  r3 R" C( l

1. 示例代码31.1.2.8 work_struct结构体
   
2. struct work_struct {
   
3.     atomic_long_t data;   
   
4.     struct list_head entry;
   
5.     work_func_t func;               /* 工作队列处理函数         */
   ! h4 J8 ?9 U, C' X7 \
6. };

复制代码

这些工作组织成工作队列，工作队列使用workqueue_struct结构体表示，内容如下(省略掉条件编译)：

. @7 Q0 y& ?  q* B$ h+ ?, \* y. \

1. 示例代码31.1.2.9 workqueue_struct结构体
   
2. struct workqueue_struct {
   
3.     struct list_head            pwqs;      
   
4.     struct list_head            list;      
   
5.     struct mutex                mutex;      
   
6.     int                                         work_color;
   0 L! K. N( Q5 f1 k+ o3 \
7.     int                                         flush_color;   
   
8.     atomic_t                        nr_pwqs_to_flush;
   
9.     struct wq_flusher           *first_flusher;
   ; p! a: O6 F0 o2 U4 G* L6 b
10.     struct list_head            flusher_queue;  
    : ]! p$ o/ g! q/ Z- ]! B8 u% S3 I  D
11.     struct list_head            flusher_overflow;
    ' |! D0 t# l- H' B
12.     struct list_head            maydays;   
    % K. \- L5 K5 q
13.     struct worker               *rescuer;   
    
14.     int                                         nr_drainers;   
    " f5 l- ]& i3 ~
15.     int                                         saved_max_active;
    
16.     struct workqueue_attrs  *unbound_attrs;
    # T+ L3 f4 |3 m* c, Y, X9 S( T
17.     struct pool_workqueue   *dfl_pwq;   
    
18.     char                                    name[WQ_NAME_LEN];
    
19.     struct rcu_head             rcu;
    % K) k* O- \$ z3 G- x4 O+ v. f' U
20.     unsigned int                flags ____cacheline_aligned;
    
21.     struct pool_workqueue __percpu *cpu_pwqs;
    
22.     struct pool_workqueue __rcu *numa_pwq_tbl[];
    " _/ z. d8 A* u: I
23. };

复制代码

Linux内核使用工作者线程(worker thread)来处理工作队列中的各个工作，Linux内核使用worker结构体表示工作者线程，worker结构体内容如下：
4 C' f1 @2 X+ P# k) ~' p2 H% q$ j6 |
- S8 N( [0 A" M, R5 W8 z; B  V

1. 示例代码31.1.2.10 worker结构体
   $ c3 J7 d6 ^/ d! T0 V8 R
2. struct worker {
   
3.     union {
   6 A# x3 F% b1 Y" [0 _
4.         struct list_head            entry;  
   5 u$ y; `( v0 O& W1 ]
5.         struct hlist_node           hentry;
   
6.     };
   
7. 
   " h7 t5 E. @  ^# g- w; E- s  _
8.     struct work_struct                  *current_work;  
   " P. m! i9 f) b9 J* g
9.     work_func_t                             current_func;   
   . i$ s. O" ~/ F. w! N6 p; N) n- M5 u
10.     struct pool_workqueue           *current_pwq;
    7 k, m8 ]) b- F9 Q& b
11.     struct list_head                    scheduled;  
    
12.     struct task_struct                  *task;      
    
13.     struct worker_pool                  *pool;      
    % F/ t: e, A" h# F; `. e
14.     struct list_head                    node;      
    0 `7 I/ |' U0 K4 g( Q3 {+ a
15.     unsigned long                       last_active;   
    
16.     unsigned int                        flags;      
    
17.     int                                                 id;     
    
18.     int                                                 sleeping;   
    
19.     char                                            desc[WORKER_DESC_LEN];
    # N% {9 r2 t8 T/ D
20.     struct workqueue_struct         *rescue_wq;
    
21.     work_func_t                             last_func;
    # E9 }9 j/ ]5 {+ a
22. };

复制代码

从示例代码31.1.2.10可以看出，每个worker都有一个工作队列，工作者线程处理自己工作队列中的所有工作。在实际的驱动开发中，我们只需要定义工作(work_struct)即可，关于工作队列和工作者线程我们基本不用去管。简单创建工作很简单，直接定义一个work_struct结构体变量即可，然后使用INIT_WORK宏来初始化工作，INIT_WORK宏定义如下：
#define INIT_WORK(_work, _func)
+ }# ?  c- i7 ?/ E' }_work表示要初始化的工作，_func是工作对应的处理函数。
8 n$ i0 Z/ Q( d5 Z  @# L也可以使用DECLARE_WORK宏一次性完成工作的创建和初始化，宏定义如下：
#define DECLARE_WORK(n, f)
# N0 C: r4 M1 p4 E; _  _& ]n表示定义的工作(work_struct)，f表示工作对应的处理函数。
和tasklet一样，工作也是需要调度才能运行的，工作的调度函数为schedule_work，函数原型如下所示：
) ~) S) D8 I7 o0 X/ y$ X  a+ qbool schedule_work(struct work_struct *work)
函数参数和返回值含义如下：
work：要调度的工作。
% i9 R" F1 z7 ^- m% S; k返回值：0 成功，其他值 失败。
关于工作队列的参考使用示例如下所示：
. F6 h5 J. K* j3 h, e* J- @$ `
- m- [, w. l; ]3 k7 I) U" j# r

1. 示例代码31.1.2.11 工作队列使用示例
   
2. /* 定义工作(work)           */
   
3. struct  work_struct testwork;
   
4. 
   
5. /* work处理函数                 */
   
6. void testwork_func_t(struct work_struct *work);
   
7. {
   ! ]- c2 c  g2 _4 S' l9 T! Y- N
8.     /* work具体处理内容         */
   
9. }
   
10. 
    ) V1 v  p) {* D! C
11. /* 中断处理函数                                 */
    * V7 b) f% `) E4 E- [
12. irqreturn_t test_handler(int irq, void *dev_id)
    1 L& L! y+ U- w) q, l& {- f
13. {
    
14.     ......
    
15.     /* 调度work                       */
      s" |4 O( Q( S7 A" C
16.     schedule_work(&testwork);
    
17.     ......
    
18. }
    6 k8 B- K* `& i! q0 F) ^& v6 z7 w" w" n
19. 
    / _: s- g. G# U; y/ U2 y1 n
20. /* 驱动入口函数                   */
    $ v7 r+ W6 }9 w7 ]2 {
21. static int __init xxxx_init(void)
    
22. {
    ' c8 c; L) X! E+ t% c. j3 C& w
23.     ......
    
24.     /* 初始化work                      */
    7 U. B; s6 X1 W6 \6 @
25.     INIT_WORK(&testwork, testwork_func_t);
    " h) n" @/ b/ z& @: ?* b; Y3 ]
26.     /* 注册中断处理函数             */
    
27.     request_irq(xxx_irq, test_handler, 0, "xxx", &xxx_dev);
    - X% G/ w* c2 u* Q$ S' O3 H
28.     ......
    
29. }

复制代码

31.1.3 设备树中断信息节点
8 x# q' w; R0 i, j% r2 p1、GIC中断控制器
STM32MP1有三个与中断有关的控制器：GIC、EXTI和NVIC，其中NVIC是Cortex-M4内核的中断控制器，本教程只讲解Cortex-A7内核，因此就只剩下了GIC和EXTI。首先是GIC，全称为：Generic Interrupt Controller，关于GIC的详细内容可以查看文档《ARM Generic Interrupt Controller(ARM GIC控制器)V2.0》，此文档已经放到了开发板光盘中，路径为：开发板光盘 4、参考资料 ARM Generic Interrupt Controller(ARM GIC控制器)V2.0.pdf。
GIC是ARM公司给Cortex-A/R内核提供的一个中断控制器，类似Cortex-M内核中的NVIC。目前GIC有4个版本:V1V4，V1是最老的版本，已经被废弃了。V2V4目前正在大量的使用。GIC V2是给ARMv7-A架构使用的，比如Cortex-A7、Cortex-A9、Cortex-A15等，V3和V4是给ARMv8-A/R架构使用的，也就是64位芯片使用的。STM32MP1是Cortex-A7内核，因此我们主要讲解GIC V2。GIC V2最多支持8个核。ARM会根据GIC版本的不同研发出不同的IP核，那些半导体厂商直接购买对应的IP核即可，比如ARM针对GIC V2就开发出了GIC400这个中断控制器IP核。当GIC接收到外部中断信号以后就会报给ARM内核，但是ARM内核只提供了四个信号给GIC来汇报中断情况：VFIQ、VIRQ、FIQ和IRQ，他们之间的关系如图31.1.3.1所示：
, g7 R  d- o, @


! c# g0 G- m) S# F4 Z1 v图31.1.3.1 中断示意图
在图31.1.3.1中，GIC接收众多的外部中断，然后对其进行处理，最终就只通过四个信号报给ARM内核，这四个信号的含义如下：
VFIQ:虚拟快速FIQ。
VIRQ:虚拟快速IRQ。
. f: P* B/ S4 C& t, z1 E4 W. s# vFIQ:快速中断IRQ。
IRQ:外部中断IRQ。
VFIQ和VIRQ是针对虚拟化的，我们讨论不虚拟化，剩下的就是FIQ和IRQ了，本教程我们只使用IRQ。所以相当于GIC最终向ARM内核就上报一个IRQ信号。那么GIC是如何完成这个工作的呢？GIC V2的逻辑图如图31.1.3.2所示：


" t4 c2 |; o2 i
图31.1.3.2 GIC V2总体框图
: |% u' i% P* `  x* ]1 y图31.1.3.2中左侧部分就是中断源，中间部分就是GIC控制器，最右侧就是中断控制器向处理器内核发送中断信息。我们重点要看的肯定是中间的GIC部分，GIC将众多的中断源分为分为三类：
①、SPI(Shared Peripheral Interrupt),共享中断，顾名思义，所有Core共享的中断，这个是最常见的，那些外部中断都属于SPI中断(注意！不是SPI总线那个中断) 。比如GPIO中断、串口中断等等，这些中断所有的Core都可以处理，不限定特定Core。
" D& W2 r) X# ~2 R7 I3 R) L②、PPI(Private Peripheral Interrupt)，私有中断，我们说了GIC是支持多核的，每个核肯定有自己独有的中断。这些独有的中断肯定是要指定的核心处理，因此这些中断就叫做私有中断。
7 s1 h  g0 z: v* w5 T③、SGI(Software-generated Interrupt)，软件中断，由软件触发引起的中断，通过向寄存器GICD_SGIR写入数据来触发，系统会使用SGI中断来完成多核之间的通信。
0 r, y  N, G, ?) ]) ^  Q1 i! m& Z2、中断ID
. @6 D! l5 n5 _# u+ `7 R中断源有很多，为了区分这些不同的中断源肯定要给他们分配一个唯一ID，这些ID就是中断ID。每一个CPU最多支持1020个中断ID，中断ID号为ID0~ID1019。这1020个ID包含了PPI、SPI和SGI，那么这三类中断是如何分配这1020个中断ID的呢？这1020个ID分配如下：
. v$ e& W* L' P, {% w  x* SID0~ID15：这16个ID分配给SGI。
ID16~ID31：这16个ID分配给PPI。
ID32~ID1019：这988个ID分配给SPI，像GPIO中断、串口中断等这些外部中断 ，至于具体到某个ID对应哪个中断那就由半导体厂商根据实际情况去定义了。比如STM32MP1系列总共分配了265个中断ID(有很多并未使用，只是保留着)，加上前面属于PPI和SGI的32个ID，STM32MP1的中断源共有256+32=288个，这288个中断ID对应的中断源可以在《STM32MP157参考手册》中找到详细的解释。找到“21.2 GIC Interrupts”小节的“Table 117. STM32MP157 interrupt mapping for Cortex®-A7 GIC (continued)”，我们重点关注的是从ID32开始的SPI中断，因为这些才是STM32MP1的外设中断，如图31.1.3.3所示(由于表太大，这里只是截取其中一部分)：
7 V) K8 |  U/ S5 m, |3 a2 ?' O! `

& Q8 N5 H: G! ?3 a$ m
+ u4 Q9 `; `8 \" p: @1 J1 z图31.1.3.3 STM32MP1中断源
关于GIC就先讲到这里，我们接下来讲解一下EXTI。
) O5 w* [  y( ^  K4 r3、EXTI- 外部中断和事件控制器
* p$ r. c3 O8 W/ v, `; @6 mEXTI是什么东西呢？全称是：Extended interrupt and event controller，中文一般叫做外部中断和事件控制器。EXTI是ST自己设计的，用来辅助GIC管理STM32MP1相应中断的。EXTI通过可配置的事件输入和直接事件输入来管理唤醒。它可以针对电源控制提供唤醒请求、针对CPU事件输入生成事件。EXTI 唤醒请求可让系统从停止模式唤醒，以及让CPU从CSTOP 和CSTANDBY模式唤醒。此外，EXTI还可以在运行模式下生成中断请求和事件请求，这个非常重要，因为在实际使用中EXTI主要是为STM32的GPIO中断服务的。
EXTI主要特性如下：
8 F" X6 [+ i% n# K( I/ H. M' ~·支持76个输入事件
# q$ {: P: [7 _6 R0 Q·两个CPU内核都支持。
5 `% S! j- O+ j- w8 Z$ p·所有事件输入均可让CPU唤醒。
+ x7 I" E# P- l1 }" z  i0 kEXTI的异步输入事件可以分为2组：
①、可配置事件（来自能够生成脉冲的I/O或外设的信号），这类事件具有以下特性：
– 可选择的有效触发边沿。
) G; r0 D7 s3 Z( B0 z. `. x. B! T# ^– 中断挂起状态寄存器位。
– 单独的中断和事件生成屏蔽。
# W0 k0 M0 ]/ h% t; Z$ S– 支持软件触发。
②、直接事件（来自其他外设的中断和唤醒源，需要在外设中清除），这类事件具有以下
特性：
' N$ M3 M7 F" k1 K; S– 固定上升沿有效触发。
– EXTI 中无中断挂起状态寄存器位（中断挂起状态由生成事件的外设提供）。
3 ]( ~4 ]! Y* s& t+ _$ E- g– 单独的中断和事件生成屏蔽。
7 G1 s; T9 _' f6 y7 N3 `! K4 C– 不支持软件触发。
对于GPIO中断来说，就是可配置事件，EXTI和GIC的关系如图31.1.3.4所示：

2 I0 A8 Z, `4 x1 u: e, @: v
; b  t: c1 N. ~; p1 n" [" q
9 j" W) X% q6 j- ^8 @# C图31.1.3.4 EXTI框架
" p6 e% q# b) x4 w% Q从图31.1.3.4可以看出STM32MP1的中断处理方式有5种：
①、外设直接产生中断到GIC，然后由GIC通知CPU内核。
- b7 {4 N) K  G7 o  s1 o②、GPIO或外设产生中断到EXTI，EXTI将信号提交给GIC，最终再将中断信号提交给CPU。
③、GPIO或外设产生中断到EXTI，EXTI直接将中断信号提交给CPU。
Linux系统会用到这三种中断方式，一个外设最多可以有两种中断方式，为啥是两种而不是三种后面会说。
8 N$ E# Z5 X" G3 x- USTM32MP1的所有GPIO都有中断功能，而GPIO中断是我们最常用的功能。STM32每一组GPIO最多有16个IO，比如PA0PA15，因此每组GPIO就有16个中断，这16个GPIO事件输入对应EXTI015，其中PA0、PB0等都对应EXTI0，如图31.1.3.5所示：
; ?, B' ^4 K9 P1 r0 Z- @


! K  c* q9 t2 r: S, ~/ {图31.1.3.5 EXTI0~15对应的GPIO
' c4 X" R. g+ n5 N, [如果要在Linux系统中使用中断，那么就需要在设备树中设置好中断属性信息，Linux内核通过读取设备树中的中断属性信息来配置中断，GIC控制器的设备树绑定信息参考文档Documentation/devicetree/bindings/ interrupt-controller/arm,gic.yaml， EXTI控制器的设备树绑定信息参考文档Documentation/devicetree/bindings/interrupt-controller/st,stm32-exti.txt。
4、GIC控制器节点
打开stm32mp151.dtsi文件，其中的intc节点就是GIC的中断控制器节点，节点内容如下所示：

' G- `: @8 V" y

1. 示例代码31.1.3.1 中断控制器intc节点
   
2. 1   intc: interrupt-controller@a0021000 {
   
3. 2       compatible = "arm,cortex-a7-gic";
   
4. 3       #interrupt-cells = <3>;
   
5. 4       interrupt-controller;
   * q. U+ o# O. x
6. 5       reg =         <0xa0021000 0x1000>,
   
7. 6                     <0xa0022000 0x2000>;
   
8. 7   };

复制代码

第2行，compatible属性值为“arm,cortex-a7-gic”在Linux内核源码中搜索“arm,cortex-a7-gic”即可找到GIC中断控制器驱动文件。
* a9 ]( s' C; e# W. c& @第3行，#interrupt-cells和#address-cells、#size-cells一样。表示此中断控制器下设备的cells大小，对于设备而言，会使用interrupts属性描述中断信息，#interrupt-cells描述了interrupts属性的cells大小，也就是一条信息有几个cells。每个cells都是32位整形值，对于ARM处理的GIC来说，一共有3个cells，这三个cells的含义如下：
第一个cells：中断类型，0表示SPI中断，1表示PPI中断。
第二个cells：中断号，对于SPI中断来说中断号的范围为32287(256个)，对于PPI中断来说中断号的范围为1631，但是该cell描述的中断号是从0开始。
第三个cells：标志，bit[3:0]表示中断触发类型，为1的时候表示上升沿触发，为2的时候表示下降沿触发，为4的时候表示高电平触发，为8的时候表示低电平触发。bit[15:8]为PPI中断的CPU掩码。
第4行，interrupt-controller节点为空，表示当前节点是中断控制器。
) }/ P2 e1 e" V1 e我们来看一下STM32MP1的SPI6是如何在设备树节点中描述中断信息的，首先是查阅《STM32MP157参考手册》第“21.2 GIC Interrupts”小节中的表117，也就是图31.1.3.3。找到SPI6对应的中断号，如图31.1.3.6所示：

) X- t1 {' E" {+ Y* N

图31.1.3.6 SPI6中断
, U0 R, T* Q$ D& g# q( ]6 v1 }从图31.1.3.6可以看出，第一列的“Num”就是SPI6的中断号：86，注意这里并没有算前面32个中断号，如果加上前面32个中断号的话就是第二列“ID”，为：86+32=118。
打开stm32mp151.dtsi，找到SPI6节点内容，如下所示：
, ?# ~# p' V! I
  ~# P: C4 H# @* @, Z

1. 示例代码31.1.3.2 SPI6节点
   
2. 1   spi6: spi@5c001000 {
   / P% v7 Q1 {. q1 ?; Z
3. 2       #address-cells = <1>;
   
4. 3       #size-cells = <0>;
   
5. 4       compatible = "st,stm32h7-spi";
   
6. 5       reg = <0x5c001000 0x400>;
   , H. n  {# G  }( C! r+ ]
7. 6       interrupts = <GIC_SPI 86 IRQ_TYPE_LEVEL_HIGH>;
   ( k% g- X( i2 y% m# G  S
8. 7       clocks = <&scmi0_clk CK_SCMI0_SPI6>;
   
9. 8       resets = <&scmi0_reset RST_SCMI0_SPI6>;
   
10. 9       dmas = <&mdma1 34 0x0 0x40008 0x0 0x0 0x0>,
    
11. 10             <&mdma1 35 0x0 0x40002 0x0 0x0 0x0>;
    : O0 L3 }! r3 n
12. 11      dma-names = "rx", "tx";
    * h4 c( |8 E) _5 e* J6 q
13. 12      power-domains = <&pd_core>;
    
14. 13      status = "disabled";
    
15. 14        };

复制代码

第6行，interrupts描述中断中断源的信息，第一个表示中断类型，为GIC_SPI，也就是共享中断。第二个表示中断号为86，来源就是图31.1.3.6。第三个表示中断触发类型是高电平触发。
2、EXTI控制器节点
% H8 c- ]' X% X$ x对于GPIO中断而言，要用到EXTI，所以我们接下来看一下EXTI设备节点。打开stm32mp151.dtsi文件，其中的exti节点就是EXTI的中断控制器节点，节点内容如下所示：

1. 示例代码51.1.3.3 中断控制器exti节点
   
2. 1   exti: interrupt-controller@5000d000 {
   
3. 2       compatible = "st,stm32mp1-exti", "syscon";
   
4. 3       interrupt-controller;
   % z) W+ s1 Z- \$ C
5. 4       #interrupt-cells = <2>;
   
6. 5       reg = <0x5000d000 0x400>;
   7 B( h! K  r! @6 G$ A
7. 6       hwlocks = <&hsem 1 1>;
   
8. 7   };

复制代码

第3行，表明exti节点是个中断控制器。
1 Z( d( d6 e8 c; M! y" r2 v( R& r第4行，interrupt-cells=2，表明exti的子节点里面第一个cell表示为中断号，也可以叫EXTI事件编号，第二个cell表示中断标志位。其它的设备树属性和GIC控制器是一样的。
前面说了，GPIO用到了EXTI，因此GPIO节点信息里面的EXTI相关内容，在stm32mp151.dtsi文件中找到如下所示内容：
2 q& q* _' E$ V2 t8 u5 J. W! e

1. 示例代码31.1.3.4  GPIO中断控制器节点
   0 `0 p. v# p: s! Q! P
2. 1   pinctrl: pin-controller@50002000 {
   3 Z0 O1 m; d) L" L0 h
3. 2       #address-cells = <1>;
   
4. 3       #size-cells = <1>;
   ( z. W' _# Y& @5 P( g7 M
5. 4       compatible = "st,stm32mp157-pinctrl";
   + F7 \6 O- g: ]
6. 5       ranges = <0 0x50002000 0xa400>;
   
7. 6       interrupt-parent = <&exti>;
   & Q0 j8 ?* W1 _2 w4 I9 q, C" _
8. 7       st,syscfg = <&exti 0x60 0xff>;
   3 G2 Y( v# ?5 z. U5 Z
9. 8       hwlocks = <&hsem 0 1>;
   ! ^5 O0 u9 |) F' `- U4 h- D* l& D
10. 9       pins-are-numbered;
    
11. 10  
    
12. 11      gpioa: gpio@50002000 {
    $ |& _* U; @8 G1 b
13. 12          gpio-controller;
    
14. 13          #gpio-cells = <2>;
    
15. 14          interrupt-controller;
    
16. 15          #interrupt-cells = <2>;
    * Y7 y+ u# _7 C
17. 16          reg = <0x0 0x400>;
    
18. 17          clocks = <&rcc GPIOA>;
    
19. 18          st,bank-name = "GPIOA";
    
20. 19          status = "disabled";
    
21. 20      };
    
22. ......
    5 _' z, i7 C' E
23. 120
    - s# P/ B; K, W+ S7 V. z& K! ~
24. 121     gpiok: gpio@5000c000 {
    
25. 122         gpio-controller;
    
26. 123         #gpio-cells = <2>;
    8 \( [4 o, c! S( M6 g3 q: [
27. 124         interrupt-controller;
    
28. 125         #interrupt-cells = <2>;
    
29. 126         reg = <0xa000 0x400>;
    
30. 127         clocks = <&rcc GPIOK>;
    ) I5 u+ ]1 X) I2 V
31. 128         st,bank-name = "GPIOK";
    
32. 129         status = "disabled";
    
33. 130     };
    
34. 131 };
    ) y: ~0 a9 k1 \+ Y0 d
35. 132
    
36. 133 pinctrl_z: pin-controller-z@54004000 {
    
37. 134     #address-cells = <1>;
    
38. 135     #size-cells = <1>;
    
39. 136     compatible = "st,stm32mp157-z-pinctrl";
    
40. 137     ranges = <0 0x54004000 0x400>;
    
41. 138     pins-are-numbered;
    + J7 ?! D& G+ X# v
42. 139     interrupt-parent = <&exti>;
    3 B$ {# x3 t5 H8 ^! m7 H4 ]
43. 140     st,syscfg = <&exti 0x60 0xff>;
    
44. 141     hwlocks = <&hsem 0 1>;
    
45. 142
    ; I' f& t7 X+ \  c
46. 143     gpioz: gpio@54004000 {
    
47. 144         gpio-controller;
    ) c9 I4 T9 h5 k0 j, h! ~
48. 145         #gpio-cells = <2>;
    0 X4 [5 H( D" p8 m
49. 146         interrupt-controller;
    9 W# u4 g$ B- I. C" V- ?
50. 147         #interrupt-cells = <2>;
    
51. 148         reg = <0 0x400>;
    0 X/ G; S9 W! r* ]) [& L1 i
52. 149         clocks = <&scmi0_clk CK_SCMI0_GPIOZ>;
    1 @2 h+ @' }: N# G2 I% e
53. 150         st,bank-name = "GPIOZ";
    
54. 151         st,bank-ioport = <11>;
      Z) f! D& M; c+ T
55. 152         status = "disabled";
    , L! x. W1 o: j- @4 H1 V
56. 153     };
    
57. 154 };

复制代码

第1131行，pinctrl节点，此节点有11个子节点，gpioagpiok，分别对应GPIOAGPIOK这11组IO。第8行，通过interrupt-parent属性指定pinctrl所有子节点的中断父节点为exti，这样GPIO的中断就和EXTI联系起来了。第1120行为gpioa节点，第14行表明gpioa节点也是个中断控制器，第15行设置interrupt-cells为2，那么对于具体的GPIO而言，interrupts属性第一个cell为某个IO在所处组的编号，第二个cell表示中断触发方式。比如现在要设置PA1这个引脚为下降沿触发，那么就要interrupts = <1 IRQ_TYPE_EDGE_FALLING>。
第133154行，pinctrl_z节点，由于GPIOZ这一组对应的寄存器地址和GPIOAGPIOK不是连续的，所以单独使用pinctrl_z来描述GPIOZ，含义和pinctrl一样。
我们来看一个具体的应用，打开stm32mp15xx-dkx.dtsi文件，找到如下所示内容：

: Z( t6 w7 {/ V$ Z% Y

1. 示例代码31.1.3.6 hdmi节点信息
   ! L* u7 M9 ~  S+ C* g. u* y
2. 1     hdmi-transmitter@39 {
   
3. 2         compatible = "sil,sii9022";
   
4. 3         reg = <0x39>;
   6 F+ W$ l7 f0 Z
5. 4         iovcc-supply = <&v3v3_hdmi>;
   ( ?2 `% i9 I& q4 v
6. 5         cvcc12-supply = <&v1v2_hdmi>;
   ! O$ }6 v5 q0 a4 I4 E
7. 6         reset-gpios = <&gpioa 10 GPIO_ACTIVE_LOW>;
   5 n1 T1 A2 P4 w% g/ j7 V, Z
8. 7         interrupts = <1 IRQ_TYPE_EDGE_FALLING>;
   3 T! [4 g+ d& C; E$ `
9. 8         interrupt-parent = <&gpiog>;
   6 s8 C6 F% z, q- Z% I
10. 9         #sound-dai-cells = <0>;
    
11. 10        status = "okay";
    
12. 11  };

复制代码

' }7 ?/ H2 h4 {# N- {$ csii9022是ST官方在开发板上的一个HDMI芯片，上述代码就是sii9022的节点信息，sii9022a芯片有一个中断，此引脚链接到了STM32MP1的PG1上，此中断是下降沿触发。
第7行，interrupts设置中断信息，1表示本组内第一个IO，在这里就是PG1。IRQ_TYPE_EDGE_FALLING表示下降沿触发。
! G& R  y. D! ~8 Y$ e+ l& ?0 [8 E第8行，interrupt-parent属性设置中断控制器，这里是有gpiog作为中断控制器。结合上面的interrupts属性，这两行的目的就是设置PG1为下降沿出触发。可以看出使用起来是非常的简单，在我们实际编写代码的时候，只需要通过interrupt-parent和interrupts这两个属性即可设置某个GPIO的中断功能。
简单总结一下与中断有关的设备树属性信息：
①、#interrupt-cells，指定中断源的信息cells个数。
3 T4 Y6 \* q8 O; z+ F②、interrupt-controller，表示当前节点为中断控制器。
) G0 S4 g; b8 v; M③、interrupts，指定中断号，触发方式等。
④、interrupt-parent，指定父中断，也就是中断控制器。
⑤、interrupts-extended，指定中断控制器、中断号、中断类型和触发方式，这个属性比较特殊，是新加入的。前面说了，要通过interrupts和interrupt-parent一起设置某个IO的中断方式。这里我们也可以只使用interrupts-extended属性一次性指定中断父节点，IO编号，中断方式等。打开stm32mp157f-ev1-a7-examples.dts文件，里面有如下所示代码：

) ]8 N4 ~+ o6 L

1. 示例代码31.1.3.7 test_keys节点
   
2. 1  test_keys {
   - y9 P& b0 E2 T/ R9 q
3. 2           compatible = "gpio-keys";
   $ v! A! M" V. Z$ ~" @4 f
4. 3           #address-cells = <1>;
   
5. 4           #size-cells = <0>;
   & C- h" g, G3 H( b  l
6. 5           autorepeat;
   ) B' Z) F. X0 @$ M* x  T
7. 6           status = "okay";
   
8. 7           /* gpio needs vdd core in retention for wakeup */
   
9. 8           power-domains = <&pd_core_ret>;
   4 }$ L$ t: A+ ^) K/ C6 x
10. 9  
    + A) W* `4 H2 ]6 r; Q# u
11. 10          button@1 {
    3 M) r/ M* u: i: K7 [+ W
12. 11              label = "PA13";
    6 a2 T1 y$ ^. t/ a
13. 12              linux,code = <BTN_1>;
    
14. 13              interrupts-extended = <&gpioa 13 IRQ_TYPE_EDGE_FALLING>;
    / p1 ]5 X0 Z" O$ E' J  Q
15. 14              status = "okay";
    
16. 15              wakeup-source;
    * I1 L' s) D+ P- n0 E: e1 M( j2 B
17. 16          };
    
18. 17 };

复制代码

很明显，上述代码用于描述一个按键，此按键采用中断方式，这个按键使用到了PA1这个引脚。第13行直接通过interrupts-extended属性描述了所有的中断信息，第一个参数为gpioa，第二个参数为13，第三个参数表示下降沿触发。如果使用interrupts和interrupt-parent来描述的话就是：
interrupt-parent = <&gpioa>;
interrupts = <13 IRQ_TYPE_EDGE_FALLING>;
/ H# @4 U2 ^/ r2 T0 p! p大家根据自己的喜好来选择使用哪种形式描述即可。
5 L$ c6 D' D( m$ x
0 ^3 @4 M9 N$ U1 O  Y* B! {31.1.4 获取中断号
! o# s1 G: d- D编写驱动的时候需要用到中断号，我们用到的中断号，中断信息已经写到了设备树里面，因此可以通过irq_of_parse_and_map函数从interupts属性中提取到对应的设备号，函数原型如下：
" u- M5 a2 }3 Nunsigned int irq_of_parse_and_map(struct device_node *dev, int index)
' A8 A4 ^1 ^& q; h9 K* R, I+ {' G函数参数和返回值含义如下：
dev：设备节点。
; x* _1 G" v8 Yindex：索引号，interrupts属性可能包含多条中断信息，通过index指定要获取的信息。
返回值：中断号。
如果使用GPIO的话，可以使用gpio_to_irq函数来获取gpio对应的中断号，函数原型如下：
9 S8 u) v4 z+ t2 lint gpio_to_irq(unsigned int gpio)
1 B; B' t* W" ?/ t9 ^函数参数和返回值含义如下：
, x2 Q! s1 N3 F1 @gpio：要获取的GPIO编号。
返回值：GPIO对应的中断号。
31.2 硬件原理图分析
( P  O* Y0 u: v5 e* V本章实验硬件原理图参考29.2小节即可。
7 i+ h" L; Z9 n31.3 实验程序编写
! C/ v- b/ `% W本实验对应的例程路径为：开发板光盘1、程序源码2、Linux驱动例程13_irq。
6 ~- \- Z" z5 {) f! a本章实验我们驱动正点原子的STM32MP157开发板上的KEY0按键，不过我们采用中断的方式，并且采用定时器来实现按键消抖，应用程序读取按键值并且通过终端打印出来。通过本章我们可以学习到Linux内核中断的使用方法，以及对Linux内核定时器的回顾。
2 C# Q7 S2 o, o31.3.1 修改设备树文件
( t8 [$ a6 q, f2 A2 V# J本章实验使用到了按键KEY0，按键KEY0使用中断模式，因此需要在“key”节点下添加中断相关属性，添加完成以后的“key”节点内容如下所示：

# G/ w& G8 A2 f+ S: x

1. 示例代码31.3.1.1 key节点信息
   ) |/ y. k  n# w; E+ J# U
2. 1    key {
   3 t/ j+ H2 a! w; v& Y6 `
3. 2        compatible = "alientek,key";
   
4. 3        status = "okay";
   
5. 4        key-gpio = <&gpiog 3 GPIO_ACTIVE_LOW>;
   , A$ w' ^6 z( x6 K0 J1 d" o
6. 5        interrupt-parent = <&gpiog>;
   
7. 6        interrupts = <3 IRQ_TYPE_EDGE_BOTH>;
   
8. 7    };

复制代码

第5行，设置interrupt-parent属性值为“gpiog”，因为KEY0所使用的GPIO为PG3，所以要设置KEY0的中断控制器为gpiog。
) Z8 [6 E  C+ |6 e7 [7 I$ {. B第6行，设置interrupts属性，也就是设置中断源，第一个cells的3表示GPIOG组的3号IO。IRQ_TYPE_EDGE_BOTH定义在文件include/linux/irq.h中，定义如下：
9 O* S- G! k# F

1. 示例代码31.3.1.2 中断状态
   1 c8 A# ?9 v% Z/ {  K! v! _/ z
2. 75  enum {
   ) `8 v' G! n8 |  n( w
3. 76      IRQ_TYPE_NONE                       = 0x00000000,
   ' E+ K* m6 m9 `. z/ }7 Z  M8 K
4. 77      IRQ_TYPE_EDGE_RISING                 = 0x00000001,
   9 D% \1 F  e" {2 R9 z3 S% Y, N+ a
5. 78      IRQ_TYPE_EDGE_FALLING           = 0x00000002,
   
6. 79      IRQ_TYPE_EDGE_BOTH        = (IRQ_TYPE_EDGE_FALLING |
   / K1 d8 H" k6 c0 ^/ l* Y( a
7. IRQ_TYPE_EDGE_RISING),
   , C& p) `. Q" \- O' U8 A! z8 @8 W
8. 80      IRQ_TYPE_LEVEL_HIGH                 = 0x00000004,
   ! Z! e/ m4 B. j2 U& H4 e% F
9. 81      IRQ_TYPE_LEVEL_LOW                  = 0x00000008,
   : D0 {: ^) G. K2 w1 M, e1 e9 Y
10. 82      IRQ_TYPE_LEVEL_MASK                 = (IRQ_TYPE_LEVEL_LOW |
    
11. IRQ_TYPE_LEVEL_HIGH),
    
12. ......
    
13. 100 };

复制代码

! P8 s! [6 I: m* f& W  R0 l从示例代码31.3.1.2中可以看出，IRQ_TYPE_EDGE_BOTH表示上升沿和下降沿同时有效，相当于KEY0按下和释放都会触发中断。
* N" B) U$ a6 n5 T" a
设备树编写完成以后使用“make dtbs”命令重新编译设备树，然后使用新编译出来的stm32mp157d-atk.dtb文件启动Linux系统。
31.3.2 按键中断驱动程序编写
3 n3 c2 Z; b! U: `) K新建名为“13_irq”的文件夹，然后在13_irq文件夹里面创建vscode工程，工作区命名为“keyirq”。工程创建好以后新建keyirq.c文件，在keyirq.c里面输入如下内容：
$ ^: {4 F# k. j7 O" W
' ?* f/ ?/ M0 ^& p$ ]/ q

1. 示例代码31.3.2.1 keyirq.c文件代码
   
2. 11  #include <linux/types.h>
   
3. 12  #include <linux/kernel.h>
   
4. 13  #include <linux/delay.h>
   - t: _4 C7 p: C+ L3 O& @
5. 14  #include <linux/ide.h>
   
6. 15  #include <linux/init.h>
   1 s; R. T& q+ M" x5 ~
7. 16  #include <linux/module.h>
   
8. 17  #include <linux/errno.h>
   
9. 18  #include <linux/gpio.h>
   3 N* Z+ I* ~7 h3 j
10. 19  #include <linux/cdev.h>
    
11. 20  #include <linux/device.h>
    
12. 21  #include <linux/of.h>
    
13. 22  #include <linux/of_address.h>
    
14. 23  #include <linux/of_gpio.h>
    6 d8 n7 Y. m1 z
15. 24  #include <linux/semaphore.h>
    3 Q) f! I( s7 Q, O3 D
16. 25  #include <linux/of_irq.h>
    
17. 26  #include <linux/irq.h>
    ( V9 d1 M4 t! G- x
18. 27  #include <asm/mach/map.h>
    1 [% B% y" c$ {
19. 28  #include <asm/uaccess.h>
    
20. 29  #include <asm/io.h>
    
21. 30
    
22. 31  #define KEY_CNT         1               /* 设备号个数          */
    " l, k6 X7 x. y) J$ G9 m4 w/ p/ ^
23. 32  #define KEY_NAME        "key"           /* 名字               */
      ?  k. n" E, f6 S
24. 33
    
25. 34  /* 定义按键状态 */
    + d- v- i% T9 w
26. 35  enum key_status {
    1 R( ^, i# v$ Q
27. 36      KEY_PRESS = 0,              /*按键按下                  */
    / {! ^6 ?) X( f/ _( J' c" n" m' ~3 I
28. 37      KEY_RELEASE,                /*按键松开                */
    
29. 38      KEY_KEEP,                   /* 按键状态保持         */
    " [4 y' G  m, P3 M3 m) y
30. 39  };
    6 g2 I) B( }, O# |/ i7 @9 X' F
31. 40
    $ a. C$ C% S; Y& e! a# {
32. 41  /* key设备结构体 */
    
33. 42  struct key_dev{
    
34. 43      dev_t devid;                    /* 设备号             */
    
35. 44      struct cdev cdev;               /* cdev                     */
    7 D& w% Q1 N0 w/ Y
36. 45      struct class *class;            /* 类                      */
    
37. 46      struct device *device;         /* 设备                    */
    
38. 47      struct device_node  *nd; /* 设备节点         */
    ! w. b2 m' @. Z" e8 Z' E
39. 48      int key_gpio;                   /* key所使用的GPIO编号*/
    5 d8 w! [& g/ v3 D
40. 49      struct timer_list timer;        /* 按键值              */
    
41. 50      int irq_num;                    /* 中断号              */
    
42. 51      spinlock_t spinlock;            /* 自旋锁              */  
    " B  d; z2 g+ i" Z% c* A
43. 52  };
    
44. 53
    0 ?5 s: ?( n+ u5 Q! r- b1 [
45. 54  static struct key_dev key;                 /* 按键设备 */
    
46. 55  static int status = KEY_KEEP;            /* 按键状态 */
    
47. 56
    
48. 57  static irqreturn_t key_interrupt(int irq, void *dev_id)
    8 F' b! i2 }6 b3 c$ O7 P
49. 58  {
    & x, ~: i) |! X( G/ T9 T2 q
50. 59      /* 按键防抖处理，开启定时器延时15ms */
    9 d9 Q# N. I6 c5 N- M
51. 60      mod_timer(&key.timer, jiffies + msecs_to_jiffies(15));
    3 g" g6 \' L3 q6 O  b- l
52. 61      return IRQ_HANDLED;
    
53. 62  }
    
54. 63
    % z1 f: ^$ ?" P# ~/ I7 M- I, N$ X
55. 64  /*
    . A% B3 B9 X+ Z0 D* u
56. 65   * @description         : 初始化按键IO，open函数打开驱动的时候
    
57. 66   *                          初始化按键所使用的GPIO引脚。
    4 }# ]+ x% D3 a1 c
58. 67   * @param               : 无
    7 c8 E2 s8 Q: m5 f; w. r7 ~' H
59. 68   * @return              : 无
    
60. 69   */
    
61. 70  static int key_parse_dt(void)
    
62. 71  {
    $ U7 F7 E* o, I4 f( J5 t
63. 72      int ret;
    % [. K% x0 a8 R! _4 ^, [# O
64. 73      const char *str;
    2 N# o  T4 b9 h% W, g5 }' @, D
65. 74      
    - {1 h, z5 {/ `% ^+ d% [
66. 75      /* 设置LED所使用的GPIO         */
    
67. 76      /* 1、获取设备节点：key *        /
    2 V- Z2 J$ Z  t
68. 77      key.nd = of_find_node_by_path("/key");
    
69. 78      if(key.nd == NULL) {
    2 u% N0 e) t7 s
70. 79          printk("key node not find!\r\n");
    " m$ S% e( Z+ g' h, Q6 [
71. 80          return -EINVAL;
    3 B  M0 B$ T# X( t$ q
72. 81      }
    
73. 82
    6 ?5 v6 Z. [0 \" A) W0 f; N
74. 83      /* 2.读取status属性 */
    
75. 84      ret = of_property_read_string(key.nd, "status", &str);
    
76. 85      if(ret < 0)
    - i6 r' ^- h: s, @4 Z
77. 86          return -EINVAL;
    & x' s7 b& x1 D5 ~
78. 87
    8 J6 v2 g, r, Z6 j4 v
79. 88      if (strcmp(str, "okay"))
    , @9 |. o( s% y& C3 w' o. g
80. 89          return -EINVAL;
    
81. 90      
      s1 q9 J* I- ^+ q& X- J- @2 P/ J
82. 91      /* 3、获取compatible属性值并进行匹配 */
    6 y8 `0 a6 {- S" Y5 d' a) l
83. 92      ret = of_property_read_string(key.nd, "compatible", &str);
    
84. 93      if(ret < 0) {
    
85. 94          printk("key: Failed to get compatible property\n");
    ! z$ }/ i% x2 |3 i% m! _# s
86. 95          return -EINVAL;
    8 o0 |; m8 S/ \: c3 o
87. 96      }
    
88. 97
    
89. 98      if (strcmp(str, "alientek,key")) {
    6 V2 _! }3 e5 i  ?4 H
90. 99          printk("key: Compatible match failed\n");
    
91. 100         return -EINVAL;
    3 J8 E6 [; X+ I" d0 A
92. 101     }
    2 |0 m0 X6 W  |* e/ E
93. 102
      U: L( j. B; o8 {4 Q9 {
94. 103     /* 4、 获取设备树中的gpio属性，得到KEY0所使用的KYE编号 */
    
95. 104     key.key_gpio = of_get_named_gpio(key.nd, "key-gpio", 0);
    
96. 105     if(key.key_gpio < 0) {
    
97. 106         printk("can't get key-gpio");
    
98. 107         return -EINVAL;
    % H0 F8 c: |/ n8 ~
99. 108     }
    
100. 109
     ! k* `/ ]7 ~# g/ x
101. 110     /* 5 、获取GPIO对应的中断号 */
     
102. 111     key.irq_num = irq_of_parse_and_map(key.nd, 0);
       k9 L6 h2 n. X5 t5 y( ^, n
103. 112     if(!key.irq_num){
     % o% A! Z$ q0 ]% ~' E
104. 113         return -EINVAL;
     
105. 114     }
     / f' [+ S( V2 K: U+ f) r6 g
106. 115
     ' Q. G5 |/ K4 l: f' ]- ?
107. 116     printk("key-gpio num = %d\r\n", key.key_gpio);
     ( X" W  K$ F/ R: K# O  T
108. 117     return 0;
     8 @3 F. p; h7 ^
109. 118 }
     
110. 119
     
111. 120 static int key_gpio_init(void)
     3 i" O* S% h# P& N
112. 121 {
     : E/ f; g7 ?3 N8 u6 W5 s
113. 122     int ret;
     2 ]1 E6 R# M! n) _
114. 123     unsigned long irq_flags;
     ! ~3 g! K( B( r; W7 q& }5 V
115. 124     
     - b4 V1 V0 g! z9 I/ s1 I( Q/ ^, v; F; n- E
116. 125     ret = gpio_request(key.key_gpio, "KEY0");
     7 M: }( x$ V$ [5 C
117. 126     if (ret) {
     % ^% e! |2 E+ c! P+ E$ a8 t' v! d
118. 127         printk(KERN_ERR "key: Failed to request key-gpio\n");
     
119. 128         return ret;
     
120. 129     }   
     ) _5 _. B3 ]2 q/ K; g1 k
121. 130     
     
122. 131     /* 将GPIO设置为输入模式                         */
     . M. A! [( k, ?. P% D. G7 c
123. 132     gpio_direction_input(key.key_gpio);
     
124. 133
     
125. 134            /* 获取设备树中指定的中断触发类型         */
     $ Q7 |! ]8 `! ]  s: A! X
126. 135     irq_flags = irq_get_trigger_type(key.irq_num);
     
127. 136     if (IRQF_TRIGGER_NONE == irq_flags)
     % _2 Y) k$ \: i" X5 I
128. 137         irq_flags = IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING;
     . N; ]0 |6 X6 [
129. 138         
     
130. 139     /* 申请中断 */
     $ T6 C3 U, _) n' r$ R
131. 140     ret = request_irq(key.irq_num, key_interrupt, irq_flags,
     $ H8 P) u& L2 j
132. "Key0_IRQ", NULL);
     4 G6 X9 I0 _& s9 G$ K
133. 141     if (ret) {
     
134. 142         gpio_free(key.key_gpio);
     + q; v' X7 p; c  ]+ x1 d1 D
135. 143         return ret;
     8 p5 b% K3 _; C8 M" S! X( ^
136. 144     }
     : Y4 k2 n& p; Q6 _4 N3 T: {
137. 145
     + E2 P" {1 _2 ]! s
138. 146     return 0;
       z' d/ X& q8 D7 l9 X
139. 147 }
     $ r. b- [, l0 v) W
140. 148
     
141. 149 static void key_timer_function(struct timer_list *arg)
     
142. 150 {
     
143. 151     static int last_val = 1;
     2 x! k; g' F8 v# e) Y$ [
144. 152     unsigned long flags;
     & R# G* Q: J7 M) ?. ?0 h1 M
145. 153     int current_val;
     8 v1 v5 i" c: L, }0 y8 [: Y2 `0 n
146. 154
     
147. 155     /* 自旋锁上锁 */
     " d) _6 |5 k% M6 j2 T
148. 156     spin_lock_irqsave(&key.spinlock, flags);
     
149. 157
     
150. 158     /* 读取按键值并判断按键当前状态 */
     
151. 159     current_val = gpio_get_value(key.key_gpio);
     
152. 160     if (0 == current_val && last_val)         /* 按下         */
     5 R( K0 J2 g5 U  v+ H
153. 161         status = KEY_PRESS;
     
154. 162     else if (1 == current_val && !last_val)
     * b9 H9 @# a5 T5 x2 N! V  W# J
155. 163         status = KEY_RELEASE;                           /* 松开         */
     ! b9 n6 N* ?# d
156. 164     else
     5 A5 W% J6 O6 z$ N: ~! O9 W$ p
157. 165         status = KEY_KEEP;                      /*状态保持         */
     6 z- F( n) w' b; L$ W4 x) H
158. 166
     
159. 167     last_val = current_val;
     8 w/ u3 l* u8 R  z3 }
160. 168
     
161. 169     /* 自旋锁解锁 */
     
162. 170     spin_unlock_irqrestore(&key.spinlock, flags);
     
163. 171 }
     6 K5 ~  H% n, [
164. 172
     
165. 173 /*
     
166. 174  * @description          : 打开设备
     
167. 175  * @param – inode        : 传递给驱动的inode
     % J& c+ x0 ?# Q) Q/ _0 S
168. 176  * @param - filp         : 设备文件，file结构体有个叫做private_data的成员变量
     ( y) n$ `# c( }7 R1 C
169. 177  *                    一般在open的时候将private_data指向设备结构体。
     
170. 178  * @return                : 0 成功;其他 失败
     - M% A' B8 F' }
171. 179  */
     ; M2 |4 \/ w" p5 s) Z5 [( j5 T$ B
172. 180 static int key_open(struct inode *inode, struct file *filp)
     6 |  D  H# Z4 w& J$ E
173. 181 {
     ! D8 y- B" }& ?- p' B* P: ~) \
174. 182     return 0;
     & ^$ f4 h+ M* Y/ R% ]
175. 183 }
     
176. 184
     3 d& c: H( N# E- t3 j$ k" T1 j0 c; X
177. 185 /*
     ) r$ L! n$ f7 r! r- \, i( Q
178. 186  * @description          : 从设备读取数据
     ; P9 s# m  n& V; H
179. 187  * @param – filp        : 要打开的设备文件(文件描述符)
     ( K" ?3 L* x( k% l: j
180. 188  * @param – buf          : 返回给用户空间的数据缓冲区
     " b  f& t7 _3 z( ]$ s4 N
181. 189  * @param – cnt          : 要读取的数据长度
     
182. 190  * @param – offt         : 相对于文件首地址的偏移
     
183. 191  * @return                : 读取的字节数，如果为负值，表示读取失败
     8 w& y$ [. l: ~5 Z1 o
184. 192  */
     
185. 193 static ssize_t key_read(struct file *filp, char __user *buf,
     % n* @" d8 V2 L) V" r" K9 N
186. 194             size_t cnt, loff_t *offt)
     ( h" \2 @; A7 L9 [
187. 195 {
     
188. 196     unsigned long flags;
     
189. 197     int ret;
     $ z8 Z0 D# Q7 g4 X" H1 X3 t7 F6 O
190. 198
     & S7 R/ W  G8 b" d
191. 199     /* 自旋锁上锁         */
     0 O* R4 A) o, K
192. 200     spin_lock_irqsave(&key.spinlock, flags);
     
193. 201
     & e* W" U/ W4 h4 H
194. 202     /* 将按键状态信息发送给应用程序 */
     
195. 203     ret = copy_to_user(buf, &status, sizeof(int));
     
196. 204
     
197. 205     /* 状态重置         */
     # C8 g1 A6 s- F: w, J- G3 |6 t
198. 206     status = KEY_KEEP;
     
199. 207
     
200. 208     /* 自旋锁解锁         */
     / [9 A0 P3 ^1 g+ G9 E
201. 209     spin_unlock_irqrestore(&key.spinlock, flags);
     " T! ^* e; c# o. Q4 t
202. 210
     ) h' ?9 E0 B' V. ^- u$ E
203. 211     return ret;
     # v9 a! [& i; g) q$ n0 o- M$ d
204. 212 }
     0 K7 X- |3 a( a' e5 G3 o
205. 213
     3 Q& N4 R8 a0 e4 r; `
206. 214 /*
     
207. 215  * @description          : 向设备写数据
     ' H; _; j8 J' s+ B4 V
208. 216  * @param - filp         : 设备文件，表示打开的文件描述符
     & g+ r* G  P" y  B' N- T
209. 217  * @param - buf          : 要写给设备写入的数据
     
210. 218  * @param - cnt          : 要写入的数据长度
     
211. 219  * @param - offt         : 相对于文件首地址的偏移
     
212. 220  * @return                : 写入的字节数，如果为负值，表示写入失败
     
213. 221  */
     
214. 222 static ssize_t key_write(struct file *filp, const char __user *buf,
     8 P, D$ B" o9 i' l: q  |
215. size_t cnt, loff_t *offt)
     
216. 223 {
     
217. 224     return 0;
     
218. 225 }
     # K  \/ V3 O0 w% F0 G8 C
219. 226
     
220. 227 /*
     
221. 228  * @description          : 关闭/释放设备
     
222. 229  * @param - filp         : 要关闭的设备文件(文件描述符)
     * ~+ V' q# H' M8 T  ]
223. 230  * @return                : 0 成功;其他 失败
     
224. 231  */
     
225. 232 static int key_release(struct inode *inode, struct file *filp)
     
226. 233 {
     + E$ Q% ^+ T6 A5 {  i' u9 P
227. 234     return 0;
     
228. 235 }
     0 b; z, T, o7 t. X8 B# s
229. 236
     
230. 237 /* 设备操作函数 */
     
231. 238 static struct file_operations key_fops = {
     
232. 239     .owner = THIS_MODULE,
     7 _' u$ u# K+ ?$ |6 u- s
233. 240     .open = key_open,
     
234. 241     .read = key_read,
     
235. 242     .write = key_write,
     
236. 243     .release =  key_release,
     % C7 K* s7 W+ f3 O8 n' Y
237. 244 };
     - A9 G2 x: C4 i% Q
238. 245
     8 r4 Y* ^4 }" C$ b3 O! K/ I
239. 246 /*
     
240. 247  * @description        : 驱动入口函数
     " \7 w- v5 ~2 I+ K
241. 248  * @param               : 无
     2 I: @; f) u" V$ g! n' m
242. 249  * @return              : 无
     ; E) W# q5 V  p- m! A% a
243. 250  */
     
244. 251 static int __init mykey_init(void)
     
245. 252 {
     & V& A4 w" x+ b
246. 253     int ret;
     ; ^/ S1 C: G. Z
247. 254     
     3 B* u/ M* K) m# I" X/ G5 {
248. 255     /* 初始化自旋锁                 */
     
249. 256     spin_lock_init(&key.spinlock);
     % b1 P% [2 n" W& r! i9 O# ^
250. 257     
     ' q7 R  M7 W# l8 w* I2 {, x
251. 258     /* 设备树解析                 */
     8 @, C/ |+ D. n- X9 W3 N
252. 259     ret = key_parse_dt();
     " j8 @0 t2 ^" ~1 y/ W8 u
253. 260     if(ret)
     8 Y4 d  L; D8 K# C
254. 261         return ret;
     
255. 262         
     . N5 e! _* G9 \- G% p, F7 }( s( R
256. 263     /* GPIO 中断初始化 */
     6 f9 f: u2 W, u. {7 y3 v
257. 264     ret = key_gpio_init();
     + ^2 P! }6 X& [& ^0 i" f
258. 265     if(ret)
       @$ _# i  x+ Z: t0 d, R
259. 266         return ret;
     
260. 267         
     
261. 268     /* 注册字符设备驱动         */
     # Z6 [. S# T; V/ [
262. 269     /* 1、创建设备号         */
     6 \* l! q/ x- K- u4 ^9 O, p
263. 270     ret = alloc_chrdev_region(&key.devid, 0, KEY_CNT, KEY_NAME);   
     / z+ z! \& ?. G8 e
264. 271     if(ret < 0) {
     $ y. y( L3 m- ?+ H* p1 N
265. 272         pr_err("%s Couldn't alloc_chrdev_region, ret=%d\r\n",
     
266. KEY_NAME, ret);
     ; i+ h, s( W, |% T5 H" S
267. 273         goto free_gpio;
     $ g+ I$ m6 \2 n  n8 B$ d+ Z2 T+ j
268. 274     }
     ) }  C, \9 e  F- D- t) s5 W
269. 275     
     ( t0 E! c5 m, h* u
270. 276     /* 2、初始化cdev         */
     
271. 277     key.cdev.owner = THIS_MODULE;
     % [) ]0 y8 w2 J$ g' T  n
272. 278     cdev_init(&key.cdev, &key_fops);
     
273. 279     
     0 b7 R- o6 b$ o! Y. S
274. 280     /* 3、添加一个cdev */
     
275. 281     cdev_add(&key.cdev, key.devid, KEY_CNT);
     & X3 r1 a0 j: x0 e; W
276. 282     if(ret < 0)
     . q; p6 p. V. |$ P  f
277. 283         goto del_unregister;
     # H2 x/ W& U/ a9 A, I; U
278. 284         
     
279. 285     /* 4、创建类                 */
     
280. 286     key.class = class_create(THIS_MODULE, KEY_NAME);
     
281. 287     if (IS_ERR(key.class)) {
     
282. 288         goto del_cdev;
     6 H& U) O6 b% O4 ?/ t% }2 q
283. 289     }
     7 F6 {) o( W& }0 Q3 k4 h
284. 290
     * x! t# y5 M- p/ Y& j0 E
285. 291     /* 5、创建设备                 */
     & a( K7 W: u3 x/ U. S! X
286. 292     key.device = device_create(key.class, NULL, key.devid, NULL,
     
287. KEY_NAME);
     9 i) e% g8 X7 X3 {! r
288. 293     if (IS_ERR(key.device)) {
     . Y3 W7 G6 B" I
289. 294         goto destroy_class;
     , m" @3 H6 w, v* y* K5 I
290. 295     }
     
291. 296     
     
292. 297     /* 6、初始化timer，设置定时器处理函数,还未设置周期，所有不会激活定时器 */
     - D6 v9 y/ ~( G' Z8 A6 J
293. 298     timer_setup(&key.timer, key_timer_function, 0);
     
294. 299     
     0 r$ K6 s* m! v) _1 G0 y
295. 300     return 0;
     : r6 Y6 i) `6 d$ b( U5 L
296. 301
     
297. 302 destroy_class:
     7 n/ r% s+ P7 h- r
298. 303     device_destroy(key.class, key.devid);
     
299. 304 del_cdev:
     9 H  Y, \- c, n, i7 K& |
300. 305     cdev_del(&key.cdev);
     0 U4 M7 J& [/ p4 [/ r! |
301. 306 del_unregister:
     
302. 307     unregister_chrdev_region(key.devid, KEY_CNT);
     
303. 308 free_gpio:
     , r9 P9 s# g, U9 u
304. 309     free_irq(key.irq_num, NULL);
     0 X) T  z0 \% ^3 [6 }& H
305. 310     gpio_free(key.key_gpio);
     2 X& R9 |! c' e: ?% Q$ Y
306. 311     return -EIO;
     6 }( D% L; A# S. A9 B" D4 U/ i+ P
307. 312 }
     
308. 313
     
309. 314 /*
     
310. 315  * @description         : 驱动出口函数
     
311. 316  * @param               : 无
     + ~6 I6 k6 v+ t& Q
312. 317  * @return              : 无
     ' i" V) k' Q0 k2 G- c3 h
313. 318  */
     
314. 319 static void __exit mykey_exit(void)
     2 O1 m; X" E; U& H/ l2 C
315. 320 {
     
316. 321     /* 注销字符设备驱动 */
     
317. 322     cdev_del(&key.cdev);                                                /* 删除cdev         */
     $ n- x6 O+ N7 C) b* F8 S. k
318. 323     unregister_chrdev_region(key.devid, KEY_CNT); /* 注销设备号 */
     + q& u4 P7 p5 x6 i5 v: i
319. 324     del_timer_sync(&key.timer);                        /* 删除timer         */
     
320. 325     device_destroy(key.class, key.devid);        /*注销设备                 */
     
321. 326     class_destroy(key.class);                               /* 注销类                 */
     ) K; u5 Z# n3 r1 \) I) V
322. 327     free_irq(key.irq_num, NULL);                    /* 释放中断                 */
     
323. 328     gpio_free(key.key_gpio);                                /* 释放IO                 */
     
324. 329 }
     
325. 330
     $ \# h; ]# P2 P
326. 331 module_init(mykey_init);
     
327. 332 module_exit(mykey_exit);
       |" O, c& h/ R4 c- H6 w% N
328. 333 MODULE_LICENSE("GPL");
     # b8 p. K4 T3 [% Z) p% I& J
329. 334 MODULE_AUTHOR("ALIENTEK");
     
330. 335 MODULE_INFO(intree, "Y");

复制代码

第35~39行，定义了一个枚举类型，包含3个常量KEY_PRESS、KEY_RELEASE、KEY_KEEP，分别用来表示按键的3种不同的状态，即按键按下、按键松开以及按键状态保持。
第42~52行，结构体key_dev为按键设备所对应的结构体，key_gpio为按键GPIO编号，irq_num为按键IO对应的中断号；除此之外，结构体当中还定义了一个定时器用于实现按键的去抖操作，还定义了一个自旋锁用于实现对关键代码的保护操作。
第54行，定义一个按键设备key。
: C) G' `/ h( K第55行，定义一个int类型的静态全局变量status用来表示按键的状态。
7 k: D2 O( }2 F6 t. [  F  G1 F第57~62行，key_interrupt函数是按键KEY0中断处理函数，参数dev_id是一个void类型的指针，本驱动程序并没使用到这个参数；这个中断处理函数很简单直接开启定时器，延时15毫秒，用于实现按键的软件防抖。
! j1 V( m5 O$ ?第70~118行，key_parse_dt函数中主要是对设备树中的属性进行了解析，获取设备树中的key节点，通过of_get_named_gpio函数得到按键的GPIO编号，通过irq_of_parse_and_map函数获取按键的中断号，irq_of_parse_and_map函数会解析key节点中的interrupt-parent和interrupts属性然后得到一个中断号，后面就可以使用这个中断号去申请以及释放中断了。
) m7 f9 ]! R  o% \1 h第120~147行，key_gpio_init函数中主要对GPIO以及中断进行了相关的初始化。使用gpio_request函数申请GPIO使用权，通过gpio_direction_input将GPIO设置为输出模式；irq_get_trigger_type函数可以获取到key节点中定义的中断触发类型，最后使用request_irq申请中断，并设置key_interrupt函数作为我们的按键中断处理函数，当按键中断发生之后便会跳转到该函数执行；request_irq函数会默认使能中断，所以不需要enable_irq来使能中断，当然我们也可以在申请成功之后先使用disable_irq函数禁用中断，等所有工作完成之后再来使能中断，这样会比较安全，建议大家这样使用。
: V' d- w  j0 |. d, U  G第149171行，key_timer_function函数为定时器定时处理函数，它的参数arg在本驱动程序中我们并没有使用到；该函数中定义了一个静态局部变量last_val用来保存按键上一次读取到的值，变量current_val用来存放当前按键读取到的值；第159165行，通过读取到的按键值以及上一次读取到的值来判断按键当前所属的状态，如果本次读取的值为0，而上一次读取的值1，则表示按键按下；如果本次读取的值为1，而上一次读取的值0，则表示按键松开；如果本次读取的值为0，而上一次读取的值也是0，则表示按键一直被按着；如果本次读取的值为1，而上一次读取的值也是1，则表示没有触碰按键。第167行，当状态判断完成之后，会将current_val的值赋值给last_val。本函数中也使用自旋锁对全局变量status进行加锁保护！
4 @% A* B, y3 o5 Z第193~212行，key_read函数，对应应用程序的read函数。此函数向应用程序返回按键状态信息数据；这个函数其实很简单，使用copy_to_user函数直接将statue数据发送给应用程序，status变量保存了按键当前的状态，发送完成之后再将按键状态重置即可！需要注意的是，该函数中使用了自旋锁进行保护。
第238~244行，按键设备的file_operations结构体。
第251~312行，mykey_init是驱动入口函数，第256行调用spin_lock_init初始化自旋锁变量，298行对定时器进行初始化并将key_timer_function函数绑定为定时器定时处理函数，当定时时间到了之后便会跳转到该函数执行。
( I' F; o# D% r+ _- M+ X% g第319~329行，mykey_exit驱动出口函数，第324行调用del_timer_sync函数删除定时器，代码中已经注释得非常详细了，这里便不再多说！
31.3.2 编写测试APP
1 P+ K* N7 ~9 T* U0 c* H" O  h4 v测试APP要实现的内容很简单，通过不断的读取/dev/key设备文件来获取按键值来判断当前按键的状态，从按键驱动上传到应用程序的数据可以有3个值，分别为0、1、2；0表示按键按下时的这个状态，1表示按键松开时对应的状态，而2表示按键一直被按住或者松开；搞懂数据代表的意思之后，我们开始编写测试程序，在13_irq目录下新建名为keyirqApp.c的文件，然后输入如下所示内容：

) `$ w* p! ]# R/ \9 E

1. 示例代码31.3.3.1 keyrqApp.c文件代码
   . K0 f9 |: W7 z" h/ k9 e
2. 1   /***************************************************************
   $ A) ^: P- t/ H0 z5 ~
3. 2   Copyright © ALIENTEK Co., Ltd. 1998-2029. All rights reserved.
   
4. 3   文件名            : keyApp.c
   6 d% R0 H( S! z+ x( }: S
5. 4   作者                : 正点原子Linux团队
   8 ~+ ]+ d& k6 o# g- h: u
6. 5   版本               : V1.0
   
7. 6   描述                : Linux中断驱动实验
   
8. 7   其他              : 无
   
9. 8   使用方法           : ./keyirqApp /dev/key
   
10. 9   论坛               : <a href="http://www.openedv.com" target="_blank">www.openedv.com</a>
    " b. C3 N7 @+ j) ]' x  o
11. 10  日志               : 初版V1.0 2021/1/30 正点原子Linux团队创建
    ( C9 G0 M" f0 C; q
12. 11  ***************************************************************/
    
13. 12
    
14. 13  #include <stdio.h>
    
15. 14  #include <unistd.h>
    
16. 15  #include <sys/types.h>
    
17. 16  #include <sys/stat.h>
    4 }1 g2 ~$ o6 C3 \/ u
18. 17  #include <fcntl.h>
    # t* p. @4 K2 g  S6 B4 g
19. 18  #include <stdlib.h>
    
20. 19  #include <string.h>
    5 z4 q5 T, x/ n  w
21. 20
    
22. 21  /*
    , n4 F$ P) ^5 B, R0 P& D5 F
23. 22   * @description          : main主程序
    " E: `+ |( n5 f, }3 F+ @
24. 23   * @param – argc         : argv数组元素个数
    
25. 24   * @param – argv         : 具体参数
    ( a! q* O! x. W- K
26. 25   * @return                : 0 成功;其他 失败
    3 X9 x7 n3 d1 _% |/ u1 h
27. 26   */
    
28. 27  int main(int argc, char *argv[])
    
29. 28  {
    + D7 s7 p0 g; \
30. 29      int fd, ret;
    
31. 30      int key_val;
    : }! v+ a9 h: D: B& e1 B
32. 31
    * W+ a- Y2 a: t  X1 d
33. 32      /* 判断传参个数是否正确 */
    
34. 33      if(2 != argc) {
    
35. 34          printf("Usage:\n"
    
36. 35               "\t./keyApp /dev/key\n"
    
37. 36              );
      v" i# F) E1 {0 i. ^& V: H% i3 y
38. 37          return -1;
    & W9 F3 \7 H4 q0 ?, p/ F1 x
39. 38      }
    
40. 39
    2 P6 e, m% U+ H+ I6 B
41. 40      /* 打开设备 */
    
42. 41      fd = open(argv[1], O_RDONLY);
    
43. 42      if(0 > fd) {
    9 F, B: V  w2 L( F( h* o
44. 43          printf("ERROR: %s file open failed!\n", argv[1]);
    
45. 44          return -1;
    
46. 45      }
    
47. 46
    
48. 47      /* 循环读取按键数据 */
    6 t! e5 Q4 ^. q, F  f
49. 48      for ( ; ; ) {
    8 o' ?6 K; f* a5 [4 w* H- _+ D
50. 49
    ' Q2 }4 c% v# F
51. 50          read(fd, &key_val, sizeof(int));
    # ]1 ]. j& A7 Y1 R( C: O$ r: H2 l9 y
52. 51          if (0 == key_val)
    
53. 52              printf("Key Press\n");
    ; u- b8 }) E. v1 M
54. 53          else if (1 == key_val)
    , s2 e' d) j( P: Z# _
55. 54              printf("Key Release\n");
    ! k6 [; J5 G# ?7 g4 `
56. 55      }
    % J# }3 ]$ i' S& T
57. 56
    % _7 U8 H1 g. u& c/ h+ d! ]9 X
58. 57      /* 关闭设备 */
    $ a2 R! a+ S* S% k. {. E  p, `
59. 58      close(fd);
    
60. 59      return 0;
    
61. 60  }

复制代码

第48~55行使用for循环不断的读取按键值，如果读取到的值是0则打印“Key Press”字符串，而过读取到的值是1则打印“Key Release”字符串。
. r6 s6 u: d+ R# M
31.4 运行测试
31.4.1 编译驱动程序和测试APP
: A8 z. m2 G7 |* x4 ^2 x; E) i1、编译驱动程序
编写Makefile文件，本章实验的Makefile文件和第四十章实验基本一样，只是将obj-m变量的值改为keyirq.o，Makefile内容如下所示：
' j% G/ m0 v  C% d3 Z) i; P# |

1. 示例代码31.4.1.1 Makefile文件
   * z4 \# x4 a; M, q- p2 L
2. 1  KERNELDIR := /home/zuozhongkai/linux/my_linux/linux-5.4.31
   
3. ......
   
4. 4  obj-m := keyirq.o
   ; l; Z* _# m  A3 q8 F8 I# C# l
5. ......
   
6. 11 clean:
   / g0 C( A7 Z6 W3 i0 F/ m3 F
7. 12  $(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean

复制代码

第4行，设置obj-m变量的值为keyirq.o。
) H* {; s( K, }. q7 i3 x输入如下命令编译出驱动模块文件：
make -j32
, g3 i6 i8 x  p8 [! a编译成功以后就会生成一个名为“keyirq.ko”的驱动模块文件。
2、编译测试APP
输入如下命令编译测试keyirqApp.c这个测试程序：
( \  N2 N6 d5 I: s& `7 K0 O7 ]arm-none-linux-gnueabihf-gcc keyirqApp.c -o keyirqApp
编译成功以后就会生成keyirqApp这个应用程序。
; X1 z9 h# s# V( m  X9 w31.4.2 运行测试
; W$ ~/ C/ b( z: p% y, |5 k2 R1 z将上一小节编译出来keyirq.ko和keyirqApp这两个文件拷贝到rootfs/lib/modules/5.4.31目录中，重启开发板，进入到目录lib/modules/5.4.31中，输入如下命令加载keyirq.ko驱动模块：
depmod //第一次加载驱动的时候需要运行此命令
modprobe keyirq.ko //加载驱动
& }6 H) w" g4 k9 z/ L驱动加载成功以后可以通过查看/proc/interrupts文件来检查一下对应的中断有没有被注册上，输入如下命令：
# Y, U) E  `* d/ r4 C/ a8 wcat /proc/interrupts
* L4 w+ \! ~! h9 g结果如图51.4.2.1所示：



图31.4.2.1 proc/interrupts文件内容
从图31.4.2.1可以看出keyirq.c驱动文件里面的KEY0中断已经存在了，触发方式为跳边沿(Edge)。
接下来使用如下命令来测试中断：
./keyirqApp /dev/key
按下开发板上的KEY0键，终端就会输出按键值，如图31.4.2.2所示：


0 o" r/ A/ d' i- y9 A: z; j/ ]
图31.4.2.2 读取到的按键值
" j/ \+ S) o' A. R/ `$ B————————————————
版权声明：正点原子
% V7 a& x8 J4 I* r7 ~
- Q6 X# ?5 K  k0 h