一、platform总线、设备与驱动

        在Linux 2.6 的设备驱动模型中，关心总线、设备和驱动3个实体，总线将设备和驱动绑定。在系统每注册一个设备的时候，会寻找与之匹配的驱动；相反的，在系统每注册一个驱动的时候，会寻找与之匹配的设备，而匹配由总线完成。

一个现实的Linux设备和驱动通常都需要挂接在一种总线上，对于本身依附于PCI、USB、I2C、SPI等的设备而言，这自然不是问题，但是在嵌入式系统里面，SoC系统中集成的独立的外设控制器、挂接在SoC内存空间的外设等确不依附于此类总线。基于这一背景，Linux发明了一种虚拟的总线，称为platform总线，相应的设备称为platform_device，而驱动成为 platform_driver。

注意，所谓的platform_device并不是与字符设备、块设备和网络设备并列的概念，而是Linux系统提供的一种附加手段，例如，在 S3C6410处理器中，把内部集成的I2C、RTC、SPI、LCD、看门狗等控制器都归纳为platform_device，而它们本身就是字符设备。

基于Platform总线的驱动开发流程如下：

a -- 定义初始化platform bus

b -- 定义各种platform devices

c -- 注册各种platform devices

d -- 定义相关platform driver

e -- 注册相关platform driver

f  -- 操作相关设备

相关结构体定义：

1、平台相关结构 --- platform_device结构体

[cpp] view plaincopy
  1. struct platform_device {
  2. const char * name;/* 设备名 */
  3. u32 id;//设备id，用于给插入给该总线并且具有相同name的设备编号，如果只有一个设备的话填-1。
  4. struct device dev;//结构体中内嵌的device结构体。
  5. u32 num_resources;/* 设备所使用各类资源数量 */
  6. struct resource * resource;/* //定义平台设备的资源*/
  7. };

2、设备的驱动 --- platform_driver 结构体

这个结构体中包含probe()、remove()、shutdown()、suspend()、 resume()函数，通常也需要由驱动实现

[cpp] view plaincopy
  1. struct platform_driver {
  2. int (*probe)(struct platform_device *);
  3. int (*remove)(struct platform_device *);
  4. void (*shutdown)(struct platform_device *);
  5. int (*suspend)(struct platform_device *, pm_message_t state);
  6. int (*suspend_late)(struct platform_device *, pm_message_t state);
  7. int (*resume_early)(struct platform_device *);
  8. int (*resume)(struct platform_device *);
  9. struct pm_ext_ops *pm;
  10. struct device_driver driver;
  11. };

3、系统中为platform总线定义了一个bus_type的实例 --- platform_bus_type

[cpp] view plaincopy
  1. struct bus_type platform_bus_type = {
  2. .name = “platform”,
  3. .dev_attrs = platform_dev_attrs,
  4. .match = platform_match,
  5. .uevent = platform_uevent,
  6. .pm = PLATFORM_PM_OPS_PTR,
  7. };
  8. EXPORT_SYMBOL_GPL(platform_bus_type);

这里要重点关注其match()成员函数，正是此成员表明了platform_device和platform_driver之间如何匹配。

[cpp] view plaincopy
  1. static int platform_match(struct device *dev, struct device_driver *drv)
  2. {
  3. struct platform_device *pdev;
  4. pdev = container_of(dev, struct platform_device, dev);
  5. return (strncmp(pdev->name, drv->name, BUS_ID_SIZE) == 0);
  6. }

匹配platform_device和platform_driver主要看二者的name字段是否相同。对platform_device的定义通常在BSP的板文件中实现，在板文件中，将platform_device归纳为一个数组，最终通过platform_add_devices()函数统一注册。

platform_add_devices()函数可以将平台设备添加到系统中，这个函数的 原型为：

[cpp] view plaincopy
  1. int platform_add_devices(struct platform_device **devs, int num);

该函数的第一个参数为平台设备数组的指针，第二个参数为平台设备的数量，它内部调用了platform_device_register()函 数用于注册单个的平台设备。

a -- platform bus总线先被kenrel注册。

