51 linux 中断

STM32 中断系统回顾

• 中断向量
  中断服务程序的入口地址或存放中断服务程序的首地址。

• 中断向量表
  是一个表，表里面存放的是中断向量。
  是一系列 中断服务程序入口地址 组成的表。

• 这些中断服务程序(函数)在中断向量表中的位置是由 半导体厂商 定好的，当某个中断被触发以后就会自动跳转到中断向量表中对应的中断服务程序(函数)入口地址处。
  中断向量表在整个程序的最前面，比如 STM32F103 的中断向量表如下所示：

__Vectors DCD __initial_sp ; Top of Stack
DCD Reset_Handler ; Reset Handler
DCD NMI_Handler ; NMI Handler
DCD HardFault_Handler ; Hard Fault Handler
DCD MemManage_Handler ; MPU Fault Handler
DCD BusFault_Handler ; Bus Fault Handler
DCD UsageFault_Handler ; Usage Fault Handler
DCD 0 ; Reserved
DCD 0 ; Reserved
DCD 0 ; Reserved
DCD 0 ; Reserved
DCD SVC_Handler ; SVCall Handler
DCD DebugMon_Handler ; Debug Monitor Handler
DCD 0 ; Reserved
DCD PendSV_Handler ; PendSV Handler
DCD SysTick_Handler ; SysTick Handler

; External Interrupts
DCD WWDG_IRQHandler ; Window Watchdog
DCD PVD_IRQHandler ; PVD through EXTI Line detect
DCD TAMPER_IRQHandler ; Tamper
DCD RTC_IRQHandler ; RTC
DCD FLASH_IRQHandler ; Flash

/* 省略掉其它代码 */

DCD DMA2_Channel4_5_IRQHandler ; DMA2 Channel4 & l5
__Vectors_End

• 上面的代码块STM32F103 的中断向量表，中断向量表都是链接到代码的最前面。
  比如一般 ARM 处理器都是从地址 0X00000000 开始执行指令的，那么 中断向量表 就是从 0X00000000 开始存放的。
  示例代码中第 1 行的 __initial_sp 就是第一条中断向量，存放的是栈顶指针，接下来是第 2 行复位中断复位函数 Reset_Handler 的入口地址，依次类推，直到第 27 行的最后一个中断服务函数 DMA2_Channel4_5_IRQHandler 的入口地址，这样 STM32F103 的中断向量表就建好了。
• ARM 处理器都是从地址 0X00000000 开始运行的，但是我们学习 STM32 的时候代码是下载到 0X8000000 开始的存储区域中。因此中断向量表是存放到 0X8000000 地址处的，而不是 0X00000000，这样不是就出错了吗？
  为了解决这个问题， Cortex-M 架构引入了一个新的概念——中断向量表偏移，通过中断向量表偏移就可以将中断向量表存放到任意地址处
  中断向量表偏移配置 在函数 SystemInit 中完成，通过向 SCB_VTOR 寄存器写入新的中断向量表首地址即可。代码如下所示：
  

void SystemInit (void)
{
	RCC->CR |= (uint32_t)0x00000001;

	/* 省略其它代码 */

#ifdef VECT_TAB_SRAM
	SCB->VTOR = SRAM_BASE | VECT_TAB_OFFSET;
#else
	SCB->VTOR = FLASH_BASE | VECT_TAB_OFFSET;
#endif
}

• 第 8 行和第 10 行就是设置中断向量表偏移。
  第 8 行是将中断向量表设置到 RAM 中。
  第 10 行是将中断向量表设置到 ROM 中（基本都是将中断向量表设置到 ROM 中，也就是地址0X8000000 处）
  第 10 行用到了 FALSH_BASE 和 VECT_TAB_OFFSET，这两个都是宏，定义如下所示：

#define FLASH_BASE ((uint32_t)0x08000000)
#define VECT_TAB_OFFSET 0x0

• 因此第 10 行的代码就是： SCB->VTOR=0X080000000，中断向量表偏移设置完成。
  通过上面的讲解我们了解了两个跟 STM32 中断有关的概念：中断向量表和中断向量表偏移。
  I.MX6U 所使用的 Cortex-A7 内核也有中断向量表和中断向量表偏移，而且其含义和 STM32 是一模一样的！只是用到的寄存器不同而已，概念完全相同！
• NVIC(内嵌向量中断控制器)
  中断系统得有个管理机构，对于 STM32 这种 Cortex-M 内核的单片机来说这个管理机构叫做 NVIC ，全称叫做 Nested Vectored Interrupt Controller。
  I.MX6U 所使用的 Cortex-A7 内核也有个中断系统管理机构，不过 Cortex-A 内核的中断管理机构不叫做NVIC，而是叫做 GIC ，全称是 general interrupt controller，后面我们会详细的讲解 Cortex-A 内核的 GIC。

一、裸机中断和linux中断对比

• 裸机中断
  1、使能中断，初始化相应的寄存器。
  2、注册中断服务函数，也就是向 irqTable 数组的指定标号处写入中断服务函数
  3、中断发生以后进入 IRQ 中断服务函数，在 数组 irqTable 里面查找具体的中断处理函数，找到以后执行相应的中断处理函数。
• linux中断（Linux 内核提供了完善的中断框架，我们只需要申请中断，然后注册中断处理函数即可）
  1、确定要使用的中断对应的 中断号（一个int变量），一般从设备树中获得。
  2、申请中断（基于中断号去申请），绑定中断处理函数 request_irq，此函数也会激活中断
  3、使用完中断后需要使用 free_irq 来释放中断
  4、中断处理函数 irqreturn_t (*irq_handler_t) (int, void *)
  5、使能和禁止中断

二、linux 中断相关概念

• 中断号（中断线）
  int型，每个中断都有一个中断号，通过中断号即可区分不同的中断

• request_irq 函数
  用于申请中断、绑定中断处理函数
  可能会导致睡眠，因此不能在中断上下文或者其他禁止睡眠的代码段中使用 request_irq 函数
  会自动激活(使能)中断，所以不需要我们再手动去使能中断

