5.5 hierarchy中断控制器驱动

最新推荐文章于 2024-07-24 09:48:42 发布

lf282481431

最新推荐文章于 2024-07-24 09:48:42 发布

阅读量63

点赞数

分类专栏： linux驱动开发文章标签： linux 驱动开发

本文链接：https://blog.csdn.net/lf282481431/article/details/132030432

版权

linux驱动开发专栏收录该内容

50 篇文章 5 订阅

订阅专栏

legacy类型的中断控制器是一个一对一的中断控制器，它注册在注册时需要指定其父中断控制器，父中断控制器的中断号与其对应的子中断控制器的中断号共用一个irq_desc。

驱动代码编写

实验程序是虚拟的中断控制器驱动，它利用 GIC_SPI 210 ~ 213作为父中断，分别对应虚拟中断控制器的中断0~3。

设备树编写

设备树包括两部分，分别是虚拟中断控制器的设备树和中断控制器测试设备的设备树

//在顶层设备树根节点中加入如下节点
	//虚拟中断控制器的设备树
	virtual_intc: virtual_interrupt_controller {
		compatible = "atk,virtual_intc";
		//此节点是一个中断控制器，使用是需要传递两个参数
		interrupt-controller;
		#interrupt-cells = <2>;
		//父中断控制器是 intc
		interrupt-parent = <&intc>;
		//GIC_SPI 210号中断对应此虚拟中断控制器的0号中断（GIC_SPI 210在GIC中断控制器中的编号为242）
		//使用下面命令可以触发中断
		//devmem 0xa002121c 32 0x40000		//触发GIC的242
		//devmem 0xa002121c 32 0x80000		//触发GIC的243
		//devmem 0xa002121c 32 0x100000		//它不能触发中断，可能是被占用了
		//devmem 0xa002121c 32 0x200000		//触发GIC的245
		upper_hwirq_base = <210>;
	};
	//中断测试设备的设备树
	virtual_intc_keys {
		compatible = "atk,virtual_intc_key";
		interrupt-parent = <&virtual_intc>;
		interrupts = <0 IRQ_TYPE_LEVEL_HIGH>,
					 <1 IRQ_TYPE_LEVEL_HIGH>,
					 <2 IRQ_TYPE_LEVEL_HIGH>,
					 <3 IRQ_TYPE_LEVEL_HIGH>;
	};
//用make ARCH=arm CROSS_COMPILE=arm-none-linux-gnueabihf- dtbs -j8编译设备树
//用新的.dtb文件启动系统

驱动代码编写

legacy中断控制器的核心便是实现一个irq_domain对象，主要包括以下步骤：

实现irq_domain的设备树解析函数、alloc函数、free函数，设备树解析函数用于解析设备树，alloc函数用于设置irq_desc，free函数函数执行与alloc函数的操作
实现中断控制器操作函数，在中断控制器操作函数中还要调用父中断控制器的操作函数
注册一个hierarchy的类型的中断域

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/clk.h>
#include <linux/err.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/io.h>
#include <linux/random.h>
#include <linux/irq.h>
#include <linux/irqdomain.h>
#include <linux/irqchip/chained_irq.h>
#include <linux/platform_device.h>
#include <linux/pm_runtime.h>
#include <linux/slab.h>
#include <linux/gpio/driver.h>
#include <linux/gpio.h>
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/random.h>
#include <linux/of_irq.h>
#include <dt-bindings/interrupt-controller/arm-gic.h>

//虚拟中断控制器的中断域
static struct irq_domain *virtual_intc_domain;
//此中断控制器0号中断对应的上级中断控制器的中断编号
static uint32_t upper_hwirq_base;

static void virtual_intc_irq_ack(struct irq_data *data)
{
	printk("function:%s line:%d\n", __FUNCTION__, __LINE__);

	//调用上级中断控制器的irq_ack
	irq_chip_ack_parent(data);
}

