2 * (C) Copyright David Gibson <dwg@au1.ibm.com>, IBM Corporation. 2005.
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
7 * published by the Free Software Foundation; either version 2 of the
8 * License, or (at your option) any later version.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
24 #define FTF_FULLPATH 0x1
25 #define FTF_VARALIGN 0x2
26 #define FTF_NAMEPROPS 0x4
27 #define FTF_BOOTCPUID 0x8
28 #define FTF_STRTABSIZE 0x10
29 #define FTF_STRUCTSIZE 0x20
32 static struct version_info
{
34 int last_comp_version
;
39 FTF_FULLPATH
|FTF_VARALIGN
|FTF_NAMEPROPS
},
41 FTF_FULLPATH
|FTF_VARALIGN
|FTF_NAMEPROPS
|FTF_BOOTCPUID
},
43 FTF_FULLPATH
|FTF_VARALIGN
|FTF_NAMEPROPS
|FTF_BOOTCPUID
|FTF_STRTABSIZE
},
45 FTF_BOOTCPUID
|FTF_STRTABSIZE
|FTF_NOPS
},
46 {17, 16, FDT_V17_SIZE
,
47 FTF_BOOTCPUID
|FTF_STRTABSIZE
|FTF_STRUCTSIZE
|FTF_NOPS
},
51 void (*cell
)(void *, cell_t
);
52 void (*string
)(void *, char *, int);
53 void (*align
)(void *, int);
54 void (*data
)(void *, struct data
);
55 void (*beginnode
)(void *, struct label
*labels
);
56 void (*endnode
)(void *, struct label
*labels
);
57 void (*property
)(void *, struct label
*labels
);
60 static void bin_emit_cell(void *e
, cell_t val
)
62 struct data
*dtbuf
= e
;
64 *dtbuf
= data_append_cell(*dtbuf
, val
);
67 static void bin_emit_string(void *e
, char *str
, int len
)
69 struct data
*dtbuf
= e
;
74 *dtbuf
= data_append_data(*dtbuf
, str
, len
);
75 *dtbuf
= data_append_byte(*dtbuf
, '\0');
78 static void bin_emit_align(void *e
, int a
)
80 struct data
*dtbuf
= e
;
82 *dtbuf
= data_append_align(*dtbuf
, a
);
85 static void bin_emit_data(void *e
, struct data d
)
87 struct data
*dtbuf
= e
;
89 *dtbuf
= data_append_data(*dtbuf
, d
.val
, d
.len
);
92 static void bin_emit_beginnode(void *e
, struct label
*labels
)
94 bin_emit_cell(e
, FDT_BEGIN_NODE
);
97 static void bin_emit_endnode(void *e
, struct label
*labels
)
99 bin_emit_cell(e
, FDT_END_NODE
);
102 static void bin_emit_property(void *e
, struct label
*labels
)
104 bin_emit_cell(e
, FDT_PROP
);
107 static struct emitter bin_emitter
= {
108 .cell
= bin_emit_cell
,
109 .string
= bin_emit_string
,
110 .align
= bin_emit_align
,
111 .data
= bin_emit_data
,
112 .beginnode
= bin_emit_beginnode
,
113 .endnode
= bin_emit_endnode
,
114 .property
= bin_emit_property
,
117 static void emit_label(FILE *f
, const char *prefix
, const char *label
)
119 fprintf(f
, "\t.globl\t%s_%s\n", prefix
, label
);
120 fprintf(f
, "%s_%s:\n", prefix
, label
);
121 fprintf(f
, "_%s_%s:\n", prefix
, label
);
124 static void emit_offset_label(FILE *f
, const char *label
, int offset
)
126 fprintf(f
, "\t.globl\t%s\n", label
);
127 fprintf(f
, "%s\t= . + %d\n", label
, offset
);
130 #define ASM_EMIT_BELONG(f, fmt, ...) \
132 fprintf((f), "\t.byte\t((" fmt ") >> 24) & 0xff\n", __VA_ARGS__); \
133 fprintf((f), "\t.byte\t((" fmt ") >> 16) & 0xff\n", __VA_ARGS__); \
134 fprintf((f), "\t.byte\t((" fmt ") >> 8) & 0xff\n", __VA_ARGS__); \
135 fprintf((f), "\t.byte\t(" fmt ") & 0xff\n", __VA_ARGS__); \
138 static void asm_emit_cell(void *e
, cell_t val
)
142 fprintf(f
, "\t.byte 0x%02x; .byte 0x%02x; .byte 0x%02x; .byte 0x%02x\n",
143 (val
>> 24) & 0xff, (val
>> 16) & 0xff,
144 (val
>> 8) & 0xff, val
& 0xff);
147 static void asm_emit_string(void *e
, char *str
, int len
)
158 fprintf(f
, "\t.string\t\"%s\"\n", str
);
165 static void asm_emit_align(void *e
, int a
)
169 fprintf(f
, "\t.balign\t%d, 0\n", a
);
172 static void asm_emit_data(void *e
, struct data d
)
176 struct marker
*m
= d
.markers
;
178 for_each_marker_of_type(m
, LABEL
)
179 emit_offset_label(f
, m
->ref
, m
->offset
);
181 while ((d
.len
- off
) >= sizeof(uint32_t)) {
182 asm_emit_cell(e
, fdt32_to_cpu(*((uint32_t *)(d
.val
+off
))));
183 off
+= sizeof(uint32_t);
186 while ((d
.len
- off
) >= 1) {
187 fprintf(f
, "\t.byte\t0x%hhx\n", d
.val
[off
]);
191 assert(off
== d
.len
);
194 static void asm_emit_beginnode(void *e
, struct label
*labels
)
199 for_each_label(labels
, l
) {
200 fprintf(f
, "\t.globl\t%s\n", l
->label
);
201 fprintf(f
, "%s:\n", l
->label
);
203 fprintf(f
, "\t/* FDT_BEGIN_NODE */\n");
204 asm_emit_cell(e
, FDT_BEGIN_NODE
);
207 static void asm_emit_endnode(void *e
, struct label
*labels
)
212 fprintf(f
, "\t/* FDT_END_NODE */\n");
213 asm_emit_cell(e
, FDT_END_NODE
);
214 for_each_label(labels
, l
) {
215 fprintf(f
, "\t.globl\t%s_end\n", l
->label
);
216 fprintf(f
, "%s_end:\n", l
->label
);
220 static void asm_emit_property(void *e
, struct label
*labels
)
225 for_each_label(labels
, l
) {
226 fprintf(f
, "\t.globl\t%s\n", l
->label
);
227 fprintf(f
, "%s:\n", l
->label
);
229 fprintf(f
, "\t/* FDT_PROP */\n");
230 asm_emit_cell(e
, FDT_PROP
);
233 static struct emitter asm_emitter
= {
234 .cell
= asm_emit_cell
,
235 .string
= asm_emit_string
,
236 .align
= asm_emit_align
,
237 .data
= asm_emit_data
,
238 .beginnode
= asm_emit_beginnode
,
239 .endnode
= asm_emit_endnode
,
240 .property
= asm_emit_property
,
243 static int stringtable_insert(struct data
*d
, const char *str
)
247 /* FIXME: do this more efficiently? */
249 for (i
= 0; i
< d
->len
; i
++) {
250 if (streq(str
, d
->val
+ i
))
254 *d
= data_append_data(*d
, str
, strlen(str
)+1);
258 static void flatten_tree(struct node
*tree
, struct emitter
*emit
,
259 void *etarget
, struct data
*strbuf
,
260 struct version_info
*vi
)
262 struct property
*prop
;
264 bool seen_name_prop
= false;
269 emit
->beginnode(etarget
, tree
->labels
);
271 if (vi
->flags
& FTF_FULLPATH
)
272 emit
->string(etarget
, tree
->fullpath
, 0);
274 emit
->string(etarget
, tree
->name
, 0);
276 emit
->align(etarget
, sizeof(cell_t
));
278 for_each_property(tree
, prop
) {
281 if (streq(prop
->name
, "name"))
282 seen_name_prop
= true;
284 nameoff
= stringtable_insert(strbuf
, prop
->name
);
286 emit
->property(etarget
, prop
->labels
);
287 emit
->cell(etarget
, prop
->val
.len
);
288 emit
->cell(etarget
, nameoff
);
290 if ((vi
->flags
& FTF_VARALIGN
) && (prop
->val
.len
>= 8))
291 emit
->align(etarget
, 8);
293 emit
->data(etarget
, prop
->val
);
294 emit
->align(etarget
, sizeof(cell_t
));
297 if ((vi
->flags
& FTF_NAMEPROPS
) && !seen_name_prop
) {
298 emit
->property(etarget
, NULL
);
299 emit
->cell(etarget
, tree
->basenamelen
+1);
300 emit
->cell(etarget
, stringtable_insert(strbuf
, "name"));
302 if ((vi
->flags
& FTF_VARALIGN
) && ((tree
->basenamelen
+1) >= 8))
303 emit
->align(etarget
, 8);
305 emit
->string(etarget
, tree
->name
, tree
->basenamelen
);
306 emit
->align(etarget
, sizeof(cell_t
));
309 for_each_child(tree
, child
) {
310 flatten_tree(child
, emit
, etarget
, strbuf
, vi
);
313 emit
->endnode(etarget
, tree
->labels
);
316 static struct data
flatten_reserve_list(struct reserve_info
*reservelist
,
317 struct version_info
*vi
)
319 struct reserve_info
*re
;
320 struct data d
= empty_data
;
321 static struct fdt_reserve_entry null_re
= {0,0};
324 for (re
= reservelist
; re
; re
= re
->next
) {
325 d
= data_append_re(d
, &re
->re
);
328 * Add additional reserved slots if the user asked for them.
330 for (j
= 0; j
< reservenum
; j
++) {
331 d
= data_append_re(d
, &null_re
);
337 static void make_fdt_header(struct fdt_header
*fdt
,
338 struct version_info
*vi
,
339 int reservesize
, int dtsize
, int strsize
,
344 reservesize
+= sizeof(struct fdt_reserve_entry
);
346 memset(fdt
, 0xff, sizeof(*fdt
));
348 fdt
->magic
= cpu_to_fdt32(FDT_MAGIC
);
349 fdt
->version
= cpu_to_fdt32(vi
->version
);
350 fdt
->last_comp_version
= cpu_to_fdt32(vi
->last_comp_version
);
352 /* Reserve map should be doubleword aligned */
353 reserve_off
= ALIGN(vi
->hdr_size
, 8);
355 fdt
->off_mem_rsvmap
= cpu_to_fdt32(reserve_off
);
356 fdt
->off_dt_struct
= cpu_to_fdt32(reserve_off
+ reservesize
);
357 fdt
->off_dt_strings
= cpu_to_fdt32(reserve_off
+ reservesize
359 fdt
->totalsize
= cpu_to_fdt32(reserve_off
+ reservesize
+ dtsize
+ strsize
);
361 if (vi
->flags
& FTF_BOOTCPUID
)
362 fdt
->boot_cpuid_phys
= cpu_to_fdt32(boot_cpuid_phys
);
363 if (vi
->flags
& FTF_STRTABSIZE
)
364 fdt
->size_dt_strings
= cpu_to_fdt32(strsize
);
365 if (vi
->flags
& FTF_STRUCTSIZE
)
366 fdt
->size_dt_struct
= cpu_to_fdt32(dtsize
);
369 void dt_to_blob(FILE *f
, struct dt_info
*dti
, int version
)
371 struct version_info
*vi
= NULL
;
373 struct data blob
= empty_data
;
374 struct data reservebuf
= empty_data
;
375 struct data dtbuf
= empty_data
;
376 struct data strbuf
= empty_data
;
377 struct fdt_header fdt
;
380 for (i
= 0; i
< ARRAY_SIZE(version_table
); i
++) {
381 if (version_table
[i
].version
== version
)
382 vi
= &version_table
[i
];
385 die("Unknown device tree blob version %d\n", version
);
387 flatten_tree(dti
->dt
, &bin_emitter
, &dtbuf
, &strbuf
, vi
);
388 bin_emit_cell(&dtbuf
, FDT_END
);
390 reservebuf
= flatten_reserve_list(dti
->reservelist
, vi
);
393 make_fdt_header(&fdt
, vi
, reservebuf
.len
, dtbuf
.len
, strbuf
.len
,
394 dti
->boot_cpuid_phys
);
397 * If the user asked for more space than is used, adjust the totalsize.
400 padlen
= minsize
- fdt32_to_cpu(fdt
.totalsize
);
405 "Warning: blob size %d >= minimum size %d\n",
406 fdt32_to_cpu(fdt
.totalsize
), minsize
);
414 padlen
= ALIGN(fdt32_to_cpu(fdt
.totalsize
) + padlen
, alignsize
)
415 - fdt32_to_cpu(fdt
.totalsize
);
418 int tsize
= fdt32_to_cpu(fdt
.totalsize
);
420 fdt
.totalsize
= cpu_to_fdt32(tsize
);
424 * Assemble the blob: start with the header, add with alignment
425 * the reserve buffer, add the reserve map terminating zeroes,
426 * the device tree itself, and finally the strings.
428 blob
= data_append_data(blob
, &fdt
, vi
->hdr_size
);
429 blob
= data_append_align(blob
, 8);
430 blob
= data_merge(blob
, reservebuf
);
431 blob
= data_append_zeroes(blob
, sizeof(struct fdt_reserve_entry
));
432 blob
= data_merge(blob
, dtbuf
);
433 blob
= data_merge(blob
, strbuf
);
436 * If the user asked for more space than is used, pad out the blob.
439 blob
= data_append_zeroes(blob
, padlen
);
441 if (fwrite(blob
.val
, blob
.len
, 1, f
) != 1) {
443 die("Error writing device tree blob: %s\n",
446 die("Short write on device tree blob\n");
450 * data_merge() frees the right-hand element so only the blob
451 * remains to be freed.
456 static void dump_stringtable_asm(FILE *f
, struct data strbuf
)
463 while (p
< (strbuf
.val
+ strbuf
.len
)) {
465 fprintf(f
, "\t.string \"%s\"\n", p
);
470 void dt_to_asm(FILE *f
, struct dt_info
*dti
, int version
)
472 struct version_info
*vi
= NULL
;
474 struct data strbuf
= empty_data
;
475 struct reserve_info
*re
;
476 const char *symprefix
= "dt";
478 for (i
= 0; i
< ARRAY_SIZE(version_table
); i
++) {
479 if (version_table
[i
].version
== version
)
480 vi
= &version_table
[i
];
483 die("Unknown device tree blob version %d\n", version
);
485 fprintf(f
, "/* autogenerated by dtc, do not edit */\n\n");
487 emit_label(f
, symprefix
, "blob_start");
488 emit_label(f
, symprefix
, "header");
489 fprintf(f
, "\t/* magic */\n");
490 asm_emit_cell(f
, FDT_MAGIC
);
491 fprintf(f
, "\t/* totalsize */\n");
492 ASM_EMIT_BELONG(f
, "_%s_blob_abs_end - _%s_blob_start",
493 symprefix
, symprefix
);
494 fprintf(f
, "\t/* off_dt_struct */\n");
495 ASM_EMIT_BELONG(f
, "_%s_struct_start - _%s_blob_start",
496 symprefix
, symprefix
);
497 fprintf(f
, "\t/* off_dt_strings */\n");
498 ASM_EMIT_BELONG(f
, "_%s_strings_start - _%s_blob_start",
499 symprefix
, symprefix
);
500 fprintf(f
, "\t/* off_mem_rsvmap */\n");
501 ASM_EMIT_BELONG(f
, "_%s_reserve_map - _%s_blob_start",
502 symprefix
, symprefix
);
503 fprintf(f
, "\t/* version */\n");
504 asm_emit_cell(f
, vi
->version
);
505 fprintf(f
, "\t/* last_comp_version */\n");
506 asm_emit_cell(f
, vi
->last_comp_version
);
508 if (vi
->flags
& FTF_BOOTCPUID
) {
509 fprintf(f
, "\t/* boot_cpuid_phys */\n");
510 asm_emit_cell(f
, dti
->boot_cpuid_phys
);
513 if (vi
->flags
& FTF_STRTABSIZE
) {
514 fprintf(f
, "\t/* size_dt_strings */\n");
515 ASM_EMIT_BELONG(f
, "_%s_strings_end - _%s_strings_start",
516 symprefix
, symprefix
);
519 if (vi
->flags
& FTF_STRUCTSIZE
) {
520 fprintf(f
, "\t/* size_dt_struct */\n");
521 ASM_EMIT_BELONG(f
, "_%s_struct_end - _%s_struct_start",
522 symprefix
, symprefix
);
526 * Reserve map entries.
527 * Align the reserve map to a doubleword boundary.
528 * Each entry is an (address, size) pair of u64 values.
529 * Always supply a zero-sized temination entry.
531 asm_emit_align(f
, 8);
532 emit_label(f
, symprefix
, "reserve_map");
534 fprintf(f
, "/* Memory reserve map from source file */\n");
537 * Use .long on high and low halfs of u64s to avoid .quad
538 * as it appears .quad isn't available in some assemblers.
540 for (re
= dti
->reservelist
; re
; re
= re
->next
) {
543 for_each_label(re
->labels
, l
) {
544 fprintf(f
, "\t.globl\t%s\n", l
->label
);
545 fprintf(f
, "%s:\n", l
->label
);
547 ASM_EMIT_BELONG(f
, "0x%08x", (unsigned int)(re
->re
.address
>> 32));
548 ASM_EMIT_BELONG(f
, "0x%08x",
549 (unsigned int)(re
->re
.address
& 0xffffffff));
550 ASM_EMIT_BELONG(f
, "0x%08x", (unsigned int)(re
->re
.size
>> 32));
551 ASM_EMIT_BELONG(f
, "0x%08x", (unsigned int)(re
->re
.size
& 0xffffffff));
553 for (i
= 0; i
< reservenum
; i
++) {
554 fprintf(f
, "\t.long\t0, 0\n\t.long\t0, 0\n");
557 fprintf(f
, "\t.long\t0, 0\n\t.long\t0, 0\n");
559 emit_label(f
, symprefix
, "struct_start");
560 flatten_tree(dti
->dt
, &asm_emitter
, f
, &strbuf
, vi
);
562 fprintf(f
, "\t/* FDT_END */\n");
563 asm_emit_cell(f
, FDT_END
);
564 emit_label(f
, symprefix
, "struct_end");
566 emit_label(f
, symprefix
, "strings_start");
567 dump_stringtable_asm(f
, strbuf
);
568 emit_label(f
, symprefix
, "strings_end");
570 emit_label(f
, symprefix
, "blob_end");
573 * If the user asked for more space than is used, pad it out.
576 fprintf(f
, "\t.space\t%d - (_%s_blob_end - _%s_blob_start), 0\n",
577 minsize
, symprefix
, symprefix
);
580 fprintf(f
, "\t.space\t%d, 0\n", padsize
);
583 asm_emit_align(f
, alignsize
);
584 emit_label(f
, symprefix
, "blob_abs_end");
590 char *base
, *limit
, *ptr
;
593 static void inbuf_init(struct inbuf
*inb
, void *base
, void *limit
)
597 inb
->ptr
= inb
->base
;
600 static void flat_read_chunk(struct inbuf
*inb
, void *p
, int len
)
602 if ((inb
->ptr
+ len
) > inb
->limit
)
603 die("Premature end of data parsing flat device tree\n");
605 memcpy(p
, inb
->ptr
, len
);
610 static uint32_t flat_read_word(struct inbuf
*inb
)
614 assert(((inb
->ptr
- inb
->base
) % sizeof(val
)) == 0);
616 flat_read_chunk(inb
, &val
, sizeof(val
));
618 return fdt32_to_cpu(val
);
621 static void flat_realign(struct inbuf
*inb
, int align
)
623 int off
= inb
->ptr
- inb
->base
;
625 inb
->ptr
= inb
->base
+ ALIGN(off
, align
);
626 if (inb
->ptr
> inb
->limit
)
627 die("Premature end of data parsing flat device tree\n");
630 static char *flat_read_string(struct inbuf
*inb
)
633 const char *p
= inb
->ptr
;
638 die("Premature end of data parsing flat device tree\n");
640 } while ((*p
++) != '\0');
642 str
= xstrdup(inb
->ptr
);
646 flat_realign(inb
, sizeof(uint32_t));
651 static struct data
flat_read_data(struct inbuf
*inb
, int len
)
653 struct data d
= empty_data
;
658 d
= data_grow_for(d
, len
);
661 flat_read_chunk(inb
, d
.val
, len
);
663 flat_realign(inb
, sizeof(uint32_t));
668 static char *flat_read_stringtable(struct inbuf
*inb
, int offset
)
672 p
= inb
->base
+ offset
;
674 if (p
>= inb
->limit
|| p
< inb
->base
)
675 die("String offset %d overruns string table\n",
684 return xstrdup(inb
->base
+ offset
);
687 static struct property
*flat_read_property(struct inbuf
*dtbuf
,
688 struct inbuf
*strbuf
, int flags
)
690 uint32_t proplen
, stroff
;
694 proplen
= flat_read_word(dtbuf
);
695 stroff
= flat_read_word(dtbuf
);
697 name
= flat_read_stringtable(strbuf
, stroff
);
699 if ((flags
& FTF_VARALIGN
) && (proplen
>= 8))
700 flat_realign(dtbuf
, 8);
702 val
= flat_read_data(dtbuf
, proplen
);
704 return build_property(name
, val
);
708 static struct reserve_info
*flat_read_mem_reserve(struct inbuf
*inb
)
710 struct reserve_info
*reservelist
= NULL
;
711 struct reserve_info
*new;
712 struct fdt_reserve_entry re
;
715 * Each entry is a pair of u64 (addr, size) values for 4 cell_t's.
716 * List terminates at an entry with size equal to zero.
718 * First pass, count entries.
721 flat_read_chunk(inb
, &re
, sizeof(re
));
722 re
.address
= fdt64_to_cpu(re
.address
);
723 re
.size
= fdt64_to_cpu(re
.size
);
727 new = build_reserve_entry(re
.address
, re
.size
);
728 reservelist
= add_reserve_entry(reservelist
, new);
735 static char *nodename_from_path(const char *ppath
, const char *cpath
)
739 plen
= strlen(ppath
);
741 if (!strneq(ppath
, cpath
, plen
))
742 die("Path \"%s\" is not valid as a child of \"%s\"\n",
745 /* root node is a special case */
746 if (!streq(ppath
, "/"))
749 return xstrdup(cpath
+ plen
);
752 static struct node
*unflatten_tree(struct inbuf
*dtbuf
,
753 struct inbuf
*strbuf
,
754 const char *parent_flatname
, int flags
)
760 node
= build_node(NULL
, NULL
);
762 flatname
= flat_read_string(dtbuf
);
764 if (flags
& FTF_FULLPATH
)
765 node
->name
= nodename_from_path(parent_flatname
, flatname
);
767 node
->name
= flatname
;
770 struct property
*prop
;
773 val
= flat_read_word(dtbuf
);
777 fprintf(stderr
, "Warning: Flat tree input has "
778 "subnodes preceding a property.\n");
779 prop
= flat_read_property(dtbuf
, strbuf
, flags
);
780 add_property(node
, prop
);
784 child
= unflatten_tree(dtbuf
,strbuf
, flatname
, flags
);
785 add_child(node
, child
);
792 die("Premature FDT_END in device tree blob\n");
796 if (!(flags
& FTF_NOPS
))
797 fprintf(stderr
, "Warning: NOP tag found in flat tree"
804 die("Invalid opcode word %08x in device tree blob\n",
807 } while (val
!= FDT_END_NODE
);
809 if (node
->name
!= flatname
) {
817 struct dt_info
*dt_from_blob(const char *fname
)
820 uint32_t magic
, totalsize
, version
, size_dt
, boot_cpuid_phys
;
821 uint32_t off_dt
, off_str
, off_mem_rsvmap
;
824 struct fdt_header
*fdt
;
826 struct inbuf dtbuf
, strbuf
;
827 struct inbuf memresvbuf
;
829 struct reserve_info
*reservelist
;
834 f
= srcfile_relative_open(fname
, NULL
);
836 rc
= fread(&magic
, sizeof(magic
), 1, f
);
838 die("Error reading DT blob magic number: %s\n",
842 die("EOF reading DT blob magic number\n");
844 die("Mysterious short read reading magic number\n");
847 magic
= fdt32_to_cpu(magic
);
848 if (magic
!= FDT_MAGIC
)
849 die("Blob has incorrect magic number\n");
851 rc
= fread(&totalsize
, sizeof(totalsize
), 1, f
);
853 die("Error reading DT blob size: %s\n", strerror(errno
));
856 die("EOF reading DT blob size\n");
858 die("Mysterious short read reading blob size\n");
861 totalsize
= fdt32_to_cpu(totalsize
);
862 if (totalsize
< FDT_V1_SIZE
)
863 die("DT blob size (%d) is too small\n", totalsize
);
865 blob
= xmalloc(totalsize
);
867 fdt
= (struct fdt_header
*)blob
;
868 fdt
->magic
= cpu_to_fdt32(magic
);
869 fdt
->totalsize
= cpu_to_fdt32(totalsize
);
871 sizeleft
= totalsize
- sizeof(magic
) - sizeof(totalsize
);
872 p
= blob
+ sizeof(magic
) + sizeof(totalsize
);
876 die("EOF before reading %d bytes of DT blob\n",
879 rc
= fread(p
, 1, sizeleft
, f
);
881 die("Error reading DT blob: %s\n",
888 off_dt
= fdt32_to_cpu(fdt
->off_dt_struct
);
889 off_str
= fdt32_to_cpu(fdt
->off_dt_strings
);
890 off_mem_rsvmap
= fdt32_to_cpu(fdt
->off_mem_rsvmap
);
891 version
= fdt32_to_cpu(fdt
->version
);
892 boot_cpuid_phys
= fdt32_to_cpu(fdt
->boot_cpuid_phys
);
894 if (off_mem_rsvmap
>= totalsize
)
895 die("Mem Reserve structure offset exceeds total size\n");
897 if (off_dt
>= totalsize
)
898 die("DT structure offset exceeds total size\n");
900 if (off_str
> totalsize
)
901 die("String table offset exceeds total size\n");
904 uint32_t size_str
= fdt32_to_cpu(fdt
->size_dt_strings
);
905 if ((off_str
+size_str
< off_str
) || (off_str
+size_str
> totalsize
))
906 die("String table extends past total size\n");
907 inbuf_init(&strbuf
, blob
+ off_str
, blob
+ off_str
+ size_str
);
909 inbuf_init(&strbuf
, blob
+ off_str
, blob
+ totalsize
);
913 size_dt
= fdt32_to_cpu(fdt
->size_dt_struct
);
914 if ((off_dt
+size_dt
< off_dt
) || (off_dt
+size_dt
> totalsize
))
915 die("Structure block extends past total size\n");
919 flags
|= FTF_FULLPATH
| FTF_NAMEPROPS
| FTF_VARALIGN
;
924 inbuf_init(&memresvbuf
,
925 blob
+ off_mem_rsvmap
, blob
+ totalsize
);
926 inbuf_init(&dtbuf
, blob
+ off_dt
, blob
+ totalsize
);
928 reservelist
= flat_read_mem_reserve(&memresvbuf
);
930 val
= flat_read_word(&dtbuf
);
932 if (val
!= FDT_BEGIN_NODE
)
933 die("Device tree blob doesn't begin with FDT_BEGIN_NODE (begins with 0x%08x)\n", val
);
935 tree
= unflatten_tree(&dtbuf
, &strbuf
, "", flags
);
937 val
= flat_read_word(&dtbuf
);
939 die("Device tree blob doesn't end with FDT_END\n");
945 return build_dt_info(DTSF_V1
, reservelist
, tree
, boot_cpuid_phys
);