I2C设备与驱动的关联(1)

原文地址 http://blog.chinaunix.net/u2/79779/showart_1657800.html

 

在Linux操作系统中，驱动程序的加载分为两种动加载和用户手动加载；硬件设备也可以采用两种方式添加到系统中：在系统启动前及系统运行时的热插拨。下面，我们以arm体系结构下的at91处理器中的I2C控制器为例，介绍一下硬件设备及相关的驱动程序是如何绑定及松绑的。

1. 平台驱动注册过程

 

1.1at91_i2c_init()函数
在文件drivers/i2c/busses/i2c-at91.c中，定义了结构体struct platform_driver并进行了初始化，通过使用module_init()宏进行声明，当模块被加载到内核时会调用at91_i2c_init()函数。在此函数中，调用了platform_driver_register()函数来完成注册。

static struct platform_driverat91_i2c_driver= {
  .probe      = at91_i2c_probe,
  .remove     = __devexit_p(at91_i2c_remove),
.suspend   = at91_i2c_suspend,
   .resume     = at91_i2c_resume,
    .driver     = {
       .name   = "at91_i2c",
     .owner  = THIS_MODULE,
    },
};

static int __initat91_i2c_init(void)
{
  returnplatform_driver_register(&at91_i2c_driver);
}
1.2platform_driver_register()函数
在文件drivers/base/platform.c中，实现并导出了platform_driver_register()

函数，以便使其他模块中的函数可以调用此函数。它在完成简单的包装后，调用了

driver_register()函数，完成了从平台实现到Linux内核实现的过渡。
    在此，我们需要关注一下platform_match()和platform_drv_probe()函数。platform_match() 函数确定驱动与设备的关联，而platform_drv_probe()函数会在随后介绍的函数中被调用。
//比较驱动信息中的name与设备信息中的name两者是否一致
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);
}

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,
};
EXPORT_SYMBOL_GPL(platform_bus_type);

/**
 *  platform_driver_register
 *   @drv: platform driver structure
 */
int platform_driver_register(struct platform_driver *drv)
{
    drv->driver.bus = &platform_bus_type;
 //在really_probe函数中，回调了platform_drv_probe函数
 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;
 returndriver_register(&drv->driver);
}
EXPORT_SYMBOL_GPL(platform_driver_register);

1.3driver_register()函数
在文件drivers/base/driver.c中，实现了driver_register()函数。在此函数中，初始化结构体struct device_driver中的klist_device和unloaded字段，通过klist_device字段，可以保存此驱动支持的设备链表，通过“完成”接口机制，完成线程间的同步。链表和“完成”接口的详细信息可以参考文献［1］。返回bus_add_driver()函数的运行结果。

/**
 *   driver_register - register driver with bus
 *   @drv:   driver to register
 *
 *    We pass off most of the work to the bus_add_driver() call,
 *    since most of the things we have to do deal with the bus
 *   structures.
 *
 *   The one interesting aspect is that we setup @drv->unloaded
 *  as a completion that gets complete when the driver reference
 *   count reaches 0.
 */
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);
  init_completion(&drv->unloaded);
  returnbus_add_driver(drv);
}

1.4bus_add_driver()函数
在文件drivers/base/bus.c中实现了bus_add_driver()函数，它通过语句klist_add_tail(&drv->knode_bus, &bus->klist_drivers); 将驱动信息保存到总线结构中，在设备注册过程中，我们就可以明白此语句的作用了。在此语句之前，调用了driver_attach()函数。
/**
 *  bus_add_driver - Add a driver to the bus.
 *    @drv:   driver.
 *
 */
int bus_add_driver(struct device_driver *drv)
{
  struct bus_type * bus = get_bus(drv->bus);
    int error = 0;

   if (!bus)
        return 0;

    pr_debug("bus %s: add driver %s\n", bus->name, drv->name);
 error = kobject_set_name(&drv->kobj, "%s", drv->name);
 if (error)
       goto out_put_bus;
    drv->kobj.kset = &bus->drivers;
    if ((error = kobject_register(&drv->kobj)))
       goto out_put_bus;

    error =driver_attach(drv);
  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);
  if (error) {
     /* How the hell do we get out of this pickle? Give up */
     printk(KERN_ERR "%s: driver_add_attrs(%s) failed\n",
         __FUNCTION__, drv->name);
 }
    error =add_bind_files(drv);
 if (error) {
     /* Ditto */
      printk(KERN_ERR "%s: add_bind_files(%s) failed\n",
           __FUNCTION__, drv->name);
 }

    return error;
out_unregister:
  kobject_unregister(&drv->kobj);
out_put_bus:
    put_bus(bus);
    return error;
}

