ITPub博客
首页 博客 专栏 学院 社区 IT新媒体评选
发博

首页 > 自动化运维 > > 网卡驱动注册到PCI总线这一过程的分析（2）

网卡驱动注册到PCI总线这一过程的分析（2）

作者：飘絮絮絮丶 时间：2020-06-22 14:39:56 0 删除 编辑

2. 网卡在PCI层的注册
2.1 数据结构
        前面第一章讲了总线、设备以及驱动方面的关系，也讲到了大多数网卡设备实际上是一个PCI设备。因此，本章就讲解网卡设备在注册时是如何注册到PCI总线上去的。在这里，以Intel的E100网卡驱动进行讲解。
        前面讲到每个PCI设备都由一组参数唯一地标识，这些参数保存在结构体pci_device_id中，如下所示：


  2. struct pci_device_id {
  3.         __u32 vendor, device;                /* Vendor and device ID or PCI_ANY_ID*/
  4.         __u32 subvendor, subdevice;        /* Subsystem ID's or PCI_ANY_ID */
  5.         __u32 class, class_mask;        /* (class,subclass,prog-if) triplet */
  6.         kernel_ulong_t driver_data;        /* Data private to the driver */
  7. };
复制代码


        每个PCI设备驱动都有一个pci_driver变量，它描述了一个PCI驱动的信息，如下所示：


  2. struct pci_driver {
  3.         struct list_head node;
  4.         char *name;
  5.         const struct pci_device_id *id_table;        /* must be non-NULL for probe to be called */
  6.         int  (*probe)  (struct pci_dev *dev, const struct pci_device_id *id);        /* New device inserted */
  7.         void (*remove) (struct pci_dev *dev);        /* Device removed (NULL if not a hot-plug capable driver) */
  8.         int  (*suspend) (struct pci_dev *dev, pm_message_t state);        /* Device suspended */
  9.         int  (*suspend_late) (struct pci_dev *dev, pm_message_t state);
  10.         int  (*resume_early) (struct pci_dev *dev);
  11.         int  (*resume) (struct pci_dev *dev);                        /* Device woken up */
  12.         int  (*enable_wake) (struct pci_dev *dev, pci_power_t state, int enable);   /* Enable wake event */
  13.         void (*shutdown) (struct pci_dev *dev);

  15.         struct pci_error_handlers *err_handler;
  16.         struct device_driver        driver;
  17.         struct pci_dynids dynids;

  19.         int multithread_probe;
  20. };
复制代码


        每个PCI驱动中都有一个id_table成员变量，记录了当前这个驱动所能够进行驱动的那些设备的ID值。
        对于E100网卡驱动来说，它的pci_driver变量定义为：


  2. static struct pci_driver e100_driver = {
  3.         .name =         DRV_NAME,
  4.         .id_table =     e100_id_table,
  5.         .probe =        e100_probe,
  6.         .remove =       __devexit_p(e100_remove),
  7. #ifdef CONFIG_PM
  8.         /* Power Management hooks */
  9.         .suspend =      e100_suspend,
  10.         .resume =       e100_resume,
  11. #endif
  12.         .shutdown =     e100_shutdown,
  13.         .err_handler = &e100_err_handler,
  14. };
复制代码


        里面e100_id_table就表示该E100驱动所能够支持的PCI设备的ID号，其定义为：


  2. #define INTEL_8255X_ETHERNET_DEVICE(device_id, ich) {\
  3.         PCI_VENDOR_ID_INTEL, device_id, PCI_ANY_ID, PCI_ANY_ID, \
  4.         PCI_CLASS_NETWORK_ETHERNET << 8, 0xFFFF00, ich }
  5. static struct pci_device_id e100_id_table[] = {
  6.         INTEL_8255X_ETHERNET_DEVICE(0x1029, 0),
  7.         INTEL_8255X_ETHERNET_DEVICE(0x1030, 0),
  8.         …
  9.         { 0, }
  10. };
复制代码


        当PCI层检测到一个PCI设备能够被某PCI驱动所支持时（这是通过函数pci_match_one_device来进行检测的），就会调用这个PCI驱动上的probe函数，在该函数中会对该特定的PCI设备进行一些具体的初始化等操作。比如对于E100设备驱动来说，其probe函数为e100_probe。在这个函数中，会对网卡设备进行初始化。
        e100_probe主要就涉及到网卡设备net_device的初始化，我们现在先来关注一下从网卡注册一直到调用e100_probe这一个过程的整个流程。
2.2 E100初始化
        E100驱动程序的初始化是在函数e100_init_module()中的，如下：


  2. static int __init e100_init_module(void)
  3. {
  4.         if(((1 << debug) - 1) & NETIF_MSG_DRV) {
  5.                 printk(KERN_INFO PFX "%s, %s\n", DRV_DESCRIPTION, DRV_VERSION);
  6.                 printk(KERN_INFO PFX "%s\n", DRV_COPYRIGHT);
  7.         }
  8.         return pci_register_driver(&e100_driver);
  9. }
