23、IMX6ULL学习笔记-中断下半部

最新推荐文章于 2024-08-18 18:25:13 发布
最新推荐文章于 2024-08-18 18:25:13 发布
阅读量427 收藏
点赞数
分类专栏： 软件 计算机 文章标签： linux 驱动程序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BaoTTing/article/details/106640754
版权

一、原理图

在这里插入图片描述

二、中断表

在这里插入图片描述

三、设备树

在这里插入图片描述

四、说明

本次实验是在按键中断的基础上修改，原理图和设备树不变，使用中断下半部机制，介绍work和tasklet两种实现下半部的方式。
方式一：tasklet
在这里插入图片描述
方式二：
在这里插入图片描述

五、tasklet方式实现下半部的驱动程序

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.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_irq.h>
#include <linux/gpio.h>
#include <linux/of_gpio.h>
#include <linux/string.h>
#include <linux/irq.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>
#include <linux/interrupt.h>
#define DeviceName 		"devicetree-key0-interrupt-tasklet" //设备驱动名称
#define DeviceNodes 	1 					  	 //设备节点个数
#define KEY_NUM 		0X01             
#define KEY0VALUE       0X01
#define INVAKEY         0XFF
struct irq_keydesc{
    int gpio_num;           /* io编号 */
    int irq_num;            /* 中断号 */
    unsigned char value;    /* 键值 */
    char name[25];          /* 名字 */
    irqreturn_t (*handler) (int, void *);  /* 中断处理函数 */
	struct tasklet_struct tasklet;
};
/* 定义一个设备结构体 */
struct mod_struct {
	dev_t devid;			     /* 设备号 */
	int major;				     /* 主设备号 */
	int minor;				     /* 次设备号 */
	struct cdev cdev;		     /* cdev */
	struct class *class;	  	 /* 类 */
	struct device *device;	 	 /* 设备 */
	struct device_node *nd;  	 /* 设备节点 */
	struct irq_keydesc irqkey0;  /* 按键中断 */
	struct timer_list timer;	 /* 内核定时器 */
	
	atomic_t keyvalue;			 /* 原子变量1->整形*/
    atomic_t releasekey;		 /* 原子变量2->整形*/
};
struct mod_struct mod_device;	 /* 定义一个设备 */
/*
 * @description		: 打开设备
 * @param - inode 	: 传递给驱动的inode
 * @param - filp 	: 设备文件，file结构体有个叫做private_data的成员变量
 * 					  一般在open的时候将private_data指向设备结构体。
 * @return 			: 0 成功;其他 失败
 */
static int key0_interrupt_open(struct inode *inode, struct file *filp)
{
	filp->private_data = &mod_device; /* 设置私有数据 */
	return 0;
}
/*
 * @description		: 从设备读取数据 
 * @param - filp 	: 要打开的设备文件(文件描述符)
 * @param - buf 	: 返回给用户空间的数据缓冲区
 * @param - cnt 	: 要读取的数据长度
 * @param - offt 	: 相对于文件首地址的偏移
 * @return 			: 读取的字节数，如果为负值，表示读取失败
 */
static ssize_t key0_interrupt_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
{
    int ret = 0;
    unsigned char keyvalue;
    unsigned char releasekey;
    struct mod_struct *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 ret;

data_error:
    return -EINVAL;
}
/*
 * @description		: 向设备写数据 
 * @param - filp 	: 设备文件，表示打开的文件描述符
 * @param - buf 	: 要写给设备写入的数据
 * @param - cnt 	: 要写入的数据长度
 * @param - offt 	: 相对于文件首地址的偏移
 * @return 			: 写入的字节数，如果为负值，表示写入失败
 */
static ssize_t key0_interrupt_write(struct file *filp, const char __user *buf,size_t cnt, loff_t *offt)
{

	return 0;
}
/*
 * @description		: 关闭/释放设备
 * @param - filp 	: 要关闭的设备文件(文件描述符)
 * @return 			: 0 成功;其他 失败
 */

