1 | /* |
2 | * Flattened Image Tree loader. |
3 | * |
4 | * Copyright (c) 2016 Imagination Technologies |
5 | * |
6 | * This library is free software; you can redistribute it and/or |
7 | * modify it under the terms of the GNU Lesser General Public |
8 | * License as published by the Free Software Foundation; either |
9 | * version 2 of the License, or (at your option) any later version. |
10 | * |
11 | * This library is distributed in the hope that it will be useful, |
12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
14 | * Lesser General Public License for more details. |
15 | * |
16 | * You should have received a copy of the GNU Lesser General Public |
17 | * License along with this library; if not, see <http://www.gnu.org/licenses/>. |
18 | */ |
19 | |
20 | #include "qemu/osdep.h" |
21 | #include "qapi/error.h" |
22 | #include "qemu/units.h" |
23 | #include "exec/memory.h" |
24 | #include "hw/loader.h" |
25 | #include "hw/loader-fit.h" |
26 | #include "qemu/cutils.h" |
27 | #include "qemu/error-report.h" |
28 | #include "sysemu/device_tree.h" |
29 | |
30 | #include <libfdt.h> |
31 | #include <zlib.h> |
32 | |
33 | #define FIT_LOADER_MAX_PATH (128) |
34 | |
35 | static const void *fit_load_image_alloc(const void *itb, const char *name, |
36 | int *poff, size_t *psz, Error **errp) |
37 | { |
38 | const void *data; |
39 | const char *comp; |
40 | void *uncomp_data; |
41 | char path[FIT_LOADER_MAX_PATH]; |
42 | int off, sz; |
43 | ssize_t uncomp_len; |
44 | |
45 | snprintf(path, sizeof(path), "/images/%s" , name); |
46 | |
47 | off = fdt_path_offset(itb, path); |
48 | if (off < 0) { |
49 | error_setg(errp, "can't find node %s" , path); |
50 | return NULL; |
51 | } |
52 | if (poff) { |
53 | *poff = off; |
54 | } |
55 | |
56 | data = fdt_getprop(itb, off, "data" , &sz); |
57 | if (!data) { |
58 | error_setg(errp, "can't get %s/data" , path); |
59 | return NULL; |
60 | } |
61 | |
62 | comp = fdt_getprop(itb, off, "compression" , NULL); |
63 | if (!comp || !strcmp(comp, "none" )) { |
64 | if (psz) { |
65 | *psz = sz; |
66 | } |
67 | uncomp_data = g_malloc(sz); |
68 | memmove(uncomp_data, data, sz); |
69 | return uncomp_data; |
70 | } |
71 | |
72 | if (!strcmp(comp, "gzip" )) { |
73 | uncomp_len = UBOOT_MAX_GUNZIP_BYTES; |
74 | uncomp_data = g_malloc(uncomp_len); |
75 | |
76 | uncomp_len = gunzip(uncomp_data, uncomp_len, (void *) data, sz); |
77 | if (uncomp_len < 0) { |
78 | error_setg(errp, "unable to decompress %s image" , name); |
79 | g_free(uncomp_data); |
80 | return NULL; |
81 | } |
82 | |
83 | data = g_realloc(uncomp_data, uncomp_len); |
84 | if (psz) { |
85 | *psz = uncomp_len; |
86 | } |
87 | return data; |
88 | } |
89 | |
90 | error_setg(errp, "unknown compression '%s'" , comp); |
91 | return NULL; |
92 | } |
93 | |
94 | static int fit_image_addr(const void *itb, int img, const char *name, |
95 | hwaddr *addr, Error **errp) |
96 | { |
97 | const void *prop; |
98 | int len; |
99 | |
100 | prop = fdt_getprop(itb, img, name, &len); |
101 | if (!prop) { |
102 | error_setg(errp, "can't find %s address" , name); |
103 | return -ENOENT; |
104 | } |
105 | |
106 | switch (len) { |
107 | case 4: |
108 | *addr = fdt32_to_cpu(*(fdt32_t *)prop); |
109 | return 0; |
110 | case 8: |
111 | *addr = fdt64_to_cpu(*(fdt64_t *)prop); |
112 | return 0; |
113 | default: |
114 | error_setg(errp, "invalid %s address length %d" , name, len); |
115 | return -EINVAL; |
116 | } |
117 | } |
118 | |
119 | static int fit_load_kernel(const struct fit_loader *ldr, const void *itb, |
120 | int cfg, void *opaque, hwaddr *pend, |
121 | Error **errp) |
122 | { |
123 | const char *name; |
124 | const void *data; |
125 | const void *load_data; |
126 | hwaddr load_addr, entry_addr; |
127 | int img_off, err; |
128 | size_t sz; |
129 | int ret; |
130 | |
131 | name = fdt_getprop(itb, cfg, "kernel" , NULL); |
132 | if (!name) { |
133 | error_setg(errp, "no kernel specified by FIT configuration" ); |
134 | return -EINVAL; |
135 | } |
136 | |
137 | load_data = data = fit_load_image_alloc(itb, name, &img_off, &sz, errp); |
138 | if (!data) { |
139 | error_prepend(errp, "unable to load kernel image from FIT: " ); |
140 | return -EINVAL; |
141 | } |
142 | |
143 | err = fit_image_addr(itb, img_off, "load" , &load_addr, errp); |
144 | if (err) { |
145 | error_prepend(errp, "unable to read kernel load address from FIT: " ); |
146 | ret = err; |
147 | goto out; |
148 | } |
149 | |
150 | err = fit_image_addr(itb, img_off, "entry" , &entry_addr, errp); |
151 | if (err) { |
152 | error_prepend(errp, "unable to read kernel entry address from FIT: " ); |
153 | ret = err; |
154 | goto out; |
155 | } |
156 | |
157 | if (ldr->kernel_filter) { |
158 | load_data = ldr->kernel_filter(opaque, data, &load_addr, &entry_addr); |
159 | } |
160 | |
161 | if (pend) { |
162 | *pend = load_addr + sz; |
163 | } |
164 | |
165 | load_addr = ldr->addr_to_phys(opaque, load_addr); |
166 | rom_add_blob_fixed(name, load_data, sz, load_addr); |
167 | |
168 | ret = 0; |
169 | out: |
170 | g_free((void *) data); |
171 | if (data != load_data) { |
172 | g_free((void *) load_data); |
173 | } |
174 | return ret; |
175 | } |
176 | |
177 | static int fit_load_fdt(const struct fit_loader *ldr, const void *itb, |
178 | int cfg, void *opaque, const void *match_data, |
179 | hwaddr kernel_end, Error **errp) |
180 | { |
181 | const char *name; |
182 | const void *data; |
183 | const void *load_data; |
184 | hwaddr load_addr; |
185 | int img_off, err; |
186 | size_t sz; |
187 | int ret; |
188 | |
189 | name = fdt_getprop(itb, cfg, "fdt" , NULL); |
190 | if (!name) { |
191 | return 0; |
192 | } |
193 | |
194 | load_data = data = fit_load_image_alloc(itb, name, &img_off, &sz, errp); |
195 | if (!data) { |
196 | error_prepend(errp, "unable to load FDT image from FIT: " ); |
197 | return -EINVAL; |
198 | } |
199 | |
200 | err = fit_image_addr(itb, img_off, "load" , &load_addr, errp); |
201 | if (err == -ENOENT) { |
202 | load_addr = ROUND_UP(kernel_end, 64 * KiB) + (10 * MiB); |
203 | error_free(*errp); |
204 | } else if (err) { |
205 | error_prepend(errp, "unable to read FDT load address from FIT: " ); |
206 | ret = err; |
207 | goto out; |
208 | } |
209 | |
210 | if (ldr->fdt_filter) { |
211 | load_data = ldr->fdt_filter(opaque, data, match_data, &load_addr); |
212 | } |
213 | |
214 | load_addr = ldr->addr_to_phys(opaque, load_addr); |
215 | sz = fdt_totalsize(load_data); |
216 | rom_add_blob_fixed(name, load_data, sz, load_addr); |
217 | |
218 | ret = 0; |
219 | out: |
220 | g_free((void *) data); |
221 | if (data != load_data) { |
222 | g_free((void *) load_data); |
223 | } |
224 | return ret; |
225 | } |
226 | |
227 | static bool fit_cfg_compatible(const void *itb, int cfg, const char *compat) |
228 | { |
229 | const void *fdt; |
230 | const char *fdt_name; |
231 | bool ret; |
232 | |
233 | fdt_name = fdt_getprop(itb, cfg, "fdt" , NULL); |
234 | if (!fdt_name) { |
235 | return false; |
236 | } |
237 | |
238 | fdt = fit_load_image_alloc(itb, fdt_name, NULL, NULL, NULL); |
239 | if (!fdt) { |
240 | return false; |
241 | } |
242 | |
243 | if (fdt_check_header(fdt)) { |
244 | ret = false; |
245 | goto out; |
246 | } |
247 | |
248 | if (fdt_node_check_compatible(fdt, 0, compat)) { |
249 | ret = false; |
250 | goto out; |
251 | } |
252 | |
253 | ret = true; |
254 | out: |
255 | g_free((void *) fdt); |
256 | return ret; |
257 | } |
258 | |
259 | int load_fit(const struct fit_loader *ldr, const char *filename, void *opaque) |
260 | { |
261 | Error *err = NULL; |
262 | const struct fit_loader_match *match; |
263 | const void *itb, *match_data = NULL; |
264 | const char *def_cfg_name; |
265 | char path[FIT_LOADER_MAX_PATH]; |
266 | int itb_size, configs, cfg_off, off; |
267 | hwaddr kernel_end; |
268 | int ret; |
269 | |
270 | itb = load_device_tree(filename, &itb_size); |
271 | if (!itb) { |
272 | return -EINVAL; |
273 | } |
274 | |
275 | configs = fdt_path_offset(itb, "/configurations" ); |
276 | if (configs < 0) { |
277 | error_report("can't find node /configurations" ); |
278 | ret = configs; |
279 | goto out; |
280 | } |
281 | |
282 | cfg_off = -FDT_ERR_NOTFOUND; |
283 | |
284 | if (ldr->matches) { |
285 | for (match = ldr->matches; match->compatible; match++) { |
286 | off = fdt_first_subnode(itb, configs); |
287 | while (off >= 0) { |
288 | if (fit_cfg_compatible(itb, off, match->compatible)) { |
289 | cfg_off = off; |
290 | match_data = match->data; |
291 | break; |
292 | } |
293 | |
294 | off = fdt_next_subnode(itb, off); |
295 | } |
296 | |
297 | if (cfg_off >= 0) { |
298 | break; |
299 | } |
300 | } |
301 | } |
302 | |
303 | if (cfg_off < 0) { |
304 | def_cfg_name = fdt_getprop(itb, configs, "default" , NULL); |
305 | if (def_cfg_name) { |
306 | snprintf(path, sizeof(path), "/configurations/%s" , def_cfg_name); |
307 | cfg_off = fdt_path_offset(itb, path); |
308 | } |
309 | } |
310 | |
311 | if (cfg_off < 0) { |
312 | error_report("can't find configuration" ); |
313 | ret = cfg_off; |
314 | goto out; |
315 | } |
316 | |
317 | ret = fit_load_kernel(ldr, itb, cfg_off, opaque, &kernel_end, &err); |
318 | if (ret) { |
319 | error_report_err(err); |
320 | goto out; |
321 | } |
322 | |
323 | ret = fit_load_fdt(ldr, itb, cfg_off, opaque, match_data, kernel_end, |
324 | &err); |
325 | if (ret) { |
326 | error_report_err(err); |
327 | goto out; |
328 | } |
329 | |
330 | ret = 0; |
331 | out: |
332 | g_free((void *) itb); |
333 | return ret; |
334 | } |
335 | |