【转】linux Platform设备驱动

  1. http://blog.csdn.net/gotosola/article/details/7459899 platform设备驱动简介可以先看个简介)


  2. PlatForm设备驱动:  

  3. 一、platform总线、设备与驱动  

  4. 1.一个现实的Linux设备和驱动通常都需要挂接在一种总线上,对于本身依附于PCI、USB、I2 C、SPI等的设备而言,这自然不是问题,  

  5. 但是在嵌入式系统里面,SoC系统中集成的独立的外设控制器、挂接在SoC内存空间的外设等确不依附于此类总线。  

  6. 基于这一背景,Linux发明了一种虚拟的总线,称为platform总线,相应的设备称为platform_device,而驱动成为 platform_driver。  

  7. 2.注意,所谓的platform_device并不是与字符设备、块设备和网络设备并列的概念,而是Linux系统提供的一种附加手段,  

  8. 例如,在 S3C6410处理器中,把内部集成的I2C、RTC、SPI、LCD、看门狗等控制器都归纳为platform_device,而它们本身就是字符设备。  

  9. 3.基于Platform总线的驱动开发流程如下:  

  10. (1)定义初始化platform bus  

  11. (2)定义各种platform devices  

  12. (3)注册各种platform devices  

  13. (4)定义相关platform driver  

  14. (5)注册相关platform driver  

  15. (6)操作相关设备  

  16. 4.平台相关结构  

  17. //platform_device结构体  

  18. struct platform_device  

  19.  const char name;  

  20.  u32 id;//设备id,用于给插入给该总线并且具有相同name的设备编号,如果只有一个设备的话填-1。  

  21.  struct device dev;//结构体中内嵌的device结构体。  

  22.  u32 num_resources;  

  23.   struct resource resource;  

  24. };  

  25. //平台资源结构  

  26. struct resource  

  27.  resource_size_t start; //定义资源的起始地址  

  28.  resource_size_t end; //定义资源的结束地址  

  29.  const char *name; //定义资源的名称  

  30.  unsigned long flags; //定义资源的类型,比如MEM,IO,IRQ,DMA类型  

  31.  struct resource *parent, *sibling, *child;  

  32. };  

  33. //设备的驱动:platform_driver这个结构体中包含probe()、remove()、shutdown()、suspend()、 resume()函数,通常也需要由驱动实现。  

  34. struct platform_driver  

  35.  int (*probe)(struct platform_device *);  

  36.  int (*remove)(struct platform_device *);  

  37.  void (*shutdown)(struct platform_device *);  

  38.  int (*suspend)(struct platform_device *, pm_message_t state);  

  39.  int (*suspend_late)(struct platform_device *, pm_message_t state);  

  40.  int (*resume_early)(struct platform_device *);  

  41.  int (*resume)(struct platform_device *);  

  42.  struct pm_ext_ops *pm;  

  43.  struct device_driver driver;  

  44. };  

  45.    

  46. //系统中为platform总线定义了一个bus_type的实例platform_bus_type,  

  47. struct bus_type platform_bus_type  

  48.  .name “platform”,  

  49.  .dev_attrs platform_dev_attrs,  

  50.  .match platform_match,  

  51.  .uevent platform_uevent,  

  52.  .pm PLATFORM_PM_OPS_PTR,  

  53. };  

  54. EXPORT_SYMBOL_GPL(platform_bus_type);  

  55.    

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

  57. static int platform_match(struct device *dev, struct device_driver *drv)  

  58.  

  59.  struct platform_device *pdev;  

  60.  pdev container_of(dev, struct platform_device, dev);  

  61.  return (strncmp(pdev->name, drv->name, BUS_ID_SIZE) == 0);  

  62.  

  63. //匹配platform_device和platform_driver主要看二者的name字段是否相同。  

  64. //对platform_device的定义通常在BSP的板文件中实现,在板文件中,将platform_device归纳为一个数组,最终通过platform_add_devices()函数统一注册。  

  65. //platform_add_devices()函数可以将平台设备添加到系统中,这个函数的 原型为:  

  66. int platform_add_devices(struct platform_device **devs, int num);  

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

  68. 1. platform bus总线先被kenrel注册。  

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

  70. 3. 平台驱动(platform driver)与平台设备(platform device)的关联是在platform_driver_register或者driver_register中实现,一般这个函数在驱动的初始化过程调用。  

  71. 通过这三步,就将平台总线,设备,驱动关联起来。  

  72. 二.Platform初始化  

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

  74. 内核初始化函数kernel_init()中调用了do_basic_setup() ,该函数中调用driver_init(),该函数中调用platform_bus_init(),我们看看platform_bus_init()函数:                                                                                                                    

  75. int __init platform_bus_init(void)  

  76.  

  77.        int error;  

  78.        early_platform_cleanup(); //清除platform设备链表  

  79.        //该函数把设备名为platform 的设备platform_bus注册到系统中,其他的platform的设备都会以它为parent。它在sysfs中目录下.即 /sys/devices/platform。  

  80.        //platform_bus总线也是设备,所以也要进行设备的注册  

  81.        //struct device platform_bus  

  82.        //.init_name       "platform",  

  83.         //};  

  84.        error device_register(&platform_bus);//将平台bus作为一个设备注册,出现在device目录   

  85.        if (error)  

  86.               return error;  

  87.        //接着bus_register(&platform_bus_type)注册了platform_bus_type总线.  

  88.          

  89.        //默认platform_bus_type中没有定义probe函数。  

  90.        error  bus_register(&platform_bus_type);//注册平台类型的bus,将出现在bus目录下  

  91.        if (error)  

  92.               device_unregister(&platform_bus);  

  93.        return error;  

  94.  

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

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

  97. static int platform_match(struct device *dev, struct device_driver *drv)  

  98.  

  99.        struct platform_device *pdev to_platform_device(dev);  

  100.        struct platform_driver *pdrv to_platform_driver(drv);  

  101.          

  102.        if (pdrv->id_table)  

  103.               return platform_match_id(pdrv->id_table, pdev) != NULL;  

  104.          

  105.        return (strcmp(pdev->name, drv->name) == 0);//比较设备和驱动的名称是否一样  

  106.  

  107. static const struct platform_device_id *platform_match_id(struct platform_device_id *id,struct platform_device *pdev)  

  108.  

  109.        while (id->name[0])  

  110.               if (strcmp(pdev->name, id->name) == 0)  

  111.                      pdev->id_entry id;  

  112.                      return id;  

  113.                

  114.               id++;  

  115.         

  116.        return NULL;  

  117.  

  118. //不难看出,如果pdrv的id_table数组中包含了pdev->name,或者drv->name和pdev->name名字相同,都会认为是匹配成功。  

  119. //id_table数组是为了应对那些对应设备和驱动的drv->name和pdev->name名字不同的情况。  

  120. //再看看platform_uevent()函数:platform_uevent 热插拔操作函数  

  121. static int platform_uevent(struct device *dev, struct kobj_uevent_env *env)  

  122.  

  123.        struct platform_device   *pdev to_platform_device(dev);  

  124.        add_uevent_var(env, "MODALIAS=%s%s", PLATFORM_MODULE_PREFIX, (pdev->id_entry) pdev->id_entry->name pdev->name);  

  125.        return 0;  

  126.  

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

  128. static struct kset_uevent_ops device_uevent_ops  

  129.        .filter    dev_uevent_filter,  

  130.        .name          dev_uevent_name,  

  131.        .uevent dev_uevent,  

  132. };  

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

  134. 三.Platform设备的注册  

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

  136. Platform设备的注册分两种方式:  

  137. 1.对于platform设备的初注册,内核源码提供了platform_device_add()函数,输入参数platform_device可以是静态的全局设备,它是进行一系列的操作后调用device_add()将设备注册到相应的总线(platform总线)上,  

  138. 内核代码中platform设备的其他注册函数都是基于这个函数,如platform_device_register()、platform_device_register_simple()、platform_device_register_data()等。  

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

  140. 无论哪一种platform_device,最终都将通过platform_device_add这册到platform总线上。  

  141. 区别在于第二步:其实platform_device_add()包括device_add(),不过要先注册resources,然后将设备挂接到特定的platform总线。  

  142. 3.第一种平台设备注册方式  

  143. //platform_device是静态的全局设备,即platform_device结构的成员已经初始化完成  

  144. //直接将平台设备注册到platform总线上  

  145.   

  146. int platform_device_register(struct platform_device *pdev)  

  147.  

  148.  device_initialize(&pdev->dev);//初始化platform_device内嵌的device  

  149.  return platform_device_add(pdev);//把它注册到platform_bus_type上  

  150.  

  151. int platform_device_add(struct platform_device *pdev)  

  152.  

  153.   int i, ret 0;  

  154.   if (!pdev)  

  155.         return -EINVAL;  

  156.   if (!pdev->dev.parent)  

  157.    pdev->dev.parent &platform_bus;//设置父节点,即platform_bus作为总线设备的父节点,其余的platform设备都是它的子设备  

  158.      

  159.   //platform_bus是一个设备,platform_bus_type才是真正的总线   

  160.   pdev->dev.bus &platform_bus_type;//设置platform总线,//指定bus类型为platform_bus_type   

  161.     

  162.   //设置pdev->dev内嵌的kobj的name字段,将platform下的名字传到内部device,最终会//传到kobj    

  163.   if (pdev->id != -1)  

  164.         dev_set_name(&pdev->dev, "%s.%d", pdev->name,  pdev->id);  

  165.   else  

  166.         dev_set_name(&pdev->dev, "%s", pdev->name);  

  167.     

  168.     

  169.   //初始化资源并将资源分配给它,每个资源的它的parent不存在则根据flags域设置parent,flags为IORESOURCE_MEM,  

  170.   //则所表示的资源为I/O映射内存,flags为IORESOURCE_IO,则所表示的资源为I/O端口。  

  171.   for (i 0; pdev->num_resources; i++)  

  172.       struct resource *p, *r &pdev->resource[i];  

  173.       if (r->name == NULL)//资源名称为NULL则把设备名称设置给它  

  174.         r->name dev_name(&pdev->dev);  

  175.                

  176.       r->parent;//取得资源的父节点,资源在内核中也是层次安排的  

  177.       if (!p)  

  178.          if (resource_type(r) == IORESOURCE_MEM) //如果父节点为NULL,并且资源类型为IORESOURCE_MEM,则把父节点设置为iomem_resource   

  179.            &iomem_resource;  

  180.          else if (resource_type(r) == IORESOURCE_IO)//否则如果类型为IORESOURCE_IO,则把父节点设置为ioport_resource  

  181.             &ioport_resource;  

  182.        

  183.         

  184.        //将资源插入父节点,也就是出现在父节点目录层次下   

  185.       if (p && insert_resource(p, r))  

  186.          printk(KERN_ERR "%s: failed to claim resource %d\n",dev_name(&pdev->dev), i);ret -EBUSY;  

  187.          goto failed;  

  188.        

  189.    

  190.     

  191.   pr_debug("Registering platform device '%s'. Parent at %s\n",dev_name(&pdev->dev), dev_name(pdev->dev.parent));  

  192.   ret device_add(&pdev->dev);//就在这里把设备注册到总线设备上,标准设备注册  

  193.   if (ret == 0)  

  194.         return ret;  

  195.     

  196.   failed:  

  197.   while (--i >= 0)  

  198.         struct resource *r &pdev->resource[i];  

  199.         unsigned long type resource_type(r);  

  200.         if (type == IORESOURCE_MEM || type == IORESOURCE_IO)  

  201.                release_resource(r);  

  202.    

  203.   return ret;  

  204.  

  205. 4.第二种平台设备注册方式  

  206. //先分配一个platform_device结构,对其进行资源等的初始化  

  207. //之后再对其进行注册,再调用platform_device_register()函数  

  208. struct platform_device platform_device_alloc(const char *name, int id)  

  209.  

  210.  struct platform_object *pa;  

  211.    

  212.  pa kzalloc(sizeof(struct platform_object) strlen(name), GFP_KERNEL);//该函数首先为platform设备分配内存空间  

  213.  if (pa)  

  214.   strcpy(pa->name, name);  

  215.   pa->pdev.name pa->name;//初始化platform_device设备的名称  

  216.   pa->pdev.id id;//初始化platform_device设备的id  

  217.   device_initialize(&pa->pdev.dev);//初始化platform_device内嵌的device  

  218.   pa->pdev.dev.release platform_device_release;  

  219.   

  220.  return pa &pa->pdev NULL;  

  221.  

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

  223. struct platform_device *platform_device_register_simple(const char *name,int id,struct resource *res,unsigned int num)  

  224.  

  225.        struct platform_device *pdev;  

  226.        int retval;  

  227.        pdev platform_device_alloc(name, id);  

  228.        if (!pdev)  

  229.               retval -ENOMEM;  

  230.               goto error;  

  231.         

  232.        if (num)  

  233.               retval platform_device_add_resources(pdev, res, num);  

  234.               if (retval)  

  235.                      goto error;  

  236.         

  237.        retval platform_device_add(pdev);  

  238.        if (retval)  

  239.               goto error;  

  240.                 

  241.        return pdev;  

  242. error:  

  243.        platform_device_put(pdev);  

  244.        return ERR_PTR(retval);  

  245.  

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

  247. int platform_device_add_resources(struct platform_device *pdev,struct resource *res, unsigned int num)  

  248.  

  249.        struct resource *r;  

  250.        kmalloc(sizeof(struct resource) num, GFP_KERNEL);//为资源分配内存空间  

  251.        if (r)  

  252.               memcpy(r, res, sizeof(struct resource) num);  

  253.               pdev->resource r;        //并拷贝参数res中的内容,链接到device并设置其num_resources  

  254.               pdev-> num_resources num;  

  255.         

  256.        return -ENOMEM;  

  257.  

  258.   

  259. 四.Platform设备驱动的注册  

  260. 我们在设备驱动模型的分析中已经知道驱动在注册要调用driver_register(),  

  261. platform driver的注册函数platform_driver_register()同样也是进行其它的一些初始化后调用driver_register()将驱动注册到platform_bus_type总线上.  

  262. int platform_driver_register(struct platform_driver *drv)  

  263.  

  264.        drv->driver.bus &platform_bus_type;//它将要注册到的总线  

  265.      

  266.        if (drv->probe)  

  267.               drv-> driver.probe platform_drv_probe;  

  268.        if (drv->remove)  

  269.               drv->driver.remove platform_drv_remove;  

  270.        if (drv->shutdown)  

  271.               drv->driver.shutdown platform_drv_shutdown;  

  272.        return driver_register(&drv->driver);//注册驱动  

  273.  

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

  275. static int platform_drv_probe(struct device *_dev)  

  276.  

  277.        struct platform_driver *drv to_platform_driver(_dev->driver);  

  278.        struct platform_device *dev to_platform_device(_dev);  

  279.        return drv->probe(dev);//调用platform_driver的probe()函数,这个函数一般由用户自己实现  

  280.                    //例如下边结构,回调的是serial8250_probe()函数  

  281.           

  282.  

  283. static int platform_drv_remove(struct device *_dev)  

  284.  

  285.        struct platform_driver *drv to_platform_driver(_dev->driver);  

  286.        struct platform_device *dev to_platform_device(_dev);  

  287.        return drv->remove(dev);  

  288.  

  289. static void platform_drv_shutdown(struct device *_dev)  

  290.  

  291.        struct platform_driver *drv to_platform_driver(_dev->driver);  

  292.        struct platform_device *dev to_platform_device(_dev);  

  293.        drv->shutdown(dev);  

  294.  

  295. //总结:  

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

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

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

  299. 2.驱动注册的时候platform_driver_register()->driver_register()->bus_add_driver()->driver_attach()->bus_for_each_dev(),  

  300. 对每个挂在虚拟的platform bus的设备作__driver_attach()->driver_probe_device()->drv->bus->match()==platform_match()->比较strncmp(pdev->name, drv->name, BUS_ID_SIZE),  

  301. 如果相符就调用platform_drv_probe()->driver->probe(),如果probe成功则绑定该设备到该驱动。 

链接:http://blog.csdn.net/zzhere2007/article/details/9101727

http://blog.chinaunix.net/uid/27041925/cid-174214-list-1.html

http://blog.csdn.net/xiaochongtou123/article/details/7752328

<script type="text/javascript" id="wumiiRelatedItems"> </script>
 
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值