int request_irq(unsigned int irq,
				irq_handler_t handler,
				unsigned long flags,
				const char *name,
				void *dev)
irq：    要申请中断的中断号。可从设备树获得
handler：中断处理函数，当中断发生以后就会执行此中断处理函数。
flags：	 中断标志，可以在文件 include/linux/interrupt.h 里面查看所有的中断标志
			这些标志可以通过“|”来实现多种组合
name：   中断名字，设置以后可以在/proc/interrupts 文件中看到对应的中断名字。
dev： 	 如果将 flags 设置为 IRQF_SHARED 的话， dev 用来区分不同的中断，一般情况下将
			dev 设置为设备结构体地址， dev 会传递给中断处理函数 irq_handler_t 的第二个参数。
返回值：  
		0 	中断申请成功
		其他负值		中断申请失败，如果返回-EBUSY 的话表示中断已经
				被申请了。

IRQF_SHARED	多个设备共享一个中断号 / 线，共享的所有中断都必须指定此标志。如果使用共享中断的话， request_irq 函数的 dev 参数就是唯一区分他们的标志。使用此中断的是哪个设备
IRQF_ONESHOT	单次中断，中断执行一次就结束。
IRQF_TRIGGER_NONE	无触发。
IRQF_TRIGGER_RISING	上升沿触发。
IRQF_TRIGGER_FALLING	下降沿触发。
IRQF_TRIGGER_HIGH	高电平触发。
IRQF_TRIGGER_LOW	低电平触发。

• free_irq 函数
  使用中断的时候需要通过 request_irq 函数申请，使用完成以后就要通过 free_irq 函数释放掉相应的中断。
  如果中断不是共享的，那么 free_irq 会删除中断处理函数并且禁止中断

void free_irq( unsigned int irq,
			   void *dev)
irq： 要释放的中断号。
dev： 如果中断设置为共享(IRQF_SHARED)的话，此参数用来区分具体的中断。
		共享中断只有在释放最后中断处理函数的时候才会被禁止掉

• 中断处理函数
  使用 request_irq 函数申请中断的时候需要设置中断处理函数

irqreturn_t (*irq_handler_t) (int, void *)
第一个参数是中断处理函数相应的中断号。
第二个参数是一个指向 void 的指针，也就是个通用指针，
			需要与 request_irq 函数的 dev 参数保持一致
			用于区分共享中断的不同设备
中断处理函数的返回值为 irqreturn_t 类型， irqreturn_t 类型定义
			如下所示
			一般中断服务函数返回值使用如下形式：
			return IRQ_RETVAL(IRQ_HANDLED)

enum irqreturn {
 IRQ_NONE = (0 << 0),
 IRQ_HANDLED = (1 << 0),
 IRQ_WAKE_THREAD = (1 << 1),
 };

typedef enum irqreturn irqreturn_t;

• 中断使能与禁止函数

void enable_irq(unsigned int irq)
void disable_irq(unsigned int irq)

用于使能和禁止指定的中断， irq 就是要禁止的中断号
disable_irq 要等到当前正在执行的中断处理函数执行完
才返回，因此使用者需要保证不会产生新的中断，并且确保
所有已经开始执行的中断处理程序已经全部退出

void disable_irq_nosync(unsigned int irq)

disable_irq_nosync 函数调用以后立即返回，
不会等待当前中断处理程序执行完毕。上面三
个函数都是使能或者禁止某一个中断

local_irq_enable()
local_irq_disable()

local_irq_enable 用于使能当前处理器中断系统
local_irq_disable 用于禁止当前处理器中断系统。

local_irq_save(flags)
local_irq_restore(flags)

local_irq_save 函数用于禁止中断，并且将中断状态保存在 flags 中。
local_irq_restore 用于恢复中断，将中断到 flags 状态。

• 上半部 和 下半部
  在使用 request_irq 申请中断的时候注册的 中断服务函数 属于中断处理的 上半部，只要中断触发，那么中断处理函数就会执行.
  中断处理函数一定要越短越好。
  有些中断处理过程就是比较费时间，我们必须要对其进行处理，缩小中断处理函数的执行时间
  中断处理函数仅仅响应中断，然后清除中断标志位即可。这个时候中断处理过程就分为了两部分：
  上半部：上半部就是 中断处理函数 ，那些处理过程比较快，不会占用很长时间的处理就可以放在上半部完成。中断处理函数即上半部尽量做到快进快出。
  下半部：如果中断处理过程比较耗时，那么就将这些比较耗时的代码提出来，交给下半部去执行
  主要目的就是实现中断处理函数的快进快出，耗时长的工作都可以放到下半部去执行，比如在上半部将数据拷贝到内存中，关于数据的具体处理就可以放到下半部去执行。

软中断（下半部的实现方法）

• Linux 内核使用结构体 softirq_action 表示软中断， softirq_action 结构体定义在文件 include/linux/interrupt.h

 struct softirq_action
 {
 	void (*action)(struct softirq_action *);
 };

• 在 kernel/softirq.c 文件中一共定义了 10 个软中断，如下所示：

static struct softirq_action softirq_vec[NR_SOFTIRQS];

enum
{
HI_SOFTIRQ=0, /* 高优先级软中断 */
TIMER_SOFTIRQ, /* 定时器软中断 */
NET_TX_SOFTIRQ, /* 网络数据发送软中断 */
NET_RX_SOFTIRQ, /* 网络数据接收软中断 */
BLOCK_SOFTIRQ,
BLOCK_IOPOLL_SOFTIRQ,
TASKLET_SOFTIRQ, /* tasklet 软中断 */
SCHED_SOFTIRQ, /* 调度软中断 */
HRTIMER_SOFTIRQ, /* 高精度定时器软中断 */
RCU_SOFTIRQ, /* RCU 软中断 */
NR_SOFTIRQS
};

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

• 要使用软中断，必须先使用 open_softirq 函数注册对应的软中断处理函数， open_softirq 函数原型如下：