b -- 系统初始化过程中调用platform_add_devices或者platform_device_register，将平台设备(platform devices)注册到平台总线中(platform bus)

c -- 平台驱动(platform driver)与平台设备(platform device)的关联是在platform_driver_register或者driver_register中实现，一般这个函数在驱动的初始化过程调用。
通过这三步，就将平台总线，设备，驱动关联起来。


二．Platform初始化

系统启动时初始化时创建了platform_bus总线设备和platform_bus_type总线,platform总线是在内核初始化的时候就注册进了内核。

内核初始化函数kernel_init()中调用了do_basic_setup() ，该函数中调用driver_init()，该函数中调用platform_bus_init()，我们看看platform_bus_init()函数：

[cpp] view plaincopy
  1. int __init platform_bus_init(void)
  2. {
  3. int error;
  4. early_platform_cleanup(); //清除platform设备链表
  5. //该函数把设备名为platform 的设备platform_bus注册到系统中，其他的platform的设备都会以它为parent。它在sysfs中目录下.即 /sys/devices/platform。
  6. //platform_bus总线也是设备，所以也要进行设备的注册
  7. //struct device platform_bus = {
  8. //.init_name = "platform",
  9. //};
  10. error = device_register(&platform_bus);//将平台bus作为一个设备注册，出现在sys文件系统的device目录
  11. if (error)
  12. return error;
  13. //接着bus_register(&platform_bus_type)注册了platform_bus_type总线.
  14. /*
  15. struct bus_type platform_bus_type = {
  16. .name = “platform”,
  17. .dev_attrs = platform_dev_attrs,
  18. .match = platform_match,
  19. .uevent = platform_uevent,
  20. .pm = PLATFORM_PM_OPS_PTR,
  21. };
  22. */
  23. //默认platform_bus_type中没有定义probe函数。
  24. error = bus_register(&platform_bus_type);//注册平台类型的bus，将出现sys文件系统在bus目录下，创建一个platform的目录，以及相关属性文件
  25. if (error)
  26. device_unregister(&platform_bus);
  27. return error;
  28. }

总线类型match函数是在设备匹配驱动时调用，uevent函数在产生事件时调用。

platform_match函数在当属于platform的设备或者驱动注册到内核时就会调用，完成设备与驱动的匹配工作

[cpp] view plaincopy
  1. static int platform_match(struct device *dev, struct device_driver *drv)
  2. {
  3. struct platform_device *pdev = to_platform_device(dev);
  4. struct platform_driver *pdrv = to_platform_driver(drv);
  5. /* match against the id table first */
  6. if (pdrv->id_table)
  7. return platform_match_id(pdrv->id_table, pdev) != NULL;
  8. /* fall-back to driver name match */
  9. return (strcmp(pdev->name, drv->name) == 0);//比较设备和驱动的名称是否一样
  10. }
  11. static const struct platform_device_id *platform_match_id(struct platform_device_id *id,struct platform_device *pdev)
  12. {
  13. while (id->name[0]) {
  14. if (strcmp(pdev->name, id->name) == 0) {
  15. pdev->id_entry = id;
  16. return id;
  17. }
  18. id++;
  19. }
  20. return NULL;
  21. }

不难看出，如果pdrv的id_table数组中包含了pdev->name，或者drv->name和pdev->name名字相同，都会认为是匹配成功。id_table数组是为了应对那些对应设备和驱动的drv->name和pdev->name名字不同的情况。

再看看platform_uevent（）函数：platform_uevent 热插拔操作函数

[cpp] view plaincopy
  1. static int platform_uevent(struct device *dev, struct kobj_uevent_env *env)
  2. {
  3. struct platform_device *pdev = to_platform_device(dev);
  4. add_uevent_var(env, "MODALIAS=%s%s", PLATFORM_MODULE_PREFIX, (pdev->id_entry) ? pdev->id_entry->name : pdev->name);
  5. return 0;
  6. }

添加了MODALIAS环境变量，我们回顾一下：platform_bus. parent->kobj->kset->uevent_ops为device_uevent_ops，bus_uevent_ops的定义如下

