Linux内核中断实验

已于 2023-10-21 19:05:59 修改
阅读量297 收藏 3
点赞数
分类专栏： Linux驱动开发 文章标签： linux 嵌入式硬件 驱动开发
于 2023-03-20 21:38:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51144400/article/details/129676328
版权

实验说明：
        当按键按下时，发生中断，在中断函数里开启定时器计时。其中中断程序分为上下半部两部分，上半部进行处理中断程序的调度工作，下半部分开启定时器，在定时是到达设定时间以后，程序进入定时器处理函数，完成按键值的读取。

        在设备树下加入如下程序段：

key {
 			compatible = "atkalpha-key";
			pinctrl-names="default";
			pinctrl-0=<&pinctrl_key>; 
			cd-gpio=<&gpio1 18 GPIO_ACTIVE_LOW>;
			interrupt-parent=<&gpio1>;
			interrupts=<18 IRQ_TYPE_EDGE_BOTH>;
 			status = "okay";	
 		};

程序说明：

1、设置 interrupt-parent 属性值为“ gpio1 ”，因为 KEY0 所使用的 GPIO 为 GPIO1_IO18，也就是 设置 KEY0 的 GPIO 中断控制器为 gpio1 ；
2、设置 interrupts 属性， 也就是设置中断源，指定中断号与触发方式 。第一个 cells 的 18 表示 GPIO1 组的 18 号 IO 。 IRQ_TYPE_EDGE_BOTH中断触发方式。

Linux内核驱动程序：

#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/slab.h>
#include <linux/fs.h>
#include <linux/io.h>
#include <linux/gpio.h>
#include <linux/errno.h>
#include <asm/io.h>
#include <asm/uaccess.h>
#include <asm/mach/map.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/of_gpio.h>
#include <linux/timer.h>
#include <linux/ioctl.h>

#define KEY_CNT 1
#define KEY_NAME "key"

#define KEYVALUE 0XFE
#define KEYNOVALUE 0

/*按键结构体*/
struct irq_keydesc{
    int key_gpio;/*IO编号*/
    int irqnum;/*中断号*/
    unsigned char value;/*键值*/
    char name[10];/*名字*/
    irqreturn_t (*handler)(int, void *);	/* 中断服务函数 */
};

/*设备结构体*/
struct key_dev {
    int major;
    int minor;
    dev_t devide;//设备号
    struct cdev cdev;
    struct class *class;
    struct device *device;
    struct device_node * bl_nd1;/*设备节点*/
    struct timer_list timer;/*定义一个定时器*/
    unsigned long timerperiod;/*定义一个周期*/
    atomic_t keyvalue;
    atomic_t releasekey;	/* 标记是否完成一次完成的按键，包括按下和释放 */
    struct irq_keydesc irq_keydesc;/*按键结构体*/
    struct tasklet_struct tasklet;
};

struct key_dev key;
/*
 * @description		: 打开设备
 * @param - inode 	: 传递给驱动的inode
 * @param - filp 	: 设备文件，file结构体有个叫做private_data的成员变量
 * 					  一般在open的时候将private_data指向设备结构体。
 * @return 			: 0 成功;其他 失败
 */
 static int key_open(struct inode *inode, struct file *filp)
{
    filp->private_data = &key; /* 设置私有数据 */
	printk("irqkey open!\r\n");
	return 0;
}

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


/*
 * @description		: 从设备读取数据 
 * @param - filp 	: 设备文件，表示打开的文件描述符
 * @param - buf 	: 要写给设备写入的数据
 * @param - cnt 	: 要写入的数据长度
 * @param - offt 	: 相对于文件首地址的偏移
 * @return 			: 读取的字节数，如果为负值，表示读取失败
 */
static ssize_t key_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
{
    struct key_dev *dev=(struct key_dev * )filp->private_data;
    int value;
    int valuerelease;
    int ret;
    value=atomic_read(&dev->keyvalue);
    valuerelease=atomic_read(&dev->releasekey);
    ret = copy_to_user(buf, &value, sizeof(value));
	return ret;
}

/*
 * @description		: 关闭/释放设备
 * @param - filp 	: 要关闭的设备文件(文件描述符)
 * @return 			: 0 成功;其他 失败
 */