void open_softirq(int nr, void (*action)(struct softirq_action *))

nr：要开启的软中断，在示例代码 51.1.2.3 中选择一个。
action：软中断对应的处理函数。
返回值： 没有返回值。

• 注册好软中断以后需要通过 raise_softirq 函数触发， raise_softirq 函数原型如下：

void raise_softirq(unsigned int nr)

nr：要触发的软中断，在示例代码 51.1.2.3 中选择一个。
返回值： 没有返回值。

• 软中断必须在编译的时候静态注册！ Linux 内核使用 softirq_init 函数初始化软中断， softirq_init 函数定义在 kernel/softirq.c 文件里面，函数内容如下：

634 void __init softirq_init(void)
635 {
636 int cpu;
637
638 for_each_possible_cpu(cpu) {
639 per_cpu(tasklet_vec, cpu).tail =
640 &per_cpu(tasklet_vec, cpu).head;
641 per_cpu(tasklet_hi_vec, cpu).tail =
642 &per_cpu(tasklet_hi_vec, cpu).head;
643 }
644
645 open_softirq(TASKLET_SOFTIRQ, tasklet_action);
646 open_softirq(HI_SOFTIRQ, tasklet_hi_action);
	//softirq_init 函数默认会打开 TASKLET_SOFTIRQ 和 HI_SOFTIRQ
647 }

tasklet

• 利用软中断来实现的另外一种下半部机制，在软中断和 tasklet 之间，建议使用 tasklet。

• Linux 内核使用结构体

 struct tasklet_struct
 {
 	struct tasklet_struct *next; /* 下一个 tasklet */
	unsigned long state; /* tasklet 状态 */
	atomic_t count; /* 计数器，记录对 tasklet 的引用数 */
	void (*func)(unsigned long); /* tasklet 执行的函数 */
	unsigned long data; /* 函数 func 的参数 */
 };

第 6 行的 func 函数 是 tasklet 要执行的处理函数，用户定义函数内容，相当于中断处理函数。
如果要使用 tasklet，必须先定义一个 tasklet 结构体变量，然后使用 tasklet_init 函数 初始化 tasklet，

taskled_init 函数原型如下：

void tasklet_init(struct tasklet_struct *t,
				void (*func)(unsigned long),
				unsigned long data);
t：要初始化的 tasklet
func： tasklet 的处理函数。
data： 要传递给 func 函数的参数

• 也 可 以 使 用 宏 DECLARE_TASKLET 来 一 次 性 完 成 tasklet 的 定 义 和 初 始 化 ，DECLARE_TASKLET 定义在 include/linux/interrupt.h 文件中，定义如下:

DECLARE_TASKLET(name, func, data)
name 为要定义的 tasklet 名字，这个名字就是一个 tasklet_struct 类型的时候变量
func 就是 tasklet 的处理函数
data 是传递给 func 函数的参数。

• 在上半部，也就是中断处理函数中调用 tasklet_schedule 函数就能使 tasklet 的处理函数（下半部）运行
  tasklet_schedule 函数原型如下：

void tasklet_schedule(struct tasklet_struct *t)

t：要调度的 tasklet，也就是 DECLARE_TASKLET 宏里面的 name。
返回值： 没有返回值

• 也需要用到上半部，只是上半部的中断处理函数中调用 tasklet_schedule 函数就能使 tasklet 在合适的时间运行
  1、定义一个 tasklet
  2、初始化 tasklet，重点是设置对应的处理函数，一般在驱动入口函数里面做这个

• 工作队列

设备树读取中断信息

• 如果使用设备树的话就需要在设备树中设置好中断属性信息， Linux 内核通过读取设备树中 的 中 断 属 性 信 息 来 配 置 中 断 。 对 于 中 断 控 制 器 而 言 ， 设 备 树 绑 定 信 息 参 考 文 档Documentation/devicetree/bindings/arm/gic.txt。打开 imx6ull.dtsi 文件，其中的 intc 节点就是 I.MX6ULL 的中断控制器节点，节点内容如下所示：

intc: interrupt-controller@00a01000 {
		compatible = "arm,cortex-a7-gic";
		#interrupt-cells = <3>;
		interrupt-controller;
		reg = <0x00a01000 0x1000>,
		      <0x00a02000 0x100>;
	};

• 第 2 行， compatible 属性值为“arm,cortex-a7-gic”在 Linux 内核源码中搜索“arm,cortex-a7-g

• 第 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 中断来说中断号的范围为 0~987，对于 PPI 中断来说中断号的范围为 0 ~15。
  第三个 cells：标志， bit[3:0]表示中断触发类型，为 1 的时候表示上升沿触发，为 2 的时候表示下降沿触发，为 4 的时候表示高电平触发，为 8 的时候表示低电平触发。 bit[15:8]为 PPI 中断的 CPU 掩码。
  第 4 行， interrupt-controller 节点为空，表示当前节点是中断控制器。

• 对于 gpio 来说， gpio 节点也可以作为中断控制器，比如 imx6ull.dtsi 文件中的 gpio5 节点内容如下所示：

gpio5: gpio@020ac000 {
				compatible = "fsl,imx6ul-gpio", "fsl,imx35-gpio";
				reg = <0x020ac000 0x4000>;
				interrupts = <GIC_SPI 74 IRQ_TYPE_LEVEL_HIGH>,
					     <GIC_SPI 75 IRQ_TYPE_LEVEL_HIGH>;
				gpio-controller;
				#gpio-cells = <2>;
				interrupt-controller;
				#interrupt-cells = <2>;
			};