static int key0_interrupt_release(struct inode *inode, struct file *filp)
{
	return 0;
}
/* 设备操作函数 */
static struct file_operations beep_fops = {
	.owner    	=  THIS_MODULE,
	.open     	=  key0_interrupt_open,
	.read     	=  key0_interrupt_read,
	.write    	=  key0_interrupt_write,
	.release  	=  key0_interrupt_release,
};
/* 按键中断处理函数 */
static irqreturn_t key0_handler(int irq, void *dev_id)
{
	struct mod_struct *dev = dev_id;
	#if 0
	dev->timer.data = (volatile long)dev_id;
	mod_timer(&dev->timer, jiffies + msecs_to_jiffies(20)); /* 20ms定时 */
	#endif
	tasklet_schedule(&dev->irqkey0.tasklet);
	return IRQ_HANDLED;
}
/* tasklet (下半部)*/
static void key_tasklet(unsigned long data)
{
    struct mod_struct *dev = (struct mod_struct*)data;
    dev->timer.data = data;
    mod_timer(&dev->timer, jiffies + msecs_to_jiffies(20)); /* 20ms定时 */
}


/* 定时器处理函数 */
static void timer_func(unsigned long arg) {
    int value = 0;
    struct mod_struct *dev = (struct mod_struct*)arg;

    value = gpio_get_value(dev->irqkey0.gpio_num);
    if(value == 0)   {          /* 按下 */
        atomic_set(&dev->keyvalue, dev->irqkey0.value);/*=0x01*/
    } else if(value == 1) {     /* 释放 */
        atomic_set(&dev->keyvalue, 0X80 | (dev->irqkey0.value));
        atomic_set(&dev->releasekey, 1);  /* 完成的按键过程 */
    }
}
/*
 * @description	: 按键初始化函数
 * @param 		: dev
 * @return 		: 无
 */
static int key_init(struct mod_struct *dev)
{
	int ret = 0;
	/* 1、获取设备节点：/devicetree-leds-pincrl */
	dev->nd = of_find_node_by_path("/devicetree-key0-interrupt");
	if(dev->nd == NULL) {
			printk("devicetree-key0-interrupt node not find!\r\n");
			ret = -EINVAL;
			goto fail_fd;
	} else {
		printk("devicetree-key0-interrupt node find!\r\n");
	}
	/* 2、从设备节点下的led-gpio属性里获取gpio编号 */
	dev->irqkey0.gpio_num = of_get_named_gpio(dev->nd,"key-gpio", 0);
	if(dev->irqkey0.gpio_num < 0) {
			printk("can't get key-gpio\r\n");
			ret = -EINVAL;
			goto fail_gpio;
	}
	printk("key-gpio num = %d\r\n", dev->irqkey0.gpio_num);
	/*3、申请gpio(检查是否被占用)*/
	sprintf(dev->irqkey0.name,"%s","key0-gpio-interrupt");
	ret = gpio_request(dev->irqkey0.gpio_num,dev->irqkey0.name);
	if(ret)
	{
		ret = -EBUSY;
		printk("IO %d busy,can't request!\r\n",dev->irqkey0.gpio_num);
		goto fail_ioreq;
	}
	/*4、设置key0为输入 */
	ret = gpio_direction_input(dev->irqkey0.gpio_num);
	if(ret < 0) {
			printk("can't set gpio!\r\n");
			goto fail_ioset;
	}
	/*5、根据IO编号获取其中断号*/
	dev->irqkey0.irq_num=gpio_to_irq(dev->irqkey0.gpio_num);
#if 0
	dev->irqkey0.irq_num = irq_of_parse_and_map(dev->nd,0);
#endif
	/*6、设置中断函数*/
	dev->irqkey0.handler = key0_handler;
    dev->irqkey0.value  = KEY0VALUE;
	/*7、注册中断*/
	ret = request_irq(dev->irqkey0.irq_num,
					  dev->irqkey0.handler,
					  IRQF_TRIGGER_RISING|IRQF_TRIGGER_FALLING,
					  dev->irqkey0.name,
					  &mod_device);
	if(ret){
		printk("irq %d request failed!\r\n", dev->irqkey0.irq_num);
		goto fail_irq;
	}
	tasklet_init(&dev->irqkey0.tasklet, key_tasklet, (unsigned long)dev);
	/*8、初始化定时器*/
	init_timer(&mod_device.timer);
    mod_device.timer.function = timer_func;
	return 0;
fail_irq:
fail_ioset:
	gpio_free(dev->irqkey0.gpio_num);
fail_ioreq:
fail_gpio:
fail_fd:
	return ret;
}
/*
 * @description	: 驱动出口函数
 * @param 		: 无
 * @return 		: 无
 */
