Linux中断机制 - Aki's Blog

1287 字

6 分钟

Linux中断机制

2025-03-26

嵌入式 Linux 开发

中断

/

Linux

设备树中断信息节点#

IMX6ULL和IMX6UL的中断控制器呈兼容关系，即IMX6ULL继承IMX6UL的GIC节点信息。在imx6ul.dtsi中有：

1
  intc: interrupt-controller@a01000 {
2
    compatible = "arm,gic-400", "arm,cortex-a7-gic";
3
        /* GIC_PPI：私有外设中断，非共享
4
           9:中断号为9
5
           GIC_CPU_MASK_SIMPLE(1):PPI只发送给CPU0处理
6
           IRQ_TYPE_LEVEL_HIGH：电平触发，高电平有效 */
7
    interrupts = <GIC_PPI 9 (GIC_CPU_MASK_SIMPLE(1) | IRQ_TYPE_LEVEL_HIGH)>;
8
        /* 中断描述需3个单元 */
9
    #interrupt-cells = <3>;
10
        /* 声明节点为中断控制器 */
11
    interrupt-controller;
12
        /* 父类为自身，说明是顶级GIC */
13
    interrupt-parent = <&intc>;
14
        /* GIC寄存器基地址和大小 */
15
    reg = <0x00a01000 0x1000>,  /* GIC分发器基地址 */
16
        <0x00a02000 0x2000>,  /* GIC CPU接口基地址 */
17
        <0x00a04000 0x2000>,  /* GIC虚拟CPU接口 */
18
        <0x00a06000 0x2000>;  /* GIC虚拟分发器 */
19
  };

这里的interrupt-cells通常格式为<中断类型中断号标志位>或<中断号标志位>，其中

中断类型：
- 0：SPI，共享外设中断
- 1：PPI，私有外设中断
中断号：设备中断ID，SPI中断号范围为0~~987，PPI中断号范围为0~~15
标志位：
- IRQ_TYPE_NONE：Kernel不参与设置，跟随uboot
- IRQ_TYPE_EDGE_RISING：上升沿触发
- IRQ_TYPE_EDGE_FALLING：下降沿触发
- IRQ_TYPE_EDGE_BOTH ：双边沿触发
- IRQ_TYPE_LEVEL_HIGH：高电平触发
- IRQ_TYPE_LEVEL_LOW：低电平触发

GPIO也可以作为GIC：

1
gpio5: gpio@20ac000 {
2
    compatible = "fsl,imx6ul-gpio", "fsl,imx35-gpio";
3
    reg = <0x020ac000 0x4000>;
4
        /* 共享中断，中断号74，高电平触发
5
           共享中断，中断号75，高电平触发 */
6
    interrupts = <GIC_SPI 74 IRQ_TYPE_LEVEL_HIGH>,
7
           <GIC_SPI 75 IRQ_TYPE_LEVEL_HIGH>;
8
    clocks = <&clks IMX6UL_CLK_GPIO5>;
9
    gpio-controller;
10
    #gpio-cells = <2>;
11
    interrupt-controller;   /* 声明为中断控制器 */
12
    gpio-ranges = <&iomuxc 0 7 10>, <&iomuxc 10 5 2>;
13
}

中断需要在节点中配置，如imx6ul-14x14-evk.dtsi中i2c1节点下的：

1
  fxls8471@1e {
2
    compatible = "fsl,fxls8471";
3
    reg = <0x1e>;
4
    position = <0>;
5
    interrupt-parent = <&gpio5>;    /* GIC为GPIO5 */
6
    interrupts = <0 8>; /* 中断号为0，低电平触发 */
7
  };

简单来说，设备树节点中描述中断的信息有：

#interrupt-cells：中断源cell个数
interrupt-controller：声明当前节点为中断控制器
interrupts：指定中断号和中断触发模式
interrupt-parent：父中断(GIC)

用法#

修改设备树
设备结构体中声明irqreturn_t (*handler)(int, void *)(也可以不声明)和int irqnum(存放中断号)
通过irq_of_parse_and_map向设备树申请中断信息

1
unsigned int irq_of_parse_and_map(struct device_node *node, int index);

该函数返回申请到的中断号。 4. 初始化时向kernel申请中断：

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

irq：中断号
handler：中断服务函数
flags：标志位，可选：

1
#define IRQF_TRIGGER_NONE  0x00000000
2
#define IRQF_TRIGGER_RISING  0x00000001
3
#define IRQF_TRIGGER_FALLING  0x00000002
4
#define IRQF_TRIGGER_HIGH  0x00000004
5
#define IRQF_TRIGGER_LOW  0x00000008
6
#define IRQF_TRIGGER_MASK  (IRQF_TRIGGER_HIGH | IRQF_TRIGGER_LOW | \
7
         IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING)
8
#define IRQF_TRIGGER_PROBE  0x00000010

