linux驱动--中断&等待队列

于 2024-08-27 19:23:12 发布
阅读量620 收藏 8
点赞数 12
分类专栏： linux驱动 文章标签： linux 运维 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jcf5832/article/details/141608166
版权

1：中断的定义

        中断是计算机科学中的一个术语，指的是计算机在执行程序的过程中，由于某些紧急事件的发生，暂时中止当前程序的运行，转而去处理更为紧急的任务。处理完这些紧急任务后，计算机会返回到被中断的地方，继续执行原来的程序。

        通俗一点的理解方式为：中断即为系统异常，异常发生就会导致其他事件发生（中断服务函数），异常事件处理完毕后，事件回到正轨。

        中断会打断当前正在做的事情，转而执行中断服务函数事件（中断服务函数/中断回调函数）等待中断服务事件处理完毕后再执行之前的事件。

而在linux驱动中正常的时候->CPU处于SVC模式

发生中断的时候->CPU会从SVC模式转换成IRQ模式

                            SVC转IRQ需要改变 CPSR寄存器后 5bit

                             SVC转IRQ还需要保护现场（压栈->SP指针）

2：linux下的中断

linux的核心思想就是分层：

        中断也是如此，不管底层的中断控制有多复制，都无所谓，linux接口把所有的硬件的复杂度，靠中间层的接口控制所有的中断系统。

我们也把中断相关的linux下控制接口叫做-linux下中断子系统。

我所使用的是A系列芯片其中的中断控制：

管理中断的控制器->GIC（通用的中断控制器）

在STM系列中的管理中断的控制器为NVIC

在硬件手册中：

        中断分为三类：

SGI：软中断（0-15）

PPI：私有中断（16-31）

PPI的中断编号 +16 = 硬件中断编号

SPI：共享中断（从0到SPI_PORT）

        实际上硬件中断编号 = SPI_PORT+32

3：linux中断控制系统的接口

3.1 中断注册函数

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
)

函数功能：都是向内核注册一个中断

参数：

        dev：

                platform匹配成功后probe->新入口的传参

        irq：

                中断编号 填入硬件中断编号

                SPI_PORT + 32
                PPI_PORT + 16
                SGI_PORT

        handler：

                中断服务函数 

                irqreturn_t (*irq_handler_t)(int, void *);

        irqflags：
                中断触发类型：
                        IRQ_TYPE_NONE： 默认的触发类型
                        IRQ_TYPE_EDGE_RISING：上升沿触发
                        IRQ_TYPE_EDGE_FALLING：下降沿触发
                        IRQ_TYPE_EDGE_BOTH：上升沿下降沿都触发
                        IRQ_TYPE_LEVEL_HIGH：高电平触发
                        IRQ_TYPE_LEVEL_LOW：低电平触发

        dename：

                中断注册标签名字

        dev_id：

                传递给中断服务函数的第二个参数

3.2 注销函数

void *free_irq(unsigned int irq, void *dev_id)

irq:
        中断编号
dev_id:
        怎么传递给中断服务函数
        你就如何传递释放

  3.3 使能/失能中断

enable_irq(unsigned int irq)
disable_irq(unsigned int irq);

3.4 获取中断编号函数

int platform_get_irq(struct platform_device *dev, unsigned int num)

函数的功能：获取中断编号
参数：
        dev:
                匹配成功后的传参 probe->参数
        num:
                你要获取哪个中断号
                原则上就是 0
 返回值：
        返回中断的编号
        * 前提是这个设备树里面有：
        interrupts 属性！

int gpio_to_irq(unsigned gpio)

函数的功能：通过提供一个 GPIO 的编号
        给你返回对应这个引脚的 GPIO 的中断编号
参数 ：
        gpio-> GPIO 的编号 原则自己算
        尽量所有的信息来源于设备树
返回值：
        返回的也是中断编号

4：linux设备树中断的属性添加

interrupt-parent：
        可以被继承
        interrupt-parent=<&gic>