[cpp] view plaincopy
  1. static struct kset_uevent_ops device_uevent_ops = {
  2. .filter = dev_uevent_filter,
  3. .name = dev_uevent_name,
  4. .uevent = dev_uevent,
  5. };

当调用device_add()时会调用kobject_uevent(&dev->kobj, KOBJ_ADD)产生一个事件，这个函数中会调用相应的kset_uevent_ops的uevent函数

三．Platform设备的注册

我们在设备模型的分析中知道了把设备添加到系统要调用device_initialize()和platform_device_add(pdev)函数。

Platform设备的注册分两种方式：

a -- 对于platform设备的初注册，内核源码提供了platform_device_add()函数，输入参数platform_device可以是静态的全局设备，它是进行一系列的操作后调用device_add()将设备注册到相应的总线（platform总线）上，内核代码中platform设备的其他注册函数都是基于这个函数，如platform_device_register()、platform_device_register_simple()、platform_device_register_data()等。

b -- 另外一种机制就是动态申请platform_device_alloc()一个platform_device设备，然后通过platform_device_add_resources及platform_device_add_data等添加相关资源和属性。

无论哪一种platform_device，最终都将通过platform_device_add这册到platform总线上。区别在于第二步：其实platform_device_add()包括device_add()，不过要先注册resources，然后将设备挂接到特定的platform总线。

1、 第一种平台设备注册方式

platform_device是静态的全局设备，即platform_device结构的成员已经初始化完成。直接将平台设备注册到platform总线上。platform_device_register和device_register的区别:

a  -- 主要是有没有resource的区别，前者的结构体包含后面，并且增加了struct resource结构体成员，后者没有。platform_device_register在device_register的基础上增加了struct resource部分的注册。

由此。可以看出，platform_device---paltform_driver_register机制与device-driver的主要区别就在于resource。前者适合于具有独立资源设备的描述，后者则不是。

b -- 其实linux的各种其他驱动机制的基础都是device_driver。只不过是增加了部分功能，适合于不同的应用场合.

[cpp] view plaincopy
  1. int platform_device_register(struct platform_device *pdev)
  2. {
  3. device_initialize(&pdev->dev);//初始化platform_device内嵌的device
  4. return platform_device_add(pdev);//把它注册到platform_bus_type上
  5. }
  6. int platform_device_add(struct platform_device *pdev)
  7. {
  8. int i, ret = 0;
  9. if (!pdev)
  10. return -EINVAL;
  11. if (!pdev->dev.parent)
  12. pdev->dev.parent = &platform_bus;//设置父节点，即platform_bus作为总线设备的父节点，其余的platform设备都是它的子设备
  13. //platform_bus是一个设备，platform_bus_type才是真正的总线
  14. pdev->dev.bus = &platform_bus_type;//设置platform总线,指定bus类型为platform_bus_type
  15. //设置pdev->dev内嵌的kobj的name字段,将platform下的名字传到内部device，最终会传到kobj
  16. if (pdev->id != -1)
  17. dev_set_name(&pdev->dev, "%s.%d", pdev->name, pdev->id);
  18. else
  19. dev_set_name(&pdev->dev, "%s", pdev->name);
  20. //初始化资源并将资源分配给它，每个资源的它的parent不存在则根据flags域设置parent，flags为IORESOURCE_MEM，
  21. //则所表示的资源为I/O映射内存，flags为IORESOURCE_IO，则所表示的资源为I/O端口。
  22. for (i = 0; i < pdev->num_resources; i++) {
  23. struct resource *p, *r = &pdev->resource[i];
  24. if (r->name == NULL)//资源名称为NULL则把设备名称设置给它
  25. r->name = dev_name(&pdev->dev);
  26. p = r->parent;//取得资源的父节点，资源在内核中也是层次安排的
  27. if (!p) {
  28. if (resource_type(r) == IORESOURCE_MEM) //如果父节点为NULL，并且资源类型为IORESOURCE_MEM，则把父节点设置为iomem_resource
  29. p = &iomem_resource;
  30. else if (resource_type(r) == IORESOURCE_IO)//否则如果类型为IORESOURCE_IO，则把父节点设置为ioport_resource
  31. p = &ioport_resource;
  32. }
  33. //从父节点申请资源，也就是出现在父节点目录层次下
  34. if (p && insert_resource(p, r)) {
  35. printk(KERN_ERR "%s: failed to claim resource %d\n",dev_name(&pdev->dev), i);ret = -EBUSY;
  36. goto failed;
  37. }
  38. }
  39. pr_debug("Registering platform device '%s'. Parent at %s\n",dev_name(&pdev->dev), dev_name(pdev->dev.parent));
  40. //device_creat() 创建一个设备并注册到内核驱动架构...
  41. //device_add() 注册一个设备到内核，少了一个创建设备..
  42. ret = device_add(&pdev->dev);//就在这里把设备注册到总线设备上,标准设备注册，即在sys文件系统中添加目录和各种属性文件
  43. if (ret == 0)
  44. return ret;
  45. failed:
  46. while (--i >= 0) {
  47. struct resource *r = &pdev->resource[i];
  48. unsigned long type = resource_type(r);
  49. if (type == IORESOURCE_MEM || type == IORESOURCE_IO)
  50. release_resource(r);
  51. }
  52. return ret;
  53. }

