一、linux驱动开发-6.1-中断

最新推荐文章于 2024-12-27 11:51:55 发布

原创最新推荐文章于 2024-12-27 11:51:55 发布 · 503 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#linux

嵌入式同时被 2 个专栏收录

30 篇文章

订阅专栏

linux驱动

23 篇文章

订阅专栏

本文深入讲解了Linux内核中的中断处理机制，包括中断API的使用、上半部和下半部的概念及其实现方式，并提供了一个具体的按键中断处理示例。

一、中断简介

内核提供了完善的中断框架，只需要申请中断，然后注册中断处理函数即可。

1.1、中断API

1.1.1、中断号

每个中断都有一个中断号，通过中断号即可区分不同的中断。

1.1.2、request_irq

用于申请中断，可能会导致睡眠，因此不能在中断上下文或者其他禁止睡眠的代码中使用，次函数会激活（使能）中断，因此不需要手动去使能中断。

/*
@Decription：申请中断
@irq：要申请的中断号
@handler：中断处理函数
@flags：中断标志
@name：中断名字
@dev：一般设置为设备结构体，dev会传递给中断处理函数irq_handler的第二个参数

@rerun：0，申请成功
      < 0，申请失败
*/
int request_irq(unsigned int irq,
                irq_handler_t handler,
                unsigned long flags,
                const char *name,
                void *dev)

1.1.3、free_irq

使用完后通过free_irq释放

/*
@Description：释放中断
@irq：要释放的中断
@dev：
*/
void free_irq(unsigned int irq,
              void *dev)

1.1.4、中断处理函数

使用 request_irq 函数申请中断的时候需要设置中断处理函数，中断处理函数格式如下所示：

irqreturn_t (*irq_handler_t) (int, void *)

        第一个参数是要中断处理函数要相应的中断号。

        第二个参数是一个指向 void 的指针，也就是个通用指针，需要与 request_irq 函数的 dev 参数保持一致。用于区分共享中断的不同设备，dev 也可以指向设备数据结构

        中断处理函数的返回值为 irqreturn_t 类型，定义如下：
enum irqreturn {
    IRQ_NONE = (0 << 0),
    IRQ_HANDLED = (1 << 0),
    IRQ_WAKE_THREAD = (1 << 1),
};

typedef enum irqreturn irqreturn_t;
一般返回形式：
return IRQ_RETVAL(IRQ_HANDLED)

1.1.5、中断使能与禁止函数

void enable_irq(unsigned int irq)

void disable_irq(unsigned int irq)

void disable_irq_nosync(unsigned int irq)

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

disable_irq_nosync 函数调用以后立即返回，不会等待当前中断处理程序执行完毕。

有时候需要挂壁当前处理器的整个中断系统：

local_irq_enable()
local_irq_disable()

考虑到多任务：

local_irq_save(flags) 
local_irq_restore(flags)

1.2、上半部和下半部

Linux 内核将中断分为上半部和下半部的主要目的就是实现中断处理函数的快进快
出。

上半部：上半部就是中断处理函数，那些处理过程比较快，不会占用很长时间的处理就可以放在上半部完成。
下半部：如果中断处理过程比较耗时，那么就将这些比较耗时的代码提出来，交给下半部去执行，这样中断处理函数就会快进快出

上半部就是中断处理函数

下半部，内核提供了多种下半部机制

1.2.1、软中断

1.2.2、tasklet

1.2.3、工作队列

1.3、设备树中的中断信息节点

1.4、获取中断号

在设备树里添加中断信息后，就可以从interrupts属性中提取对应的中断号了。

/*
Description：获取中断号
@dev：设备节点
@index：索引号

@return：中断号
*/
unsigned int irq_of_parse_and_map(struct device_node *dev,
                                  int index)

如果使用gpio的话，可以使用gpio_to_irq来获取gpio对应的中断号

/*
@Description：获取中断号
@gpio：要获取的gpio编号

@return：gpio对应的中断号
*/
int gpio_to_irq(unsigned int gpio)

二、程序编写

采用按键触发中断的方式，用定时器实现消抖。

