linux 中斷號碼是什麼意思
- 藏色散人原創
- 2023-03-20 10:09:452662瀏覽
linux中斷號是系統分配給每個中斷來源的代號，以便識別和處理；在採用向量中斷方式的中斷系統中，CPU必須透過它才可以找到中斷服務程式的入口位址，實現程序的轉移。
本教學操作環境：linux5.9.8系統、Dell G3電腦。
linux 中斷號碼是什麼意思？
中斷號與中斷程式設計：
#1、中斷號
中斷號是系統指派給每個中斷來源的代號，以便識別和處理。在採用向量中斷方式的中斷系統中，CPU必須透過它才能找到中斷服務程序的入口位址，以實現程式的轉移。
在ARM裸機中實作中斷需要設定：
I/O口为中断模式，触发方式，I/O口中断使能 设置GIC中断使能，分发配置，分发总使能，CPU外部中断接口使能，中断优先级
在linux核心中實作中斷，只需要知道：
中断号是什么，怎么得到中断号 中断处理方法
2、取得中斷號的方法：
/arm/boot/dts/exynos4412-fs4412.dts
1）看原理圖，晶片手冊找到中斷來源對應的中斷號SPI Port No
# 
2）進入裝置樹，在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等對應於SPI Port No，以上是系統中已經定義好的節點
#在程式設計中，需要定義自己的節點，用來描述按鍵，開啟可編輯的裝置樹檔案：
arch/arm/boot/dts/exynos4412-fs4412.dts，進入檔案。
3）定義節點，描述目前裝置用的中斷號
1 key_int_node{
2 compatible = "test_key";
3 interrupt-parent = ; //继承于gpx1
4 interrupts = ; //2表示第几个中断号，4表示触发方式为下降沿5 }; //interrupts里长度由父母的-cell决定再舉個栗子，設定k4 --- GPX3_2(XEINT26) 的節點，中斷號
1 key_int_node{
2 compatible = "test_key";
3 interrupt-parent = <&gpx3>; //继承于gpx3
4 interrupts = <2 4>; //2表示第2个中断号，4表示触发方式为下降沿
5 };
中斷號的定位方法：
看I/O引腳，GPX1_2，中斷號就是GPX1裡面的第2個
更新設備樹檔案： cp -raf arch/arm/boot/dts/exynos4412-fs4412.dtb /tfboot/
2. ：在根目錄的proc/device-tree/目錄下
3、實作中斷處理方法 在驅動程式中透過程式碼取得中斷號，並且申請中斷
先看一下中斷相關的函數：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个参数保持一致程式碼實作取得中斷號，並註冊中斷，按下按鍵引發中斷，列印訊息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.ckey_drv.c
##cat /proc/interrupt
#4、 中斷程式設計--- 字元裝置驅動框架
// 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、驅動實作將硬體所產生的資料傳遞給使用者
1）硬體如何取得資料key： 按下和抬起： 1/0读取key对应的gpio的状态，可以判断按下还是抬起
读取key对应gpio的寄存器--数据寄存器
//读取数据寄存器int value = readl(key_dev->reg_base + 4) & (1<<2); 2）驅動傳遞資料給使用者
在中断处理中填充数据： key_dev->event.code = KEY_ENTER; key_dev->event.value = 0; 在xxx_read中奖数据传递给用户 ret = copy_to_user(buf, &key_dev->event, count);# 3 ）使用者取得資料
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");
}
}
}
##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.ckey_drv .c
1 #include <stdio.h>
2 #include <string.h>
3 #include <stdlib.h>
4 #include <unistd.h>
5 #include <sys/types.h>
6 #include <sys/stat.h>
7 #include <fcntl.h>
8
9
10 #define KEY_ENTER 28
11
12 //0、设计一个描述按键的数据的对象
13 struct key_event{
14 int code; //按键类型：home，esc,enter
15 int value; //表状态，按下，松开
16 };
17
18
19 int main(int argc, char *argv[])
20 {
21 struct key_event event;
22 int fd;
23 fd = open("/dev/key0", O_RDWR);
24 if(fd < 0)
25 {
26 perror("open");
27 exit(1);
28 }
29
30 while(1)
31 {
32 read(fd, &event, sizeof(struct key_event));
33
34 if(event.code == KEY_ENTER)
35 {
36 if(event.value)
37 {
38 printf("APP__ key enter down\n");
39 }else{
40
41 printf("APP__ key enter up\n");
42 }
43 }
44 }
45
46 close(fd);
47
48 return 0;
49 }
key_test.ckey_test.c1 ROOTFS_DIR = /home/linux/source/rootfs#根文件系统路径 2 3 APP_NAME = key_test 4 MODULE_NAME = key_drv 5 6 CROSS_COMPILE = /home/linux/toolchains/gcc-4.6.4/bin/arm-none-linux-gnueabi- 7 CC = $(CROSS_COMPILE)gcc 8 9 ifeq ($(KERNELRELEASE),) 10 11 KERNEL_DIR = /home/linux/kernel/linux-3.14-fs4412 #编译过的内核源码的路径 12 CUR_DIR = $(shell pwd) #当前路径 13 14 all: 15 make -C $(KERNEL_DIR) M=$(CUR_DIR) modules #把当前路径编成modules 16 $(CC) $(APP_NAME).c -o $(APP_NAME) 17 @#make -C 进入到内核路径 18 @#M 指定当前路径（模块位置） 19 20 clean: 21 make -C $(KERNEL_DIR) M=$(CUR_DIR) clean 22 23 install: 24 sudo cp -raf *.ko $(APP_NAME) $(ROOTFS_DIR)/drv_module #把当前的所有.ko文件考到根文件系统的drv_module目录 25 26 else 27 28 obj-m += $(MODULE_NAME).o #指定内核要把哪个文件编译成ko 29 30 endif Makefile
執行使用者程序，按下按鍵可以看到資訊
# 退出使用者程序，按下按鍵，也會列印對應資訊。
檢視裝置與中斷節點資訊：
再看下CPU情況：
可以看到key_test應用程式佔了很高的CPU，什麼原因呢？
在應用程式中，是透過while循環，一直read核心的訊息，當有按鍵中斷發生的時候，就會對key_event賦值，在while循環裡判斷，進而列印出來，這樣在使用者空間與核心空間一直來回切換，一直read會十分消耗CPU資源。
解決思路：當有中斷發生時，才來呼叫read，沒有資料產生，跳出進程調度，進程休眠。
推薦學習：《linux影片教學》
以上是linux 中斷號碼是什麼意思的詳細內容。更多資訊請關注PHP中文網其他相關文章！