linux设备模型之platform总线

最新推荐文章于 2023-05-05 15:21:57 发布

beyondioi

最新推荐文章于 2023-05-05 15:21:57 发布

阅读量1k

点赞数

分类专栏：嵌入式linux 文章标签： linux struct resources object table null

嵌入式linux 专栏收录该内容

100 篇文章 7 订阅

订阅专栏

从Linux 2.6起引入了一套新的驱动管理和注册机制:Platform_device和Platform_driver。

Linux中大部分的设备驱动，都可以使用这套机制, 设备用Platform_device表示，驱动用Platform_driver进行注册。

Linux platform driver机制和传统的device driver 机制(通过driver_register函数进行注册)相比，一个十分明显的优势在于platform机制将设备本身的资源注册进内核，由内核统一管理，在驱动程序中使用这些资源时通过platform device提供的标准接口进行申请并使用。这样提高了驱动和资源管理的独立性，并且拥有较好的可移植性和安全性(这些标准接口是安全的)。

通过platform机制开发底层设备驱动流程图：

定义platform_device---->注册platform_device---->定义platform_driver------>注册platform_driver

系统启动时初始化时创建了 platform_bus 设备和 platform_bus_type 总线：

通过insert_resource将设备定义的所要分配的资源注册到内核。

经过platform_device_register注册的设备，在sys中看起来的结构可能是：

/sys/devices/platform/serial8250.0

|-- uevent

|-- modalias

|-- subsystem -> ../../../bus/platform

|-- power

|-- tty

|-- driver -> ../../../bus/platform/drivers/serial8250

内核初始化函数 kernel_init() 中调用了 do_basic_setup() ，该函数中调用 driver_init() ，该函数中调用 platform_bus_init() ，我们看看 platform_bus_init() 函数：

int __init platform_bus_init(void)

{

       int error

       early_platform_cleanup()

       error = device_register(&platform_bus);

       if (error)

              return error;

       error =  bus_register(&platform_bus_type);

       if (error)

              device_unregister(&platform_bus);

       return error;

}

device_register(&platform_bus) 中的 platform_bus 如下：

struct device platform_bus = {

       .init_name       = "platform",

};

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

接着 bus_register(&platform_bus_type) 注册了 platform_bus_type 总线，看一下改总线的定义：

struct bus_type platform_bus_type = {

       .name             = "platform",

       .dev_attrs       = platform_dev_attrs,

       .match           = platform_match,

       .uevent           = platform_uevent,

       .pm         = &platform_dev_pm_ops,

};

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

我们分析一下其中 platform_match 和 platform_uevent 函数。在分析设备驱动模型是已经知道总线类型 match 函数是在设备匹配驱动时调用， uevent 函数在产生事件时调用。

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

}

static const struct platform_device_id *platform_match_id(

                     struct platform_device_id *id,

                     struct platform_device *pdev)

{

       while (id->name[0]) {

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

                     pdev->id_entry = id;

                     return id;

              }

              id++;

       }

       return NULL;

}

不难看出，如果 pdrv 的 id_table 数组中包含了 pdev->name ，或者 drv->name 和 pdev->name 名字相同，都会认为是匹配成功。 id_table 数组是为了应对那些对应设备和驱动的 drv->name 和 pdev->name 名字不同的情况。

再看看 platform_uevent （）函数：

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

{

       struct platform_device   *pdev = to_platform_device(dev);

 

       add_uevent_var(env, "MODALIAS=%s%s", PLATFORM_MODULE_PREFIX,

              (pdev->id_entry) ? pdev->id_entry->name : pdev->name);

       return 0;

}

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

static struct kset_uevent_ops device_uevent_ops = {

       .filter =    dev_uevent_filter,

       .name =          dev_uevent_name,

       .uevent = dev_uevent,

};

当调用 device_add() 时会调用 kobject_uevent(&dev->kobj, KOBJ_ADD) 产生一个事件，这个函数中会调用相应的 kset_uevent_ops 的 uevent 函数，这里即为 dev_uevent() ，我们看一下这个函数的代码片段：

static int dev_uevent(struct kset *kset, struct kobject *kobj,

                    struct kobj_uevent_env *env)

{

       /* have the bus specific function add its stuff */

       if (dev->bus && dev->bus->uevent) {

              retval = dev->bus->uevent(dev, env);

              if (retval)

                     pr_debug("device: '%s': %s: bus uevent() returned %d ",

                              dev_name(dev), __func__, retval);

       }       .

}

从这里看到如果 bus->uevent() 函数存在则会调用它。

到这里我们清楚了 platform_uevent 会在哪里调用了。

在2.6内核中platform设备用结构体platform_device来描述，该结构体定义在kernelincludelinuxplatform_device.h中，Platform设备简单的封装了struct device，主要是增加了struct resource来表示设备在系统中所占用的内存或者中断资源等。

1、struct platform_device {

       const char       * name;   //设备名称，和设备id一起设置内嵌kobj的name

       int          id;           //设备id，和设备名称一起设置内嵌kobj的name

       struct device   dev;  //内部封装的device

       u32         num_resources;   //资源的个数

       struct resource * resource; //一些io或者中断资源

};

该结构一个重要的元素是resource，该元素存入了最为重要的设备资源信息，定义在kernelincludelinuxioport.h中，

2、　　struct resource {

　　const char *name;   资源的名称

　　unsigned long start, end;资源的起始物理地址，结束物理地址

　　unsigned long flags;  资源的类型。比如MEM,IO,IRQ等类型

　　struct resource *parent, *sibling, *child;   //资源链表指针

　　};

3、　下面举s3c2410平台的i2c驱动作为例子来说明：

　　/* arch/arm/mach-s3c2410/devs.c */

　　/* I2C */

　　static struct resource s3c_i2c_resource[] = {

　　[0] = {

　　.start = S3C24XX_PA_IIC,

　　.end = S3C24XX_PA_IIC + S3C24XX_SZ_IIC - 1,

　　.flags = IORESOURCE_MEM,

　　},

　　[1] = {

　　.start = IRQ_IIC, //S3C2410_IRQ(27)

　　.end = IRQ_IIC,

　　.flags = IORESOURCE_IRQ,

　　}

　　};

　　这里定义了两组resource，它描述了一个I2C设备的资源，第1组描述了这个I2C设备所占用的总线地址范围，IORESOURCE_MEM表示第1组描述的是内存类型的资源信息，第2组描述了这个I2C设备的中断号，IORESOURCE_IRQ表示第2组描述的是中断资源信息。设备驱动会根据flags来获取相应的资源信息。

　　有了resource信息，就可以定义platform_device了：

　　struct platform_device s3c_device_i2c = {

　　.name = "s3c2410-i2c",

　　.id = -1,

　　.num_resources = ARRAY_SIZE(s3c_i2c_resource),

　　.resource = s3c_i2c_resource,

　　};

static struct resource s3c_wdt_resource1={

   .start=0x44100000,

   .end=0x44200000,

   .flags=IORESOURCE_MEM

           };

设备从0x441000000!~0x442000000结束，属于地址性的信息。

static struct resource s3c_wdt_resource2={

   .start=20,

   .end=20,

   .flags=IORESOURCE_IRQ

         };

改设备用20号中断。

4、struct platform_device的分配使用：

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

参数：设备名，id:设备id，一般为-1.

5、注册平台设备

int platform_device_add(struct platform_device *pdev)

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

对于 platform 设备的初始化，内核源码也提供了 platform_device_alloc() 函数。

对于 platform 设备的初注册，内核源码提供了 platform_device_add() 函数，它是进行一系列的操作后调用 device_add() 将设备注册到相应的总线上，内核代码中 platform 设备的其他注册函数都是基于这个函数，如 platform_device_register() 、 platform_device_register_simple() 、 platform_device_register_data() 等。

对这些函数逐个分析，首先看看初始化函数 platform_device_alloc() ：

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

{

       struct platform_object *pa;

 

       pa = kzalloc(sizeof(struct platform_object) + strlen(name), GFP_KERNEL);

       if (pa) {

              strcpy(pa->name, name);

              pa->pdev.name = pa->name;

              pa->pdev.id = id;

              device_initialize(&pa->pdev.dev);

              pa->pdev.dev.release = platform_device_release;

       }

 

       return pa ? &pa->pdev : NULL;

}

该函数首先为 platform 设备分配内存空间，这里的 struct platform_object 结构是 struct platform _device 结构的封装，其定义如下：

struct platform_object {

       struct platform_device pdev;

       char name[1];

};

其中第二个字段 name 的地址用于存放第一个字段 pdev 的 name 指针上的内容，函数中的代码说明了这点：

strcpy(pa->name, name);

pa->pdev.name = pa->name;

接着用输入参数 id 初始化 platform_device 的 id 字段，这个 id 是在设置代表它的 kobject 时会用到的，我们将在后面分析到，如果不用它，则设为 -1 。

接着调用 device_initialize() 初始化 platform_device 内嵌的 device ，并设置其 release 函数指针。

platform_device_alloc() 函数分析完了。

接着我们看看 platform_device_add() 函数：

int platform_device_add(struct platform_device *pdev)

{

       int i, ret = 0;

 

       if (!pdev)

              return -EINVAL;

 

       if (!pdev->dev.parent)

              pdev->dev.parent = & platform_bus;

 

       pdev->dev.bus = &platform_bus_type;

设置父节点和总线，这里的 platform_bus 和 platform_bus_type 在上面的初始化部分已经分析。

       if (pdev->id != -1)

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

       else

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

设置 pdev->dev 内嵌的 kobj 的 name 字段，它是 pdev->name 指向的内容加上 id ，如果 id 为 -1 则忽略它，关于 dev_set_name() 函数已经在分析设备驱动模型时分析过，这里不再累赘。

       for (i = 0; i < pdev->num_resources; i++) {

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

 

              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 ",

                            dev_name(&pdev->dev), i);

                     ret = -EBUSY;

                     goto failed;

              }

       }

初始化资源并将资源分配给它，每个资源的它的 parent 不存在则根据 flags 域设置 parent ， flags 为 IORESOURCE_MEM ，则所表示的资源为 I/O 映射内存， flags 为 IORESOURCE_IO ，则所表示的资源为 I/O 端口。

       pr_debug("Registering platform device '%s'. Parent at %s ",

                dev_name(&pdev->dev), dev_name(pdev->dev.parent));

 

       ret = device_add(&pdev->dev);

就在这里把设备注册到总线上，如果你对 device_add() 函数不熟悉，请参考本站的设别模型分析部分内容。

       if (ret == 0)

              return ret;

 

  failed:

       while (--i >= 0) {

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

              unsigned long type = resource_type(r);

 

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

                     release_resource(r);

       }

除错撤销的内容。

       return ret;

}

platform_device_add() 函数分析完了，我们看下 platform_device_register() 函数：

int platform_device_register(struct platform_device *pdev)

{

       device_initialize(&pdev->dev);

       return platform_device_add(pdev);

}

没错它就是初始化 pdev->dev 后调用 platform_device_add() 把它注册到 platform_bus_type 上。

在看看 platform_device_register_simple() 函数：

struct platform_device *platform_device_register_simple(const char *name,

                                                 int id,

                                                 struct resource *res,

                                                 unsigned int num)

{

       struct platform_device *pdev;

       int retval;

 

       pdev = platform_device_alloc(name, id);

       if (!pdev) {

              retval = -ENOMEM;

              goto error;

       }

 

       if (num) {

              retval = platform_device_add_resources(pdev, res, num);

              if (retval)

                     goto error;

       }

 

       retval = platform_device_add(pdev);

       if (retval)

              goto error;

 

       return pdev;

 

error:

       platform_device_put(pdev);    注册失败，释放相关内存

       return ERR_PTR(retval);

}

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

int platform_device_add_resources(struct platform_device *pdev,

                              struct resource *res, unsigned int num)

{

       struct resource *r;

 

       r = kmalloc(sizeof(struct resource) * num, GFP_KERNEL);

       if (r) {

              memcpy(r, res, sizeof(struct resource) * num);

              pdev->resource = r;

              pdev-> num_resources = num;

       }

       return r ? 0 : -ENOMEM;

}

很简单，为资源分配内存空间，并拷贝参数 res 中的内容，链接到 device 并设置其 num_resources 。

二、获取资源

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[i];

  if (type == resource_type(r) && num-- == 0)
   return r;
 }
 return NULL;
}

例如： platform_get_resource(pdev,IORESOURCE_IRQ,0) 获取中断号，第1个资源。

三、平台驱动

类似platform_driver,就是对driver_register的一层很简单的包装。在sys文件系统中的结构可能是：

/sys/bus/platform/drivers/serial8250

|-- serial8250 -> ../../../../devices/platform/serial8250

|-- serial8250.0 -> ../../../../devices/platform/serial8250.0

|-- uevent

|-- unbind

|-- bind

数据结构

相对于标准的struct device_drvier，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 (*suspend_late)(struct platform_device *, pm_message_t state);

       int (*resume_early)(struct platform_device *);

       int (*resume)(struct platform_device *);

       struct device_driver driver; //内部封装的device_driver

};

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

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;

 

       return driver_register(&drv->driver);

}

上面的函数指定了内嵌的 driver 的 bus 字段为 platform_bus_type ，即为它将要注册到的总线。

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

看下相应的这三个函数：

static int platform_drv_probe(struct device *_dev)

{

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

       struct platform_device *dev = to_platform_device(_dev);

 

       return drv->probe(dev);

}

static int platform_drv_remove(struct device *_dev)

{

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

       struct platform_device *dev = to_platform_device(_dev);

 

       return drv->remove(dev);

}

 

static void platform_drv_shutdown(struct device *_dev)

{

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

       struct platform_device *dev = to_platform_device(_dev);

 

       drv->shutdown(dev);

}

从这三个函数的代码可以看到，又找到了相应的 platform_driver 和 platform_device ，然后调用 platform_driver 的 probe 、 remove 、 shutdown 函数。这是一种高明的做法：在不针对某个驱动具体的 probe 、 remove 、 shutdown 指向的函数，而通过上三个过度函数来找到 platform_driver ，然后调用 probe 、 remove 、 shutdown 接口。

来源： http://i.yoho.cn/4774537/logview/2646835.html

beyondioi

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
linux设备模型之platform总线

从Linux 2.6起引入了一套新的驱动管理和注册机制:Platform_device和Platform_driver。 Linux中大部分的设备驱动，都可以使用这套机制, 设备用Platform_device表示，驱动用Platform_driver进行注册。 Linux platform driver机制和传统的device driver 机制(通过driver_reg
复制链接

扫一扫