1.5 dd.c文件
在文件drivers/base/dd.c中，实现了设备与驱动交互的核心函数。
1.5.1driver_attach()函数
函数driver_attach()返回bus_for_each_dev()函数的运行结果。bus_for_each_dev()函数的原型如下：
int bus_for_each_dev(struct bus_type *bus, struct device *start, void *data,
 int (*fn) (struct device *, void *));
该函数迭代了在总线上的每个设备，将相关的device结构传递给fn，同时传递data值。如果start是NULL，将从总线上的第一个设备开始迭代；否则将从start后的第一个设备开始迭代。如果fn返回一个非零值，将停止迭代，而这个值也会从该函数返回（摘自<设备驱动程序>>第三版）。
该函数是如何知道总线上的每个设备的呢？在设备注册过程中，我会详细介绍。
/*
 * drivers/base/dd.c - The core device/driver interactions.
 *
 *  This file contains the (sometimes tricky) code that controls the
 *   interactions between devices and drivers, which primarily includes
 * driver binding and unbinding.
 */

/**
 *   driver_attach - try to bind driver to devices.
 * @drv:   driver.
 *
 *   Walk the list of devices that the bus has on it and try to
 * match the driver with each one.  If driver_probe_device()
 *  returns 0 and the @dev->driver is set, we've found a
 *    compatible pair.
 */
int driver_attach(struct device_driver * drv)
{
   return bus_for_each_dev(drv->bus, NULL, drv,__driver_attach);
}
1.5.2__driver_attach()函数
函数__driver_attach()在调用driver_probe_device()函数前，需要进行线程间的互斥处理。
static int__driver_attach(struct device * dev, void * data)
{
 struct device_driver * drv = data;

   /*
    * Lock device and try to bind to it. We drop the error
   * here and always return 0, because we need to keep trying
   * to bind to devices and some drivers will return an error
   * simply if it didn't support the device.
    *
    * driver_probe_device() will spit a warning if there
     * is an error.
   */

  if (dev->parent) /* Needed for USB */
     down(&dev->parent->sem);
   down(&dev->sem);
  if (!dev->driver)
    driver_probe_device(drv, dev);
   up(&dev->sem);
    if (dev->parent)
      up(&dev->parent->sem);

 return 0;
}
1.5.3driver_probe_device()函数
在driver_probe_device()函数中，调用了match函数platform_match()，如果它返回0，表示驱动与设备不一致，函数返回；否则，调用really_probe()函数。
/**
 * driver_probe_device - attempt to bind device & driver together
 * @drv: driver to bind a device to
 * @dev: device to try to bind to the driver
 *
 * First, we call the bus's match function, if one present, which should
 * compare the device IDs the driver supports with the device IDs of the
 * device. Note we don't do this ourselves because we don't know the
 * format of the ID structures, nor what is to be considered a match and
 * what is not.
 *
 * This function returns 1 if a match is found, an error if one occurs
 * (that is not -ENODEV or -ENXIO), and 0 otherwise.
 *
 * This function must be called with @dev->sem held.  When called for a
 * USB interface, @dev->parent->sem must be held as well.
 */
int driver_probe_device(struct device_driver * drv, struct device * dev)
{
   struct stupid_thread_structure *data;
    struct task_struct *probe_task;
  int ret = 0;

 if (!device_is_registered(dev))
      return -ENODEV;
  if (drv->bus->match && !drv->bus->match(dev, drv))
       goto done;

   pr_debug("%s: Matched Device %s with Driver %s\n",
        drv->bus->name, dev->bus_id, drv->name);

    data = kmalloc(sizeof(*data), GFP_KERNEL);
   if (!data)
       return -ENOMEM;
  data->drv = drv;
  data->dev = dev;

  if (drv->multithread_probe) {
     probe_task = kthread_run(really_probe, data,
                  "probe-%s", dev->bus_id);
        if (IS_ERR(probe_task))
          ret = really_probe(data);
    } else
       ret =really_probe(data);

done:
    return ret;
}

struct stupid_thread_structure {
   struct device_driver *drv;
   struct device *dev;
};

1.5.4really_probe()函数
在really_probe()函数中，实现了设备与驱动的绑定。语句如下：dev->driver = drv;和
ret = drv->probe(dev); probe()函数的实现如下：
include/linux/platform_device.h

#define to_platform_device(x) container_of((x), struct platform_device, dev)

drivers/base/platform.c

#define to_platform_driver(drv)   (container_of((drv), struct platform_driver, driver))


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);
 
   returndrv->probe(dev);
}
在此函数中，回调了我们在i2c-at91.c文件中实现的探测函数at91_i2c_probe()，至此，平台驱动的注册过程结束。

static atomic_t probe_count = ATOMIC_INIT(0);
static DECLARE_WAIT_QUEUE_HEAD(probe_waitqueue);

