驱动模型匹配过程

我会带着你远行 2022-12-26 08:20 137阅读 0赞

#device方面：
    platform_device_register(struct platform_device *dev)
    ------platform_device_add(pdev)；
    ----------device_add(&pdev->dev);
    --------------bus_probe_device(dev);
    -------------------device_attach(dev);
    -------------------------bus_for_each_drv(dev->bus, NULL, dev, __device_attach);
    -------------------------------driver_match_device(drv, dev)；成功才向下执行probe！
    -------------------------------------driver_probe_device(drv, dev);
    --------------------------------------------really_probe(dev, drv);
    ----------------------------------------------------dev->bus->probe(dev);或者drv->probe(dev);platform_device_add(pdev)；
    
    #driver方面：
    platform_driver_register(struct platform_driver * drv)
    --------driver_register(&drv->driver);
    ------------bus_add_driver(drv);
    -----------------driver_attach(drv);
    ------------------------bus_for_each_dev(drv->bus, NULL, drv, __driver_attach); 遍历所有节点!
    -------------------------------driver_match_device(drv, dev)；成功才向下执行probe！
    ---------------------------------------driver_probe_device(drv, dev);
    ------------------------------------------------really_probe(dev, drv);
    ---------------------------------------------------------dev->bus->probe(dev);或者drv->probe(dev);
    
    
    
    driver_match_device()  是匹配的关键，实质是上执行：
    --------return drv->bus->match ? drv->bus->match(dev, drv) : 1;
    ------------------.match = platform_match  最终调用bus中的platform_match函数来匹配。
    
    
    bus_for_each_drv/dev()  函数中：
    ---------while ((dev = next_device(&i)) && !error)  遍历所有节点;

代码跟踪：

static struct platform_driver cobalt_raq_led_driver = {
    	.probe	= cobalt_raq_led_probe,
    	.driver = {
    		.name	= "cobalt-raq-leds",
    	},
    };

static int __init cobalt_raq_led_init(void)
    {
    	return platform_driver_register(&cobalt_raq_led_driver);
    }

#define platform_driver_register(drv) \
    	__platform_driver_register(drv, THIS_MODULE)
    extern int __platform_driver_register(struct platform_driver *,
    					struct module *);

/**
     * __platform_driver_register - register a driver for platform-level devices
     * @drv: platform driver structure
     * @owner: owning module/driver
     */
    int __platform_driver_register(struct platform_driver *drv,
    				struct module *owner)
    {
    	drv->driver.owner = owner;
    	drv->driver.bus = &platform_bus_type;
    	drv->driver.probe = platform_drv_probe;
    	drv->driver.remove = platform_drv_remove;
    	drv->driver.shutdown = platform_drv_shutdown;
    
    	return driver_register(&drv->driver);
    }
    EXPORT_SYMBOL_GPL(__platform_driver_register);

/**
     * 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)
    {
    	int ret;
    	struct device_driver *other;
    
    	BUG_ON(!drv->bus->p);
    
    	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);
    	if (other) {
    		printk(KERN_ERR "Error: Driver '%s' is already registered, "
    			"aborting...\n", drv->name);
    		return -EBUSY;
    	}
    
    	ret = bus_add_driver(drv);
    	if (ret)
    		return ret;
    	ret = driver_add_groups(drv, drv->groups);
    	if (ret) {
    		bus_remove_driver(drv);
    		return ret;
    	}
    	kobject_uevent(&drv->p->kobj, KOBJ_ADD);
    
    	return ret;
    }
    EXPORT_SYMBOL_GPL(driver_register);

/**
     * bus_add_driver - Add a driver to the bus.
     * @drv: driver.
     */
    int bus_add_driver(struct device_driver *drv)
    {
    	struct bus_type *bus;
    	struct driver_private *priv;
    	int error = 0;
    
    	bus = bus_get(drv->bus);
    	if (!bus)
    		return -EINVAL;
    
    	pr_debug("bus: '%s': add driver %s\n", bus->name, drv->name);
    
    	priv = kzalloc(sizeof(*priv), GFP_KERNEL);
    	if (!priv) {
    		error = -ENOMEM;
    		goto out_put_bus;
    	}
    	klist_init(&priv->klist_devices, NULL, NULL);
    	priv->driver = drv;
    	drv->p = priv;
    	priv->kobj.kset = bus->p->drivers_kset;
    	error = kobject_init_and_add(&priv->kobj, &driver_ktype, NULL,
    				     "%s", drv->name);
    	if (error)
    		goto out_unregister;
    
    	klist_add_tail(&priv->knode_bus, &bus->p->klist_drivers);
    	if (drv->bus->p->drivers_autoprobe) {
    		if (driver_allows_async_probing(drv)) {
    			pr_debug("bus: '%s': probing driver %s asynchronously\n",
    				drv->bus->name, drv->name);
    			async_schedule(driver_attach_async, drv);
    		} else {
    			error = driver_attach(drv);
    			if (error)
    				goto out_unregister;
    		}
    	}
    	module_add_driver(drv->owner, drv);
    
    	error = driver_create_file(drv, &driver_attr_uevent);
    	if (error) {
    		printk(KERN_ERR "%s: uevent attr (%s) failed\n",
    			__func__, drv->name);
    	}
    	error = driver_add_groups(drv, bus->drv_groups);
    	if (error) {
    		/* How the hell do we get out of this pickle? Give up */
    		printk(KERN_ERR "%s: driver_create_groups(%s) failed\n",
    			__func__, drv->name);
    	}
    
    	if (!drv->suppress_bind_attrs) {
    		error = add_bind_files(drv);
    		if (error) {
    			/* Ditto */
    			printk(KERN_ERR "%s: add_bind_files(%s) failed\n",
    				__func__, drv->name);
    		}
    	}
    
    	return 0;
    
    out_unregister:
    	kobject_put(&priv->kobj);
    	/* drv->p is freed in driver_release()  */
    	drv->p = NULL;
    out_put_bus:
    	bus_put(bus);
    	return error;
    }

/**
     * 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);
    }
    EXPORT_SYMBOL_GPL(driver_attach);

其中\_\_dirver\_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 (!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;
    }

/**
     * bus_for_each_dev - device iterator.
     * @bus: bus type.
     * @start: device to start iterating from.
     * @data: data for the callback.
     * @fn: function to be called for each device.
     *
     * Iterate over @bus's list of devices, and call @fn for each,
     * passing it @data. If @start is not NULL, we use that device to
     * begin iterating from.
     *
     * We check the return of @fn each time. If it returns anything
     * other than 0, we break out and return that value.
     *
     * NOTE: The device that returns a non-zero value is not retained
     * in any way, nor is its refcount incremented. If the caller needs
     * to retain this data, it should do so, and increment the reference
     * count in the supplied callback.
     */
    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 || !bus->p)
    		return -EINVAL;
    
    	klist_iter_init_node(&bus->p->klist_devices, &i,
    			     (start ? &start->p->knode_bus : NULL));
    	while ((dev = next_device(&i)) && !error)
    		error = fn(dev, data);
    	klist_iter_exit(&i);
    	return error;
    }
    
    EXPORT_SYMBOL_GPL(bus_for_each_dev);

接下来调用很关键

static inline int driver_match_device(struct device_driver *drv,
    				      struct device *dev)
    {
    	return drv->bus->match ? drv->bus->match(dev, drv) : 1;
    }

调用到了match方法。。。。。。