xref: /openbmc/qemu/hw/core/loader-fit.c (revision bef6a77f) 
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.1 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     ERRP_GUARD();
124     const char *name;
125     const void *data;
126     const void *load_data;
127     hwaddr load_addr, entry_addr;
128     int img_off, err;
129     size_t sz;
130     int ret;
131 
132     name = fdt_getprop(itb, cfg, "kernel", NULL);
133     if (!name) {
134         error_setg(errp, "no kernel specified by FIT configuration");
135         return -EINVAL;
136     }
137 
138     load_data = data = fit_load_image_alloc(itb, name, &img_off, &sz, errp);
139     if (!data) {
140         error_prepend(errp, "unable to load kernel image from FIT: ");
141         return -EINVAL;
142     }
143 
144     err = fit_image_addr(itb, img_off, "load", &load_addr, errp);
145     if (err) {
146         error_prepend(errp, "unable to read kernel load address from FIT: ");
147         ret = err;
148         goto out;
149     }
150 
151     err = fit_image_addr(itb, img_off, "entry", &entry_addr, errp);
152     if (err) {
153         error_prepend(errp, "unable to read kernel entry address from FIT: ");
154         ret = err;
155         goto out;
156     }
157 
158     if (ldr->kernel_filter) {
159         load_data = ldr->kernel_filter(opaque, data, &load_addr, &entry_addr);
160     }
161 
162     if (pend) {
163         *pend = load_addr + sz;
164     }
165 
166     load_addr = ldr->addr_to_phys(opaque, load_addr);
167     rom_add_blob_fixed(name, load_data, sz, load_addr);
168 
169     ret = 0;
170 out:
171     g_free((void *) data);
172     if (data != load_data) {
173         g_free((void *) load_data);
174     }
175     return ret;
176 }
177 
178 static int fit_load_fdt(const struct fit_loader *ldr, const void *itb,
179                         int cfg, void *opaque, const void *match_data,
180                         hwaddr kernel_end, Error **errp)
181 {
182     ERRP_GUARD();
183     Error *err = NULL;
184     const char *name;
185     const void *data;
186     const void *load_data;
187     hwaddr load_addr;
188     int img_off;
189     size_t sz;
190     int ret;
191 
192     name = fdt_getprop(itb, cfg, "fdt", NULL);
193     if (!name) {
194         return 0;
195     }
196 
197     load_data = data = fit_load_image_alloc(itb, name, &img_off, &sz, errp);
198     if (!data) {
199         error_prepend(errp, "unable to load FDT image from FIT: ");
200         return -EINVAL;
201     }
202 
203     ret = fit_image_addr(itb, img_off, "load", &load_addr, &err);
204     if (ret == -ENOENT) {
205         load_addr = ROUND_UP(kernel_end, 64 * KiB) + (10 * MiB);
206         error_free(err);
207     } else if (ret) {
208         error_propagate_prepend(errp, err,
209                                 "unable to read FDT load address from FIT: ");
210         goto out;
211     }
212 
213     if (ldr->fdt_filter) {
214         load_data = ldr->fdt_filter(opaque, data, match_data, &load_addr);
215     }
216 
217     load_addr = ldr->addr_to_phys(opaque, load_addr);
218     sz = fdt_totalsize(load_data);
219     rom_add_blob_fixed(name, load_data, sz, load_addr);
220 
221     ret = 0;
222 out:
223     g_free((void *) data);
224     if (data != load_data) {
225         g_free((void *) load_data);
226     }
227     return ret;
228 }
229 
230 static bool fit_cfg_compatible(const void *itb, int cfg, const char *compat)
231 {
232     const void *fdt;
233     const char *fdt_name;
234     bool ret;
235 
236     fdt_name = fdt_getprop(itb, cfg, "fdt", NULL);
237     if (!fdt_name) {
238         return false;
239     }
240 
241     fdt = fit_load_image_alloc(itb, fdt_name, NULL, NULL, NULL);
242     if (!fdt) {
243         return false;
244     }
245 
246     if (fdt_check_header(fdt)) {
247         ret = false;
248         goto out;
249     }
250 
251     if (fdt_node_check_compatible(fdt, 0, compat)) {
252         ret = false;
253         goto out;
254     }
255 
256     ret = true;
257 out:
258     g_free((void *) fdt);
259     return ret;
260 }
261 
262 int load_fit(const struct fit_loader *ldr, const char *filename, void *opaque)
263 {
264     Error *err = NULL;
265     const struct fit_loader_match *match;
266     const void *itb, *match_data = NULL;
267     const char *def_cfg_name;
268     char path[FIT_LOADER_MAX_PATH];
269     int itb_size, configs, cfg_off, off;
270     hwaddr kernel_end = 0;
271     int ret;
272 
273     itb = load_device_tree(filename, &itb_size);
274     if (!itb) {
275         return -EINVAL;
276     }
277 
278     configs = fdt_path_offset(itb, "/configurations");
279     if (configs < 0) {
280         error_report("can't find node /configurations");
281         ret = configs;
282         goto out;
283     }
284 
285     cfg_off = -FDT_ERR_NOTFOUND;
286 
287     if (ldr->matches) {
288         for (match = ldr->matches; match->compatible; match++) {
289             off = fdt_first_subnode(itb, configs);
290             while (off >= 0) {
291                 if (fit_cfg_compatible(itb, off, match->compatible)) {
292                     cfg_off = off;
293                     match_data = match->data;
294                     break;
295                 }
296 
297                 off = fdt_next_subnode(itb, off);
298             }
299 
300             if (cfg_off >= 0) {
301                 break;
302             }
303         }
304     }
305 
306     if (cfg_off < 0) {
307         def_cfg_name = fdt_getprop(itb, configs, "default", NULL);
308         if (def_cfg_name) {
309             snprintf(path, sizeof(path), "/configurations/%s", def_cfg_name);
310             cfg_off = fdt_path_offset(itb, path);
311         }
312     }
313 
314     if (cfg_off < 0) {
315         error_report("can't find configuration");
316         ret = cfg_off;
317         goto out;
318     }
319 
320     ret = fit_load_kernel(ldr, itb, cfg_off, opaque, &kernel_end, &err);
321     if (ret) {
322         error_report_err(err);
323         goto out;
324     }
325 
326     ret = fit_load_fdt(ldr, itb, cfg_off, opaque, match_data, kernel_end,
327                        &err);
328     if (ret) {
329         error_report_err(err);
330         goto out;
331     }
332 
333     ret = 0;
334 out:
335     g_free((void *) itb);
336     return ret;
337 }
338