static int __init key0_interrupt_init(void)
{
	int ret = 0;
/*一、 注册字符设备驱动 */
	/* 1、创建设备号 */
	if (mod_device.major)
	{		
		mod_device.devid = MKDEV(mod_device.major,0);//设备号起始点(major,0)
		//设备号起始点开始，申请DeviceNodes个设备号
		ret = register_chrdev_region(mod_device.devid,DeviceNodes,DeviceName);
	} 
	else {
		ret = alloc_chrdev_region(&mod_device.devid,0,DeviceNodes,DeviceName);	/* 申请设备号 */
		mod_device.major = MAJOR(mod_device.devid);	/* 获取分配号的主设备号 */
		mod_device.minor = MINOR(mod_device.devid);	/* 获取分配号的次设备号 */	
	}
	if(ret < 0){ printk("设备号申请失败\r\n");goto fail_chrdev; }
	printk("mod_device major=%d,minor=%d\r\n",mod_device.major,mod_device.minor);	
	/* 2、初始化cdev并添加cdev */
	mod_device.cdev.owner = THIS_MODULE;
	cdev_init(&mod_device.cdev,&beep_fops);
	ret = cdev_add(&mod_device.cdev,mod_device.devid,DeviceNodes);
	if(ret < 0){ printk("添加cdev失败！\r\n");goto fail_cdev; }
	/* 3、创建类 */
	mod_device.class = class_create(THIS_MODULE,DeviceName);
	if (IS_ERR(mod_device.class)) { ret = PTR_ERR(mod_device.class);goto fail_class; } 
	/* 4、创建设备节点*/
	mod_device.device = device_create(mod_device.class,NULL,mod_device.devid,NULL,"pinctrl-key0-interrupt-tasklet");
	if (IS_ERR(mod_device.device)) { ret = PTR_ERR(mod_device.device);goto fail_device; }
	/* 5、初始化IO */
    ret = key_init(&mod_device);
    if(ret < 0) {
        goto fail_keyinit;
    }
	/* 6、初始化原子变量 */
	atomic_set(&mod_device.keyvalue, INVAKEY);/*mod_device.keyvalue=INVAKEY*/
    atomic_set(&mod_device.releasekey, 0);/*mod_device.releasekey=0*/
    return 0;
/*X、模块加载失败处理部分*/
fail_keyinit:
	device_destroy(mod_device.class,mod_device.devid);
fail_device:	
	class_destroy(mod_device.class);
fail_class:	
	cdev_del(&mod_device.cdev);
fail_cdev:
	unregister_chrdev_region(mod_device.devid,DeviceNodes);
fail_chrdev:
	return ret;
}
/*
 * @description	: 驱动出口函数
 * @param 		: 无
 * @return 		: 无
 */
static void __exit key0_interrupt_exit(void)/*按照相反顺序注销*/
{
	/*1、释放中断*/
	free_irq(mod_device.irqkey0.irq_num, &mod_device);
	/*2、内核定定时器注销部分*/
	del_timer_sync(&mod_device.timer);/* 删除timer */
	/*3、LED设备注销部分*/
	gpio_free(mod_device.irqkey0.gpio_num);/*注销gpio*/		
	/*4、设备驱动注销部分*/			
	device_destroy(mod_device.class,mod_device.devid);/*注销设备节点*/
	class_destroy(mod_device.class);/*注销类*/
	cdev_del(&mod_device.cdev);/*注销cdev*/
	unregister_chrdev_region(mod_device.devid,DeviceNodes);/*注销chrdev*/
}
module_init(key0_interrupt_init);
module_exit(key0_interrupt_exit);
MODULE_LICENSE("GPL");

