平台设备驱动分析

 
通常在Linux中，把SOC系统中集成的独立外设单元(如：I2C、IIS、RTC、看门狗等)都被当作平台设备来处理。在Linux中用platform_device结构体来描述一个平台设备

 

平台设备驱动分析：

   使用内核linux-2.6.22

   分析工具：source insight

 

我们来分析s3c2410-lcd是如何进行平台设备驱动注册的。

 drivers/video/s3c2410fb.c

 

 首先我们找到s3c2410fb.c的入口函数：

  module_init(s3c2410fb_init);

  module_exit(s3c2410fb_cleanup);

 

 然后查找 s3c2410fb：

 int __devinit s3c2410fb_init(void)

 {

  return platform_driver_register(&s3c2410fb_driver);   //在入口函数中注册了&s3c2410fb_driver结构体

 }

 static void __exit s3c2410fb_cleanup(void)

 {

  platform_driver_unregister(&s3c2410fb_driver);

 }

 我们就跳到s3c2410fb_driver结构体：

 

 static struct platform_driver s3c2410fb_driver = {

 .probe  = s3c2410fb_probe,             /*这个函数很重要，它的作用就相当于我们普通字符设备驱动中的init函数*/

 .remove  = s3c2410fb_remove,        /*这个函数的作用就相当于我们普通字符设备驱动中的exit函数里所作的工作*/

 .suspend = s3c2410fb_suspend,

 .resume  = s3c2410fb_resume,

 .driver  = {

  .name = "s3c2410-lcd",     //名字很重要，设备驱动和设备只有在相同的名字情况下，才能够进行匹配。

  .owner = THIS_MODULE,

 },

};

 

 接下来分析.probe  = s3c2410fb_probe, 中的s3c2410fb_probe结构体

 

  static int __init s3c2410fb_probe(struct platform_device *pdev)

{

 struct s3c2410fb_info *info;

 struct fb_info    *fbinfo;

 struct s3c2410fb_hw *mregs;

 int ret;

 int irq;

 int i;

 u32 lcdcon1;

      mach_info = pdev->dev.platform_data;  //mach_info函数非常重要，他会和dev.platform_data中的dev进行匹配。

}

对于这个结构体里面的函数我就不一一分析了

 

我们构造的每一个平台设备结构体都会添加到platform.c（总线驱动中）：

          drivers/base/platform.c

找到它的入口函数：

int __init platform_bus_init(void)

{

 int error;

 error = device_register(&platform_bus);

 if (error)

  return error;

 error =  bus_register(&platform_bus_type);

 if (error)

  device_unregister(&platform_bus);

 return error;

}

找到platform_bus_type结构体：

struct bus_type platform_bus_type = {

 .name  = "platform",

 .dev_attrs = platform_dev_attrs,

 .match  = platform_match,

 .uevent  = platform_uevent,

 .suspend = platform_suspend,

 .suspend_late = platform_suspend_late,

 .resume_early = platform_resume_early,

 .resume  = platform_resume,

};

那么我们的设备驱动&s3c2410fb_driver又是如何注册到总线驱动platform.c中的呢？

platform_driver_register(&s3c2410fb_driver);

在platform.c中：

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

}

drivers/base/driver.c

int driver_register(struct device_driver * drv)

{

 if ((drv->bus->probe && drv->probe) ||

     (drv->bus->remove && drv->remove) ||

     (drv->bus->shutdown && drv->shutdown)) {

  printk(KERN_WARNING "Driver '%s' needs updating - please use bus_type methods\n", drv->name);

 }

 klist_init(&drv->klist_devices, NULL, NULL);    //

 return bus_add_driver(drv);   //将本drv驱动注册登记到drv->bus所在的总线上

}

我们找到bus_add_driver结构体：

drivers/base/bus.c

int bus_add_driver(struct device_driver *drv)

{

 struct bus_type * bus = get_bus(drv->bus);

 int error = 0;

 

 drv->kobj.kset = &bus->drivers;

 if (drv->bus->drivers_autoprobe) {

  error = driver_attach(drv);  //在此去总线的设备链表上去搜索每一个设备，每搜索一个设备都会去调用__driver_attach;

  if (error)

   goto out_unregister;

 }

 klist_add_tail(&drv->knode_bus, &bus->klist_drivers);  //将自己挂载到驱动链表上面去

 module_add_driver(drv->owner, drv);

 error = driver_add_attrs(bus, drv);

 

}

driver_attach起的作用是什么？

drivers/base/dd.c

int driver_attach(struct device_driver * drv)

{

 return bus_for_each_dev(drv->bus, NULL, drv, __driver_attach);   //查找bus驱动中的每一个drv

}

来看看 __driver_attach函数的作用：

static int __driver_attach(struct device * dev, void * data)

