Linux的中断使用
一、响应API函数
1.中断号
每个中断都有一个中断号，通过中断号区分不同的中断，有的资料也把中断号叫做中断线。在Linux内核中使用一个int变量表示中断号。
2.request_irq函数
在 Linux内核中要想使用某个中断是需要申请的， request_irq函数用于申请中断， request_irq函数可能会导致睡眠，因此不能在中断上下文或者其他禁止睡眠的代码段中使用 request_irq函数。 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的话表示中断已经被申请了。
3.free_irq函数
使用中断的时候需要通过 request_irq函数申请，使用完成以后就要通过 free_irq函数释放掉相应的中断。如果中断不是共享的，那么 free_irq会删除中断处理函数并且禁止中断。 free_irq函数原型如下所示：
void free_irq(unsigned int irq, void *dev)
函数参数和返回值含义如下：
irq 要释放的中断。
dev：如果中断设置为共享 (IRQF_SHARED)的话，此参数用来区分具体的中断。共享中断只有在释放最后中断处理函数的时候才会被禁止掉。
返回值：无。
4.中断处理函数
使用 request_irq函数申请中断的时候需要设置中断处理函数，中断处理函数格式如下所示：
irqreturn_t (*irq_handler_t) (int, void *)
第一个参数是要中断处理函数要相应的中断号。第二个参数是一个指向 void的指针，也就是个通用指针，需要与 request_irq函数的 dev参数保持一致。用于区分共享中断的不同设备，dev也可以指向设备数据结构。
是个枚举类型，一共有三种返回值。一般中断服务函数返回值使用如下形式：
return IRQ_RETVAL(IRQ_HANDLED)
5.中断使能与禁止函数
常用的中断使用和禁止函数如下所示：
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的时候常说的关闭全局中断，这个时候可以使用如下两个函数：
local_irq_enable()
local_irq_disable()
local_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函数来打开全局中断，而是将中断状态恢复到以前的状态，要考 虑到别的任务的感受，此时就要用到下面两个函数：
local_irq_save(flags)
local_irq_restore(flags)
这两个函数是一对， local_irq_save函数用于禁止中断，并且将中断状态保存在 flags中。local_irq_restore用于恢复中断，将中断到 flags状态。
二、中断的上半部和下半部
1、中断的上半部和下半部是什么
在有些资料中也将上半部和下半部称为顶半部和底半部，都是一个意思。我们在使用request_irq申请中断的时候注册的中断服务函数属于中断处理的上半部，只要中断触发 ，那么中断处理函数就会执行。我们都知道中断处理函数一定要快点执行完毕，越短越好，但是现实往往是残酷的，有些中断处理过程就是比较费时间，我们必须要对其进行处理，缩小中断处理函数的执行时间。比如电容触摸屏通过中断通知 SOC有触摸事件发生， SOC响应中断，然后通过 IIC接口读取触摸坐标值并将其上报给系统。但是我们都知道 IIC的速度最高也只有400Kbit/S，所以在中断中通过 IIC读取数据就会浪费时间。我们可以将通过 IIC读取触摸数据的操作暂后执行，中断处理函数仅仅相应中断，然后清除中断标志位即可。这个时候中断处 理过程就分为了两部分：
-
上半部：上半部就是中断处理函数，那些处理过程比较快，不会占用很长时间的处理就可以放在上半部完成。
-
下半部：如果中断处理过程比较耗时，那么就将这些比较耗时的代码提出来，交给下半部去执行，这样中断处理函数就会快进快出。
因此， Linux内核将中断分为上半部和下半部的主要目的就是实现中断处理函数的快进快出，那些对时间敏感、执行速度 快 的操作可以放到中断处理函数中，也就是上半部。剩下的所有工作都可以放到下半部去执行，比如在上半部将数据拷贝到内存中，关于数据的具体处理就可以放到下半部去执行。至于哪些代码属于上半部，哪些代码属于下半部并没有明确的规定，一切根据实际使用情况去判断，这个就很考验驱动编写人员的功底了。这里有一些可以借鉴的参考点：
-
①、如果要处理的内容不希望被其他中断打断，那么可以放到上半部。
-
②、如果要处理的任务对时间敏感，可以放到上半部。
-
③、如果要处理的任务与硬件有关，可以放到上半部
-
④、除了上述三点以外的其他任务，优先考虑放到下半部。
上半部处理很简单，直接编写中断处理函数就行了，关键是下半部该怎么做呢？ Linux内核提供了多种下半部机制，接下来我们来学习一下这些下半部机制。
2、下半部处理机制
2.1软中断
一开始 Linux内核提供了“ bottom half”机制来实现下半部，简称 BH”。后面引入了软中断和 tasklet来替代“ BH”机制，完全可以使用软中断和 tasklet来替代 BH，从 2.5版本的 Linux内核开始 BH已经被抛弃了。 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];
NR_SOFTIRQS是枚举类型，定义在文件 include/linux/interrupt.h中，定义如下：
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函数原型如下：
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文件里面，函数内容如下：
void __init softirq_init(void)
{
int cpu;
for_each_possible_cpu(cpu) {
per_cpu(tasklet_vec, cpu).tail =
&per_cpu(tasklet_vec, cpu).head;
per_cpu(tasklet_hi_vec, cpu).tail =
&per_cpu(tasklet_hi_vec, cpu).head;
}
open_softirq(TASKLET_SOFTIRQ, tasklet_action);
open_softirq(HI_SOFTIRQ, tasklet_hi_action);
}
可以看出， softirq_init函数默认会打开 TASKLET_SOFTIRQ和HI_SOFTIRQ。
2.2tasklet
tasklet是利用软中断来实现的另外一种下半部机制，在软中断和 tasklet之间，建议大家使用 tasklet。 Linux内核使用 tasklet_struct结构体 来表示 tasklet:
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的参数 */
};
func函数就是 tasklet要执行的处理函数，用户定义函数内容，相当于中断处理函数。如果要使用 tasklet，必须先定义一个 tasklet，然后使用 tasklet_init函数初始化 tasklettaskled_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的参考使用示例如下所示：
/* 定义taselet */
struct tasklet_struct testtasklet;
/* tasklet处理函数 */
void testtasklet_func(unsigned long data)
{
/* tasklet具体处理内容 */
}
/* 中断处理函数 */
irqreturn_t test_handler(int irq, void *dev_id)
{
......
/* 调度tasklet */
tasklet_schedule(&testtasklet);
......
}
/* 驱动入口函数 */
static int __init xxxx_init(void)
{
......
/* 初始化tasklet */
tasklet_init(&testtasklet, testtasklet_func, data);
/* 注册中断处理函数 */
request_irq(xxx_irq, test_handler, 0, "xxx", &xxx_dev);
......
}
2.3工作队列
工作队列是另外一种下半部执行方式，工作队列在进程上下文执行，工作队列将要推后的工作交给一个内核线程去执行，因为工作队列工作在进程上下文，因此工作队列允许睡眠或重新调度。因此如果你要推后的工作可以睡眠那么就可以选择工作队列，否则的话就只能选择软中断或 tasklet。
Linux内核使用 work_struct结构体表示一个工作，内容如下 (省略掉条件编译)：
struct work_struct
{
atomic_long_t data;
struct list_head entry;
work_func_t func; /* 工作队列处理函数 */
};
这些工作组织成工作队列，工作队列使用 workqueue_struct结构体表示，内容如下 (省略掉条件编译):
struct workqueue_struct
{
struct list_head pwqs;
struct list_head list;
struct mutex mutex;
int work_color;
int flush_color;
atomic_t nr_pwqs_to_flush;
struct wq_flusher *first_flusher;
struct list_head flusher_queue;
struct list_head flusher_overflow;
struct list_head maydays;
struct worker *rescuer;
int nr_drainers;
int saved_max_active;
struct workqueue_attrs *unbound_attrs;
struct pool_workqueue *dfl_pwq;
char name[WQ_NAME_LEN];
struct rcu_head rcu;
unsigned int flags ____cacheline_aligned;
struct pool_workqueue __percpu *cpu_pwqs;
struct pool_workqueue __rcu *numa_pwq_tbl[];
};
Linux内核使用工作者线程 (worker thread)来处理工作队列中的各个工作， Linux内核使用worker结构体表示工作者线程， worker结构体内容如下：
struct worker
{
union {
struct list_head entry;
struct hlist_node hentry;
};
struct work_struct *current_work;
work_func_t current_func;
struct pool_workqueue *current_pwq;
bool desc_valid;
struct list_head scheduled;
struct task_struct *task;
struct worker_pool *pool;
struct list_head node;
unsigned long last_active;
unsigned int flags;
int id;
char desc[WORKER_DESC_LEN];
struct workqueue_struct *rescue_wq;
};
从示例代码 51.1.2.10可以看出，每个 worker都有一个工作队列，工作者线程处理自己工作队列中的所有工作。在实际的驱动开发中，我们只需要定义工作 (work_struct)即可，关于工作队列和工作者线程我们基本不用去管。简单创建工作很简单，直接定义一个 work_struct结构体变量即可，然后使用 INIT_WORK宏来初始化工作， INIT_WORK宏定义如下：
#define INIT_WORK(_work, _func)
_work表示要初始化的工作， ，_func是工作对应的处理函数。
也可以使用 DECLARE_WORK宏一次性完成工作的创建和初始化，宏定义如下：
#define DECLARE_WORK(n, f)
n表示定义的工作 (work_ f表示工作对应的处理函数。
和 tasklet一样，工作也是需要调度才能运行的，工作的调度函数为 schedule_work，函数原型如下所示：
bool schedule_work(struct work_struct *work)
函数参数和返回值含义如下：
work 要调度的工作。
返回值： 0 成功，其他值 失败。
关于工作队列的参考使用示例如下所示：
/* 定义工作(work) */
struct work_struct testwork;
/* work处理函数 */
void testwork_func_t(struct work_struct *work);
{
/* work具体处理内容 */
}
/* 中断处理函数 */
irqreturn_t test_handler(int irq, void *dev_id)
{
......
/* 调度work */
schedule_work(&testwork);
......
}
/* 驱动入口函数 */
static int __init xxxx_init(void)
{
......
/* 初始化work */
INIT_WORK(&testwork, testwork_func_t);
/* 注册中断处理函数 */
request_irq(xxx_irq, test_handler, 0, "xxx", &xxx_dev);
......
}
三、设备树中断信息节点
如果使用设备树的话就需要在设备树中设置好中断属性信息， Linux内核通过读取设备树中的中断属性信息来配置中断。对于中断控制器而言，打开 imx6ull.dtsi文件，其中的 intc节点就是I.MX6ULL的中断控制器节点，节点内容如下所示：
1 intc: interrupt-controller@00a01000 {
2 compatible = "arm,cortex-a7-gic";
3 #interrupt-cells = <3>;
4 interrupt-controller;
5 reg = <0x00a01000 0x1000>,
6 <0x00a02000 0x100>;
7 };
第 2行， compatible属性值为“ arm,cortex-a7-gic”在 Linux内核源码中搜索“ arm,cortex-a7-gic”即可找到 GIC中断控制器驱动文件。
第 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节点为空，表示当前节点是中断控制器。
打开 imx6ull-alientek-emmc.dts文件，找到如下所示内容：
1 fxls8471@1e {
2 compatible = "fsl,fxls8471";
3 reg = <0x1e>;
4 position = <0>;
5 interrupt-parent = <&gpio5>;
6 interrupts = <0 8>;
7 };
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)
函数参数和返回值含义如下：
dev 设备节点。
index：索引号 interrupts属性可能包含多条中断信息，通过 index指定要获取的信息。
返回值：中断号。
如果使用GPIO的话，可以使用 gpio_to_irq函数来获取 gpio对应的中断号，函数原型如下：
int gpio_to_irq(unsigned int gpio)
函数参数和返回值含义如下：
gpio 要获取的 GPIO编号。
返回值： GPIO对应的中断号。
四、案件中断编写
1、修改设备树
my_keys {
#address-cells = <1>;
#size-cells = <1>;
compatible = "my-key";
pinctrl-names = "default";
pinctrl-0 = <&pinctrl_gpio_keys>;
key-gpio = <&gpio4 14 GPIO_ACTIVE_LOW>;
interrupt-parent = <&gpio4>; //因为案件连接到gpio4_14上，所以负中断为gpio4
interrupts = <18 IRQ_TYPE_EDGE_BOTH>; //14表示GPIO4组的14号IO，边沿触发
status = "okay";
};
编译设备树之后重启开发板。
2、案件中断程序编写
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_gpio.h>
#include <linux/semaphore.h>
#include <linux/timer.h>
#include <linux/of_irq.h>
#include <linux/irq.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>
#define IMX6UIRQ_CNT 1 //设备号个数
#define IMX6UIRQ_NAME "imx6uirq" //名字
#define KEY0VALUE 0x01 //KEY0按键值
#define INVAKEY 0xFF //无效按键值
#define KEY_NUM 1 //按键数量
struct irq_keydesc{
int gpio; //gpio
int irqnum; //中断号
unsigned char value; //按键对应的值
char name[10]; //名字
irqreturn_t (*handler)(int,void *); //中断服务函数
};
//设备结构体
struct imx6uirq_dev{
dev_t devid; //设备号
struct cdev cdev; //cdev
struct class *class; //类
struct device *device; //设备
int major; //主设备号
int mnior; //次设备号
struct device_node *nd; //设备节点
atomic_t keyvalue; //有效的按键键值
atomic_t releasekey; //标记是否完成一次完成的按键
struct timer_list timer; //定义一个定时器
struct irq_keydesc irqkeydesc[KEY_NUM]; //按键描述数组
unsigned char curkeynum; //当前按键号
};
struct imx6uirq_dev imx6uirq;
/* @description : 中断服务函数，开启定时器，延时10ms，
* * 定时器用于按键消抖。
* * @param - irq : 中断号
* * @param - dev_id : 设备结构。
* * @return : 中断执行结果
* */
static irqreturn_t key0_handler(int irq,void *dev_id)
{
struct imx6uirq_dev *dev = (struct imx6uirq_dev *)dev_id;
dev->curkeynum = 0;
// dev->timer.data = (volatile long)dev_id;
mod_timer(&dev->timer,jiffies + msecs_to_jiffies(10));
return IRQ_RETVAL(IRQ_HANDLED);
}
/* @description : 定时器服务函数，用于按键消抖，定时器到了以后
* 再次读取按键值，如果按键还是处于按下状态就表示按键有效。
* @param – arg : 设备结构变量
* @return : 无
* */
void timer_function(struct timer_list *t)
{
unsigned char value;
unsigned char num;
struct irq_keydesc *keydesc;
struct imx6uirq_dev *dev = from_timer(dev,t,timer);
num = dev->curkeynum;
keydesc = &dev->irqkeydesc[num];
value = gpio_get_value(keydesc->gpio); //读取IO值
if(value == 0) //按下按键
{
atomic_set(&dev->keyvalue,keydesc->value);
}
else //按键松开
{
atomic_set(&dev->keyvalue,0x80 | keydesc->value);
atomic_set(&dev->releasekey,1); //标记松开按键
}
}
static int keyio_init(void)
{
unsigned char i = 0;
int ret = 0;
imx6uirq.nd = of_find_node_by_path("/my_keys");
if(imx6uirq.nd == NULL)
{
printk("key node not find!\r\n");
return -EINVAL;
}
//提取GPIO
for(i=0;i<KEY_NUM;i++)
{
imx6uirq.irqkeydesc[i].gpio = of_get_named_gpio(imx6uirq.nd,"key-gpio",i);
if(imx6uirq.irqkeydesc[i].gpio<0)
{
printk("can't get key%d\r\n",i);
}
}
//初始化key所使用的IO,并且设置成中断模式
for(i=0;i<KEY_NUM;i++)
{
memset(imx6uirq.irqkeydesc[i].name,0,sizeof(imx6uirq.irqkeydesc[i].name));
snprintf(imx6uirq.irqkeydesc[i].name,sizeof(imx6uirq.irqkeydesc[i].name),"KEY%d",i);
gpio_request(imx6uirq.irqkeydesc[i].gpio,imx6uirq.irqkeydesc[i].name);
gpio_direction_input(imx6uirq.irqkeydesc[i].gpio);
// imx6uirq.irqkeydesc[i].irqnum = irq_of_parse_and_map(imx6uirq.nd,i);
#if 1 //因为使用到了gpio，所以用gpio_to_irq获取中断号
imx6uirq.irqkeydesc[i].irqnum = gpio_to_irq(imx6uirq.irqkeydesc[i].gpio);
#endif
printk("key%d:gpio=%d,irqnum=%d\r\n",i,imx6uirq.irqkeydesc[i].gpio,
imx6uirq.irqkeydesc[i].irqnum);
}
//申请中断
imx6uirq.irqkeydesc[0].handler = key0_handler;
imx6uirq.irqkeydesc[0].value = KEY0VALUE;
for(i=0;i<KEY_NUM;i++)
{
ret = request_irq(imx6uirq.irqkeydesc[i].irqnum,
imx6uirq.irqkeydesc[i].handler,
IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
imx6uirq.irqkeydesc[i].name,&imx6uirq);
if(ret<0)
{
printk("irq %d request failure!\r\n",imx6uirq.irqkeydesc[i].irqnum);
return -EINVAL;
}
}
//创建定时器
timer_setup(&imx6uirq.timer,timer_function,0);
// imx6uirq.timer.function = timer_function;
return 0;
}
static int imx6uirq_open(struct inode *indoe,struct file *filp)
{
filp->private_data = &imx6uirq;
return 0;
}
static ssize_t imx6uirq_read(struct file *filp,char __user *buf,size_t cnt,loff_t *offt)
{
int ret = 0;
unsigned char keyvalue = 0;
unsigned char releasekey = 0;
struct imx6uirq_dev *dev = (struct imx6uirq_dev *)filp->private_data;
keyvalue =atomic_read(&dev->keyvalue);
releasekey = atomic_read(&dev->releasekey);
if(releasekey) //按键按下
{
if(keyvalue&0x80)
{
keyvalue &= ~0x80;
ret = copy_to_user(buf,&keyvalue,sizeof(keyvalue));
}
else
goto data_error;
atomic_set(&dev->releasekey,0); //按下标志清零
}
else
{
goto data_error;
}
return 0;
data_error:
return -EINVAL;
}
static struct file_operations imx6uirq_fops={
.owner = THIS_MODULE,
.open = imx6uirq_open,
.read = imx6uirq_read,
};
static int __init imx6uirq_init(void)
{
//构建设备号
if(imx6uirq.major)
{
imx6uirq.devid = MKDEV(imx6uirq.major,0);
register_chrdev_region(imx6uirq.devid,IMX6UIRQ_CNT,IMX6UIRQ_NAME);
}
else
{
alloc_chrdev_region(&imx6uirq.devid,0,IMX6UIRQ_CNT,IMX6UIRQ_NAME);
imx6uirq.major = MAJOR(imx6uirq.devid);
imx6uirq.mnior = MINOR(imx6uirq.devid);
}
//注册字符设备
cdev_init(&imx6uirq.cdev,&imx6uirq_fops);
cdev_add(&imx6uirq.cdev,imx6uirq.devid,IMX6UIRQ_CNT);
//创建类
imx6uirq.class = class_create(THIS_MODULE,IMX6UIRQ_NAME);
if(IS_ERR(imx6uirq.class))
{
return PTR_ERR(imx6uirq.class);
}
//创建设备
imx6uirq.device = device_create(imx6uirq.class,NULL,imx6uirq.devid,NULL,IMX6UIRQ_NAME);
if(IS_ERR(imx6uirq.device))
{
return PTR_ERR(imx6uirq.device);
}
//初始化按键
atomic_set(&imx6uirq.keyvalue,INVAKEY);
atomic_set(&imx6uirq.releasekey,0);
keyio_init();
printk("init successfully!\r\n");
return 0;
}
static void __exit imx6uirq_exit(void)
{
unsigned int i=0;
//删除定时器
del_timer_sync(&imx6uirq.timer);
//释放中断
for(i=0;i<KEY_NUM;i++)
{
free_irq(imx6uirq.irqkeydesc[i].irqnum,&imx6uirq);
}
cdev_del(&imx6uirq.cdev);
unregister_chrdev_region(imx6uirq.devid,IMX6UIRQ_CNT);
device_destroy(imx6uirq.class,imx6uirq.devid);
class_destroy(imx6uirq.class);
}
module_init(imx6uirq_init);
module_exit(imx6uirq_exit);
MODULE_LICENSE("GPL");
Makefile
KERNELDIR := /home/xxx/imx6ull_file/bsp/kernel/linux-imx
CURRENT_PATH := $(shell pwd)
obj-m := irq_key.o
build:kernel_modules
kernel_modules:
$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) modules
clean:
$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean
3、编写应用程序
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
int main(int argc ,char **argv)
{
int fd,rv;
char *filename;
unsigned char data;
if(argc != 2)
{
printf("Error Usage!\r\n");
return -1;
}
filename = argv[1];
fd = open(filename,O_RDWR);
if(fd < 0)
{
printf("file %s open failed!\r\n",argv[1]);
return -1;
}
while(1)
{
rv = read(fd,&data,sizeof(data));
if(rv<0)//数据读取错误或者无效
{
}else
{
if(data)
printf("KEY0 Press,value =%#X\r\n",data);//按下
}
}
rv = close(fd);
if(rv<0)
{
printf("file %s close failed!\r\n,argv[1]");
return -1;
}
return 0;
}
4、运行测试
insmod加载驱动模块
cat /proc/interrupts
按键按下后就会读取按键有效值
但是这也的中断是存在问题的，使用top命令查看
如上图，一个普通的按键中断对CPU的占用率高达99%，因为一直在轮询查看按键是否被按下，是很耗CPU的，所以应该学习阻塞与非阻塞的应用，还有异步通知。
声明：以上资料摘抄自正点原子的Linux嵌入式开发指南，侵权删。
2500
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