六、work方式实现下半部的驱动程序

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.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_irq.h>
#include <linux/gpio.h>
#include <linux/of_gpio.h>
#include <linux/string.h>
#include <linux/irq.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>
#include <linux/interrupt.h>
#define DeviceName 		"devicetree-key0-interrupt-work" //设备驱动名称
#define DeviceNodes 	1 					  	 //设备节点个数
#define KEY_NUM 		0X01             
#define KEY0VALUE       0X01
#define INVAKEY         0XFF
struct irq_keydesc{
    int gpio_num;           /* io编号 */
    int irq_num;            /* 中断号 */
    unsigned char value;    /* 键值 */
    char name[25];          /* 名字 */
    irqreturn_t (*handler) (int, void *);  /* 中断处理函数 */
	struct tasklet_struct tasklet;
};
/* 定义一个设备结构体 */
struct mod_struct {
	dev_t devid;			     /* 设备号 */
	int major;				     /* 主设备号 */
	int minor;				     /* 次设备号 */
	struct cdev cdev;		     /* cdev */
	struct class *class;	  	 /* 类 */
	struct device *device;	 	 /* 设备 */
	struct device_node *nd;  	 /* 设备节点 */
	struct irq_keydesc irqkey0;  /* 按键中断 */
	struct timer_list timer;	 /* 内核定时器 */
	struct work_struct work;     /* 工作队列 */
	
	atomic_t keyvalue;			 /* 原子变量1->整形*/
    atomic_t releasekey;		 /* 原子变量2->整形*/
};
struct mod_struct mod_device;	 /* 定义一个设备 */
/*
 * @description		: 打开设备
 * @param - inode 	: 传递给驱动的inode
 * @param - filp 	: 设备文件，file结构体有个叫做private_data的成员变量
 * 					  一般在open的时候将private_data指向设备结构体。
 * @return 			: 0 成功;其他 失败
 */
static int key0_interrupt_open(struct inode *inode, struct file *filp)
{
	filp->private_data = &mod_device; /* 设置私有数据 */
	return 0;
}
/*
 * @description		: 从设备读取数据 
 * @param - filp 	: 要打开的设备文件(文件描述符)
 * @param - buf 	: 返回给用户空间的数据缓冲区
 * @param - cnt 	: 要读取的数据长度
 * @param - offt 	: 相对于文件首地址的偏移
 * @return 			: 读取的字节数，如果为负值，表示读取失败
 */
static ssize_t key0_interrupt_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
{
    int ret = 0;
    unsigned char keyvalue;
    unsigned char releasekey;
    struct mod_struct *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 ret;

data_error:
    return -EINVAL;
}
/*
 * @description		: 向设备写数据 
 * @param - filp 	: 设备文件，表示打开的文件描述符
 * @param - buf 	: 要写给设备写入的数据
 * @param - cnt 	: 要写入的数据长度
 * @param - offt 	: 相对于文件首地址的偏移
 * @return 			: 写入的字节数，如果为负值，表示写入失败
 */
static ssize_t key0_interrupt_write(struct file *filp, const char __user *buf,size_t cnt, loff_t *offt)
{

	return 0;
}
/*
 * @description		: 关闭/释放设备
 * @param - filp 	: 要关闭的设备文件(文件描述符)
 * @return 			: 0 成功;其他 失败
 */

static int key0_interrupt_release(struct inode *inode, struct file *filp)
{
	return 0;
}
/* 设备操作函数 */
static struct file_operations beep_fops = {
	.owner    	=  THIS_MODULE,
	.open     	=  key0_interrupt_open,
	.read     	=  key0_interrupt_read,
	.write    	=  key0_interrupt_write,
	.release  	=  key0_interrupt_release,
};
/* 按键中断处理函数 */
static irqreturn_t key0_handler(int irq, void *dev_id)
{
	struct mod_struct *dev = dev_id;
	#if 0
	dev->timer.data = (volatile long)dev_id;
	mod_timer(&dev->timer, jiffies + msecs_to_jiffies(20)); /* 20ms定时 */
	#endif
	//tasklet_schedule(&dev->irqkey0.tasklet);
	schedule_work(&dev->work);
	return IRQ_HANDLED;
}
/* tasklet (下半部方法1)*/
static void key_tasklet(unsigned long data)
{
    struct mod_struct *dev = (struct mod_struct*)data;
    dev->timer.data = data;
    mod_timer(&dev->timer, jiffies + msecs_to_jiffies(20)); /* 20ms定时 */
}
/* work (下半部方法2)*/
static void key_work(struct work_struct *work)
{
	struct mod_struct *dev = container_of(work, struct mod_struct, work);
	dev->timer.data = (unsigned long)dev;
    mod_timer(&dev->timer, jiffies + msecs_to_jiffies(20)); /* 20ms定时 */ 
}
/* 定时器处理函数 */
static void timer_func(unsigned long arg) {
    int value = 0;
    struct mod_struct *dev = (struct mod_struct*)arg;

    value = gpio_get_value(dev->irqkey0.gpio_num);
    if(value == 0)   {          /* 按下 */
        atomic_set(&dev->keyvalue, dev->irqkey0.value);/*=0x01*/
    } else if(value == 1) {     /* 释放 */
        atomic_set(&dev->keyvalue, 0X80 | (dev->irqkey0.value));
        atomic_set(&dev->releasekey, 1);  /* 完成的按键过程 */
    }
}
/*
 * @description	: 按键初始化函数
 * @param 		: dev
 * @return 		: 无
 */
