sysmo-bts
/
u-boot
9
0
Fork 0
Code Pull Requests Releases Activity

Merge git://git.denx.de/u-boot-fdt

This commit is contained in:
Tom Rini 2016-10-13 20:03:33 -04:00
parent 44afdc4a12 42b7600d62
commit 4504062b27
38 changed files with 299 additions and 222 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
arch/arm/mach-tegra/xusb-padctl-common.c
View File

@ -78,11 +78,11 @@ tegra_xusb_padctl_group_parse_dt(struct tegra_xusb_padctl *padctl,
const void *fdt, int node)
{
unsigned int i;
int len, err;
int len;
group->name = fdt_get_name(fdt, node, &len);
len = fdt_count_strings(fdt, node, "nvidia,lanes");
len = fdt_stringlist_count(fdt, node, "nvidia,lanes");
if (len < 0) {
error("failed to parse \"nvidia,lanes\" property");
return -EINVAL;
@ -91,9 +91,9 @@ tegra_xusb_padctl_group_parse_dt(struct tegra_xusb_padctl *padctl,
group->num_pins = len;
for (i = 0; i < group->num_pins; i++) {
err = fdt_get_string_index(fdt, node, "nvidia,lanes", i,
&group->pins[i]);
if (err < 0) {
group->pins[i] = fdt_stringlist_get(fdt, node, "nvidia,lanes",
i, NULL);
if (!group->pins[i]) {
error("failed to read string from \"nvidia,lanes\" property");
return -EINVAL;
}
@ -101,8 +101,8 @@ tegra_xusb_padctl_group_parse_dt(struct tegra_xusb_padctl *padctl,
group->num_pins = len;
err = fdt_get_string(fdt, node, "nvidia,function", &group->func);
if (err < 0) {
group->func = fdt_stringlist_get(fdt, node, "nvidia,function", 0, NULL);
if (!group->func) {
error("failed to parse \"nvidia,func\" property");
return -EINVAL;
}
@ -223,7 +223,7 @@ tegra_xusb_padctl_config_parse_dt(struct tegra_xusb_padctl *padctl,
config->name = fdt_get_name(fdt, node, NULL);
fdt_for_each_subnode(fdt, subnode, node) {
fdt_for_each_subnode(subnode, fdt, node) {
struct tegra_xusb_padctl_group *group;
int err;
@ -253,7 +253,7 @@ static int tegra_xusb_padctl_parse_dt(struct tegra_xusb_padctl *padctl,
return err;
}
fdt_for_each_subnode(fdt, subnode, node) {
fdt_for_each_subnode(subnode, fdt, node) {
struct tegra_xusb_padctl_config *config = &padctl->config;
err = tegra_xusb_padctl_config_parse_dt(padctl, config, fdt,

5
arch/arm/mach-uniphier/board_late_init.c
View File

@ -37,13 +37,12 @@ static int uniphier_set_fdt_file(void)
const char *compat;
char dtb_name[256];
int buf_len = 256;
int ret;
if (getenv("fdt_file"))
return 0; /* do nothing if it is already set */
ret = fdt_get_string(gd->fdt_blob, 0, "compatible", &compat);
if (ret)
compat = fdt_stringlist_get(gd->fdt_blob, 0, "compatible", 0, NULL);
if (!compat)
return -EINVAL;
if (strncmp(compat, VENDOR_PREFIX, strlen(VENDOR_PREFIX)))

5
arch/x86/cpu/irq.c
View File

@ -103,11 +103,12 @@ static int create_pirq_routing_table(struct udevice *dev)
/* extract the bdf from fdt_pci_addr */
priv->bdf = dm_pci_get_bdf(dev->parent);
ret = fdt_find_string(blob, node, "intel,pirq-config", "pci");
ret = fdt_stringlist_search(blob, node, "intel,pirq-config", "pci");
if (!ret) {
priv->config = PIRQ_VIA_PCI;
} else {
ret = fdt_find_string(blob, node, "intel,pirq-config", "ibase");
ret = fdt_stringlist_search(blob, node, "intel,pirq-config",
"ibase");
if (!ret)
priv->config = PIRQ_VIA_IBASE;
else

2
board/compulab/cm_fx6/cm_fx6.c
View File

@ -602,7 +602,7 @@ int ft_board_setup(void *blob, bd_t *bd)
char baseboard_name[16];
int err;
fdt_shrink_to_minimum(blob); /* Make room for new properties */
fdt_shrink_to_minimum(blob, 0); /* Make room for new properties */
/* MAC addr */
if (eth_getenv_enetaddr("ethaddr", enetaddr)) {

9
cmd/fdt.c
View File

@ -662,7 +662,12 @@ static int do_fdt(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
#endif
/* resize the fdt */
else if (strncmp(argv[1], "re", 2) == 0) {
fdt_shrink_to_minimum(working_fdt);
uint extrasize;
if (argc > 2)
extrasize = simple_strtoul(argv[2], NULL, 16);
else
extrasize = 0;
fdt_shrink_to_minimum(working_fdt, extrasize);
}
else {
/* Unrecognized command */
@ -1056,7 +1061,7 @@ static char fdt_help_text[] =
"fdt systemsetup - Do system-specific set up\n"
#endif
"fdt move <fdt> <newaddr> <length> - Copy the fdt to <addr> and make it active\n"
"fdt resize - Resize fdt to size + padding to 4k addr\n"
"fdt resize [<extrasize>] - Resize fdt to size + padding to 4k addr + some optional <extrasize> if needed\n"
"fdt print <path> [<prop>] - Recursive print starting at <path>\n"
"fdt list <path> [<prop>] - Print one level starting at <path>\n"
"fdt get value <var> <path> <prop> - Get <property> and store in <var>\n"

3
common/fdt_support.c
View File

@ -523,7 +523,7 @@ void fdt_fixup_ethernet(void *fdt)
}
/* Resize the fdt to its actual size + a bit of padding */
int fdt_shrink_to_minimum(void *blob)
int fdt_shrink_to_minimum(void *blob, uint extrasize)
{
int i;
uint64_t addr, size;
@ -551,6 +551,7 @@ int fdt_shrink_to_minimum(void *blob)
actualsize = fdt_off_dt_strings(blob) +
fdt_size_dt_strings(blob) + 5 * sizeof(struct fdt_reserve_entry);
actualsize += extrasize;
/* Make it so the fdt ends on a page boundary */
actualsize = ALIGN(actualsize + ((uintptr_t)blob & 0xfff), 0x1000);
actualsize = actualsize - ((uintptr_t)blob & 0xfff);

2
common/image-fdt.c
View File

@ -503,7 +503,7 @@ int image_setup_libfdt(bootm_headers_t *images, void *blob,
lmb_free(lmb, (phys_addr_t)(u32)(uintptr_t)blob,
(phys_size_t)fdt_totalsize(blob));
ret = fdt_shrink_to_minimum(blob);
ret = fdt_shrink_to_minimum(blob, 0);
if (ret < 0)
goto err;
of_size = ret;

21
common/image-fit.c
View File

@ -1026,7 +1026,7 @@ int fit_image_verify(const void *fit, int image_noffset)
}
/* Process all hash subnodes of the component image node */
fdt_for_each_subnode(fit, noffset, image_noffset) {
fdt_for_each_subnode(noffset, fit, image_noffset) {
const char *name = fit_get_name(fit, noffset, NULL);
/*
@ -1457,7 +1457,7 @@ int fit_conf_get_prop_node(const void *fit, int noffset,
void fit_conf_print(const void *fit, int noffset, const char *p)
{
char *desc;
char *uname;
const char *uname;
int ret;
int loadables_index;
@ -1469,7 +1469,7 @@ void fit_conf_print(const void *fit, int noffset, const char *p)
else
printf("%s\n", desc);
uname = (char *)fdt_getprop(fit, noffset, FIT_KERNEL_PROP, NULL);
uname = fdt_getprop(fit, noffset, FIT_KERNEL_PROP, NULL);
printf("%s Kernel: ", p);
if (uname == NULL)
printf("unavailable\n");
@ -1477,26 +1477,23 @@ void fit_conf_print(const void *fit, int noffset, const char *p)
printf("%s\n", uname);
/* Optional properties */
uname = (char *)fdt_getprop(fit, noffset, FIT_RAMDISK_PROP, NULL);
uname = fdt_getprop(fit, noffset, FIT_RAMDISK_PROP, NULL);
if (uname)
printf("%s Init Ramdisk: %s\n", p, uname);
uname = (char *)fdt_getprop(fit, noffset, FIT_FDT_PROP, NULL);
uname = fdt_getprop(fit, noffset, FIT_FDT_PROP, NULL);
if (uname)
printf("%s FDT: %s\n", p, uname);
uname = (char *)fdt_getprop(fit, noffset, FIT_FPGA_PROP, NULL);
uname = fdt_getprop(fit, noffset, FIT_FPGA_PROP, NULL);
if (uname)
printf("%s FPGA: %s\n", p, uname);
/* Print out all of the specified loadables */
for (loadables_index = 0;
fdt_get_string_index(fit, noffset,
FIT_LOADABLE_PROP,
loadables_index,
(const char **)&uname) == 0;
loadables_index++)
{
uname = fdt_stringlist_get(fit, noffset, FIT_LOADABLE_PROP,
loadables_index, NULL), uname;
loadables_index++) {
if (loadables_index == 0) {
printf("%s Loadables: ", p);
} else {

8
common/image-sig.c
View File

@ -212,7 +212,7 @@ static int fit_image_verify_sig(const void *fit, int image_noffset,
int ret;
/* Process all hash subnodes of the component image node */
fdt_for_each_subnode(fit, noffset, image_noffset) {
fdt_for_each_subnode(noffset, fit, image_noffset) {
const char *name = fit_get_name(fit, noffset, NULL);
if (!strncmp(name, FIT_SIG_NODENAME,
@ -260,7 +260,7 @@ int fit_image_verify_required_sigs(const void *fit, int image_noffset,
return 0;
}
fdt_for_each_subnode(sig_blob, noffset, sig_node) {
fdt_for_each_subnode(noffset, sig_blob, sig_node) {
const char *required;
int ret;
@ -393,7 +393,7 @@ static int fit_config_verify_sig(const void *fit, int conf_noffset,
int ret;
/* Process all hash subnodes of the component conf node */
fdt_for_each_subnode(fit, noffset, conf_noffset) {
fdt_for_each_subnode(noffset, fit, conf_noffset) {
const char *name = fit_get_name(fit, noffset, NULL);
if (!strncmp(name, FIT_SIG_NODENAME,
@ -438,7 +438,7 @@ int fit_config_verify_required_sigs(const void *fit, int conf_noffset,
return 0;
}
fdt_for_each_subnode(sig_blob, noffset, sig_node) {
fdt_for_each_subnode(noffset, sig_blob, sig_node) {
const char *required;
int ret;

19
common/image.c
View File

@ -1305,7 +1305,7 @@ int boot_get_fpga(int argc, char * const argv[], bootm_headers_t *images,
void *buf;
int conf_noffset;
int fit_img_result;
char *uname, *name;
const char *uname, *name;
int err;
int devnum = 0; /* TODO support multi fpga platforms */
const fpga_desc * const desc = fpga_get_desc(devnum);
@ -1332,9 +1332,9 @@ int boot_get_fpga(int argc, char * const argv[], bootm_headers_t *images,
case IMAGE_FORMAT_FIT:
conf_noffset = fit_conf_get_node(buf, images->fit_uname_cfg);
err = fdt_get_string_index(buf, conf_noffset, FIT_FPGA_PROP, 0,
(const char **)&uname);
if (err < 0) {
uname = fdt_stringlist_get(buf, conf_noffset, FIT_FPGA_PROP, 0,
NULL);
if (!uname) {
debug("## FPGA image is not specified\n");
return 0;
}
@ -1404,7 +1404,7 @@ int boot_get_loadable(int argc, char * const argv[], bootm_headers_t *images,
int loadables_index;
int conf_noffset;
int fit_img_result;
char *uname;
const char *uname;
/* Check to see if the images struct has a FIT configuration */
if (!genimg_has_config(images)) {
@ -1428,15 +1428,14 @@ int boot_get_loadable(int argc, char * const argv[], bootm_headers_t *images,
conf_noffset = fit_conf_get_node(buf, images->fit_uname_cfg);
for (loadables_index = 0;
fdt_get_string_index(buf, conf_noffset,
FIT_LOADABLE_PROP,
loadables_index,
(const char **)&uname) == 0;
uname = fdt_stringlist_get(buf, conf_noffset,
FIT_LOADABLE_PROP, loadables_index,
NULL), uname;
loadables_index++)
{
fit_img_result = fit_image_load(images,
tmp_img_addr,
(const char **)&uname,
&uname,
&(images->fit_uname_cfg), arch,
IH_TYPE_LOADABLE,
BOOTSTAGE_ID_FIT_LOADABLE_START,

6
drivers/clk/clk-uclass.c
View File

@ -101,10 +101,10 @@ int clk_get_by_name(struct udevice *dev, const char *name, struct clk *clk)
debug("%s(dev=%p, name=%s, clk=%p)\n", __func__, dev, name, clk);
index = fdt_find_string(gd->fdt_blob, dev->of_offset, "clock-names",
name);
index = fdt_stringlist_search(gd->fdt_blob, dev->of_offset,
"clock-names", name);
if (index < 0) {
debug("fdt_find_string() failed: %d\n", index);
debug("fdt_stringlist_search() failed: %d\n", index);
return index;
}

2
drivers/core/device.c
View File

@ -698,7 +698,7 @@ fdt_addr_t dev_get_addr_name(struct udevice *dev, const char *name)
#if CONFIG_IS_ENABLED(OF_CONTROL)
int index;
index = fdt_find_string(gd->fdt_blob, dev->of_offset, "reg-names",
index = fdt_stringlist_search(gd->fdt_blob, dev->of_offset, "reg-names",
name);
if (index < 0)
return index;

3
drivers/gpio/dwapb_gpio.c
View File

@ -132,7 +132,8 @@ static int gpio_dwapb_bind(struct udevice *dev)
plat->base = base;
plat->bank = bank;
plat->pins = fdtdec_get_int(blob, node, "snps,nr-gpios", 0);
ret = fdt_get_string(blob, node, "bank-name", &plat->name);
plat->name = fdt_stringlist_get(blob, node, "bank-name", 0,
NULL);
if (ret)
goto err;

2
drivers/i2c/mxc_i2c.c
View File

@ -773,7 +773,7 @@ static int mxc_i2c_probe(struct udevice *bus)
* See Documentation/devicetree/bindings/i2c/i2c-imx.txt
* Use gpio to force bus idle when necessary.
*/
ret = fdt_find_string(fdt, node, "pinctrl-names", "gpio");
ret = fdt_stringlist_search(fdt, node, "pinctrl-names", "gpio");
if (ret < 0) {
dev_info(dev, "i2c bus %d at %lu, no gpio pinctrl state.\n", bus->seq, i2c_bus->base);
} else {

6
drivers/mailbox/mailbox-uclass.c
View File

@ -85,10 +85,10 @@ int mbox_get_by_name(struct udevice *dev, const char *name,
debug("%s(dev=%p, name=%s, chan=%p)\n", __func__, dev, name, chan);
index = fdt_find_string(gd->fdt_blob, dev->of_offset, "mbox-names",
name);
index = fdt_stringlist_search(gd->fdt_blob, dev->of_offset,
"mbox-names", name);
if (index < 0) {
debug("fdt_find_string() failed: %d\n", index);
debug("fdt_stringlist_search() failed: %d\n", index);
return index;
}

2
drivers/net/cpsw.c
View File

@ -1348,7 +1348,7 @@ static int cpsw_eth_ofdata_to_platdata(struct udevice *dev)
active_slave = fdtdec_get_int(fdt, node, "active_slave", 0);
priv->data.active_slave = active_slave;
fdt_for_each_subnode(fdt, subnode, node) {
fdt_for_each_subnode(subnode, fdt, node) {
int len;
const char *name;

4
drivers/net/keystone_net.c
View File

@ -990,7 +990,7 @@ static int ks2_eth_bind_slaves(struct udevice *dev, int gbe, int *gbe_0)
char *slave_name;
interfaces = fdt_subnode_offset(fdt, gbe, "interfaces");
fdt_for_each_subnode(fdt, slave, interfaces) {
fdt_for_each_subnode(slave, fdt, interfaces) {
int slave_no;
slave_no = fdtdec_get_int(fdt, slave, "slave-port", -ENOENT);
@ -1015,7 +1015,7 @@ static int ks2_eth_bind_slaves(struct udevice *dev, int gbe, int *gbe_0)
}
sec_slave = fdt_subnode_offset(fdt, gbe, "secondary-slave-ports");
fdt_for_each_subnode(fdt, slave, sec_slave) {
fdt_for_each_subnode(slave, fdt, sec_slave) {
int slave_no;
slave_no = fdtdec_get_int(fdt, slave, "slave-port", -ENOENT);

2
drivers/net/mvpp2.c
View File

@ -4153,7 +4153,7 @@ static int mvpp2_base_bind(struct udevice *parent)
return -ENOENT;
}
fdt_for_each_subnode(blob, subnode, node) {
fdt_for_each_subnode(subnode, blob, node) {
/* Skip disabled ports */
if (!fdtdec_get_is_enabled(blob, subnode))
continue;

5
drivers/net/sun8i_emac.c
View File

@ -456,8 +456,9 @@ static int parse_phy_pins(struct udevice *dev)
for (i = 0; ; i++) {
int pin;
if (fdt_get_string_index(gd->fdt_blob, offset,
"allwinner,pins", i, &pin_name))
pin_name = fdt_stringlist_get(gd->fdt_blob, offset,
"allwinner,pins", i, NULL);
if (!pin_name)
break;
if (pin_name[0] != 'P')
continue;

2
drivers/pci/pci_tegra.c
View File

@ -531,7 +531,7 @@ static int tegra_pcie_parse_dt(const void *fdt, int node, enum tegra_pci_id id,
}
#endif
fdt_for_each_subnode(fdt, subnode, node) {
fdt_for_each_subnode(subnode, fdt, node) {
unsigned int index = 0, num_lanes = 0;
struct tegra_pcie_port *port;

2
drivers/phy/marvell/comphy_core.c
View File

@ -152,7 +152,7 @@ static int comphy_probe(struct udevice *dev)
}
lane = 0;
fdt_for_each_subnode(blob, subnode, node) {
fdt_for_each_subnode(subnode, blob, node) {
/* Skip disabled ports */
if (!fdtdec_get_is_enabled(blob, subnode))
continue;

9
drivers/pinctrl/exynos/pinctrl-exynos.c
View File

@ -71,7 +71,7 @@ int exynos_pinctrl_set_state(struct udevice *dev, struct udevice *config)
{
const void *fdt = gd->fdt_blob;
int node = config->of_offset;
unsigned int count, idx, pin_num, ret;
unsigned int count, idx, pin_num;
unsigned int pinfunc, pinpud, pindrv;
unsigned long reg, value;
const char *name;
@ -80,7 +80,7 @@ int exynos_pinctrl_set_state(struct udevice *dev, struct udevice *config)
* refer to the following document for the pinctrl bindings
* linux/Documentation/devicetree/bindings/pinctrl/samsung-pinctrl.txt
*/
count = fdt_count_strings(fdt, node, "samsung,pins");
count = fdt_stringlist_count(fdt, node, "samsung,pins");
if (count <= 0)
return -EINVAL;
@ -89,9 +89,8 @@ int exynos_pinctrl_set_state(struct udevice *dev, struct udevice *config)
pindrv = fdtdec_get_int(fdt, node, "samsung,pin-drv", -1);
for (idx = 0; idx < count; idx++) {
ret = fdt_get_string_index(fdt, node, "samsung,pins",
idx, &name);
if (ret < 0)
name = fdt_stringlist_get(fdt, node, "samsung,pins", idx, NULL);
if (!name)
continue;
reg = pin_to_bank_base(dev, name, &pin_num);

4
drivers/pinctrl/meson/pinctrl-meson.c
View File

@ -122,7 +122,7 @@ static fdt_addr_t parse_address(int offset, const char *name, int na, int ns)
int index, len = 0;
const fdt32_t *reg;
index = fdt_find_string(gd->fdt_blob, offset, "reg-names", name);
index = fdt_stringlist_search(gd->fdt_blob, offset, "reg-names", name);
if (index < 0)
return FDT_ADDR_T_NONE;
@ -154,7 +154,7 @@ int meson_pinctrl_probe(struct udevice *dev)
return -EINVAL;
}
fdt_for_each_subnode(gd->fdt_blob, node, dev->of_offset) {
fdt_for_each_subnode(node, gd->fdt_blob, dev->of_offset) {
if (fdt_getprop(gd->fdt_blob, node, "gpio-controller", &len)) {
gpio = node;
break;

10
drivers/pinctrl/pinctrl-generic.c
View File

@ -306,11 +306,11 @@ static int pinctrl_generic_set_state_subnode(struct udevice *dev,
const char *name;
int strings_count, selector, i, ret;
strings_count = fdt_count_strings(fdt, node, subnode_target_type);
strings_count = fdt_stringlist_count(fdt, node, subnode_target_type);
if (strings_count < 0) {
subnode_target_type = "groups";
is_group = true;
strings_count = fdt_count_strings(fdt, node,
strings_count = fdt_stringlist_count(fdt, node,
subnode_target_type);
if (strings_count < 0) {
/* skip this node; may contain config child nodes */
@ -319,9 +319,9 @@ static int pinctrl_generic_set_state_subnode(struct udevice *dev,
}
for (i = 0; i < strings_count; i++) {
ret = fdt_get_string_index(fdt, node, subnode_target_type,
i, &name);
if (ret < 0)
name = fdt_stringlist_get(fdt, node, subnode_target_type, i,
NULL);
if (!name)
return -EINVAL;
if (is_group)

2
drivers/pinctrl/pinctrl-uclass.c
View File

@ -72,7 +72,7 @@ static int pinctrl_select_state_full(struct udevice *dev, const char *statename)
struct udevice *config;
int state, size, i, ret;
state = fdt_find_string(fdt, node, "pinctrl-names", statename);
state = fdt_stringlist_search(fdt, node, "pinctrl-names", statename);
if (state < 0) {
char *end;
/*

2
drivers/power/pmic/palmas.c
View File

@ -52,7 +52,7 @@ static int palmas_bind(struct udevice *dev)
int node = dev->of_offset;
int subnode, len;
fdt_for_each_subnode(blob, subnode, node) {
fdt_for_each_subnode(subnode, blob, node) {
const char *name;
char *temp;

6
drivers/reset/reset-uclass.c
View File

@ -88,10 +88,10 @@ int reset_get_by_name(struct udevice *dev, const char *name,
debug("%s(dev=%p, name=%s, reset_ctl=%p)\n", __func__, dev, name,
reset_ctl);
index = fdt_find_string(gd->fdt_blob, dev->of_offset, "reset-names",
name);
index = fdt_stringlist_search(gd->fdt_blob, dev->of_offset,
"reset-names", name);
if (index < 0) {
debug("fdt_find_string() failed: %d\n", index);
debug("fdt_stringlist_search() failed: %d\n", index);
return index;
}

2
drivers/spi/fsl_qspi.c
View File

@ -1098,7 +1098,7 @@ static int fsl_qspi_ofdata_to_platdata(struct udevice *bus)
}
/* Count flash numbers */
fdt_for_each_subnode(blob, subnode, node)
fdt_for_each_subnode(subnode, blob, node)
++flash_num;
if (flash_num == 0) {

2
drivers/video/sunxi_display.c
View File

@ -1562,7 +1562,7 @@ int sunxi_simplefb_setup(void *blob)
offset = fdt_node_offset_by_compatible(blob, -1,
"allwinner,simple-framebuffer");
while (offset >= 0) {
ret = fdt_find_string(blob, offset, "allwinner,pipeline",
ret = fdt_stringlist_search(blob, offset, "allwinner,pipeline",
pipeline);
if (ret == 0)
break;

10
include/fdt_support.h
View File

@ -167,7 +167,15 @@ void ft_pci_setup(void *blob, bd_t *bd);
int ft_system_setup(void *blob, bd_t *bd);
void set_working_fdt_addr(ulong addr);
int fdt_shrink_to_minimum(void *blob);
/**
* shrink down the given blob to minimum size + some extrasize if required
*
* @param blob FDT blob to update
* @param extrasize additional bytes needed
* @return 0 if ok, or -FDT_ERR_... on error
*/
int fdt_shrink_to_minimum(void *blob, uint extrasize);
int fdt_increase_size(void *fdt, int add_len);
int fdt_fixup_nor_flash_size(void *blob);

187
include/libfdt.h
View File

@ -61,7 +61,7 @@
#define FDT_ERR_NOTFOUND 1
/* FDT_ERR_NOTFOUND: The requested node or property does not exist */
#define FDT_ERR_EXISTS 2
/* FDT_ERR_EXISTS: Attemped to create a node or property which
/* FDT_ERR_EXISTS: Attempted to create a node or property which
* already exists */
#define FDT_ERR_NOSPACE 3
/* FDT_ERR_NOSPACE: Operation needed to expand the device
@ -121,12 +121,17 @@
/* FDT_ERR_BADNCELLS: Device tree has a #address-cells, #size-cells
* or similar property with a bad format or value */
#define FDT_ERR_TOODEEP 15
#define FDT_ERR_BADVALUE 15
/* FDT_ERR_BADVALUE: Device tree has a property with an unexpected
* value. For example: a property expected to contain a string list
* is not NUL-terminated within the length of its value. */
#define FDT_ERR_TOODEEP 16
/* FDT_ERR_TOODEEP: The depth of a node has exceeded the internal
* libfdt limit. This can happen if you have more than
* FDT_MAX_DEPTH nested nodes. */
#define FDT_ERR_MAX 15
#define FDT_ERR_MAX 16
/**********************************************************************/
/* Low-level functions (you probably don't need these) */
@ -171,24 +176,27 @@ int fdt_next_subnode(const void *fdt, int offset);
/**
* fdt_for_each_subnode - iterate over all subnodes of a parent
*
* @node: child node (int, lvalue)
* @fdt: FDT blob (const void *)
* @parent: parent node (int)
*
* This is actually a wrapper around a for loop and would be used like so:
*
* fdt_for_each_subnode(fdt, node, parent) {
* ...
* use node
* fdt_for_each_subnode(node, fdt, parent) {
* Use node
* ...
* }
*
* Note that this is implemented as a macro and node is used as iterator in
* the loop. It should therefore be a locally allocated variable. The parent
* variable on the other hand is never modified, so it can be constant or
* even a literal.
* if ((node < 0) && (node != -FDT_ERR_NOT_FOUND)) {
* Error handling
* }
*
* Note that this is implemented as a macro and @node is used as
* iterator in the loop. The parent variable be constant or even a
* literal.
*
* @fdt: FDT blob (const void *)
* @node: child node (int)
* @parent: parent node (int)
*/
#define fdt_for_each_subnode(fdt, node, parent) \
#define fdt_for_each_subnode(node, fdt, parent) \
for (node = fdt_first_subnode(fdt, parent); \
node >= 0; \
node = fdt_next_subnode(fdt, node))
@ -213,7 +221,7 @@ int fdt_next_subnode(const void *fdt, int offset);
#define __fdt_set_hdr(name) \
static inline void fdt_set_##name(void *fdt, uint32_t val) \
{ \
struct fdt_header *fdth = (struct fdt_header*)fdt; \
struct fdt_header *fdth = (struct fdt_header *)fdt; \
fdth->name = cpu_to_fdt32(val); \
}
__fdt_set_hdr(magic);
@ -288,11 +296,13 @@ const char *fdt_string(const void *fdt, int stroffset);
* @fdt: pointer to the device tree blob
*
* fdt_get_max_phandle retrieves the highest phandle in the given
* device tree
* device tree. This will ignore badly formatted phandles, or phandles
* with a value of 0 or -1.
*
* returns:
* the highest phandle on success
* 0, if an error occurred
* 0, if no phandle was found in the device tree
* -1, if an error occurred
*/
uint32_t fdt_get_max_phandle(const void *fdt);
@ -356,8 +366,9 @@ int fdt_subnode_offset_namelen(const void *fdt, int parentoffset,
* returns:
* structure block offset of the requested subnode (>=0), on success
* -FDT_ERR_NOTFOUND, if the requested subnode does not exist
* -FDT_ERR_BADOFFSET, if parentoffset did not point to an FDT_BEGIN_NODE tag
* -FDT_ERR_BADMAGIC,
* -FDT_ERR_BADOFFSET, if parentoffset did not point to an FDT_BEGIN_NODE
* tag
* -FDT_ERR_BADMAGIC,
* -FDT_ERR_BADVERSION,
* -FDT_ERR_BADSTATE,
* -FDT_ERR_BADSTRUCTURE,
@ -366,13 +377,13 @@ int fdt_subnode_offset_namelen(const void *fdt, int parentoffset,
int fdt_subnode_offset(const void *fdt, int parentoffset, const char *name);
/**
* fdt_path_offset_namelen - find a tree node based on substring
* fdt_path_offset_namelen - find a tree node by its full path
* @fdt: pointer to the device tree blob
* @path: full path of the node to locate
* @namelen: number of characters of name to consider
* @namelen: number of characters of path to consider
*
* Identical to fdt_path_offset(), but only examine the first
* namelen characters of path for matching the node path.
* Identical to fdt_path_offset(), but only consider the first namelen
* characters of path as the path name.
*/
int fdt_path_offset_namelen(const void *fdt, const char *path, int namelen);
@ -389,7 +400,8 @@ int fdt_path_offset_namelen(const void *fdt, const char *path, int namelen);
* address).
*
* returns:
* structure block offset of the node with the requested path (>=0), on success
* structure block offset of the node with the requested path (>=0), on
* success
* -FDT_ERR_BADPATH, given path does not begin with '/' or is invalid
* -FDT_ERR_NOTFOUND, if the requested node does not exist
* -FDT_ERR_BADMAGIC,
@ -398,10 +410,7 @@ int fdt_path_offset_namelen(const void *fdt, const char *path, int namelen);
* -FDT_ERR_BADSTRUCTURE,
* -FDT_ERR_TRUNCATED, standard meanings.
*/
static inline int fdt_path_offset(const void *fdt, const char *path)
{
return fdt_path_offset_namelen(fdt, path, strlen(path));
}
int fdt_path_offset(const void *fdt, const char *path);
/**
* fdt_get_name - retrieve the name of a given node
@ -416,10 +425,12 @@ static inline int fdt_path_offset(const void *fdt, const char *path)
*
* returns:
* pointer to the node's name, on success
* If lenp is non-NULL, *lenp contains the length of that name (>=0)
* If lenp is non-NULL, *lenp contains the length of that name
* (>=0)
* NULL, on error
* if lenp is non-NULL *lenp contains an error code (<0):
* -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
* -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE
* tag
* -FDT_ERR_BADMAGIC,
* -FDT_ERR_BADVERSION,
* -FDT_ERR_BADSTATE, standard meanings
@ -468,23 +479,26 @@ int fdt_first_property_offset(const void *fdt, int nodeoffset);
int fdt_next_property_offset(const void *fdt, int offset);
/**
* fdt_for_each_property - iterate over all properties of a node
* @property_offset: property offset (int)
* fdt_for_each_property_offset - iterate over all properties of a node
*
* @property_offset: property offset (int, lvalue)
* @fdt: FDT blob (const void *)
* @node: node offset (int)
*
* This is actually a wrapper around a for loop and would be used like so:
*
* fdt_for_each_property(fdt, node, property) {
* ...
* use property
* fdt_for_each_property_offset(property, fdt, node) {
* Use property
* ...
* }
*
* if ((property < 0) && (property != -FDT_ERR_NOT_FOUND)) {
* Error handling
* }
*
* Note that this is implemented as a macro and property is used as
* iterator in the loop. It should therefore be a locally allocated
* variable. The node variable on the other hand is never modified, so
* it can be constant or even a literal.
* iterator in the loop. The node variable can be constant or even a
* literal.
*/
#define fdt_for_each_property_offset(property, fdt, node) \
for (property = fdt_first_property_offset(fdt, node); \
@ -527,8 +541,8 @@ const struct fdt_property *fdt_get_property_by_offset(const void *fdt,
* @namelen: number of characters of name to consider
* @lenp: pointer to an integer variable (will be overwritten) or NULL
*
* Identical to fdt_get_property_namelen(), but only examine the first
* namelen characters of name for matching the property name.
* Identical to fdt_get_property(), but only examine the first namelen
* characters of name for matching the property name.
*/
const struct fdt_property *fdt_get_property_namelen(const void *fdt,
int nodeoffset,
@ -555,7 +569,8 @@ const struct fdt_property *fdt_get_property_namelen(const void *fdt,
* NULL, on error
* if lenp is non-NULL, *lenp contains an error code (<0):
* -FDT_ERR_NOTFOUND, node does not have named property
* -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
* -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE
* tag
* -FDT_ERR_BADMAGIC,
* -FDT_ERR_BADVERSION,
* -FDT_ERR_BADSTATE,
@ -647,7 +662,8 @@ static inline void *fdt_getprop_namelen_w(void *fdt, int nodeoffset,
* NULL, on error
* if lenp is non-NULL, *lenp contains an error code (<0):
* -FDT_ERR_NOTFOUND, node does not have named property
* -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
* -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE
* tag
* -FDT_ERR_BADMAGIC,
* -FDT_ERR_BADVERSION,
* -FDT_ERR_BADSTATE,
@ -689,7 +705,7 @@ const char *fdt_get_alias_namelen(const void *fdt,
const char *name, int namelen);
/**
* fdt_get_alias - retreive the path referenced by a given alias
* fdt_get_alias - retrieve the path referenced by a given alias
* @fdt: pointer to the device tree blob
* @name: name of the alias th look up
*
@ -749,11 +765,11 @@ int fdt_get_path(const void *fdt, int nodeoffset, char *buf, int buflen);
* structure from the start to nodeoffset.
*
* returns:
* structure block offset of the node at node offset's ancestor
* of depth supernodedepth (>=0), on success
* -FDT_ERR_BADOFFSET, nodeoffset does not refer to a BEGIN_NODE tag
* -FDT_ERR_NOTFOUND, supernodedepth was greater than the depth of nodeoffset
* -FDT_ERR_NOTFOUND, supernodedepth was greater than the depth of
* nodeoffset
* -FDT_ERR_BADMAGIC,
* -FDT_ERR_BADVERSION,
* -FDT_ERR_BADSTATE,
@ -946,51 +962,66 @@ int fdt_node_offset_by_compatible(const void *fdt, int startoffset,
int fdt_stringlist_contains(const char *strlist, int listlen, const char *str);
/**
* fdt_count_strings - count the number of strings in a string list
* fdt_stringlist_count - count the number of strings in a string list
* @fdt: pointer to the device tree blob
* @node: offset of the node
* @nodeoffset: offset of a tree node
* @property: name of the property containing the string list
* @return: the number of strings in the given property
* @return:
* the number of strings in the given property
* -FDT_ERR_BADVALUE if the property value is not NUL-terminated
* -FDT_ERR_NOTFOUND if the property does not exist
*/
int fdt_count_strings(const void *fdt, int node, const char *property);
int fdt_stringlist_count(const void *fdt, int nodeoffset, const char *property);
/**
* fdt_find_string - find a string in a string list and return its index
* fdt_stringlist_search - find a string in a string list and return its index
* @fdt: pointer to the device tree blob
* @node: offset of the node
* @nodeoffset: offset of a tree node
* @property: name of the property containing the string list
* @string: string to look up in the string list
* @return: the index of the string or negative on error
*
* Note that it is possible for this function to succeed on property values
* that are not NUL-terminated. That's because the function will stop after
* finding the first occurrence of @string. This can for example happen with
* small-valued cell properties, such as #address-cells, when searching for
* the empty string.
*
* @return:
* the index of the string in the list of strings
* -FDT_ERR_BADVALUE if the property value is not NUL-terminated
* -FDT_ERR_NOTFOUND if the property does not exist or does not contain
* the given string
*/
int fdt_find_string(const void *fdt, int node, const char *property,
const char *string);
int fdt_stringlist_search(const void *fdt, int nodeoffset, const char *property,
const char *string);
/**
* fdt_get_string_index() - obtain the string at a given index in a string list
* fdt_stringlist_get() - obtain the string at a given index in a string list
* @fdt: pointer to the device tree blob
* @node: offset of the node
* @nodeoffset: offset of a tree node
* @property: name of the property containing the string list
* @index: index of the string to return
* @output: return location for the string
* @return: 0 if the string was found or a negative error code otherwise
*/
int fdt_get_string_index(const void *fdt, int node, const char *property,
int index, const char **output);
/**
* fdt_get_string() - obtain the first string in a string list
* @fdt: pointer to the device tree blob
* @node: offset of the node
* @property: name of the property containing the string list
* @output: return location for the string
* @return: 0 if the string was found or a negative error code otherwise
* @lenp: return location for the string length or an error code on failure
*
* This is a shortcut for:
* Note that this will successfully extract strings from properties with
* non-NUL-terminated values. For example on small-valued cell properties
* this function will return the empty string.
*
* fdt_get_string_index(fdt, node, property, 0, output).
* If non-NULL, the length of the string (on success) or a negative error-code
* (on failure) will be stored in the integer pointer to by lenp.
*
* @return:
* A pointer to the string at the given index in the string list or NULL on
* failure. On success the length of the string will be stored in the memory
* location pointed to by the lenp parameter, if non-NULL. On failure one of
* the following negative error codes will be returned in the lenp parameter
* (if non-NULL):
* -FDT_ERR_BADVALUE if the property value is not NUL-terminated
* -FDT_ERR_NOTFOUND if the property does not exist
*/
int fdt_get_string(const void *fdt, int node, const char *property,
const char **output);
const char *fdt_stringlist_get(const void *fdt, int nodeoffset,
const char *property, int index,
int *lenp);
/**********************************************************************/
/* Read-only functions (addressing related) */
@ -1060,7 +1091,7 @@ int fdt_size_cells(const void *fdt, int nodeoffset);
* @nodeoffset: offset of the node whose property to change
* @name: name of the property to change
* @namelen: number of characters of name to consider
* @index: index of the property to change in the array
* @idx: index of the property to change in the array
* @val: pointer to data to replace the property value with
* @len: length of the property value
*
@ -1071,7 +1102,7 @@ int fdt_size_cells(const void *fdt, int nodeoffset);
*/
int fdt_setprop_inplace_namelen_partial(void *fdt, int nodeoffset,
const char *name, int namelen,
uint32_t index, const void *val,
uint32_t idx, const void *val,
int len);
/**
@ -1700,9 +1731,11 @@ int fdt_add_subnode_namelen(void *fdt, int parentoffset,
* change the offsets of some existing nodes.
* returns:
* structure block offset of the created nodeequested subnode (>=0), on success
* structure block offset of the created nodeequested subnode (>=0), on
* success
* -FDT_ERR_NOTFOUND, if the requested subnode does not exist
* -FDT_ERR_BADOFFSET, if parentoffset did not point to an FDT_BEGIN_NODE tag
* -FDT_ERR_BADOFFSET, if parentoffset did not point to an FDT_BEGIN_NODE
* tag
* -FDT_ERR_EXISTS, if the node at parentoffset already has a subnode of
* the given name
* -FDT_ERR_NOSPACE, if there is insufficient free space in the

4
lib/fdtdec.c
View File

@ -836,7 +836,7 @@ int fdtdec_get_child_count(const void *blob, int node)
int subnode;
int num = 0;
fdt_for_each_subnode(blob, subnode, node)
fdt_for_each_subnode(subnode, blob, node)
num++;
return num;
@ -1014,7 +1014,7 @@ int fdt_get_named_resource(const void *fdt, int node, const char *property,
{
int index;
index = fdt_find_string(fdt, node, prop_names, name);
index = fdt_stringlist_search(fdt, node, prop_names, name);
if (index < 0)
return index;

13
lib/libfdt/fdt.c
View File

@ -35,18 +35,19 @@ int fdt_check_header(const void *fdt)
const void *fdt_offset_ptr(const void *fdt, int offset, unsigned int len)
{
const char *p;
unsigned absoffset = offset + fdt_off_dt_struct(fdt);
if ((absoffset < offset)
|| ((absoffset + len) < absoffset)
|| (absoffset + len) > fdt_totalsize(fdt))
return NULL;
if (fdt_version(fdt) >= 0x11)
if (((offset + len) < offset)
|| ((offset + len) > fdt_size_dt_struct(fdt)))
return NULL;
p = _fdt_offset_ptr(fdt, offset);
if (p + len < p)
return NULL;
return p;
return _fdt_offset_ptr(fdt, offset);
}
uint32_t fdt_next_tag(const void *fdt, int startoffset, int *nextoffset)

8
lib/libfdt/fdt_overlay.c
View File

@ -146,7 +146,7 @@ static int overlay_adjust_node_phandles(void *fdto, int node,
if (!found && !ret)
return ret;
fdt_for_each_subnode(fdto, child, node)
fdt_for_each_subnode(child, fdto, node)
overlay_adjust_node_phandles(fdto, child, delta);
return 0;
@ -248,7 +248,7 @@ static int overlay_update_local_node_references(void *fdto,
}
}
fdt_for_each_subnode(fdto, fixup_child, fixup_node) {
fdt_for_each_subnode(fixup_child, fdto, fixup_node) {
const char *fixup_child_name = fdt_get_name(fdto, fixup_child,
NULL);
int tree_child;
@ -511,7 +511,7 @@ static int overlay_apply_node(void *fdt, int target,
return ret;
}
fdt_for_each_subnode(fdto, node, fragment) {
fdt_for_each_subnode(node, fdto, fragment) {
const char *name = fdt_get_name(fdto, node, NULL);
int nnode;
int ret;
@ -550,7 +550,7 @@ static int overlay_merge(void *dt, void *dto)
{
int fragment;
fdt_for_each_subnode(dto, fragment, 0) {
fdt_for_each_subnode(fragment, dto, 0) {
int overlay;
int target;
int ret;

119
lib/libfdt/fdt_ro.c
View File

@ -60,11 +60,11 @@ uint32_t fdt_get_max_phandle(const void *fdt)
return max_phandle;
if (offset < 0)
return 0;
return (uint32_t)-1;
phandle = fdt_get_phandle(fdt, offset);
if (phandle == (uint32_t)-1)
return 0;
continue;
if (phandle > max_phandle)
max_phandle = phandle;
@ -204,6 +204,11 @@ int fdt_path_offset_namelen(const void *fdt, const char *path, int namelen)
return offset;
}
int fdt_path_offset(const void *fdt, const char *path)
{
return fdt_path_offset_namelen(fdt, path, strlen(path));
}
const char *fdt_get_name(const void *fdt, int nodeoffset, int *len)
{
const struct fdt_node_header *nh = _fdt_offset_ptr(fdt, nodeoffset);
@ -538,80 +543,104 @@ int fdt_stringlist_contains(const char *strlist, int listlen, const char *str)
return 0;
}
int fdt_count_strings(const void *fdt, int node, const char *property)
int fdt_stringlist_count(const void *fdt, int nodeoffset, const char *property)
{
int length, i, count = 0;
const char *list;
const char *list, *end;
int length, count = 0;
list = fdt_getprop(fdt, node, property, &length);
list = fdt_getprop(fdt, nodeoffset, property, &length);
if (!list)
return length;
return -length;
for (i = 0; i < length; i++) {
int len = strlen(list);
end = list + length;
list += len + 1;
i += len;
while (list < end) {
length = strnlen(list, end - list) + 1;
/* Abort if the last string isn't properly NUL-terminated. */
if (list + length > end)
return -FDT_ERR_BADVALUE;
list += length;
count++;
}
return count;
}
int fdt_find_string(const void *fdt, int node, const char *property,
const char *string)
int fdt_stringlist_search(const void *fdt, int nodeoffset, const char *property,
const char *string)
{
int length, len, idx = 0;
const char *list, *end;
int len, index = 0;
list = fdt_getprop(fdt, node, property, &len);
list = fdt_getprop(fdt, nodeoffset, property, &length);
if (!list)
return len;
return -length;
end = list + len;
len = strlen(string);
len = strlen(string) + 1;
end = list + length;
while (list < end) {
int l = strlen(list);
length = strnlen(list, end - list) + 1;
if (l == len && memcmp(list, string, len) == 0)
return index;
/* Abort if the last string isn't properly NUL-terminated. */
if (list + length > end)
return -FDT_ERR_BADVALUE;
list += l + 1;
index++;
if (length == len && memcmp(list, string, length) == 0)
return idx;
list += length;
idx++;
}
return -FDT_ERR_NOTFOUND;
}
int fdt_get_string_index(const void *fdt, int node, const char *property,
int index, const char **output)
const char *fdt_stringlist_get(const void *fdt, int nodeoffset,
const char *property, int idx,
int *lenp)
{
const char *list;
int length, i;
const char *list, *end;
int length;
list = fdt_getprop(fdt, node, property, &length);
list = fdt_getprop(fdt, nodeoffset, property, &length);
if (!list) {
if (lenp)
*lenp = length;
for (i = 0; i < length; i++) {
int len = strlen(list);
return NULL;
}
if (index == 0) {
*output = list;
return 0;
end = list + length;
while (list < end) {
length = strnlen(list, end - list) + 1;
/* Abort if the last string isn't properly NUL-terminated. */
if (list + length > end) {
if (lenp)
*lenp = -FDT_ERR_BADVALUE;
return NULL;
}
list += len + 1;
i += len;
index--;
if (idx == 0) {
if (lenp)
*lenp = length - 1;
return list;
}
list += length;
idx--;
}
return -FDT_ERR_NOTFOUND;
}
if (lenp)
*lenp = -FDT_ERR_NOTFOUND;
int fdt_get_string(const void *fdt, int node, const char *property,
const char **output)
{
return fdt_get_string_index(fdt, node, property, 0, output);
return NULL;
}
int fdt_node_check_compatible(const void *fdt, int nodeoffset,
@ -623,10 +652,8 @@ int fdt_node_check_compatible(const void *fdt, int nodeoffset,
prop = fdt_getprop(fdt, nodeoffset, "compatible", &len);
if (!prop)
return len;
if (fdt_stringlist_contains(prop, len, compatible))
return 0;
else
return 1;
return !fdt_stringlist_contains(prop, len, compatible);
}
int fdt_node_offset_by_compatible(const void *fdt, int startoffset,

4
lib/libfdt/fdt_rw.c
View File

@ -60,6 +60,8 @@ static int _fdt_splice(void *fdt, void *splicepoint, int oldlen, int newlen)
if (((p + oldlen) < p) || ((p + oldlen) > end))
return -FDT_ERR_BADOFFSET;
if ((p < (char *)fdt) || ((end - oldlen + newlen) < (char *)fdt))
return -FDT_ERR_BADOFFSET;
if ((end - oldlen + newlen) > ((char *)fdt + fdt_totalsize(fdt)))
return -FDT_ERR_NOSPACE;
memmove(p + newlen, p + oldlen, end - p - oldlen);
@ -164,7 +166,7 @@ static int _fdt_resize_property(void *fdt, int nodeoffset, const char *name,
int err;
*prop = fdt_get_property_w(fdt, nodeoffset, name, &oldlen);
if (!(*prop))
if (!*prop)
return oldlen;
if ((err = _fdt_splice_struct(fdt, (*prop)->data, FDT_TAGALIGN(oldlen),

6
lib/libfdt/fdt_wip.c
View File

@ -16,7 +16,7 @@
int fdt_setprop_inplace_namelen_partial(void *fdt, int nodeoffset,
const char *name, int namelen,
uint32_t index, const void *val,
uint32_t idx, const void *val,
int len)
{
void *propval;
@ -27,10 +27,10 @@ int fdt_setprop_inplace_namelen_partial(void *fdt, int nodeoffset,
if (!propval)
return proplen;
if (proplen < (len + index))
if (proplen < (len + idx))
return -FDT_ERR_NOSPACE;
memcpy(propval + index, val, len);
memcpy((char *)propval + idx, val, len);
return 0;
}

5
test/overlay/cmd_ut_overlay.c
View File

@ -52,12 +52,15 @@ static int fdt_getprop_str(void *fdt, const char *path, const char *name,
const char **out)
{
int node_off;
int len;
node_off = fdt_path_offset(fdt, path);
if (node_off < 0)
return node_off;
return fdt_get_string(fdt, node_off, name, out);
*out = fdt_stringlist_get(fdt, node_off, name, 0, &len);
return len < 0 ? len : 0;
}
static int fdt_overlay_change_int_property(struct unit_test_state *uts)