复制代码


        在这个函数中，调用了pci_register_driver()函数，对e100_driver这个驱动进行注册。
2.3 PCI注册
        在前面我们已经看到，PCI的注册就是将PCI驱动程序挂载到其所在的总线的drivers链，同时扫描PCI设备，将它能够进行驱动的设备挂载到driver上的devices链表上来，这里，我们将详细地查看这整个流程的函数调用关系。
        pci_register_driver()->__pci_register_driver()


  2. /**
  3. * __pci_register_driver - register a new pci driver
  4. * @drv: the driver structure to register
  5. * @owner: owner module of drv
  6. * @mod_name: module name string
  7. * 
  8. * Adds the driver structure to the list of registered drivers.
  9. * Returns a negative value on error, otherwise 0. 
  10. * If no error occurred, the driver remains registered even if 
  11. * no device was claimed during registration.
  12. */        
  13. int __pci_register_driver(struct pci_driver *drv, struct module *owner, const char *mod_name);
  14.         在函数中有几个初始化语句：
  15.         drv->driver.name = drv->name;
  16.         drv->driver.bus = &pci_bus_type;
  17.         drv->driver.owner = owner;
  18.         drv->driver.mod_name = mod_name;
复制代码


        即是将PCI设备中的driver变量的总线指向pci_bus_type这个总线描述符，同时设置驱动的名字等。
        pci_bus_type定义如下：


  2. struct bus_type pci_bus_type = {
  3.         .name                = "pci",
  4.         .match                = pci_bus_match,
  5.         .uevent                = pci_uevent,
  6.         .probe                = pci_device_probe,
  7.         .remove                = pci_device_remove,
  8.         .suspend        = pci_device_suspend,
  9.         .suspend_late        = pci_device_suspend_late,
  10.         .resume_early        = pci_device_resume_early,
  11.         .resume                = pci_device_resume,
  12.         .shutdown        = pci_device_shutdown,
  13.         .dev_attrs        = pci_dev_attrs,
  14. };
复制代码


        然后再调用函数driver_register(&drv->driver);通过这个函数将这个PCI驱动中的struct device_driver driver成员变量注册到系统中去。
        pci_register_driver()->__pci_register_driver()->driver_register()
        driver_register()代码如下：


  2. /**
  3. *        driver_register - register driver with bus
  4. *        @drv:        driver to register
  5. *
  6. *        We pass off most of the work to the bus_add_driver() call,
  7. *        since most of the things we have to do deal with the bus
  8. *        structures.
  9. *
  10. *        The one interesting aspect is that we setup @drv->unloaded
  11. *        as a completion that gets complete when the driver reference
  12. *        count reaches 0.
  13. */
  14. int driver_register(struct device_driver * drv)
  15. {
  16.         if ((drv->bus->probe && drv->probe) ||
  17.             (drv->bus->remove && drv->remove) ||
  18.             (drv->bus->shutdown && drv->shutdown)) {
  19.                 printk(KERN_WARNING "Driver '%s' needs updating - please use bus_type methods\n", drv->name);
  20.         }
  21.         klist_init(&drv->klist_devices, NULL, NULL);
  22.         init_completion(&drv->unloaded);
  23.         return bus_add_driver(drv);
  24. }
复制代码


        klist_init()是为设备驱动的klist_devices成员进行初始化，这个klist_devices是一个对链表进行操作的包裹结构，它会链接这个驱动能够支持的那些设备。
        最后就调用bus_add_driver()函数。这个函数的功能就是将这个驱动加到其所在的总线的驱动链上。
        pci_register_driver()->__pci_register_driver()->driver_register()->bus_add_driver()->driver_attach()
        在bus_add_driver()函数中，最重要的是调用driver_attach()函数，其定义如下：


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


        该函数遍历这个驱动所在的总线上的所有设备，然后将这些设备与当前驱动进行匹配，以检测这个驱动是否能够支持某个设备，也即是将设备与驱动联系起来。
        bus_for_each_dev函数是扫描在drv->bus这个总线上的所有设备，然后将每个设备以及当前驱动这两个指针传递给__driver_attach函数。
        pci_register_driver()->__pci_register_driver()->driver_register()->bus_add_driver()->driver_attach()->__driver_attach()
        __driver_attach()函数是将驱动与设备联系起来的函数。


  2. static int __driver_attach(struct device * dev, void * data)
  3. {
  4.         struct device_driver * drv = data;

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

  16.         if (dev->parent)        /* Needed for USB */
  17.                 down(&dev->parent->sem);
  18.         down(&dev->sem);
  19.         if (!dev->driver)
  20.                 driver_probe_device(drv, dev);
  21.         up(&dev->sem);
  22.         if (dev->parent)
  23.                 up(&dev->parent->sem);

  25.         return 0;
  26. }