static int key_init(struct mod_struct *dev)
{
	int ret = 0;
	/* 1、获取设备节点：/devicetree-leds-pincrl */
	dev->nd = of_find_node_by_path("/devicetree-key0-interrupt");
	if(dev->nd == NULL) {
			printk("devicetree-key0-interrupt node not find!\r\n");
			ret = -EINVAL;
			goto fail_fd;
	} else {
		printk("devicetree-key0-interrupt node find!\r\n");
	}
	/* 2、从设备节点下的led-gpio属性里获取gpio编号 */
	dev->irqkey0.gpio_num = of_get_named_gpio(dev->nd,"key-gpio", 0);
	if(dev->irqkey0.gpio_num < 0) {
			printk("can't get key-gpio\r\n");
			ret = -EINVAL;
			goto fail_gpio;
	}
	printk("key-gpio num = %d\r\n", dev->irqkey0.gpio_num);
	/*3、申请gpio(检查是否被占用)*/
	sprintf(dev->irqkey0.name,"%s","key0-gpio-interrupt");
	ret = gpio_request(dev->irqkey0.gpio_num,dev->irqkey0.name);
	if(ret)
	{
		ret = -EBUSY;
		printk("IO %d busy,can't request!\r\n",dev->irqkey0.gpio_num);
		goto fail_ioreq;
	}
	/*4、设置key0为输入 */
	ret = gpio_direction_input(dev->irqkey0.gpio_num);
	if(ret < 0) {
			printk("can't set gpio!\r\n");
			goto fail_ioset;
	}
	/*5、根据IO编号获取其中断号*/
	dev->irqkey0.irq_num=gpio_to_irq(dev->irqkey0.gpio_num);
#if 0
	dev->irqkey0.irq_num = irq_of_parse_and_map(dev->nd,0);
#endif
	/*6、设置中断函数*/
	dev->irqkey0.handler = key0_handler;
    dev->irqkey0.value  = KEY0VALUE;
	/*7、注册中断*/
	ret = request_irq(dev->irqkey0.irq_num,
					  dev->irqkey0.handler,
					  IRQF_TRIGGER_RISING|IRQF_TRIGGER_FALLING,
					  dev->irqkey0.name,
					  &mod_device);
	if(ret){
		printk("irq %d request failed!\r\n", dev->irqkey0.irq_num);
		goto fail_irq;
	}
	INIT_WORK(&dev->work,key_work);
	//tasklet_init(&dev->irqkey0.tasklet, key_tasklet, (unsigned long)dev);
	/*8、初始化定时器*/
	init_timer(&mod_device.timer);
    mod_device.timer.function = timer_func;
	return 0;
fail_irq:
fail_ioset:
	gpio_free(dev->irqkey0.gpio_num);
fail_ioreq:
fail_gpio:
fail_fd:
	return ret;
}
/*
 * @description	: 驱动出口函数
 * @param 		: 无
 * @return 		: 无
 */