• 第 4 行， interrupts 描述中断源信息，对于 gpio5 来说一共有两条信息，中断类型都是 SPI，触发电平都是 IRQ_TYPE_LEVEL_HIGH。不同之处在于中断源，一个是 74，一个是 75，可以打开《IMX6ULL 参考手册》的“Chapter 3 Interrupts and DMA Events”章节，找到表 3-1，
  有如图 50.1.3.1 所示的内容：
  
  从图 50.1.3.1 可以看出， GPIO5 一共用了 2 个中断号，一个是 74，一个是 75。其中 74 对应 GPIO5_IO00 ~ GPIO5_IO15 这低 16 个 IO， 75 对应 GPIO5_IO16~ GPIOI5_IO31 这高 16 位 IO。
  第 8 行， interrupt-controller 表明了 gpio5 节点也是个中断控制器，用于控制 gpio5 所有 IO的中断。
  第 9 行，将#interrupt-cells 修改为 2

fxls8471@1e {
		compatible = "fsl,fxls8471";
		reg = <0x1e>;
		position = <0>;
		interrupt-parent = <&gpio5>;
		interrupts = <0 8>;
	};

interrupt-parent 指定父中断（属于 gpio5）
interrupts 第一个 cell 是 gpio pin 的编号，因此上面使用的就是 gpio5_io00
fxls8471 是 NXP 官方的 6ULL 开发板上的一个磁力计芯片， fxls8471 有一个中断引脚链接
到了 I.MX6ULL 的 SNVS_TAMPER0 因脚上，这个引脚可以复用为 GPIO5_IO00。
第 5 行， interrupt-parent 属性设置中断控制器，这里使用 gpio5 作为中断控制器。
第 6 行， interrupts 设置中断信息， 0 表示 GPIO5_IO00， 8 表示低电平触发。
简单总结一下与中断有关的设备树属性信息：
①、 #interrupt-cells，指定中断源的信息 cells 个数。
②、 interrupt-controller，表示当前节点为中断控制器。
③、 interrupts，指定中断号，触发方式等。
④、 interrupt-parent，指定父中断，也就是中断控制器。

获取中断号

编写驱动的时候需要用到中断号，我们用到中断号，中断信息已经写到了设备树里面，因
此可以通过 irq_of_parse_and_map 函数从 interupts 属性中提取到对应的设备号，函数原型如下：

unsigned int irq_of_parse_and_map(struct device_node *dev,
									int index)
获取外设/gpio 中断号
函数参数和返回值含义如下：
dev： 设备节点。
index：索引号， interrupts 属性可能包含多条中断信息，通过 index 指定要获取的信息。
返回值：中断号。

如果使用 GPIO 的话，可以使用 gpio_to_irq 函数来获取 gpio 对应的中断号，函数原型如
下：

int gpio_to_irq(unsigned int gpio)
获取gpio中断号
函数参数和返回值含义如下：
gpio： 要获取的 GPIO 编号。
返回值： GPIO 对应的中断号。

编写驱动

• 1、

#include<linux/module.h>
#include<linux/kernel.h>
#include<linux/init.h>
#include <linux/fs.h>
#include<linux/slab.h>
#include<linux/io.h>
#include<linux/uaccess.h>
#include<linux/cdev.h>
#include<linux/device.h>
#include<linux/of.h>
#include<linux/of_address.h>
#include<linux/of_irq.h>
#include<linux/gpio.h>
#include<linux/of_gpio.h>
#include<linux/atomic.h>
#include<linux/timer.h>
#include<linux/string.h>
#include<linux/jiffies.h>
#include<linux/irq.h>
#include<asm/mach/map.h>
#include<asm/uaccess.h>
#include<asm/io.h>
#include<linux/interrupt.h>

#define     IRQ_CNT             1
#define     IMX6ULIRQ_NAME      "imx6ulirq"
#define     KEY_NUM             1
#define     KEY0_ACTIVE         1
#define     KEY0_INACTIVE       2

// 按键结构体
struct irq_keydesc
{
    int gpio;   //gpio号
    int irqnum; //中断号
    u8 value;   //键值
    char name[8];//名字
    irqreturn_t (*handler)(int, void *);// 中断处理函数
    									// 第二个参数由 request_irq 最后一个
    									// 参数决定
};

struct imx6ulirq_dev
{
    dev_t devid;
    u32 major;
    u32 minor;
    struct cdev cdev;
    struct class *class;
    struct device *device;
    struct device_node *nd;
    int led_gpio;
    int beep_gpio;
    struct timer_list timer;
    int timer_period;
    struct irq_keydesc irqkey;

};

struct imx6ulirq_dev imx6ulirq;

static int imx6ulirq_open(struct inode *inode, struct file *filp);
static int imx6ulirq_release(struct inode *inode, struct file *filp);
static ssize_t imx6ulirq_read(struct file *file, 
								char __user *buf, 
								size_t count,
			            		loff_t *ppos);

static const struct file_operations imx6ulirq_fops = 
{
    .owner = THIS_MODULE,
    .open = imx6ulirq_open,
    .read = imx6ulirq_read,
    .release = imx6ulirq_release, 
};

static int imx6ulirq_open(struct inode *inode, struct file *filp)
{
    filp->private_data = &imx6ulirq;
    return 0;
}

static ssize_t imx6ulirq_read(struct file *file, char __user *buf, size_t count,
			            loff_t *ppos)
{
    return 0;  
}

static int imx6ulirq_release(struct inode *inode, struct file *filp)
{
    return 0;
}


// 按键中断处理函数
// 第二个参数是 自定义设备结构体指针
static irqreturn_t key0_handler(int irq, void *dev_id)
{
    struct imx6ulirq_dev *dev = dev_id;
	// 开启定时器
	// 此数值将传递给 timer_func
    dev->timer.data = (u32 )dev_id;
    mod_timer(&dev->timer, jiffies+msecs_to_jiffies(10));

    return IRQ_HANDLED;
}

