平台总线设备模型

平台总线是内核实现的一条虚拟总线，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);