interrupts
        描述一个节点下的中断属性 现在有两种写法：
                中断父设备为 interrupt-parent=<&gic>
                直接编写 中断编号信息：
                interrupts = <GIC_SPI 326 IRQ_TYPE_LEVEL_HIGH>;
                        分组 编号 触发类型
        你的中断属性的父属性：
                interrupt-parent = <&gpio0>; 中断属性来源 gpio0 组
        GPIO 的中断属性：
                interrupts = <RK_PC4 IRQ_TYPE_LEVEL_LOW>;
        GPIO 小组 C 第四个引脚 触发类型
                示例按键设备树编写：

xyd_key {
    compatible = "xyd_key","xydkey","XYDKEY";
    xyd-gpios =<&gpio1 RK_PA4 GPIO_ACTIVE_LOW>;
    interrupt-parent = <&gpio1>;
    interrupts = <RK_PA4 IRQ_TYPE_LEVEL_HIGH>;
    status = "okay";
};

5：linux下按键中断代码的编写

#include "linux/kernel.h"
#include "linux/module.h"
#include "linux/of.h"
#include "linux/cdev.h"
#include "linux/fs.h"
#include "linux/gpio.h"
#include "linux/of_gpio.h"
#include "linux/device/class.h"
#include "linux/device.h"
#include "linux/platform_device.h"
#include "linux/miscdevice.h"
#include "asm/uaccess.h"
#include "linux/irq.h"
#include "linux/interrupt.h"
struct device_node * node =NULL;
struct platform_device * xydkeydev = NULL;
int gpio_num;
struct miscdevice * keymisc;
struct file_operations * ops;
int keyirqnum;
uint8_t value = 0;irqreturn_t mykey_irqhandler(int irqnum, void * arg)
{
    //一定按键按下了！
    value = gpio_get_value(gpio_num);
    return 0;
}
int xyd_key_open(struct inode * i , struct file * dev)
{
    //1: 获取中断号
    int ret = 0;
    keyirqnum = platform_get_irq(xydkeydev,0);
    printk("keyirqnum == %d\r\n",keyirqnum);
if(keyirqnum < 0)
{
    printk("ERROR!: keyirq is Error!\r\n");
    return -EIO;
}
//2：使能
//enable_irq(keyirqnum);//新开发
//3: 向内核注册一个中断
ret = devm_request_irq(&xydkeydev->dev,\
    keyirqnum,\
    mykey_irqhandler,\
    IRQ_TYPE_EDGE_FALLING,\
    "key_irq",NULL);
    ret = ret;
    return 0;
}
int xyd_key_close(struct inode * i , struct file * dev)
{
    //1: 释放中断
    free_irq(keyirqnum,NULL);
    //2: 失能中断
    //disable_irq(keyirqnum);
    return 0;
}
ssize_t xyd_key_read(struct file * file, char __user * buf, size_t
size, loff_t * offt)
{
    int ret = copy_to_user(buf,&value,1);value = 0xFF;
    ret = ret ;
    return 1;
}
int xyd_key_probe(struct platform_device * dev)
{
    node = dev->dev.of_node;
    xydkeydev = dev;
    //1: 获取 GPIO 的信息
    gpio_num = of_get_named_gpio(node,"xyd-gpios",0);
    //2: 申请 + 设置 输入
    gpio_request(gpio_num,"xyd_key");
    gpio_direction_input(gpio_num);
    //3:注册杂项设备
    keymisc = kzalloc(sizeof(struct miscdevice), GFP_KERNEL);
    ops = kzalloc(sizeof(struct file_operations), GFP_KERNEL);
    ops->owner = THIS_MODULE;
    ops->open = xyd_key_open;
    ops->release= xyd_key_close;
    ops->read = xyd_key_read;
    keymisc->minor = 255;
    keymisc->name = "xyd_key";
    keymisc->fops = ops;
    return misc_register(keymisc);
}
struct of_device_id xyd_id_table={
    .compatible = "xydkey",//匹配名字
};
struct platform_driver myxyd_key_driver={
    .driver={
    .name = "xyd_key",
    .of_match_table = &xyd_id_table,
    },
    .probe = xyd_key_probe,
};
static int __init mykey_init(void)
{
    return platform_driver_register(&myxyd_key_driver);
}
static void __exit mykey_exit(void)
{ }
module_init(mykey_init);
module_exit(mykey_exit);
MODULE_LICENSE("GPL");