static int key_release(struct inode *inode, struct file *filp)
{
    struct key_dev *dev=(struct key_dev * )filp->private_data;
	printk("key release！\r\n");
	return 0;
}


static struct file_operations key_ops={
    .owner=THIS_MODULE,
    .open=key_open,
    .release=key_release,
    .write=key_write,
    .read=key_read,
};


/* @description		: 中断服务函数，开启定时器，延时10ms，
 *				  	  定时器用于按键消抖。
 * @param - irq 	: 中断号 
 * @param - dev_id	: 设备结构。
 * @return 			: 中断执行结果
 */
static irqreturn_t key0_handler(int irq, void *dev_id)
{
    int value=0;
    struct key_dev *dev=dev_id; 
    tasklet_schedule(&key.tasklet);
    return IRQ_HANDLED;
}

static void key_tasklet(unsigned long data)
{
    struct key_dev *dev=(struct key_dev *)data;
    printk("key_tasklet\n");
    dev->timer.data=data;
    mod_timer(&key.timer,jiffies+msecs_to_jiffies(20));/*开启定时器*/
}


/*定时器回调函数*/
void timer_function(unsigned long t)
{  
    struct key_dev *dev=(struct key_dev * )t;
    static int sta=0;
    int value=0;
    //dev->timerperiod=1000;
    unsigned long period;
    value = gpio_get_value(dev->irq_keydesc.key_gpio); 	/* 读取IO值 */
	
    if(value == 0){ 						/* 按下按键 */
		atomic_set(&dev->keyvalue, value);
	}
	else{ 									/* 按键松开 */
		atomic_set(&dev->keyvalue, 1);			
	}
    //mod_timer(&key.timer,jiffies+msecs_to_jiffies(period));
    printk("jiffies=%#x\n",jiffies);
    printk("keyvalue=%d\n",dev->keyvalue);
}

