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