2、第二种平台设备注册方式

先分配一个platform_device结构，对其进行资源等的初始化；之后再对其进行注册，再调用platform_device_register()函数

[cpp] view plaincopy
  1. struct platform_device * platform_device_alloc(const char *name, int id)
  2. {
  3. struct platform_object *pa;
  4. /*
  5. struct platform_object {
  6. struct platform_device pdev;
  7. char name[1];
  8. };
  9. */
  10. pa = kzalloc(sizeof(struct platform_object) + strlen(name), GFP_KERNEL);//该函数首先为platform设备分配内存空间
  11. if (pa) {
  12. strcpy(pa->name, name);
  13. pa->pdev.name = pa->name;//初始化platform_device设备的名称
  14. pa->pdev.id = id;//初始化platform_device设备的id
  15. device_initialize(&pa->pdev.dev);//初始化platform_device内嵌的device
  16. pa->pdev.dev.release = platform_device_release;
  17. }
  18. return pa ? &pa->pdev : NULL;
  19. }

一个更好的方法是，通过下面的函数platform_device_register_simple()动态创建一个设备，并把这个设备注册到系统中：

[cpp] view plaincopy
  1. struct platform_device *platform_device_register_simple(const char *name,int id,struct resource *res,unsigned int num)
  2. {
  3. struct platform_device *pdev;
  4. int retval;
  5. pdev = platform_device_alloc(name, id);
  6. if (!pdev) {
  7. retval = -ENOMEM;
  8. goto error;
  9. }
  10. if (num) {
  11. retval = platform_device_add_resources(pdev, res, num);
  12. if (retval)
  13. goto error;
  14. }
  15. retval = platform_device_add(pdev);
  16. if (retval)
  17. goto error;
  18. return pdev;
  19. error:
  20. platform_device_put(pdev);
  21. return ERR_PTR(retval);
  22. }

该函数就是调用了platform_device_alloc()和platform_device_add()函数来创建的注册platform device，函数也根据res参数分配资源，看看platform_device_add_resources()函数：

[cpp] view plaincopy
  1. int platform_device_add_resources(struct platform_device *pdev,struct resource *res, unsigned int num)
  2. {
  3. struct resource *r;
  4. r = kmalloc(sizeof(struct resource) * num, GFP_KERNEL);//为资源分配内存空间
  5. if (r) {
  6. memcpy(r, res, sizeof(struct resource) * num);
  7. pdev->resource = r; //并拷贝参数res中的内容，链接到device并设置其num_resources
  8. pdev-> num_resources = num;
  9. }
  10. return r ? 0 : -ENOMEM;
  11. }

四．Platform设备驱动的注册

我们在设备驱动模型的分析中已经知道驱动在注册要调用driver_register()，platform driver的注册函数platform_driver_register()同样也是进行其它的一些初始化后调用driver_register()将驱动注册到platform_bus_type总线上.

