Linux平台总线驱动设备模型

uperrua · 发表于 2020-4-21 10:36

EDA365欢迎您登录！

您需要登录才可以下载或查看，没有帐号？注册

x

platform总线是一种虚拟的总线，相应的设备则为platform_device，而驱动则为platform_driver。Linux 2.6的设备驱动模型中，把I2C、RTC、LCD等都归纳为platform_device。

总线将设备和驱动绑定，在系统每注册一个设备的时候，会寻找与之匹配的驱动；相反的，在系统每注册一个驱动的时候，会寻找与之匹配的设备，而匹配由总线完成。

Linux2.6系统中定义了一个bus_type的实例platform_bus_type

struct bus_type platform_bus_type = {
      .name             = "platform",
      .dev_attrs       = platform_dev_attrs,
      .match             = platform_match,             //设备和驱动使用match函数来判断是否匹配
      .uevent             = platform_uevent,
      .pm             = PLATFORM_PM_OPS_PTR,
};
/* platform_match函数用于匹配总线中的驱动和设备 */
static int platform_match(struct device *dev, struct device_driver *drv)
{
      struct platform_device *pdev = to_platform_device(dev);
      struct platform_driver *pdrv = to_platform_driver(drv);

      /* match against the id table first */
      if (pdrv->id_table)
            return platform_match_id(pdrv->id_table, pdev) != NULL;

      /* fall-back to driver name match */
      return (strcmp(pdev->name, drv->name) == 0);
}
platform_match函数首先判断是否由id_table，如果有则使用id_table来进行匹配，否则，判断platform_device和platform_driver成员里的name，如果二者的name字段相同则匹配，如果匹配则调用platform_driver的probe函数。
platform_device结构体的定义

struct platform_device {
      const char       * name;                      /* 名字 */
      int             id;
      struct device       dev;
      u32             num_resources;             /* 资源总数 */
      struct resource       * resource;       /* 资源 */

      struct platform_device_id       *id_entry;
};
其中有个重要的成员是resource，是设备的资源信息，如IO地址，中断号等。

struct resource {
      resource_size_t start;             //资源的起始值
      resource_size_t end;             //资源的结束值
      const char *name;
      unsigned long flags;             //资源的类型，如IORESOURCE_IO,IORESOURCE_MEM,IORESOURCE_IRQ,IORESOURCE_DMA
      struct resource *parent, *sibling, *child;
};
有的设备可能有多个资源，通常使用platform_get_resource函数来获取资源

/**
* platform_get_resource - get a resource for a device
* @dev: platform device
* @type: resource type
* @num: resource index
*/
struct resource *platform_get_resource(struct platform_device *dev,
                                    unsigned int type, unsigned int num)
{
      int i;

      for (i = 0; i < dev->num_resources; i++) {
            struct resource *r = &dev->resource;

            if (type == resource_type(r) && num-- == 0)
                     return r;
      }
      return NULL;
}
平台设备的注册，使用platform_device_register函数

int platform_device_register(struct platform_device *pdev)
{
      device_initialize(&pdev->dev);
      return platform_device_add(pdev);
}
platform_device_register函数先通过device_initialize函数初始化platform_device的device成员，然后调用platform_device_add向内核添加一个平台设备。

