2 * libfdt - Flat Device Tree manipulation
3 * Copyright (C) 2006 David Gibson, IBM Corporation.
5 * libfdt is dual licensed: you can use it either under the terms of
6 * the GPL, or the BSD license, at your option.
8 * a) This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License as
10 * published by the Free Software Foundation; either version 2 of the
11 * License, or (at your option) any later version.
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public
19 * License along with this library; if not, write to the Free
20 * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
25 * b) Redistribution and use in source and binary forms, with or
26 * without modification, are permitted provided that the following
29 * 1. Redistributions of source code must retain the above
30 * copyright notice, this list of conditions and the following
32 * 2. Redistributions in binary form must reproduce the above
33 * copyright notice, this list of conditions and the following
34 * disclaimer in the documentation and/or other materials
35 * provided with the distribution.
37 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
38 * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
39 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
40 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
41 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
42 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
43 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
44 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
45 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
46 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
47 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
48 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
49 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
51 #include "libfdt_env.h"
60 #include "libfdt_internal.h"
62 static int _blocks_misordered(const void *fdt
,
63 int mem_rsv_size
, int struct_size
)
65 return (fdt_off_mem_rsvmap(fdt
) < ALIGN(sizeof(struct fdt_header
), 8))
66 || (fdt_off_dt_struct(fdt
) <
67 (fdt_off_mem_rsvmap(fdt
) + mem_rsv_size
))
68 || (fdt_off_dt_strings(fdt
) <
69 (fdt_off_dt_struct(fdt
) + struct_size
))
70 || (fdt_totalsize(fdt
) <
71 (fdt_off_dt_strings(fdt
) + fdt_size_dt_strings(fdt
)));
74 static int rw_check_header(void *fdt
)
78 if (fdt_version(fdt
) < 17)
79 return -FDT_ERR_BADVERSION
;
80 if (_blocks_misordered(fdt
, sizeof(struct fdt_reserve_entry
),
81 fdt_size_dt_struct(fdt
)))
82 return -FDT_ERR_BADLAYOUT
;
83 if (fdt_version(fdt
) > 17)
84 fdt_set_version(fdt
, 17);
89 #define RW_CHECK_HEADER(fdt) \
92 if ((err = rw_check_header(fdt)) != 0) \
96 static inline int _blob_data_size(void *fdt
)
98 return fdt_off_dt_strings(fdt
) + fdt_size_dt_strings(fdt
);
101 static int _blob_splice(void *fdt
, void *p
, int oldlen
, int newlen
)
103 void *end
= fdt
+ _blob_data_size(fdt
);
105 if (((p
+ oldlen
) < p
) || ((p
+ oldlen
) > end
))
106 return -FDT_ERR_BADOFFSET
;
107 if ((end
- oldlen
+ newlen
) > (fdt
+ fdt_totalsize(fdt
)))
108 return -FDT_ERR_NOSPACE
;
109 memmove(p
+ newlen
, p
+ oldlen
, end
- p
- oldlen
);
113 static int _blob_splice_mem_rsv(void *fdt
, struct fdt_reserve_entry
*p
,
116 int delta
= (newn
- oldn
) * sizeof(*p
);
118 err
= _blob_splice(fdt
, p
, oldn
* sizeof(*p
), newn
* sizeof(*p
));
121 fdt_set_off_dt_struct(fdt
, fdt_off_dt_struct(fdt
) + delta
);
122 fdt_set_off_dt_strings(fdt
, fdt_off_dt_strings(fdt
) + delta
);
126 static int _blob_splice_struct(void *fdt
, void *p
,
127 int oldlen
, int newlen
)
129 int delta
= newlen
- oldlen
;
132 if ((err
= _blob_splice(fdt
, p
, oldlen
, newlen
)))
135 fdt_set_size_dt_struct(fdt
, fdt_size_dt_struct(fdt
) + delta
);
136 fdt_set_off_dt_strings(fdt
, fdt_off_dt_strings(fdt
) + delta
);
140 static int _blob_splice_string(void *fdt
, int newlen
)
142 void *p
= fdt
+ fdt_off_dt_strings(fdt
) + fdt_size_dt_strings(fdt
);
145 if ((err
= _blob_splice(fdt
, p
, 0, newlen
)))
148 fdt_set_size_dt_strings(fdt
, fdt_size_dt_strings(fdt
) + newlen
);
152 static int _find_add_string(void *fdt
, const char *s
)
154 char *strtab
= (char *)fdt
+ fdt_off_dt_strings(fdt
);
157 int len
= strlen(s
) + 1;
160 p
= _fdt_find_string(strtab
, fdt_size_dt_strings(fdt
), s
);
165 new = strtab
+ fdt_size_dt_strings(fdt
);
166 err
= _blob_splice_string(fdt
, len
);
171 return (new - strtab
);
174 int fdt_add_mem_rsv(void *fdt
, uint64_t address
, uint64_t size
)
176 struct fdt_reserve_entry
*re
;
179 if ((err
= rw_check_header(fdt
)))
182 re
= _fdt_mem_rsv_w(fdt
, fdt_num_mem_rsv(fdt
));
183 err
= _blob_splice_mem_rsv(fdt
, re
, 0, 1);
187 re
->address
= cpu_to_fdt64(address
);
188 re
->size
= cpu_to_fdt64(size
);
192 int fdt_del_mem_rsv(void *fdt
, int n
)
194 struct fdt_reserve_entry
*re
= _fdt_mem_rsv_w(fdt
, n
);
197 if ((err
= rw_check_header(fdt
)))
199 if (n
>= fdt_num_mem_rsv(fdt
))
200 return -FDT_ERR_NOTFOUND
;
202 err
= _blob_splice_mem_rsv(fdt
, re
, 1, 0);
208 static int _resize_property(void *fdt
, int nodeoffset
, const char *name
, int len
,
209 struct fdt_property
**prop
)
214 *prop
= fdt_get_property_w(fdt
, nodeoffset
, name
, &oldlen
);
218 if ((err
= _blob_splice_struct(fdt
, (*prop
)->data
,
219 ALIGN(oldlen
, FDT_TAGSIZE
),
220 ALIGN(len
, FDT_TAGSIZE
))))
223 (*prop
)->len
= cpu_to_fdt32(len
);
227 static int _add_property(void *fdt
, int nodeoffset
, const char *name
, int len
,
228 struct fdt_property
**prop
)
236 tag
= fdt_next_tag(fdt
, nodeoffset
, &nextoffset
);
237 if (tag
!= FDT_BEGIN_NODE
)
238 return -FDT_ERR_BADOFFSET
;
240 namestroff
= _find_add_string(fdt
, name
);
244 *prop
= _fdt_offset_ptr_w(fdt
, nextoffset
);
245 proplen
= sizeof(**prop
) + ALIGN(len
, FDT_TAGSIZE
);
247 err
= _blob_splice_struct(fdt
, *prop
, 0, proplen
);
251 (*prop
)->tag
= cpu_to_fdt32(FDT_PROP
);
252 (*prop
)->nameoff
= cpu_to_fdt32(namestroff
);
253 (*prop
)->len
= cpu_to_fdt32(len
);
257 int fdt_set_name(void *fdt
, int nodeoffset
, const char *name
)
263 if ((err
= rw_check_header(fdt
)))
266 namep
= (char *)fdt_get_name(fdt
, nodeoffset
, &oldlen
);
270 newlen
= strlen(name
);
272 err
= _blob_splice_struct(fdt
, namep
, ALIGN(oldlen
+1, FDT_TAGSIZE
),
273 ALIGN(newlen
+1, FDT_TAGSIZE
));
277 memcpy(namep
, name
, newlen
+1);
281 int fdt_setprop(void *fdt
, int nodeoffset
, const char *name
,
282 const void *val
, int len
)
284 struct fdt_property
*prop
;
287 if ((err
= rw_check_header(fdt
)))
290 err
= _resize_property(fdt
, nodeoffset
, name
, len
, &prop
);
291 if (err
== -FDT_ERR_NOTFOUND
)
292 err
= _add_property(fdt
, nodeoffset
, name
, len
, &prop
);
296 memcpy(prop
->data
, val
, len
);
300 int fdt_delprop(void *fdt
, int nodeoffset
, const char *name
)
302 struct fdt_property
*prop
;
305 RW_CHECK_HEADER(fdt
);
307 prop
= fdt_get_property_w(fdt
, nodeoffset
, name
, &len
);
311 proplen
= sizeof(*prop
) + ALIGN(len
, FDT_TAGSIZE
);
312 return _blob_splice_struct(fdt
, prop
, proplen
, 0);
315 int fdt_add_subnode_namelen(void *fdt
, int parentoffset
,
316 const char *name
, int namelen
)
318 struct fdt_node_header
*nh
;
319 int offset
, nextoffset
;
325 RW_CHECK_HEADER(fdt
);
327 offset
= fdt_subnode_offset_namelen(fdt
, parentoffset
, name
, namelen
);
329 return -FDT_ERR_EXISTS
;
330 else if (offset
!= -FDT_ERR_NOTFOUND
)
333 /* Try to place the new node after the parent's properties */
334 fdt_next_tag(fdt
, parentoffset
, &nextoffset
); /* skip the BEGIN_NODE */
337 tag
= fdt_next_tag(fdt
, offset
, &nextoffset
);
338 } while ((tag
== FDT_PROP
) || (tag
== FDT_NOP
));
340 nh
= _fdt_offset_ptr_w(fdt
, offset
);
341 nodelen
= sizeof(*nh
) + ALIGN(namelen
+1, FDT_TAGSIZE
) + FDT_TAGSIZE
;
343 err
= _blob_splice_struct(fdt
, nh
, 0, nodelen
);
347 nh
->tag
= cpu_to_fdt32(FDT_BEGIN_NODE
);
348 memset(nh
->name
, 0, ALIGN(namelen
+1, FDT_TAGSIZE
));
349 memcpy(nh
->name
, name
, namelen
);
350 endtag
= (uint32_t *)((void *)nh
+ nodelen
- FDT_TAGSIZE
);
351 *endtag
= cpu_to_fdt32(FDT_END_NODE
);
356 int fdt_add_subnode(void *fdt
, int parentoffset
, const char *name
)
358 return fdt_add_subnode_namelen(fdt
, parentoffset
, name
, strlen(name
));
361 int fdt_del_node(void *fdt
, int nodeoffset
)
365 RW_CHECK_HEADER(fdt
);
367 endoffset
= _fdt_node_end_offset(fdt
, nodeoffset
);
371 return _blob_splice_struct(fdt
, _fdt_offset_ptr_w(fdt
, nodeoffset
),
372 endoffset
- nodeoffset
, 0);
375 static void _packblocks(const void *fdt
, void *buf
,
376 int mem_rsv_size
, int struct_size
)
378 int mem_rsv_off
, struct_off
, strings_off
;
380 mem_rsv_off
= ALIGN(sizeof(struct fdt_header
), 8);
381 struct_off
= mem_rsv_off
+ mem_rsv_size
;
382 strings_off
= struct_off
+ struct_size
;
384 memmove(buf
+ mem_rsv_off
, fdt
+ fdt_off_mem_rsvmap(fdt
), mem_rsv_size
);
385 fdt_set_off_mem_rsvmap(buf
, mem_rsv_off
);
387 memmove(buf
+ struct_off
, fdt
+ fdt_off_dt_struct(fdt
), struct_size
);
388 fdt_set_off_dt_struct(buf
, struct_off
);
389 fdt_set_size_dt_struct(buf
, struct_size
);
391 memmove(buf
+ strings_off
, fdt
+ fdt_off_dt_strings(fdt
),
392 fdt_size_dt_strings(fdt
));
393 fdt_set_off_dt_strings(buf
, strings_off
);
394 fdt_set_size_dt_strings(buf
, fdt_size_dt_strings(fdt
));
397 int fdt_open_into(const void *fdt
, void *buf
, int bufsize
)
400 int mem_rsv_size
, struct_size
;
406 mem_rsv_size
= (fdt_num_mem_rsv(fdt
)+1)
407 * sizeof(struct fdt_reserve_entry
);
409 if (fdt_version(fdt
) >= 17) {
410 struct_size
= fdt_size_dt_struct(fdt
);
413 while (fdt_next_tag(fdt
, struct_size
, &struct_size
) != FDT_END
)
417 if (!_blocks_misordered(fdt
, mem_rsv_size
, struct_size
)) {
418 /* no further work necessary */
419 err
= fdt_move(fdt
, buf
, bufsize
);
422 fdt_set_version(buf
, 17);
423 fdt_set_size_dt_struct(buf
, struct_size
);
424 fdt_set_totalsize(buf
, bufsize
);
428 /* Need to reorder */
429 newsize
= ALIGN(sizeof(struct fdt_header
), 8) + mem_rsv_size
430 + struct_size
+ fdt_size_dt_strings(fdt
);
432 if (bufsize
< newsize
)
433 return -FDT_ERR_NOSPACE
;
435 if (((buf
+ newsize
) <= fdt
)
436 || (buf
>= (fdt
+ fdt_totalsize(fdt
)))) {
439 tmp
= (void *)fdt
+ fdt_totalsize(fdt
);
440 if ((tmp
+ newsize
) > (buf
+ bufsize
))
441 return -FDT_ERR_NOSPACE
;
444 _packblocks(fdt
, tmp
, mem_rsv_size
, struct_size
);
445 memmove(buf
, tmp
, newsize
);
447 fdt_set_magic(buf
, FDT_MAGIC
);
448 fdt_set_totalsize(buf
, bufsize
);
449 fdt_set_version(buf
, 17);
450 fdt_set_last_comp_version(buf
, 16);
451 fdt_set_boot_cpuid_phys(buf
, fdt_boot_cpuid_phys(fdt
));
456 int fdt_pack(void *fdt
)
461 err
= rw_check_header(fdt
);
465 mem_rsv_size
= (fdt_num_mem_rsv(fdt
)+1)
466 * sizeof(struct fdt_reserve_entry
);
467 _packblocks(fdt
, fdt
, mem_rsv_size
, fdt_size_dt_struct(fdt
));
468 fdt_set_totalsize(fdt
, _blob_data_size(fdt
));