2 * libfdt - Flat Device Tree manipulation
3 * Copyright (C) 2006 David Gibson, IBM Corporation.
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public License
7 * as published by the Free Software Foundation; either version 2.1 of
8 * the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
19 #include "libfdt_env.h"
24 #include "libfdt_internal.h"
26 static int rw_check_header(void *fdt)
30 if ((err = fdt_check_header(fdt)))
32 if (fdt_version(fdt) < 0x11)
33 return -FDT_ERR_BADVERSION;
34 if (fdt_off_mem_rsvmap(fdt) < ALIGN(sizeof(struct fdt_header), 8))
35 return -FDT_ERR_BADLAYOUT;
36 if (fdt_off_dt_struct(fdt) <
37 (fdt_off_mem_rsvmap(fdt) + sizeof(struct fdt_reserve_entry)))
38 return -FDT_ERR_BADLAYOUT;
39 if (fdt_off_dt_strings(fdt) <
40 (fdt_off_dt_struct(fdt) + fdt_size_dt_struct(fdt)))
41 return -FDT_ERR_BADLAYOUT;
42 if (fdt_totalsize(fdt) <
43 (fdt_off_dt_strings(fdt) + fdt_size_dt_strings(fdt)))
44 return -FDT_ERR_BADLAYOUT;
48 #define RW_CHECK_HEADER(fdt) \
51 if ((err = rw_check_header(fdt)) != 0) \
55 static inline int _blob_data_size(void *fdt)
57 return fdt_off_dt_strings(fdt) + fdt_size_dt_strings(fdt);
60 static int _blob_splice(void *fdt, void *p, int oldlen, int newlen)
62 void *end = fdt + _blob_data_size(fdt);
64 if (((p + oldlen) < p) || ((p + oldlen) > end))
65 return -FDT_ERR_BADOFFSET;
66 if ((end - oldlen + newlen) > (fdt + fdt_totalsize(fdt)))
67 return -FDT_ERR_NOSPACE;
68 memmove(p + newlen, p + oldlen, end - p - oldlen);
72 static int _blob_splice_struct(void *fdt, void *p,
73 int oldlen, int newlen)
75 int delta = newlen - oldlen;
78 if ((err = _blob_splice(fdt, p, oldlen, newlen)))
81 fdt_set_header(fdt, size_dt_struct, fdt_size_dt_struct(fdt) + delta);
82 fdt_set_header(fdt, off_dt_strings, fdt_off_dt_strings(fdt) + delta);
86 static int _blob_splice_string(void *fdt, int newlen)
88 void *p = fdt + fdt_off_dt_strings(fdt) + fdt_size_dt_strings(fdt);
91 if ((err = _blob_splice(fdt, p, 0, newlen)))
94 fdt_set_header(fdt, size_dt_strings, fdt_size_dt_strings(fdt) + newlen);
98 static int _find_add_string(void *fdt, const char *s)
100 char *strtab = (char *)fdt + fdt_off_dt_strings(fdt);
103 int len = strlen(s) + 1;
106 p = _fdt_find_string(strtab, fdt_size_dt_strings(fdt), s);
111 new = strtab + fdt_size_dt_strings(fdt);
112 err = _blob_splice_string(fdt, len);
117 return (new - strtab);
120 static int _resize_property(void *fdt, int nodeoffset, const char *name, int len,
121 struct fdt_property **prop)
126 *prop = fdt_get_property(fdt, nodeoffset, name, &oldlen);
130 if ((err = _blob_splice_struct(fdt, (*prop)->data,
131 ALIGN(oldlen, FDT_TAGSIZE),
132 ALIGN(len, FDT_TAGSIZE))))
135 (*prop)->len = cpu_to_fdt32(len);
139 static int _add_property(void *fdt, int nodeoffset, const char *name, int len,
140 struct fdt_property **prop)
148 tag = fdt_next_tag(fdt, nodeoffset, &nextoffset, NULL);
149 if (tag != FDT_BEGIN_NODE)
150 return -FDT_ERR_BADOFFSET;
152 namestroff = _find_add_string(fdt, name);
156 *prop = _fdt_offset_ptr(fdt, nextoffset);
157 proplen = sizeof(**prop) + ALIGN(len, FDT_TAGSIZE);
159 err = _blob_splice_struct(fdt, *prop, 0, proplen);
163 (*prop)->tag = cpu_to_fdt32(FDT_PROP);
164 (*prop)->nameoff = cpu_to_fdt32(namestroff);
165 (*prop)->len = cpu_to_fdt32(len);
169 int fdt_setprop(void *fdt, int nodeoffset, const char *name,
170 const void *val, int len)
172 struct fdt_property *prop;
175 if ((err = rw_check_header(fdt)))
178 err = _resize_property(fdt, nodeoffset, name, len, &prop);
179 if (err == -FDT_ERR_NOTFOUND)
180 err = _add_property(fdt, nodeoffset, name, len, &prop);
184 memcpy(prop->data, val, len);
189 * fdt_find_and_setprop: Find a node and set it's property
191 * @fdt: ptr to device tree
192 * @node: path of node
193 * @prop: property name
194 * @val: ptr to new value
195 * @len: length of new property value
196 * @create: flag to create the property if it doesn't exist
198 * Convenience function to directly set a property given the path to the node.
200 int fdt_find_and_setprop(void *fdt, const char *node, const char *prop,
201 const void *val, int len, int create)
203 int nodeoff = fdt_find_node_by_path(fdt, node);
208 if ((!create) && (fdt_get_property(fdt, nodeoff, prop, 0) == NULL))
209 return 0; /* create flag not set; so exit quietly */
211 return fdt_setprop(fdt, nodeoff, prop, val, len);
214 int fdt_delprop(void *fdt, int nodeoffset, const char *name)
216 struct fdt_property *prop;
219 RW_CHECK_HEADER(fdt);
221 prop = fdt_get_property(fdt, nodeoffset, name, &len);
225 proplen = sizeof(*prop) + ALIGN(len, FDT_TAGSIZE);
226 return _blob_splice_struct(fdt, prop, proplen, 0);
229 int fdt_add_subnode_namelen(void *fdt, int parentoffset,
230 const char *name, int namelen)
232 struct fdt_node_header *nh;
233 int offset, nextoffset;
239 RW_CHECK_HEADER(fdt);
241 offset = fdt_subnode_offset_namelen(fdt, parentoffset, name, namelen);
243 return -FDT_ERR_EXISTS;
244 else if (offset != -FDT_ERR_NOTFOUND)
247 /* Try to place the new node after the parent's properties */
248 fdt_next_tag(fdt, parentoffset, &nextoffset, NULL); /* skip the BEGIN_NODE */
251 tag = fdt_next_tag(fdt, offset, &nextoffset, NULL);
252 } while (tag == FDT_PROP);
254 nh = _fdt_offset_ptr(fdt, offset);
255 nodelen = sizeof(*nh) + ALIGN(namelen+1, FDT_TAGSIZE) + FDT_TAGSIZE;
257 err = _blob_splice_struct(fdt, nh, 0, nodelen);
261 nh->tag = cpu_to_fdt32(FDT_BEGIN_NODE);
262 memset(nh->name, 0, ALIGN(namelen+1, FDT_TAGSIZE));
263 memcpy(nh->name, name, namelen);
264 endtag = (uint32_t *)((void *)nh + nodelen - FDT_TAGSIZE);
265 *endtag = cpu_to_fdt32(FDT_END_NODE);
270 int fdt_add_subnode(void *fdt, int parentoffset, const char *name)
272 return fdt_add_subnode_namelen(fdt, parentoffset, name, strlen(name));
275 int fdt_del_node(void *fdt, int nodeoffset)
279 endoffset = _fdt_node_end_offset(fdt, nodeoffset);
283 return _blob_splice_struct(fdt, _fdt_offset_ptr(fdt, nodeoffset),
284 endoffset - nodeoffset, 0);
287 int fdt_open_into(void *fdt, void *buf, int bufsize)
291 err = fdt_move(fdt, buf, bufsize);
297 fdt_set_header(fdt, totalsize, bufsize);
299 /* FIXME: re-order if necessary */
301 err = rw_check_header(fdt);
308 int fdt_pack(void *fdt)
312 err = rw_check_header(fdt);
316 /* FIXME: pack components */
317 fdt_set_header(fdt, totalsize, _blob_data_size(fdt));