static int key_init(struct imx6ulirq_dev *dev)
{
    int ret = 0;
   // 1.按键gpio初始化
    dev->nd = of_find_node_by_path("/gpiokey");
    if(dev->nd == NULL)
    {
        ret = -1;
        printk("%s(%d):fail\n", __FILE__, __LINE__);
        goto fail_nd;
    }

    dev->irqkey.gpio = of_get_named_gpio(dev->nd, 
                                          "key-gpios", // 设备树中的名称一致
                                           0 );
    if(dev->irqkey.gpio < 0)
    {
    	ret = -1;
   		goto fail_gpio;
    }
    
    memset(dev->irqkey.name, 0, sizeof(dev->irqkey.name));
    ret = gpio_request(dev->irqkey.gpio, dev->irqkey.name);
    if(ret)
    {
    	ret = -1;
    	goto fail_request;
    }
    gpio_direction_input(dev->irqkey.gpio);

        // 获取中断号
#if 1
        dev->irqkey.irqnum = gpio_to_irq(dev->irqkey.gpio);
#else
        dev->irqkey.irqnum = irq_of_parse_and_map(dev->nd, i);
#endif
        dev->irqkey.handler = key0_handler;
        dev->irqkey.value = KEY0_ACTIVE;
    }

   // 2.按键中断初始化
    ret = request_irq(dev->irqkey.irqnum, 
                            dev->irqkey.handler,
                            IRQF_TRIGGER_RISING|IRQF_TRIGGER_FALLING,
                            dev->irqkey.name, //中断名字，设置以后可以在/proc/interrupts 文件中看到对应的中断名字。
                            &imx6ulirq ); // 此参数会传递给中断处理函数第二个参数
     if(ret)
     {
     	printk("irq %d request failed\n", dev->irqkey.irqnum);
        free_irq(dev->irqkey.irqnum, NULL);
        ret = -1;
        goto fail_irq;
     }
    
    return 0;

fail_irq:
	gpio_free(dev->irqkey.gpio);
fail_request:
fail_gpio:
fail_nd:
    return ret;
}

// 超时处理函数
// 参数由 timer_list 结构体的成员变量决定
static void timer_func(unsigned long arg)
{
    int value = 0;
    struct imx6ulirq_dev *dev = (void *)arg;

    value = gpio_get_value(dev->irqkey[0].gpio);
    if(value == 0) // 按下
    {
        printk("%s(%d):KEY0 PUSHED \n", __FILE__, __LINE__);
    }
    else if(value == 1)// 释放
    {
        printk("%s(%d):KEY0 RELEASED \n", __FILE__, __LINE__);
    }
}

static int __init imx6ulirq_init(void)
{
    int ret = 0;

    //1
    imx6ulirq.major = 0;
    if(imx6ulirq.major)
    {
        imx6ulirq.devid = MKDEV(imx6ulirq.major, 0);
        ret = register_chrdev_region(imx6ulirq.devid, 1, IMX6ULIRQ_NAME);
    }
    else
    {
        ret = alloc_chrdev_region(&imx6ulirq.devid, 0, 1, IMX6ULIRQ_NAME);
        imx6ulirq.major = MAJOR(imx6ulirq.devid);
        imx6ulirq.minor = MAJOR(imx6ulirq.devid);
    }
    if(ret < 0)
    {
        printk("%s(%d):fail\n", __FILE__, __LINE__);
        goto fail_devid;
    }

    //2
    imx6ulirq.cdev.owner = THIS_MODULE;
    cdev_init(&imx6ulirq.cdev, &imx6ulirq_fops);
    ret = cdev_add(&imx6ulirq.cdev, imx6ulirq.devid, 1);
    if(ret < 0)
    {
        printk("%s(%d):fail\n", __FILE__, __LINE__);
        goto fail_cdev;
    }

    //3
    imx6ulirq.class = class_create(THIS_MODULE, IMX6ULIRQ_NAME);
    if(IS_ERR(imx6ulirq.class))
    {
        printk("%s(%d):fail\n", __FILE__, __LINE__);
        ret = PTR_ERR(imx6ulirq.class);
        goto fail_class;
    }

    imx6ulirq.device = device_create(imx6ulirq.class, NULL, imx6ulirq.devid, NULL, IMX6ULIRQ_NAME);
    if(IS_ERR(imx6ulirq.device))
    {
        printk("%s(%d):fail\n", __FILE__, __LINE__);
        ret = PTR_ERR(imx6ulirq.device);
        goto fail_device;
    }

    //4
    ret = key_init(&imx6ulirq);
    if(ret < 0)
    {
        goto fail_keyinit;
    }

    init_timer(&imx6ulirq.timer);
    imx6ulirq.timer.function = timer_func;

    return 0;

    printk("%s(%d):fail\n", __FILE__, __LINE__);
fail_keyinit:
	device_destroy(imx6ulirq.class, imx6ulirq.device);
fail_device:
    class_destroy(imx6ulirq.class);
fail_class:
    cdev_del(&imx6ulirq.cdev);
fail_cdev:
    unregister_chrdev_region(imx6ulirq.devid, 1);
fail_devid:
    printk("%d:---------------\r\n", __LINE__);
    return ret;

}

static void __exit imx6ulirq_exit(void)
{
    // 释放中断
    // 第一个参数是中断号，第二个参数一般是自定义设备结构体指针
  	free_irq(imx6ulirq.irqkey.irqnum, NULL);
    // 释放gpio
    gpio_free(imx6ulirq.irqkey.gpio);
    // 删除定时器
    del_timer_sync(&imx6ulirq.timer);
    cdev_del(&imx6ulirq.cdev);
    unregister_chrdev_region(imx6ulirq.devid, IRQ_CNT);
    device_destroy(imx6ulirq.class, imx6ulirq.devid);
    class_destroy(imx6ulirq.class);

}

module_init(imx6ulirq_init);
module_exit(imx6ulirq_exit);
MODULE_LICENSE("GPL");

• 2、tasklet组成下半部
  初始化按键（完成对key这个gpio的初始化，获取中断号，设置上半部函数，申请中断，注册tasklet处理函数）
  初始化定时器
  按下按键，进入按键中断上半部，上半部中调用 tasklet_schedule进入下半部，下半部开启定时器计时，进入超时处理函数读取gpio值