/*按键初始化*/
static int irqkey_init(void)
{
    int ret=0;

    /*获取设备节点*/
    key.bl_nd1=of_find_node_by_path("/key");
    if(key.bl_nd1==NULL)
    {
        printk("of_find_node_by_path failed\r\n");
        ret = -EINVAL;
        goto fail_nd;
    }
    /*获取设备cd-gpio属性的第一个GPIO编号*/
    key.irq_keydesc.key_gpio=of_get_named_gpio(key.bl_nd1,"cd-gpio",0);
    if(key.irq_keydesc.key_gpio<0)
    {
        printk("of_get_named_gpio failed\r\n");
        ret = -EINVAL;
        goto fail_naned;
    }

    /*申请一个GPIO管脚*/
    ret=gpio_request(key.irq_keydesc.key_gpio,"cd-gpio");
    if(ret==0){
        printk("gpio_requests success\n");
    }

    /*将GPIO设置为输出，默认输出高电平*/
    ret=gpio_direction_input(key.irq_keydesc.key_gpio);
    if(ret<0)
    {
        printk("gpio_direction_input failed\n");
        ret = -EINVAL;
        goto fail_input;
    }


    /*获取中断号*/
    key.irq_keydesc.irqnum = gpio_to_irq(key.irq_keydesc.key_gpio);

    /*按键中断初始化*/
    key.irq_keydesc.handler = key0_handler;
    key.irq_keydesc.value = KEYNOVALUE;

    ret = request_irq(key.irq_keydesc.irqnum, key.irq_keydesc.handler, 
		                 IRQF_TRIGGER_FALLING|IRQF_TRIGGER_RISING, "irqkey", 				&key);
		if(ret < 0){
			printk("irq %d request failed!\r\n", key.irq_keydesc.irqnum);
			ret = -EFAULT;
            goto fail_irq;
        }

        /*初始化tasklet*/
        tasklet_init(&key.tasklet,key_tasklet,(unsigned long)&key);


    /*初始化定时器*/
    init_timer(&key.timer);
    key.timer.function=timer_function;
    //timerled.timer.expires=jiffies+msecs_to_jiffies(1000);
    key.timer.data=(unsigned long)&key;
    //timerled.timerperiod=5000;
    //add_timer(&timerled.timer);/*启动定时器*/ 

    return 0;
    fail_irq:
    fail_input:
         gpio_free(key.irq_keydesc.key_gpio);    
    fail_naned:
    fail_nd:
        return ret;
}
static int __init keey_init(void)
{
    /*初始化原子变量*/
    atomic_set(&key.keyvalue,0);
    printk("keyvalue0=%d\n",key.keyvalue);
    atomic_set(&key.releasekey, 0);
    int ret=0;
       
	/*注册设备号*/
    key.major=0;
    if(key.major){
        key.devide=MKDEV(key.major,0);
        register_chrdev_region(key.devide,KEY_CNT,KEY_NAME);
    }else{
        ret=alloc_chrdev_region(&key.devide, 0, KEY_CNT, KEY_NAME);	/* 申请设备号 */
		if(ret<0)
            {
                goto fail_devide;
            }
        key.major = MAJOR(key.devide);	/* 获取分配号的主设备号 */
		key.minor = MINOR(key.devide);	/* 获取分配号的次设备号 */
        printk("major=%d\n",key.major);
        printk("minor=%d\n",key.minor);
    }


     /*初始化cdev*/
    key.cdev.owner=THIS_MODULE;
    cdev_init(&key.cdev, &key_ops);
    
	
	/* 3、添加一个cdev */
	ret= cdev_add(&key.cdev, key.devide, KEY_CNT);
    if(ret<0)
        {
            goto fail_cdev;
        }

    //创建设备节点
	/* 4、创建类 */
	key.class = class_create(THIS_MODULE, KEY_NAME);
	if (IS_ERR(key.class)) {
		ret= PTR_ERR(key.class);
        goto fail_class;
	}

	/* 5、创建设备 */
	key.device = device_create(key.class, NULL, key.devide, NULL, KEY_NAME);
	if (IS_ERR(key.device)) {
		ret=PTR_ERR(key.device);
        goto fail_device;
	}  

    atomic_set(&key.keyvalue,KEYNOVALUE);
    ret=irqkey_init();
    if(ret<0)
    {
        printk("irqkey_init failed\n");
    }
   

    return 0;
    fail_device:
        class_destroy(key.class);
    fail_class:
        cdev_del(&key.cdev);
    fail_cdev:
        unregister_chrdev_region(key.devide, KEY_CNT);
    fail_devide:
        return ret;
}

static void __exit keey_exit(void)
{
    del_timer(&key.timer);
    gpio_free(key.irq_keydesc.key_gpio);
    free_irq(key.irq_keydesc.irqnum,&key);
   
    device_destroy(key.class,key.devide);
    class_destroy(key.class);
    cdev_del(&key.cdev);
    unregister_chrdev_region(key.devide, KEY_CNT);
    
    printk("exit\n");
    printk("exit\n");
}


/*模块的加载与卸载*/
module_init(keey_init);
module_exit(keey_exit);


MODULE_LICENSE("GPL");
MODULE_AUTHOR("liuchuanqiang");

程序说明：
1、获取中断号key.irq_keydesc.irqnum = gpio_to_irq(key.irq_keydesc.key_gpio);

int gpio_to_irq(unsigned int gpio)

函数参数和返回值含义如下：

gpio：要获取的 GPIO 编号。

返回值：GPIO 对应的中断号。

2、ret = request_irq(key.irq_keydesc.irqnum, key.irq_keydesc.handler,

                 IRQF_TRIGGER_FALLING|IRQF_TRIGGER_RISING, "irqkey", &key);

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、 tasklet_init(&key.tasklet,key_tasklet,(unsigned long)&key);初始化 tasklet

void tasklet_init(struct tasklet_struct *t,void (*func)(unsigned long), unsigned long data);

函数参数和返回值含义如下：

t：要初始化的 tasklet

func：tasklet 的处理函数。

data：要传递给 func 函数的参数

返回值：没有返回值。

4、 tasklet_schedule(&key.tasklet);在上半部，也就是中断处理函数中调用 tasklet_schedule 函数就能使 tasklet 在合适的时间运行。

void tasklet_schedule(struct tasklet_struct *t)

函数参数和返回值含义如下：

t：要调度的 tasklet

5、struct key_dev key;变量key的传递：