[cpp] view plaincopy
  1. int platform_driver_register(struct platform_driver *drv)
  2. {
  3. drv->driver.bus = &platform_bus_type;//它将要注册到的总线
  4. /*设置成platform_bus_type这个很重要，因为driver和device是通过bus联系在一起的，
  5. 具体在本例中是通过 platform_bus_type中注册的回调例程和属性来是实现的,
  6. driver与device的匹配就是通过 platform_bus_type注册的回调例程platform_match ()来完成的。
  7. */
  8. if (drv->probe)
  9. drv-> driver.probe = platform_drv_probe;
  10. if (drv->remove)
  11. drv->driver.remove = platform_drv_remove;
  12. if (drv->shutdown)
  13. drv->driver.shutdown = platform_drv_shutdown;
  14. return driver_register(&drv->driver);//注册驱动
  15. }

然后设定了platform_driver内嵌的driver的probe、remove、shutdown函数。

[cpp] view plaincopy
  1. static int platform_drv_probe(struct device *_dev)
  2. {
  3. struct platform_driver *drv = to_platform_driver(_dev->driver);
  4. struct platform_device *dev = to_platform_device(_dev);
  5. return drv->probe(dev);//调用platform_driver的probe()函数，这个函数一般由用户自己实现
  6. //例如下边结构，回调的是serial8250_probe()函数
  7. /*
  8. static struct platform_driver serial8250_isa_driver = {
  9. .probe        = serial8250_probe,
  10. .remove        = __devexit_p(serial8250_remove),
  11. .suspend    = serial8250_suspend,
  12. .resume        = serial8250_resume,
  13. .driver        = {
  14. .name    = "serial8250",
  15. .owner    = THIS_MODULE,
  16. },
  17. };
  18. */
  19. }
  20. static int platform_drv_remove(struct device *_dev)
  21. {
  22. struct platform_driver *drv = to_platform_driver(_dev->driver);
  23. struct platform_device *dev = to_platform_device(_dev);
  24. return drv->remove(dev);
  25. }
  26. static void platform_drv_shutdown(struct device *_dev)
  27. {
  28. struct platform_driver *drv = to_platform_driver(_dev->driver);
  29. struct platform_device *dev = to_platform_device(_dev);
  30. drv->shutdown(dev);
  31. }

总结：

1、从这三个函数的代码可以看到，又找到了相应的platform_driver和platform_device，然后调用platform_driver的probe、remove、shutdown函数。这是一种高明的做法：

在不针对某个驱动具体的probe、remove、shutdown指向的函数，而通过上三个过度函数来找到platform_driver，然后调用probe、remove、shutdown接口。

如果设备和驱动都注册了，就可以通过bus ->match、bus->probe或driver->probe进行设备驱动匹配了。

2、驱动注册的时候platform_driver_register()->driver_register()->bus_add_driver()->driver_attach()->bus_for_each_dev()，

对每个挂在虚拟的platform bus的设备作__driver_attach()->driver_probe_device()->drv->bus->match()==platform_match()->比较strncmp(pdev->name, drv->name, BUS_ID_SIZE)，如果相符就调用platform_drv_probe()->driver->probe()，如果probe成功则绑定该设备到该驱动。