2.1、修改设备树

在key节点下添加中断相关属性

2.2、驱动程序

①、在中断服务函数中启动10ms定时器用于消抖

②、在定时器服务函数中读取按键，并用原子变量进行保护

#include <linux/types.h>

#include <linux/module.h>

#include <linux/ide.h>

#include <linux/kernel.h>

#include <linux/init.h>

#include <linux/errno.h>

#include <linux/fs.h>

#include <linux/slab.h>

#include <linux/uaccess.h>

#include <linux/io.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/gpio.h>

#include <linux/of_irq.h>

#include <linux/irq.h>

#include <linux/semaphore.h>

#include <linux/timer.h>

#include <linux/io.h>



#define IMX6UIRQ_CNT     	1     

#define IMX6UIRQ_NAME    	"imx6uirq"

#define KEY0VALUE			0X01

#define INVAKEY				0xFF 

#define KEY_NUM				1



struct irq_keydesc{

	int gpio;				//gpio编号

	unsigned int irqnum;	//中断号

	irqreturn_t (*irq_handler)(int, void*);		//中断处理函数

};



//设备结构体

struct imx6uirq_dev{

	dev_t devid;

	struct cdev cdev;

	struct class *class;

	struct device *device;

	int major;

	int minor;

	struct device_node *nd;		//设备节点

	atomic_t keyvalue;			//有效的按键值

	atomic_t releasekey;		//标记是否完成一次完整的按键

	struct timer_list timer;	//定时器

	struct irq_keydesc irq_keydesc[KEY_NUM];	//按键描述数组

};



struct imx6uirq_dev imx6uirq;  



static int imx6uirq_open(struct inode *inode, struct file *file)

{

	file->private_data = &imx6uirq;

	return 0;

}



ssize_t imx6uirq_read(struct file *file, char __user *buf, size_t size, loff_t *ppos)

{

	unsigned char keyvalue = 0;

	unsigned char releasekey = 0;

	struct imx6uirq_dev *dev = file->private_data;



	keyvalue = atomic_read(&dev->keyvalue);

	releasekey = atomic_read(&dev->releasekey);

	

	if (releasekey)

	{

		copy_to_user(buf, &keyvalue, sizeof(keyvalue));

		atomic_set(&dev->releasekey, 0);	//清除按下标志位

	}

	else

	{

		return -EINVAL;

	}

	



	return 0;

}



static const struct file_operations imx6uirq_fops = {

	.owner = THIS_MODULE,

	.open  = imx6uirq_open,

	.read  = imx6uirq_read,

};



//定时器回调函数

static void timer_function(unsigned long arg)

{

	int value;

	struct irq_keydesc *keydesc;

	struct imx6uirq_dev *dev = (struct imx6uirq_dev *)arg;

	keydesc = &dev->irq_keydesc[0];



	value = gpio_get_value(keydesc->gpio);

	if (value == 0)

		atomic_set(&dev->keyvalue, value);

	else {

		atomic_set(&dev->keyvalue, value);

		atomic_set(&dev->releasekey, 1);	//标记按键松开

	}

}



static irqreturn_t key0_irq_handler(int irq, void *dev_id)

{

	int value;

	struct imx6uirq_dev *dev = (struct imx6uirq_dev *)dev_id;



	dev->timer.data = (volatile long)dev_id;

	//启动定时器

	mod_timer(&dev->timer, jiffies + msecs_to_jiffies(10));



	return IRQ_HANDLED;

}



static int key_io_init(void)

