Heim  >  Artikel  >  Betrieb und Instandhaltung  >  Was bedeutet die Linux-Interrupt-Nummer?

Was bedeutet die Linux-Interrupt-Nummer?

藏色散人
藏色散人Original
2023-03-20 10:09:452659Durchsuche

Die Linux-Interrupt-Nummer ist der Code, der vom System jeder Interrupt-Quelle zur Identifizierung und Verarbeitung im Interrupt-System im Vektor-Interrupt-Modus zugewiesen wird. Die CPU muss ihn verwenden, um die Eintragsadresse des Interrupt-Dienstprogramms zu finden und die Programmübertragung zu realisieren.

Was bedeutet die Linux-Interrupt-Nummer?

Die Betriebsumgebung dieses Tutorials: Linux5.9.8-System, Dell G3-Computer.

linux Was bedeutet die Interrupt-Nummer?

Interrupt-Nummer und Interrupt-Programmierung:

1. Interrupt-Nummer

Die Interrupt-Nummer ist der Codename, der vom System jeder Interrupt-Quelle zur einfachen Identifizierung und Verarbeitung zugewiesen wird. In einem Interrupt-System, das Vektor-Interrupts verwendet, muss die CPU damit die Eintragsadresse des Interrupt-Serviceprogramms finden und die Programmübertragung realisieren.

  Um Interrupts in ARM Bare Metal zu implementieren, müssen Sie Folgendes konfigurieren:

 I/O口为中断模式,触发方式,I/O口中断使能
 设置GIC中断使能,分发配置,分发总使能,CPU外部中断接口使能,中断优先级

  Um Interrupts im Linux-Kernel zu implementieren, müssen Sie nur Folgendes wissen:

中断号是什么,怎么得到中断号
中断处理方法

 2. So erhalten Sie die Interrupt-Nummer :

/arm/boot/dts/exynos4412-fs4412.dts

1) Sehen Sie sich das schematische Diagramm und das Chip -Handbuch an, um den SPI -Anschluss der Interrupt -Nummer zu finden, das der Interrupt -Quelle NO

Was bedeutet die Linux-Interrupt-Nummer?

2) den Gerätebaum in

eingeben arch/arm/boot/dts/exynos4x12-pinctrl.dtsi

gpx1: gpx1 {
                    gpio-controller;
                    #gpio-cells = <2>;

                    interrupt-controller;  //中断控制器
                    interrupt-parent = <&gic>;  //继承于gic
                    interrupts = <0 24 0>, <0 25 0>, <0 26 0>, <0 27 0>,
                                 <0 28 0>, <0 29 0>, <0 30 0>, <0 31 0>;
                    #interrupt-cells = <2>; //子继承的interrupts的长度
            };

  24, 25 usw. in Klammern entsprechen der SPI-Port-Nr., die oben genannten sind die Knoten, die im System definiert wurden

Bei der Programmierung müssen Sie Ihre eigenen Knoten definieren, um die Schaltflächen zu beschreiben und die bearbeitbaren zu öffnen Gerätebaumdatei:

arch/arm/boot/dts/exynos4412-fs4412, geben Sie die Datei ein.

  3) Definieren Sie den Knoten und beschreiben Sie die vom aktuellen Gerät verwendete Interrupt-Nummer

1 key_int_node{
2             compatible = "test_key";
3             interrupt-parent = ;  //继承于gpx1
4             interrupts = ;      //2表示第几个中断号,4表示触发方式为下降沿5         };               //interrupts里长度由父母的-cell决定
 Ein weiteres Beispiel: Legen Sie den Knoten von k4 fest --- GPX3_2 (XEINT26), die Interrupt-Nummer

1 key_int_node{
2              compatible = "test_key";
3              interrupt-parent = <&gpx3>;  //继承于gpx3
4              interrupts = <2 4>;      //2表示第2个中断号,4表示触发方式为下降沿
5          };

  So geht's Suchen Sie die Interrupt-Nummer:

  Sehen Sie sich den I/O-Pin GPX1_2 an, die Interrupt-Nummer ist die zweite in GPX1

 4) Kompilieren Sie den Gerätebaum: make dtbs

  Aktualisieren Sie die Gerätebaumdatei: cp -raf arch/ arm/boot/dts/exynos4412- fs4412.dtb /tftpboot/

 Sehen Sie sich die definierten Knoten an: im Verzeichnis proc/device-tree/ des Stammverzeichnisses

 

3. Implementieren Sie die Interrupt-Behandlungsmethode