6：等待队列

6.1 等待队列的意义

等待队列是目前内核最常用的阻塞同步机制之一

其中的作用为在内核层产生一个阻塞

等待队列的功能：

        阻塞->调用后立刻产生挂起

        wait_event（）

        唤醒->调用会唤醒之前挂起进程/程序

        wake_up

内核层的阻塞会引起上层的阻塞！

6.2 内核的阻塞机制

等待队列的创建：

        DECLARE_WAIT_QUEUE_HEAD(name);

等待队列阻塞函数：

wait_event_interruptible(wq,cond)

wq:
        等待队列变量 而非指针！
        struct wait_queue_head *wq_head
cond:
        如果是 非 0 ->无调用效果
        如果 0 -> 产生阻塞

解除阻塞：

wake_up_interruptible(x)

        x:等待队列的结构体指针 而非变量

struct wait_queue_head *wq_head

7：等待队列应用优化按键

#include "linux/kernel.h"
#include "linux/module.h"
#include "linux/of.h"
#include "linux/cdev.h"
#include "linux/fs.h"
#include "linux/gpio.h"
#include "linux/of_gpio.h"
#include "linux/device/class.h"
#include "linux/device.h"
#include "linux/platform_device.h"
#include "linux/miscdevice.h"
#include "asm/uaccess.h"
#include "linux/irq.h"
#include "linux/interrupt.h"
#include "linux/sched.h"
#include "linux/wait.h"
struct device_node * node =NULL;
struct platform_device * xydkeydev = NULL;
int gpio_num;
struct miscdevice * keymisc;
struct file_operations * ops;
int keyirqnum;
uint8_t value = 0;
int cond = 0;
//加一个 等待队列的结构体变量
DECLARE_WAIT_QUEUE_HEAD(xyd_key_wait);
irqreturn_t mykey_irqhandler(int irqnum, void * arg)
{
    //一定按键按下了！
    value = gpio_get_value(gpio_num);
    cond = 1;//原则上解除阻塞后再次判断
    wake_up_interruptible(&xyd_key_wait);
    return 0;
}
int xyd_key_open(struct inode * i , struct file * dev)
{
//1: 获取中断号
int ret = 0;
keyirqnum = platform_get_irq(xydkeydev,0);
printk("keyirqnum == %d\r\n",keyirqnum);
if(keyirqnum < 0)
{
printk("ERROR!: keyirq is Error!\r\n");
return -EIO;
}
    //2：使能
    //enable_irq(keyirqnum);//新开发
    //3: 向内核注册一个中断
    ret = devm_request_irq(&xydkeydev-            >dev,keyirqnum,mykey_irqhandler,IRQ_TYPE_EDGE_FALLING,"key_irq",NULL);
    ret = ret;
    return 0;
}
int xyd_key_close(struct inode * i , struct file * dev)
{
    //1: 释放中断
    free_irq(keyirqnum,NULL);
    //2: 失能中断
    //disable_irq(keyirqnum);
    return 0;
}
    ssize_t xyd_key_read(struct file * file, char __user * buf, size_t
size, loff_t * offt)
{
    cond = 0;
    wait_event_interruptible(xyd_key_wait,cond);//不管你按键有没有按下现阻塞在说
    int ret = copy_to_user(buf,&value,1);
    value = 0xFF;
    ret = ret ;
    return 1;
}
int xyd_key_probe(struct platform_device * dev)
{
    node = dev->dev.of_node;
    xydkeydev = dev;
    //1: 获取 GPIO 的信息
    gpio_num = of_get_named_gpio(node,"xyd-gpios",0);
    //2: 申请 + 设置 输入
    gpio_request(gpio_num,"xyd_key");
    gpio_direction_input(gpio_num);
    //3:注册杂项设备
    keymisc = kzalloc(sizeof(struct miscdevice), GFP_KERNEL);
    ops = kzalloc(sizeof(struct file_operations), GFP_KERNEL);
    ops->owner = THIS_MODULE;
    ops->open = xyd_key_open;
    ops->release= xyd_key_close;
    ops->read = xyd_key_read;keymisc->minor = 255;
    keymisc->name = "xyd_key";
    keymisc->fops = ops;
    return misc_register(keymisc);
}
    struct of_device_id xyd_id_table={
    .compatible = "xydkey",//匹配名字
};
struct platform_driver myxyd_key_driver={
    .driver={
        .name = "xyd_key",
        .of_match_table = &xyd_id_table,
    },
    .probe = xyd_key_probe,
};
static int __init mykey_init(void)
{
    return platform_driver_register(&myxyd_key_driver);//注册设备的驱动信息
}
static void __exit mykey_exit(void)
{ }
module_init(mykey_init);
module_exit(mykey_exit);
MODULE_LICENSE("GPL");

