I2C设备与驱动的关联

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;
return driver_register(&drv->driver);
}
EXPORT_SYMBOL_GPL(platform_driver_register);

1.3 driver_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);
return bus_add_driver(drv);
}

1.4 bus_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.1 driver_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.3 driver_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.4 really_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);

return drv->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. 平台驱动卸载过程

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

2.2 platform_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.3 driver_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.4 bus_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.5 driver_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); 
 } 
} 

2.6 __device_release_driver()函数
/** 
 * device_release_driver - manually detach device from driver. 
 * @dev: device. 
 * 
 * Manually detach device from driver. 
 * 
 * __device_release_driver() must be called with @dev->sem held. 
 * When called for a USB interface, @dev->parent->sem must be held 
 * as well. 
 */ 

static void __device_release_driver(struct device * dev) 
{ 
 struct device_driver * drv; 

 drv = dev->driver; 
 if (drv) { 
  get_driver(drv); 
  driver_sysfs_remove(dev); 
  sysfs_remove_link(&dev->kobj, "driver"); 
  klist_remove(&dev->knode_driver); 

  if (dev->bus) 
   blocking_notifier_call_chain(&dev->bus->bus_notifier, 
           BUS_NOTIFY_UNBIND_DRIVER, 
           dev); 

  if (dev->bus && dev->bus->remove) 
   dev->bus->remove(dev); 
  else if (drv->remove) 
   drv->remove(dev); 
  devres_release_all(dev); 
  dev->driver = NULL; 
  put_driver(drv); 
 } 
} 

2.7 platform_drv_remove()函数
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); 
}

在此函数中，回调了我们在i2c-at91.c文件中实现的移除函数at91_i2c_remove()，至此，平台驱动的卸载过程结束。

在注册和卸载过程中，Linux采用了一些变量来保存相关的信息，比如引用计数、通知链等，感兴趣的人员，可以详细的阅读此部分内容。