static void virtual_intc_irq_mask(struct irq_data *data)
{
	printk("function:%s line:%d\n", __FUNCTION__, __LINE__);

	//调用上级中断控制器的irq_mask
	irq_chip_mask_parent(data);
}

static void virtual_intc_irq_mask_ack(struct irq_data *data)
{
	printk("function:%s line:%d\n", __FUNCTION__, __LINE__);

	//调用上级中断控制器的irq_mask_ack
	irq_chip_mask_ack_parent(data);
}

static void virtual_intc_irq_unmask(struct irq_data *data)
{
	printk("function:%s line:%d\n", __FUNCTION__, __LINE__);

	//调用上级中断控制器的irq_unmask
	irq_chip_unmask_parent(data);
}

static void virtual_intc_irq_eoi(struct irq_data *data)
{
	printk("function:%s line:%d\n", __FUNCTION__, __LINE__);

	//调用上级中断控制器的irq_eoi
	irq_chip_eoi_parent(data);
}

//中断控制器操作函数
static struct irq_chip virtual_intc_irq_chip = {
	.name = "atk_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_translate(struct irq_domain *d, struct irq_fwspec *fwspec,
								unsigned long *out_hwirq, unsigned int *out_type)
{
	printk("function:%s line:%d\n", __FUNCTION__, __LINE__);

	//解析设备树
	if(fwspec->param_count != 2)
	{
		printk("The device tree format is incorrect\n");
		return -EINVAL;
	}

	//设备树参数的第一个是参数物理中断号
	*out_hwirq = fwspec->param[0];
	//设备树参数的第二个是参数中断触发方式
	*out_type = fwspec->param[1] & IRQ_TYPE_SENSE_MASK;

	return 0;
}

//设置 irq_desc
static int virtual_intc_irq_alloc(struct irq_domain *d, unsigned int virq,
								unsigned int nr_irqs, void *arg)
{
	int i;
	unsigned long hwirq;
	unsigned int type;
	struct irq_fwspec *fwspec = arg;
	struct irq_fwspec parent_fwspec;

	printk("function:%s line:%d\n", __FUNCTION__, __LINE__);

	//解析设备树
	if(fwspec->param_count != 2)
	{
		printk("The device tree format is incorrect\n");
		return -EINVAL;
	}
	//设备树参数的第一个是参数物理中断号
	hwirq = fwspec->param[0];
	//设备树参数的第二个是参数中断触发方式
	type = fwspec->param[1] & IRQ_TYPE_SENSE_MASK;

	//绑定rq_chip
	for(i=0; i<nr_irqs; i++)
	{
		irq_domain_set_hwirq_and_chip(d, virq+i, hwirq+i, 
							&virtual_intc_irq_chip,
							NULL);
	}

	//组合上级中断控制器的IRQ说明符结构
	parent_fwspec.fwnode = d->parent->fwnode;
	parent_fwspec.param_count = 3;									//上级中断控制器需要3个参数
	parent_fwspec.param[0] = GIC_SPI;								//中断类型
	parent_fwspec.param[1] = fwspec->param[0] + upper_hwirq_base;	//物理中断号
	parent_fwspec.param[2] = fwspec->param[1];						//中断触发方式

	//调用上级中断控制器域的alloc函数
	return irq_domain_alloc_irqs_parent(d, virq, 1, &parent_fwspec);
}

//执行与 alloc 相反的操作
static void virtual_intc_irq_free(struct irq_domain *d, unsigned int virq, unsigned int nr_irqs)
{
	printk("function:%s line:%d\n", __FUNCTION__, __LINE__);

	irq_domain_free_irqs_common(d, virq, nr_irqs);
}

static const struct irq_domain_ops virtual_intc_domain_ops = {
	.alloc = virtual_intc_irq_alloc,
	.free = virtual_intc_irq_free,
	.translate = virtual_intc_irq_translate,
};