static int __init key0_interrupt_init(void)
{
	int ret = 0;
/*一、 注册字符设备驱动 */
	/* 1、创建设备号 */
	if (mod_device.major)
	{		
		mod_device.devid = MKDEV(mod_device.major,0);//设备号起始点(major,0)
		//设备号起始点开始，申请DeviceNodes个设备号
		ret = register_chrdev_region(mod_device.devid,DeviceNodes,DeviceName);
	} 
	else {
		ret = alloc_chrdev_region(&mod_device.devid,0,DeviceNodes,DeviceName);	/* 申请设备号 */
		mod_device.major = MAJOR(mod_device.devid);	/* 获取分配号的主设备号 */
		mod_device.minor = MINOR(mod_device.devid);	/* 获取分配号的次设备号 */	
	}
	if(ret < 0){ printk("设备号申请失败\r\n");goto fail_chrdev; }
	printk("mod_device major=%d,minor=%d\r\n",mod_device.major,mod_device.minor);	
	/* 2、初始化cdev并添加cdev */
	mod_device.cdev.owner = THIS_MODULE;
	cdev_init(&mod_device.cdev,&beep_fops);
	ret = cdev_add(&mod_device.cdev,mod_device.devid,DeviceNodes);
	if(ret < 0){ printk("添加cdev失败！\r\n");goto fail_cdev; }
	/* 3、创建类 */
	mod_device.class = class_create(THIS_MODULE,DeviceName);
	if (IS_ERR(mod_device.class)) { ret = PTR_ERR(mod_device.class);goto fail_class; } 
	/* 4、创建设备节点*/
	mod_device.device = device_create(mod_device.class,NULL,mod_device.devid,NULL,"pinctrl-key0-interrupt-work");
	if (IS_ERR(mod_device.device)) { ret = PTR_ERR(mod_device.device);goto fail_device; }
	/* 5、初始化IO */
    ret = key_init(&mod_device);
    if(ret < 0) {
        goto fail_keyinit;
    }
	/* 6、初始化原子变量 */
	atomic_set(&mod_device.keyvalue, INVAKEY);/*mod_device.keyvalue=INVAKEY*/
    atomic_set(&mod_device.releasekey, 0);/*mod_device.releasekey=0*/
    return 0;
/*X、模块加载失败处理部分*/
fail_keyinit:
	device_destroy(mod_device.class,mod_device.devid);
fail_device:	
	class_destroy(mod_device.class);
fail_class:	
	cdev_del(&mod_device.cdev);
fail_cdev:
	unregister_chrdev_region(mod_device.devid,DeviceNodes);
fail_chrdev:
	return ret;
}
/*
 * @description	: 驱动出口函数
 * @param 		: 无
 * @return 		: 无
 */
static void __exit key0_interrupt_exit(void)/*按照相反顺序注销*/
{
	/*1、释放中断*/
	free_irq(mod_device.irqkey0.irq_num, &mod_device);
	/*2、内核定定时器注销部分*/
	del_timer_sync(&mod_device.timer);/* 删除timer */
	/*3、LED设备注销部分*/
	gpio_free(mod_device.irqkey0.gpio_num);/*注销gpio*/		
	/*4、设备驱动注销部分*/			
	device_destroy(mod_device.class,mod_device.devid);/*注销设备节点*/
	class_destroy(mod_device.class);/*注销类*/
	cdev_del(&mod_device.cdev);/*注销cdev*/
	unregister_chrdev_region(mod_device.devid,DeviceNodes);/*注销chrdev*/
}
module_init(key0_interrupt_init);
module_exit(key0_interrupt_exit);
MODULE_LICENSE("GPL");

七、APP测试程序

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
/*
 *argc:应用程序参数个数
 *argv[]:具体的参数内容，字符串形式 
 *./imx6uirqAPP  <filename>  
 * ./imx6uirqAPP /dev/mx6uirq
 */
int main(int argc, char *argv[])
{
    int fd, ret;
    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", filename);
        return -1;
    }
    /* 循环读取 */
    while(1) {
        ret = read(fd, &data, sizeof(data));
        if(ret < 0) {	
        } else {
            if(data)
                printf("key value = %#x\r\n", data);
        }
    }
    close(fd);
    return 0;
}

八、看完别走，你还有两件事没做

1、欢迎加入全国大学生电子交流群下载源码历程
在这里插入图片描述
2、点个赞呗
在这里插入图片描述