复制代码


        在函数中有两条语句：


  2.         if (!dev->driver)
  3.                 driver_probe_device(drv, dev);
复制代码


        也即是判断当前设备是否已经注册了一个驱动，如果没有注册驱动，则调用driver_probe_device()函数。
        pci_register_driver()->__pci_register_driver()->driver_register()->bus_add_driver()->driver_attach()->__driver_attach()->driver_probe_device()
        如下：


  2. /**
  3. * driver_probe_device - attempt to bind device & driver together
  4. * @drv: driver to bind a device to
  5. * @dev: device to try to bind to the driver
  6. *
  7. * First, we call the bus's match function, if one present, which should
  8. * compare the device IDs the driver supports with the device IDs of the
  9. * device. Note we don't do this ourselves because we don't know the
  10. * format of the ID structures, nor what is to be considered a match and
  11. * what is not.
  12. *
  13. * This function returns 1 if a match is found, an error if one occurs
  14. * (that is not -ENODEV or -ENXIO), and 0 otherwise.
  15. *
  16. * This function must be called with @dev->sem held.  When called for a
  17. * USB interface, @dev->parent->sem must be held as well.
  18. */
  19. int driver_probe_device(struct device_driver * drv, struct device * dev)
  20. {
  21.         struct stupid_thread_structure *data;
  22.         struct task_struct *probe_task;
  23.         int ret = 0;

  25.         if (!device_is_registered(dev))
  26.                 return -ENODEV;
  27.         if (drv->bus->match && !drv->bus->match(dev, drv))
  28.                 goto done;

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

  33.         data = kmalloc(sizeof(*data), GFP_KERNEL);
  34.         if (!data)
  35.                 return -ENOMEM;
  36.        >
  37.        >

  39.         if (drv->multithread_probe) {
  40.                 probe_task = kthread_run(really_probe, data,
  41.                                          "probe-%s", dev->bus_id);
  42.                 if (IS_ERR(probe_task))
  43.                         ret = really_probe(data);
  44.         } else
  45.                 ret = really_probe(data);

  47. done:
  48.         return ret;
  49. }        
复制代码


        该函数首先会调用总线上的match函数，以判断当前的PCI驱动能否支持该PCI设备，如果可以，则继续往后面执行。
        drv->bus->match函数也即是pci_bus_type中的match成员变量，它为pci_bus_match函数。
        pci_register_driver()->__pci_register_driver()->driver_register()->bus_add_driver()->driver_attach()->__driver_attach()->driver_probe_device()->pci_bus_match()


  2. /**
  3. * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
  4. * @dev: the PCI device structure to match against
  5. * @drv: the device driver to search for matching PCI device id structures
  6. * 
  7. * Used by a driver to check whether a PCI device present in the
  8. * system is in its list of supported devices. Returns the matching
  9. * pci_device_id structure or %NULL if there is no match.
  10. */
  11. static int pci_bus_match(struct device *dev, struct device_driver *drv)
  12. {
  13.         struct pci_dev *pci_dev = to_pci_dev(dev);
  14.         struct pci_driver *pci_drv = to_pci_driver(drv);
  15.         const struct pci_device_id *found_id;

  17.         found_id = pci_match_device(pci_drv, pci_dev);
  18.         if (found_id)
  19.                 return 1;

  21.         return 0;
  22. }
复制代码


        pci_bus_match函数的作用就是将PCI设备与PCI驱动进行比较以检查该驱动是否能够支持这个设备。在函数的最前面是两个宏to_pci_dev和to_pci_driver。因为在函数执行的过程中，虽然最开始传进来的是pci_driver结构与pci_dev结构，但是在执行的时候却取了这两个结构体中的device_driver和device成员变量，所以现在就要通过这两个成员变量找到之前对应的pci_driver和pci_dev结构的地址。
