学步园

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

        other =
driver_find(drv->name, drv->bus);        //在kobject
结
构组成的链表中查找是否已经存在这个驱动,以前的blog讲过,驱动必然挂接在某个总线上.请复习,返回值是




device_driver

结构的指针

        if (other) {
               
put_driver(other);               
//由于之前增加了引用计数,这里在减1
                      
               

printk(KERN_ERR "Error: Driver '%s' is already registered, "
                       
"aborting.../n", drv->name);

                return -EEXIST
;
        }

       
ret =
bus_add_driver(drv);                                          //此函数是重点！

       
if (ret)
                return

ret;
        ret = driver_add_groups(drv,
drv->groups);              
//这两个函数不用介绍也猜的出来

        if (ret)
               
bus_remove_driver(drv);
       
return
ret;
}
那么我们接着看



bus_add_driver
函数





,这个函数的作用
是：如果驱动还未挂接在总线上,挂接它并且调用probe函数进行探测.
它的代码在


drivers/base/bus.c中.






int
bus_add_driver(struct
device_driver
*drv)            
//这个函数我不记得我的blog中是否有讲过(我记得我写过注释,如果没写过,就请自己看吧  呵呵 )

{
      
.......................................
        if
(drv->bus->p->drivers_autoprobe) {
                error =
driver_attach(drv);                           //这个函数是重点.

               
if (error)
                        goto out_unregister;
        }
 
      ......................................      
 


}

driver_attach
函
数在
drivers/base/dd.c
中




,很简单的一句话：


 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;

       
/*
         * 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;
}


driver_probe_device
函数中有一个

really_probe
函数,这是我们的最终目的地

:
static int
really_probe(struct
device *dev, struct
device_driver *drv)
{
       
...................................................
           if
(dev->bus->probe) {                                         //我们看到了这里会调用probe函数,同样这里也会决定你的probe函数是使用
一个参数还是两个参数,

                ret = dev->bus->probe(dev);
                          因为这取决于你是如何注册的.也就是是否调用了（仅仅针对于网友的提问）
platform_device_register

               
if (ret)                                                               
函数来注册设备.具体看下面的总结.

                       
goto probe_failed;
        } else if (drv->probe) {
                ret = drv->probe(dev);

               
if (ret)
                        goto probe_failed;
        }
        
....................................................
}

好了,这里来总结一下得失,同时根据以上列的代码回答网友的提问: if (dev->bus->probe)
这个表示是否注册
了device结构,如果注册了并且给device结构挂接上了驱动和总线,那么调用挂接在device结构中的总线的probe函数.这里的
device结构从哪里冒出来的？它在
bus_for_each_dev
函数中：


int
bus_for_each_dev(struct
bus_type *bus, struct
device *start,
                     void
*data, int
(*fn)(struct
device *, void
*))
{
        struct
klist_iter i;
        struct
device *dev;
        int error = 0;

       
if (!bus)
               
return -EINVAL;

       
klist_iter_init_node(&bus->p->klist_devices, &i,         
                            
(start ? &start->knode_bus :
NULL
));
        while ((dev = next_device(&i)) &&
!error)                                      //查找每个挂接在sdio总线上的设备,看他们是否有注册,并调用相应的probe函数也就是

               
error = fn(dev,
data);                                                               

__driver_attach
函数.实际上就是查找device结构


.
       
klist_iter_exit(&i);




        return
error;
}

关于platform_device结构与device结构的关系,就不用我在解释了
吧！probe函数的调用,就取决于你在你注册的device结构中挂接的总线的类型了.因为调用

dev->bus->probe(dev); 所以清查看一下你注册是挂接的总线的probe函数的参数即可.


一般来说,参数会是两个,因为一类总线上总是可以挂接多个设备,所以我们还需要一个device_id.
如果行到else部分

: else if
(drv->probe) .这里调用驱动的probe函数,由于我们注册的是
sdio_driver
结构


.看一看sdio_driver结构的申明,在include/linux
/mmc/sdio_func.h中：




struct sdio_driver {
       
char *name;
        const struct sdio_device_id *id_table;

        int (*probe)(struct sdio_func *, const
struct sdio_device_id *);                     //很显然probe就是两个参数,而不是一个.

       
void (*remove)(struct sdio_func *);

        struct device_driver
drv;
};

至于为什么你的probe是一个参
数,我希望你能给出完整的注册流程才能分析,但是我认为根据我刚才分析的流程应该可以自己找出相应的代码了.