悟凡爱学习
关注
  • 12
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
linux中断--中断嵌套&中断请求丢失
鱼思故渊的专栏
04-14 1万+
关于中断嵌套： 在linux内核里，如果驱动在申请注册中断的时候没有特别的指定，do_irq在做中断响应的时候，是开启中断的，如果在驱动的中断处理函数正在执行的过程中，出现同一设备的中断或者不同设备的中断，这时候新的中断会被立即处理，还是被pending，等当前中断处理完成后，再做处理。 在2.4和2.6内核里，关于这一块是否有什么不同。 一般申请中断的时候都允许开中断，即不使用SA_I
Linux驱动等待队列与poll机制
weixin_44453694的博客
09-13 1061
当我们在操作设备时，我们经常遇到当设备获取不到资源时就会挂起进程，当设备资源满足要求时再唤醒进程(如read函数，当读不到数据时就会挂起，读到了数据则可立刻返回)。这种通过阻塞方式访问设备，可以极大的减轻CPU负荷，在进程挂起是可以让CPU去执行其它资源。而通过等待队列的方式就可实现进程阻塞，满足要求时再唤醒进程。因为阻塞的进程会进入休眠状态， 因此， 必须确保有一个地方能够唤醒休眠的进程。唤醒进程的地方最大可能发生在中断里面， 因为硬件资源获得的同时往往伴随着一个中断。
Linux驱动之等待队列
qq_53221728的博客
04-17 1112
Linux驱动之等待队列。定时器按键消抖、
linux设备驱动--内核等待队列知识点---结合中断使用
nanhangfengshuai的博客
01-18 613
等待队列：           在 Linux 驱动程序设计中，可以使用等待队列来实现进程的阻塞.           等待队列可以看作保存进程的容器，在阻塞进程时，将进程放入等待队列；           当唤醒进程时，从等待队列中取出进程. 等待队列的 定义 和 初始化 wait_queue_head_t    DECLARE_WAIT_QUEUE_HE
linux驱动---等待队列、工作队列、Tasklets
子木
02-03 4059
概述: 等待队列、工作队列、Tasklet都是linux驱动很重要的API,下面主要从用法上来讲述如何使用API. 应用场景： 等待队列（waitqueue） linux驱动中，阻塞一般就是用等待队列来实现，将进程停止在此处并睡眠下，直到条件满足时，才可通过此处，继续运行。当然在睡眠等待期间，是不定期来检查条件。 工作队列（workqueue） 工作队列，将一个work提交
Linux驱动 | HC-SR501红外热释电驱动(中断&内核线程)
欲盖弥彰1314
03-26 1708
HC-SR501红外热释电驱动
Linux驱动编程【中断】
m0_59756458的博客
05-04 958
一、获取设备树结点中断信息 /* 1.intc 节点就是I.MX6ULL 的中断控制器节点 */ intc: interrupt-controller@00a01000 { compatible = "arm,cortex-a7-gic"; #interrupt-cells = <3>; interrupt-controller; reg = <0x00a01000 0x1000>, <0x00a02000 0x100>; }; //#
【Linux】内核驱动篇八--中断处理
修成真的博客
05-24 1187
内核驱动篇八--中断处理一、什么是中断二、中断处理原理三、中断接口3.1 中断申请 3.2 中断释放3.3 中断处理函数原型四、按键驱动五、上半部与下半部六、下半部机制之tasklet ---- 基于软中断6.1 结构体6.2 定义tasklet的中断底半部处理函数6.3 初始化tasklet6.4 调度tasklet七、下半部机制之workqueue ----- 基于内核线程7.1 工作队列结构体：7.2 定义工作队列底半部处理函数7.3 初始化工作队列7.4 工作队列的调度函数八、按键驱动之work.
linux驱动之中断(二)---- 中断驱动程序(tasklet,workqueue,thread_irq)
qq_40684669的博客
11-06 974
中断驱动程序(tasklet,workqueue,thread_irq)
【Linux驱动】Linux的中断系统 | 中断的重要数据结构
weixin_63726869的博客
01-12 2216
讲解了Linux的中断体系，中断可以分为上下两部分，下半部分有三种处理方式，包括软件中断，内核线程，线程化等方式。还详细介绍了Linux中管理中断的irq_desc数组这个数据结构，以及产生中断后，CPU是如何通过这个数据结构调用中断处理函数的。
zyqn的linux驱动11-硬件中断
01-31
在Linux驱动程序开发中，硬件中断是连接操作系统与硬件设备之间的重要桥梁，它使得系统能够及时响应设备事件，如按键按下、网络数据包到达等。本教程将专注于“zyqn的Linux驱动11-硬件中断”，通过按键测试来深入...
linux中断--内核中断编程.docx
09-26
此外，中断处理还可以涉及中断共享、中断底半部（SoftIRQs）和任务队列（Tasklets）等概念，这些在更复杂的中断处理场景中会用到，用于异步处理中断事件，确保系统的响应速度和效率。 总之，Linux内核中断编程涉及...
Linux设备驱动-中断
Leo-夜空的博客
08-13 559
由于中断服务程序的执行并不存在于进程上下文中，所以要求中断服务程序的时间要尽量短。因此，Linux在中断处理中引入了顶半部和底半部分离的机制。
Linux基础知识（一、什么是Linux）
最新发布
心寒的博客
08-26 650
什么是Linux Linux创始人
Linux 线程的控制 互斥与同步
qq_63145217的博客
08-23 947
include //头文件sem_t sem;信号量的类型 信号量的变量。
多进程和多线程基础概念LINUX
2301_79109608的博客
08-22 1117
直接访问物理地址,会导致地址空间没有隔离,很容易导致数据被修改通过虚拟地址空间可以实现每个进程空间都是独立的，操作系统会映射到不用的物理地址区间，在访问时互不干扰.进程状态分为三个基本状态，即运行态，就绪态，阻塞态。在五态模型中，进程分为新建态、终止态，运行态，就绪态，阻塞态。并发：有限的 cpu 核芯的情况下 ,利用快速交替(时间片轮转)执行来达到宏观上的同时执行。虚拟地址 : 虚拟地址并不代表真实的内存空间,而是一个用于寻址的编号。并行：在 cpu 多核的支持下，实现物理上的同时执行。
虚拟内存和linux（操作系统part1）
linjixia的博客
08-24 612
八股之虚拟内存和Linux部分的笔记。
linux定期统计某个目录内每天的文件增量大小
mengbing1990的博客
08-21 205
每天统计一次前一天的日志量大小，并将每个目录的大小记录一份日志。 本测试脚本下，所有目录产生的日志均有固定格式，如每个目录不一样的话，需定义find语句中的name变量。
Linux中信号量相关接口及环形队列
2301_77479435的博客
08-22 338
Linux中信号量相关接口及环形队列
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值