linux通过platform_match()匹配platform总线上的device和driver

悠悠 2023-01-13 01:53 73阅读 0赞

\\kernel\\msm-4.9\\drivers\\base\\platform.c定义了platform\_match()的实现，先来看定义

/**
     * platform_match - bind platform device to platform driver.
     * @dev: device.
     * @drv: driver.
     *
     * Platform device IDs are assumed to be encoded like this:
     * "<name><instance>", where <name> is a short description of the type of
    * device, like "pci" or "floppy", and <instance> is the enumerated
     * instance of the device, like '0' or '42'.  Driver IDs are simply
     * "<name>".  So, extract the <name> from the platform_device structure,
     * and compare it against the name of the driver. Return whether they match
     * or not.
     */
    static int platform_match(struct device *dev, struct device_driver *drv)
    {
    	struct platform_device *pdev = to_platform_device(dev);
    	struct platform_driver *pdrv = to_platform_driver(drv);
    
        /* When driver_override is set, only bind to the matching driver */
    	if (pdev->driver_override)
    		return !strcmp(pdev->driver_override, drv->name);
    
    	/* Attempt an OF style match first */
        //第1种匹配方式，OF类型匹配，设备树采用的匹配方式
    	if (of_driver_match_device(dev, drv))
    		return 1;
    
        /* Then try ACPI style match */
        //第2种匹配方式，ACPI匹配
    	if (acpi_driver_match_device(dev, drv))
    		return 1;
    
    	/* Then try to match against the id table */
        //第3种匹配方式，id_table匹配
    	if (pdrv->id_table)
    		return platform_match_id(pdrv->id_table, pdev) != NULL;
    
        	/* fall-back to driver name match */
        //第4种匹配方式，直接比较驱动和设备的name字段
    	return (strcmp(pdev->name, drv->name) == 0);
    }

可以看到，platform\_match可以使用四种匹配方式

第1种：OF类型匹配，设备树采用的匹配方式

kernel\\msm-4.9\\include\\linux\\of\_device.h\\of\_driver\_match\_device()定义如下：

/**
     * of_driver_match_device - Tell if a driver's of_match_table matches a device.
     * @drv: the device_driver structure to test
     * @dev: the device structure to match against
     */
    static inline int of_driver_match_device(struct device *dev,
    					 const struct device_driver *drv)
    {
    	return of_match_device(drv->of_match_table, dev) != NULL;
    }

调用of\_match\_device(drv->of\_match\_table, dev)来实现匹配，此函数在kernel\\msm-4.9\\drivers\\of\\device.c种定义

/**
     * of_match_device - Tell if a struct device matches an of_device_id list
     * @ids: array of of device match structures to search in
     * @dev: the of device structure to match against
     *
     * Used by a driver to check whether an platform_device present in the
     * system is in its list of supported devices.
     */
    const struct of_device_id *of_match_device(const struct of_device_id *matches,
    					   const struct device *dev)
    {
    	if ((!matches) || (!dev->of_node))
    		return NULL;
    	return of_match_node(matches, dev->of_node);
    }
    EXPORT_SYMBOL(of_match_device);

这里调用of\_match\_node()，此函数在kernel\\msm-4.9\\drivers\\of\\base.c中定义

/**
     * of_match_node - Tell if a device_node has a matching of_match structure
     *	@matches:	array of of device match structures to search in
     *	@node:		the of device structure to match against
     *
     *	Low level utility function used by device matching.
     */
    const struct of_device_id *of_match_node(const struct of_device_id *matches,
    					 const struct device_node *node)
    {
    	const struct of_device_id *match;
    	unsigned long flags;
    
        raw_spin_lock_irqsave(&devtree_lock, flags);
    	match = __of_match_node(matches, node);
    	raw_spin_unlock_irqrestore(&devtree_lock, flags);
    	return match;
    }
    EXPORT_SYMBOL(of_match_node);

调用\_\_of\_match\_node()，此函数在kernel\\msm-4.9\\drivers\\of\\base.c中定义