{

	int ret;

	//通过节点名字查找节点

	imx6uirq.nd = of_find_node_by_name(NULL, "gpiokey");

	if (imx6uirq.nd == NULL)

	{

		printk("find %s fail\r\n", "gpiokey");

		return -EINVAL;

	}



	//通过节点获取GPIO编号

	imx6uirq.irq_keydesc[0].gpio = of_get_named_gpio(imx6uirq.nd, "key-gpio", 0);

	if (imx6uirq.irq_keydesc[0].gpio < 0)

	{

		printk("get %s fail\r\n", "key-gpio");

		return -EINVAL;

	}

	//初始化key-gpio

	ret = gpio_request(imx6uirq.irq_keydesc[0].gpio, "gpio_irq");

	if (ret != 0)

	{

		printk("request %s fail\r\n", "gpio_irq");

		return -EINVAL;

	}

	ret = gpio_direction_input(imx6uirq.irq_keydesc[0].gpio);

	if (ret < 0)

	{

		printk("set key status fail\r\n");

		return -EINVAL;

	}



	//通过节点获取中断号

	imx6uirq.irq_keydesc[0].irqnum = irq_of_parse_and_map(imx6uirq.nd, 0);

#if 0

	//通过GPIO编号获取中断号

	imx6uirq.irq_keydesc[0].irqnum = gpio_to_irq(imx6uirq.irq_keydesc[0].gpio);

#endif

	//设置中断处理函数

	imx6uirq.irq_keydesc[0].irq_handler = key0_irq_handler;

		

	//通过中断号申请中断

	ret = request_irq(imx6uirq.irq_keydesc[0].irqnum,	

				imx6uirq.irq_keydesc[0].irq_handler,

				IRQF_TRIGGER_RISING|IRQF_TRIGGER_FALLING,

				IMX6UIRQ_NAME,

				&imx6uirq);	

	if (ret < 0)

	{

		printk("request irq fail\r\n");

		return -EINVAL;

	}



	//初始化定时器

	init_timer(&imx6uirq.timer);

	imx6uirq.timer.function = timer_function;

}



static int __init imx6uirq_init(void)

{

	int ret = 0;

	int val = 0;	



	//分配设备号

	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.minor = MINOR(imx6uirq.devid);

	}



	//初始化cdev

	imx6uirq.cdev.owner = THIS_MODULE;

	cdev_init(&imx6uirq.cdev, &imx6uirq_fops);

	//添加cdev

	cdev_add(&imx6uirq.cdev, imx6uirq.devid,  IMX6UIRQ_CNT);

	//创建类

	imx6uirq.class = class_create(THIS_MODULE,  IMX6UIRQ_NAME);

	//创建设备

	imx6uirq.device = device_create(imx6uirq.class, NULL, imx6uirq.devid, NULL,  IMX6UIRQ_NAME);



	//按键gpio初始化

	key_io_init();

	

	return 0;

}



static void __exit imx6uirq_exit(void)

{

	//删除定时器

	del_timer_sync(&imx6uirq.timer);

	//释放中断

	free_irq(imx6uirq.irq_keydesc[0].irqnum, &imx6uirq);



	//删除设备

	cdev_del(&imx6uirq.cdev);

	//注销设备号

	unregister_chrdev_region(imx6uirq.devid,  IMX6UIRQ_CNT);

	//删除设备的类

	device_destroy(imx6uirq.class,  imx6uirq.devid);

	//删除类

	class_destroy(imx6uirq.class);

		

	printk(" dev exit\n");

}



module_init( imx6uirq_init);

module_exit( imx6uirq_exit);



MODULE_LICENSE("GPL");

MODULE_AUTHOR("ZK");

2.3、应用程序

通过不断读取获取按键值

#include "stdio.h"
#include "unistd.h"
#include "sys/types.h"
#include "sys/stat.h"
#include "fcntl.h"
#include "stdlib.h"
#include "string.h"

#define CLOSE_CMD		1
#define OPEN_CMD		2
#define SETPERIOD_CMD	3

int main(int argc, char *argv[])
{
    int fd, ret;
    char *filename;
    unsigned char keyvalue;

    if (argc != 2)
    {
        printf("Usage:\n");
        printf("\n");
        return -1;
    }
    filename = argv[1];
    fd = open(filename, O_RDWR);
    if (fd < 0)
    {
        printf("open file %s fail\n", filename);
    }

    while (1)
    {
        ret = read(fd, &keyvalue, sizeof(keyvalue));
        if (ret < 0)
        {

        }
        else 
        {
            if (keyvalue)
                printf("key0 value is %d\r\n", keyvalue);
        }
    }

    close(fd);
    return ret;
}