#include<linux/module.h>
#include<linux/kernel.h>
#include<linux/init.h>
#include <linux/fs.h>
#include<linux/slab.h>
#include<linux/io.h>
#include<linux/uaccess.h>
#include<linux/cdev.h>
#include<linux/device.h>
#include<linux/of.h>
#include<linux/of_address.h>
#include<linux/of_irq.h>
#include<linux/gpio.h>
#include<linux/of_gpio.h>
#include<linux/atomic.h>
#include<linux/timer.h>
#include<linux/jiffies.h>
#include<linux/interrupt.h>

#define     IRQ_CNT         1
#define     IMX6ULIRQ_NAME  "imx6ulirq"
#define     KEY0_ACTIVE     1
#define     KEY0_INACTIVE   2

struct irq_keydesc
{
    int gpio;
    int irqnum;
    u8 value;
    char name[8];
    irqreturn_t (*handler )(int, void *);
    struct tasklet_struct tasklet;
};

struct imx6ulirq_dev
{
    dev_t devid;
    u32 major;
    u32 minor;
    struct cdev cdev;
    struct class *class;
    struct device *device;
    struct device_node *nd;
    struct irq_keydesc irqkey;
    struct timer_list timer;
    int timer_period;
};

struct imx6ulirq_dev imx6ulirqdev;

static int imx6ulirq_open(struct inode *inode, struct file *filp);
static int imx6ulirq_release(struct inode *inode, struct file *filp);
static irqreturn_t key0_handler(int irq, void *dev1);
static void key_tasklet(unsigned long data);

static const struct file_operations imx6ulirqdev_fops = 
{
    .owner = THIS_MODULE,
    .open = imx6ulirq_open,
    .release = imx6ulirq_release, 
};

static int imx6ulirq_open(struct inode *inode, struct file *filp)
{
    filp->private_data = &imx6ulirqdev;
    return 0;
}

static int imx6ulirq_release(struct inode *inode, struct file *filp)
{
    return 0;
}

static int key_init(struct imx6ulirq_dev *dev)
{
    int ret = 0;
    // 1.
    dev->nd = of_find_node_by_path("/gpiokey");
    if(NULL == dev->nd)
    {
        printk("%s(%d):fail\n", __FILE__, __LINE__);
        ret = -1;
        goto fail_nd;
    }
    // 2.
    dev->irqkey.gpio = of_get_named_gpio(dev->nd, "key-gpios", 0);
    if(dev->irqkey.gpio < 0)
    {
        ret = -1;
        printk("%s(%d):fail\n", __FILE__, __LINE__);
        goto fail_gpio;
    }
    // 3.
    memset(dev->irqkey.name, 0, sizeof(dev->irqkey.name));
    memcpy(dev->irqkey.name,"key_0", strlen("key_0"));
    ret = gpio_request(dev->irqkey.gpio, dev->irqkey.name);
    if(ret)
    {
        ret = -1;
        printk("%s(%d):fail\n", __FILE__, __LINE__);
        goto fail_request;
    }
    // 4.
    ret = gpio_direction_input(dev->irqkey.gpio);
    if(ret)
    {
        ret = -1;
        printk("%s(%d):fail\n", __FILE__, __LINE__);
        goto fail_setdir;
    }
    // 5.
#if 1
    dev->irqkey.irqnum = gpio_to_irq(dev->irqkey.gpio);
#else
    dev->irqkey.irqnum = irq_of_parse_and_map(dev->nd, 0);
#endif
    dev->irqkey.handler = key0_handler;
    dev->irqkey.value = KEY0_INACTIVE;
    ret = request_irq(dev->irqkey.irqnum,
                        dev->irqkey.handler,
                        IRQF_TRIGGER_RISING|IRQF_TRIGGER_FALLING,
                        dev->irqkey.name,//中断名字，可以在 /proc/interrupts 中看见
                        &imx6ulirqdev);//此参数会传递给中断处理函数第二个参数
    if(ret < 0)
    {
        ret = -1;
        printk("%s(%d):fail\n", __FILE__, __LINE__);
        goto fail_irq;
    }
    // 第3个参数dev 将传递给 tasklet执行函数 key_tasklet
    tasklet_init(&dev->irqkey.tasklet, key_tasklet, (u32 )dev);

    return 0;

fail_irq:
fail_setdir:
    gpio_free(dev->irqkey.gpio);
fail_request:
fail_gpio:
fail_nd:
    return ret;
}

static irqreturn_t key0_handler(int irq, void *dev1)
{
    struct imx6ulirq_dev *dev = dev1;
	// 上半部调用此函数，tasklet执行函数key_tasklet将会执行
    tasklet_schedule(&dev->irqkey.tasklet);

    return IRQ_HANDLED;
}

// 此函数的参数将由 tasklet_init 第3个参数决定
static void key_tasklet(unsigned long data)
{
    struct imx6ulirq_dev *dev = (void *)data;
    dev->timer.data = data;
    mod_timer(&dev->timer, jiffies+msecs_to_jiffies(10));
}

// 此函数的参数由 timer_list 结构体中的成员变量决定
static void timer_func(unsigned long arg)
{
    int val = 0;
    printk("%d:---------------\r\n", __LINE__);
    struct imx6ulirq_dev *dev = (void *)arg;
    val = gpio_get_value(dev->irqkey.gpio);
    if(0 == val)
    {
        printk("Pushed.\n");
    }
    else if(1 == val)
    {
        printk("Released.\n");
    }
}