int platform_device_add(struct platform_device *pdev)
{
      int i, ret = 0;

      if (!pdev)       /* 如果pdev为空则返回EINVAL */
            return -EINVAL;

      /* 如果pdev->dev.parent为空则将pdev->dev.parent设置为platform_bus */
      if (!pdev->dev.parent)
            pdev->dev.parent = &platform_bus;

      pdev->dev.bus = &platform_bus_type;       /* 设置总线类型 */

      if (pdev->id != -1)             /* 如果id = -1则表示自动分配name */
            dev_set_name(&pdev->dev, "%s.%d", pdev->name,  pdev->id);
      else
            dev_set_name(&pdev->dev, pdev->name);

      for (i = 0; i < pdev->num_resources; i++) {
            struct resource *p, *r = &pdev->resource;       /* 获取资源 */

            if (r->name == NULL)
                     r->name = dev_name(&pdev->dev);

            p = r->parent;
            if (!p) {
                     if (resource_type(r) == IORESOURCE_MEM) /* 设置资源类型 */
                              p = &iomem_resource;
                     else if (resource_type(r) == IORESOURCE_IO)
                              p = &ioport_resource;
            }

            if (p && insert_resource(p, r)) {
                     printk(KERN_ERR
                           "%s: failed to claim resource %d\n",
                           dev_name(&pdev->dev), i);
                     ret = -EBUSY;
                     goto failed;
            }
      }

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

      /* 向内核添加一个device */
      ret = device_add(&pdev->dev);
      if (ret == 0)
            return ret;

failed:
      while (--i >= 0) {
            struct resource *r = &pdev->resource;
            unsigned long type = resource_type(r);

            if (type == IORESOURCE_MEM || type == IORESOURCE_IO)
                     release_resource(r);
      }

      return ret;
}
platform_device_add最终调用device_add来完成平台设备的注册。

相反地，如果要注销平台设备则使用platform_device_unregister函数

void platform_device_unregister(struct platform_device *pdev)
{
      platform_device_del(pdev);
      platform_device_put(pdev);
}
platform_device_unregister函数调用platform_device_del函数来注销平台设备

void platform_device_del(struct platform_device *pdev)
{
      int i;

      if (pdev) {
            device_del(&pdev->dev);

            for (i = 0; i < pdev->num_resources; i++) {
                     struct resource *r = &pdev->resource;
                     unsigned long type = resource_type(r);

                     if (type == IORESOURCE_MEM || type == IORESOURCE_IO)
                              release_resource(r);
            }
      }
}
platform_device_del函数调用device_del函数来删除平台设备，相应地，要释放资源应调用release_resource函数，前提是资源的类型必须为IORESOURCE_MEM或者IORESOURCE_IO

platform_driver的定义：

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;
};

device_driver的定义：
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 */

      const struct of_device_id       *of_match_table;
      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;
};

platform_driver结构体有device_driver成员，该成员的各自字段如上所示，device_driver也有probe、remove、shutdown等函数，在平台驱动注册的时候被初始化。
前面说过，当系统中存在有平台设备和平台驱动通过总线的match函数匹配后则会调用platform_driver的probe函数，参数为platform_device，有时候也通过id_table来判断是否匹配。

struct platform_device_id {
      char name[PLATFORM_NAME_SIZE];
      kernel_ulong_t driver_data
                     __attribute__((aligned(sizeof(kernel_ulong_t))));
};
平台驱动的注册使用platform_driver_register函数

int platform_driver_register(struct platform_driver *drv)
{
      drv->driver.bus = &platform_bus_type;
      if (drv->probe)
            drv->driver.probe = platform_drv_probe;
      if (drv->remove)
            drv->driver.remove = platform_drv_remove;
      if (drv->shutdown)
            drv->driver.shutdown = platform_drv_shutdown;
      if (drv->suspend)
            drv->driver.suspend = platform_drv_suspend;
      if (drv->resume)
            drv->driver.resume = platform_drv_resume;
      return driver_register(&drv->driver);
}
先初始化platform_driver里的driver，该driver的类型为device_driver，设置driver的bus为platform_bus_type；设置driver的probe为platform_drv_probe；设置driver的remove为platform_drv_remove；设置driver的shutdown为platform_drv_shutdown；设置driver的suspend为platform_drv_suspend；设置driver的resume为platform_drv_resume，最后调用driver_register函数来注册平台驱动。
相反地，要注销平台驱动的话，使用platform_driver_unregister函数

void platform_driver_unregister(struct platform_driver *drv)
{
      driver_unregister(&drv->driver);
}

附bus_drv_dev模型的框架图

ExxNEN · 发表于 2020-4-21 14:20

Linux平台总线驱动设备模型

帐号		自动登录	找回密码
密码			注册

Linux平台总线驱动设备模型

EDA365欢迎您登录！

浏览过的版块

推荐内容 /1