powerpc: Zero fill the return values of rtas argument buffer
[linux-2.6] / arch / powerpc / boot / libfdt-wrapper.c
1 /*
2  * This file does the necessary interface mapping between the bootwrapper
3  * device tree operations and the interface provided by shared source
4  * files flatdevicetree.[ch].
5  *
6  * Copyright 2007 David Gibson, IBM Corporation.
7  *
8  * 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, but
14  * WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this library; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
21  * 02110-1301 USA
22  */
23
24 #include <stddef.h>
25 #include <stdio.h>
26 #include <page.h>
27 #include <libfdt.h>
28 #include "ops.h"
29
30 #define DEBUG   0
31 #define BAD_ERROR(err)  (((err) < 0) \
32                          && ((err) != -FDT_ERR_NOTFOUND) \
33                          && ((err) != -FDT_ERR_EXISTS))
34
35 #define check_err(err) \
36         ({ \
37                 if (BAD_ERROR(err) || ((err < 0) && DEBUG)) \
38                         printf("%s():%d  %s\n\r", __func__, __LINE__, \
39                                fdt_strerror(err)); \
40                 if (BAD_ERROR(err)) \
41                         exit(); \
42                 (err < 0) ? -1 : 0; \
43         })
44
45 #define offset_devp(off)        \
46         ({ \
47                 int _offset = (off); \
48                 check_err(_offset) ? NULL : (void *)(_offset+1); \
49         })
50
51 #define devp_offset_find(devp)  (((int)(devp))-1)
52 #define devp_offset(devp)       (devp ? ((int)(devp))-1 : 0)
53
54 static void *fdt;
55 static void *buf; /* = NULL */
56
57 #define EXPAND_GRANULARITY      1024
58
59 static void expand_buf(int minexpand)
60 {
61         int size = fdt_totalsize(fdt);
62         int rc;
63
64         size = _ALIGN(size + minexpand, EXPAND_GRANULARITY);
65         buf = platform_ops.realloc(buf, size);
66         if (!buf)
67                 fatal("Couldn't find %d bytes to expand device tree\n\r", size);
68         rc = fdt_open_into(fdt, buf, size);
69         if (rc != 0)
70                 fatal("Couldn't expand fdt into new buffer: %s\n\r",
71                       fdt_strerror(rc));
72
73         fdt = buf;
74 }
75
76 static void *fdt_wrapper_finddevice(const char *path)
77 {
78         return offset_devp(fdt_path_offset(fdt, path));
79 }
80
81 static int fdt_wrapper_getprop(const void *devp, const char *name,
82                                void *buf, const int buflen)
83 {
84         const void *p;
85         int len;
86
87         p = fdt_getprop(fdt, devp_offset(devp), name, &len);
88         if (!p)
89                 return check_err(len);
90         memcpy(buf, p, min(len, buflen));
91         return len;
92 }
93
94 static int fdt_wrapper_setprop(const void *devp, const char *name,
95                                const void *buf, const int len)
96 {
97         int rc;
98
99         rc = fdt_setprop(fdt, devp_offset(devp), name, buf, len);
100         if (rc == -FDT_ERR_NOSPACE) {
101                 expand_buf(len + 16);
102                 rc = fdt_setprop(fdt, devp_offset(devp), name, buf, len);
103         }
104
105         return check_err(rc);
106 }
107
108 static void *fdt_wrapper_get_parent(const void *devp)
109 {
110         return offset_devp(fdt_parent_offset(fdt, devp_offset(devp)));
111 }
112
113 static void *fdt_wrapper_create_node(const void *devp, const char *name)
114 {
115         int offset;
116
117         offset = fdt_add_subnode(fdt, devp_offset(devp), name);
118         if (offset == -FDT_ERR_NOSPACE) {
119                 expand_buf(strlen(name) + 16);
120                 offset = fdt_add_subnode(fdt, devp_offset(devp), name);
121         }
122
123         return offset_devp(offset);
124 }
125
126 static void *fdt_wrapper_find_node_by_prop_value(const void *prev,
127                                                  const char *name,
128                                                  const char *val,
129                                                  int len)
130 {
131         int offset = fdt_node_offset_by_prop_value(fdt, devp_offset_find(prev),
132                                                    name, val, len);
133         return offset_devp(offset);
134 }
135
136 static void *fdt_wrapper_find_node_by_compatible(const void *prev,
137                                                  const char *val)
138 {
139         int offset = fdt_node_offset_by_compatible(fdt, devp_offset_find(prev),
140                                                    val);
141         return offset_devp(offset);
142 }
143
144 static char *fdt_wrapper_get_path(const void *devp, char *buf, int len)
145 {
146         int rc;
147
148         rc = fdt_get_path(fdt, devp_offset(devp), buf, len);
149         if (check_err(rc))
150                 return NULL;
151         return buf;
152 }
153
154 static unsigned long fdt_wrapper_finalize(void)
155 {
156         int rc;
157
158         rc = fdt_pack(fdt);
159         if (rc != 0)
160                 fatal("Couldn't pack flat tree: %s\n\r",
161                       fdt_strerror(rc));
162         return (unsigned long)fdt;
163 }
164
165 void fdt_init(void *blob)
166 {
167         int err;
168
169         dt_ops.finddevice = fdt_wrapper_finddevice;
170         dt_ops.getprop = fdt_wrapper_getprop;
171         dt_ops.setprop = fdt_wrapper_setprop;
172         dt_ops.get_parent = fdt_wrapper_get_parent;
173         dt_ops.create_node = fdt_wrapper_create_node;
174         dt_ops.find_node_by_prop_value = fdt_wrapper_find_node_by_prop_value;
175         dt_ops.find_node_by_compatible = fdt_wrapper_find_node_by_compatible;
176         dt_ops.get_path = fdt_wrapper_get_path;
177         dt_ops.finalize = fdt_wrapper_finalize;
178
179         /* Make sure the dt blob is the right version and so forth */
180         fdt = blob;
181         err = fdt_open_into(fdt, fdt, fdt_totalsize(blob));
182         if (err == -FDT_ERR_NOSPACE) {
183                 int bufsize = fdt_totalsize(fdt) + 4;
184                 buf = malloc(bufsize);
185                 err = fdt_open_into(fdt, buf, bufsize);
186         }
187
188         if (err != 0)
189                 fatal("fdt_init(): %s\n\r", fdt_strerror(err));
190
191         if (buf)
192                 fdt = buf;
193 }