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 int fdt_delprop(void *fdt, int nodeoffset, const char *name)
 192 {
 193         struct fdt_property *prop;
 194         int len, proplen;
 195
 196         RW_CHECK_HEADER(fdt);
 197
 198         prop = fdt_get_property(fdt, nodeoffset, name, &len);
 199         if (! prop)
 200                 return len;
 201
 202         proplen = sizeof(*prop) + ALIGN(len, FDT_TAGSIZE);
 203         return _blob_splice_struct(fdt, prop, proplen, 0);
 204 }
 205
 206 int fdt_add_subnode_namelen(void *fdt, int parentoffset,
 207                             const char *name, int namelen)
 208 {
 209         struct fdt_node_header *nh;
 210         int offset, nextoffset;
 211         int nodelen;
 212         int err;
 213         uint32_t tag;
 214         uint32_t *endtag;
 215
 216         RW_CHECK_HEADER(fdt);
 217
 218         offset = fdt_subnode_offset_namelen(fdt, parentoffset, name, namelen);
 219         if (offset >= 0)
 220                 return -FDT_ERR_EXISTS;
 221         else if (offset != -FDT_ERR_NOTFOUND)
 222                 return offset;
 223
 224         /* Try to place the new node after the parent's properties */
 225         fdt_next_tag(fdt, parentoffset, &nextoffset, NULL); /* skip the BEGIN_NODE */
 226         do {
 227                 offset = nextoffset;
 228                 tag = fdt_next_tag(fdt, offset, &nextoffset, NULL);
 229         } while (tag == FDT_PROP);
 230
 231         nh = _fdt_offset_ptr(fdt, offset);
 232         nodelen = sizeof(*nh) + ALIGN(namelen+1, FDT_TAGSIZE) + FDT_TAGSIZE;
 233
 234         err = _blob_splice_struct(fdt, nh, 0, nodelen);
 235         if (err)
 236                 return err;
 237
 238         nh->tag = cpu_to_fdt32(FDT_BEGIN_NODE);
 239         memset(nh->name, 0, ALIGN(namelen+1, FDT_TAGSIZE));
 240         memcpy(nh->name, name, namelen);
 241         endtag = (uint32_t *)((void *)nh + nodelen - FDT_TAGSIZE);
 242         *endtag = cpu_to_fdt32(FDT_END_NODE);
 243
 244         return offset;
 245 }
 246
 247 int fdt_add_subnode(void *fdt, int parentoffset, const char *name)
 248 {
 249         return fdt_add_subnode_namelen(fdt, parentoffset, name, strlen(name));
 250 }
 251
 252 int fdt_del_node(void *fdt, int nodeoffset)
 253 {
 254         int endoffset;
 255
 256         endoffset = _fdt_node_end_offset(fdt, nodeoffset);
 257         if (endoffset < 0)
 258                 return endoffset;
 259
 260         return _blob_splice_struct(fdt, _fdt_offset_ptr(fdt, nodeoffset),
 261                                    endoffset - nodeoffset, 0);
 262 }
 263
 264 int fdt_open_into(void *fdt, void *buf, int bufsize)
 265 {
 266         int err;
 267
 268         err = fdt_move(fdt, buf, bufsize);
 269         if (err)
 270                 return err;
 271
 272         fdt = buf;
 273
 274         fdt_set_header(fdt, totalsize, bufsize);
 275
 276         /* FIXME: re-order if necessary */
 277
 278         err = rw_check_header(fdt);
 279         if (err)
 280                 return err;
 281
 282         return 0;
 283 }
 284
 285 int fdt_pack(void *fdt)
 286 {
 287         int err;
 288
 289         err = rw_check_header(fdt);
 290         if (err)
 291                 return err;
 292
 293         /* FIXME: pack components */
 294         fdt_set_header(fdt, totalsize, _blob_data_size(fdt));
 295         return 0;
 296 }
 297
 298 #endif /* CONFIG_OF_LIBFDT */