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