Merge with git://www.denx.de/git/u-boot.git
[platform/kernel/u-boot.git] / libfdt / fdt_ro.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 #define CHECK_HEADER(fdt)       { \
27         int err; \
28         if ((err = fdt_check_header(fdt)) != 0) \
29                 return err; \
30 }
31
32 static int offset_streq(const void *fdt, int offset,
33                         const char *s, int len)
34 {
35         const char *p = fdt_offset_ptr(fdt, offset, len+1);
36
37         if (! p)
38                 /* short match */
39                 return 0;
40
41         if (memcmp(p, s, len) != 0)
42                 return 0;
43
44         if (p[len] != '\0')
45                 return 0;
46
47         return 1;
48 }
49
50 /*
51  * Return a pointer to the string at the given string offset.
52  */
53 char *fdt_string(const void *fdt, int stroffset)
54 {
55         return (char *)fdt + fdt_off_dt_strings(fdt) + stroffset;
56 }
57
58 /*
59  * Return the node offset of the node specified by:
60  *   parentoffset - starting place (0 to start at the root)
61  *   name         - name being searched for
62  *   namelen      - length of the name: typically strlen(name)
63  *
64  * Notes:
65  *   If the start node has subnodes, the subnodes are _not_ searched for the
66  *     requested name.
67  */
68 int fdt_subnode_offset_namelen(const void *fdt, int parentoffset,
69                                const char *name, int namelen)
70 {
71         int level = 0;
72         uint32_t tag;
73         int offset, nextoffset;
74
75         CHECK_HEADER(fdt);
76
77         tag = fdt_next_tag(fdt, parentoffset, &nextoffset, NULL);
78         if (tag != FDT_BEGIN_NODE)
79                 return -FDT_ERR_BADOFFSET;
80
81         do {
82                 offset = nextoffset;
83                 tag = fdt_next_tag(fdt, offset, &nextoffset, NULL);
84
85                 switch (tag) {
86                 case FDT_END:
87                         return -FDT_ERR_TRUNCATED;
88
89                 case FDT_BEGIN_NODE:
90                         level++;
91                         /*
92                          * If we are nested down levels, ignore the strings
93                          * until we get back to the proper level.
94                          */
95                         if (level != 1)
96                                 continue;
97
98                         /* Return the offset if this is "our" string. */
99                         if (offset_streq(fdt, offset+FDT_TAGSIZE, name, namelen))
100                                 return offset;
101                         break;
102
103                 case FDT_END_NODE:
104                         level--;
105                         break;
106
107                 case FDT_PROP:
108                 case FDT_NOP:
109                         break;
110
111                 default:
112                         return -FDT_ERR_BADSTRUCTURE;
113                 }
114         } while (level >= 0);
115
116         return -FDT_ERR_NOTFOUND;
117 }
118
119 /*
120  * See fdt_subnode_offset_namelen()
121  */
122 int fdt_subnode_offset(const void *fdt, int parentoffset,
123                        const char *name)
124 {
125         return fdt_subnode_offset_namelen(fdt, parentoffset, name, strlen(name));
126 }
127
128 /*
129  * Searches for the node corresponding to the given path and returns the
130  * offset of that node.
131  */
132 int fdt_path_offset(const void *fdt, const char *path)
133 {
134         const char *end = path + strlen(path);
135         const char *p = path;
136         int offset = 0;
137
138         CHECK_HEADER(fdt);
139
140         /* Paths must be absolute */
141         if (*path != '/')
142                 return -FDT_ERR_BADPATH;
143
144         while (*p) {
145                 const char *q;
146
147                 /* Skip path separator(s) */
148                 while (*p == '/')
149                         p++;
150                 if (! *p)
151                         return -FDT_ERR_BADPATH;
152
153                 /*
154                  * Find the next path separator.  The characters between
155                  * p and q are the next segment of the the path to find.
156                  */
157                 q = strchr(p, '/');
158                 if (! q)
159                         q = end;
160
161                 /*
162                  * Find the offset corresponding to the this path segment.
163                  */
164                 offset = fdt_subnode_offset_namelen(fdt, offset, p, q-p);
165
166                 /* Oops, error, abort abort abort */
167                 if (offset < 0)
168                         return offset;
169
170                 p = q;
171         }
172
173         return offset;
174 }
175
176 /*
177  * Given the offset of a node and a name of a property in that node, return
178  * a pointer to the property struct.
179  */
180 struct fdt_property *fdt_get_property(const void *fdt,
181                                       int nodeoffset,
182                                       const char *name, int *lenp)
183 {
184         int level = 0;
185         uint32_t tag;
186         struct fdt_property *prop;
187         int namestroff;
188         int offset, nextoffset;
189         int err;
190
191         if ((err = fdt_check_header(fdt)) != 0)
192                 goto fail;
193
194         err = -FDT_ERR_BADOFFSET;
195         if (nodeoffset % FDT_TAGSIZE)
196                 goto fail;
197
198         tag = fdt_next_tag(fdt, nodeoffset, &nextoffset, NULL);
199         if (tag != FDT_BEGIN_NODE)
200                 goto fail;
201
202         do {
203                 offset = nextoffset;
204
205                 tag = fdt_next_tag(fdt, offset, &nextoffset, NULL);
206                 switch (tag) {
207                 case FDT_END:
208                         err = -FDT_ERR_TRUNCATED;
209                         goto fail;
210
211                 case FDT_BEGIN_NODE:
212                         level++;
213                         break;
214
215                 case FDT_END_NODE:
216                         level--;
217                         break;
218
219                 case FDT_PROP:
220                         /*
221                          * If we are nested down levels, ignore the strings
222                          * until we get back to the proper level.
223                          */
224                         if (level != 0)
225                                 continue;
226
227                         err = -FDT_ERR_BADSTRUCTURE;
228                         prop = fdt_offset_ptr_typed(fdt, offset, prop);
229                         if (! prop)
230                                 goto fail;
231                         namestroff = fdt32_to_cpu(prop->nameoff);
232                         if (streq(fdt_string(fdt, namestroff), name)) {
233                                 /* Found it! */
234                                 int len = fdt32_to_cpu(prop->len);
235                                 prop = fdt_offset_ptr(fdt, offset,
236                                                       sizeof(*prop)+len);
237                                 if (! prop)
238                                         goto fail;
239
240                                 if (lenp)
241                                         *lenp = len;
242
243                                 return prop;
244                         }
245                         break;
246
247                 case FDT_NOP:
248                         break;
249
250                 default:
251                         err = -FDT_ERR_BADSTRUCTURE;
252                         goto fail;
253                 }
254         } while (level >= 0);
255
256         err = -FDT_ERR_NOTFOUND;
257 fail:
258         if (lenp)
259                 *lenp = err;
260         return NULL;
261 }
262
263 /*
264  * Given the offset of a node and a name of a property in that node, return
265  * a pointer to the property data (ONLY).
266  */
267 void *fdt_getprop(const void *fdt, int nodeoffset,
268                   const char *name, int *lenp)
269 {
270         const struct fdt_property *prop;
271
272         prop = fdt_get_property(fdt, nodeoffset, name, lenp);
273         if (! prop)
274                 return NULL;
275
276         return (void *)prop->data;
277 }
278
279
280 uint32_t fdt_next_tag(const void *fdt, int offset, int *nextoffset, char **namep)
281 {
282         const uint32_t *tagp, *lenp;
283         uint32_t tag;
284         const char *p;
285
286         if (offset % FDT_TAGSIZE)
287                 return -1;
288
289         tagp = fdt_offset_ptr(fdt, offset, FDT_TAGSIZE);
290         if (! tagp)
291                 return FDT_END; /* premature end */
292         tag = fdt32_to_cpu(*tagp);
293         offset += FDT_TAGSIZE;
294
295         switch (tag) {
296         case FDT_BEGIN_NODE:
297                 if(namep)
298                         *namep = fdt_offset_ptr(fdt, offset, 1);
299
300                 /* skip name */
301                 do {
302                         p = fdt_offset_ptr(fdt, offset++, 1);
303                 } while (p && (*p != '\0'));
304                 if (! p)
305                         return FDT_END;
306                 break;
307         case FDT_PROP:
308                 lenp = fdt_offset_ptr(fdt, offset, sizeof(*lenp));
309                 if (! lenp)
310                         return FDT_END;
311                 /*
312                  * Get the property and set the namep to the name.
313                  */
314                 if(namep) {
315                         struct fdt_property *prop;
316
317                         prop = fdt_offset_ptr_typed(fdt, offset - FDT_TAGSIZE, prop);
318                         if (! prop)
319                                 return -FDT_ERR_BADSTRUCTURE;
320                         *namep = fdt_string(fdt, fdt32_to_cpu(prop->nameoff));
321                 }
322                 /* skip name offset, length and value */
323                 offset += 2*FDT_TAGSIZE + fdt32_to_cpu(*lenp);
324                 break;
325         }
326
327         if (nextoffset)
328                 *nextoffset = ALIGN(offset, FDT_TAGSIZE);
329
330         return tag;
331 }
332
333 /*
334  * Return the number of used reserve map entries and total slots available.
335  */
336 int fdt_num_reservemap(void *fdt, int *used, int *total)
337 {
338         struct fdt_reserve_entry *re;
339         int  start;
340         int  end;
341         int  err = fdt_check_header(fdt);
342
343         if (err != 0)
344                 return err;
345
346         start = fdt_off_mem_rsvmap(fdt);
347
348         /*
349          * Convention is that the reserve map is before the dt_struct,
350          * but it does not have to be.
351          */
352         end = fdt_totalsize(fdt);
353         if (end > fdt_off_dt_struct(fdt))
354                 end = fdt_off_dt_struct(fdt);
355         if (end > fdt_off_dt_strings(fdt))
356                 end = fdt_off_dt_strings(fdt);
357
358         /*
359          * Since the reserved area list is zero terminated, you get one fewer.
360          */
361         if (total)
362                 *total = ((end - start) / sizeof(struct fdt_reserve_entry)) - 1;
363
364         if (used) {
365                 *used = 0;
366                 while (start < end) {
367                         re = (struct fdt_reserve_entry *)(fdt + start);
368                         if (re->size == 0)
369                                 return 0;       /* zero size terminates the list */
370
371                         *used += 1;
372                         start += sizeof(struct fdt_reserve_entry);
373                 }
374                 /*
375                  * If we get here, there was no zero size termination.
376                  */
377                 return -FDT_ERR_BADLAYOUT;
378         }
379         return 0;
380 }
381
382 /*
383  * Return the nth reserve map entry.
384  */
385 int fdt_get_reservemap(void *fdt, int n, struct fdt_reserve_entry *re)
386 {
387         int  used;
388         int  total;
389         int  err;
390
391         err = fdt_num_reservemap(fdt, &used, &total);
392         if (err != 0)
393                 return err;
394
395         if (n >= total)
396                 return -FDT_ERR_NOSPACE;
397         if (re) {
398                 *re = *(struct fdt_reserve_entry *)
399                         _fdt_offset_ptr(fdt, n * sizeof(struct fdt_reserve_entry));
400         }
401         return 0;
402 }