Linux设备驱动——虚拟总线platform

- 日理万妓 2021-12-09 05:49 458阅读 0赞

在Linux设备中有的是没有对应的物理总线的，但为了适配Linux的总线模型，内核针对这种没有物理总线的设备开发了一种虚拟总线——platform总线。

一、平台设备（device）

1.平台设备是用struct platform_device结构来表示的，它的定义如下：

  1. struct platform_device {
  3.     const char    *name;
  4.     int        id;
  5.     bool        id_auto;
  6.     struct device    dev;
  7.     u32        num_resources;
  8.     struct resource    *resource;
  10.     const struct platform_device_id    *id_entry;
  11.     char *driver_override; /* Driver name to force a match */
  13.     /* MFD cell pointer */
  14.     struct mfd_cell *mfd_cell;
  16.     /* arch specific additions */
  17.     struct pdev_archdata    archdata;
  18. };

驱动开发者关心的主要成员有：
name： 设备的名字，在平台总线的match函数中可用于同平台driver的匹配；
id： 设备的ID，用于区分同类型不同的device；
dev： 内嵌的struct device；
nem_resources： 平台设备使用的资源个数；
resource： 平台设备的资源列表，指向资源数组中的首元素；
id_entry： 用于同平台驱动匹配的ID，在平台总线的match函数中首先尝试匹配该ID，如果不成功在尝试用name成员来匹配。

下面为我定义的两个device：

  1. struct platform_device pdev0 = {
  3.     .name = "pdev",
  4.     .id = 0,
  5.     .num_resources = 1,
  6.     .resource = &pdev_resources[0],
  7.     .dev = {
  9.         .release = pdev_release,
  10.     },
  11. };
  13. struct platform_device pdev1 = {
  15.     .name = "pdev",
  16.     .id = 1,
  17.     .num_resources = 1,
  18.     .resource = &pdev_resources[1],
  19.     .dev = {
  21.         .release = pdev_release,
  22.     },
  23. };

2.在平台设备中，最关键的是struct resource，这是实现device和driver分离的关键，其定义如下：

  1. struct resource {
  3.     resource_size_t start;
  4.     resource_size_t end;
  5.     const char *name;
  6.     unsigned long flags;
  7.     struct resource *parent, *sibling, *child;
  8. };

驱动开发者关心的主要成员如下：
start： 资源的开始，对于内存来说是内存起始地址，对于中断资源来说是起始中断号，对于DMA资源来说是DMA起始通道号；
end： 资源的结束；
flags： 资源的标志，常见的有一下几种：

  • IORESOURCE_MEM：内存资源；
  • IORESOURCE_IRQ：中断资源；
  • IORESOURCE_DMA：DMA资源。

下面为我定义的resource：

  1. static char buf0[200] = {
  2.     0};
  3. static char buf1[200] = {
  4.     0};
  6. static struct resource pdev_resources[] = {
  8.     [0] = {
  9.     buf0,  buf0+sizeof(buf0)-1,  "pdev0-resource", IORESOURCE_MEM,},
  10.     [1] = {
  11.     buf1,  buf1+sizeof(buf1)-1,  "pdev1-resource", IORESOURCE_MEM,},
  12. };

3.向platform总线注册和注销device的主要函数如下：

  1. int platform_device_register(struct platform_device *pdev)；
  2. void platform_device_unregister(struct platform_device *pdev)；

二、平台驱动（driver）

1.平台驱动（driver）用struct platform_driver结构来表示，其定义如下：

  1. struct platform_driver {
  3. int (*probe)(struct platform_device *);
  4. int (*remove)(struct platform_device *);
  5. void (*shutdown)(struct platform_device *);
  6. int (*suspend)(struct platform_device *, pm_message_t state);
  7. int (*resume)(struct platform_device *);
  8. struct device_driver driver;
  9. const struct platform_device_id *id_table;
  10. bool prevent_deferred_probe;
  11. };

驱动开发者关心的主要成员如下：
probe： platform总线发现有匹配的平台设备（device）时调用；
remove： 驱动的平台设备（device）被移除或平台驱动（driver）注销时调用；
shutdown、suspend和resume： 电源管理函数；
id_table: 平台驱动（driver）可以驱动的平台设备ID列表。
下面为我定义的driver：

  1. struct platform_driver pdrv = {
  3.     .driver = {
  5.         .name    = "pdev",
  6.         .owner   = THIS_MODULE,
  7.         .pm      = &pdrv_pm_ops,
  8.     },
  9.     .probe   = pdrv_probe,
  10.     .remove  = pdrv_remove,
  11. };

2.向platform总线注册和注销驱动的主要函数如下：

  1. platform_driver_register(drv);
  2. platform_driver_unregister(drv);

三、示例代码

在这里我实现了一个简单的platform驱动，其中device注册了两个设备，如下：