Linux 设备驱动开发 —— platform 设备驱动相关推荐

  1. Linux 设备驱动开发 —— platform设备驱动应用实例解析

    前面我们已经学习了platform设备的理论知识Linux 设备驱动开发 -- platform 设备驱动 ,下面将通过一个实例来深入我们的学习. 一.platform 驱动的工作过程 platfor ...

  2. STM32MP157驱动开发——platform设备驱动(中)

    STM32MP157驱动开发--platform设备驱动(中) 0.前言 一.platform设备模块--设备信息解析 二.platform驱动模块--加载设备 三.测试App 四.编译及运行 相关文 ...

  3. Linux 设备驱动开发 —— 设备树在platform设备驱动中的使用

    关与设备树的概念,我们在Exynos4412 内核移植(六)-- 设备树解析 里面已经学习过,下面看一下设备树在设备驱动开发中起到的作用 Device Tree是一种描述硬件的数据结构,设备树源(De ...

  4. ＜Linux开发＞--驱动开发-- 字符设备驱动（3） 过程详细记录

    <Linux开发>–驱动开发-- 字符设备驱动(3) 过程详细记录 驱动开发是建立再系统之上的,前面作者也记录了系统移植的过程记录,如果有兴趣,可进入博主的主页查看相关文章,这里就不添加链 ...

  5. 【Linux驱动开发】设备树详解（二）设备树语法详解

    ​ 活动地址:CSDN21天学习挑战赛 [Linux驱动开发]设备树详解(一)设备树基础介绍 [Linux驱动开发]设备树详解(二)设备树语法详解 [Linux驱动开发]设备树详解(三)设备树Kern ...

  6. STM32MP157驱动开发——蜂鸣器设备驱动

    STM32MP157驱动开发--蜂鸣器设备驱动 0.相关知识 一.驱动程序开发 1.设备树修改 2.启动程序编写 3.测试程序编写 二.编译及运行测试 0.相关知识   蜂鸣器常用于计算机.打印机.报 ...

  7. STM32MP157驱动开发——USB设备驱动

    STM32MP157驱动开发--USB设备驱动 一.简介 1.电气属性 2.USB OTG 3.STM32MP1 USB 接口简介 4.Type-C 电气属性 二.USB HOST 驱动开发 1.US ...

  8. Linux设备模型之platform设备

    Linux设备模型之platform设备 1. Platform模块的软件架构 2. Platform设备 2.1 platform_device原型 2.2 注册添加device 2.2.1 pla ...

  9. Linux嵌入式驱动开发07——GPIO驱动过程记录（飞凌开发板）

    文章目录 全系列传送门 1. 在/arch/arm/boot/dts/imx6q-pinfunc.h查找 2. 在设备树配置文件中添加设备节点定义以及其引脚定义 3. 修改设备树文件添加配置 4. d ...

最新文章

  1. Nature子刊：精胺介导稻瘟病菌侵染水稻叶片的新机制！
  2. 深度思考|TCP协议存在那些缺陷？
  3. 【BIM入门实战】Revit 图元分类有哪三种？Revit图元分类图文详解
  4. 如何讲页面打入jar包中_如何把我的Java程序变成exe文件？
  5. 用Markdown写博客快速入门
  6. Python画各种 3D 图形Matplotlib库
  7. linux ssh密钥登录
  8. 参考文献如何居中_一线教师如何写教育教学论文？
  9. 如何隐藏地址栏中的真实地址_代理IP如何隐藏真实IP
  10. 去掉Tomcat的管理页面
  11. java泛型与集合中文版,第8章java泛型与集合类.doc
  12. 2020云服务平台领域最具商业合作价值企业盘点
  13. 贝叶斯网络之父Judea Pearl力荐、LeCun点赞，这篇长论文全面解读机器学习中的因果关系
  14. VP9编码（3）-- 符号
  15. 怎么判断冠词用a还是an_如何判断单词前的冠词用a还是an
  16. 数据结构：单链表中在P结点前插入S结点
  17. 携程和12306解绑
  18. 企业邮箱支持通过手机号登录邮箱
  19. linux系统怎么进入救援模式,Linux怎么进入救援模式？
  20. 如何在Excel中对工作表进行分组

热门文章

  1. android thread实例
  2. 计算机软件技术基础fifo算法,软件技术基础真题
  3. 代码 抠图_3 行 Python 代码 5 秒抠图的 AI 神器，根本无需 PS，附教程
  4. leetcode 188. 买卖股票的最佳时机 IV（dp）
  5. leetcode35. 搜索插入位置（二分搜索）
  6. shopify二次开发教程_详细教程：如何将Shopify的Storefront API与React和Redux结合使用...
  7. c语言 二进制压缩算法_使用C ++解释的二进制搜索算法
  8. 随机加密_随机艺术和加密圣诞树
  9. react 组件引用组件_React Elements VS React组件
  10. 一亿小目标成就_成就卓越的一种方式：自我选择