本篇分为设备树部分和API接口部分
设备树
想要使用中断，设备树中需要有两个属性：
interrupts // 表示要使用哪一个中断, 中断的触发类型等等。
interrupt-parent // 这个中断要接到哪一个设备去? 即父中断控制器是谁
父中断控制器有两种指定方法：
- 只有一个父中断设备
- 有多个父中断设备
1）、只有一个父中断设备
interrupt-parent = <&父设备标号>;
interrupts = <... ...>, <... ...>;
2）、有多个父设备节点
interrupts-extended = <&父设备标号 .....>, <... ... ...>;
通过不断往里跳可以发现 设备树查找有这两种方式
方法一
此方法中，由于查看父节点是靠 interrupt-parent实现的，所以此属性不可少.
方法二
不断跳就会发现这个循环
此方法中是通过属性中第一个元素找出的父节点，所以无需指定中断父节点
上述属性用多少个u32表示
由它的父中断控制器来描述,在父中断控制器中, 至少有2个属性:
interrupt-controller; // 表示自己是一个中断控制器
#interrupt-cells // 表示自己的子设备里应该用几个U32的数据来描述中断
如此图，此节点是父节点中断控制器，他的子节点用2个u32 描述中断。
如何找到一个节点的父中断控制器
一般在描述子中断节点中都会有一个属性interrupt-parent，由此属性描述。
如果子中断节点中没有此属性，需要查看此节点的父节点，一级一级往上直到父节点中出现interrupt-parent。
API函数
获取中断号
int platform_get_irq(struct platform_device *dev, unsigned int num)参数一：平台设备，
参数二：设备树里第几个中断引脚，一般给0
返回值：中断号
ps：需要在设备树里指定。
int gpio_to_irq(unsigned gpio)参数：io口号
返回值：中断号
ps：此函数无需在设备树里指定中断信息，直接调用可直接在根目录下的gpio中断控制器里申请返回一个中断号，一旦在设备树里指定，也可获得中断号，不过与不指定的中断号可能存在差异，不过不影响，都可以实现中断。
注册中断
int request_irq(unsigned int irq, irq_handler_t handler, unsigned long flags,const char *name, void *dev)参数一：中断号
参数二：中断回调函数
参数三：在什么边沿触发
参数四：标签，可随意
参数五：中断回调函数传入的参数
int
devm_request_irq(struct device *dev, unsigned int irq, irq_handler_t handler,
unsigned long irqflags, const char *devname, void *dev_id)此函数也可以注册中断，建议使用这个，参数跟上面函数大差不差不在重复介绍。
devm_request_irq和request_irq区别在于前者是申请的内核“managed”资源，不需要自己手动释放，会自动回收资源，而后者需要手动调用free_irq来释放中断资源
中断回调函数类型
flag类型
注销函数
const void *free_irq(unsigned int irq, void *dev_id)参数一：中断号
参数二：与注册函数传入参数一致。
void devm_free_irq(struct device *dev, unsigned int irq, void *dev_id)参数与上述函数一致，注意配套使用
使用中断后，我们就可以在按下按键后就可以收到一次消息，但是由于上层函数在while循环里一直执行，每调用一次read就会调用底层内核的read，不会阻塞，所以cpu占用率百分之百，此时这就是个病毒驱动。但是我们在学习系统编程的时候，read是一个阻塞函数，当然那时内核实现的他的阻塞，所以我们就需要在内核里把read阻塞，当按键按下进入中断再让read解除阻塞，减少cpu的占用率。
等待队列
等待队列是目前内核最常用的阻塞同步机制之一可以在内核层产生一个阻塞( 等于放弃 CPU 的！ )while(1); ->这种叫死等 -> 效率最低 占用 CPU 最高一种等待机制所有的系统的等待机制都绝非死等-> 都是放弃 CPU ，后续被换唤醒机制！在 FreeRTOS 大家应该接触过类似的概念等待队列非常类似之前大家在系统层面学习 线程的同步和互斥：条件变量！等待队列除了创建之外就两个函数，也是两个功能：一个功能叫做： 阻塞 -> 调用后立刻产生挂起wait_event唤醒->调用会唤醒之前挂起进程 / 程序wake_up内核层的阻塞会引起上层的阻塞！举个例子：我在 open-> 调用 “ 阻塞 ” -> 上层 open 也会阻塞我在 read->调用 “ 阻塞 ” –> 上层 read 也会阻塞
等待队列的创建：(宏定义函数->用空间换时间)
DECLARE_WAIT_QUEUE_HEAD(name);#define DECLARE_WAIT_QUEUE_HEAD(name) \
struct wait_queue_head name = __WAIT_QUEUE_HEAD_INITIALIZER(name)
// Expands to
struct wait_queue_head queue = { . lock = ( spinlock_t ) { { . rlock = { . raw_lock = { { . val = { ( 0 ) } } } , } } } , . head = { & ( queue ) . head , & ( queue ) . head } }此函数为宏函数， 声明的时候已经帮我们初始化好了，括号里面是我们创建的变量名字
阻塞函数
wait_event_interruptible(wq_head, condition)
此函数也也为宏函数，可以看出，当condition为1时，不阻塞，为0时阻塞，另外第二个参数必须为变量，如果填0，则当唤醒函数执行后不会解除阻塞。wait_event_interruptible（以及wait_event打头的其他变体）是Linux的wait queue机制提供的线程同步接口（应先cond=0，把cond传进去）另外也可以看出，参数一直接传入变量名即可
唤醒函数
wake_up_interruptible(x)
此函数也为宏函数， 跳进去可发现，参数传入变量名地址。调用完该函数cond设置为1.
整体代码
#include "linux/cdev.h"
#include "linux/device.h"
#include "linux/device/class.h"
#include "linux/export.h"
#include "linux/fs.h"
#include "linux/gpio.h"
#include "linux/interrupt.h"
#include "linux/irq.h"
#include "linux/module.h"
#include "linux/of_device.h"
#include "linux/of_gpio.h"
#include "linux/platform_device.h"
#include "linux/printk.h"
#include "linux/types.h"
#include "linux/uaccess.h"
#include "linux/wait.h"
#include "linux/zconf.h"
uint32_t pin;
dev_t dev_num;
struct cdev *cdev;
struct class *cls;
struct device * dev;
uint8_t cond;
DECLARE_WAIT_QUEUE_HEAD(queue);
uint8_t val;
irqreturn_t fun(int i, void * a)
{
val=gpio_get_value(pin);
printk("%d\r\n",val);
wake_up_interruptible(&queue);
cond=1;
return 0;
}
static ssize_t read(struct file *f, char __user *b, size_t s, loff_t *offt)
{
cond=0;
wait_event_interruptible(queue,cond);
int a=copy_to_user(b,&val,1);
if(a)
{
}
return 0;
}
static int open(struct inode *i, struct file *f)
{
int ret=devm_request_irq(dev, gpio_to_irq(pin),fun,IRQ_TYPE_EDGE_FALLING,"key", NULL);
printk("%d\r\n",ret);
return ret;
}
static int close(struct inode *i, struct file *f)
{
devm_free_irq(dev,gpio_to_irq(pin),NULL);
return 0;
}
struct file_operations fops={
.owner=THIS_MODULE,
.read=read,
.open=open,
.release=close,
};
int probe(struct platform_device *d)
{
// DECLARE_WAIT_QUEUE_HEAD(name);
// wait_event_interruptible(,);
// wake_up_interruptible(x)
platform_get_irq();
//free_irq();
// devm_free_irq();
dev=&d->dev;
pin=of_get_named_gpio(d->dev.of_node,"key_pin",0);
printk("%d\r\n",pin);
printk("%d\r\n", platform_get_irq(d,0));
printk("irq_num=%d", gpio_to_irq(pin));
gpio_request(pin,"key");
gpio_direction_input(pin);
// devm_request_irq(&d->dev, gpio_to_irq(pin),fun,IRQ_TYPE_EDGE_FALLING,"key", NULL);
alloc_chrdev_region(&dev_num, 0, 1,"key");
cdev=cdev_alloc();
cdev->ops=&fops;
cdev_add(cdev,dev_num,1);
cls=class_create(THIS_MODULE, "key");
device_create(cls, NULL,dev_num,NULL,"key");
return 0;
}
int remove(struct platform_device *d)
{
return 0;
}
static struct of_device_id match={
.compatible="key",
};
static struct platform_driver driver={
.probe=probe,
.remove=remove,
.driver={
.name="key",
.of_match_table=&match,
},
};
static int __init start(void)
{
platform_driver_register(&driver);
printk(KERN_INFO "Hello, world!\n");
return 0;
}
static void __exit stop(void)
{
platform_driver_unregister(&driver);
printk(KERN_INFO "Goodbye, world!\n");
}
module_init(start);
module_exit(stop);
MODULE_LICENSE("GPL");