{

 struct device_driver * drv = data;

 

 down(&dev->sem);

 if (!dev->driver)

  driver_probe_device(drv, dev);

 return 0;

}

int driver_attach(struct device_driver * drv)

{

 return bus_for_each_dev(drv->bus, NULL, drv, __driver_attach);

}

分析driver_probe_device结构体：

int driver_probe_device(struct device_driver * drv, struct device * dev)

{

 if (drv->bus->match && !drv->bus->match(dev, drv))     //platform_match

  goto done;

 ret = really_probe(dev, drv);    //名字相同，代表匹配成功，成功则调用次函数

done:

 return ret;

}

再来看看really_probe：

static int really_probe(struct device *dev, struct device_driver *drv)

{

 dev->driver = drv;

 if (driver_sysfs_add(dev)) {

 }

 if (dev->bus->probe) {

  ret = dev->bus->probe(dev);

  if (ret)

 } else if (drv->probe) {

  ret = drv->probe(dev);   //platform_drv_probe

  if (ret)

 }

}

 

drivers/base/platform.c

static int platform_match(struct device * dev, struct device_driver * drv)

{

 struct platform_device *pdev = container_of(dev, struct platform_device, dev);

 return (strncmp(pdev->name, drv->name, BUS_ID_SIZE) == 0);

}

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

}

platform_device注册过程：arch/arm/mach-s3c2410/mach-smdk2410.c

static void __init smdk2410_init(void)

{

 platform_add_devices(smdk2410_devices, ARRAY_SIZE(smdk2410_devices));   //添加dev

 smdk_machine_init();

}

 

static struct platform_device *smdk2410_devices[] __initdata = {                 //各种设备

 &s3c_device_usb,

 &s3c_device_lcd,

 &s3c_device_wdt,

 &s3c_device_i2c,

 &s3c_device_iis,

};

drivers/base/platform.c

int platform_device_register(struct platform_device * pdev)

{

 device_initialize(&pdev->dev);

 return platform_device_add(pdev);

}

 

int platform_device_add(struct platform_device *pdev)

{

 if (!pdev->dev.parent)

  pdev->dev.parent = &platform_bus;

 pdev->dev.bus = &platform_bus_type;

 else

  strlcpy(pdev->dev.bus_id, pdev->name, BUS_ID_SIZE);

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

 }

 ret = device_add(&pdev->dev);

}

drivers/base/core.c

int device_add(struct device *dev)

{

 dev = get_device(dev);

 if (dev->bus)

 bus_attach_device(dev);  //开始匹配平台驱动，开始去找控制驱动（lcd控制器驱动）

 if (parent)

  klist_add_tail(&dev->knode_parent, &parent->klist_children);

 if (dev->class) {

  down(&dev->class->sem);

  list_add_tail(&dev->node, &dev->class->devices);

  list_for_each_entry(class_intf, &dev->class->interfaces, node)

   if (class_intf->add_dev)

    class_intf->add_dev(dev, class_intf);

  up(&dev->class->sem);

 }

void bus_attach_device(struct device * dev)

{

 struct bus_type *bus = dev->bus;

 int ret = 0;

 if (bus) {

  dev->is_registered = 1;

  if (bus->drivers_autoprobe)

   ret = device_attach(dev);

  if (ret >= 0)

   klist_add_tail(&dev->knode_bus, &bus->klist_devices);

 }

}

查看device_attach函数

int device_attach(struct device * dev)

{

 int ret = 0;

 down(&dev->sem);

 if (dev->driver) {

  ret = device_bind_driver(dev);

  if (ret == 0)

   ret = 1;

  else {

   dev->driver = NULL;

   ret = 0;

  }

 } else {

  ret = bus_for_each_drv(dev->bus, NULL, dev, __device_attach);

 }

 up(&dev->sem);

 return ret;

}

再看看__device_attach函数：

drivers/base/dd.c

static int __device_attach(struct device_driver * drv, void * data)

{

 struct device * dev = data;

 return driver_probe_device(drv, dev);   //也会调用总线的match函数来实现匹配过程，根据名字进行匹配

}

int driver_probe_device(struct device_driver * drv, struct device * dev)

{

 

 if (drv->bus->match && !drv->bus->match(dev, drv))

  goto done;

 ret = really_probe(dev, drv);

}

 

static int really_probe(struct device *dev, struct device_driver *drv)

{

 dev->driver = drv;

 if (dev->bus->probe) {

  ret = dev->bus->probe(dev);

  if (ret)

   goto probe_failed;

 } else if (drv->probe) {

  ret = drv->probe(dev);                                //platform_drv_probe最终会调用到我们的s3c2410fb_probe  if (ret)

 }

}

就分析到这了，后面有一些因为时间匆忙以后再做详细分析。