平台总线设备模型

平台总线是内核实现的一条虚拟总线，Linux设备模型包含三个重要的元素，总线、设备和驱动，那看看平台总线又是怎样去实现的。

首先看平台总线的定义：

 946 struct bus_type platform_bus_type = {  947         .name           = "platform",  948         .dev_attrs      = platform_dev_attrs,  949         .match          = platform_match,  950         .uevent         = platform_uevent,  951         .pm             = &platform_dev_pm_ops,  952 }; 

我们知道总线匹配设备和驱动是通过它的match函数，那具体看看这个函数是怎样实现的。

 606 static int platform_match(struct device *dev, struct device_driver *drv)  607 {  608         struct platform_device *pdev = to_platform_device(dev);  609         struct platform_driver *pdrv = to_platform_driver(drv);  610  611         /* match against the id table first */  612         if (pdrv->id_table)  613                 return platform_match_id(pdrv->id_table, pdev) != NULL;  614  615         /* fall-back to driver name match */  616         return (strcmp(pdev->name, drv->name) == 0);  617 } 

我们看，如果平台驱动有一个id_table，那就通过函数platform_match_id去匹配，如果没有就比较平台设备的name字段和平台驱动的name字段是否相同，这也就是平台总线的匹配规则。再来看平台总线的注册。

 955 int __init platform_bus_init(void)  956 {  957         int error;  958  959         early_platform_cleanup();  960  961         error = device_register(&platform_bus);  962         if (error)  963                 return error;  964         error =  bus_register(&platform_bus_type);  965         if (error)  966                 device_unregister(&platform_bus);  967         return error;  968 } 

我们看平台总线注册就是采用的bus_register函数，再看在注册平台总线之前，还调用了

device_register去注册了一个设备，因为总线它也是一个设备，也要被注册进内核。那就具体来看这个设备是怎么定义的。

  28 struct device platform_bus = {   29         .init_name      = "platform",   30 };   31 EXPORT_SYMBOL_GPL(platform_bus); 

我们看就给了一个名字。看完了总线，又来看看平台设备又是怎样定义怎样去注册。

 17 struct platform_device {  18         const char      * name;  19         int             id;  20         struct device   dev;  21         u32             num_resources;  22         struct resource * resource;  23  24         struct platform_device_id       *id_entry;  25  26         /* arch specific additions */  27         struct pdev_archdata    archdata;  28 }; 

其中有个重要的元素resource，该元素存入的最重要的设备资源信息，比如I/O基地址，中断号等等。structresource结构定义在include/linux/ioport.h中

 18 struct resource {  19         resource_size_t start;  20         resource_size_t end;  21         const char *name;  22         unsigned long flags;  23         struct resource *parent, *sibling, *child;  24 }; 

有可能设备的资源不只一个，定义资源时定义成一个数组的形式，那就使用函数去获取，

platform_get_resource就是用来获取设备的资源信息，去看看这个函数

  33 /**   34  * platform_get_resource - get a resource for a device   35  * @dev: platform device   36  * @type: resource type   37  * @num: resource index   38  */   39 struct resource *platform_get_resource(struct platform_device *dev,   40                                        unsigned int type, unsigned int num)   41 {   42         int i;   43   44         for (i = 0; i < dev->num_resources; i++) {   45                 struct resource *r = &dev->resource[i];   46   47                 if (type == resource_type(r) && num-- == 0)   48                         return r;   49         }   50         return NULL;   51 }   52 EXPORT_SYMBOL_GPL(platform_get_resource); 

这个函数的第一个参数为要获取资源的平台设备，第二个参数为资源类型，比如IORESOURCE_MEM，第三个参数为资源在数组中的一个号。如果是获取中断号，还可以使用函数platform_get_irq

  54 /**   55  * platform_get_irq - get an IRQ for a device   56  * @dev: platform device   57  * @num: IRQ number index   58  */   59 int platform_get_irq(struct platform_device *dev, unsigned int num)   60 {   61         struct resource *r = platform_get_resource(dev, IORESOURCE_IRQ, num);   62   63         return r ? r->start : -ENXIO;   64 }   65 EXPORT_SYMBOL_GPL(platform_get_irq); 