*name：生成中断的设备名
*dev：Cookie，传递设备结构体地址

设备注销时释放中断：

1
void *free_irq(unsigned int irq, void *dev);

irq：中断号
*dev：Cookie，传递设备结构体地址

例程#

1
#include <linux/types.h>
2
#include <linux/kernel.h>
3
#include <linux/delay.h>
4
#include <linux/libata.h>   /* 新版kernel不再支持ide.h */
5
#include <linux/init.h>
6
#include <linux/module.h>
7
#include <linux/errno.h>
8
#include <linux/gpio.h>
9
#include <linux/cdev.h>
10
#include <linux/device.h>
11
#include <linux/of.h>
12
#include <linux/of_address.h>
13
#include <linux/of_gpio.h>
14
#include <asm/mach/map.h>
15
#include <asm/uaccess.h>
16
#include <asm/io.h>
17
#include <linux/semaphore.h>
18
#include <linux/timer.h>
19
#include <linux/of_irq.h>
20
#include <linux/irq.h>
21

22
#define IMX6UIRQ_CNT         1
23
#define IMX6UIRQ_NAME   "imx6uirq"
24
#define KEY0VALUE       0x01
25
#define INVAKEY         0xFF
26
#define KEY_NUM         1
27

28
struct irq_keydesc {
29
    int gpio;
30
    int irqnum;             /* 中断号 */
31
    unsigned char value;    /* 按键对应的键值 */
32
    char name[10];
33
    irqreturn_t (*handler)(int, void *);    /* 中断服务函数 */
34
};
35

36
struct irq_led {
37
    int gpio;
38
};
39

40
struct imx6uirq_dev {
41
    dev_t devid;
42
    struct cdev cdev;
43
    struct class *class;
44
    struct device *device;
45
    int major;
46
    int minor;
47
    struct device_node *nd;
48
    atomic_t keyvalue;      /* 有效按键键值 */
49
    atomic_t releasekey;    /* 标记是否完成一次按键 */
50
    struct timer_list timer;
51
    struct irq_keydesc irqkeydesc; /* 按键描述结构体 */
52
    struct irq_led irqled;
53
};
54

55
struct imx6uirq_dev imx6uirq;
56

57
/* IRQ服务函数，延时10ms，消抖 */
58
static irqreturn_t key0_handler(int irq, void *dev_id)
59
{
60
    struct imx6uirq_dev *dev = (struct imx6uirq_dev *)dev_id;
61

62
    mod_timer(&dev->timer, jiffies + msecs_to_jiffies(10)); /* 延时10ms，消抖 */
63
    return IRQ_RETVAL(IRQ_HANDLED);
64
}
65

66
/* 定时器服务函数，到期后再次读取按键值，如果还是按下表示按键有效 */
67
void timer_function(struct timer_list *t)
68
{
69
    unsigned char value;
70
    struct irq_keydesc *keydesc;
71
    struct imx6uirq_dev *dev = from_timer(dev, t, timer);
72

73
    keydesc = &dev->irqkeydesc;
74

75
    value = gpio_get_value(keydesc->gpio);  /* 读取IO电平 */
76
    if (value == 0){    /* 如果按下 */
77
        int sta = gpio_get_value(dev->irqled.gpio);
78
        gpio_set_value(dev->irqled.gpio, !sta);
79
        atomic_set(&dev->keyvalue, keydesc->value);
80
    }else{      /* 如果松开 */
81
        atomic_set(&dev->keyvalue, 0x80 | keydesc->value);
82
        atomic_set(&dev->releasekey, 1);    /* 标记松开按键 */
83
    }
84
}
85

