• 驱动——platform驱动总线三种匹配方式

    三种platform驱动匹配方式代码案例以及现象

    方式一：通过设置名字进行匹配

    相关API简介：

    1、platform_device的API

    ①分配对象

    struct platform_device {

            const  char *name;//用于进行匹配的名字

            int  id;//总线号 PLATFORM_DEVID_AUTO（自动分配总线号）

            struct  devicedev;//父类

            u32     num_resources;//表示设备信息的个数

            struct resource*resource;//描述硬件设备信息的结构体

    }；

    struct device {

            void    (*release)(struct device *dev); //释放device的资源

    }

    struct resource {

            resource_size_t start;//资源的起始数值 

            resource_size_t end;//资源的结束值

            unsigned long flags;//资源的类型 // IORESOURCE_IO|IORESOURCE_MEM|IORESOURCE_IRQ };

    ②对象初始化

    1>定义一个relese函数

    void pdev_release(struct device *dev) { }

    2>对设备信息进行填充

    struct resource res[]={

                    [0]={

                            .start=0x12345678,

                            .end=0x12345678+49,

                            .flags= IORESOURCE_MEM,

                    },

                    [1]={

                            .start=71,

                            .end=71,

                            .flags= IORESOURCE_IRQ,

                    },

    };

    3>给对象赋值

    struct platform_device pdev={

                            .name="aaaaa"，

                            .id=PLATFORM_DEVID_AUTO,

                            .dev={

                                    .release=pdev_release,

                            },

                            .resource=res,

                            .num_resources=ARRAY_SIZE(res),

    }；

    ③将对象注册进内核

    int platform_device_register(struct platform_device *pdev)

    参数：platform_device对象指针

    ④注销对象

     int platform_device_unregister(struct platform_device *pdev)

     2、platform_driver的API

    ①对象结构体

    struct platform_driver {
                    //匹配成功后执行probe函数
                    int (*probe)(struct platform_device *);
                     //设备和驱动分离的时候执行remove函数
                    int (*remove)(struct platform_device *);
                     //父类，进行匹配选项的设置
                    struct device_driver driver;
                     //通过id_table的方式匹配设备文件
                    const struct platform_device_id *id_table;
    };

    struct device_driver {
                    const char  *name;//设置名字匹配
                    struct of_device_id*of_match_table;//通过设备树进行匹配
            }；

    ②对象的初始化

    //定义一个probe函数
        int pdrv_probe(struct platform_device *pdev)
        {      
        }
        int pdrv_remove(struct platform_device *pdev)
        {      
        }
        //对象初始化
        struct platform_driver pdrv={
            .probe=pdrv_probe,
            .remove=pdrv_remove,  
            .driver={
                .name="aaaaa",        
            },  
        };

    ③对象的注册

     #define platform_driver_register(drv)   __platform_driver_register(drv, THIS_MODULE)

    ④对象的注销

    void platform_driver_unregister(struct platform_driver *drv)

    3、代码实现

    ——device

    1. #include 
    2. #include 
    3. #include 
    4.  
    5. //对设备信息进行填充
    6.   struct resource res[]={
    7.       [0]={
    8.          .start=0x12345678,
    9.          .end=0x12345678+49,
    10.          .flags= IORESOURCE_MEM,     
    11.       },
    12.       [1]={
    13.           .start=71,
    14.          .end=71,
    15.          .flags= IORESOURCE_IRQ,      
    16.       },
    17.   };
    18.   
    19. //定义一个relese函数
    20. void pdev_release(struct device *dev)
    21. {
    22.     printk("%s:%d\n",__func__,__LINE__);
    23. }
    24.  
    25.   //给对象赋值
    26.   struct platform_device pdev={
    27.       .name="aaaaa",
    28.       .id=PLATFORM_DEVID_AUTO,
    29.       .dev={
    30.           .release=pdev_release,      
    31.       },
    32.       .resource=res,
    33.       .num_resources=ARRAY_SIZE(res),        
    34.   };
    35.  
    36. static int __init mycdev_init(void)
    37. {
    38.     //注册device
    39.     return platform_device_register(&pdev);
    40. }
    41. static void __exit mycdev_exit(void)
    42. {
    43.     //注销device
    44.     platform_device_unregister(&pdev);
    45.  
    46. }
    47. module_init(mycdev_init);
    48. module_exit(mycdev_exit);
    49. MODULE_LICENSE("GPL");

    ——driver

    1. #include
    2. #include
    3. #include
    4. #include
    5. struct resource *res;
    6. int irqno;
    7. //对象的初始化
    8. int pdrv_probe(struct platform_device *pdev)
    9. {
    10.     printk("%s:%d\n",__func__,__LINE__); 
    11.     res=platform_get_resource(pdev,IORESOURCE_MEM,0);
    12.         if(res==NULL)
    13.         {
    14.             printk("获取MEM资源失败\n");
    15.             return ENODATA;
    16.         }
    17.     //获取中断类型的资源
    18.     irqno=platform_get_irq(pdev,0);
    19.         if(irqno<0)
    20.         {
    21.             printk("获取中断资源失败\n");
    22.             return ENODATA;
    23.         }
    24.  
    25.         printk("addr:%#llx ,irqno:%d\n",res->start,irqno);
    26.     return 0;
    27. }
    28.  
    29. int pdrv_remove(struct platform_device *pdev)
    30. {
    31.     printk("%s:%d\n",__func__,__LINE__);
    32.     return 0;
    33. } 
    34. struct platform_driver pdrv={
    35.     .probe=pdrv_probe,
    36.     .remove=pdrv_remove,
    37.     .driver={
    38.         .name="aaaaa",
    39.     },
    40. };
    41.  
    42. module_platform_driver(pdrv);
    43. MODULE_LICENSE("GPL");

    4、测试现象

     方式二：通过id_table方式匹配

            在驱动编写的时候，有时候需要一个驱动适配多款硬件，任何一个硬件的设备信息和这个驱动匹配成功后都可以执行这个驱动里的probe函数，所以为了解决这个情景，linux内核设计了id_table存取设备的名字列表，驱动端选择id_table方式通过platform_device_id来实现：

    #include
    struct platform_device_id {
        char name[PLATFORM_NAME_SIZE];//匹配的名字
        kernel_ulong_t driver_data;//设备驱动的私有数据
    };

     代码实现—

    ——device

    1. #include 
    2. #include 
    3. #include 
    4.  
    5. //对设备信息进行填充
    6.   struct resource res[]={
    7.       [0]={
    8.          .start=0x12345678,
    9.          .end=0x12345678+49,
    10.          .flags= IORESOURCE_MEM,     
    11.       },
    12.       [1]={
    13.           .start=71,
    14.          .end=71,
    15.          .flags= IORESOURCE_IRQ,      
    16.       },
    17.   };
    18.   
    19. //定义一个relese函数
    20. void pdev_release(struct device *dev)
    21. {
    22.     printk("%s:%d\n",__func__,__LINE__);
    23. }
    24.  
    25.   //给对象赋值
    26.   struct platform_device pdev={
    27.       .name="hello1",
    28.       .id=PLATFORM_DEVID_AUTO,
    29.       .dev={
    30.           .release=pdev_release,      
    31.       },
    32.       .resource=res,
    33.       .num_resources=ARRAY_SIZE(res),        
    34.   };
    35.  
    36. static int __init mycdev_init(void)
    37. {
    38.     //注册device
    39.     return platform_device_register(&pdev);
    40. }
    41. static void __exit mycdev_exit(void)
    42. {
    43.     //注销device
    44.     platform_device_unregister(&pdev);
    45.  
    46. }
    47. module_init(mycdev_init);
    48. module_exit(mycdev_exit);
    49. MODULE_LICENSE("GPL");

    ——driver

    1. #include
    2. #include
    3. #include
    4. #include
    5. struct resource *res;
    6. int irqno;
    7. //对象的初始化
    8. int pdrv_probe(struct platform_device *pdev)
    9. {
    10.     printk("%s:%d\n",__func__,__LINE__); 
    11.     res=platform_get_resource(pdev,IORESOURCE_MEM,0);
    12.         if(res==NULL)
    13.         {
    14.             printk("获取MEM资源失败\n");
    15.             return ENODATA;
    16.         }
    17.     //获取中断类型的资源
    18.     irqno=platform_get_irq(pdev,0);
    19.         if(irqno<0)
    20.         {
    21.             printk("获取中断资源失败\n");
    22.             return ENODATA;
    23.         }
    24.  
    25.         printk("addr:%#llx ,irqno:%d\n",res->start,irqno);
    26.     return 0;
    27. }
    28.  
    29. int pdrv_remove(struct platform_device *pdev)
    30. {
    31.     printk("%s:%d\n",__func__,__LINE__);
    32.     return 0;
    33. } 
    34. struct platform_device_id idtable[]={
    35.     {"hello1",0},
    36.     {"hello2",1},
    37.     {"hello3",2},
    38.     {},
    39. };
    40. //热插拔宏
    41. MODULE_DEVICE_TABLE(platform,idtable);
    42. struct platform_driver pdrv={
    43.     .probe=pdrv_probe,
    44.     .remove=pdrv_remove,
    45.     .driver={
    46.         .name="aaaaa",
    47.     },
    48. };
    49.  
    50. module_platform_driver(pdrv);
    51. MODULE_LICENSE("GPL");

    测试现象 

     

    方式三：通过设备树进行匹配

            在linux内核版本3.10之后，要求所有的设备信息都放在设备树中，所以在platform驱动被使用的时候不再写platform_device了。而是将platform_device中的设备信息直接放在设备树中即可

     1、添加设备节点信息

    1.    myplatform{
    2.        compatible="hqyj,platform";
    3.        reg=<0x12345678 0x14>;
    4.        interrupt-parent = <&gpiof>;
    5.        interrupts = <9 0>;
    6.        myled1 = <&gpioe 10 0>;
    7.    };

    2、将匹配方式设置为设备树匹配 

     //构建compatible表
        struct of_device_id oftable[]=
        {
            {.compatible="hqyj,platform",},
            {}
        };
        //热插拔宏
        MODULE_DEVICE_TABLE(of,oftable);  
        //对象初始化
        struct platform_driver pdrv={       
            .probe=pdrv_probe,
            .remove=pdrv_remove,  
            .driver={
                .name="aaaaa", //设置名字匹配
                .of_match_table=oftable,//设备树匹配
            }, 

    3、解析设备树节点信息获取GPIO编号

    4、代码实现

    1. #include
    2. #include
    3. #include
    4. #include
    5. #include
    6. #include
    7. /*   myplatform{
    8.        compatible="hqyj,platform";
    9.        reg=<0x12345678 0x14>;
    10.        interrupt-parent = <&gpiof>;
    11.        interrupts = <9 0>;
    12.        myled1 = <&gpioe 10 0>;
    13.    };                              
    14. */
    15. struct resource *res;
    16. int irqno;
    17. struct gpio_desc *gpiono;
    18. //对象的初始化
    19. int pdrv_probe(struct platform_device *pdev)
    20. {
    21.     printk("%s:%d\n",__func__,__LINE__);
    22.     res = platform_get_resource(pdev,IORESOURCE_MEM,0);
    23.     if(res==NULL)
    24.     {
    25.         printk("paltform get resource error\n");
    26.         return ENODATA;
    27.     }
    28.     irqno = platform_get_irq(pdev,0);
    29.     if(irqno<0)
    30.     {
    31.         printk("paltform get irq error\n");
    32.         return ENODATA;
    33.     }
    34.     printk("addr:%#x,irqno:%d\n",res->start,irqno);
    35.     //解析设备树节点信息获取GPIO编号
    36.     gpiono=gpiod_get_from_of_node(pdev->dev.of_node,"myled1",0,GPIOD_OUT_HIGH,NULL);
    37.     if(IS_ERR(gpiono))
    38.     {
    39.         printk("gpiod get from of node error\n");
    40.         return PTR_ERR(gpiono);
    41.     }
    42.     printk("gpiod get from of node success\n");
    43.     //点灯
    44.     gpiod_set_value(gpiono,1);
    45.     return 0;
    46. }
    47.  
    48. int pdrv_remove(struct platform_device *pdev)
    49. {
    50.     printk("%s:%d\n",__func__,__LINE__);
    51.     gpiod_set_value(gpiono, 0);
    52.     gpiod_put(gpiono);
    53.     return 0;
    54. } 
    55. //构建compatible表
    56. struct of_device_id oftable[]=
    57. {
    58.     {.compatible="hqyj,platform",},
    59.     {}
    60. };
    61. //热插拔宏
    62. MODULE_DEVICE_TABLE(of,oftable);
    63. struct platform_driver pdrv={
    64.     .probe=pdrv_probe,
    65.     .remove=pdrv_remove,
    66.     .driver={
    67.         .name="aaaaa",
    68.         .of_match_table=oftable,//设备树匹配
    69.     },
    70.     
    71. };
    72.  
    73. module_platform_driver(pdrv);
    74. MODULE_LICENSE("GPL");

    5、 测试现象

  • 相关阅读:
    python：数据类型、编码方式（base64、utf--8）、python中的进制、\u,\x,0x区别
    [谷粒商城笔记]08、环境-linux安装docker
    【C语言】文件操作（一）
    KingbaseESV8R6垃圾回收受到参数old_snapshot_threshold的影响
    Android - Context
    【无标题】
    python中float类型是如何实现的
    Laravel框架06：文件、迁移填充、会话、缓存
    LeetCode·32.最长有效括号·栈·动态规划
    【安卓APP毕业设计源码】android在线点单系统APP
  • 原文地址：https://blog.csdn.net/ww1106/article/details/128103591