blob: cd06178e7b023c37ae23d165d1fb6456673a43d1 [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
296int fdt_delprop(void *fdt, int nodeoffset, const char *name)
297{
298 struct fdt_property *prop;
299 int len, proplen;
300
David Gibsonfc7758e2008-07-09 14:10:24 +1000301 FDT_RW_CHECK_HEADER(fdt);
Gerald Van Baren35748172007-03-31 12:00:56 -0400302
Kumar Gala8d04f022007-10-24 11:04:22 -0500303 prop = fdt_get_property_w(fdt, nodeoffset, name, &len);
Gerald Van Baren35748172007-03-31 12:00:56 -0400304 if (! prop)
305 return len;
306
David Gibsonfc7758e2008-07-09 14:10:24 +1000307 proplen = sizeof(*prop) + FDT_TAGALIGN(len);
308 return _fdt_splice_struct(fdt, prop, proplen, 0);
Gerald Van Baren35748172007-03-31 12:00:56 -0400309}
310
311int fdt_add_subnode_namelen(void *fdt, int parentoffset,
312 const char *name, int namelen)
313{
314 struct fdt_node_header *nh;
315 int offset, nextoffset;
316 int nodelen;
317 int err;
318 uint32_t tag;
319 uint32_t *endtag;
320
David Gibsonfc7758e2008-07-09 14:10:24 +1000321 FDT_RW_CHECK_HEADER(fdt);
Gerald Van Baren35748172007-03-31 12:00:56 -0400322
323 offset = fdt_subnode_offset_namelen(fdt, parentoffset, name, namelen);
324 if (offset >= 0)
325 return -FDT_ERR_EXISTS;
326 else if (offset != -FDT_ERR_NOTFOUND)
327 return offset;
328
329 /* Try to place the new node after the parent's properties */
Kumar Gala8d04f022007-10-24 11:04:22 -0500330 fdt_next_tag(fdt, parentoffset, &nextoffset); /* skip the BEGIN_NODE */
Gerald Van Baren35748172007-03-31 12:00:56 -0400331 do {
332 offset = nextoffset;
Kumar Gala8d04f022007-10-24 11:04:22 -0500333 tag = fdt_next_tag(fdt, offset, &nextoffset);
David Gibsonf84d65f2008-02-14 16:50:34 +1100334 } while ((tag == FDT_PROP) || (tag == FDT_NOP));
Gerald Van Baren35748172007-03-31 12:00:56 -0400335
Kumar Gala8d04f022007-10-24 11:04:22 -0500336 nh = _fdt_offset_ptr_w(fdt, offset);
David Gibsonfc7758e2008-07-09 14:10:24 +1000337 nodelen = sizeof(*nh) + FDT_TAGALIGN(namelen+1) + FDT_TAGSIZE;
Gerald Van Baren35748172007-03-31 12:00:56 -0400338
David Gibsonfc7758e2008-07-09 14:10:24 +1000339 err = _fdt_splice_struct(fdt, nh, 0, nodelen);
Gerald Van Baren35748172007-03-31 12:00:56 -0400340 if (err)
341 return err;
342
343 nh->tag = cpu_to_fdt32(FDT_BEGIN_NODE);
David Gibsonfc7758e2008-07-09 14:10:24 +1000344 memset(nh->name, 0, FDT_TAGALIGN(namelen+1));
Gerald Van Baren35748172007-03-31 12:00:56 -0400345 memcpy(nh->name, name, namelen);
David Gibsonef4e8ce2008-07-07 10:10:48 +1000346 endtag = (uint32_t *)((char *)nh + nodelen - FDT_TAGSIZE);
Gerald Van Baren35748172007-03-31 12:00:56 -0400347 *endtag = cpu_to_fdt32(FDT_END_NODE);
348
349 return offset;
350}
351
352int fdt_add_subnode(void *fdt, int parentoffset, const char *name)
353{
354 return fdt_add_subnode_namelen(fdt, parentoffset, name, strlen(name));
355}
356
357int fdt_del_node(void *fdt, int nodeoffset)
358{
359 int endoffset;
360
David Gibsonfc7758e2008-07-09 14:10:24 +1000361 FDT_RW_CHECK_HEADER(fdt);
Kumar Gala8d04f022007-10-24 11:04:22 -0500362
Gerald Van Baren35748172007-03-31 12:00:56 -0400363 endoffset = _fdt_node_end_offset(fdt, nodeoffset);
364 if (endoffset < 0)
365 return endoffset;
366
David Gibsonfc7758e2008-07-09 14:10:24 +1000367 return _fdt_splice_struct(fdt, _fdt_offset_ptr_w(fdt, nodeoffset),
368 endoffset - nodeoffset, 0);
Gerald Van Baren35748172007-03-31 12:00:56 -0400369}
370
David Gibsonfc7758e2008-07-09 14:10:24 +1000371static void _fdt_packblocks(const char *old, char *new,
372 int mem_rsv_size, int struct_size)
Kumar Gala8d04f022007-10-24 11:04:22 -0500373{
374 int mem_rsv_off, struct_off, strings_off;
375
David Gibsonfc7758e2008-07-09 14:10:24 +1000376 mem_rsv_off = FDT_ALIGN(sizeof(struct fdt_header), 8);
Kumar Gala8d04f022007-10-24 11:04:22 -0500377 struct_off = mem_rsv_off + mem_rsv_size;
378 strings_off = struct_off + struct_size;
379
David Gibsonef4e8ce2008-07-07 10:10:48 +1000380 memmove(new + mem_rsv_off, old + fdt_off_mem_rsvmap(old), mem_rsv_size);
381 fdt_set_off_mem_rsvmap(new, mem_rsv_off);
Kumar Gala8d04f022007-10-24 11:04:22 -0500382
David Gibsonef4e8ce2008-07-07 10:10:48 +1000383 memmove(new + struct_off, old + fdt_off_dt_struct(old), struct_size);
384 fdt_set_off_dt_struct(new, struct_off);
385 fdt_set_size_dt_struct(new, struct_size);
Kumar Gala8d04f022007-10-24 11:04:22 -0500386
David Gibsonef4e8ce2008-07-07 10:10:48 +1000387 memmove(new + strings_off, old + fdt_off_dt_strings(old),
388 fdt_size_dt_strings(old));
389 fdt_set_off_dt_strings(new, strings_off);
390 fdt_set_size_dt_strings(new, fdt_size_dt_strings(old));
Kumar Gala8d04f022007-10-24 11:04:22 -0500391}
392
393int fdt_open_into(const void *fdt, void *buf, int bufsize)
Gerald Van Baren35748172007-03-31 12:00:56 -0400394{
395 int err;
Kumar Gala8d04f022007-10-24 11:04:22 -0500396 int mem_rsv_size, struct_size;
397 int newsize;
David Gibsonef4e8ce2008-07-07 10:10:48 +1000398 const char *fdtstart = fdt;
399 const char *fdtend = fdtstart + fdt_totalsize(fdt);
400 char *tmp;
Gerald Van Baren35748172007-03-31 12:00:56 -0400401
David Gibsonfc7758e2008-07-09 14:10:24 +1000402 FDT_CHECK_HEADER(fdt);
Gerald Van Baren35748172007-03-31 12:00:56 -0400403
Kumar Gala8d04f022007-10-24 11:04:22 -0500404 mem_rsv_size = (fdt_num_mem_rsv(fdt)+1)
405 * sizeof(struct fdt_reserve_entry);
Gerald Van Baren35748172007-03-31 12:00:56 -0400406
Kumar Gala8d04f022007-10-24 11:04:22 -0500407 if (fdt_version(fdt) >= 17) {
408 struct_size = fdt_size_dt_struct(fdt);
409 } else {
410 struct_size = 0;
411 while (fdt_next_tag(fdt, struct_size, &struct_size) != FDT_END)
412 ;
413 }
Gerald Van Baren35748172007-03-31 12:00:56 -0400414
David Gibsonfc7758e2008-07-09 14:10:24 +1000415 if (!_fdt_blocks_misordered(fdt, mem_rsv_size, struct_size)) {
Kumar Gala8d04f022007-10-24 11:04:22 -0500416 /* no further work necessary */
417 err = fdt_move(fdt, buf, bufsize);
418 if (err)
419 return err;
420 fdt_set_version(buf, 17);
421 fdt_set_size_dt_struct(buf, struct_size);
422 fdt_set_totalsize(buf, bufsize);
423 return 0;
424 }
Gerald Van Baren35748172007-03-31 12:00:56 -0400425
Kumar Gala8d04f022007-10-24 11:04:22 -0500426 /* Need to reorder */
David Gibsonfc7758e2008-07-09 14:10:24 +1000427 newsize = FDT_ALIGN(sizeof(struct fdt_header), 8) + mem_rsv_size
Kumar Gala8d04f022007-10-24 11:04:22 -0500428 + struct_size + fdt_size_dt_strings(fdt);
429
430 if (bufsize < newsize)
431 return -FDT_ERR_NOSPACE;
432
David Gibsonef4e8ce2008-07-07 10:10:48 +1000433 /* First attempt to build converted tree at beginning of buffer */
434 tmp = buf;
435 /* But if that overlaps with the old tree... */
436 if (((tmp + newsize) > fdtstart) && (tmp < fdtend)) {
437 /* Try right after the old tree instead */
David Gibsonc6683022008-07-07 10:14:15 +1000438 tmp = (char *)(uintptr_t)fdtend;
David Gibsonef4e8ce2008-07-07 10:10:48 +1000439 if ((tmp + newsize) > ((char *)buf + bufsize))
Kumar Gala8d04f022007-10-24 11:04:22 -0500440 return -FDT_ERR_NOSPACE;
441 }
442
David Gibsonfc7758e2008-07-09 14:10:24 +1000443 _fdt_packblocks(fdt, tmp, mem_rsv_size, struct_size);
Kumar Gala8d04f022007-10-24 11:04:22 -0500444 memmove(buf, tmp, newsize);
445
446 fdt_set_magic(buf, FDT_MAGIC);
447 fdt_set_totalsize(buf, bufsize);
448 fdt_set_version(buf, 17);
449 fdt_set_last_comp_version(buf, 16);
450 fdt_set_boot_cpuid_phys(buf, fdt_boot_cpuid_phys(fdt));
Gerald Van Baren35748172007-03-31 12:00:56 -0400451
452 return 0;
453}
454
455int fdt_pack(void *fdt)
456{
Kumar Gala8d04f022007-10-24 11:04:22 -0500457 int mem_rsv_size;
Gerald Van Baren35748172007-03-31 12:00:56 -0400458
David Gibsonfc7758e2008-07-09 14:10:24 +1000459 FDT_RW_CHECK_HEADER(fdt);
Gerald Van Baren35748172007-03-31 12:00:56 -0400460
Kumar Gala8d04f022007-10-24 11:04:22 -0500461 mem_rsv_size = (fdt_num_mem_rsv(fdt)+1)
462 * sizeof(struct fdt_reserve_entry);
David Gibsonfc7758e2008-07-09 14:10:24 +1000463 _fdt_packblocks(fdt, fdt, mem_rsv_size, fdt_size_dt_struct(fdt));
464 fdt_set_totalsize(fdt, _fdt_data_size(fdt));
Kumar Gala8d04f022007-10-24 11:04:22 -0500465
Gerald Van Baren35748172007-03-31 12:00:56 -0400466 return 0;
467}