Chinaunix首页 | 论坛 | 博客
  • 博客访问: 855863
  • 博文数量: 290
  • 博客积分: 511
  • 博客等级: 下士
  • 技术积分: 1590
  • 用 户 组: 普通用户
  • 注册时间: 2010-11-29 13:14
文章分类

全部博文(290)

文章存档

2018年(28)

2017年(19)

2016年(8)

2015年(1)

2014年(14)

2013年(12)

2012年(22)

2011年(186)

分类: LINUX

2014-07-08 13:02:38

原文地址:linux Platform设备驱动 作者:wangbaolin719


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

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

  8. 3.基于Platform总线的驱动开发流程如下:
  9. (1)定义初始化platform bus
  10. (2)定义各种platform devices
  11. (3)注册各种platform devices
  12. (4)定义相关platform driver
  13. (5)注册相关platform driver
  14. (6)操作相关设备

  15. 4.平台相关结构
  16. //platform_device结构体
  17. struct platform_device {
  18.     const char * name;/* 设备名 */
  19.     u32 id;//设备id,用于给插入给该总线并且具有相同name的设备编号,如果只有一个设备的话填-1。
  20.     struct device dev;//结构体中内嵌的device结构体。
  21.     u32 num_resources;/* 设备所使用各类资源数量 */
  22.   struct resource * resource;/* //定义平台设备的资源*/
  23. };

  24. //平台资源结构
  25. struct resource {
  26.     resource_size_t start; //定义资源的起始地址
  27.     resource_size_t end; //定义资源的结束地址
  28.     const char *name; //定义资源的名称
  29.     unsigned long flags; //定义资源的类型,比如MEM,IO,IRQ,DMA类型
  30.     struct resource *parent, *sibling, *child;
  31. };

  32. //设备的驱动:platform_driver这个结构体中包含probe()、remove()、shutdown()、suspend()resume()函数,通常也需要由驱动实现。
  33. struct platform_driver {
  34.     int (*probe)(struct platform_device *);
  35.     int (*remove)(struct platform_device *);
  36.     void (*shutdown)(struct platform_device *);
  37.     int (*suspend)(struct platform_device *, pm_message_t state);
  38.     int (*suspend_late)(struct platform_device *, pm_message_t state);
  39.     int (*resume_early)(struct platform_device *);
  40.     int (*resume)(struct platform_device *);
  41.     struct pm_ext_ops *pm;
  42.     struct device_driver driver;
  43. };
  44.  
  45. //系统中为platform总线定义了一个bus_type的实例platform_bus_type,
  46. struct bus_type platform_bus_type = {
  47.     .name = “platform”,
  48.     .dev_attrs = platform_dev_attrs,
  49.     .match = platform_match,
  50.     .uevent = platform_uevent,
  51.     .pm = PLATFORM_PM_OPS_PTR,
  52. };
  53. EXPORT_SYMBOL_GPL(platform_bus_type);
  54.  
  55. //这里要重点关注其match()成员函数,正是此成员表明了platform_device和platform_driver之间如何匹配。
  56. static int platform_match(struct device *dev, struct device_driver *drv)
  57. {
  58.     struct platform_device *pdev;

  59.     pdev = container_of(dev, struct platform_device, dev);
  60.     return (strncmp(pdev->name, drv->name, BUS_ID_SIZE) == 0);
  61. }
  62. //匹配platform_device和platform_driver主要看二者的name字段是否相同。
  63. //对platform_device的定义通常在BSP的板文件中实现,在板文件中,将platform_device归纳为一个数组,最终通过platform_add_devices()函数统一注册。
  64. //platform_add_devices()函数可以将平台设备添加到系统中,这个函数的 原型为:
  65. int platform_add_devices(struct platform_device **devs, int num);
  66. //该函数的第一个参数为平台设备数组的指针,第二个参数为平台设备的数量,它内部调用了platform_device_register()函 数用于注册单个的平台设备。

  67. 1. platform bus总线先被kenrel注册。
  68. 2. 系统初始化过程中调用platform_add_devices或者platform_device_register,将平台设备(platform devices)注册到平台总线中(platform bus)
  69. 3. 平台驱动(platform driver)与平台设备(platform device)的关联是在platform_driver_register或者driver_register中实现,一般这个函数在驱动的初始化过程调用。
  70. 通过这三步,就将平台总线,设备,驱动关联起来。

  71. 二.Platform初始化
  72. 系统启动时初始化时创建了platform_bus总线设备和platform_bus_type总线,platform总线是在内核初始化的时候就注册进了内核。
  73. 内核初始化函数kernel_init()中调用了do_basic_setup() ,该函数中调用driver_init(),该函数中调用platform_bus_init(),我们看看platform_bus_init()函数:
  74. int __init platform_bus_init(void)
  75. {
  76.        int error;
  77.        early_platform_cleanup(); //清除platform设备链表
  78.        //该函数把设备名为platform 的设备platform_bus注册到系统中,其他的platform的设备都会以它为parent。它在sysfs中目录下./sys/devices/platform。
  79.        //platform_bus总线也是设备,所以也要进行设备的注册
  80.        //struct device platform_bus = {
  81.        //.init_name = "platform",
  82.         //};
  83.        error = device_register(&platform_bus);//将平台bus作为一个设备注册,出现在sys文件系统的device目录
  84.        if (error)
  85.               return error;
  86.        //接着bus_register(&platform_bus_type)注册了platform_bus_type总线.
  87.        /*
  88.        struct bus_type platform_bus_type = {
  89.                     .name = “platform”,
  90.                     .dev_attrs = platform_dev_attrs,
  91.                     .match = platform_match,
  92.                     .uevent = platform_uevent,
  93.                     .pm = PLATFORM_PM_OPS_PTR,
  94.                 };
  95.        */
  96.        //默认platform_bus_type中没有定义probe函数。
  97.        error = bus_register(&platform_bus_type);//注册平台类型的bus,将出现sys文件系统在bus目录下,创建一个platform的目录,以及相关属性文件
  98.        if (error)
  99.               device_unregister(&platform_bus);
  100.        return error;
  101. }

  102. //总线类型match函数是在设备匹配驱动时调用,uevent函数在产生事件时调用。
  103. //platform_match函数在当属于platform的设备或者驱动注册到内核时就会调用,完成设备与驱动的匹配工作。
  104. static int platform_match(struct device *dev, struct device_driver *drv)
  105. {
  106.        struct platform_device *pdev = to_platform_device(dev);
  107.        struct platform_driver *pdrv = to_platform_driver(drv);
  108.        /* match against the id table first */
  109.        if (pdrv->id_table)
  110.               return platform_match_id(pdrv->id_table, pdev) != NULL;
  111.        /* fall-back to driver name match */
  112.        return (strcmp(pdev->name, drv->name) == 0);//比较设备和驱动的名称是否一样

  113. }

  114. static const struct platform_device_id *platform_match_id(struct platform_device_id *id,struct platform_device *pdev)
  115. {
  116.        while (id->name[0]) {
  117.               if (strcmp(pdev->name, id->name) == 0) {
  118.                      pdev->id_entry = id;
  119.                      return id;
  120.               }
  121.               id++;
  122.        }
  123.        return NULL;

  124. }

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

  127. //再看看platform_uevent()函数:platform_uevent 热插拔操作函数
  128. static int platform_uevent(struct device *dev, struct kobj_uevent_env *env)
  129. {
  130.        struct platform_device *pdev = to_platform_device(dev);
  131.        add_uevent_var(env, "MODALIAS=%s%s", PLATFORM_MODULE_PREFIX, (pdev->id_entry) ? pdev->id_entry->name : pdev->name);
  132.        return 0;
  133. }

  134. //添加了MODALIAS环境变量,我们回顾一下:platform_bus. parent->kobj->kset->uevent_ops为device_uevent_ops,bus_uevent_ops的定义如下:
  135. static struct kset_uevent_ops device_uevent_ops = {
  136.        .filter = dev_uevent_filter,
  137.        .name = dev_uevent_name,
  138.        .uevent = dev_uevent,
  139. };
  140. //当调用device_add()时会调用kobject_uevent(&dev->kobj, KOBJ_ADD)产生一个事件,这个函数中会调用相应的kset_uevent_ops的uevent函数,

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

  143. Platform设备的注册分两种方式:
  144. 1.对于platform设备的初注册,内核源码提供了platform_device_add()函数,输入参数platform_device可以是静态的全局设备,它是进行一系列的操作后调用device_add()将设备注册到相应的总线(platform总线)上,
  145. 内核代码中platform设备的其他注册函数都是基于这个函数,如platform_device_register()、platform_device_register_simple()、platform_device_register_data()等。

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

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

  149. 3.第一种平台设备注册方式
  150. //platform_device是静态的全局设备,即platform_device结构的成员已经初始化完成
  151. //直接将平台设备注册到platform总线上
  152. /*platform_device_register和device_register的区别:
  153. (1).主要是有没有resource的区别,前者的结构体包含后面,并且增加了struct resource结构体成员,后者没有。
  154.         platform_device_register在device_register的基础上增加了struct resource部分的注册。
  155.         由此。可以看出,platform_device---paltform_driver_register机制与device-driver的主要区别就在于resource。
  156.         前者适合于具有独立资源设备的描述,后者则不是。
  157. (2).其实linux的各种其他驱动机制的基础都是device_driver。只不过是增加了部分功能,适合于不同的应用场合.
  158. */
  159. int platform_device_register(struct platform_device *pdev)
  160. {
  161.     device_initialize(&pdev->dev);//初始化platform_device内嵌的device
  162.     return platform_device_add(pdev);//把它注册到platform_bus_type上
  163. }

  164. int platform_device_add(struct platform_device *pdev)
  165. {
  166.         int i, ret = 0;
  167.         if (!pdev)
  168.          return -EINVAL;
  169.         if (!pdev->dev.parent)
  170.             pdev->dev.parent = &platform_bus;//设置父节点,即platform_bus作为总线设备的父节点,其余的platform设备都是它的子设备
  171.             
  172.         //platform_bus是一个设备,platform_bus_type才是真正的总线    
  173.         pdev->dev.bus = &platform_bus_type;//设置platform总线,指定bus类型为platform_bus_type
  174.         
  175.         //设置pdev->dev内嵌的kobj的name字段,将platform下的名字传到内部device,最终会传到kobj
  176.         if (pdev->id != -1)
  177.          dev_set_name(&pdev->dev, "%s.%d", pdev->name, pdev->id);
  178.         else
  179.          dev_set_name(&pdev->dev, "%s", pdev->name);
  180.         
  181.         
  182.         //初始化资源并将资源分配给它,每个资源的它的parent不存在则根据flags域设置parent,flags为IORESOURCE_MEM,
  183.         //则所表示的资源为I/O映射内存,flags为IORESOURCE_IO,则所表示的资源为I/O端口。
  184.         for (i = 0; i < pdev->num_resources; i++) {
  185.          struct resource *p, *r = &pdev->resource[i];
  186.          if (r->name == NULL)//资源名称为NULL则把设备名称设置给它
  187.                  r->name = dev_name(&pdev->dev);
  188.         
  189.          p = r->parent;//取得资源的父节点,资源在内核中也是层次安排的
  190.          if (!p) {
  191.          if (resource_type(r) == IORESOURCE_MEM) //如果父节点为NULL,并且资源类型为IORESOURCE_MEM,则把父节点设置为iomem_resource
  192.                  p = &iomem_resource;
  193.          else if (resource_type(r) == IORESOURCE_IO)//否则如果类型为IORESOURCE_IO,则把父节点设置为ioport_resource
  194.               p = &ioport_resource;
  195.          }
  196.         
  197.          //从父节点申请资源,也就是出现在父节点目录层次下
  198.          if (p && insert_resource(p, r)) {
  199.          printk(KERN_ERR "%s: failed to claim resource %d\n",dev_name(&pdev->dev), i);ret = -EBUSY;
  200.          goto failed;
  201.          }
  202.         }
  203.         
  204.         pr_debug("Registering platform device '%s'. Parent at %s\n",dev_name(&pdev->dev), dev_name(pdev->dev.parent));
  205.         //device_creat() 创建一个设备并注册到内核驱动架构...
  206.         //device_add() 注册一个设备到内核,少了一个创建设备..
  207.         ret = device_add(&pdev->dev);//就在这里把设备注册到总线设备上,标准设备注册,即在sys文件系统中添加目录和各种属性文件
  208.         if (ret == 0)
  209.          return ret;
  210.         
  211.         failed:
  212.         while (--i >= 0) {
  213.          struct resource *r = &pdev->resource[i];
  214.          unsigned long type = resource_type(r);
  215.          if (type == IORESOURCE_MEM || type == IORESOURCE_IO)
  216.          release_resource(r);
  217.         }
  218.         return ret;

  219. }

  220. 4.第二种平台设备注册方式
  221. //先分配一个platform_device结构,对其进行资源等的初始化
  222. //之后再对其进行注册,再调用platform_device_register()函数
  223. struct platform_device * platform_device_alloc(const char *name, int id)
  224. {
  225.     struct platform_object *pa;
  226.     /*
  227.     struct platform_object {
  228.        struct platform_device pdev;
  229.        char name[1];
  230.     };
  231.     */
  232.     pa = kzalloc(sizeof(struct platform_object) + strlen(name), GFP_KERNEL);//该函数首先为platform设备分配内存空间
  233.     if (pa) {
  234.         strcpy(pa->name, name);
  235.         pa->pdev.name = pa->name;//初始化platform_device设备的名称
  236.         pa->pdev.id = id;//初始化platform_device设备的id
  237.         device_initialize(&pa->pdev.dev);//初始化platform_device内嵌的device
  238.         pa->pdev.dev.release = platform_device_release;
  239.     }
  240.     return pa ? &pa->pdev : NULL;
  241. }

  242. //一个更好的方法是,通过下面的函数platform_device_register_simple()动态创建一个设备,并把这个设备注册到系统中:
  243. struct platform_device *platform_device_register_simple(const char *name,int id,struct resource *res,unsigned int num)
  244. {
  245.        struct platform_device *pdev;
  246.        int retval;
  247.        pdev = platform_device_alloc(name, id);
  248.        if (!pdev) {
  249.               retval = -ENOMEM;
  250.               goto error;
  251.        }

  252.        if (num) {
  253.               retval = platform_device_add_resources(pdev, res, num);
  254.               if (retval)
  255.                      goto error;
  256.        }

  257.        retval = platform_device_add(pdev);
  258.        if (retval)
  259.               goto error;
  260.               
  261.        return pdev;
  262. error:
  263.        platform_device_put(pdev);
  264.        return ERR_PTR(retval);
  265. }

  266. //该函数就是调用了platform_device_alloc()和platform_device_add()函数来创建的注册platform device,函数也根据res参数分配资源,看看platform_device_add_resources()函数:
  267. int platform_device_add_resources(struct platform_device *pdev,struct resource *res, unsigned int num)
  268. {
  269.        struct resource *r;
  270.        r = kmalloc(sizeof(struct resource) * num, GFP_KERNEL);//为资源分配内存空间
  271.        if (r) {
  272.               memcpy(r, res, sizeof(struct resource) * num);
  273.               pdev->resource = r; //并拷贝参数res中的内容,链接到device并设置其num_resources
  274.               pdev-> num_resources = num;
  275.        }
  276.        return r ? 0 : -ENOMEM;
  277. }


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

  281. int platform_driver_register(struct platform_driver *drv)
  282. {
  283.        drv->driver.bus = &platform_bus_type;//它将要注册到的总线
  284.             /*设置成platform_bus_type这个很重要,因为driver和device是通过bus联系在一起的,
  285.             具体在本例中是通过 platform_bus_type中注册的回调例程和属性来是实现的,
  286.             driver与device的匹配就是通过 platform_bus_type注册的回调例程platform_match ()来完成的。
  287.             */
  288.        if (drv->probe)
  289.               drv-> driver.probe = platform_drv_probe;
  290.        if (drv->remove)
  291.               drv->driver.remove = platform_drv_remove;
  292.        if (drv->shutdown)
  293.               drv->driver.shutdown = platform_drv_shutdown;
  294.        return driver_register(&drv->driver);//注册驱动
  295. }

  296. //然后设定了platform_driver内嵌的driver的probe、remove、shutdown函数。
  297. static int platform_drv_probe(struct device *_dev)
  298. {
  299.        struct platform_driver *drv = to_platform_driver(_dev->driver);
  300.        struct platform_device *dev = to_platform_device(_dev);
  301.        return drv->probe(dev);//调用platform_driver的probe()函数,这个函数一般由用户自己实现
  302.                                                        //例如下边结构,回调的是serial8250_probe()函数
  303.            /*
  304.                 static struct platform_driver serial8250_isa_driver = {
  305.                     .probe        = serial8250_probe,
  306.                     .remove        = __devexit_p(serial8250_remove),
  307.                     .suspend    = serial8250_suspend,
  308.                     .resume        = serial8250_resume,
  309.                     .driver        = {
  310.                         .name    = "serial8250",
  311.                         .owner    = THIS_MODULE,
  312.                     },
  313.                 };
  314.                 */
  315. }

  316. static int platform_drv_remove(struct device *_dev)
  317. {
  318.        struct platform_driver *drv = to_platform_driver(_dev->driver);
  319.        struct platform_device *dev = to_platform_device(_dev);
  320.        return drv->remove(dev);

  321. }

  322. static void platform_drv_shutdown(struct device *_dev)
  323. {
  324.        struct platform_driver *drv = to_platform_driver(_dev->driver);
  325.        struct platform_device *dev = to_platform_device(_dev);
  326.        drv->shutdown(dev);

  327. }

  328. //总结:
  329. 1.从这三个函数的代码可以看到,又找到了相应的platform_driver和platform_device,然后调用platform_driver的probe、remove、shutdown函数。这是一种高明的做法:
  330. 在不针对某个驱动具体的probe、remove、shutdown指向的函数,而通过上三个过度函数来找到platform_driver,然后调用probe、remove、shutdown接口。
  331. 如果设备和驱动都注册了,就可以通过bus ->match、bus->probe或driver->probe进行设备驱动匹配了。

  332. 2.驱动注册的时候platform_driver_register()->driver_register()->bus_add_driver()->driver_attach()->bus_for_each_dev()
  333. 对每个挂在虚拟的platform bus的设备作__driver_attach()->driver_probe_device()->drv->bus->match()==platform_match()->比较strncmp(pdev->name, drv->name, BUS_ID_SIZE)
  334. 如果相符就调用platform_drv_probe()->driver->probe(),如果probe成功则绑定该设备到该驱动。

阅读(611) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~