static
    const struct of_device_id *__of_match_node(const struct of_device_id *matches,
    					   const struct device_node *node)
    {
    	const struct of_device_id *best_match = NULL;
    	int score, best_score = 0;
    
        if (!matches)
    		return NULL;
        //name,type,compatible需要有一个非NULL。
    	for (; matches->name[0] || matches->type[0] || matches->compatible[0]; matches++) {
    		score = __of_device_is_compatible(node, matches->compatible,
    						  matches->type, matches->name);
    		if (score > best_score) {
    			best_match = matches;
    			best_score = score;
    		}
    	}
    
        	return best_match;
    }

调用 \_\_of\_device\_is\_compatible(node, matches->compatible, matches->type, matches->name)，此函数在kernel\\msm-4.9\\drivers\\of\\base.c中定义

/**
     * __of_device_is_compatible() - Check if the node matches given constraints
     * @device: pointer to node
     * @compat: required compatible string, NULL or "" for any match
     * @type: required device_type value, NULL or "" for any match
     * @name: required node name, NULL or "" for any match
     *
     * Checks if the given @compat, @type and @name strings match the
     * properties of the given @device. A constraints can be skipped by
     * passing NULL or an empty string as the constraint.
     *
     * Returns 0 for no match, and a positive integer on match. The return
     * value is a relative score with larger values indicating better
     * matches. The score is weighted for the most specific compatible value
     * to get the highest score. Matching type is next, followed by matching
     * name. Practically speaking, this results in the following priority
     * order for matches:
     *
     * 1. specific compatible && type && name
     * 2. specific compatible && type
     * 3. specific compatible && name
     * 4. specific compatible
     * 5. general compatible && type && name
     * 6. general compatible && type
     * 7. general compatible && name
     * 8. general compatible
     * 9. type && name
     * 10. type
     * 11. name
     */
    static int __of_device_is_compatible(const struct device_node *device,
    				     const char *compat, const char *type, const char *name)
    {
    	struct property *prop;
    	const char *cp;
    	int index = 0, score = 0;
    
        /* Compatible match has highest priority */
        if (compat && compat[0]) {
    		prop = __of_find_property(device, "compatible", NULL);
            for (cp = of_prop_next_string(prop, NULL); cp;
    		     cp = of_prop_next_string(prop, cp), index++) {
    			if (of_compat_cmp(cp, compat, strlen(compat)) == 0) {
    				score = INT_MAX/2 - (index << 2);
    				break;
    			}
    		}
        
        	if (!score)
    			return 0;
    	}
    
        /* Matching type is better than matching name */
    	if (type && type[0]) {
    		if (!device->type || of_node_cmp(type, device->type))
    			return 0;
    		score += 2;
    	}
    
        /* Matching name is a bit better than not */
    	if (name && name[0]) {
    		if (!device->name || of_node_cmp(name, device->name))
    			return 0;
    		score++;
    	}
    
    	return score;
    }

先判断设备节点compatible属性的值和驱动中of\_match\_table的compatible成员是否相等

下面是设备节点的compatible属性：

gpio_control {
    		compatible = "gpio-control";
            ...
    }

下面是驱动中of\_match\_table的compatible成员

static const struct of_device_id gpio_control_of_match[] = {
    	{ .compatible = "gpio-control", },
    	{ },
    };
    
    static struct platform_driver gpio_control_device_driver = {
    	.probe		= gpio_control_probe,
    	.remove		= gpio_control_remove,
        .driver		= {
    		.name	= "gpio-control",
    		.owner	= THIS_MODULE,
    		.pm	= &gpio_control_pm_ops,
    		.of_match_table = of_match_ptr(gpio_control_of_match),
    	}
    };

后面判断type和name。

第2种：ACPI匹配

kernel\\msm-4.9\\drivers\\acpi\\bus.c定义了acpi\_driver\_match\_device()的实现

第3种：id\_table匹配

kernel\\msm-4.9\\drivers\\base\\platform.c定义了platform\_match\_id的实现()

static const struct platform_device_id *platform_match_id(
    			const struct platform_device_id *id,
    			struct platform_device *pdev)
    {
    
        	while (id->name[0]) {
    		if (strcmp(pdev->name, id->name) == 0) {
    			pdev->id_entry = id;
    			return id;
    		}
    		id++;
    	}
    	return NULL;
    }