Erhalten Sie es über den Code im Treiber zur Interrupt-Nummer und beantragen Sie einen Interrupt.

Werfen wir zunächst einen Blick auf die Interrupt-bezogenen Funktionen:

1 a,获取到中断号码:
 2     int get_irqno_from_node(void)
 3     {
 4         // 获取到设备树中的节点
 5         struct device_node *np = of_find_node_by_path("/key_int_node");
 6         if(np){
 7             printk("find node ok\n");
 8         }else{
 9             printk("find node failed\n");
10         }
11 
12         // 通过节点去获取到中断号码
13         int irqno = irq_of_parse_and_map(np, 0);
14         printk("irqno = %d\n", irqno);
15         
16         return irqno;
17     }
18 b,申请中断
19 int request_irq(unsigned int irq, irq_handler_t handler, unsigned long flags, const char * name, void * dev)
20     参数1: irq     设备对应的中断号
21     参数2: handler     中断的处理函数
22             typedef irqreturn_t (*irq_handler_t)(int, void *);
23     参数3:flags     触发方式
24             #define IRQF_TRIGGER_NONE    0x00000000  //内部控制器触发中断的时候的标志
25             #define IRQF_TRIGGER_RISING    0x00000001 //上升沿
26             #define IRQF_TRIGGER_FALLING    0x00000002 //下降沿
27             #define IRQF_TRIGGER_HIGH    0x00000004  // 高点平
28             #define IRQF_TRIGGER_LOW    0x00000008 //低电平触发
29     参数4:name     中断的描述,自定义,主要是给用户查看的
30             /proc/interrupts
31     参数5:dev     传递给参数2中函数指针的值
32     返回值: 正确为0,错误非0
33 
34 
35     参数2的赋值:即中断处理函数
36     irqreturn_t key_irq_handler(int irqno, void *devid)
37     {
38         return IRQ_HANDLED;
39     }
43     
44 c, 释放中断:
45         void free_irq(unsigned int irq, void *dev_id)
46         参数1: 设备对应的中断号
47         参数2:与request_irq中第5个参数保持一致

Der Code implementiert das Abrufen der Interrupt-Nummer, das Registrieren des Interrupts, Drücken der Taste, um die Unterbrechung auszulösen, und Drucken der Informationen

1 #include <linux/init.h>
 2 #include <linux/module.h>
 3 #include <linux/fs.h>
 4 #include <linux/device.h>
 5 #include <asm/uaccess.h>
 6 #include <asm/io.h>
 7 #include <linux/slab.h>
 8 #include <linux/of.h>
 9 #include <linux/of_irq.h>
10 #include <linux/interrupt.h>
11 
12 int irqno;    //中断号
13 
14 
15 irqreturn_t key_irq_handler(int irqno, void *devid)
16 {
17     printk("----------%s---------",__FUNCTION__);
18     return IRQ_HANDLED;
19 }
20 
21 
22 //获取中断号
23 int get_irqno_from_node(void)
24 {
25     //获取设备树中的节点
26     struct device_node *np = of_find_node_by_path("/key_int_node");
27     if(np){
28         printk("find node success\n");
29     }else{
30         printk("find node failed\n");
31     }
32 
33     //通过节点去获取中断号
34     int irqno = irq_of_parse_and_map(np, 0);
35     printk("iqrno = %d",irqno);
36 
37     return irqno;
38 }
39 
40 
41 
42 static int __init key_drv_init(void)
43 {
44     //演示如何获取到中断号
45     int ret;
46     
47     irqno = get_irqno_from_node();
48 
49     ret = request_irq(irqno, key_irq_handler, IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING, 
50         "key3_eint10", NULL);
51     if(ret != 0)
52     {
53         printk("request_irq error\n");
54         return ret;
55     }
56     
57     return 0;
58 }
59 
60 static void __exit key_drv_exit(void)
61 {
62     free_irq(irqno, NULL);  //free_irq与request_irq的最后一个参数一致
63 }
64 
65 
66 
67 module_init(key_drv_init);
68 module_exit(key_drv_exit);
69 
70 MODULE_LICENSE("GPL");
key_drv.c
key_drv.c
Testeffekt: Drücken Sie die Taste, um die Informationen zu drucken, aber die Tasten zittern

