每一個驅動程式都有 module_init(xxxx_init) 這個語句，它代表系統啟動的時候會自動執行 xxxx 這個函式，也就是說驅動的人口函式是由module_init來定義的。當然還有module_exit(XXXX)，它代表系統解除安裝驅動時呼叫（linux系統允許動態載入解除安裝驅動），這一部分這不細說了。

       上文提到的 xxxx_init 是驅動的入口函式，在此函式中，我們一般註冊驅動的driver，比如我今天說的 i2c_driver:

        static int __init xxxx_init(void)
       {
          

其中xxxx_driver就是我們今天的主角 i2c_driver ：

      static struct i2c_driver xxxx_driver =
     {
         .driver =
         {
             .owner = THIS_MODULE,
             .name = "xxxx",
         },
        .id_table = xxxx_idtable,
        .probe = xxxx_probe,
     }

完整的 i2c_driver 非常複雜，上面的定義只是完成了最基本的部分，當然也是必須，也就代表完成了上面的部分你的驅動就可以工作了，當然還有其他的，這裡不細說了。i2c_driver 中的driver.name 要和i2c_client一致，因為這是他們配備的一個依據，id_table 是i2c_device_id結構體的一個物件，裡面定義了i2c驅動對應裝置的i2c地址，probe函式是個非常重要的函式，等下我再來細說。

     現在我來說說 i2c_add_driver 的執行過程。

   （注意：此函式是linux系統i2c 子系統已經為我們做好了的，我們完全不需要了解它的執行過程，只需要明白，當系統中已經註冊了和上文提到的i2c_driver  xxxx_driver 對應的i2c_client，所謂對應的是說，name一樣，i2c裝置的地址也一樣，那麼i2c_driver 與i2c_client配備成功，接著就會呼叫i2c_driver 的probe函式，在此函式中可以做一系列的初始化工作。）

     i2c_add_driver 函式只是呼叫了i2c_register_driver函式，在i2c_register_driver裡呼叫了driver_register(&i2c_driver->driver),

注意 driver_register 是linux系統裝置模型裡面的函數了，每一類linux裝置驅動的註冊最終都會呼叫它，傳遞的引數也由原來的i2c_driver 變成了 device_driver。driver_register做了一些判斷，最後呼叫了 bus_add_driver，然後呼叫 driver_attach，然後呼叫

bus_for_each_dev，這個函式就是搜尋總線上所有的device，我們這裡是i2c匯流排，也即搜尋i2c總線上的i2c_client，呼叫__driver_attach判斷i2c_driver i2c_client是否配備，再呼叫driver_match_device，driver_match_device最終呼叫了bus的match函式，我們這也就是i2c bus的match函式，再呼叫

i2c_match_id，這裡到最後的id 配備了，如果配備成功則正常返回到__driver_attach函式，呼叫driver_probe_device，再呼叫really_probe，最後呼叫bus的probe函式，在bus的probe函式裡利用to_i2c_driver 將device_driver轉換成了i2c_driver，最後呼叫了i2c_driver的probe函式，這個部分有點複雜，其中我可能也沒說的太清楚，建議用source insight自己跟一邊，因為其中有很多是公用的，跟一邊後，其他驅動註冊也就容易了。

1，driver_register把驅動註冊到匯流排

1. /**
2. * driver_register - register driver with bus
3. * @drv: driver to register
4. * We pass off most of the work to the bus_add_driver() call,
5. * since most of the things we have to do deal with the bus
6. * structures.
7. */
8. int driver_register(struct device_driver *drv) 
9. { 
10. …………………… 
11.     if ((drv->bus->probe && drv->probe) || 
12.         (drv->bus->remove && drv->remove) || 
13.         (drv->bus->shutdown && drv->shutdown)) 
14.     ret = bus_add_driver(drv);//把drv驅動，註冊到匯流排
15. …………………… 
16. } 

/**
 * 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.
 */
int driver_register(struct device_driver *drv)
{
……………………
	if ((drv->bus->probe && drv->probe) ||
	    (drv->bus->remove && drv->remove) ||
	    (drv->bus->shutdown && drv->shutdown))

	ret = bus_add_driver(drv);//把drv驅動，註冊到匯流排
……………………
}

2，驅動註冊到匯流排的實現函式

1. /**
2. * bus_add_driver - Add a driver to the bus.        -----在總線上加入一個驅動
3. * @drv: driver.
4. */
5. int bus_add_driver(struct device_driver *drv) 
6. { 
7. ……………… 
8.     if (drv->bus->p->drivers_autoprobe) { 
9.         error = driver_attach(drv);      //驅動的匹配函式
10. ……………… 
11. } 

/**
 * bus_add_driver - Add a driver to the bus.        -----在總線上加入一個驅動
 * @drv: driver.
 */
int bus_add_driver(struct device_driver *drv)
{
………………
	if (drv->bus->p->drivers_autoprobe) {
		error = driver_attach(drv);      //驅動的匹配函式
………………
}

3，driver_attach()

1. /**
2. * driver_attach - try to bind driver to devices.
3. * @drv: driver.
4. *
5. * Walk the list of devices that the bus has on it and try to
6. * match the driver with each one.  If driver_probe_device()
7. * returns 0 and the @dev->driver is set, we've found a
8. * compatible pair.
9. */
10. int driver_attach(struct device_driver *drv) 
11. { 
12.     return bus_for_each_dev(drv->bus, NULL, drv, __driver_attach);//注意這裡的__driver_attach
13. } 
14. EXPORT_SYMBOL_GPL(driver_attach); 

/**
 * 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);//注意這裡的__driver_attach
}
EXPORT_SYMBOL_GPL(driver_attach);

上面真正起作用的是__driver_attach：

1. staticint __driver_attach(struct device *dev, void *data) 
2. { 
3.     struct device_driver *drv = data; 
4.     /*
5.      * Lock device and try to bind to it. We drop the error
6.      * here and always return 0, because we need to keep trying
7.      * to bind to devices and some drivers will return an error
8.      * simply if it didn't support the device.
9.      *
10.      * driver_probe_device() will spit a warning if there
11.      * is an error.
12.      */
13.     if (!driver_match_device(drv, dev)) 
14.         return 0; 
15.     if (dev->parent) /* Needed for USB */
16.         device_lock(dev->parent); 
17.     device_lock(dev); 
18.     if (!dev->driver) 
19.         driver_probe_device(drv, dev);//看下這個函式的實現過程
20.     device_unlock(dev); 
21.     if (dev->parent) 
22.         device_unlock(dev->parent); 
23.     return 0; 
24. } 
25. int driver_probe_device(structdevice_driver *drv, struct device *dev) 
26. { 
27. ... 
28. //1.先是判斷bus是否match：
29. if (drv->bus->match && !drv->bus->match(dev, drv)) 
30.    goto done; 
31. //2.再具體執行probe：
32. ret = really_probe(dev, drv); 
33. ... 
34. } 

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 (!driver_match_device(drv, dev))
		return 0;

	if (dev->parent)	/* Needed for USB */
		device_lock(dev->parent);
	device_lock(dev);
	if (!dev->driver)
		driver_probe_device(drv, dev);//看下這個函式的實現過程
	device_unlock(dev);
	if (dev->parent)
		device_unlock(dev->parent);

	return 0;
}
int driver_probe_device(structdevice_driver *drv, struct device *dev)
{
...
//1.先是判斷bus是否match：
if (drv->bus->match && !drv->bus->match(dev, drv))
   goto done;
//2.再具體執行probe：
ret = really_probe(dev, drv);
...
}

4,really_probe是我們真正要找的函式

1. staticint really_probe(struct device *dev, struct device_driver *drv) 
2. { 
3. …………………… 
4. //1.先是呼叫的驅動所屬匯流排的probe函式：
5.     if (dev->bus->probe) { 
6.         ret = dev->bus->probe(dev); 
7.         if (ret) 
8.             goto probe_failed; 
9.     }  
10. //2.再呼叫的驅動中的probe函式：
11.     elseif (drv->probe) { 
12.         ret = drv->probe(dev); 
13.         if (ret) 
14.             goto probe_failed; 
15.     } 
16.     driver_bound(dev); 
17.     ret = 1; 
18.     pr_debug("bus: '%s': %s: bound device %s to driver %s\n", 
19.          drv->bus->name, __func__, dev_name(dev), drv->name);//這個資訊可以看到我們註冊的總 驅動、裝置和匯流排  資訊
20.     goto done; 
21. ……………… 
22. } 

static int really_probe(struct device *dev, struct device_driver *drv)
{
……………………
//1.先是呼叫的驅動所屬匯流排的probe函式：
	if (dev->bus->probe) {
		ret = dev->bus->probe(dev);
		if (ret)
			goto probe_failed;
	} 
//2.再呼叫的驅動中的probe函式：
	else if (drv->probe) {
		ret = drv->probe(dev);
		if (ret)
			goto probe_failed;
	}

	driver_bound(dev);
	ret = 1;
	pr_debug("bus: '%s': %s: bound device %s to driver %s\n",
		 drv->bus->name, __func__, dev_name(dev), drv->name);//這個資訊可以看到我們註冊的總 驅動、裝置和匯流排  資訊
	goto done;
………………
}

打印出的驅動裝置資訊如：

………………

[    0.588087] bus: 'platform': really_probe: bound device power.0to driverpower  //匯流排：platform  裝置：power.0  驅動：power
[    0.661226] bus: 'platform': really_probe: bound device s3c24xx-pwm.0 to driver s3c24xx-pwm
[    0.678552] bus: 'platform': really_probe: bound device s3c24xx-pwm.1 to driver s3c24xx-pwm
[    0.695971] bus: 'platform': really_probe: bound device s3c24xx-pwm.2 to driver s3c24xx-pwm
[    0.713389 bus: 'platform': really_probe: bound device s3c24xx-pwm.3 to driver
……………………