static int __init imx6ulirq_init(void)
{
    int ret = 0;

    // 1.
    imx6ulirqdev.major = 0;
    if(imx6ulirqdev.major)
    {
        imx6ulirqdev.devid = MKDEV(imx6ulirqdev.major, 0);
        ret = register_chrdev_region(imx6ulirqdev.devid, 1, IMX6ULIRQ_NAME);
    }
    else
    {
        ret = alloc_chrdev_region(&imx6ulirqdev.devid, 0, 1, IMX6ULIRQ_NAME);
        imx6ulirqdev.major = MAJOR(imx6ulirqdev.devid);
        imx6ulirqdev.minor = MAJOR(imx6ulirqdev.devid);
    }
    if(ret < 0)
    {
        printk("%s(%d):fail\n", __FILE__, __LINE__);
        goto fail_devid;
    }

    //2
    imx6ulirqdev.cdev.owner = THIS_MODULE;
    cdev_init(&imx6ulirqdev.cdev, &imx6ulirqdev_fops);
    ret = cdev_add(&imx6ulirqdev.cdev, imx6ulirqdev.devid, 1);
    if(ret < 0)
    {
        printk("%s(%d):fail\n", __FILE__, __LINE__);
        goto fail_cdev;
    }

    //3
    imx6ulirqdev.class = class_create(THIS_MODULE, IMX6ULIRQ_NAME);
    if(IS_ERR(imx6ulirqdev.class))
    {
        printk("%s(%d):fail\n", __FILE__, __LINE__);
        ret = PTR_ERR(imx6ulirqdev.class);
        goto fail_class;
    }

    imx6ulirqdev.device = device_create(imx6ulirqdev.class, 
                                    NULL, 
                                    imx6ulirqdev.devid, 
                                    NULL, 
                                    IMX6ULIRQ_NAME);
    if(IS_ERR(imx6ulirqdev.device))
    {
        printk("%s(%d):fail\n", __FILE__, __LINE__);
        ret = PTR_ERR(imx6ulirqdev.device);
        goto fail_device;
    }

    // 4.
    ret = key_init(&imx6ulirqdev);
    if(ret < 0)
    {
        printk("%s(%d):fail\n", __FILE__, __LINE__);
        goto fail_keyinit;
    }

    //5
    init_timer(&imx6ulirqdev.timer);
    imx6ulirqdev.timer.function = timer_func;
    imx6ulirqdev.timer.data = (unsigned long )&imx6ulirqdev;
    printk("%d:---------------\r\n", __LINE__);

    return 0;


fail_keyinit:
fail_device:
    class_destroy(imx6ulirqdev.class);
fail_class:
    cdev_del(&imx6ulirqdev.cdev);
fail_cdev:
    unregister_chrdev_region(imx6ulirqdev.devid, 1);
fail_devid:
    printk("%d:---------------\r\n", __LINE__);
    return ret;

}

static void __exit imx6ulirq_exit(void)
{
	// 释放中断
    free_irq(imx6ulirqdev.irqkey.irqnum, NULL);
    gpio_free(imx6ulirqdev.irqkey.gpio);
    // 删除定时器
    del_timer_sync(&imx6ulirqdev.timer);
    cdev_del(&imx6ulirqdev.cdev);
    unregister_chrdev_region(imx6ulirqdev.devid, IRQ_CNT);
    device_destroy(imx6ulirqdev.class, imx6ulirqdev.devid);
    class_destroy(imx6ulirqdev.class);
}

module_init(imx6ulirq_init);
module_exit(imx6ulirq_exit);
MODULE_LICENSE("GPL");

• 3、work

#include<linux/module.h>
#include<linux/kernel.h>
#include<linux/init.h>
#include <linux/fs.h>
#include<linux/slab.h>
#include<linux/io.h>
#include<linux/uaccess.h>
#include<linux/cdev.h>
#include<linux/device.h>
#include<linux/of.h>
#include<linux/of_address.h>
#include<linux/of_irq.h>
#include<linux/gpio.h>
#include<linux/of_gpio.h>
#include<linux/atomic.h>
#include<linux/timer.h>
#include<linux/string.h>
#include<linux/jiffies.h>
#include<linux/irq.h>
#include<asm/mach/map.h>
#include<asm/uaccess.h>
#include<asm/io.h>
#include<linux/interrupt.h>


#define     IRQ_CNT             1
#define     IMX6ULIRQ_NAME      "imx6ulirq"
#define     KEY_NUM             1
#define     KEY0_ACTIVE         1
#define     KEY0_INACTIVE       2

static ssize_t imx6ulirq_read(struct file *file, char __user *buf, size_t count,
			            loff_t *ppos);
// 按键结构体
struct irq_keydesc
{
    int gpio;   //gpio号
    int irqnum; //中断号
    u8 value;   //键值
    char name[8];//名字
    irqreturn_t (*handler)(int, void *);//中断处理函数 
    
};

struct imx6ulirq_dev
{
    dev_t devid;
    u32 major;
    u32 minor;
    struct cdev cdev;
    struct class *class;
    struct device *device;
    struct device_node *nd;
    int led_gpio;
    int beep_gpio;
    struct timer_list timer;
    int timer_period;
    struct irq_keydesc irqkey;
    struct work_struct work;
};

struct imx6ulirq_dev imx6ulirq;

static int imx6ulirq_open(struct inode *inode, struct file *filp);
static int imx6ulirq_release(struct inode *inode, struct file *filp);
static ssize_t imx6ulirq_read(struct file *file, 
								char __user *buf, 
								size_t count,
			            		loff_t *ppos)

static const struct file_operations imx6ulirq_fops = 
{
    .owner = THIS_MODULE,
    .open = imx6ulirq_open,
    .read = imx6ulirq_read,
    .release = imx6ulirq_release, 
};

static int imx6ulirq_open(struct inode *inode, struct file *filp)
{
    filp->private_data = &imx6ulirq;
    return 0;
}

static ssize_t imx6ulirq_read(struct file *file, char __user *buf, size_t count,
			            loff_t *ppos)
{
    return 0;
    
}

static int imx6ulirq_release(struct inode *inode, struct file *filp)
{
    return 0;
}


// 按键中断处理函数（上半部）
static irqreturn_t key0_handler(int irq, void *dev_id)
{
    
    struct imx6ulirq_dev *dev = dev_id;

    //tasklet_schedule(&dev->irqkey[0].tasklet);
    schedule_work(&dev->work);

    return IRQ_HANDLED;
}