#define        to_pci_dev(n) container_of(n, struct pci_dev, dev)
#define        to_pci_driver(drv) container_of(drv,struct pci_driver, driver)
        这两个宏在<Linux Device Driver> 3rd书上有相应的讲解，这里也就是找到E100的pci_driver：e100_driver以及该网卡设备的pci_dev结构。现在就要对它们进行比较以看它们之间是否能够联系起来。这是通过函数pci_match_device实现的。
        pci_register_driver()->__pci_register_driver()->driver_register()->bus_add_driver()->driver_attach()->__driver_attach()->driver_probe_device()->pci_bus_match()->pci_match_device()


  2. /**
  3. * pci_match_device - Tell if a PCI device structure has a matching PCI device id structure
  4. * @drv: the PCI driver to match against
  5. * @dev: the PCI device structure to match against
  6. *
  7. * Used by a driver to check whether a PCI device present in the
  8. * system is in its list of supported devices.  Returns the matching
  9. * pci_device_id structure or %NULL if there is no match.
  10. */
  11. const struct pci_device_id *pci_match_device(struct pci_driver *drv,
  12.                                              struct pci_dev *dev)
  13. {
  14.         struct pci_dynid *dynid;

  16.         /* Look at the dynamic ids first, before the static ones */
  17.         spin_lock(&drv->dynids.lock);
  18.         list_for_each_entry(dynid, &drv->dynids.list, node) {
  19.                 if (pci_match_one_device(&dynid->id, dev)) {
  20.                         spin_unlock(&drv->dynids.lock);
  21.                         return &dynid->id;
  22.                 }
  23.         }
  24.         spin_unlock(&drv->dynids.lock);

  26.         return pci_match_id(drv->id_table, dev);
  27. }
复制代码


        pci_match_one_driver函数的作用是将一个PCI设备与PCI驱动进行比较，以查看它们是否相匹配。如果相匹配，则返回匹配的pci_device_id结构体指针。
        此时，如果该PCI驱动已经找到了一个可以想符的PCI设备，则返回，然后再退回到之前的driver_probe_device函数中。在该函数最后将调用really_probe函数。将device_driver与device结构体指针作为参数传递到这个函数中。下面几行是调用驱动或者总线的probe函数来扫描设备。
        pci_register_driver()->__pci_register_driver()->driver_register()->bus_add_driver()->driver_attach()->__driver_attach()->driver_probe_device()->really_probe()
        在函数really_probe()中：


  2.         if (dev->bus->probe) {
  3.                 ret = dev->bus->probe(dev);
  4.                 if (ret)
  5.                         goto probe_failed;
  6.         } else if (drv->probe) {
  7.                 ret = drv->probe(dev);
  8.                 if (ret)
  9.                         goto probe_failed;
  10.         }
复制代码


        此时的dev->bus为pci_bus_type，其probe函数则对应为：pci_device_probe。
        pci_register_driver()->__pci_register_driver()->driver_register()->bus_add_driver()->driver_attach()->__driver_attach()->driver_probe_device()->really_probe()->pci_device_probe()
        同样，在该函数中会获得当前的PCI设备的pci_dev结构体指针以及PCI驱动程序的pci_driver结构体指针。分别使用宏to_pci_dev和to_pci_driver。最后则调用函数__pci_device_probe。在该函数中还会调用函数pci_call_probe，这是最后的函数
        pci_register_driver()->__pci_register_driver()->driver_register()->bus_add_driver()->driver_attach()->__driver_attach()->driver_probe_device()->really_probe()->pci_device_probe()->__pci_device_probe()->pci_call_probe()
        在函数pci_call_probe里有一条语句：


  2. static int pci_call_probe(struct pci_driver *drv, struct pci_dev *dev,
  3.                           const struct pci_device_id *id)
  4. {
  5.         int error;
  6. /*  省略  */
  7.         error = drv->probe(dev, id);
复制代码


        在此处就调用了pci_driver的probe函数，对于这里的E100驱动来说，它的probe函数是最开始注册的e100_probe函数，在该函数中会完成对网卡设备net_device的初始化等操作。


  2.         pci_register_driver()->__pci_register_driver()->driver_register()->bus_add_driver()->driver_attach()->__driver_attach()->driver_probe_device()->really_probe()->pci_device_probe()->__pci_device_probe()->pci_call_probe()->e100_probe()
复制代码


        到这里，我们对网卡驱动的PCI层的初始化分析就告一个段落了，剩下的部分就是网卡驱动对网卡设备本身的初始化等操作。  


文章来源CU社区：网卡驱动注册到PCI总线这一过程的分析

来自 “ ITPUB博客 ” ，链接：https://blog.itpub.net/69946831/viewspace-3146363/ ，如需转载，请注明出处，否则将追究法律责任。

0
0
上一篇： 给新手学习MySQL的建议
下一篇： 如何使用ZODB
请登录后发表评论 登录
全部评论
飘絮絮絮丶

注册时间：2019-09-09

  • 博文量
    2646
  • 访问量
    42319

最新文章

支持我们 作者招募 用户协议 FAQ Contact Us

北京盛拓优讯信息技术有限公司. 版权所有  京ICP备16024965号-8 北京市公安局海淀分局网监中心备案编号：11010802021510 niuxiaotong@pcpop.com 17352615567 未成年人举报专区

广播电视节目制作经营许可证(京) 字第1234号 中国互联网协会会员

违法和不良信息举报电话:18101376593