linux platform设备与驱动

 struct platform_driver {

     int (*probe)(struct platform_device *);

     int (*remove)(struct platform_device *);

     void (*shutdown)(struct platform_device *);

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

     int (*resume)(struct platform_device *);

     struct device_driver driver;

     const struct platform_device_id *id_table;

     bool prevent_deferred_probe;

 };

  struct device_driver {

      const char      *name;

      struct bus_type     *bus;

      struct module       *owner;

      const char      *mod_name;  /* used for built-in modules */

      bool suppress_bind_attrs;   /* disables bind/unbind via sysfs */

      enum probe_type probe_type;

      const struct of_device_id   *of_match_table;　　　　//device tree通过这个去匹配

      const struct acpi_device_id *acpi_match_table;

      int (*probe) (struct device *dev);

      int (*remove) (struct device *dev);

      void (*shutdown) (struct device *dev);

      int (*suspend) (struct device *dev, pm_message_t state);

      int (*resume) (struct device *dev);

      const struct attribute_group **groups;

      const struct dev_pm_ops *pm;

      struct driver_private *p;

  };

  struct platform_device {

      const char  *name;

      int     id;

      bool        id_auto;

      struct device   dev;

      u32     num_resources;

      struct resource *resource;

      const struct platform_device_id *id_entry;

      char *driver_override; /* Driver name to force a match */

      /* MFD cell pointer */

      struct mfd_cell *mfd_cell;

      /* arch specific additions */

      struct pdev_archdata    archdata;

  };

以上是头文件的结构体定义

 static const struct of_device_id dw_spi_mmio_of_match[] = {

     { .compatible = "snps,dw-apb-ssi", },

     { /* end of table */}

 };

 MODULE_DEVICE_TABLE(of, dw_spi_mmio_of_match);

 static struct platform_driver dw_spi_mmio_driver = {

     .probe      = dw_spi_mmio_probe,

     .remove     = dw_spi_mmio_remove,

     .driver     = {

         .name   = DRIVER_NAME,

         .of_match_table = dw_spi_mmio_of_match,

     },

 };

 module_platform_driver(dw_spi_mmio_driver);

 MODULE_AUTHOR("Jean-Hugues Deschenes <jean-hugues.deschenes@octasic.com>");

 MODULE_DESCRIPTION("Memory-mapped I/O interface driver for DW SPI Core");

 MODULE_LICENSE("GPL v2");

以前的写法　：　

    struct platform_device s3c_device_usb = {

             .name    = "s3c2410-ohci",  //s3c6410-usb

             .id    = -,

             .num_resources   = ARRAY_SIZE(s3c_usb_resource),

             .resource   = s3c_usb_resource,

             .dev              = {

                     .dma_mask = &s3c_device_usb_dmamask,

                     .coherent_dma_mask = 0xffffffffUL

                 }

    };  

有了platform_device就可以调用函数platform_add_devices向系统中添加该设备了。系统中的设备资源都可以采用这种方式列举在一起，然后成一个指针数组，如：

static struct platform_device *smdk6410_devices[] __initdata = {

......

 &s3c_device_usbgadget,

 &s3c_device_usb,  //jeff add.

......

}

   static struct platform_driver ohci_hcd_s3c2410_driver = {

         .probe  = ohci_hcd_s3c2410_drv_probe,

         .remove  = ohci_hcd_s3c2410_drv_remove,

         .shutdown = usb_hcd_platform_shutdown,

         /*.suspend = ohci_hcd_s3c2410_drv_suspend, */

         /*.resume = ohci_hcd_s3c2410_drv_resume, */

         .driver  = {

              .owner = THIS_MODULE,

              .name = "s3c2410-ohci",

            },

    };  

（）在内核初始化时kernel_init()->do_basic_setup()->driver_init()->platform_bus_init()初始化platform_bus(虚拟总线)；

（2）设备注册的时候platform_device_register()->platform_device_add()->(pdev->dev.bus = &platform_bus_type)把设备挂在虚拟的platform bus下；

（）驱动注册的时候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)，如果相符就调用really_probe（实际就是执行的相应设备的platform_driver->probe(platform_device)，
 注意platform_drv_probe的_dev参数是由bus_for_each_dev的next_device获得）开始真正的探测加载，如果probe成功则绑定该设备到该驱动。

      当进入probe函数后，需要获取设备的资源信息，根据参数type所指定类型，例如IORESOURCE_MEM，来分别获取指定的资源。

struct resource * platform_get_resource(struct platform_device *dev, unsigned int type, unsigned int num);当然，也可以固定资源类型，
如获取资源中的中断号：struct int platform_get_irq(struct platform_device *dev, unsigned int num);

      probe函数一般完成硬件设备使能，struct resource的获取以及虚拟地址的动态映射和具体类型设备的注册（因为平台设备只是一种虚拟的设备类型);
remove函数完成硬件设备的关闭，struct resource以及虚拟地址的动态映射的释放和具体类型设备的注销。只要和内核本身运行依赖性不大的外围设备
 ( 换句话说只要不在内核运行所需的一个最小系统之内的设备 ), 相对独立的拥有各自独自的资源 (addresses and IRQs) ，都可以用platform_driver 实现。
如：lcd,usb,uart 等，都可以用platfrom_driver 写，而timer,irq等最小系统之内的设备则最好不用platfrom_driver 机制，实际上内核实现也是这样的。

http://blog.csdn.net/zhandoushi1982/article/details/5130207