libfdt/fdt_rw.c

   1 /*
   2  * libfdt - Flat Device Tree manipulation
   3  * Copyright (C) 2006 David Gibson, IBM Corporation.
   4  *
   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.
   9  *
  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.
  14  *
  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
  18  */
  19 #include "config.h"
  20 #if CONFIG_OF_LIBFDT
  21
  22 #include "libfdt_env.h"
  23
  24 #include <fdt.h>
  25 #include <libfdt.h>
  26
  27 #include "libfdt_internal.h"
  28
  29 static int rw_check_header(void *fdt)
  30 {
  31         int err;
  32
  33         if ((err = fdt_check_header(fdt)))
  34                 return err;
  35         if (fdt_version(fdt) < 0x11)
  36                 return -FDT_ERR_BADVERSION;
  37         if (fdt_off_mem_rsvmap(fdt) < ALIGN(sizeof(struct fdt_header), 8))
  38                 return -FDT_ERR_BADLAYOUT;
  39         if (fdt_off_dt_struct(fdt) <
  40             (fdt_off_mem_rsvmap(fdt) + sizeof(struct fdt_reserve_entry)))
  41                 return -FDT_ERR_BADLAYOUT;
  42         if (fdt_off_dt_strings(fdt) <
  43             (fdt_off_dt_struct(fdt) + fdt_size_dt_struct(fdt)))
  44                 return -FDT_ERR_BADLAYOUT;
  45         if (fdt_totalsize(fdt) <
  46             (fdt_off_dt_strings(fdt) + fdt_size_dt_strings(fdt)))
  47                 return -FDT_ERR_BADLAYOUT;
  48         return 0;
  49 }
  50
  51 #define RW_CHECK_HEADER(fdt) \
  52         { \
  53                 int err; \
  54                 if ((err = rw_check_header(fdt)) != 0) \
  55                         return err; \
  56         }
  57
  58 static inline int _blob_data_size(void *fdt)
  59 {
  60         return fdt_off_dt_strings(fdt) + fdt_size_dt_strings(fdt);
  61 }
  62
  63 static int _blob_splice(void *fdt, void *p, int oldlen, int newlen)
  64 {
  65         void *end = fdt + _blob_data_size(fdt);
  66
  67         if (((p + oldlen) < p) || ((p + oldlen) > end))
  68                 return -FDT_ERR_BADOFFSET;
  69         if ((end - oldlen + newlen) > (fdt + fdt_totalsize(fdt)))
  70                 return -FDT_ERR_NOSPACE;
  71         memmove(p + newlen, p + oldlen, end - p - oldlen);
  72         return 0;
  73 }
  74
  75 static int _blob_splice_struct(void *fdt, void *p,
  76                                int oldlen, int newlen)
  77 {
  78         int delta = newlen - oldlen;
  79         int err;
  80
  81         if ((err = _blob_splice(fdt, p, oldlen, newlen)))
  82                 return err;
  83
  84         fdt_set_header(fdt, size_dt_struct, fdt_size_dt_struct(fdt) + delta);
  85         fdt_set_header(fdt, off_dt_strings, fdt_off_dt_strings(fdt) + delta);
  86         return 0;
  87 }
  88
  89 static int _blob_splice_string(void *fdt, int newlen)
  90 {
  91         void *p = fdt + fdt_off_dt_strings(fdt) + fdt_size_dt_strings(fdt);
  92         int err;
  93
  94         if ((err = _blob_splice(fdt, p, 0, newlen)))
  95                 return err;
  96
  97         fdt_set_header(fdt, size_dt_strings, fdt_size_dt_strings(fdt) + newlen);
  98         return 0;
  99 }
 100
 101 static int _find_add_string(void *fdt, const char *s)
 102 {
 103         char *strtab = (char *)fdt + fdt_off_dt_strings(fdt);
 104         const char *p;
 105         char *new;
 106         int len = strlen(s) + 1;
 107         int err;
 108
 109         p = _fdt_find_string(strtab, fdt_size_dt_strings(fdt), s);
 110         if (p)
 111                 /* found it */
 112                 return (p - strtab);
 113
 114         new = strtab + fdt_size_dt_strings(fdt);
 115         err = _blob_splice_string(fdt, len);
 116         if (err)
 117                 return err;
 118
 119         memcpy(new, s, len);
 120         return (new - strtab);
 121 }
 122
 123 static int _resize_property(void *fdt, int nodeoffset, const char *name, int len,
 124                             struct fdt_property **prop)
 125 {
 126         int oldlen;
 127         int err;
 128
 129         *prop = fdt_get_property(fdt, nodeoffset, name, &oldlen);
 130         if (! (*prop))
 131                 return oldlen;
 132
 133         if ((err = _blob_splice_struct(fdt, (*prop)->data,
 134                                        ALIGN(oldlen, FDT_TAGSIZE),
 135                                        ALIGN(len, FDT_TAGSIZE))))
 136                 return err;
 137
 138         (*prop)->len = cpu_to_fdt32(len);
 139         return 0;
 140 }
 141
 142 static int _add_property(void *fdt, int nodeoffset, const char *name, int len,
 143                          struct fdt_property **prop)
 144 {
 145         uint32_t tag;
 146         int proplen;
 147         int nextoffset;
 148         int namestroff;
 149         int err;
 150
 151         tag = fdt_next_tag(fdt, nodeoffset, &nextoffset, NULL);
 152         if (tag != FDT_BEGIN_NODE)
 153                 return -FDT_ERR_BADOFFSET;
 154
 155         namestroff = _find_add_string(fdt, name);
 156         if (namestroff < 0)
 157                 return namestroff;
 158
 159         *prop = _fdt_offset_ptr(fdt, nextoffset);
 160         proplen = sizeof(**prop) + ALIGN(len, FDT_TAGSIZE);
 161
 162         err = _blob_splice_struct(fdt, *prop, 0, proplen);
 163         if (err)
 164                 return err;
 165
 166         (*prop)->tag = cpu_to_fdt32(FDT_PROP);
 167         (*prop)->nameoff = cpu_to_fdt32(namestroff);
 168         (*prop)->len = cpu_to_fdt32(len);
 169         return 0;
 170 }
 171
 172 int fdt_setprop(void *fdt, int nodeoffset, const char *name,
 173                 const void *val, int len)
 174 {
 175         struct fdt_property *prop;
 176         int err;
 177
 178         if ((err = rw_check_header(fdt)))
 179                 return err;
 180
 181         err = _resize_property(fdt, nodeoffset, name, len, &prop);
 182         if (err == -FDT_ERR_NOTFOUND)
 183                 err = _add_property(fdt, nodeoffset, name, len, &prop);
 184         if (err)
 185                 return err;
 186
 187         memcpy(prop->data, val, len);
 188         return 0;
 189 }
 190
 191 /**
 192  * fdt_find_and_setprop: Find a node and set it's property
 193  *
 194  * @fdt: ptr to device tree
 195  * @node: path of node
 196  * @prop: property name
 197  * @val: ptr to new value
 198  * @len: length of new property value
 199  * @create: flag to create the property if it doesn't exist
 200  *
 201  * Convenience function to directly set a property given the path to the node.
 202  */
 203 int fdt_find_and_setprop(void *fdt, const char *node, const char *prop,
 204                          const void *val, int len, int create)
 205 {
 206         int nodeoff = fdt_find_node_by_path(fdt, node);
 207
 208         if (nodeoff < 0)
 209                 return nodeoff;
 210
 211         if ((!create) && (fdt_get_property(fdt, nodeoff, prop, 0) == NULL))
 212                 return 0; /* create flag not set; so exit quietly */
 213
 214         return fdt_setprop(fdt, nodeoff, prop, val, len);
 215 }
 216
 217 int fdt_delprop(void *fdt, int nodeoffset, const char *name)
 218 {
 219         struct fdt_property *prop;
 220         int len, proplen;
 221
 222         RW_CHECK_HEADER(fdt);
 223
 224         prop = fdt_get_property(fdt, nodeoffset, name, &len);
 225         if (! prop)
 226                 return len;
 227
 228         proplen = sizeof(*prop) + ALIGN(len, FDT_TAGSIZE);
 229         return _blob_splice_struct(fdt, prop, proplen, 0);
 230 }
 231
 232 int fdt_add_subnode_namelen(void *fdt, int parentoffset,
 233                             const char *name, int namelen)
 234 {
 235         struct fdt_node_header *nh;
 236         int offset, nextoffset;
 237         int nodelen;
 238         int err;
 239         uint32_t tag;
 240         uint32_t *endtag;
 241
 242         RW_CHECK_HEADER(fdt);
 243
 244         offset = fdt_subnode_offset_namelen(fdt, parentoffset, name, namelen);
 245         if (offset >= 0)
 246                 return -FDT_ERR_EXISTS;
 247         else if (offset != -FDT_ERR_NOTFOUND)
 248                 return offset;
 249
 250         /* Try to place the new node after the parent's properties */
 251         fdt_next_tag(fdt, parentoffset, &nextoffset, NULL); /* skip the BEGIN_NODE */
 252         do {
 253                 offset = nextoffset;
 254                 tag = fdt_next_tag(fdt, offset, &nextoffset, NULL);
 255         } while (tag == FDT_PROP);
 256
 257         nh = _fdt_offset_ptr(fdt, offset);
 258         nodelen = sizeof(*nh) + ALIGN(namelen+1, FDT_TAGSIZE) + FDT_TAGSIZE;
 259
 260         err = _blob_splice_struct(fdt, nh, 0, nodelen);
 261         if (err)
 262                 return err;
 263
 264         nh->tag = cpu_to_fdt32(FDT_BEGIN_NODE);
 265         memset(nh->name, 0, ALIGN(namelen+1, FDT_TAGSIZE));
 266         memcpy(nh->name, name, namelen);
 267         endtag = (uint32_t *)((void *)nh + nodelen - FDT_TAGSIZE);
 268         *endtag = cpu_to_fdt32(FDT_END_NODE);
 269
 270         return offset;
 271 }
 272
 273 int fdt_add_subnode(void *fdt, int parentoffset, const char *name)
 274 {
 275         return fdt_add_subnode_namelen(fdt, parentoffset, name, strlen(name));
 276 }
 277
 278 int fdt_del_node(void *fdt, int nodeoffset)
 279 {
 280         int endoffset;
 281
 282         endoffset = _fdt_node_end_offset(fdt, nodeoffset);
 283         if (endoffset < 0)
 284                 return endoffset;
 285
 286         return _blob_splice_struct(fdt, _fdt_offset_ptr(fdt, nodeoffset),
 287                                    endoffset - nodeoffset, 0);
 288 }
 289
 290 int fdt_open_into(void *fdt, void *buf, int bufsize)
 291 {
 292         int err;
 293
 294         err = fdt_move(fdt, buf, bufsize);
 295         if (err)
 296                 return err;
 297
 298         fdt = buf;
 299
 300         fdt_set_header(fdt, totalsize, bufsize);
 301
 302         /* FIXME: re-order if necessary */
 303
 304         err = rw_check_header(fdt);
 305         if (err)
 306                 return err;
 307
 308         return 0;
 309 }
 310
 311 int fdt_pack(void *fdt)
 312 {
 313         int err;
 314
 315         err = rw_check_header(fdt);
 316         if (err)
 317                 return err;
 318
 319         /* FIXME: pack components */
 320         fdt_set_header(fdt, totalsize, _blob_data_size(fdt));
 321         return 0;
 322 }
 323
 324 #endif /* CONFIG_OF_LIBFDT */