中断触发时，static irqreturn_t key0_handler(int irq, void *dev_id)//dev_id=&key;

执行tasklet函数时，static void key_tasklet(unsigned long data)//data=&key;

执行定时器回调函数，void timer_function(unsigned long t)//t=&key。

6、该实验程序的运行顺序：

         当按键按下时，发生中断，在中断函数里开启定时器计时。其中中断程序分为上下半部两部分，上半部进行处理中断程序的调度工作，下半部分开启定时器，在定时是到达设定时间以后，程序进入定时器处理函数，完成按键值的读取。

中断使用方式：

（1）获取中断号 int gpio_to_irq(unsigned int gpio)

（2）编写中断处理函数

（3）申请中断

        int request_irq(unsigned int irq, irq_handler_t handler, unsigned long flags, const char *name, void *dev)

（4）初始化tasklet

        void tasklet_init(struct tasklet_struct *t,void (*func)(unsigned long), unsigned long data)

  (5)在中断处理函数调用tasklet_schedule转到下半部

中断框架：

/* 定义 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);

        ......

}

7、中断的上半部与下半部：上半部直接在中断触发时就可响应，下半部则是将那些需要花费时间的中断处理放在下半部。

8、下半部的处理机制：软中断、tasklet、工作队列

行者甲
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux 中断实验
m0_69211839的博客
05-14 772
中断：CPU在正常运行期间，由外部或者内部引起的事件，让CPU停下当前正在运行的程序，转而去执行触发其他中断所对应的程序，这就是中断。中断上下文：中断的存在可以极大的提高CPU的运行效率，但是中断会打断内核进程中正常的调度和运行，所以为了保证系统的实时性，中断服务程序必须足够简短，但实际应用中某些中断必须要处理大量的事物，如果这些都在中断服务中完成，则会严重降低中断的实时性，基于这个原因，Linux系统提出把中断服务程序分为两个部分，即中断上文和中断下文。
linux开发之设备树四、设备树中断节点
qq_40170041的博客
05-29 330
表示那个引脚作为中断引脚，低电平触发中断，这里有两个值，从上面的#interrupt-cells = ;首先gpio0是一个标签（可以理解为名字），gpio0@fdd60000是这个节点的名称，fdd60000是这个gpio0的寄存器地址，这个只是为了取名字，实际可能没有意义，具体还要看内部其他参数。在节点中出现gpio-controller说明这是一个gpio控制器，出现interrupt-controller代表这是一个中断控制器，同时出现是因为gpio引脚也可以作为中断使用。
linux中断实验
lengyuefeng212的博客
08-05 535
文章目录一、linux中断简介1.linux中断API函数1.中断号2.request_irq函数3.free_irq4.中断处理函数5.中断使能与禁止函数2.上半部与下半部1.软中断2.tasklet3.工作队列3.设备树中断信息节点4.获取中断号二、硬件原理图分析三、实验程序编写1.修改设备树文件2.按键中断驱动程序编写3.编写测试APP四、运行测试 Linux 内核提供了完善的中断框架，我们只需要申请中断，然后注册中断处理函数即可，使用非常方便，不需要一系列复杂的寄存器配置。 一、linux中断简介
cortex-A7核中断实验（库）
Satellitex的博客
08-23 94
【代码】cortex-A7核中断实验（库）
cortex-A7核 中断实验（按键中断实验）
m0_72852022的博客
11-08 849
4）设置GICD层中断目标分配给那个CPU（cpu0 cpu1）3）设置中断不屏蔽，EXTI层中断转发到GIC层。3）设置GICD层中断优先级，需高于GICC层。1）设置GPIO引脚信号与EXTI进行连接。2）清除EXTI层中断挂起标志位。3）清除GICD层中断挂起标志位。2）设置GICC层中断优先级。2）设置中断信号的触发方式。2）设置GICD层中断使能。1）设置引脚为 输入模式。1）ARM中：延时消抖。1）使能GICD层使能。1）设置GICC层使能。4）清除获取到的中断号。1）使能GPIOF组。
linux内核实验教材1
08-04
在进行Linux内核实验时，了解其编程特点至关重要，这将有助于我们编写安全、高效的内核代码。 1.1 内核编程的特点 1.1.1 使用GNU C编写和开发内核程序：Linux内核主要使用C语言编写，同时兼容GNU扩展，因为GNU...
Linux内核和设备驱动程序实验报告
06-06
本实验报告将深入探讨Linux内核的结构、工作原理以及设备驱动程序的设计与实现。首先，我们需要理解Linux内核的主要组件，包括内存管理、进程调度、文件系统和网络协议栈等。这些组件共同构成了Linux内核的基础架构...
linux内核-miniShell课程实验.zip
最新发布
06-02
在这个“miniShell”课程实验中，我们将会深入理解Linux内核的工作原理，通过编写一个小型的命令行解释器——miniShell，来实践内核级编程的基本概念。 在Linux中，Shell是用户与操作系统之间的接口，它接收用户...
Linux内核时钟.doc
01-17
Linux内核时钟实验报告 Linux内核时钟是操作系统的核心组件之一，对于操作系统的性能和稳定性具有重要影响。在本实验报告中，我们将详细介绍Linux内核时钟的实现机理、时钟模块的设计和实现、时钟的应用程序设计等...
linux内核源代码分析中断处理程序与内核同步ppt课件.ppt
11-20
Linux内核源代码分析：中断处理程序与内核同步 在Linux操作系统中，中断处理程序扮演着至关重要的角色，它们负责响应硬件事件并进行相应的处理。中断处理分为上半部和下半部，这种设计是为了优化性能和确保系统的...
cortex - A7核中断实验——基于STM32MP157A
laoKdx的博客
10-04 1072
基于STM32MP157A的按键中断实验
linux内核实验中断,Linux内核的中断机制分析(栢图实验室)
weixin_36487107的博客
05-07 80
Linux内核的中断机制分析一、中断的概念中断是指在CPU正常运行期间，由于内外部事件或由程序预先安排的事件引起的CPU暂时停止正在运行的程序，转而为该内部或外部事件或预先安排的事件服务的程序中去，服务完毕后再返回去继续运行被暂时中断的程序。Linux中通常分为外部中断(又叫硬件中断)和内部中断(又叫异常)。在实地址模式中，CPU把内存中从0开始的1KB空间作为一个中断向量表。表中的每一项占4个字...
Linux驱动开发之按键中断实验【完整教程】
weixin_57037095的博客
03-22 3328
Linux驱动开发之按键中断实验【附有完整代码】
linux终端定时器实验报告,定时器实验报告.doc
weixin_35540389的博客
05-09 202
定时器实验报告实验六　定时器 / 计数器一、实验目的⒈　学会8253芯片和微机接口的原理和方法。掌握8253定时器/计数器的工作方式和编程原理。二、实验内容用8253的0通道工作在方式3，产生方波。三、实验接线图四、编程指南⒈　8253芯片介绍8253是一种可编程定时/计数器，有三个十六位计数器，其计数频率范围为0-2MHz， 用+5V单电源供电。8253的功能用途：延时中断　实时时钟可编程频率发...
中断实验(5)后续
Maximus_Tann的专栏
11-30 785
最后一个部分，因为以上代码都是在linux下完成的，完成后我们需要将他们编译成可执行文件放到板子上测试， 于是需要写一个Makefile文件来集中编译他们。 interrupt.bin:head.S init.c interrupt.c main.c //包含的文件 arm-linux-gcc -g -c -o head.o head.S
完全解析input子系统设备模型之mini2440按键驱动程序
wxie的Linux人生
03-24 2858
实现过程中参考了文章 http://blog.csdn.net/sylcrq/article/details/6174144 在此表示感谢   本人是成长中的菜鸟，经过三天三夜的琢磨，终于使按键驱动程序结合input子系统在mini2440上能够运行，下面将本人的成果展示如下,希望高手们不吝赐教；（代码红色部分为需要注意的地方）   驱动程序： #in
[工学]基于Linux内核的操作系统实验体系.ppt
12-22
"该文档是关于基于Linux内核的操作系统实验的详细介绍，涵盖了进程管理、存储管理、用户接口、模块编程、设备管理、文件系统以及操作系统的构成等多个方面的实验内容。通过这些实验，学生可以深入理解和实践操作系统...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值