（DT系列四）驱动加载中, 如何取得device tree中的属性

 

本文以At91rm9200平台为例，从源码实现的角度来分析驱动加载时，Device tree的属性是如何取得的。
一：系统级初始化
DT_MACHINE_START 主要是定义"struct machine_desc"的类型，放在 section(".arch.info.init")，是初始化数据，Kernel 起来之后将被丢弃。
#define DT_MACHINE_START(_name, _namestr) \
static const struct machine_desc __mach_desc_##_name\
 __used \
 __attribute__((__section__(".arch.info.init"))) = {\
.nr = ~0,\
.name = _namestr,


1,
DT_MACHINE_START(at91sam_dt, "Atmel AT91SAM (Device Tree)")
/* Maintainer: Atmel */
.timer = &at91sam926x_timer,
.map_io = at91_map_io,
.init_early = at91_dt_initialize,
.init_irq = at91_dt_init_irq,
.init_machine = at91_dt_device_init,
.dt_compat = at91_dt_board_compat,
MACHINE_END


2,
void __init at91_map_io(void)
{
/* Map peripherals */
iotable_init(&at91_io_desc, 1);


at91_soc_initdata.type = AT91_SOC_NONE;
at91_soc_initdata.subtype = AT91_SOC_SUBTYPE_NONE;


soc_detect(AT91_BASE_DBGU0);
if (!at91_soc_is_detected())
soc_detect(AT91_BASE_DBGU1);


if (!at91_soc_is_detected())
panic("AT91: Impossible to detect the SOC type");


pr_info("AT91: Detected soc type: %s\n",
at91_get_soc_type(&at91_soc_initdata));
pr_info("AT91: Detected soc subtype: %s\n",
at91_get_soc_subtype(&at91_soc_initdata));


if (!at91_soc_is_enabled())
panic("AT91: Soc not enabled");


if (at91_boot_soc.map_io)
at91_boot_soc.map_io();
}


3,
static void __init soc_detect(u32 dbgu_base)
{
u32 cidr, socid;


cidr = __raw_readl(AT91_IO_P2V(dbgu_base) + AT91_DBGU_CIDR);
socid = cidr & ~AT91_CIDR_VERSION;


switch (socid) {
case ARCH_ID_AT91RM9200:
at91_soc_initdata.type = AT91_SOC_RM9200;
at91_boot_soc = at91rm9200_soc;
break;


case ARCH_ID_AT91SAM9260:
at91_soc_initdata.type = AT91_SOC_SAM9260;
at91_boot_soc = at91sam9260_soc;
break;
}
}


4,
static inline int at91_soc_is_enabled(void)
{
return at91_boot_soc.init != NULL;
}


5,
Arch/arm/mach-at91/At91rm9200.c
struct at91_init_soc __initdata at91rm9200_soc = {
.map_io = at91rm9200_map_io,
.default_irq_priority = at91rm9200_default_irq_priority,
.ioremap_registers = at91rm9200_ioremap_registers,
.register_clocks = at91rm9200_register_clocks,
.init = at91rm9200_initialize,
};


二，硬件的实际但简单的初始化
6,
static void __init at91rm9200_initialize(void)
{
arm_pm_idle = at91rm9200_idle;
arm_pm_restart = at91rm9200_restart;


/* 初始化GPIO 子系统*/
at91_gpio_init(at91rm9200_gpio,
cpu_is_at91rm9200_bga() ? AT91RM9200_BGA : AT91RM9200_PQFP);
}


7,
/*
 * 该函数被特定的处理器初始化时调用，用来使能GPIO 引脚的支持.
 */
void __init at91_gpio_init(struct at91_gpio_bank *data, int nr_banks)
{
unsigned i;
struct at91_gpio_chip *at91_gpio, *last = NULL;


BUG_ON(nr_banks > MAX_GPIO_BANKS);


if (of_at91_gpio_init() < 0) {
/* No GPIO controller found in device tree */
for (i = 0; i < nr_banks; i++)
at91_gpio_init_one(i, data[i].regbase, data[i].id);
}


for (i = 0; i < gpio_banks; i++) {
at91_gpio = &gpio_chip[i];


/*
* GPIO controller are grouped on some SoC:
* PIOC, PIOD and PIOE can share the same IRQ line
*/
if (last && last->pioc_hwirq == at91_gpio->pioc_hwirq)
last->next = at91_gpio;
last = at91_gpio;


gpiochip_add(&at91_gpio->chip);
}
}


8,
static int __init of_at91_gpio_init(void)
{
struct device_node *np = NULL;


/*
* This isn't ideal, but it gets things hooked up until this
* driver is converted into a platform_device
*/
/*1，对每个节点进行属性的查询操作
  2，钩子函数使用的场景：驱动加载时，device node生成相应的platform device。*/
for_each_compatible_node(np, NULL, "atmel,at91rm9200-gpio")
of_at91_gpio_init_one(np);


return gpio_banks > 0 ? 0 : -EINVAL;
}


三，实际的属性查找过程
9,
#define for_each_compatible_node(dn, type, compatible) \
for (dn = of_find_compatible_node(NULL, type, compatible); dn; \
    dn = of_find_compatible_node(dn, type, compatible))


10,
/**
 * of_find_compatible_node - Find a node based on type and one of the
 *                                tokens in its "compatible" property
 * @from: The node to start searching from or NULL, the node
 * you pass will not be searched, only the next one
 * will; typically, you pass what the previous call
 * returned. of_node_put() will be called on it
 * @type: The type string to match "device_type" or NULL to ignore
 * @compatible:The string to match to one of the tokens in the device
 * "compatible" list.
 *
 * Returns a node pointer with refcount incremented, use
 * of_node_put() on it when done.
 */
//通过type参数找到相应类型的节点，并且节点的一个tokens在参数compatible属性中。
struct device_node *of_find_compatible_node(struct device_node *from,
const char *type, const char *compatible)
{
struct device_node *np;


read_lock(&devtree_lock);
np = from ? from->allnext : allnodes;
for (; np; np = np->allnext) {
//通过类型找相应节点
if (type
   && !(np->type && (of_node_cmp(np->type, type) == 0)))
continue;
//通过属性找相应节点
if (of_device_is_compatible(np, compatible) && of_node_get(np))
break;
}
of_node_put(from);
read_unlock(&devtree_lock);
return np;
}


11,
// 核查所给的"compat" 字符串能否匹配某个device node中的"compatible" 属性。
int of_device_is_compatible(const struct device_node *device,
const char *compat)
{
const char* cp;
int cplen, l;


// 通过所给的名字找到相应节点的属性
cp = of_get_property(device, "compatible", &cplen);
if (cp == NULL)
return 0;
while (cplen > 0) {


//重新验证其compatible属性是否匹配
if (of_compat_cmp(cp, compat, strlen(compat)) == 0)
return 1;
l = strlen(cp) + 1;
cp += l;
cplen -= l;
}


return 0;
}


12,
/*
 * 通过所给的名字找到相应节点的属性，并返回其数值。若没有找到，则返回NULL。
 */
const void *of_get_property(const struct device_node *np, const char *name,
int *lenp)
{
//此函数是真正去找device tree中对应的属性
struct property *pp = of_find_property(np, name, lenp);


return pp ? pp->value : NULL;
}


13, //从函数定义上看，比of_get_property（）不同的是返回值变为property。
struct property *of_find_property(const struct device_node *np,
 const char *name,
 int *lenp)
{
struct property *pp;


if (!np)
return NULL;


read_lock(&devtree_lock);
for (pp = np->properties; pp != 0; pp = pp->next) {
//调用基本的字符串比较函数
if (of_prop_cmp(pp->name, name) == 0) {
if (lenp != 0)
*lenp = pp->length;
break;
}
}
read_unlock(&devtree_lock);


return pp;
}


14, //庐山真面目的property结构体
struct property {
char *name;
int length;
void *value;
struct property *next;
unsigned long _flags;
unsigned int unique_id;
};


15, //多了一层封装，这应该是遵从了Linux kernel的编码规范，待确认。
#define of_prop_cmp(s1, s2) strcasecmp((s1), (s2))


16, //忽略字母大小写的字符串比较。
int strcasecmp(const char *s1, const char *s2)
{
int c1, c2;


do {
c1 = tolower(*s1++);
c2 = tolower(*s2++);
} while (c1 == c2 && c1 != 0);
return c1 - c2;
}


四，真正的通过属性来执行硬件初始化
17，（从函数8转过来的）
最终回到第八个函数的调用： for_each_compatible_node（）
之后执行此函数： of_at91_gpio_init_one（）
//找到相应的属性，并以此属性进行相应的初始化等操作......
static void __init of_at91_gpio_init_one(struct device_node *np)
{
int alias_idx;
struct at91_gpio_chip *at91_gpio;


if (!np)
return;


alias_idx =  of_alias_get_id(np, "gpio");
if (alias_idx >= MAX_GPIO_BANKS) {
pr_err("at91_gpio, failed alias idx(%d) > MAX_GPIO_BANKS(%d), ignoring.\n",
alias_idx, MAX_GPIO_BANKS);
return;
}


at91_gpio = &gpio_chip[alias_idx];
at91_gpio->chip.base = alias_idx * at91_gpio->chip.ngpio;


at91_gpio->regbase = of_iomap(np, 0);
if (!at91_gpio->regbase) {
pr_err("at91_gpio.%d, failed to map registers, ignoring.\n",
alias_idx);
return;
}


/* 获得中断属性*/
if (of_property_read_u32(np, "interrupts", &at91_gpio->pioc_hwirq)) {
pr_err("at91_gpio.%d, failed to get interrupts property, ignoring.\n",
alias_idx);
goto ioremap_err;
}


/* 从compatibility属性里获得相关“能力” */
if (of_device_is_compatible(np, "atmel,at91sam9x5-gpio"))
at91_gpio_caps |= AT91_GPIO_CAP_PIO3;


/* 设置clock */
if (at91_gpio_setup_clk(alias_idx))
goto ioremap_err;


at91_gpio->chip.of_node = np;
gpio_banks = max(gpio_banks, alias_idx + 1);
at91_gpio->pioc_idx = alias_idx;
return;


ioremap_err:
iounmap(at91_gpio->regbase);
}


五，具体任务及相关参考
以上从四个部分，通过追踪代码，一一先后的叙述了device tree中的属性如何获得，并起到相应的作用。下面将从工作任务的角度来分析：
任务:
驱动加载中取得device tree中的属性，有哪些关键的函数，各个函数
的用法是什么。函数的实现原理是什么


相关参考：
关键的函数：
1，
//对每个节点进行属性的查询操作
for_each_compatible_node(np, NULL, "atmel,at91rm9200-gpio")
2，
//通过type参数找到相应类型的节点，并且节点的一个tokens在参数compatible属性中。
of_find_compatible_node(NULL, type, compatible)
3，
// 核查所给的"compat" 字符串能否匹配某个device node中的"compatible" 属性。
of_device_is_compatible(np, compatible) && of_node_get(np))
4，
// 通过所给的名字找到相应节点的属性
of_get_property(device, "compatible", &cplen);
5，
//从函数定义上看，比of_get_property（）不同的是返回值变为property。
of_find_property(np, name, lenp);


各个函数的用法相对简单，属于层层调用。最终的实现都是调用相应的字符串比较函数。这里写的相对简单，以后再丰富。