cat /ProC /Interrupt
// 1,设定一个全局的设备对象
key_dev = kzalloc(sizeof(struct key_desc),  GFP_KERNEL);
// 2,申请主设备号
key_dev->dev_major = register_chrdev(0, "key_drv", &key_fops);
// 3,创建设备节点文件
key_dev->cls = class_create(THIS_MODULE, "key_cls");
key_dev->dev = device_create(key_dev->cls, NULL, MKDEV(key_dev->dev_major,0), NULL, "key0");
// 4,硬件初始化:
        a.地址映射
        b.中断申请

 

5 . Der Treiber implementiert die Weitergabe der von der Hardware generierten Daten an den Benutzer.

 1) Wie die Hardware die Daten erhält die Daten

key: 按下和抬起: 1/0读取key对应的gpio的状态,可以判断按下还是抬起
    
读取key对应gpio的寄存器--数据寄存器 
//读取数据寄存器int value = readl(key_dev->reg_base + 4) & (1<<2);

 6. Beispiel:

在中断处理中填充数据:
     key_dev->event.code = KEY_ENTER;
     key_dev->event.value = 0;
在xxx_read中奖数据传递给用户
     ret = copy_to_user(buf, &key_dev->event,  count);
key_drv.c
    while(1)
    {
        read(fd, &event, sizeof(struct key_event));        if(event.code == KEY_ENTER)
        {            if(event.value)
            {
                printf("APP__ key enter pressed\n");
            }else{
                printf("APP__ key enter up\n");
            }
        }
    }
key_test.c

1 #include <linux/init.h>
  2 #include <linux/module.h>
  3 #include <linux/of.h>
  4 #include <linux/of_irq.h>
  5 #include <linux/interrupt.h>
  6 #include <linux/slab.h>
  7 #include <linux/fs.h>
  8 #include <linux/device.h>
  9 #include <linux/kdev_t.h>
 10 #include <linux/err.h>
 11 #include <linux/device.h>
 12 #include <asm/io.h>
 13 #include <asm/uaccess.h>
 14 
 15 
 16 #define GPXCON_REG 0X11000C20   //不可以从数据寄存器开始映射,要配置寄存器
 17 #define KEY_ENTER  28
 18 
 19 //0、设计一个描述按键的数据的对象
 20 struct key_event{
 21     int code;    //按键类型:home,esc,enter
 22     int value;   //表状态,按下,松开
 23 };
 24 
 25 //1、设计一个全局对象——— 描述key的信息
 26 struct key_desc{
 27     unsigned int dev_major;
 28     int irqno;  //中断号
 29     struct class  *cls;
 30     struct device *dev;
 31     void *reg_base;
 32     struct key_event event;
 33 };
 34 
 35 struct key_desc *key_dev;
 36 
 37 
 38 irqreturn_t key_irq_handler(int irqno, void *devid)
 39 {
 40     printk("----------%s---------",__FUNCTION__);
 41 
 42     int value;
 43     //读取按键状态
 44     value = readl(key_dev->reg_base + 4) & (0x01<<2);
 45     
 46     if(value){
 47         printk("key3 up\n");
 48         key_dev->event.code  = KEY_ENTER;
 49         key_dev->event.value = 0;
 50     }else{
 51         printk("key3 down\n");
 52         key_dev->event.code  = KEY_ENTER;
 53         key_dev->event.value = 1;
 54     }
 55     return IRQ_HANDLED;
 56 }
 57 
 58 
 59 //获取中断号
 60 int get_irqno_from_node(void)
 61 {
 62     int irqno;
 63     //获取设备树中的节点
 64     struct device_node *np = of_find_node_by_path("/key_int_node");
 65     if(np){
 66         printk("find node success\n");
 67     }else{
 68         printk("find node failed\n");
 69     }
 70 
 71     //通过节点去获取中断号
 72     irqno = irq_of_parse_and_map(np, 0);
 73     printk("iqrno = %d",key_dev->irqno);
 74 
 75     return irqno;
 76 }
 77 
 78 ssize_t key_drv_read (struct file * filp, char __user * buf, size_t count, loff_t * fops)
 79 {
 80     //printk("----------%s---------",__FUNCTION__);
 81     int ret;
 82     ret = copy_to_user(buf, &key_dev->event, count);
 83     if(ret > 0)
 84     {
 85         printk("copy_to_user error\n");
 86         return -EFAULT;
 87     }
 88 
 89     //传递给用户数据后,将数据清除,否则APP每次读都是第一次的数据
 90     memset(&key_dev->event, 0, sizeof(key_dev->event));
 91     return count;
 92 }
 93 
 94 ssize_t key_drv_write (struct file *filp, const char __user * buf, size_t count, loff_t * fops)
 95 {
 96     printk("----------%s---------",__FUNCTION__);
 97     return 0;
 98 }
 99 
