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 int fdt_wrapper_del_node(const void *devp)
109 {
110 	return fdt_del_node(fdt, devp_offset(devp));
111 }
112 
113 static void *fdt_wrapper_get_parent(const void *devp)
114 {
115 	return offset_devp(fdt_parent_offset(fdt, devp_offset(devp)));
116 }
117 
118 static void *fdt_wrapper_create_node(const void *devp, const char *name)
119 {
120 	int offset;
121 
122 	offset = fdt_add_subnode(fdt, devp_offset(devp), name);
123 	if (offset == -FDT_ERR_NOSPACE) {
124 		expand_buf(strlen(name) + 16);
125 		offset = fdt_add_subnode(fdt, devp_offset(devp), name);
126 	}
127 
128 	return offset_devp(offset);
129 }
130 
131 static void *fdt_wrapper_find_node_by_prop_value(const void *prev,
132 						 const char *name,
133 						 const char *val,
134 						 int len)
135 {
136 	int offset = fdt_node_offset_by_prop_value(fdt, devp_offset_find(prev),
137 	                                           name, val, len);
138 	return offset_devp(offset);
139 }
140 
141 static void *fdt_wrapper_find_node_by_compatible(const void *prev,
142 						 const char *val)
143 {
144 	int offset = fdt_node_offset_by_compatible(fdt, devp_offset_find(prev),
145 	                                           val);
146 	return offset_devp(offset);
147 }
148 
149 static char *fdt_wrapper_get_path(const void *devp, char *buf, int len)
150 {
151 	int rc;
152 
153 	rc = fdt_get_path(fdt, devp_offset(devp), buf, len);
154 	if (check_err(rc))
155 		return NULL;
156 	return buf;
157 }
158 
159 static unsigned long fdt_wrapper_finalize(void)
160 {
161 	int rc;
162 
163 	rc = fdt_pack(fdt);
164 	if (rc != 0)
165 		fatal("Couldn't pack flat tree: %s\n\r",
166 		      fdt_strerror(rc));
167 	return (unsigned long)fdt;
168 }
169 
170 void fdt_init(void *blob)
171 {
172 	int err;
173 	int bufsize;
174 
175 	dt_ops.finddevice = fdt_wrapper_finddevice;
176 	dt_ops.getprop = fdt_wrapper_getprop;
177 	dt_ops.setprop = fdt_wrapper_setprop;
178 	dt_ops.get_parent = fdt_wrapper_get_parent;
179 	dt_ops.create_node = fdt_wrapper_create_node;
180 	dt_ops.find_node_by_prop_value = fdt_wrapper_find_node_by_prop_value;
181 	dt_ops.find_node_by_compatible = fdt_wrapper_find_node_by_compatible;
182 	dt_ops.del_node = fdt_wrapper_del_node;
183 	dt_ops.get_path = fdt_wrapper_get_path;
184 	dt_ops.finalize = fdt_wrapper_finalize;
185 
186 	/* Make sure the dt blob is the right version and so forth */
187 	fdt = blob;
188 	bufsize = fdt_totalsize(fdt) + EXPAND_GRANULARITY;
189 	buf = malloc(bufsize);
190 	if(!buf)
191 		fatal("malloc failed. can't relocate the device tree\n\r");
192 
193 	err = fdt_open_into(fdt, buf, bufsize);
194 
195 	if (err != 0)
196 		fatal("fdt_init(): %s\n\r", fdt_strerror(err));
197 
198 	fdt = buf;
199 }
200