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 emit_local_fixups(struct node
*tree
, struct emitter
*emit
,
259 void *etarget
, struct data
*strbuf
, struct version_info
*vi
,
262 struct fixup_entry
*fe
, *fen
;
268 if (node
->emit_local_fixup_node
) {
270 /* emit the external fixups (do not emit /) */
272 emit
->beginnode(etarget
, NULL
);
273 emit
->string(etarget
, node
->name
, 0);
274 emit
->align(etarget
, sizeof(cell_t
));
277 for_each_local_fixup_entry(tree
, fe
) {
278 if (fe
->node
!= node
|| fe
->local_fixup_generated
)
281 /* count the number of fixup entries */
283 for_each_local_fixup_entry(tree
, fen
) {
284 if (fen
->prop
!= fe
->prop
)
286 fen
->local_fixup_generated
= true;
290 /* allocate buffer */
291 buf
= xmalloc(count
* sizeof(cell_t
));
293 /* collect all the offsets in buffer */
295 for_each_local_fixup_entry(tree
, fen
) {
296 if (fen
->prop
!= fe
->prop
)
298 fen
->local_fixup_generated
= true;
299 buf
[count
++] = cpu_to_fdt32(fen
->offset
);
302 d
.len
= count
* sizeof(cell_t
);
305 nameoff
= stringtable_insert(strbuf
, fe
->prop
->name
);
306 emit
->property(etarget
, fe
->prop
->labels
);
307 emit
->cell(etarget
, count
* sizeof(cell_t
));
308 emit
->cell(etarget
, nameoff
);
310 if ((vi
->flags
& FTF_VARALIGN
) &&
311 (count
* sizeof(cell_t
)) >= 8)
312 emit
->align(etarget
, 8);
314 emit
->data(etarget
, d
);
315 emit
->align(etarget
, sizeof(cell_t
));
321 for_each_child(node
, child
)
322 emit_local_fixups(tree
, emit
, etarget
, strbuf
, vi
, child
);
324 if (node
->emit_local_fixup_node
&& node
!= tree
)
325 emit
->endnode(etarget
, tree
->labels
);
328 static void emit_symbols_node(struct node
*tree
, struct emitter
*emit
,
329 void *etarget
, struct data
*strbuf
,
330 struct version_info
*vi
)
335 /* do nothing if no symbols */
339 emit
->beginnode(etarget
, NULL
);
340 emit
->string(etarget
, "__symbols__", 0);
341 emit
->align(etarget
, sizeof(cell_t
));
343 for_each_symbol(tree
, sym
) {
345 vallen
= strlen(sym
->node
->fullpath
);
347 nameoff
= stringtable_insert(strbuf
, sym
->label
->label
);
349 emit
->property(etarget
, NULL
);
350 emit
->cell(etarget
, vallen
+ 1);
351 emit
->cell(etarget
, nameoff
);
353 if ((vi
->flags
& FTF_VARALIGN
) && vallen
>= 8)
354 emit
->align(etarget
, 8);
356 emit
->string(etarget
, sym
->node
->fullpath
,
357 strlen(sym
->node
->fullpath
));
358 emit
->align(etarget
, sizeof(cell_t
));
361 emit
->endnode(etarget
, NULL
);
364 static void emit_local_fixups_node(struct node
*tree
, struct emitter
*emit
,
365 void *etarget
, struct data
*strbuf
,
366 struct version_info
*vi
)
368 struct fixup_entry
*fe
;
371 /* do nothing if no local fixups */
372 if (!tree
->local_fixups
)
375 /* mark all nodes that need a local fixup generated (and parents) */
376 for_each_local_fixup_entry(tree
, fe
) {
378 while (node
!= NULL
&& !node
->emit_local_fixup_node
) {
379 node
->emit_local_fixup_node
= true;
384 /* emit the local fixups node now */
385 emit
->beginnode(etarget
, NULL
);
386 emit
->string(etarget
, "__local_fixups__", 0);
387 emit
->align(etarget
, sizeof(cell_t
));
389 emit_local_fixups(tree
, emit
, etarget
, strbuf
, vi
, tree
);
391 emit
->endnode(etarget
, tree
->labels
);
394 static void emit_fixups_node(struct node
*tree
, struct emitter
*emit
,
395 void *etarget
, struct data
*strbuf
,
396 struct version_info
*vi
)
399 struct fixup_entry
*fe
;
401 const char *fullpath
;
402 int namesz
, nameoff
, vallen
;
404 /* do nothing if no fixups */
408 /* emit the external fixups */
409 emit
->beginnode(etarget
, NULL
);
410 emit
->string(etarget
, "__fixups__", 0);
411 emit
->align(etarget
, sizeof(cell_t
));
413 for_each_fixup(tree
, f
) {
416 for_each_fixup_entry(f
, fe
) {
417 fullpath
= fe
->node
->fullpath
;
418 if (fullpath
[0] == '\0')
420 namesz
+= strlen(fullpath
) + 1;
421 namesz
+= strlen(fe
->prop
->name
) + 1;
422 namesz
+= 32; /* space for :<number> + '\0' */
425 name
= xmalloc(namesz
);
428 for_each_fixup_entry(f
, fe
) {
429 fullpath
= fe
->node
->fullpath
;
430 if (fullpath
[0] == '\0')
432 snprintf(s
, name
+ namesz
- s
, "%s:%s:%d", fullpath
,
433 fe
->prop
->name
, fe
->offset
);
437 nameoff
= stringtable_insert(strbuf
, f
->ref
);
438 vallen
= s
- name
- 1;
440 emit
->property(etarget
, NULL
);
441 emit
->cell(etarget
, vallen
+ 1);
442 emit
->cell(etarget
, nameoff
);
444 if ((vi
->flags
& FTF_VARALIGN
) && vallen
>= 8)
445 emit
->align(etarget
, 8);
447 emit
->string(etarget
, name
, vallen
);
448 emit
->align(etarget
, sizeof(cell_t
));
453 emit
->endnode(etarget
, tree
->labels
);
456 static void flatten_tree(struct node
*tree
, struct emitter
*emit
,
457 void *etarget
, struct data
*strbuf
,
458 struct version_info
*vi
)
460 struct property
*prop
;
462 bool seen_name_prop
= false;
467 emit
->beginnode(etarget
, tree
->labels
);
469 if (vi
->flags
& FTF_FULLPATH
)
470 emit
->string(etarget
, tree
->fullpath
, 0);
472 emit
->string(etarget
, tree
->name
, 0);
474 emit
->align(etarget
, sizeof(cell_t
));
476 for_each_property(tree
, prop
) {
479 if (streq(prop
->name
, "name"))
480 seen_name_prop
= true;
482 nameoff
= stringtable_insert(strbuf
, prop
->name
);
484 emit
->property(etarget
, prop
->labels
);
485 emit
->cell(etarget
, prop
->val
.len
);
486 emit
->cell(etarget
, nameoff
);
488 if ((vi
->flags
& FTF_VARALIGN
) && (prop
->val
.len
>= 8))
489 emit
->align(etarget
, 8);
491 emit
->data(etarget
, prop
->val
);
492 emit
->align(etarget
, sizeof(cell_t
));
495 if ((vi
->flags
& FTF_NAMEPROPS
) && !seen_name_prop
) {
496 emit
->property(etarget
, NULL
);
497 emit
->cell(etarget
, tree
->basenamelen
+1);
498 emit
->cell(etarget
, stringtable_insert(strbuf
, "name"));
500 if ((vi
->flags
& FTF_VARALIGN
) && ((tree
->basenamelen
+1) >= 8))
501 emit
->align(etarget
, 8);
503 emit
->string(etarget
, tree
->name
, tree
->basenamelen
);
504 emit
->align(etarget
, sizeof(cell_t
));
507 for_each_child(tree
, child
) {
508 flatten_tree(child
, emit
, etarget
, strbuf
, vi
);
511 emit_symbols_node(tree
, emit
, etarget
, strbuf
, vi
);
512 emit_local_fixups_node(tree
, emit
, etarget
, strbuf
, vi
);
513 emit_fixups_node(tree
, emit
, etarget
, strbuf
, vi
);
515 emit
->endnode(etarget
, tree
->labels
);
518 static struct data
flatten_reserve_list(struct reserve_info
*reservelist
,
519 struct version_info
*vi
)
521 struct reserve_info
*re
;
522 struct data d
= empty_data
;
523 static struct fdt_reserve_entry null_re
= {0,0};
526 for (re
= reservelist
; re
; re
= re
->next
) {
527 d
= data_append_re(d
, &re
->re
);
530 * Add additional reserved slots if the user asked for them.
532 for (j
= 0; j
< reservenum
; j
++) {
533 d
= data_append_re(d
, &null_re
);
539 static void make_fdt_header(struct fdt_header
*fdt
,
540 struct version_info
*vi
,
541 int reservesize
, int dtsize
, int strsize
,
546 reservesize
+= sizeof(struct fdt_reserve_entry
);
548 memset(fdt
, 0xff, sizeof(*fdt
));
550 fdt
->magic
= cpu_to_fdt32(FDT_MAGIC
);
551 fdt
->version
= cpu_to_fdt32(vi
->version
);
552 fdt
->last_comp_version
= cpu_to_fdt32(vi
->last_comp_version
);
554 /* Reserve map should be doubleword aligned */
555 reserve_off
= ALIGN(vi
->hdr_size
, 8);
557 fdt
->off_mem_rsvmap
= cpu_to_fdt32(reserve_off
);
558 fdt
->off_dt_struct
= cpu_to_fdt32(reserve_off
+ reservesize
);
559 fdt
->off_dt_strings
= cpu_to_fdt32(reserve_off
+ reservesize
561 fdt
->totalsize
= cpu_to_fdt32(reserve_off
+ reservesize
+ dtsize
+ strsize
);
563 if (vi
->flags
& FTF_BOOTCPUID
)
564 fdt
->boot_cpuid_phys
= cpu_to_fdt32(boot_cpuid_phys
);
565 if (vi
->flags
& FTF_STRTABSIZE
)
566 fdt
->size_dt_strings
= cpu_to_fdt32(strsize
);
567 if (vi
->flags
& FTF_STRUCTSIZE
)
568 fdt
->size_dt_struct
= cpu_to_fdt32(dtsize
);
571 void dt_to_blob(FILE *f
, struct boot_info
*bi
, int version
)
573 struct version_info
*vi
= NULL
;
575 struct data blob
= empty_data
;
576 struct data reservebuf
= empty_data
;
577 struct data dtbuf
= empty_data
;
578 struct data strbuf
= empty_data
;
579 struct fdt_header fdt
;
582 for (i
= 0; i
< ARRAY_SIZE(version_table
); i
++) {
583 if (version_table
[i
].version
== version
)
584 vi
= &version_table
[i
];
587 die("Unknown device tree blob version %d\n", version
);
589 flatten_tree(bi
->dt
, &bin_emitter
, &dtbuf
, &strbuf
, vi
);
590 bin_emit_cell(&dtbuf
, FDT_END
);
592 reservebuf
= flatten_reserve_list(bi
->reservelist
, vi
);
595 make_fdt_header(&fdt
, vi
, reservebuf
.len
, dtbuf
.len
, strbuf
.len
,
596 bi
->boot_cpuid_phys
);
599 * If the user asked for more space than is used, adjust the totalsize.
602 padlen
= minsize
- fdt32_to_cpu(fdt
.totalsize
);
603 if ((padlen
< 0) && (quiet
< 1))
605 "Warning: blob size %d >= minimum size %d\n",
606 fdt32_to_cpu(fdt
.totalsize
), minsize
);
613 int tsize
= fdt32_to_cpu(fdt
.totalsize
);
615 fdt
.totalsize
= cpu_to_fdt32(tsize
);
619 * Assemble the blob: start with the header, add with alignment
620 * the reserve buffer, add the reserve map terminating zeroes,
621 * the device tree itself, and finally the strings.
623 blob
= data_append_data(blob
, &fdt
, vi
->hdr_size
);
624 blob
= data_append_align(blob
, 8);
625 blob
= data_merge(blob
, reservebuf
);
626 blob
= data_append_zeroes(blob
, sizeof(struct fdt_reserve_entry
));
627 blob
= data_merge(blob
, dtbuf
);
628 blob
= data_merge(blob
, strbuf
);
631 * If the user asked for more space than is used, pad out the blob.
634 blob
= data_append_zeroes(blob
, padlen
);
636 if (fwrite(blob
.val
, blob
.len
, 1, f
) != 1) {
638 die("Error writing device tree blob: %s\n",
641 die("Short write on device tree blob\n");
645 * data_merge() frees the right-hand element so only the blob
646 * remains to be freed.
651 static void dump_stringtable_asm(FILE *f
, struct data strbuf
)
658 while (p
< (strbuf
.val
+ strbuf
.len
)) {
660 fprintf(f
, "\t.string \"%s\"\n", p
);
665 void dt_to_asm(FILE *f
, struct boot_info
*bi
, int version
)
667 struct version_info
*vi
= NULL
;
669 struct data strbuf
= empty_data
;
670 struct reserve_info
*re
;
671 const char *symprefix
= "dt";
673 for (i
= 0; i
< ARRAY_SIZE(version_table
); i
++) {
674 if (version_table
[i
].version
== version
)
675 vi
= &version_table
[i
];
678 die("Unknown device tree blob version %d\n", version
);
680 fprintf(f
, "/* autogenerated by dtc, do not edit */\n\n");
682 emit_label(f
, symprefix
, "blob_start");
683 emit_label(f
, symprefix
, "header");
684 fprintf(f
, "\t/* magic */\n");
685 asm_emit_cell(f
, FDT_MAGIC
);
686 fprintf(f
, "\t/* totalsize */\n");
687 ASM_EMIT_BELONG(f
, "_%s_blob_abs_end - _%s_blob_start",
688 symprefix
, symprefix
);
689 fprintf(f
, "\t/* off_dt_struct */\n");
690 ASM_EMIT_BELONG(f
, "_%s_struct_start - _%s_blob_start",
691 symprefix
, symprefix
);
692 fprintf(f
, "\t/* off_dt_strings */\n");
693 ASM_EMIT_BELONG(f
, "_%s_strings_start - _%s_blob_start",
694 symprefix
, symprefix
);
695 fprintf(f
, "\t/* off_mem_rsvmap */\n");
696 ASM_EMIT_BELONG(f
, "_%s_reserve_map - _%s_blob_start",
697 symprefix
, symprefix
);
698 fprintf(f
, "\t/* version */\n");
699 asm_emit_cell(f
, vi
->version
);
700 fprintf(f
, "\t/* last_comp_version */\n");
701 asm_emit_cell(f
, vi
->last_comp_version
);
703 if (vi
->flags
& FTF_BOOTCPUID
) {
704 fprintf(f
, "\t/* boot_cpuid_phys */\n");
705 asm_emit_cell(f
, bi
->boot_cpuid_phys
);
708 if (vi
->flags
& FTF_STRTABSIZE
) {
709 fprintf(f
, "\t/* size_dt_strings */\n");
710 ASM_EMIT_BELONG(f
, "_%s_strings_end - _%s_strings_start",
711 symprefix
, symprefix
);
714 if (vi
->flags
& FTF_STRUCTSIZE
) {
715 fprintf(f
, "\t/* size_dt_struct */\n");
716 ASM_EMIT_BELONG(f
, "_%s_struct_end - _%s_struct_start",
717 symprefix
, symprefix
);
721 * Reserve map entries.
722 * Align the reserve map to a doubleword boundary.
723 * Each entry is an (address, size) pair of u64 values.
724 * Always supply a zero-sized temination entry.
726 asm_emit_align(f
, 8);
727 emit_label(f
, symprefix
, "reserve_map");
729 fprintf(f
, "/* Memory reserve map from source file */\n");
732 * Use .long on high and low halfs of u64s to avoid .quad
733 * as it appears .quad isn't available in some assemblers.
735 for (re
= bi
->reservelist
; re
; re
= re
->next
) {
738 for_each_label(re
->labels
, l
) {
739 fprintf(f
, "\t.globl\t%s\n", l
->label
);
740 fprintf(f
, "%s:\n", l
->label
);
742 ASM_EMIT_BELONG(f
, "0x%08x", (unsigned int)(re
->re
.address
>> 32));
743 ASM_EMIT_BELONG(f
, "0x%08x",
744 (unsigned int)(re
->re
.address
& 0xffffffff));
745 ASM_EMIT_BELONG(f
, "0x%08x", (unsigned int)(re
->re
.size
>> 32));
746 ASM_EMIT_BELONG(f
, "0x%08x", (unsigned int)(re
->re
.size
& 0xffffffff));
748 for (i
= 0; i
< reservenum
; i
++) {
749 fprintf(f
, "\t.long\t0, 0\n\t.long\t0, 0\n");
752 fprintf(f
, "\t.long\t0, 0\n\t.long\t0, 0\n");
754 emit_label(f
, symprefix
, "struct_start");
755 flatten_tree(bi
->dt
, &asm_emitter
, f
, &strbuf
, vi
);
757 fprintf(f
, "\t/* FDT_END */\n");
758 asm_emit_cell(f
, FDT_END
);
759 emit_label(f
, symprefix
, "struct_end");
761 emit_label(f
, symprefix
, "strings_start");
762 dump_stringtable_asm(f
, strbuf
);
763 emit_label(f
, symprefix
, "strings_end");
765 emit_label(f
, symprefix
, "blob_end");
768 * If the user asked for more space than is used, pad it out.
771 fprintf(f
, "\t.space\t%d - (_%s_blob_end - _%s_blob_start), 0\n",
772 minsize
, symprefix
, symprefix
);
775 fprintf(f
, "\t.space\t%d, 0\n", padsize
);
777 emit_label(f
, symprefix
, "blob_abs_end");
783 char *base
, *limit
, *ptr
;
786 static void inbuf_init(struct inbuf
*inb
, void *base
, void *limit
)
790 inb
->ptr
= inb
->base
;
793 static void flat_read_chunk(struct inbuf
*inb
, void *p
, int len
)
795 if ((inb
->ptr
+ len
) > inb
->limit
)
796 die("Premature end of data parsing flat device tree\n");
798 memcpy(p
, inb
->ptr
, len
);
803 static uint32_t flat_read_word(struct inbuf
*inb
)
807 assert(((inb
->ptr
- inb
->base
) % sizeof(val
)) == 0);
809 flat_read_chunk(inb
, &val
, sizeof(val
));
811 return fdt32_to_cpu(val
);
814 static void flat_realign(struct inbuf
*inb
, int align
)
816 int off
= inb
->ptr
- inb
->base
;
818 inb
->ptr
= inb
->base
+ ALIGN(off
, align
);
819 if (inb
->ptr
> inb
->limit
)
820 die("Premature end of data parsing flat device tree\n");
823 static char *flat_read_string(struct inbuf
*inb
)
826 const char *p
= inb
->ptr
;
831 die("Premature end of data parsing flat device tree\n");
833 } while ((*p
++) != '\0');
835 str
= xstrdup(inb
->ptr
);
839 flat_realign(inb
, sizeof(uint32_t));
844 static struct data
flat_read_data(struct inbuf
*inb
, int len
)
846 struct data d
= empty_data
;
851 d
= data_grow_for(d
, len
);
854 flat_read_chunk(inb
, d
.val
, len
);
856 flat_realign(inb
, sizeof(uint32_t));
861 static char *flat_read_stringtable(struct inbuf
*inb
, int offset
)
865 p
= inb
->base
+ offset
;
867 if (p
>= inb
->limit
|| p
< inb
->base
)
868 die("String offset %d overruns string table\n",
877 return xstrdup(inb
->base
+ offset
);
880 static struct property
*flat_read_property(struct inbuf
*dtbuf
,
881 struct inbuf
*strbuf
, int flags
)
883 uint32_t proplen
, stroff
;
887 proplen
= flat_read_word(dtbuf
);
888 stroff
= flat_read_word(dtbuf
);
890 name
= flat_read_stringtable(strbuf
, stroff
);
892 if ((flags
& FTF_VARALIGN
) && (proplen
>= 8))
893 flat_realign(dtbuf
, 8);
895 val
= flat_read_data(dtbuf
, proplen
);
897 return build_property(name
, val
);
901 static struct reserve_info
*flat_read_mem_reserve(struct inbuf
*inb
)
903 struct reserve_info
*reservelist
= NULL
;
904 struct reserve_info
*new;
905 struct fdt_reserve_entry re
;
908 * Each entry is a pair of u64 (addr, size) values for 4 cell_t's.
909 * List terminates at an entry with size equal to zero.
911 * First pass, count entries.
914 flat_read_chunk(inb
, &re
, sizeof(re
));
915 re
.address
= fdt64_to_cpu(re
.address
);
916 re
.size
= fdt64_to_cpu(re
.size
);
920 new = build_reserve_entry(re
.address
, re
.size
);
921 reservelist
= add_reserve_entry(reservelist
, new);
928 static char *nodename_from_path(const char *ppath
, const char *cpath
)
932 plen
= strlen(ppath
);
934 if (!strneq(ppath
, cpath
, plen
))
935 die("Path \"%s\" is not valid as a child of \"%s\"\n",
938 /* root node is a special case */
939 if (!streq(ppath
, "/"))
942 return xstrdup(cpath
+ plen
);
945 static struct node
*unflatten_tree(struct inbuf
*dtbuf
,
946 struct inbuf
*strbuf
,
947 const char *parent_flatname
, int flags
)
953 node
= build_node(NULL
, NULL
);
955 flatname
= flat_read_string(dtbuf
);
957 if (flags
& FTF_FULLPATH
)
958 node
->name
= nodename_from_path(parent_flatname
, flatname
);
960 node
->name
= flatname
;
963 struct property
*prop
;
966 val
= flat_read_word(dtbuf
);
970 fprintf(stderr
, "Warning: Flat tree input has "
971 "subnodes preceding a property.\n");
972 prop
= flat_read_property(dtbuf
, strbuf
, flags
);
973 add_property(node
, prop
);
977 child
= unflatten_tree(dtbuf
,strbuf
, flatname
, flags
);
978 add_child(node
, child
);
985 die("Premature FDT_END in device tree blob\n");
989 if (!(flags
& FTF_NOPS
))
990 fprintf(stderr
, "Warning: NOP tag found in flat tree"
997 die("Invalid opcode word %08x in device tree blob\n",
1000 } while (val
!= FDT_END_NODE
);
1006 struct boot_info
*dt_from_blob(const char *fname
)
1009 uint32_t magic
, totalsize
, version
, size_dt
, boot_cpuid_phys
;
1010 uint32_t off_dt
, off_str
, off_mem_rsvmap
;
1013 struct fdt_header
*fdt
;
1015 struct inbuf dtbuf
, strbuf
;
1016 struct inbuf memresvbuf
;
1018 struct reserve_info
*reservelist
;
1023 f
= srcfile_relative_open(fname
, NULL
);
1025 rc
= fread(&magic
, sizeof(magic
), 1, f
);
1027 die("Error reading DT blob magic number: %s\n",
1031 die("EOF reading DT blob magic number\n");
1033 die("Mysterious short read reading magic number\n");
1036 magic
= fdt32_to_cpu(magic
);
1037 if (magic
!= FDT_MAGIC
)
1038 die("Blob has incorrect magic number\n");
1040 rc
= fread(&totalsize
, sizeof(totalsize
), 1, f
);
1042 die("Error reading DT blob size: %s\n", strerror(errno
));
1045 die("EOF reading DT blob size\n");
1047 die("Mysterious short read reading blob size\n");
1050 totalsize
= fdt32_to_cpu(totalsize
);
1051 if (totalsize
< FDT_V1_SIZE
)
1052 die("DT blob size (%d) is too small\n", totalsize
);
1054 blob
= xmalloc(totalsize
);
1056 fdt
= (struct fdt_header
*)blob
;
1057 fdt
->magic
= cpu_to_fdt32(magic
);
1058 fdt
->totalsize
= cpu_to_fdt32(totalsize
);
1060 sizeleft
= totalsize
- sizeof(magic
) - sizeof(totalsize
);
1061 p
= blob
+ sizeof(magic
) + sizeof(totalsize
);
1065 die("EOF before reading %d bytes of DT blob\n",
1068 rc
= fread(p
, 1, sizeleft
, f
);
1070 die("Error reading DT blob: %s\n",
1077 off_dt
= fdt32_to_cpu(fdt
->off_dt_struct
);
1078 off_str
= fdt32_to_cpu(fdt
->off_dt_strings
);
1079 off_mem_rsvmap
= fdt32_to_cpu(fdt
->off_mem_rsvmap
);
1080 version
= fdt32_to_cpu(fdt
->version
);
1081 boot_cpuid_phys
= fdt32_to_cpu(fdt
->boot_cpuid_phys
);
1083 if (off_mem_rsvmap
>= totalsize
)
1084 die("Mem Reserve structure offset exceeds total size\n");
1086 if (off_dt
>= totalsize
)
1087 die("DT structure offset exceeds total size\n");
1089 if (off_str
> totalsize
)
1090 die("String table offset exceeds total size\n");
1093 uint32_t size_str
= fdt32_to_cpu(fdt
->size_dt_strings
);
1094 if ((off_str
+size_str
< off_str
) || (off_str
+size_str
> totalsize
))
1095 die("String table extends past total size\n");
1096 inbuf_init(&strbuf
, blob
+ off_str
, blob
+ off_str
+ size_str
);
1098 inbuf_init(&strbuf
, blob
+ off_str
, blob
+ totalsize
);
1101 if (version
>= 17) {
1102 size_dt
= fdt32_to_cpu(fdt
->size_dt_struct
);
1103 if ((off_dt
+size_dt
< off_dt
) || (off_dt
+size_dt
> totalsize
))
1104 die("Structure block extends past total size\n");
1108 flags
|= FTF_FULLPATH
| FTF_NAMEPROPS
| FTF_VARALIGN
;
1113 inbuf_init(&memresvbuf
,
1114 blob
+ off_mem_rsvmap
, blob
+ totalsize
);
1115 inbuf_init(&dtbuf
, blob
+ off_dt
, blob
+ totalsize
);
1117 reservelist
= flat_read_mem_reserve(&memresvbuf
);
1119 val
= flat_read_word(&dtbuf
);
1121 if (val
!= FDT_BEGIN_NODE
)
1122 die("Device tree blob doesn't begin with FDT_BEGIN_NODE (begins with 0x%08x)\n", val
);
1124 tree
= unflatten_tree(&dtbuf
, &strbuf
, "", flags
);
1126 val
= flat_read_word(&dtbuf
);
1128 die("Device tree blob doesn't end with FDT_END\n");
1134 return build_boot_info(reservelist
, tree
, boot_cpuid_phys
);