1、打开“drivers/of/base.c”
#define of_prop_cmp(s1, s2) strcmp((s1), (s2))
/*如果s1小于s2,则返回值小于0。
如果s1大于s2,则返回值大于0。
如果s1等于s2,则返回值等于0。*/
//函数功能:根据所给的“设备树的节点np”和“properties名字”在设备树里查找是否有“properties名字”
//np是指向设备树的节点
//name是指向要查找的properties名字
//lenp用来返回properties名字的长度
static struct property *__of_find_property(const struct device_node *np,
const char *name, int *lenp)
{
struct property *pp;
if (!np)return NULL;
for (pp = np->properties; pp; pp = pp->next)
{
if (of_prop_cmp(pp->name, name) == 0)
{ //如果pp->name等于name,则返回值等于0。
if (lenp) *lenp = pp->length;//保存properties名字的长度
break;
}
}
return pp;//返回property结构指针
}
const char *of_prop_next_string(struct property *prop, const char *cur)
{
const void *curv = cur;
if (!prop)return NULL;//如果prop=NULL，则返回NULL
if (!cur)return prop->value;//如果prop=NULL，则返回prop->value
curv += strlen(cur) + 1;//求cur字符串的长度,包括结束符;
if (curv >= prop->value + prop->length)//所给字符串的长度
return NULL;
return curv;
}
/*函数功能:根据name，在np指向的节点查找name所指向的字符串;返回属性名字的长度
保存在lenp中,并返回属性的指针值*/
static struct property *__of_find_property(const struct device_node *np,
const char *name, int *lenp)
{
struct property *pp;
if (!np) return NULL;//如果np=NULL，则返回NULL
for (pp = np->properties; pp; pp = pp->next)
{ /*np->properties指向属性*/
if (of_prop_cmp(pp->name, name) == 0)
{
/*根据所给的“设备树的节点np”和“name所指向的名字”在设备树里查找是否有“name所指向的名字”*/
if (lenp) *lenp = pp->length;//返回属性名字的长度
break;
}
}
return pp;
}
/*根据所给的节点查找给定名字的属性
* Find a property with a given name for a given node
* and return the value.
*/
const void *__of_get_property(const struct device_node *np,
const char *name, int *lenp)
{
struct property *pp = __of_find_property(np, name, lenp);
/*函数功能:根据name，在np指向的节点查找name所指向的字符串;返回属性名字的长度
保存在lenp中,并返回属性的指针值*/
return pp ? pp->value : NULL;
//如果pp!=NULL，则返回pp->value
}
//函数功能:如果根据所给的节点查找到了属性名为type,则返回1
static bool __of_node_is_type(const struct device_node *np, const char *type)
{
const char *match = __of_get_property(np, "device_type", NULL);
//根据所给的节点np查找device_type的属性,match=np->value
return np && match && type && !strcmp(match, type);
//np->value和type相同，返回1
}
//检查节点是否匹配所给的“name”,匹配则返回1;
bool of_node_name_eq(const struct device_node *np, const char *name)
{
const char *node_name;
size_t len;
if (!np)return false;
node_name = kbasename(np->full_name);//从np->full_name中提取名字;
len = strchrnul(node_name, '@') - node_name;//计算节点名字的长度
return (strlen(name) == len) && (strncmp(node_name, name, len) == 0);
//检查是否找到name所指向的字符串，匹配则返回1
}
#define INT_MAX 0x7fffffff
/**
函数功能:检查节点是否匹配所给的“compat，type和name”;
device: 指向节点的指针;
compat: 是compatible的缩写,要求匹配的字符串, 也可能是NULL或者是"";
type: 要求匹配的device_type值, 也可能是NULL或者是"";
name: 要求匹配的节点名字, 也可能是NULL或者是"";
返回值为0，表示不匹配;返回值大于0，表示匹配;
* 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匹配具有最高优先级 */
if (compat && compat[0])//如果compat!=NULL,且compat[0]>0，则执行
{
prop = __of_find_property(device, "compatible", NULL);
/*根据所给的“设备树的节点device”和“properties名字compatible”在设备树里查找是否有“compatible”;
返回值是property结构指针
*/
for (cp = of_prop_next_string(prop, NULL); cp;
cp = of_prop_next_string(prop, cp), index++)
{
/*of_prop_next_string(prop, NULL)执行后cp=prop->value;*/
/*of_prop_next_string(prop, cp)cp=cp+strlen(cp) + 1;指向下一个prop->value*/
if (of_compat_cmp(cp, compat, strlen(compat)) == 0)
{ /*根据所给的“设备树的节点cp”和“compat所指向的名字”在设备树里查找是否有“compat所指向的名字”*/
score = INT_MAX/2 - (index << 2);
break;
}
}
if (!score)return 0;
}
/*匹配type比匹配的name的优先级要高;Matching type is better than matching name */
if (type && type[0])//如果type!=NULL,且type[0]>0，则执行
{
if (!__of_node_is_type(device, type))return 0;
//如果根据所给的device节点查找到了属性名为type,则返回1;
score += 2;
}
/* 要匹配的名字,Matching name is a bit better than not */
if (name && name[0])//如果name!=NULL,且name[0]>0，则执行
{
if (!of_node_name_eq(device, name))return 0;
//of_node_name_eq()检查节点是否匹配所给的“name”,匹配则返回1;
score++;
}
return score;
}
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;
for (; matches->name[0] || matches->type[0] || matches->compatible[0]; matches++) {
score = __of_device_is_compatible(node, matches->compatible,
matches->type, matches->name);
/*检查节点是否匹配所给的“compat，type和name”;*/
if (score > best_score) {
best_match = matches;
best_score = score;
}
}
return best_match;
}
/**判断device_node是否具有匹配的of_match结构
* 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;
}
2、打开“drivers/of/device.c”
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);
/*使用of_match_node函数查找匹配的设备ID*/
}
const void *of_device_get_match_data(const struct device *dev)
{
const struct of_device_id *match;
match = of_match_device(dev->driver->of_match_table, dev);
if (!match)
return NULL;
return match->data;
}