100 int key_drv_open (struct inode * inode, struct file *filp)
101 {
102     printk("----------%s---------",__FUNCTION__);
103     return 0;
104 }
105 
106 int key_drv_close (struct inode *inode, struct file *filp)
107 {
108     printk("----------%s---------",__FUNCTION__);
109     return 0;
110 }
111 
112 
113 const struct file_operations key_fops = {
114     .open    = key_drv_open,
115     .read    = key_drv_read,
116     .write   = key_drv_write,
117     .release = key_drv_close,
118 
119 };
120 
121 
122 
123 static int __init key_drv_init(void)
124 {
125     //演示如何获取到中断号
126     int ret;
127     
128     //1、设定全局设备对象并分配空间
129     key_dev = kzalloc(sizeof(struct key_desc), GFP_KERNEL);  //GFP_KERNEL表正常分配内存
130                           //kzalloc相比于kmalloc,不仅分配连续空间,还会将内存初始化清零
131 
132     //2、动态申请设备号
133     key_dev->dev_major = register_chrdev(0, "key_drv", &key_fops);
134 
135     //3、创建设备节点文件
136     key_dev->cls = class_create(THIS_MODULE, "key_cls");
137     key_dev->dev = device_create(key_dev->cls, NULL, MKDEV(key_dev->dev_major, 0), NULL, "key0");
138 
139     //4、硬件初始化 -- 地址映射或中断申请    
140     
141     key_dev->reg_base = ioremap(GPXCON_REG,8);
142 
143     key_dev->irqno = get_irqno_from_node();
144     
145     ret = request_irq(key_dev->irqno, key_irq_handler, IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING, 
146         "key3_eint10", NULL);
147     if(ret != 0)
148     {
149         printk("request_irq error\n");
150         return ret;
151     }
152 
153     //a. 硬件如何获取数据
154     
155     
156     
157     return 0;
158 }
159 
160 static void __exit key_drv_exit(void)
161 {
162     iounmap(GPXCON_REG);
163     free_irq(key_dev->irqno, NULL);  //free_irq与request_irq的最后一个参数一致
164     device_destroy(key_dev->cls, MKDEV(key_dev->dev_major, 0));
165     class_destroy(key_dev->cls);
166     unregister_chrdev(key_dev->dev_major, "key_drv");
167     kfree(key_dev);
168 }
169 
170 
171 
172 module_init(key_drv_init);
173 module_exit(key_drv_exit);
174 
175 MODULE_LICENSE("GPL");
key_drv.c

Makefile

Führen Sie das Benutzerprogramm aus und drücken Sie die Taste, um die Informationen anzuzeigen.

 

Verlassen Sie das Benutzerprogramm und drücken Sie die Taste. Die entsprechenden Informationen werden gedruckt.

 

 Geräte- und Interrupt-Knoteninformationen anzeigen:

 Schauen Sie sich die CPU-Situation an:

Sie können sehen, dass die key_test-Anwendung eine hohe CPU-Menge belegt Grund?

In der Anwendung werden die Kernelinformationen immer über die While-Schleife gelesen. Wenn ein Schlüsselinterrupt auftritt, wird key_event ein Wert zugewiesen, in der While-Schleife beurteilt und dann ausgedruckt, sodass der Benutzerbereich und der Kernelbereich übereinstimmen Ständiges Hin- und Herwechseln und Lesen verbraucht eine Menge CPU-Ressourcen.

Lösung: Wenn ein Interrupt auftritt, wird read aufgerufen. Wenn keine Daten generiert werden, wird der Prozessplan herausgesprungen und der Prozess schläft.

Empfohlenes Lernen: „Linux-Video-Tutorial

Das obige ist der detaillierte Inhalt vonWas bedeutet die Linux-Interrupt-Nummer?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!

Stellungnahme:
Der Inhalt dieses Artikels wird freiwillig von Internetnutzern beigesteuert und das Urheberrecht liegt beim ursprünglichen Autor. Diese Website übernimmt keine entsprechende rechtliche Verantwortung. Wenn Sie Inhalte finden, bei denen der Verdacht eines Plagiats oder einer Rechtsverletzung besteht, wenden Sie sich bitte an admin@php.cn
Vorheriger Artikel:Basiert VIM auf Linux?Nächster Artikel:Basiert VIM auf Linux?