Bao@Ting
关注
专栏目录
I.MX6U 学习笔记八------Cortex-A中断原理和GPIO中断实验
我不会飞的博客
04-12 424
Cortex-A7中断系统 Cortex-A7中断向量表 中断向量表主要功能是描述了中断对应的中断服务函数。 Cortex-A7中断向量表有8个中断，其中重点关注IRQ。需要用户自己去定义中断向量表。 中断向量表偏移 裸机例程都是从0x87800000开始的，因此要设置中断向量偏移。 GIC中断控制器 同NVIC一样，GIC用于管理Cortex-A7的中断。GIC提供了开关中断，设置优先级。 IMX6U中断号 为了区分不同的中断，引入了中断号。ID0-15是给SGI，16-31是给PPI，剩
IMX6ULL-CORE-V1.4(核心板原理图).pdf
03-08
《IMX6ULL-CORE-V1.4核心板原理图详解》 IMX6ULL CORE V1.4是一款基于NXP公司i.MX6ULL处理器的核心板，它在电子设计领域有着广泛的应用，尤其在嵌入式系统和物联网(IoT)设备中。这款核心板的原理图详细地描绘了其...
imx6ull中断系统 一
monkea123的博客
11-06 1651
Cortex-A7 中断系统简介 IRQ中断 复位中断(Rest)， CPU 复位以后就会进入复位中断，我们可以在复位中断服务函数里面做一些初始化工作，比如初始化 SP 指针、 DDR 等等。 未定义指令中断(Undefined Instruction)，如果指令不能识别的话就会产生此中断。 软中断(Software Interrupt,SWI)，由 SWI 指令引起的中断， Linux 的...
Cortex-A7的GIC（通用中断控制器）使用方法（2）：GIC寄存器介绍
最新发布
kevin1499的博客
08-18 433
Cortex-A7的GIC（通用中断控制器）使用方法（2）：GIC寄存器介绍。
imx6ull中断分析
qq_40831436的博客
05-12 1668
imx6ull中断控制器使用GIC（通用中断控制器），功能框图如下图所示： GIC 主要分为分发器（Distributor）和 CPU 接口（CPU interface/Virtual CPU interface）。 分发器（Distributor）：分发器用于管理 CPU 所有中断源，确定每个中断的优先级，管理中断的屏蔽和中断抢占。最终将优先级最高的中断转发到一个或者多个 CPU 接口。 (也就是每次分发一个中断)。 分发器的作用： • 全局的开启或关闭 CPU 的中断。 • 控制任意一个中断请求的开启
IMX6ULL_中断笔记
m0_46703823的博客
01-05 727
linux内核提供了完善的中断框架 1> 什么是中断号? 每个中断都有一个中断号，通过中断号即可区分不同的中断 中断号也叫中断线 在linux中使用int变量来表示中断号 2> 中断申请函数 request_irq() int request_irq(unsigned int irq, irq_handler_t handler, unsigned long flags,const char *name, void *dev); irq: 要申请的中断对应的 中断号 handler: 中断处理
I.MX6ull 中断 一
TyearLin的专栏
06-02 352
Cortex-A7内核有8个异常中断，这8个异常中断的中断向量表如下表所示：Cortex-A 内核 CPU 的所有外部中 断都属于这个 IRQ 中断，当任意一个外部中断发生的时候都会触发 IRQ 中断。在 IRQ 中断服 务函数里面就可以读取指定的寄存器来判断发生的具体是什么中断，进而根据具体的中断做出 相应的处理。
iTOP-iMX6ULL_开发板-FFmpeg_移植实现视频采集-综合文档
05-14
在iTOP-iMX6ULL开发板上移植FFmpeg，可以帮助开发者充分利用这款嵌入式设备的硬件资源，实现高效稳定的视频采集与处理功能。iMX6ULL是NXP公司推出的一款基于ARM Cortex-A7内核的低功耗微处理器，适用于各种嵌入式...
datasheet-imx6ULL-rm-.rar
09-23
IMX6ULL是一款基于ARM Cortex-A7架构的嵌入式微处理器，由NXP（恩智浦）公司设计生产。这款芯片广泛应用于物联网(IoT)、工业控制、汽车电子和消费类电子产品等领域，因其低功耗、高性能和丰富的外设接口而受到青睐。...
交叉编译 IMX6ULL--Opencv4.5.1---release
02-20
交叉编译是软件开发中的一个重要概念，特别是在嵌入式系统领域，如IMX6ULL这样的处理器平台上。当我们在X86架构的主机上为ARM架构的目标设备（如IMX6ULL）编译代码时，需要用到交叉编译工具链。在这个案例中，使用的...
IMX6ULL-ALPHA-V2.1(底板原理图).pdf
03-08
文档"IMX6ULL-ALPHA-V2.1(底板原理图).pdf"和"IMX6UL_ALPHA_V2"标签所关联的是基于IMX6ULL芯片的电路设计，这是一个嵌入式系统的底板原理图。这个系统设计用于驱动各种组件和接口，包括电源管理、显示接口、存储卡...
imx6q platform中断驱动
04-03
自己写的中断驱动，在飞凌的板子上使用，结合压缩包中的pdf学习使用
IMX6LL|中断详解
m0_73731708的博客
01-17 1221
通用中断控制器（General Interrupt Controller，GIC）是一种硬件设备，通常用于处理多核处理器或多处理器系统中的中断。GIC 负责接收来自各个设备和处理器内核的中断信号，并根据优先级和配置规则将这些中断分派给适当的处理器核心进行处理。GIC 的工作原理如下：中断请求：外设或处理器核心会向 GIC 发送中断请求信号，表示产生了一个中断。中断分发：GIC 根据中断请求的类型、优先级和配置规则，决定将中断分派给哪个处理器核心进行处理。
【嵌入式Linux】i.MX6ULL GPIO 中断管理与配置函数
Beihai_Van的博客
06-26 1038
- 本文章结合了正点原子的 i.mx6u嵌入式Linux开发指南和笔者的理解。 - 前面我们进行了总的外部中断处理函数（system_irqhandler）的初始化，在这个函数中同个中断号，选择跳转到了不同的中断服务函数 - 下面我们就来写一个具体的中断服务函数，本文将具体编写**GPIO 中断管理与配置函数**
i.MX6ULL(五) 中断（按键驱动蜂鸣器）
TyearLin的专栏
06-03 667
中断向量表 2 定义对应的中断函数 2.1 复位函数 CP15协处理器 Cotex-A7 参考手册 107页面 关闭I,DCache和MMU SCTLR寄存器 系统控制寄存器中断向量偏移设置 将新的中断向量表首地址写入到CP15 的VBAR 寄存器 mcr p15, 0, r0, c12, c0, 0注意 读改写顺序 分支预测(Branch Prediction)： 解决处理分支指令导致流水线失败的数据处理方法 。从P5时代开始的一种先进的，解决处理分支指令（if-then-else
Cortex-A7---IMX6ULL中断系统gpio外部中断配置
DWH的博客
05-18 2717
一，Cortex-A7 中断系统 Cortex-A7 内核有 8 个异常中断 跟 STM32 一样， Cortex-A7 也有中断向量表，中断向量表也是在代码的最前面。 CortexA7 内核有 8 个异常中断，这 8 个异常中断的中断向量表如下图 复位中断(Rest)， CPU 复位以后就会进入复位中断， 我们可以在复位中断服务函数里面做一些初始化工作，比如初始化 SP 指针、DDR 等等。 未定义指令中断(Undefined Instruction)，如果指令不能识别的话就会产生此中断。 软中断(So
IMX6ULL裸机之UART串口通信（中断）
weixin_42963900的博客
02-21 405
imx6ull 裸机之UART串口通信（中断）
IMX6ULL学习笔记（18）——GPIO中断
Leung的博客
03-15 1763
一、中断简介 相比 STM32 的 NVIC，IMX6ULL 的中断控制系统更复杂，它的中断管理器使用的是 GIC V2，GIC V2 的实现方式与我们熟知的 NVIC 差别较大。 1.1 GIC GIC（Generic Interrupt Controller），直译为通用中断控制器，它是 ARM 公司给 Cortex-A/R 内核提供的一个中断控制器，类似 Cortex-M 内核中的NVIC。目前共有 4 个版本 V1~V4，IMX6ULL 使用的是 GIC V2。GIC V2 是给 ARMv7-
imx6ull中断设备树以及对应驱动相关的知识点的理解
ldysl111的博客
11-17 1069
imx6ull中断设备树以及对应驱动相关的知识点的理解
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值