Whitebox
/
u-boot
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

fdt: unshadow global working fdt variable

Browse Source 
differentiate with local variables of the same name by renaming the
global 'fdt' variable 'working_fdt'.

Signed-off-by: Kim Phillips <kim.phillips@freescale.com>
master
Kim Phillips 16 years ago committed by Gerald Van Baren
parent 2fb698bf50
commit e489b9c078
4 changed files with 64 additions and 56 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 114
      common/cmd_fdt.c
  2. 2
      common/fdt_support.c
  3. 2
      include/libfdt_env.h
  4. 2
      lib_ppc/bootm.c

114
common/cmd_fdt.c
Unescape View File

@ -62,7 +62,7 @@ int do_fdt (cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])
/* /*
* Set the address [and length] of the fdt. * Set the address [and length] of the fdt.
*/ */
fdt = (struct fdt_header *)simple_strtoul(argv[2], NULL, 16); working_fdt = (struct fdt_header *)simple_strtoul(argv[2], NULL, 16);
if (!fdt_valid()) { if (!fdt_valid()) {
return 1; return 1;
@ -75,15 +75,15 @@ int do_fdt (cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])
* Optional new length * Optional new length
*/ */
len = simple_strtoul(argv[3], NULL, 16); len = simple_strtoul(argv[3], NULL, 16);
if (len < fdt_totalsize(fdt)) { if (len < fdt_totalsize(working_fdt)) {
printf ("New length %d < existing length %d, " printf ("New length %d < existing length %d, "
"ignoring.\n", "ignoring.\n",
len, fdt_totalsize(fdt)); len, fdt_totalsize(working_fdt));
} else { } else {
/* /*
* Open in place with a new length. * Open in place with a new length.
*/ */
err = fdt_open_into(fdt, fdt, len); err = fdt_open_into(working_fdt, working_fdt, len);
if (err != 0) { if (err != 0) {
printf ("libfdt fdt_open_into(): %s\n", printf ("libfdt fdt_open_into(): %s\n",
fdt_strerror(err)); fdt_strerror(err));
@ -92,7 +92,7 @@ int do_fdt (cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])
} }
/******************************************************************** /********************************************************************
* Move the fdt * Move the working_fdt
********************************************************************/ ********************************************************************/
} else if (strncmp(argv[1], "mo", 2) == 0) { } else if (strncmp(argv[1], "mo", 2) == 0) {
struct fdt_header *newaddr; struct fdt_header *newaddr;
@ -107,7 +107,7 @@ int do_fdt (cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])
/* /*
* Set the address and length of the fdt. * Set the address and length of the fdt.
*/ */
fdt = (struct fdt_header *)simple_strtoul(argv[2], NULL, 16); working_fdt = (struct fdt_header *)simple_strtoul(argv[2], NULL, 16);
if (!fdt_valid()) { if (!fdt_valid()) {
return 1; return 1;
} }
@ -119,13 +119,13 @@ int do_fdt (cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])
* current length. * current length.
*/ */
if (argc <= 4) { if (argc <= 4) {
len = fdt_totalsize(fdt); len = fdt_totalsize(working_fdt);
} else { } else {
len = simple_strtoul(argv[4], NULL, 16); len = simple_strtoul(argv[4], NULL, 16);
if (len < fdt_totalsize(fdt)) { if (len < fdt_totalsize(working_fdt)) {
printf ("New length 0x%X < existing length " printf ("New length 0x%X < existing length "
"0x%X, aborting.\n", "0x%X, aborting.\n",
len, fdt_totalsize(fdt)); len, fdt_totalsize(working_fdt));
return 1; return 1;
} }
} }
@ -133,13 +133,13 @@ int do_fdt (cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])
/* /*
* Copy to the new location. * Copy to the new location.
*/ */
err = fdt_open_into(fdt, newaddr, len); err = fdt_open_into(working_fdt, newaddr, len);
if (err != 0) { if (err != 0) {
printf ("libfdt fdt_open_into(): %s\n", printf ("libfdt fdt_open_into(): %s\n",
fdt_strerror(err)); fdt_strerror(err));
return 1; return 1;
} }
fdt = newaddr; working_fdt = newaddr;
/******************************************************************** /********************************************************************
* Make a new node * Make a new node
@ -161,7 +161,7 @@ int do_fdt (cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])
pathp = argv[2]; pathp = argv[2];
nodep = argv[3]; nodep = argv[3];
nodeoffset = fdt_path_offset (fdt, pathp); nodeoffset = fdt_path_offset (working_fdt, pathp);
if (nodeoffset < 0) { if (nodeoffset < 0) {
/* /*
* Not found or something else bad happened. * Not found or something else bad happened.
@ -170,7 +170,7 @@ int do_fdt (cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])
fdt_strerror(nodeoffset)); fdt_strerror(nodeoffset));
return 1; return 1;
} }
err = fdt_add_subnode(fdt, nodeoffset, nodep); err = fdt_add_subnode(working_fdt, nodeoffset, nodep);
if (err < 0) { if (err < 0) {
printf ("libfdt fdt_add_subnode(): %s\n", printf ("libfdt fdt_add_subnode(): %s\n",
fdt_strerror(err)); fdt_strerror(err));
@ -178,7 +178,7 @@ int do_fdt (cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])
} }
/******************************************************************** /********************************************************************
* Set the value of a property in the fdt. * Set the value of a property in the working_fdt.
********************************************************************/ ********************************************************************/
} else if (argv[1][0] == 's') { } else if (argv[1][0] == 's') {
char *pathp; /* path */ char *pathp; /* path */
@ -206,7 +206,7 @@ int do_fdt (cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])
return ret; return ret;
} }
nodeoffset = fdt_path_offset (fdt, pathp); nodeoffset = fdt_path_offset (working_fdt, pathp);
if (nodeoffset < 0) { if (nodeoffset < 0) {
/* /*
* Not found or something else bad happened. * Not found or something else bad happened.
@ -216,7 +216,7 @@ int do_fdt (cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])
return 1; return 1;
} }
ret = fdt_setprop(fdt, nodeoffset, prop, data, len); ret = fdt_setprop(working_fdt, nodeoffset, prop, data, len);
if (ret < 0) { if (ret < 0) {
printf ("libfdt fdt_setprop(): %s\n", fdt_strerror(ret)); printf ("libfdt fdt_setprop(): %s\n", fdt_strerror(ret));
return 1; return 1;
@ -267,7 +267,7 @@ int do_fdt (cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])
* Get the path. The root node is an oddball, the offset * Get the path. The root node is an oddball, the offset
* is zero and has no name. * is zero and has no name.
*/ */
nodeoffset = fdt_path_offset (fdt, argv[2]); nodeoffset = fdt_path_offset (working_fdt, argv[2]);
if (nodeoffset < 0) { if (nodeoffset < 0) {
/* /*
* Not found or something else bad happened. * Not found or something else bad happened.
@ -281,14 +281,14 @@ int do_fdt (cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])
* otherwise delete the node. * otherwise delete the node.
*/ */
if (argc > 3) { if (argc > 3) {
err = fdt_delprop(fdt, nodeoffset, argv[3]); err = fdt_delprop(working_fdt, nodeoffset, argv[3]);
if (err < 0) { if (err < 0) {
printf("libfdt fdt_delprop(): %s\n", printf("libfdt fdt_delprop(): %s\n",
fdt_strerror(err)); fdt_strerror(err));
return err; return err;
} }
} else { } else {
err = fdt_del_node(fdt, nodeoffset); err = fdt_del_node(working_fdt, nodeoffset);
if (err < 0) { if (err < 0) {
printf("libfdt fdt_del_node(): %s\n", printf("libfdt fdt_del_node(): %s\n",
fdt_strerror(err)); fdt_strerror(err));
@ -300,24 +300,30 @@ int do_fdt (cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])
* Display header info * Display header info
********************************************************************/ ********************************************************************/
} else if (argv[1][0] == 'h') { } else if (argv[1][0] == 'h') {
u32 version = fdt_version(fdt); u32 version = fdt_version(working_fdt);
printf("magic:\t\t\t0x%x\n", fdt_magic(fdt)); printf("magic:\t\t\t0x%x\n", fdt_magic(working_fdt));
printf("totalsize:\t\t0x%x (%d)\n", fdt_totalsize(fdt), fdt_totalsize(fdt)); printf("totalsize:\t\t0x%x (%d)\n", fdt_totalsize(working_fdt),
printf("off_dt_struct:\t\t0x%x\n", fdt_off_dt_struct(fdt)); fdt_totalsize(working_fdt));
printf("off_dt_strings:\t\t0x%x\n", fdt_off_dt_strings(fdt)); printf("off_dt_struct:\t\t0x%x\n",
printf("off_mem_rsvmap:\t\t0x%x\n", fdt_off_mem_rsvmap(fdt)); fdt_off_dt_struct(working_fdt));
printf("off_dt_strings:\t\t0x%x\n",
fdt_off_dt_strings(working_fdt));
printf("off_mem_rsvmap:\t\t0x%x\n",
fdt_off_mem_rsvmap(working_fdt));
printf("version:\t\t%d\n", version); printf("version:\t\t%d\n", version);
printf("last_comp_version:\t%d\n", fdt_last_comp_version(fdt)); printf("last_comp_version:\t%d\n",
fdt_last_comp_version(working_fdt));
if (version >= 2) if (version >= 2)
printf("boot_cpuid_phys:\t0x%x\n", printf("boot_cpuid_phys:\t0x%x\n",
fdt_boot_cpuid_phys(fdt)); fdt_boot_cpuid_phys(working_fdt));
if (version >= 3) if (version >= 3)
printf("size_dt_strings:\t0x%x\n", printf("size_dt_strings:\t0x%x\n",
fdt_size_dt_strings(fdt)); fdt_size_dt_strings(working_fdt));
if (version >= 17) if (version >= 17)
printf("size_dt_struct:\t\t0x%x\n", printf("size_dt_struct:\t\t0x%x\n",
fdt_size_dt_struct(fdt)); fdt_size_dt_struct(working_fdt));
printf("number mem_rsv:\t\t0x%x\n", fdt_num_mem_rsv(fdt)); printf("number mem_rsv:\t\t0x%x\n",
fdt_num_mem_rsv(working_fdt));
printf("\n"); printf("\n");
/******************************************************************** /********************************************************************
@ -325,7 +331,7 @@ int do_fdt (cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])
********************************************************************/ ********************************************************************/
} else if (strncmp(argv[1], "boo", 3) == 0) { } else if (strncmp(argv[1], "boo", 3) == 0) {
unsigned long tmp = simple_strtoul(argv[2], NULL, 16); unsigned long tmp = simple_strtoul(argv[2], NULL, 16);
fdt_set_boot_cpuid_phys(fdt, tmp); fdt_set_boot_cpuid_phys(working_fdt, tmp);
/******************************************************************** /********************************************************************
* memory command * memory command
@ -340,7 +346,7 @@ int do_fdt (cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])
addr = simple_strtoul(argv[2], NULL, 16); addr = simple_strtoul(argv[2], NULL, 16);
size = simple_strtoul(argv[3], NULL, 16); size = simple_strtoul(argv[3], NULL, 16);
#endif #endif
err = fdt_fixup_memory(fdt, addr, size); err = fdt_fixup_memory(working_fdt, addr, size);
if (err < 0) if (err < 0)
return err; return err;
@ -350,13 +356,13 @@ int do_fdt (cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])
} else if (strncmp(argv[1], "rs", 2) == 0) { } else if (strncmp(argv[1], "rs", 2) == 0) {
if (argv[2][0] == 'p') { if (argv[2][0] == 'p') {
uint64_t addr, size; uint64_t addr, size;
int total = fdt_num_mem_rsv(fdt); int total = fdt_num_mem_rsv(working_fdt);
int j, err; int j, err;
printf("index\t\t start\t\t size\n"); printf("index\t\t start\t\t size\n");
printf("-------------------------------" printf("-------------------------------"
"-----------------\n"); "-----------------\n");
for (j = 0; j < total; j++) { for (j = 0; j < total; j++) {
err = fdt_get_mem_rsv(fdt, j, &addr, &size); err = fdt_get_mem_rsv(working_fdt, j, &addr, &size);
if (err < 0) { if (err < 0) {
printf("libfdt fdt_get_mem_rsv(): %s\n", printf("libfdt fdt_get_mem_rsv(): %s\n",
fdt_strerror(err)); fdt_strerror(err));
@ -378,7 +384,7 @@ int do_fdt (cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])
addr = simple_strtoul(argv[3], NULL, 16); addr = simple_strtoul(argv[3], NULL, 16);
size = simple_strtoul(argv[4], NULL, 16); size = simple_strtoul(argv[4], NULL, 16);
#endif #endif
err = fdt_add_mem_rsv(fdt, addr, size); err = fdt_add_mem_rsv(working_fdt, addr, size);
if (err < 0) { if (err < 0) {
printf("libfdt fdt_add_mem_rsv(): %s\n", printf("libfdt fdt_add_mem_rsv(): %s\n",
@ -387,7 +393,7 @@ int do_fdt (cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])
} }
} else if (argv[2][0] == 'd') { } else if (argv[2][0] == 'd') {
unsigned long idx = simple_strtoul(argv[3], NULL, 16); unsigned long idx = simple_strtoul(argv[3], NULL, 16);
int err = fdt_del_mem_rsv(fdt, idx); int err = fdt_del_mem_rsv(working_fdt, idx);
if (err < 0) { if (err < 0) {
printf("libfdt fdt_del_mem_rsv(): %s\n", printf("libfdt fdt_del_mem_rsv(): %s\n",
@ -403,11 +409,11 @@ int do_fdt (cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])
#ifdef CONFIG_OF_BOARD_SETUP #ifdef CONFIG_OF_BOARD_SETUP
/* Call the board-specific fixup routine */ /* Call the board-specific fixup routine */
else if (strncmp(argv[1], "boa", 3) == 0) else if (strncmp(argv[1], "boa", 3) == 0)
ft_board_setup(fdt, gd->bd); ft_board_setup(working_fdt, gd->bd);
#endif #endif
/* Create a chosen node */ /* Create a chosen node */
else if (argv[1][0] == 'c') else if (argv[1][0] == 'c')
fdt_chosen(fdt, 0, 0, 1); fdt_chosen(working_fdt, 0, 0, 1);
else { else {
/* Unrecognized command */ /* Unrecognized command */
printf ("Usage:\n%s\n", cmdtp->usage); printf ("Usage:\n%s\n", cmdtp->usage);
@ -423,12 +429,12 @@ static int fdt_valid(void)
{ {
int err; int err;
if (fdt == NULL) { if (working_fdt == NULL) {
printf ("The address of the fdt is invalid (NULL).\n"); printf ("The address of the fdt is invalid (NULL).\n");
return 0; return 0;
} }
err = fdt_check_header(fdt); err = fdt_check_header(working_fdt);
if (err == 0) if (err == 0)
return 1; /* valid */ return 1; /* valid */
@ -438,17 +444,19 @@ static int fdt_valid(void)
* Be more informative on bad version. * Be more informative on bad version.
*/ */
if (err == -FDT_ERR_BADVERSION) { if (err == -FDT_ERR_BADVERSION) {
if (fdt_version(fdt) < FDT_FIRST_SUPPORTED_VERSION) { if (fdt_version(working_fdt) <
FDT_FIRST_SUPPORTED_VERSION) {
printf (" - too old, fdt $d < %d", printf (" - too old, fdt $d < %d",
fdt_version(fdt), fdt_version(working_fdt),
FDT_FIRST_SUPPORTED_VERSION); FDT_FIRST_SUPPORTED_VERSION);
fdt = NULL; working_fdt = NULL;
} }
if (fdt_last_comp_version(fdt) > FDT_LAST_SUPPORTED_VERSION) { if (fdt_last_comp_version(working_fdt) >
FDT_LAST_SUPPORTED_VERSION) {
printf (" - too new, fdt $d > %d", printf (" - too new, fdt $d > %d",
fdt_version(fdt), fdt_version(working_fdt),
FDT_LAST_SUPPORTED_VERSION); FDT_LAST_SUPPORTED_VERSION);
fdt = NULL; working_fdt = NULL;
} }
return 0; return 0;
} }
@ -644,7 +652,7 @@ static void print_data(const void *data, int len)
/****************************************************************************/ /****************************************************************************/
/* /*
* Recursively print (a portion of) the fdt. The depth parameter * Recursively print (a portion of) the working_fdt. The depth parameter
* determines how deeply nested the fdt is printed. * determines how deeply nested the fdt is printed.
*/ */
static int fdt_print(const char *pathp, char *prop, int depth) static int fdt_print(const char *pathp, char *prop, int depth)
@ -660,7 +668,7 @@ static int fdt_print(const char *pathp, char *prop, int depth)
int level = 0; /* keep track of nesting level */ int level = 0; /* keep track of nesting level */
const struct fdt_property *fdt_prop; const struct fdt_property *fdt_prop;
nodeoffset = fdt_path_offset (fdt, pathp); nodeoffset = fdt_path_offset (working_fdt, pathp);
if (nodeoffset < 0) { if (nodeoffset < 0) {
/* /*
* Not found or something else bad happened. * Not found or something else bad happened.
@ -674,7 +682,7 @@ static int fdt_print(const char *pathp, char *prop, int depth)
* Print only the given property and then return. * Print only the given property and then return.
*/ */
if (prop) { if (prop) {
nodep = fdt_getprop (fdt, nodeoffset, prop, &len); nodep = fdt_getprop (working_fdt, nodeoffset, prop, &len);
if (len == 0) { if (len == 0) {
/* no property value */ /* no property value */
printf("%s %s\n", pathp, prop); printf("%s %s\n", pathp, prop);
@ -696,10 +704,10 @@ static int fdt_print(const char *pathp, char *prop, int depth)
* print the node and all subnodes. * print the node and all subnodes.
*/ */
while(level >= 0) { while(level >= 0) {
tag = fdt_next_tag(fdt, nodeoffset, &nextoffset); tag = fdt_next_tag(working_fdt, nodeoffset, &nextoffset);
switch(tag) { switch(tag) {
case FDT_BEGIN_NODE: case FDT_BEGIN_NODE:
pathp = fdt_get_name(fdt, nodeoffset, NULL); pathp = fdt_get_name(working_fdt, nodeoffset, NULL);
if (level <= depth) { if (level <= depth) {
if (pathp == NULL) if (pathp == NULL)
pathp = "/* NULL pointer error */"; pathp = "/* NULL pointer error */";
@ -723,9 +731,9 @@ static int fdt_print(const char *pathp, char *prop, int depth)
} }
break; break;
case FDT_PROP: case FDT_PROP:
fdt_prop = fdt_offset_ptr(fdt, nodeoffset, fdt_prop = fdt_offset_ptr(working_fdt, nodeoffset,
sizeof(*fdt_prop)); sizeof(*fdt_prop));
pathp = fdt_string(fdt, pathp = fdt_string(working_fdt,
fdt32_to_cpu(fdt_prop->nameoff)); fdt32_to_cpu(fdt_prop->nameoff));
len = fdt32_to_cpu(fdt_prop->len); len = fdt32_to_cpu(fdt_prop->len);
nodep = fdt_prop->data; nodep = fdt_prop->data;

2
common/fdt_support.c
Unescape View File

@ -38,7 +38,7 @@ DECLARE_GLOBAL_DATA_PTR;
/* /*
* fdt points to our working device tree. * fdt points to our working device tree.
*/ */
struct fdt_header *fdt; struct fdt_header *working_fdt;
/** /**

2
include/libfdt_env.h
Unescape View File

@ -31,7 +31,7 @@
#include <stddef.h> #include <stddef.h>
#include <asm/byteorder.h> #include <asm/byteorder.h>
extern struct fdt_header *fdt; /* Pointer to the working fdt */ extern struct fdt_header *working_fdt; /* Pointer to the working fdt */
#define fdt32_to_cpu(x) __be32_to_cpu(x) #define fdt32_to_cpu(x) __be32_to_cpu(x)
#define cpu_to_fdt32(x) __cpu_to_be32(x) #define cpu_to_fdt32(x) __cpu_to_be32(x)

2
lib_ppc/bootm.c
Unescape View File

@ -750,7 +750,7 @@ static int boot_relocate_fdt (struct lmb *lmb, ulong bootmap_base,
*of_flat_tree = (char *)of_start; *of_flat_tree = (char *)of_start;
} else { } else {
*of_flat_tree = fdt_blob; *of_flat_tree = fdt_blob;
lmb_reserve(lmb, (ulong)fdt, of_len); lmb_reserve(lmb, (ulong)working_fdt, of_len);
} }
return 0; return 0;

Write Preview
Loading…
Cancel
Save