blob: aba60948416e1cd7a802770f94627089d685446e [file] [log] [blame]
Gerald Van Baren35748172007-03-31 12:00:56 -04001/*
2 * libfdt - Flat Device Tree manipulation
3 * Copyright (C) 2006 David Gibson, IBM Corporation.
4 *
Kumar Gala8d04f022007-10-24 11:04:22 -05005 * libfdt is dual licensed: you can use it either under the terms of
6 * the GPL, or the BSD license, at your option.
Gerald Van Baren35748172007-03-31 12:00:56 -04007 *
Kumar Gala8d04f022007-10-24 11:04:22 -05008 * 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.
Gerald Van Baren35748172007-03-31 12:00:56 -040012 *
Kumar Gala8d04f022007-10-24 11:04:22 -050013 * 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.
17 *
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,
21 * MA 02110-1301 USA
22 *
23 * Alternatively,
24 *
25 * b) Redistribution and use in source and binary forms, with or
26 * without modification, are permitted provided that the following
27 * conditions are met:
28 *
29 * 1. Redistributions of source code must retain the above
30 * copyright notice, this list of conditions and the following
31 * disclaimer.
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.
36 *
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.
Gerald Van Baren35748172007-03-31 12:00:56 -040050 */
51#include "libfdt_env.h"
52
Bartlomiej Sieka8cf30802008-02-29 16:00:24 +010053#ifndef USE_HOSTCC
Gerald Van Baren35748172007-03-31 12:00:56 -040054#include <fdt.h>
55#include <libfdt.h>
Bartlomiej Sieka8cf30802008-02-29 16:00:24 +010056#else
57#include "fdt_host.h"
58#endif
Gerald Van Baren35748172007-03-31 12:00:56 -040059
60#include "libfdt_internal.h"
61
David Gibsonfc7758e2008-07-09 14:10:24 +100062static int _fdt_blocks_misordered(const void *fdt,
Kumar Gala8d04f022007-10-24 11:04:22 -050063 int mem_rsv_size, int struct_size)
64{
David Gibsonfc7758e2008-07-09 14:10:24 +100065 return (fdt_off_mem_rsvmap(fdt) < FDT_ALIGN(sizeof(struct fdt_header), 8))
Kumar Gala8d04f022007-10-24 11:04:22 -050066 || (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)));
72}
73
David Gibsonfc7758e2008-07-09 14:10:24 +100074static int _fdt_rw_check_header(void *fdt)
Gerald Van Baren35748172007-03-31 12:00:56 -040075{
David Gibsonfc7758e2008-07-09 14:10:24 +100076 FDT_CHECK_HEADER(fdt);
Gerald Van Baren35748172007-03-31 12:00:56 -040077
Kumar Gala8d04f022007-10-24 11:04:22 -050078 if (fdt_version(fdt) < 17)
Gerald Van Baren35748172007-03-31 12:00:56 -040079 return -FDT_ERR_BADVERSION;
David Gibsonfc7758e2008-07-09 14:10:24 +100080 if (_fdt_blocks_misordered(fdt, sizeof(struct fdt_reserve_entry),
81 fdt_size_dt_struct(fdt)))
Gerald Van Baren35748172007-03-31 12:00:56 -040082 return -FDT_ERR_BADLAYOUT;
Kumar Gala8d04f022007-10-24 11:04:22 -050083 if (fdt_version(fdt) > 17)
84 fdt_set_version(fdt, 17);
85
Gerald Van Baren35748172007-03-31 12:00:56 -040086 return 0;
87}
88
David Gibsonfc7758e2008-07-09 14:10:24 +100089#define FDT_RW_CHECK_HEADER(fdt) \
Gerald Van Baren35748172007-03-31 12:00:56 -040090 { \
91 int err; \
David Gibsonfc7758e2008-07-09 14:10:24 +100092 if ((err = _fdt_rw_check_header(fdt)) != 0) \
Gerald Van Baren35748172007-03-31 12:00:56 -040093 return err; \
94 }
95
David Gibsonfc7758e2008-07-09 14:10:24 +100096static inline int _fdt_data_size(void *fdt)
Gerald Van Baren35748172007-03-31 12:00:56 -040097{
98 return fdt_off_dt_strings(fdt) + fdt_size_dt_strings(fdt);
99}
100
David Gibsonfc7758e2008-07-09 14:10:24 +1000101static int _fdt_splice(void *fdt, void *splicepoint, int oldlen, int newlen)
Gerald Van Baren35748172007-03-31 12:00:56 -0400102{
David Gibsonef4e8ce2008-07-07 10:10:48 +1000103 char *p = splicepoint;
David Gibsonfc7758e2008-07-09 14:10:24 +1000104 char *end = (char *)fdt + _fdt_data_size(fdt);
Gerald Van Baren35748172007-03-31 12:00:56 -0400105
106 if (((p + oldlen) < p) || ((p + oldlen) > end))
107 return -FDT_ERR_BADOFFSET;
David Gibsonef4e8ce2008-07-07 10:10:48 +1000108 if ((end - oldlen + newlen) > ((char *)fdt + fdt_totalsize(fdt)))
Gerald Van Baren35748172007-03-31 12:00:56 -0400109 return -FDT_ERR_NOSPACE;
110 memmove(p + newlen, p + oldlen, end - p - oldlen);
111 return 0;
112}
113
David Gibsonfc7758e2008-07-09 14:10:24 +1000114static int _fdt_splice_mem_rsv(void *fdt, struct fdt_reserve_entry *p,
115 int oldn, int newn)
Kumar Gala8d04f022007-10-24 11:04:22 -0500116{
117 int delta = (newn - oldn) * sizeof(*p);
118 int err;
David Gibsonfc7758e2008-07-09 14:10:24 +1000119 err = _fdt_splice(fdt, p, oldn * sizeof(*p), newn * sizeof(*p));
Kumar Gala8d04f022007-10-24 11:04:22 -0500120 if (err)
121 return err;
122 fdt_set_off_dt_struct(fdt, fdt_off_dt_struct(fdt) + delta);
123 fdt_set_off_dt_strings(fdt, fdt_off_dt_strings(fdt) + delta);
124 return 0;
125}
126
David Gibsonfc7758e2008-07-09 14:10:24 +1000127static int _fdt_splice_struct(void *fdt, void *p,
128 int oldlen, int newlen)
Gerald Van Baren35748172007-03-31 12:00:56 -0400129{
130 int delta = newlen - oldlen;
131 int err;
132
David Gibsonfc7758e2008-07-09 14:10:24 +1000133 if ((err = _fdt_splice(fdt, p, oldlen, newlen)))
Gerald Van Baren35748172007-03-31 12:00:56 -0400134 return err;
135
Kumar Gala8d04f022007-10-24 11:04:22 -0500136 fdt_set_size_dt_struct(fdt, fdt_size_dt_struct(fdt) + delta);
137 fdt_set_off_dt_strings(fdt, fdt_off_dt_strings(fdt) + delta);
Gerald Van Baren35748172007-03-31 12:00:56 -0400138 return 0;
139}
140
David Gibsonfc7758e2008-07-09 14:10:24 +1000141static int _fdt_splice_string(void *fdt, int newlen)
Gerald Van Baren35748172007-03-31 12:00:56 -0400142{
David Gibsonef4e8ce2008-07-07 10:10:48 +1000143 void *p = (char *)fdt
144 + fdt_off_dt_strings(fdt) + fdt_size_dt_strings(fdt);
Gerald Van Baren35748172007-03-31 12:00:56 -0400145 int err;
146
David Gibsonfc7758e2008-07-09 14:10:24 +1000147 if ((err = _fdt_splice(fdt, p, 0, newlen)))
Gerald Van Baren35748172007-03-31 12:00:56 -0400148 return err;
149
Kumar Gala8d04f022007-10-24 11:04:22 -0500150 fdt_set_size_dt_strings(fdt, fdt_size_dt_strings(fdt) + newlen);
Gerald Van Baren35748172007-03-31 12:00:56 -0400151 return 0;
152}
153
David Gibsonfc7758e2008-07-09 14:10:24 +1000154static int _fdt_find_add_string(void *fdt, const char *s)
Gerald Van Baren35748172007-03-31 12:00:56 -0400155{
156 char *strtab = (char *)fdt + fdt_off_dt_strings(fdt);
157 const char *p;
158 char *new;
159 int len = strlen(s) + 1;
160 int err;
161
162 p = _fdt_find_string(strtab, fdt_size_dt_strings(fdt), s);
163 if (p)
164 /* found it */
165 return (p - strtab);
166
167 new = strtab + fdt_size_dt_strings(fdt);
David Gibsonfc7758e2008-07-09 14:10:24 +1000168 err = _fdt_splice_string(fdt, len);
Gerald Van Baren35748172007-03-31 12:00:56 -0400169 if (err)
170 return err;
171
172 memcpy(new, s, len);
173 return (new - strtab);
174}
175
Kumar Gala8d04f022007-10-24 11:04:22 -0500176int fdt_add_mem_rsv(void *fdt, uint64_t address, uint64_t size)
177{
178 struct fdt_reserve_entry *re;
179 int err;
180
David Gibsonfc7758e2008-07-09 14:10:24 +1000181 FDT_RW_CHECK_HEADER(fdt);
Kumar Gala8d04f022007-10-24 11:04:22 -0500182
183 re = _fdt_mem_rsv_w(fdt, fdt_num_mem_rsv(fdt));
David Gibsonfc7758e2008-07-09 14:10:24 +1000184 err = _fdt_splice_mem_rsv(fdt, re, 0, 1);
Kumar Gala8d04f022007-10-24 11:04:22 -0500185 if (err)
186 return err;
187
188 re->address = cpu_to_fdt64(address);
189 re->size = cpu_to_fdt64(size);
190 return 0;
191}
192
193int fdt_del_mem_rsv(void *fdt, int n)
194{
195 struct fdt_reserve_entry *re = _fdt_mem_rsv_w(fdt, n);
196 int err;
197
David Gibsonfc7758e2008-07-09 14:10:24 +1000198 FDT_RW_CHECK_HEADER(fdt);
David Gibson2f08bfa2008-05-20 17:19:11 +1000199
Kumar Gala8d04f022007-10-24 11:04:22 -0500200 if (n >= fdt_num_mem_rsv(fdt))
201 return -FDT_ERR_NOTFOUND;
202
David Gibsonfc7758e2008-07-09 14:10:24 +1000203 err = _fdt_splice_mem_rsv(fdt, re, 1, 0);
Kumar Gala8d04f022007-10-24 11:04:22 -0500204 if (err)
205 return err;
206 return 0;
207}
208
David Gibsonfc7758e2008-07-09 14:10:24 +1000209static int _fdt_resize_property(void *fdt, int nodeoffset, const char *name,
210 int len, struct fdt_property **prop)
Gerald Van Baren35748172007-03-31 12:00:56 -0400211{
212 int oldlen;
213 int err;
214
Kumar Gala8d04f022007-10-24 11:04:22 -0500215 *prop = fdt_get_property_w(fdt, nodeoffset, name, &oldlen);
Gerald Van Baren35748172007-03-31 12:00:56 -0400216 if (! (*prop))
217 return oldlen;
218
David Gibsonfc7758e2008-07-09 14:10:24 +1000219 if ((err = _fdt_splice_struct(fdt, (*prop)->data, FDT_TAGALIGN(oldlen),
220 FDT_TAGALIGN(len))))
Gerald Van Baren35748172007-03-31 12:00:56 -0400221 return err;
222
223 (*prop)->len = cpu_to_fdt32(len);
224 return 0;
225}
226
David Gibsonfc7758e2008-07-09 14:10:24 +1000227static int _fdt_add_property(void *fdt, int nodeoffset, const char *name,
228 int len, struct fdt_property **prop)
Gerald Van Baren35748172007-03-31 12:00:56 -0400229{
Gerald Van Baren35748172007-03-31 12:00:56 -0400230 int proplen;
231 int nextoffset;
232 int namestroff;
233 int err;
234
David Gibson2f08bfa2008-05-20 17:19:11 +1000235 if ((nextoffset = _fdt_check_node_offset(fdt, nodeoffset)) < 0)
236 return nextoffset;
Gerald Van Baren35748172007-03-31 12:00:56 -0400237
David Gibsonfc7758e2008-07-09 14:10:24 +1000238 namestroff = _fdt_find_add_string(fdt, name);
Gerald Van Baren35748172007-03-31 12:00:56 -0400239 if (namestroff < 0)
240 return namestroff;
241
Kumar Gala8d04f022007-10-24 11:04:22 -0500242 *prop = _fdt_offset_ptr_w(fdt, nextoffset);
David Gibsonfc7758e2008-07-09 14:10:24 +1000243 proplen = sizeof(**prop) + FDT_TAGALIGN(len);
Gerald Van Baren35748172007-03-31 12:00:56 -0400244
David Gibsonfc7758e2008-07-09 14:10:24 +1000245 err = _fdt_splice_struct(fdt, *prop, 0, proplen);
Gerald Van Baren35748172007-03-31 12:00:56 -0400246 if (err)
247 return err;
248
249 (*prop)->tag = cpu_to_fdt32(FDT_PROP);
250 (*prop)->nameoff = cpu_to_fdt32(namestroff);
251 (*prop)->len = cpu_to_fdt32(len);
252 return 0;
253}
254
David Gibson9eaeb072008-01-11 14:55:05 +1100255int fdt_set_name(void *fdt, int nodeoffset, const char *name)
256{
257 char *namep;
258 int oldlen, newlen;
259 int err;
260
David Gibsonfc7758e2008-07-09 14:10:24 +1000261 FDT_RW_CHECK_HEADER(fdt);
David Gibson9eaeb072008-01-11 14:55:05 +1100262
David Gibsonc6683022008-07-07 10:14:15 +1000263 namep = (char *)(uintptr_t)fdt_get_name(fdt, nodeoffset, &oldlen);
David Gibson9eaeb072008-01-11 14:55:05 +1100264 if (!namep)
265 return oldlen;
266
267 newlen = strlen(name);
268
David Gibsonfc7758e2008-07-09 14:10:24 +1000269 err = _fdt_splice_struct(fdt, namep, FDT_TAGALIGN(oldlen+1),
270 FDT_TAGALIGN(newlen+1));
David Gibson9eaeb072008-01-11 14:55:05 +1100271 if (err)
272 return err;
273
274 memcpy(namep, name, newlen+1);
275 return 0;
276}
277
Gerald Van Baren35748172007-03-31 12:00:56 -0400278int fdt_setprop(void *fdt, int nodeoffset, const char *name,
279 const void *val, int len)
280{
281 struct fdt_property *prop;
282 int err;
283
David Gibsonfc7758e2008-07-09 14:10:24 +1000284 FDT_RW_CHECK_HEADER(fdt);
Gerald Van Baren35748172007-03-31 12:00:56 -0400285
David Gibsonfc7758e2008-07-09 14:10:24 +1000286 err = _fdt_resize_property(fdt, nodeoffset, name, len, &prop);
Gerald Van Baren35748172007-03-31 12:00:56 -0400287 if (err == -FDT_ERR_NOTFOUND)
David Gibsonfc7758e2008-07-09 14:10:24 +1000288 err = _fdt_add_property(fdt, nodeoffset, name, len, &prop);
Gerald Van Baren35748172007-03-31 12:00:56 -0400289 if (err)
290 return err;
291
292 memcpy(prop->data, val, len);
293 return 0;
294}
295
Minghuan Lian36ad18a2012-08-27 19:38:59 -0500296int fdt_appendprop(void *fdt, int nodeoffset, const char *name,
297 const void *val, int len)
298{
299 struct fdt_property *prop;
300 int err, oldlen, newlen;
301
302 FDT_RW_CHECK_HEADER(fdt);
303
304 prop = fdt_get_property_w(fdt, nodeoffset, name, &oldlen);
305 if (prop) {
306 newlen = len + oldlen;
307 err = _fdt_splice_struct(fdt, prop->data,
308 FDT_TAGALIGN(oldlen),
309 FDT_TAGALIGN(newlen));
310 if (err)
311 return err;
312 prop->len = cpu_to_fdt32(newlen);
313 memcpy(prop->data + oldlen, val, len);
314 } else {
315 err = _fdt_add_property(fdt, nodeoffset, name, len, &prop);
316 if (err)
317 return err;
318 memcpy(prop->data, val, len);
319 }
320 return 0;
321}
322
Gerald Van Baren35748172007-03-31 12:00:56 -0400323int fdt_delprop(void *fdt, int nodeoffset, const char *name)
324{
325 struct fdt_property *prop;
326 int len, proplen;
327
David Gibsonfc7758e2008-07-09 14:10:24 +1000328 FDT_RW_CHECK_HEADER(fdt);
Gerald Van Baren35748172007-03-31 12:00:56 -0400329
Kumar Gala8d04f022007-10-24 11:04:22 -0500330 prop = fdt_get_property_w(fdt, nodeoffset, name, &len);
Gerald Van Baren35748172007-03-31 12:00:56 -0400331 if (! prop)
332 return len;
333
David Gibsonfc7758e2008-07-09 14:10:24 +1000334 proplen = sizeof(*prop) + FDT_TAGALIGN(len);
335 return _fdt_splice_struct(fdt, prop, proplen, 0);
Gerald Van Baren35748172007-03-31 12:00:56 -0400336}
337
338int fdt_add_subnode_namelen(void *fdt, int parentoffset,
339 const char *name, int namelen)
340{
341 struct fdt_node_header *nh;
342 int offset, nextoffset;
343 int nodelen;
344 int err;
345 uint32_t tag;
Kim Phillipsb2ba62a2013-01-16 13:59:50 +0000346 fdt32_t *endtag;
Gerald Van Baren35748172007-03-31 12:00:56 -0400347
David Gibsonfc7758e2008-07-09 14:10:24 +1000348 FDT_RW_CHECK_HEADER(fdt);
Gerald Van Baren35748172007-03-31 12:00:56 -0400349
350 offset = fdt_subnode_offset_namelen(fdt, parentoffset, name, namelen);
351 if (offset >= 0)
352 return -FDT_ERR_EXISTS;
353 else if (offset != -FDT_ERR_NOTFOUND)
354 return offset;
355
356 /* Try to place the new node after the parent's properties */
Kumar Gala8d04f022007-10-24 11:04:22 -0500357 fdt_next_tag(fdt, parentoffset, &nextoffset); /* skip the BEGIN_NODE */
Gerald Van Baren35748172007-03-31 12:00:56 -0400358 do {
359 offset = nextoffset;
Kumar Gala8d04f022007-10-24 11:04:22 -0500360 tag = fdt_next_tag(fdt, offset, &nextoffset);
David Gibsonf84d65f2008-02-14 16:50:34 +1100361 } while ((tag == FDT_PROP) || (tag == FDT_NOP));
Gerald Van Baren35748172007-03-31 12:00:56 -0400362
Kumar Gala8d04f022007-10-24 11:04:22 -0500363 nh = _fdt_offset_ptr_w(fdt, offset);
David Gibsonfc7758e2008-07-09 14:10:24 +1000364 nodelen = sizeof(*nh) + FDT_TAGALIGN(namelen+1) + FDT_TAGSIZE;
Gerald Van Baren35748172007-03-31 12:00:56 -0400365
David Gibsonfc7758e2008-07-09 14:10:24 +1000366 err = _fdt_splice_struct(fdt, nh, 0, nodelen);
Gerald Van Baren35748172007-03-31 12:00:56 -0400367 if (err)
368 return err;
369
370 nh->tag = cpu_to_fdt32(FDT_BEGIN_NODE);
David Gibsonfc7758e2008-07-09 14:10:24 +1000371 memset(nh->name, 0, FDT_TAGALIGN(namelen+1));
Gerald Van Baren35748172007-03-31 12:00:56 -0400372 memcpy(nh->name, name, namelen);
Kim Phillipsb2ba62a2013-01-16 13:59:50 +0000373 endtag = (fdt32_t *)((char *)nh + nodelen - FDT_TAGSIZE);
Gerald Van Baren35748172007-03-31 12:00:56 -0400374 *endtag = cpu_to_fdt32(FDT_END_NODE);
375
376 return offset;
377}
378
379int fdt_add_subnode(void *fdt, int parentoffset, const char *name)
380{
381 return fdt_add_subnode_namelen(fdt, parentoffset, name, strlen(name));
382}
383
384int fdt_del_node(void *fdt, int nodeoffset)
385{
386 int endoffset;
387
David Gibsonfc7758e2008-07-09 14:10:24 +1000388 FDT_RW_CHECK_HEADER(fdt);
Kumar Gala8d04f022007-10-24 11:04:22 -0500389
Gerald Van Baren35748172007-03-31 12:00:56 -0400390 endoffset = _fdt_node_end_offset(fdt, nodeoffset);
391 if (endoffset < 0)
392 return endoffset;
393
David Gibsonfc7758e2008-07-09 14:10:24 +1000394 return _fdt_splice_struct(fdt, _fdt_offset_ptr_w(fdt, nodeoffset),
395 endoffset - nodeoffset, 0);
Gerald Van Baren35748172007-03-31 12:00:56 -0400396}
397
David Gibsonfc7758e2008-07-09 14:10:24 +1000398static void _fdt_packblocks(const char *old, char *new,
399 int mem_rsv_size, int struct_size)
Kumar Gala8d04f022007-10-24 11:04:22 -0500400{
401 int mem_rsv_off, struct_off, strings_off;
402
David Gibsonfc7758e2008-07-09 14:10:24 +1000403 mem_rsv_off = FDT_ALIGN(sizeof(struct fdt_header), 8);
Kumar Gala8d04f022007-10-24 11:04:22 -0500404 struct_off = mem_rsv_off + mem_rsv_size;
405 strings_off = struct_off + struct_size;
406
David Gibsonef4e8ce2008-07-07 10:10:48 +1000407 memmove(new + mem_rsv_off, old + fdt_off_mem_rsvmap(old), mem_rsv_size);
408 fdt_set_off_mem_rsvmap(new, mem_rsv_off);
Kumar Gala8d04f022007-10-24 11:04:22 -0500409
David Gibsonef4e8ce2008-07-07 10:10:48 +1000410 memmove(new + struct_off, old + fdt_off_dt_struct(old), struct_size);
411 fdt_set_off_dt_struct(new, struct_off);
412 fdt_set_size_dt_struct(new, struct_size);
Kumar Gala8d04f022007-10-24 11:04:22 -0500413
David Gibsonef4e8ce2008-07-07 10:10:48 +1000414 memmove(new + strings_off, old + fdt_off_dt_strings(old),
415 fdt_size_dt_strings(old));
416 fdt_set_off_dt_strings(new, strings_off);
417 fdt_set_size_dt_strings(new, fdt_size_dt_strings(old));
Kumar Gala8d04f022007-10-24 11:04:22 -0500418}
419
420int fdt_open_into(const void *fdt, void *buf, int bufsize)
Gerald Van Baren35748172007-03-31 12:00:56 -0400421{
422 int err;
Kumar Gala8d04f022007-10-24 11:04:22 -0500423 int mem_rsv_size, struct_size;
424 int newsize;
David Gibsonef4e8ce2008-07-07 10:10:48 +1000425 const char *fdtstart = fdt;
426 const char *fdtend = fdtstart + fdt_totalsize(fdt);
427 char *tmp;
Gerald Van Baren35748172007-03-31 12:00:56 -0400428
David Gibsonfc7758e2008-07-09 14:10:24 +1000429 FDT_CHECK_HEADER(fdt);
Gerald Van Baren35748172007-03-31 12:00:56 -0400430
Kumar Gala8d04f022007-10-24 11:04:22 -0500431 mem_rsv_size = (fdt_num_mem_rsv(fdt)+1)
432 * sizeof(struct fdt_reserve_entry);
Gerald Van Baren35748172007-03-31 12:00:56 -0400433
Kumar Gala8d04f022007-10-24 11:04:22 -0500434 if (fdt_version(fdt) >= 17) {
435 struct_size = fdt_size_dt_struct(fdt);
436 } else {
437 struct_size = 0;
438 while (fdt_next_tag(fdt, struct_size, &struct_size) != FDT_END)
439 ;
David Gibsona22d9cf2009-02-06 14:03:24 +1100440 if (struct_size < 0)
441 return struct_size;
Kumar Gala8d04f022007-10-24 11:04:22 -0500442 }
Gerald Van Baren35748172007-03-31 12:00:56 -0400443
David Gibsonfc7758e2008-07-09 14:10:24 +1000444 if (!_fdt_blocks_misordered(fdt, mem_rsv_size, struct_size)) {
Kumar Gala8d04f022007-10-24 11:04:22 -0500445 /* no further work necessary */
446 err = fdt_move(fdt, buf, bufsize);
447 if (err)
448 return err;
449 fdt_set_version(buf, 17);
450 fdt_set_size_dt_struct(buf, struct_size);
451 fdt_set_totalsize(buf, bufsize);
452 return 0;
453 }
Gerald Van Baren35748172007-03-31 12:00:56 -0400454
Kumar Gala8d04f022007-10-24 11:04:22 -0500455 /* Need to reorder */
David Gibsonfc7758e2008-07-09 14:10:24 +1000456 newsize = FDT_ALIGN(sizeof(struct fdt_header), 8) + mem_rsv_size
Kumar Gala8d04f022007-10-24 11:04:22 -0500457 + struct_size + fdt_size_dt_strings(fdt);
458
459 if (bufsize < newsize)
460 return -FDT_ERR_NOSPACE;
461
David Gibsonef4e8ce2008-07-07 10:10:48 +1000462 /* First attempt to build converted tree at beginning of buffer */
463 tmp = buf;
464 /* But if that overlaps with the old tree... */
465 if (((tmp + newsize) > fdtstart) && (tmp < fdtend)) {
466 /* Try right after the old tree instead */
David Gibsonc6683022008-07-07 10:14:15 +1000467 tmp = (char *)(uintptr_t)fdtend;
David Gibsonef4e8ce2008-07-07 10:10:48 +1000468 if ((tmp + newsize) > ((char *)buf + bufsize))
Kumar Gala8d04f022007-10-24 11:04:22 -0500469 return -FDT_ERR_NOSPACE;
470 }
471
David Gibsonfc7758e2008-07-09 14:10:24 +1000472 _fdt_packblocks(fdt, tmp, mem_rsv_size, struct_size);
Kumar Gala8d04f022007-10-24 11:04:22 -0500473 memmove(buf, tmp, newsize);
474
475 fdt_set_magic(buf, FDT_MAGIC);
476 fdt_set_totalsize(buf, bufsize);
477 fdt_set_version(buf, 17);
478 fdt_set_last_comp_version(buf, 16);
479 fdt_set_boot_cpuid_phys(buf, fdt_boot_cpuid_phys(fdt));
Gerald Van Baren35748172007-03-31 12:00:56 -0400480
481 return 0;
482}
483
484int fdt_pack(void *fdt)
485{
Kumar Gala8d04f022007-10-24 11:04:22 -0500486 int mem_rsv_size;
Gerald Van Baren35748172007-03-31 12:00:56 -0400487
David Gibsonfc7758e2008-07-09 14:10:24 +1000488 FDT_RW_CHECK_HEADER(fdt);
Gerald Van Baren35748172007-03-31 12:00:56 -0400489
Kumar Gala8d04f022007-10-24 11:04:22 -0500490 mem_rsv_size = (fdt_num_mem_rsv(fdt)+1)
491 * sizeof(struct fdt_reserve_entry);
David Gibsonfc7758e2008-07-09 14:10:24 +1000492 _fdt_packblocks(fdt, fdt, mem_rsv_size, fdt_size_dt_struct(fdt));
493 fdt_set_totalsize(fdt, _fdt_data_size(fdt));
Kumar Gala8d04f022007-10-24 11:04:22 -0500494
Gerald Van Baren35748172007-03-31 12:00:56 -0400495 return 0;
496}