//设备和驱动匹配成功执行
static int virtual_intc_probe(struct platform_device *pdev)
{
	int result;
	struct irq_domain *parent_domain;
	struct device_node *parent_irq_node;

	printk("function:%s line:%d\n", __FUNCTION__, __LINE__);

	//读取此中断控制器0号中断对应的上级中断控制器的中断编号
	result = of_property_read_u32(pdev->dev.of_node, "upper_hwirq_base", &upper_hwirq_base);
	if(result != 0)
	{
		printk("read upper_hwirq_base failed\r\n");
		return result;
	}

	//得到上级中断控制器的设备树节点
	parent_irq_node = of_irq_find_parent(pdev->dev.of_node);
	if(!parent_irq_node) 
	{
		printk("find parent irq node failed\r\n");
		return -ENXIO;
	}

	//得到上级中断控制器的域
	parent_domain = irq_find_host(parent_irq_node);
	of_node_put(parent_irq_node);
	if(!parent_domain)
	{
		printk("find parent irq host failed\r\n");
		return -EPROBE_DEFER;
	}

	//注册hierarchy的类型的中断域
	virtual_intc_domain = irq_domain_add_hierarchy(parent_domain, 0, 4,
													pdev->dev.of_node, &virtual_intc_domain_ops,
													NULL);
	if(!virtual_intc_domain)
	{
		pr_err("unable to add irq domain\n");
		return -ENODEV;
	}

	return 0;
}

//设备或驱动卸载时执行
static int virtual_intc_remove(struct platform_device *pdev)
{
	irq_domain_remove(virtual_intc_domain);

	return 0;
}

/* 匹配列表，用于设备树和平台驱动匹配 */
static const struct of_device_id virtual_intc_of_match[] = {
	{.compatible = "atk,virtual_intc"},
	{ /* Sentinel */ }
};
//平台驱动
static struct platform_driver virtual_intc_drv = {
	.driver = {
		.name = "virtual_intc",
		.owner = THIS_MODULE,
		.pm = NULL,
		.of_match_table = virtual_intc_of_match,
	},
	.probe = virtual_intc_probe,
	.remove = virtual_intc_remove,
};

static int __init virtual_intc_drv_init(void)
{
	int result;

	printk("%s\r\n", __FUNCTION__);

	//注册平台驱动
	result = platform_driver_register(&virtual_intc_drv);
	if(result < 0)
	{
		printk("add cdev faikey\r\n");
		return result;
	}

	return 0;
}

static void __exit virtual_intc_drv_exit(void)
{
	printk("%s\r\n", __FUNCTION__);

	//注销平台驱动
	platform_driver_unregister(&virtual_intc_drv);
}

module_init(virtual_intc_drv_init);
module_exit(virtual_intc_drv_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("CSDN");
MODULE_DESCRIPTION("virtual_intc_drivrer");

中断测试程序

中断测试程序非常简单，就是从设备树获取中断号，然后通过request_irq注册对应的中断事件处理函数即可，其代码与5.3 legacy中断控制器驱动中的中断测试程序一样

上机测试

修改设备树，然后用新的设备树启动目标板，设备树中的GIC_SPI 中断号根据芯片手册进行修改
从这里下载代码。然后进行编译，并拷贝到目标板root目录
执行insmod virtual_intc.ko加载虚拟中断控制器驱动
执行命令加载中断控制器测试设备的驱动insmod virtual_intc_key.ko，此时可以看到设备树解析函数translate、irq_desc设置函数alloc、中断使能函数unmask被调用
执行命令devmem 0xa002121c 32 0x40000，触发GIC_SPI 210中断（通过向特定寄存器写入值来实现）可以看到触发到虚拟中断控制器的0号中断，用同样的方法还可以触发1号中断和3号中断

注意：在卸载时必须先卸载virtual_intc_key.ko，再卸载virtual_intc.ko，否则可能会报段错误