~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/scripts/dtc/libfdt/fdt.c

Version: ~ [ linux-5.16-rc3 ] ~ [ linux-5.15.5 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.82 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.162 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.218 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.256 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.291 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.293 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * libfdt - Flat Device Tree manipulation
  3  * Copyright (C) 2006 David Gibson, IBM Corporation.
  4  *
  5  * libfdt is dual licensed: you can use it either under the terms of
  6  * the GPL, or the BSD license, at your option.
  7  *
  8  *  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.
 12  *
 13  *     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.
 50  */
 51 #include "libfdt_env.h"
 52 
 53 #include <fdt.h>
 54 #include <libfdt.h>
 55 
 56 #include "libfdt_internal.h"
 57 
 58 int fdt_check_header(const void *fdt)
 59 {
 60         if (fdt_magic(fdt) == FDT_MAGIC) {
 61                 /* Complete tree */
 62                 if (fdt_version(fdt) < FDT_FIRST_SUPPORTED_VERSION)
 63                         return -FDT_ERR_BADVERSION;
 64                 if (fdt_last_comp_version(fdt) > FDT_LAST_SUPPORTED_VERSION)
 65                         return -FDT_ERR_BADVERSION;
 66         } else if (fdt_magic(fdt) == FDT_SW_MAGIC) {
 67                 /* Unfinished sequential-write blob */
 68                 if (fdt_size_dt_struct(fdt) == 0)
 69                         return -FDT_ERR_BADSTATE;
 70         } else {
 71                 return -FDT_ERR_BADMAGIC;
 72         }
 73 
 74         return 0;
 75 }
 76 
 77 const void *fdt_offset_ptr(const void *fdt, int offset, unsigned int len)
 78 {
 79         unsigned absoffset = offset + fdt_off_dt_struct(fdt);
 80 
 81         if ((absoffset < offset)
 82             || ((absoffset + len) < absoffset)
 83             || (absoffset + len) > fdt_totalsize(fdt))
 84                 return NULL;
 85 
 86         if (fdt_version(fdt) >= 0x11)
 87                 if (((offset + len) < offset)
 88                     || ((offset + len) > fdt_size_dt_struct(fdt)))
 89                         return NULL;
 90 
 91         return _fdt_offset_ptr(fdt, offset);
 92 }
 93 
 94 uint32_t fdt_next_tag(const void *fdt, int startoffset, int *nextoffset)
 95 {
 96         const fdt32_t *tagp, *lenp;
 97         uint32_t tag;
 98         int offset = startoffset;
 99         const char *p;
100 
101         *nextoffset = -FDT_ERR_TRUNCATED;
102         tagp = fdt_offset_ptr(fdt, offset, FDT_TAGSIZE);
103         if (!tagp)
104                 return FDT_END; /* premature end */
105         tag = fdt32_to_cpu(*tagp);
106         offset += FDT_TAGSIZE;
107 
108         *nextoffset = -FDT_ERR_BADSTRUCTURE;
109         switch (tag) {
110         case FDT_BEGIN_NODE:
111                 /* skip name */
112                 do {
113                         p = fdt_offset_ptr(fdt, offset++, 1);
114                 } while (p && (*p != '\0'));
115                 if (!p)
116                         return FDT_END; /* premature end */
117                 break;
118 
119         case FDT_PROP:
120                 lenp = fdt_offset_ptr(fdt, offset, sizeof(*lenp));
121                 if (!lenp)
122                         return FDT_END; /* premature end */
123                 /* skip-name offset, length and value */
124                 offset += sizeof(struct fdt_property) - FDT_TAGSIZE
125                         + fdt32_to_cpu(*lenp);
126                 break;
127 
128         case FDT_END:
129         case FDT_END_NODE:
130         case FDT_NOP:
131                 break;
132 
133         default:
134                 return FDT_END;
135         }
136 
137         if (!fdt_offset_ptr(fdt, startoffset, offset - startoffset))
138                 return FDT_END; /* premature end */
139 
140         *nextoffset = FDT_TAGALIGN(offset);
141         return tag;
142 }
143 
144 int _fdt_check_node_offset(const void *fdt, int offset)
145 {
146         if ((offset < 0) || (offset % FDT_TAGSIZE)
147             || (fdt_next_tag(fdt, offset, &offset) != FDT_BEGIN_NODE))
148                 return -FDT_ERR_BADOFFSET;
149 
150         return offset;
151 }
152 
153 int _fdt_check_prop_offset(const void *fdt, int offset)
154 {
155         if ((offset < 0) || (offset % FDT_TAGSIZE)
156             || (fdt_next_tag(fdt, offset, &offset) != FDT_PROP))
157                 return -FDT_ERR_BADOFFSET;
158 
159         return offset;
160 }
161 
162 int fdt_next_node(const void *fdt, int offset, int *depth)
163 {
164         int nextoffset = 0;
165         uint32_t tag;
166 
167         if (offset >= 0)
168                 if ((nextoffset = _fdt_check_node_offset(fdt, offset)) < 0)
169                         return nextoffset;
170 
171         do {
172                 offset = nextoffset;
173                 tag = fdt_next_tag(fdt, offset, &nextoffset);
174 
175                 switch (tag) {
176                 case FDT_PROP:
177                 case FDT_NOP:
178                         break;
179 
180                 case FDT_BEGIN_NODE:
181                         if (depth)
182                                 (*depth)++;
183                         break;
184 
185                 case FDT_END_NODE:
186                         if (depth && ((--(*depth)) < 0))
187                                 return nextoffset;
188                         break;
189 
190                 case FDT_END:
191                         if ((nextoffset >= 0)
192                             || ((nextoffset == -FDT_ERR_TRUNCATED) && !depth))
193                                 return -FDT_ERR_NOTFOUND;
194                         else
195                                 return nextoffset;
196                 }
197         } while (tag != FDT_BEGIN_NODE);
198 
199         return offset;
200 }
201 
202 int fdt_first_subnode(const void *fdt, int offset)
203 {
204         int depth = 0;
205 
206         offset = fdt_next_node(fdt, offset, &depth);
207         if (offset < 0 || depth != 1)
208                 return -FDT_ERR_NOTFOUND;
209 
210         return offset;
211 }
212 
213 int fdt_next_subnode(const void *fdt, int offset)
214 {
215         int depth = 1;
216 
217         /*
218          * With respect to the parent, the depth of the next subnode will be
219          * the same as the last.
220          */
221         do {
222                 offset = fdt_next_node(fdt, offset, &depth);
223                 if (offset < 0 || depth < 1)
224                         return -FDT_ERR_NOTFOUND;
225         } while (depth > 1);
226 
227         return offset;
228 }
229 
230 const char *_fdt_find_string(const char *strtab, int tabsize, const char *s)
231 {
232         int len = strlen(s) + 1;
233         const char *last = strtab + tabsize - len;
234         const char *p;
235 
236         for (p = strtab; p <= last; p++)
237                 if (memcmp(p, s, len) == 0)
238                         return p;
239         return NULL;
240 }
241 
242 int fdt_move(const void *fdt, void *buf, int bufsize)
243 {
244         FDT_CHECK_HEADER(fdt);
245 
246         if (fdt_totalsize(fdt) > bufsize)
247                 return -FDT_ERR_NOSPACE;
248 
249         memmove(buf, fdt, fdt_totalsize(fdt));
250         return 0;
251 }
252 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp