linux下platform总线驱动

参考文章:http://blog.csdn.net/zqixiao_09/article/details/50865480

platform总线、设备与驱动

在Linux 2.6 的设备驱动模型中,关心总线设备驱动 3个实体,总线将设备和驱动绑定。在系统每注册一个设备的时候,会寻找与之匹配的驱动;相反的,在系统每注册一个驱动的时候,会寻找与之匹配的设备,而匹配由总线完成。

一个现实的linux设备和驱动通常都需要挂接在一种总线上,对于本身依附于PCI、USB、I2C、SPI等的设备而言,这自然不是问题,但是在嵌入式系统里面,SoC系统中集成的独立的外设控制器、挂接在SoC内存空间的外设等却不依附于此类总线。基于这一背景,Linux发明了一种虚拟的总线,称为platform总线,相应的设备称为platform_device,而驱动成为platform_driver

注意,所谓的platform_device并不是与字符设备、块设备和网络设备并列的概念,而是Linux系统提供的一种附加手段,例如,在 S3C6410处理器中,把内部集成的I2C、RTC、SPI、LCD、看门狗等控制器都归纳为platform_device,而它们本身就是字符设备。

基于Platform总线的驱动开发流程如下
a – 定义初始化platform_bus
b – 定义各种platform_devices
c – 注册各种platform_devices
d – 定义相关platform_driver
e – 注册相关platform_driver
f – 操作相关设备

相关结构体的定义

1.平台设备–platform_device结构体(linux/platform_device.h中)

struct platform_device {
        const char * name;/* 设备名 */
        u32 id;//设备id,用于插入给该总线并且具有相同name的设备编号,如果只有一个设备的话填-1。
        struct device dev;//结构体中内嵌的device结构体。
        u32 num_resources;/* 设备所使用各类资源数量 */
        struct resource * resource;/* 定义平台设备的资源首地址*/
        const struct platform_device_id     *id_entry;//平台设备的id
        ....
    };

device结构体(linux/device.h中)

struct device {
        struct device       *parent;
        struct device_private   *p;
        const char      *init_name; /* initial name of the device */
        const struct device_type *type;
        struct bus_type *bus;       /* type of bus device is on */
        struct device_driver *driver;   /* which driver has allocated this device */
        void        *platform_data; /* Platform specific data, device core doesn't touch it */
        void        *driver_data;   /* Driver data, set and get with dev_set/get_drvdata */
        struct device_node  *of_node; /* associated device tree node */
        u32         id; /* device instance */
        ....
    };

2.设备的驱动–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 pm_ext_ops *pm;        
        struct device_driver driver;//所有驱动的id
        const struct platform_device_id* id_table;//设备id表,表明这个驱动支持哪些同类型的设备
        bool prevent_deferred_probe;
   };

device_driver结构体(linux/device.h中)

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;// The open firmware table
        const struct acpi_device_id *acpi_match_table;// The 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;
    };    

3.系统中为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_PM_OPS_PTR,
    };
    EXPORT_SYMBOL_GPL(platform_bus_type);

这里要重点关注其match()成员函数,正是此成员表明了platform_device和platform_driver之间如何匹配。

static int platform_match(struct device *dev, struct device_driver *drv)  
    {  
         struct platform_device *pdev;  
         pdev = container_of(dev, struct platform_device, dev);  
         return (strncmp(pdev->name, drv->name, BUS_ID_SIZE) == 0);  
    }  

匹配platform_device和platform_driver主要看二者的name字段是否相同。对platform_device的定义通常在BSP的板文件中实现,在板文件中,将platform_device归纳为一个数组,最终通过platform_add_devices()函数统一注册。platform_add_devices()函数可以将平台设备添加到系统中,这个函数的原型为:

int platform_add_devices(struct platform_device **devs, int num);

该函数的第一个参数为平台设备数组的指针,第二个参数为平台设备的数量,它内部调用了platform_device_register()函 数用于注册单个的平台设备。

一、platform初始化

系统启动初始化时创建了platform_bus总线设备和platform_bus_type总线,platform总线是在内核初始化的时候就注册进了内核。
内核初始化函数kernel_init()中调用了do_basic_setup() ,该函数中调用driver_init(),该函数中调用platform_bus_init(),我们看看platform_bus_init()函数:

int __init platform_bus_init(void)
    {
         int error;
         early_platform_cleanup(); //清除platform设备链表
         //device_register函数把设备名为platform 的设备platform_bus注册到系统中,其他的platform设备都会以它为parent。
         //它在sysfs中目录下.即 /sys/devices/platform。
         //platform_bus总线也是设备,所以也要进行设备的注册
         //struct device platform_bus = {
         //.init_name = "platform",
         //};
         //将平台bus作为一个设备注册,出现在sys文件系统的device目录  
         error = device_register(&platform_bus); 
         if (error) 
             return error; 
         //接着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_PM_OPS_PTR, }; */ 
         //默认platform_bus_type中没有定义probe函数。
         //注册平台类型的bus,将出现sys文件系统在bus目录下,创建一个platform的目录,以及相关属性文件
         error = bus_register(&platform_bus_type); 
         if (error) 
             device_unregister(&platform_bus); 
             return error; 
      }

总线类型match函数是在设备匹配驱动时调用,uevent函数在产生事件时调用。
platform_match函数在当属于platform的设备或者驱动注册到内核时就会调用,完成设备与驱动的匹配工作

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设备的注册

注册完platform总线后,接下来就是platform设备的注册,无论哪种注册方式,把设备添加到系统都要调用device_initialize()函数和platform_device_add()函数

platform设备的注册分为两种方式:

1. 第一种平台设备注册方式

platform_device是静态的全局设备,即platform_device结构的成员已经初始化完成。直接将平台设备注册到platform总线上。注册函数为platform_device_register()

int platform_device_register(struct platform_device *pdev)
{
    device_initialize(&pdev->dev);//初始化platform_device内嵌的device
    return platform_device_add(pdev);//把它注册到platform_bus_type上
}
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;//设置父节点,即platform_bus作为总线设备的父节点,其余的platform设备都是它的子设备          
        //platform_bus是一个设备,platform_bus_type才是真正的总线    
        pdev->dev.bus = &platform_bus_type;//设置platform总线,指定bus类型为platform_bus_type 
        //设置pdev->dev内嵌的kobj的name字段,将platform下的名字传到内部device,最终会传到kobj 
        if (pdev->id != -1)
         dev_set_name(&pdev->dev, "%s.%d", pdev->name, pdev->id);
        else
         dev_set_name(&pdev->dev, "%s", pdev->name);     
        //初始化资源并将资源分配给它,每个资源的它的parent不存在则根据flags域设置parent,flags为IORESOURCE_MEM,
        //则所表示的资源为I/O映射内存,flags为IORESOURCE_IO,则所表示的资源为I/O端口。
        for (i = 0; i < pdev->num_resources; i++) {
         struct resource *p, *r = &pdev->resource[i];
         if (r->name == NULL)//资源名称为NULL则把设备名称设置给它
                 r->name = dev_name(&pdev->dev);
         p = r->parent;//取得资源的父节点,资源在内核中也是层次安排的
         if (!p) {
         if (resource_type(r) == IORESOURCE_MEM) //如果父节点为NULL,并且资源类型为IORESOURCE_MEM,则把父节点设置为iomem_resource 
                 p = &iomem_resource;
         else if (resource_type(r) == IORESOURCE_IO)//否则如果类型为IORESOURCE_IO,则把父节点设置为ioport_resource
              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_creat() 创建一个设备并注册到内核驱动架构...
        //device_add() 注册一个设备到内核,少了一个创建设备..
        ret = device_add(&pdev->dev);//就在这里把设备注册到总线设备上,标准设备注册,即在sys文件系统中添加目录和各种属性文件
        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;
}

2. 第二种平台设备注册方式

另外一种机制就是通过platform_device_alloc()函数动态申请一个platform_device设备,对其进行初始化,之后调用platform_device_register()函数进行注册。

struct platform_device * platform_device_alloc(const char *name, int id)
{
    struct platform_object *pa;
    /*
    struct platform_object {
       struct platform_device pdev;
       char name[1];
    };
    */
    pa = kzalloc(sizeof(struct platform_object) + strlen(name), GFP_KERNEL);//该函数首先为platform设备分配内存空间
    if (pa) {
        strcpy(pa->name, name);
        pa->pdev.name = pa->name;//初始化platform_device设备的名称
        pa->pdev.id = id;//初始化platform_device设备的id
        device_initialize(&pa->pdev.dev);//初始化platform_device内嵌的device
        pa->pdev.dev.release = platform_device_release;
    }
    return pa ? &pa->pdev : NULL;
}

一个更好的方法是,通过下面的函数platform_device_register_simple()动态创建一个设备,并把这个设备注册到系统中:该函数就是调用了platform_device_alloc()和platform_device_add()函数来创建和注册platform_device。

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

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; //并拷贝参数res中的内容,链接到device并设置其num_resources
              pdev-> num_resources = num;
       }
       return r ? 0 : -ENOMEM;
}

注:
1. 无论是platform_device_add()函数、platform_device_register()函数、platform_device_register_simple()函数、platform_device_register_data()函数本质上都是先注册resources资源和相关属性,然后调用device_add()函数,将设备挂到特定的platform总线。

三、platform驱动的注册

驱动在注册时要调用driver_register(),platform driver的注册函数platform_driver_register()同样也是进行其它的一些初始化后调用driver_register()将驱动注册到platform_bus_type总线上.

int platform_driver_register(struct platform_driver *drv)
{
       drv->driver.bus = &platform_bus_type;//它将要注册到的总线
            /*设置成platform_bus_type这个很重要,因为driver和device是通过bus联系在一起的,
            具体在本例中是通过 platform_bus_type中注册的回调例程和属性来是实现的,
            driver与device的匹配就是通过 platform_bus_type注册的回调例程platform_match ()来完成的。
            */
       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);//注册驱动
}

然后设定了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);//调用platform_driver的probe()函数,这个函数一般由用户自己实现
                              //例如下边结构,回调的是serial8250_probe()函数
           /*
                static struct platform_driver serial8250_isa_driver = {
                    .probe        = serial8250_probe,
                    .remove        = __devexit_p(serial8250_remove),
                    .suspend    = serial8250_suspend,
                    .resume        = serial8250_resume,
                    .driver        = {
                        .name    = "serial8250",
                        .owner    = THIS_MODULE,
                    },
                };
                */
}

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

}

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

如果设备和驱动都注册了,就可以通过bus ->match、bus->probe或driver->probe进行设备驱动匹配了。
  • 0
    点赞
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值