static int really_probe(void *void_data)
{
    struct stupid_thread_structure *data = void_data;
    struct device_driver *drv = data->drv;
    struct device *dev = data->dev;
   int ret = 0;

 atomic_inc(&probe_count);
    pr_debug("%s: Probing driver %s with device %s\n",
        drv->bus->name, drv->name, dev->bus_id);
    WARN_ON(!list_empty(&dev->devres_head));

 dev->driver = drv;
    if (driver_sysfs_add(dev)) {
     printk(KERN_ERR "%s: driver_sysfs_add(%s) failed\n",
         __FUNCTION__, dev->bus_id);
       goto probe_failed;
   }

    if (dev->bus->probe) {
     ret = dev->bus->probe(dev);
        if (ret)
         goto probe_failed;
   } else if (drv->probe) {
      ret =drv->probe(dev);
      if (ret)
         goto probe_failed;
   }
    //设备与驱动绑定后，对系统中已注册的组件进行事件通知。
 driver_bound(dev);
   ret = 1;
 pr_debug("%s: Bound Device %s to Driver %s\n",
        drv->bus->name, dev->bus_id, drv->name);
    goto done;

probe_failed:
   devres_release_all(dev);
 driver_sysfs_remove(dev);
    dev->driver = NULL;

   if (ret != -ENODEV && ret != -ENXIO) {
       /* driver matched but the probe failed */
        printk(KERN_WARNING
             "%s: probe of %s failed with error %d\n",
            drv->name, dev->bus_id, ret);
   }
    /*
    * Ignore errors returned by ->probe so that the next driver can try
   * its luck.
  */
  ret = 0;
done:
 kfree(data);
 atomic_dec(&probe_count);
    wake_up(&probe_waitqueue);
   return ret;
}

平台驱动卸载过程

平台驱动卸载过程是注册的逆过程，详细信息可参考注册过程进行分析。
2.1at91_i2c_exit()函数
static void __exit at91_i2c_exit(void)
{
   platform_driver_unregister(&at91_i2c_driver);
}

2.2platform_driver_unregister()函数

/**
 *  platform_driver_unregister
 * @drv: platform driver structure
 */
void platform_driver_unregister(struct platform_driver *drv)
{
 driver_unregister(&drv->driver);
}
EXPORT_SYMBOL_GPL(platform_driver_unregister);

2.3driver_unregister()函数

/**
 *   driver_unregister - remove driver from system.
 * @drv:   driver.
 *
 *   Again, we pass off most of the work to the bus-level call.
 *
 *    Though, once that is done, we wait until @drv->unloaded is completed.
 *   This will block until the driver refcount reaches 0, and it is
 * released. Only modular drivers will call this function, and we
 * have to guarantee that it won't complete, letting the driver
 *   unload until all references are gone.
 */

void driver_unregister(struct device_driver * drv)
{
 bus_remove_driver(drv);
  /*
    * If the driver is a module, we are probably in
  * the module unload path, and we want to wait
    * for everything to unload before we can actually
    * finish the unload.
     */
  if (drv->owner)
       wait_for_completion(&drv->unloaded);
}

2.4bus_remove_driver()函数
/**
 *   bus_remove_driver - delete driver from bus's knowledge.
 *    @drv:   driver.
 *
 *   Detach the driver from the devices it controls, and remove
 * it from its bus's list of drivers. Finally, we drop the reference
 *  to the bus we took in bus_add_driver().
 */

void bus_remove_driver(struct device_driver * drv)
{
   if (!drv->bus)
        return;

  remove_bind_files(drv);
  driver_remove_attrs(drv->bus, drv);
   klist_remove(&drv->knode_bus);
    pr_debug("bus %s: remove driver %s\n", drv->bus->name, drv->name);
 driver_detach(drv);
  module_remove_driver(drv);
   kobject_unregister(&drv->kobj);
   put_bus(drv->bus);
}

2.5driver_detach()函数
/**
 * driver_detach - detach driver from all devices it controls.
 * @drv: driver.
 */
void driver_detach(struct device_driver * drv)
{
    struct device * dev;

 for (;;) {
       spin_lock(&drv->klist_devices.k_lock);
        if (list_empty(&drv->klist_devices.k_list)) {
         spin_unlock(&drv->klist_devices.k_lock);
          break;
       }
        dev = list_entry(drv->klist_devices.k_list.prev,
              struct device, knode_driver.n_node);
     get_device(dev);
     spin_unlock(&drv->klist_devices.k_lock);

      if (dev->parent) /* Needed for USB */
         down(&dev->parent->sem);
       down(&dev->sem);
      if (dev->driver == drv)
          __device_release_driver(dev);
        up(&dev->sem);
        if (dev->parent)
          up(&dev->parent->sem);
     put_device(dev);
 }
}