86
static int keyio_init(void)
87
{
88
    int ret = 0;
89

90
    imx6uirq.nd = of_find_node_by_path("/key");
91
    if (imx6uirq.nd == NULL){
92
        printk("find node failed\r\n");
93
        return -EINVAL;
94
    }
95

96
    imx6uirq.irqkeydesc.gpio = of_get_named_gpio(imx6uirq.nd, "key-gpio", 0);
97
    if (imx6uirq.irqkeydesc.gpio < 0){
98
        printk("unable get key gpio\r\n");
99
        return -EINVAL;
100
    }
101

102
    imx6uirq.irqled.gpio = of_get_named_gpio(imx6uirq.nd, "led-gpio", 0);
103
    if (imx6uirq.irqled.gpio < 0){
104
        printk("unable get led gpio\r\n");
105
        return -EINVAL;
106
    }
107

108
    sprintf(imx6uirq.irqkeydesc.name, "KEY0");
109
    gpio_request(imx6uirq.irqkeydesc.gpio, imx6uirq.irqkeydesc.name);
110
    ret = gpio_direction_input(imx6uirq.irqkeydesc.gpio);
111
    if (ret < 0){
112
        printk("unable set key pin level\r\n");
113
        return ret;
114
    }
115
    imx6uirq.irqkeydesc.irqnum = irq_of_parse_and_map(imx6uirq.nd, 0);
116
    printk("key0: gpio = %d, irqnum = %d\r\n", imx6uirq.irqkeydesc.gpio, imx6uirq.irqkeydesc.irqnum);
117

118
    gpio_request(imx6uirq.irqled.gpio, "LED");
119
    ret = gpio_direction_output(imx6uirq.irqled.gpio, 1);
120
    if (ret < 0){
121
        printk("unable set led pin level\r\n");
122
        return ret;
123
    }
124

125
    imx6uirq.irqkeydesc.handler = key0_handler;
126
    imx6uirq.irqkeydesc.value = KEY0VALUE;
127

128
    ret = request_irq(imx6uirq.irqkeydesc.irqnum, imx6uirq.irqkeydesc.handler, IRQF_TRIGGER_FALLING|IRQF_TRIGGER_RISING, imx6uirq.irqkeydesc.name, &imx6uirq);
129

130
    if (ret < 0){
131
        printk("IRQ request failed, error code: %d\r\n", ret);
132
    }
133

134
    timer_setup(&imx6uirq.timer, timer_function, 0);
135

136
    return 0;
137
}
138

139
static int imx6uirq_open(struct inode *inode, struct file *filp)
140
{
141
    filp->private_data = &imx6uirq;
142
    return 0;
143
}
144

145
static ssize_t imx6uirq_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
146
{
147
    int ret = 0;
148
    unsigned char keyvalue = 0;
149
    unsigned char releasekey = 0;
150
    struct imx6uirq_dev *dev = (struct imx6uirq_dev *)filp->private_data;
151

152
    keyvalue = atomic_read(&dev->keyvalue);
153
    releasekey = atomic_read(&dev->releasekey);
154

155
    if (releasekey){
156
        if (keyvalue & 0x80){
157
            keyvalue &= ~(0x80);
158
            ret = copy_to_user(buf, &keyvalue, sizeof(keyvalue));
159
        }else{
160
            goto data_error;
161
        }
162
        atomic_set(&dev->releasekey, 0);
163
    }else{
164
        goto data_error;
165
    }
166
    return 0;
167

168
data_error:
169
    return -EINVAL;
170
}
171

172
static struct file_operations imx6uirq_fops = {
173
    .owner = THIS_MODULE,
174
    .open = imx6uirq_open,
175
    .read = imx6uirq_read,
176
};
177

178
static int __init imx6uirq_init(void)
179
{
180
    if (imx6uirq.major){
181
        imx6uirq.devid = MKDEV(imx6uirq.major, 0);
182
        register_chrdev_region(imx6uirq.devid, IMX6UIRQ_CNT, IMX6UIRQ_NAME);
183
    }else{
184
        alloc_chrdev_region(&imx6uirq.devid, 0, IMX6UIRQ_CNT, IMX6UIRQ_NAME);
185
        imx6uirq.major = MAJOR(imx6uirq.devid);
186
        imx6uirq.minor = MINOR(imx6uirq.devid);
187
    }
188
    printk("KEY reg ok, major = %d, minor = %d\r\n", imx6uirq.major, imx6uirq.minor);
189

190
    cdev_init(&imx6uirq.cdev, &imx6uirq_fops);
191
    cdev_add(&imx6uirq.cdev, imx6uirq.devid, IMX6UIRQ_CNT);
192

193
    imx6uirq.class = class_create(IMX6UIRQ_NAME);
194
    if (IS_ERR(imx6uirq.class)){
195
        return PTR_ERR(imx6uirq.class);
196
    }
197

198
    imx6uirq.device = device_create(imx6uirq.class, NULL, imx6uirq.devid, NULL, IMX6UIRQ_NAME);
199
    if (IS_ERR(imx6uirq.device)){
200
        return PTR_ERR(imx6uirq.device);
201
    }
202

203
    atomic_set(&imx6uirq.keyvalue, INVAKEY);
204
    atomic_set(&imx6uirq.releasekey, 0);
205
    keyio_init();
206

207
    return 0;
208
}
209

210
static void __exit imx6uirq_exit(void)
211
{
212
    del_timer_sync(&imx6uirq.timer);
213

214
    free_irq(imx6uirq.irqkeydesc.irqnum, &imx6uirq);
215
    gpio_free(imx6uirq.irqkeydesc.gpio);
216

217
    cdev_del(&imx6uirq.cdev);
218
    unregister_chrdev_region(imx6uirq.devid, IMX6UIRQ_CNT);
219
    device_destroy(imx6uirq.class, imx6uirq.devid);
220
    class_destroy(imx6uirq.class);
221
}
222

223
module_init(imx6uirq_init);
224
module_exit(imx6uirq_exit);
225
MODULE_LICENSE("GPL");