我们看这个函数也是调用platform_get_resource去获取资源，只是它获取资源的类型为IORESOURCE_IRQ，最后返回中断号。

再来看平台设备的注册，平台设备注册采用platform_device_register函数

  54 /**   55  * platform_get_irq - get an IRQ for a device   56  * @dev: platform device   57  * @num: IRQ number index   58  */   59 int platform_get_irq(struct platform_device *dev, unsigned int num)   60 {   61         struct resource *r = platform_get_resource(dev, IORESOURCE_IRQ, num);   62   63         return r ? r->start : -ENXIO;   64 }   65 EXPORT_SYMBOL_GPL(platform_get_irq); 

device_initialize就是device_register那的函数，那就看platform_device_add

 227 /**  228  * platform_device_add - add a platform device to device hierarchy  229  * @pdev: platform device we're adding  230  *  231  * This is part 2 of platform_device_register(), though may be called  232  * separately _iff_ pdev was allocated by platform_device_alloc().  233  */  234 int platform_device_add(struct platform_device *pdev)  235 {  236         int i, ret = 0;  237  238         if (!pdev)  239                 return -EINVAL;  240  241         if (!pdev->dev.parent)  242                 pdev->dev.parent = &platform_bus;  243  244         pdev->dev.bus = &platform_bus_type;  245  246         if (pdev->id != -1)  247                 dev_set_name(&pdev->dev, "%s.%d", pdev->name,  pdev->id);  248         else  249                 dev_set_name(&pdev->dev, "%s", pdev->name);  250  251         for (i = 0; i < pdev->num_resources; i++) {  252                 struct resource *p, *r = &pdev->resource[i];  253  254                 if (r->name == NULL)  255                         r->name = dev_name(&pdev->dev);  256  257                 p = r->parent;  258                 if (!p) {  259                         if (resource_type(r) == IORESOURCE_MEM)  260                                 p = &iomem_resource;  261                         else if (resource_type(r) == IORESOURCE_IO)  262                                 p = &ioport_resource;  263                 }  264  265                 if (p && insert_resource(p, r)) {  266                         printk(KERN_ERR  267                                "%s: failed to claim resource %d\n",  268                                dev_name(&pdev->dev), i);  269                         ret = -EBUSY;  270                         goto failed;  271                 }  272         }  273  274         pr_debug("Registering platform device '%s'. Parent at %s\n",  275                  dev_name(&pdev->dev), dev_name(pdev->dev.parent));  276  277         ret = device_add(&pdev->dev);  278         if (ret == 0)  279                 return ret;  280  281  failed:  282         while (--i >= 0) {  283                 struct resource *r = &pdev->resource[i];  284                 unsigned long type = resource_type(r);  285  286                 if (type == IORESOURCE_MEM || type == IORESOURCE_IO)  287                         release_resource(r);  288         }  289  290         return ret;  291 }  292 EXPORT_SYMBOL_GPL(platform_device_add); 

最终调用device_register那的device_add完成平台设备的注册。

我们也可以使用platform_add_devices去注册一组平台设备

 103 /**  104  * platform_add_devices - add a numbers of platform devices  105  * @devs: array of platform devices to add  106  * @num: number of platform devices in array  107  */  108 int platform_add_devices(struct platform_device **devs, int num)  109 {  110         int i, ret = 0;  111  112         for (i = 0; i < num; i++) {  113                 ret = platform_device_register(devs[i]);  114                 if (ret) {  115                         while (--i >= 0)  116                                 platform_device_unregister(devs[i]);  117                         break;  118                 }  119         }  120  121         return ret;  122 }  123 EXPORT_SYMBOL_GPL(platform_add_devices); 

