Linux驱动中，probe函数何时被调用

以你之姓@ 2022-06-04 07:21 115阅读 0赞

https://www.cnblogs.com/hoys/archive/2011/04/01/2002299.html

最近看到linux的设备驱动模型，关于Kobject、Kset等还不是很清淅。看到了struct device\_driver这个结构时，想到一个问题：它的初始化函数到底在哪里调用呢？以前搞PCI驱动时用pci驱动注册函数就可以调用它，搞s3c2410驱动时只要在mach-smdk2410.c中的struct platform\_device \*smdk2410\_devices \{\}中加入设备也会调用。但从来就没有想过具体的驱动注册并调用probe的过程。  
  
于是打开SourceInsight追踪了一下：  
  
从driver\_register看起：

int
        
         driver_register(
        
         struct
        
         device_driver 
        
         *
        
         drv) { klist_init(
        
         &
        
         drv
        
         ->
        
         klist_devices, klist_devices_get, klist_devices_put); init_completion(
        
         &
        
         drv
        
         ->
        
         unloaded); 
        
         return
        
         bus_add_driver(drv); }

klist\_init与init\_completion没去管它，可能是2.6的这个设备模型要做的一些工作。直觉告诉我要去bus\_add\_driver。  
  
bus\_add\_driver中：  
都是些Kobject 与 klist 、attr等。还是与设备模型有关的。但是其中有一句：  
driver\_attach(drv);  
单听名字就很像：

void
        
         driver_attach(
        
         struct
        
         device_driver 
        
         *
        
         drv) { bus_for_each_dev(drv
        
         ->
        
         bus, NULL, drv, __driver_attach); }

这个熟悉，遍历总线上的设备并设用\_\_driver\_attach。  
在\_\_driver\_attach中又主要是这样：  
driver\_probe\_device(drv, dev);  
跑到driver\_probe\_device中去看看：  
有一段很重要：  
if (drv->bus->match && !drv->bus->match(dev, drv))  
                goto Done;  
明显，是调用的驱动的总线上的match函数。如果返回1，则可以继续，否则就Done了。  
继承执行的话：  
        if (drv->probe) \{  
                ret = drv->probe(dev);  
                if (ret) \{  
                        dev->driver = NULL;  
                        goto ProbeFailed;  
                \}  
只要probe存在则调用之。至此就完成了probe的调用。  
  
这个过程链的关键还是在drv->bus->match ，因为其余的地方出错的话就是注册失败，而只要注册不失败且match返回1，那么就铁定会调用驱程的probe了。你可以注册一个总线类型和总线,并在match中总是返回 1, 会发现,只要struct device\_driver中的bus类型正确时,probe函数总是被调用.  
PCI设备有自己的总线模型，估计在它的match中就有一个判断的条件。

![复制代码][copycode.gif]

static
        
         
        
         int
        
         pci_bus_match(
        
         struct
        
         device 
        
         *
        
         dev, 
        
         struct
        
         device_driver 
        
         *
        
         drv) { 
        
         struct
        
         pci_dev 
        
         *
        
         pci_dev 
        
         =
        
         to_pci_dev(dev); 
        
         struct
        
         pci_driver 
        
         *
        
         pci_drv 
        
         =
        
         to_pci_driver(drv); 
        
         const
        
         
        
         struct
        
         pci_device_id 
        
         *
        
         found_id; found_id 
        
         =
        
         pci_match_device(pci_drv, pci_dev); 
        
         if
        
         (found_id) 
        
         return
        
         
        
         1
        
         ; 
        
         return
        
         
        
         0
        
         ; }

![复制代码][copycode.gif]

再往下跟踪就知道主要是根据我们熟悉的id\_table来的。

\-------------------------------另解-----------------------------------------------------------------------------------------------

从driver\_register看起，此处我的这里是：

![复制代码][copycode.gif]

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

![复制代码][copycode.gif]

klist\_init不相关，不用管他，具体再去看bus\_add\_driver：

int
       
        bus_add_driver(
       
        struct
       
        device_driver 
       
        *
       
        drv) { 
       
        //
       
        1.先kobject_set_name(&drv->kobj, "%s", drv->name); 
       
        //
       
        2.再kobject_register(&drv->kobj) 
       
        //
       
        3.然后调用了：driver_attach(drv)
       
        
       
        }

int
       
        driver_attach(
       
        struct
       
        device_driver 
       
        *
       
        drv) { 
       
        return
       
        bus_for_each_dev(drv
       
        ->
       
        bus, NULL, drv, __driver_attach); }

真正起作用的是\_\_driver\_attach：

![复制代码][copycode.gif]

static
       
        
       
        int
       
        __driver_attach(
       
        struct
       
        device 
       
        *
       
        dev, 
       
        void
       
        
       
        *
       
        data) { ... 
       
        if
       
        (
       
        !
       
        dev
       
        ->
       
        driver) driver_probe_device(drv, dev); ... } 
       
        int
       
        driver_probe_device(
       
        struct
       
        device_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); ... }

![复制代码][copycode.gif]

really\_probe才是我们要找的函数：

![复制代码][copycode.gif]

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; } 
       
        else
       
        
       
        if
       
        (drv
       
        ->
       
        probe) { 
       
        //
       
        2.再调用你的驱动中的probe函数：
       
        
       
        ret 
       
        =
       
        drv
       
        ->
       
        probe(dev); 
       
        if
       
        (ret) 
       
        goto
       
        probe_failed; } ... }

![复制代码][copycode.gif]

其中，drv->probe(dev)，才是真正调用你的驱动实现的具体的probe函数。  
也就是对应此文标题所问的，probe函数此时被调用。

声明：以下主要内容参考自：  
[关于struct device\_driver结构中的probe探测函数的调用][struct device_driver_probe]  
[http://blog.chinaunix.net/u2/71164/showart.php?id=1361188][struct device_driver_probe]

[copycode.gif]: /images/20220604/da5a4c3c81424ae280de5500ee5050e2.png
[struct device_driver_probe]: http://blog.chinaunix.net/u2/71164/showart.php?id=1361188