pltdev.c

  1. #include <linux/init.h>
  2. #include <linux/kernel.h>
  3. #include <linux/module.h>
  4. #include <linux/platform_device.h>
  6. static char buf0[200] = {
  7.     0};
  8. static char buf1[200] = {
  9.     0};
  11. static struct resource pdev_resources[] = {
  13.     [0] = {
  14.     buf0,  buf0+sizeof(buf0)-1,  "pdev0-resource", IORESOURCE_MEM,},
  15.     [1] = {
  16.     buf1,  buf1+sizeof(buf1)-1,  "pdev1-resource", IORESOURCE_MEM,},
  17. };
  19. static void pdev_release(struct device *dev)
  20. {
  22. }
  24. struct platform_device pdev0 = {
  26.     .name = "pdev",
  27.     .id = 0,
  28.     .num_resources = 1,
  29.     .resource = &pdev_resources[0],
  30.     .dev = {
  32.         .release = pdev_release,
  33.     },
  34. };
  36. struct platform_device pdev1 = {
  38.     .name = "pdev",
  39.     .id = 1,
  40.     .num_resources = 1,
  41.     .resource = &pdev_resources[1],
  42.     .dev = {
  44.         .release = pdev_release,
  45.     },
  46. };
  48. static int __init pltdev_init(void)
  49. {
  51.     strcpy(buf0, "hello");
  52.     strcpy(buf1, "world");
  54.     printk(KERN_EMERG"pltdev_init!\n");
  56.     platform_device_register(&pdev0);
  57.     platform_device_register(&pdev1);
  59.     return 0;
  60. }
  62. static void __exit pltdev_exit(void)
  63. {
  65.     printk(KERN_EMERG"pltdev_exit!\n");
  67.     platform_device_unregister(&pdev1);
  68.     platform_device_unregister(&pdev0);
  69. }
  71. module_init(pltdev_init);
  72. module_exit(pltdev_exit);
  74. MODULE_LICENSE("GPL");
  75. MODULE_AUTHOR("xiaodongzhao");
  76. MODULE_DESCRIPTION("register a platfom device");

pltdrv.c

  1. #include <linux/init.h>
  2. #include <linux/kernel.h>
  3. #include <linux/module.h>
  5. #include <linux/platform_device.h>
  7. static int pdrv_suspend(struct device *dev)
  8. {
  10.     printk(KERN_EMERG"pdev: suspend\n");
  11.     return 0;
  12. }
  14. static int pdrv_resume(struct device *dev)
  15. {
  17.     printk(KERN_EMERG"pdev: resume\n");
  18.     return 0;
  19. }
  21. static const struct dev_pm_ops pdrv_pm_ops = {
  23.     .suspend = pdrv_suspend,
  24.     .resume  = pdrv_resume,
  25. };
  27. static int pdrv_probe(struct platform_device *pdev)
  28. {
  30.     struct resource* mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
  32.     printk(KERN_EMERG"id:%d name:%s buf:%s\n", pdev->id, mem_res->name, (char*)mem_res->start);
  34.     return 0;
  35. }
  37. static int pdrv_remove(struct platform_device *pdev)
  38. {
  40.     printk(KERN_EMERG"pdrv_remove!\n");
  42.     return 0;
  43. }
  45. struct platform_driver pdrv = {
  47.     .driver = {
  49.         .name    = "pdev",
  50.         .owner   = THIS_MODULE,
  51.         .pm      = &pdrv_pm_ops,
  52.     },
  53.     .probe   = pdrv_probe,
  54.     .remove  = pdrv_remove,
  55. };
  57. static int __init pdev_init(void)
  58. {
  60.     int ret;
  62.     printk(KERN_EMERG"pdev_init!\n");
  63.     ret = platform_driver_register(&pdrv);
  65.     return ret;
  66. }
  68. static void __exit pdev_exit(void)
  69. {
  71.     printk(KERN_EMERG"pdev_exit!\n");
  73.     platform_driver_unregister(&pdrv);
  74. }
  76. module_init(pdev_init);
  77. module_exit(pdev_exit);
  79. //module_platform_driver(pdrv);
  81. MODULE_LICENSE("GPL");
  82. MODULE_AUTHOR("xiaodongzhao");
  83. MODULE_DESCRIPTION("A simple platform driver");
  84. MODULE_ALIAS("platform:pdev");

测试：
测试结果如下：

  1. # insmod pltdev.ko 
  2. pltdev_init!
  3. # insmod pltdrv.ko 
  4. id:0 name:pdev0-resource buf:hello
  5. id:1 name:pdev1-resource buf:world

从上述结果可知，在插入pltdrv.ko的时候driver被匹配了两次，因为在device中注册了两个设备。

发表评论

表情：
评论列表 （有 0 条评论，458人围观）

还没有评论，来说两句吧...

相关阅读

    相关 999、platform设备驱动实验

    一、驱动的分离和分隔 驱动的分隔，也就是将主机驱动和设备驱动分隔开来，比如 I2C、 SPI 等等都会采用驱动分隔的方式来简化驱动的开发。在实际的驱动开发中，一般 I2C

    港控/mmm°港控/mmm°/ 0 赞/ 261 阅读