基于高通MSM 8x60的I2C驱动终极讲解(7)

上面讲完控制器设备的注册，下面继续接着上面的，讲下控制器平台驱动的注册。

static struct platform_driver qup_i2c_driver = {
 .probe  = qup_i2c_probe,
 .remove  = __devexit_p(qup_i2c_remove),//如果编译为静态的，则__devexit_p为空
 .driver  = {
  .name = "qup_i2c",
  .owner = THIS_MODULE,
  .pm = &i2c_qup_dev_pm_ops,
 },
};

/* QUP may be needed to bring up other drivers */
static int __init qup_i2c_init_driver(void)
{
 return platform_driver_register (&qup_i2c_driver);//平台驱动的注册函数
}

 

arch_initcall(qup_i2c_init_driver);//注：该初始化的优先级别为3  .initcall3.init
下面开始分析，平台驱动如何注册驱动的。

int platform_driver_register(struct platform_driver *drv)
{
 drv->driver.bus = &platform_bus_type;//把该driver的bus类型赋值为平台总线类型
 if (drv->probe)//platform的探测函数不为空，则该driver的probe函数赋值为platform_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成员，下面跟踪下注册的过程。

int driver_register(struct device_driver *drv)
{
 other = driver_find(drv->name, drv->bus);//判读查找该驱动是否已经在该总线上注册过？
 ret = bus_add_driver(drv);//如果没有注册过，就把该drv加入到总线上
}

继续分析，加入的过程：

int bus_add_driver(struct device_driver *drv)
{
 struct bus_type *bus;
 struct driver_private *priv;
 priv = kzalloc(sizeof(*priv), GFP_KERNEL);//分配一个priv私有数据结构，并初始化
 klist_init(&priv->klist_devices, NULL, NULL);
 priv->driver = drv;//把该私有结构挂到driver上
 drv->p = priv;
 priv->kobj.kset = bus->p->drivers_kset;
 if (drv->bus->p->drivers_autoprobe) {//如果bus设置了drivers的自动探测，则执行探测绑定
  error = driver_attach(drv);
 }
 klist_add_tail(&priv->knode_bus, &bus->p->klist_drivers);//到处已经探测成功，把该驱动加入bus的driver的链表中
 return 0;

}

继续跟踪探测，绑定函数，该函数是取出总线设备链表的每一个设备，和该驱动匹配

int driver_attach(struct device_driver *drv)
{
 return bus_for_each_dev(drv->bus, NULL, drv, __driver_attach);
}
继续看_driver_attach函数

static int __driver_attach(struct device *dev, void *data)
{
 struct device_driver *drv = data;

 if (!driver_match_device(drv, dev))//该函数调用总线的match函数，进行匹配
  return 0;

  if (!dev->driver)//到此匹配成功，并且dev的driver为空，则执行如下探测函数
  driver_probe_device(drv, dev);
 return 0;
}

下面就跟踪下探测函数的实现：

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

 dev->driver = drv;//关联二者
 ret = really_probe(dev, drv);
}

继续跟踪：

static int really_probe(struct device *dev, struct device_driver *drv)
{
 if (dev->bus->probe) {//如果总线上有probe函数，优先调用总线的该函数
  ret = dev->bus->probe(dev);
  if (ret)
   goto probe_failed;
 } else if (drv->probe) {//如果drv的不为空，则调用driver的探测函数
  ret = drv->probe(dev);
  if (ret)
   goto probe_failed;
 }

 driver_bound(dev);//探测成功后，绑定，也就是把该dev加入到driver的device链表
}

到处平台驱动的注册函数完毕，已经把该平台驱动加入到对应的总线中，以及和对应的平台设备绑定。

因为此处为平台设备，所以还有一点需要分析：就是探测函数

此时执行的是：drv->driver.probe = platform_drv_probe;
函数，下面分析下，该函数干了什么活：

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中的探测函数。到处算是驱动框架分析完毕，下一节开始分析具体的probe探测函数，由于注册设备和注册驱动时，都要调用对应驱动的探测函数，所以重点看的就是探测函数。