// 下半部
static void key_work(struct work_struct *work)
{
    struct imx6ulirq_dev *dev = container_of(work, struct imx6ulirq_dev, work);
    printk("%s(%d)\n", __FILE__, __LINE__);
    dev->timer.data = (u32 )dev;
    mod_timer(&dev->timer, jiffies+msecs_to_jiffies(10));
}

static int key_init(struct imx6ulirq_dev *dev)
{
    int ret = 0;
   	// 1.按键gpio初始化
    dev->nd = of_find_node_by_path("/gpiokey");
    if(dev->nd == NULL)
    {
        ret = -1;
        printk("%s(%d):fail\n", __FILE__, __LINE__);
        goto fail_nd;
    }

   
	dev->irqkey.gpio = of_get_named_gpio(dev->nd, 
                                            "key-gpios",
                                             0 );
	if(dev->irqkey.gpio < 0)
	{
		ret = -1;
		goto fail_gpio;
	}
   

	memset(dev->irqkey.name, 0, sizeof(dev->irqkey.name));
	sprintf(dev->irqkey.name, "key_%d", i);
	ret = gpio_request(dev->irqkey.gpio, dev->irqkey.name);
	if(ret)
	{
		ret = -1;
		goto fail_request;
	}
	gpio_direction_input(dev->irqkey.gpio);

        // 获取中断号
#if 1
        dev->irqkey.irqnum = gpio_to_irq(dev->irqkey.gpio);
#else
        dev->irqkey.irqnum = irq_of_parse_and_map(dev->nd, i);
#endif
        dev->irqkey[0].handler = key0_handler;
        dev->irqkey[0].value = KEY0_ACTIVE;
  

   // 2.按键中断初始化
   ret = request_irq(dev->irqkey.irqnum, 
                            dev->irqkey.handler,
                            IRQF_TRIGGER_RISING|IRQF_TRIGGER_FALLING,
                            dev->irqkey.name,
                            &imx6ulirq ); // 作为中断处理函数的第二个参数
	if(ret)
	{
		free_irq(dev->irqkey.irqnum, NULL);
		ret = -1;
		goto fail_irq;
	}
      
    INIT_WORK(&dev->work, key_work);
    
    return 0;


fail_irq:
        gpio_free(dev->irqkey.gpio);

fail_request:
fail_gpio:
fail_nd:
    return ret;
}

// 超时处理函数由 timer_list 结构体里面的成员变量决定
static void timer_func(unsigned long arg)
{
    int value = 0;
    struct imx6ulirq_dev *dev = (void *)arg;

    value = gpio_get_value(dev->irqkey[0].gpio);
    if(value == 0) 
    {
        printk("%s(%d):KEY0 PUSHED \n", __FILE__, __LINE__);
    }
    else if(value == 1)
    {
        printk("%s(%d):KEY0 RELEASED \n", __FILE__, __LINE__);
    }
}

static int __init imx6ulirq_init(void)
{
    int ret = 0;

    //1
    imx6ulirq.major = 0;
    if(imx6ulirq.major)
    {
        imx6ulirq.devid = MKDEV(imx6ulirq.major, 0);
        ret = register_chrdev_region(imx6ulirq.devid, 1, IMX6ULIRQ_NAME);
    }
    else
    {
        ret = alloc_chrdev_region(&imx6ulirq.devid, 0, 1, IMX6ULIRQ_NAME);
        imx6ulirq.major = MAJOR(imx6ulirq.devid);
        imx6ulirq.minor = MAJOR(imx6ulirq.devid);
    }
    if(ret < 0)
    {
        printk("%s(%d):fail\n", __FILE__, __LINE__);
        goto fail_devid;
    }

    //2
    imx6ulirq.cdev.owner = THIS_MODULE;
    cdev_init(&imx6ulirq.cdev, &imx6ulirq_fops);
    ret = cdev_add(&imx6ulirq.cdev, imx6ulirq.devid, 1);
    if(ret < 0)
    {
        printk("%s(%d):fail\n", __FILE__, __LINE__);
        goto fail_cdev;
    }

    //3
    imx6ulirq.class = class_create(THIS_MODULE, IMX6ULIRQ_NAME);
    if(IS_ERR(imx6ulirq.class))
    {
        printk("%s(%d):fail\n", __FILE__, __LINE__);
        ret = PTR_ERR(imx6ulirq.class);
        goto fail_class;
    }

    imx6ulirq.device = device_create(imx6ulirq.class, NULL, imx6ulirq.devid, NULL, IMX6ULIRQ_NAME);
    if(IS_ERR(imx6ulirq.device))
    {
        printk("%s(%d):fail\n", __FILE__, __LINE__);
        ret = PTR_ERR(imx6ulirq.device);
        goto fail_device;
    }

    //4
    printk("%s(%d):\n", __FILE__, __LINE__);
    ret = key_init(&imx6ulirq);
    if(ret < 0)
    {
        goto fail_keyinit;
    }

    init_timer(&imx6ulirq.timer);
    imx6ulirq.timer.function = timer_func;

    return 0;

    printk("%s(%d):fail\n", __FILE__, __LINE__);
fail_keyinit:
fail_device:
    class_destroy(imx6ulirq.class);
fail_class:
    cdev_del(&imx6ulirq.cdev);
fail_cdev:
    unregister_chrdev_region(imx6ulirq.devid, 1);
fail_devid:
    printk("%d:---------------\r\n", __LINE__);
    return ret;

}

static void __exit imx6ulirq_exit(void)
{
	free_irq(imx6ulirq.irqkey.irqnum, NULL);
	gpio_free(imx6ulirq.irqkey.gpio);
    del_timer_sync(&imx6ulirq.timer);
    cdev_del(&imx6ulirq.cdev);
    unregister_chrdev_region(imx6ulirq.devid, IRQ_CNT);
    device_destroy(imx6ulirq.class, imx6ulirq.devid);
    class_destroy(imx6ulirq.class);

}

module_init(imx6ulirq_init);
module_exit(imx6ulirq_exit);
MODULE_LICENSE("GPL");