hw/core/loader-fit.c

   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;
 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 }