看完了注册来看注销函数，注销函数就是platform_device_unregister。

 331 /**  332  * platform_device_unregister - unregister a platform-level device  333  * @pdev: platform device we're unregistering  334  *  335  * Unregistration is done in 2 steps. First we release all resources  336  * and remove it from the subsystem, then we drop reference count by  337  * calling platform_device_put().  338  */  339 void platform_device_unregister(struct platform_device *pdev)  340 {  341         platform_device_del(pdev);  342         platform_device_put(pdev);  343 }  344 EXPORT_SYMBOL_GPL(platform_device_unregister);  294 /**  295  * platform_device_del - remove a platform-level device  296  * @pdev: platform device we're removing  297  *  298  * Note that this function will also release all memory- and port-based  299  * resources owned by the device (@dev->resource).  This function must  300  * _only_ be externally called in error cases.  All other usage is a bug.  301  */  302 void platform_device_del(struct platform_device *pdev)  303 {  304         int i;  305  306         if (pdev) {  307                 device_del(&pdev->dev);  308  309                 for (i = 0; i < pdev->num_resources; i++) {  310                         struct resource *r = &pdev->resource[i];  311                         unsigned long type = resource_type(r);  312  313                         if (type == IORESOURCE_MEM || type == IORESOURCE_IO)  314                                 release_resource(r);  315                 }  316         }  317 }  318 EXPORT_SYMBOL_GPL(platform_device_del); 

device_del就是device_unregister那的函数

再来看驱动，平台设备驱动结构定义

 58 struct platform_driver {  59         int (*probe)(struct platform_device *);  60         int (*remove)(struct platform_device *);  61         void (*shutdown)(struct platform_device *);  62         int (*suspend)(struct platform_device *, pm_message_t state);  63         int (*resume)(struct platform_device *);  64         struct device_driver driver;  65         struct platform_device_id *id_table;  66 }; 

驱动注册

 474 /**  475  * platform_driver_register  476  * @drv: platform driver structure  477  */  478 int platform_driver_register(struct platform_driver *drv)  479 {  480         drv->driver.bus = &platform_bus_type;  481         if (drv->probe)  482                 drv->driver.probe = platform_drv_probe;  483         if (drv->remove)  484                 drv->driver.remove = platform_drv_remove;  485         if (drv->shutdown)  486                 drv->driver.shutdown = platform_drv_shutdown;  487  488         return driver_register(&drv->driver);  489 }  490 EXPORT_SYMBOL_GPL(platform_driver_register); 

平台驱动结构里面有个成员driver，它是device_driver结构类型，它的probe函数指针赋值了这里的platform_drv_probe，也就是平台总线匹配设备和驱动成功后，将调用这里的

platform_drv_probe函数，那就在去看看这个函数。

 445 static int platform_drv_probe(struct device *_dev)  446 {  447         struct platform_driver *drv = to_platform_driver(_dev->driver);  448         struct platform_device *dev = to_platform_device(_dev);  449  450         return drv->probe(dev);  451 } 

还有一点的是它的remove函数为这里的platform_drv_remove，不管是设备注销还是驱动注销都是先调用这个函数，然后才调用平台驱动的remove函数。

 458 static int platform_drv_remove(struct device *_dev)  459 {  460         struct platform_driver *drv = to_platform_driver(_dev->driver);  461         struct platform_device *dev = to_platform_device(_dev);  462  463         return drv->remove(dev);  464 } 

也就是最后调用platform_driver的probe函数，它的参数dev是platform_device结构类型。注意这里有两个probe，一个是platform_driver的probe，它是要求我们在编写平台设备驱动时自己去定义，另一个是device_driver的probe，它供总线匹配设备和驱动成功后调用，probe为这里的platform_drv_probe，这个函数的功能就是调用platform_driver的probe。

平台设备驱动注册最后调用的就是driver_register，只不过这里的总线是平台总线。

驱动注销

 492 /**  493  * platform_driver_unregister  494  * @drv: platform driver structure  495  */  496 void platform_driver_unregister(struct platform_driver *drv)  497 {  498         driver_unregister(&drv->driver);  499 }  500 EXPORT_SYMBOL_GPL(platform_driver_unregister);