本文已参与【新人创作礼】活动，一起开启掘金创作之路。
一、链式中断控制器的重要函数和结构体
1.1 链式处理流程回顾
当按下按键后，GPIO向上一层发出中断，触发33号中断。CPU从异常向量表中找到33号中断，然后从GIC irq_domain中找到对应的软件中断17。从而调用irq_desc里的第17个handle函数，handleB去屏蔽中断。然后回去读取gpio的寄存器，来分辨发生了哪一个中断，比如发生了2号中断，那么通过gpio的irq_domain就找到了102号irq_desc。然后调用handleC函数，handleC来调用irq_dataB中函数，屏蔽中断，然后调用用户注册的处理函数。
GIC下的中断控制器涉及4个重要的部分：handleB、GPIO Domain、handleC、irq_chip
- handleB：处理GIC33号中断，handleB由GPIO驱动提供
- 屏蔽GIC33号中断：调用irq_dataA的irq_chip函数，irq_dataA由GIC驱动提供
- 细分并处理某个GPIO中断：
- 读取GPIO寄存器得到hwirq，通过GPIO Domain转换为virq，假设是102
- 调用irq_desc[102].handle_irq，即handleC
- 清除GIC 33号中断：调用irq_dataA的irq_chip的函数，由GIC驱动提供
- handleC：处理gpio 2号中断，handleC由gpio驱动提供
-
屏蔽GPIO 2号中断：调用irq_dataB的irq_chip的函数，由GPIO驱动提供
-
处理：调用actions链表中用户注册的函数
-
清除GPIO 2号中断：调用irq_dataB的irq_chip的函数，由GPIO驱动提供
-
1.2 irq_domain的作用
在这些重要的部分中，irq_domain是核心，需要通过它把，软件处理和硬件中断连接起来。
- 在设备树里指定使用哪个中断
gpio_keys_100ask {
compatible = "100ask,gpio_key";
interrupt-parent = <&gpio5>;
interrupts = <3 IRQ_TYPE_EDGE_BOTH>,
};
- 内核解析、处理和设备树的中断信息
- 根据
interrupt-parent找到驱动程序注册的irq_domain - 使用
irq_domain.ops中的translate或xlate函数解析设备树，得到hwirq和type - 分配/找到irq_desc，得到virq
- 把(hwirq,virq)的关系存入irq_domain
- 把virq存入platform_device的resource中
- 使用irq_domain.ops中的alloc或map函数进行设置
- 可能是替换irq_desc[virq].handle_irq函数
- 可能是替换irq_desc[virq].irq_data，里面由irq_chip
- 用户驱动程序注册中断
- 从platform_device的resource中得到中断号virq
- request_irq(virq, ..., func)
- 发生中断、处理中断：处理流程见上面
- 根据
二、硬件模型
下图中列出了链式中断控制器、层级中断控制器，本节课程只涉及左边的链式中断控制器。
内核中有各类中断控制器的驱动程序，它们涉及的硬件过于复杂，从这些杂乱的代码中去讲清楚中断体系，比较难。
我们实现一些虚拟的中断控制器，如下图所示。
实际板子中，我们可以通过按键触发中断。
对于这些虚拟的中断控制器，我们没有真实按键，通过devmem指令写GIC的PENDING寄存器触发中断。
三、编程
会涉及2个驱动程序：虚拟的中断控制器驱动程序，按键驱动程序，以及对应的设备树。
这个是legacy的方式写的： virtual_intc.dts:
/ {
virtual_intc: virtual_intc_100ask {
compatible = "100ask,virtual_intc";
/* this is a interrupt controller */
interrupt-controller;
/* sub interrupt node needs to provide 2 cells */
#interrupt-cells = <2>;
/* this node's parent interrupt controller is intc */
interrupt-parent = <&intc>;
/* this intrrupt controoler will send irq to intc */
interrupts = <GIC_SPI 122 IRQ_TYPE_LEVEL_HGIH>;
};
gpio_keys_100ask {
compatible = "100ask,gpio_key";
interrupt-parent = <&virtual_intc>; // which interrupt use
interrupts = <0 IRQ_TYPE_LEVEL_HIGH>, // which interrupt line
<1 IRQ_TYPE_LEVEL_HIGH>,
<2 IRQ_TYPE_LEVEL_HIGH>,
<3 IRQ_TYPE_LEVEL_HIGH>;
};
};
gpio_key_drv.c
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/errno.h>
#include <linux/miscdevice.h>
#include <linux/kernel.h>
#include <linux/major.h>
#include <linux/mutex.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/stat.h>
#include <linux/init.h>
#include <linux/device.h>
#include <linux/tty.h>
#include <linux/kmod.h>
#include <linux/gfp.h>
#include <linux/gpio/consumer.h>
#include <linux/platform_device.h>
#include <linux/of_gpio.h>
#include <linux/of_irq.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/slab.h>
struct gpio_key{
char name[100];
int irq;
int cnt;
} ;
static struct gpio_key gpio_keys_100ask[100];
static irqreturn_t gpio_key_isr(int irq, void *dev_id)
{
struct gpio_key *gpio_key = dev_id;
printk("key %s %d\n", gpio_key->name, gpio_key->cnt++);
return IRQ_HANDLED;
}
/* 1. 从platform_device获得GPIO
* 2. gpio=>irq
* 3. request_irq
*/
static int gpio_key_probe(struct platform_device *pdev)
{
int err;
int i = 0;
int irq;
printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
while(1) {
irq = platform_get_irq(pdev, i);
if(irq <= 0) break;
gpio_keys_100ask[i].irq = irq;
sprintf(gpio_keys_100ask[i].name, "100ask_virtual_key%d", i);
err = devm_request_irq(&pdev->dev, gpio_keys_100ask[i].irq, gpio_key_isr,
IRQF_TRIGGER_RISING| IRQF_TRIGGER_FALLING,
gpio_keys_100ask[i].name, &gpio_keys_100ask[i]);
printk("devm_request_irq %d for %s, err = %d\n", irq, gpio_keys_100ask[i].name, err);
i++;
}
return 0;
}
static int gpio_key_remove(struct platform_device *pdev)
{
return 0;
}
static const struct of_device_id ask100_keys[] = {
{ .compatible = "100ask,gpio_key" },
{ },
};
/* 1. 定义platform_driver */
static struct platform_driver gpio_keys_driver = {
.probe = gpio_key_probe,
.remove = gpio_key_remove,
.driver = {
.name = "100ask_gpio_key",
.of_match_table = ask100_keys,
},
};
/* 2. 在入口函数注册platform_driver */
static int __init gpio_key_init(void)
{
int err;
printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
err = platform_driver_register(&gpio_keys_driver);
return err;
}
/* 3. 有入口函数就应该有出口函数：卸载驱动程序时，就会去调用这个出口函数
* 卸载platform_driver
*/
static void __exit gpio_key_exit(void)
{
printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
platform_driver_unregister(&gpio_keys_driver);
}
/* 7. 其他完善：提供设备信息，自动创建设备节点 */
module_init(gpio_key_init);
module_exit(gpio_key_exit);
MODULE_LICENSE("GPL");
virtual_int_controller.c:
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/of.h>
#include <linux/random.h>
#include <linux/irqdomain.h>
#include <linux/irq.h>
#include <linux/irqchip/chained_irq.h>
static struct irq_domain *virtual_intc_domain;
static int virtual_intc_get_hwirq(void)
{
return get_random_int() & 0x3;
}
static void virtual_intc_irq_handler(struct irq_desc *desc)
{
/* distinguwish which hwirq, call the irq_desc[].handle_irq */
int hwirq;
struct irq_chip *chip = irq_desc_get_chip(desc);
/* mask irq */
chained_irq_enter(chip, desc);
/* distinguwish the irq number */
hwirq = virtual_intc_get_hwirq();
/* call irq_desc[].handle_irq(handleC) */
generic_handle_irq(irq_find_mapping(virtual_intc_domain, hwirq));
/* unmask irq */
chained_irq_exit(chip, desc);
}
static void virtual_intc_irq_ack(struct irq_data *data)
{
printk("%s %d\n", __FUNCTION__, __LINE__);
}
static void virtual_intc_irq_mask(struct irq_data *data)
{
printk("%s %d\n", __FUNCTION__, __LINE__);
}
static void virtual_intc_irq_mask_ack(struct irq_data *data)
{
printk("%s %d\n", __FUNCTION__, __LINE__);
}
static void virtual_intc_irq_unmask(struct irq_data *data)
{
printk("%s %d\n", __FUNCTION__, __LINE__);
}
static void virtual_intc_irq_eoi(struct irq_data *data)
{
printk("%s %d\n", __FUNCTION__, __LINE__);
}
static struct irq_chip virtual_intc_irq_chip = {
.name = "100ask_virtual_intc",
.irq_ack = virtual_intc_irq_ack,
.irq_mask = virtual_intc_irq_mask,
.irq_mask_ack = virtual_intc_irq_mask_ack,
.irq_unmask = virtual_intc_irq_unmask,
.irq_eoi = virtual_intc_irq_eoi,
};
static int virtual_intc_irq_map(struct irq_domain *h, unsigned int virq,
irq_hw_number_t hw)
{
/* 1. provide virq a handle function */
/* 2. provide irq_chip to mask/unmask interrupt */
irq_set_chip_data(virq, h->host_data);
/* handle_edge_irq is handleC */
irq_set_chip_and_handler(virq, &virtual_intc_irq_chip, handle_edge_irq);
//irq_set_nested_thread(virq, 1);
//irq_set_noprobe(virq);
return 0;
}
static const struct irq_domain_ops virtual_intc_domain_ops = {
/* parse the 2 cell in node */
.xlate = irq_domain_xlate_onetwocell,
/* map hwirq to virq and set handler */
.map = virtual_intc_irq_map,
};
static int virtual_intc_probe(struct platform_device *pdev)
{
struct device_node *np = pdev->dev.of_node;
int irq_to_parent, irq_base;
/* 1. virtual intc will send n IRQ to GIC */
/* 1.1 get irq num from devicetree */
irq_to_parent = platform_get_irq(pdev, 0);
/* 1.2 set irq_desc[].handle_irq */
irq_set_chained_handler_and_data(irq_to_parent, virtual_intc_irq_handler, NULL);
/* 2. alloc/config/register a irq_domain */
irq_base = irq_alloc_descs(-1, 0, 4, numa_node_id());
virtual_intc_domain = irq_domain_add_legacy(np, 4, irq_base, 0,
&virtual_intc_domain_ops, NULL);
return 0;
}
static int virtual_intc_remove(struct platform_device *pdev)
{
return 0;
}
static const struct of_device_id virtual_intc_of_match[] = {
{ .compatible = "100ask,virtual_intc" },
{ },
};
struct platform_driver virtual_intc_driver = {
.probe = virtual_intc_probe,
.remove = virtual_intc_remove,
.driver = {
.name = "100ask_virtual_intc",
.of_match_table = of_match_ptr(virtual_intc_of_match),
},
};
static int __init virtual_intc_init(void)
{
int ret = 0;
printk("%s %d\n", __FUNCTION__, __LINE__);
ret = platform_driver_register(&virtual_intc_driver);
return ret;
}
static void __exit virtual_intc_exit(void)
{
printk("%s %d\n", __FUNCTION__, __LINE__);
platform_driver_unregister(&virtual_intc_driver);
}
module_init(virtual_intc_init);
module_exit(virtual_intc_exit);
MODULE_LICENSE("GPL");
调试输出日志：
[ 105.498987] virtual_int_controller: loading out-of-tree module taints kernel.
[ 105.506981] virtual_intc_init 135
[ 118.521650] /home/chen/Documents/mygit/100ask_rk3288_module/16_interrupt/01_virtual_interrupt/gpio_key_drv.c gpio_key_init line 97
[ 118.522140] /home/chen/Documents/mygit/100ask_rk3288_module/16_interrupt/01_virtual_interrupt/gpio_key_drv.c gpio_key_probe line 53
[ 118.524218] virtual_intc_irq_unmask 55
[ 118.524306] devm_request_irq 237 for 100ask_virtual_key0, err = 0
[ 118.524346] virtual_intc_irq_unmask 55
[ 118.524403] devm_request_irq 238 for 100ask_virtual_key1, err = 0
[ 118.524430] virtual_intc_irq_unmask 55
[ 118.524478] devm_request_irq 239 for 100ask_virtual_key2, err = 0
[ 118.524502] virtual_intc_irq_unmask 55
[ 118.524553] devm_request_irq 240 for 100ask_virtual_key3, err = 0
[ 197.958237] /home/chen/Documents/mygit/100ask_rk3288_module/16_interrupt/01_virtual_interrupt/gpio_key_drv.c gpio_key_exit line 109
[ 197.973080] virtual_intc_irq_mask 45
[ 197.976710] virtual_intc_irq_mask 45
[ 197.980304] virtual_intc_irq_mask 45
[ 197.986245] virtual_intc_irq_mask 45
[ 201.572562] /home/chen/Documents/mygit/100ask_rk3288_module/16_interrupt/01_virtual_interrupt/gpio_key_drv.c gpio_key_init line 97
[ 201.595077] /home/chen/Documents/mygit/100ask_rk3288_module/16_interrupt/01_virtual_interrupt/gpio_key_drv.c gpio_key_probe line 53
[ 201.608816] virtual_intc_irq_unmask 55
[ 201.614073] devm_request_irq 237 for 100ask_virtual_key0, err = 0
[ 201.620252] virtual_intc_irq_unmask 55
[ 201.625838] devm_request_irq 238 for 100ask_virtual_key1, err = 0
[ 201.632217] virtual_intc_irq_unmask 55
[ 201.636000] devm_request_irq 239 for 100ask_virtual_key2, err = 0
[ 201.644365] virtual_intc_irq_unmask 55
[ 201.648165] devm_request_irq 240 for 100ask_virtual_key3, err = 0
[ 452.414732] virtual_intc_irq_ack 40
[ 452.419050] key 100ask_virtual_key3 0
[ 457.034802] virtual_intc_irq_ack 40
[ 457.039095] key 100ask_virtual_key1 0
[ 458.564621] virtual_intc_irq_ack 40
[ 458.569138] key 100ask_virtual_key3 1
[ 459.684539] virtual_intc_irq_ack 40
[ 459.688858] key 100ask_virtual_key1 1
[ 460.614514] virtual_intc_irq_ack 40
[ 460.618853] key 100ask_virtual_key2 0
[ 461.474376] virtual_intc_irq_ack 40
[ 461.478718] key 100ask_virtual_key2 1
[ 462.194053] virtual_intc_irq_ack 40
[ 462.198371] key 100ask_virtual_key0 0
[ 463.464188] virtual_intc_irq_ack 40
[ 463.468529] key 100ask_virtual_key2 2
[ 537.137130] virtual_intc_irq_ack 40
[ 537.141648] key 100ask_virtual_key1 2
[ 541.816660] virtual_intc_irq_ack 40
[ 541.821009] key 100ask_virtual_key1 3
[ 546.656197] virtual_intc_irq_ack 40
[ 546.660539] key 100ask_virtual_key1 4
[ 547.866120] virtual_intc_irq_ack 40
[ 547.870641] key 100ask_virtual_key1 5
[ 549.325932] virtual_intc_irq_ack 40
[ 549.330277] key 100ask_virtual_key0 1
[ 551.065656] virtual_intc_irq_ack 40
[ 551.069978] key 100ask_virtual_key0 2
[ 552.095844] virtual_intc_irq_ack 40
[ 552.100169] key 100ask_virtual_key1 6
[ 553.115605] virtual_intc_irq_ack 40
[ 553.119948] key 100ask_virtual_key3 2
[ 553.905163] virtual_intc_irq_ack 40
[ 553.909505] key 100ask_virtual_key2 3
[ 554.435651] virtual_intc_irq_ack 40
[ 554.439982] key 100ask_virtual_key2 4
[ 554.945217] virtual_intc_irq_ack 40
[ 554.949723] key 100ask_virtual_key0 3
[ 555.445280] virtual_intc_irq_ack 40
[ 555.449621] key 100ask_virtual_key2 5
[ 555.925126] virtual_intc_irq_ack 40
[ 555.929461] key 100ask_virtual_key3 3
[ 556.405223] virtual_intc_irq_ack 40
[ 556.409547] key 100ask_virtual_key2 6
[ 560.125866] /home/chen/Documents/mygit/100ask_rk3288_module/16_interrupt/01_virtual_interrupt/gpio_key_drv.c gpio_key_exit line 109
[ 560.139021] virtual_intc_irq_mask 45
[ 560.142641] virtual_intc_irq_mask 45
[ 560.146234] virtual_intc_irq_mask 45
[ 560.152504] virtual_intc_irq_mask 45
[ 565.233453] virtual_intc_exit 142
