RK3568平台 of操作函数获取中断资源

一.of操作函数获取中断资源

irq_of_parse_and_map 函数，从设备节点的"interrupts"属性中解析和映射对应的中断号。

unsigned int irq_of_parse_and_map(struct device_node *dev, int index);

dev：设备节点，表示要解析的设备节点。

index：索引号，表示从"interrupts"属性中获取第几个中断号。

返回值： 是一个无符号整数，表示成功解析和映射的中断号。

irq_get_trigger_type 函数，从中断数据结构（irq_data）中获取对应的中断触发类型。

u32 irqd_get_trigger_type(struct irq_data *d);

d：中断数据结构（irq_data），表示要获取中断触发类型的中断。

返回值： 是一个无符号 32 位整数，表示成功获取的中断触发类型。

irq_get_irq_data 函数，根据中断号获取对应的中断数据结构。

struct irq_data *irq_get_irq_data(unsigned int irq);

irq：中断号，表示要获取中断数据结构的中断号。

返回值： 指向 irq_data 结构体的指针，表示成功获取的中断数据结构。

gpio_to_irq 函数，根据 GPIO 编号获取对应的中断号。

int gpio_to_irq(unsigned int gpio);

gpio：GPIO 编号，表示要获取中断号的 GPIO。

返回值： 是一个整数，表示成功获取的中断号。

of_irq_get 函数，是从设备节点的"interrupts"属性中获取对应的中断号。

int of_irq_get(struct device_node *dev, int index);

dev：设备节点，表示要获取中断号的设备节点。

index：索引号，表示从"interrupts"属性中获取第几个中断号。

返回值： 是一个整数，表示成功获取的中断号。

二.of操作函数获取中断资源驱动程序

dts：

myirq {
			compatible = "my_devicetree_irq";
			interrupt-parent = <&gpio3>;
			interrupts = ;
};

驱动程序：

#include 
#include 
#include 
#include 
#include 
#include 
int num;
int irq;
struct irq_data *my_irq_data;
struct device_node *mydevice_node;
u32 trigger_type;

// 平台设备的初始化函数
static int my_platform_probe(struct platform_device *pdev)
{
    printk(KERN_INFO "my_platform_probe: Probing platform device\n");

    // 查找设备节点
    mydevice_node = of_find_node_by_name(NULL, "myirq");
    
    // 解析和映射中断
    irq = irq_of_parse_and_map(mydevice_node, 0);
    printk("irq is %d\n", irq);
    
    // 获取中断数据结构
    my_irq_data = irq_get_irq_data(irq);
    // 获取中断触发类型
    trigger_type = irqd_get_trigger_type(my_irq_data);
    printk("trigger type is 0x%x\n", trigger_type);
    
    // 将GPIO转换为中断号
    irq = gpio_to_irq(101);
    printk("irq is %d\n", irq);
    
    // 从设备节点获取中断号
    irq = of_irq_get(mydevice_node, 0);
    printk("irq is %d\n", irq);
    
    // 获取平台设备的中断号
    irq = platform_get_irq(pdev, 0);
    printk("irq is %d\n", irq);
    return 0;
}

// 平台设备的移除函数
static int my_platform_remove(struct platform_device *pdev)
{
    printk(KERN_INFO "my_platform_remove: Removing platform device\n");

    // 清理设备特定的操作
    // ...

    return 0;
}


const struct of_device_id of_match_table_id[]  = {
	{.compatible="my_devicetree_irq"},
};

// 定义平台驱动结构体
static struct platform_driver my_platform_driver = {
    .probe = my_platform_probe,
    .remove = my_platform_remove,
    .driver = {
        .name = "my_platform_device",
        .owner = THIS_MODULE,
		.of_match_table =  of_match_table_id,
    },
};

// 模块初始化函数
static int __init my_platform_driver_init(void)
{
    int ret;

    // 注册平台驱动
    ret = platform_driver_register(&my_platform_driver);
    if (ret) {
        printk(KERN_ERR "Failed to register platform driver\n");
        return ret;
    }

    printk(KERN_INFO "my_platform_driver: Platform driver initialized\n");

    return 0;
}

// 模块退出函数
static void __exit my_platform_driver_exit(void)
{
    // 注销平台驱动
    platform_driver_unregister(&my_platform_driver);

    printk(KERN_INFO "my_platform_driver: Platform driver exited\n");
}

module_init(my_platform_driver_init);
module_exit(my_platform_driver_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("topeet");