The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 1 | /* |
| 2 | * QEMU Executable loader |
| 3 | * |
| 4 | * Copyright (c) 2006 Fabrice Bellard |
| 5 | * |
| 6 | * Permission is hereby granted, free of charge, to any person obtaining a copy |
| 7 | * of this software and associated documentation files (the "Software"), to deal |
| 8 | * in the Software without restriction, including without limitation the rights |
| 9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
| 10 | * copies of the Software, and to permit persons to whom the Software is |
| 11 | * furnished to do so, subject to the following conditions: |
| 12 | * |
| 13 | * The above copyright notice and this permission notice shall be included in |
| 14 | * all copies or substantial portions of the Software. |
| 15 | * |
| 16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| 17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| 18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
| 19 | * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| 20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
| 21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
| 22 | * THE SOFTWARE. |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 23 | * |
| 24 | * Gunzip functionality in this file is derived from u-boot: |
| 25 | * |
| 26 | * (C) Copyright 2008 Semihalf |
| 27 | * |
| 28 | * (C) Copyright 2000-2005 |
| 29 | * Wolfgang Denk, DENX Software Engineering, wd@denx.de. |
| 30 | * |
| 31 | * This program is free software; you can redistribute it and/or |
| 32 | * modify it under the terms of the GNU General Public License as |
| 33 | * published by the Free Software Foundation; either version 2 of |
| 34 | * the License, or (at your option) any later version. |
| 35 | * |
| 36 | * This program is distributed in the hope that it will be useful, |
| 37 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 38 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 39 | * GNU General Public License for more details. |
| 40 | * |
| 41 | * You should have received a copy of the GNU General Public License along |
| 42 | * with this program; if not, write to the Free Software Foundation, Inc., |
| 43 | * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 44 | */ |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 45 | |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 46 | #include "qemu-common.h" |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 47 | #include "disas.h" |
| 48 | #include "sysemu.h" |
| 49 | #include "uboot_image.h" |
| 50 | |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 51 | #include <zlib.h> |
| 52 | |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 53 | /* return the size or -1 if error */ |
| 54 | int get_image_size(const char *filename) |
| 55 | { |
| 56 | int fd, size; |
| 57 | fd = open(filename, O_RDONLY | O_BINARY); |
| 58 | if (fd < 0) |
| 59 | return -1; |
| 60 | size = lseek(fd, 0, SEEK_END); |
| 61 | close(fd); |
| 62 | return size; |
| 63 | } |
| 64 | |
| 65 | /* return the size or -1 if error */ |
| 66 | /* deprecated, because caller does not specify buffer size! */ |
| 67 | int load_image(const char *filename, uint8_t *addr) |
| 68 | { |
| 69 | int fd, size; |
| 70 | fd = open(filename, O_RDONLY | O_BINARY); |
| 71 | if (fd < 0) |
| 72 | return -1; |
| 73 | size = lseek(fd, 0, SEEK_END); |
| 74 | lseek(fd, 0, SEEK_SET); |
| 75 | if (read(fd, addr, size) != size) { |
| 76 | close(fd); |
| 77 | return -1; |
| 78 | } |
| 79 | close(fd); |
| 80 | return size; |
| 81 | } |
| 82 | |
| 83 | /* return the amount read, just like fread. 0 may mean error or eof */ |
| 84 | int fread_targphys(target_phys_addr_t dst_addr, size_t nbytes, FILE *f) |
| 85 | { |
| 86 | uint8_t buf[4096]; |
| 87 | target_phys_addr_t dst_begin = dst_addr; |
| 88 | size_t want, did; |
| 89 | |
| 90 | while (nbytes) { |
| 91 | want = nbytes > sizeof(buf) ? sizeof(buf) : nbytes; |
| 92 | did = fread(buf, 1, want, f); |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 93 | |
| 94 | cpu_physical_memory_write_rom(dst_addr, buf, did); |
| 95 | dst_addr += did; |
| 96 | nbytes -= did; |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 97 | if (did != want) |
| 98 | break; |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 99 | } |
| 100 | return dst_addr - dst_begin; |
| 101 | } |
| 102 | |
| 103 | /* returns 0 on error, 1 if ok */ |
| 104 | int fread_targphys_ok(target_phys_addr_t dst_addr, size_t nbytes, FILE *f) |
| 105 | { |
| 106 | return fread_targphys(dst_addr, nbytes, f) == nbytes; |
| 107 | } |
| 108 | |
| 109 | /* read()-like version */ |
| 110 | int read_targphys(int fd, target_phys_addr_t dst_addr, size_t nbytes) |
| 111 | { |
| 112 | uint8_t buf[4096]; |
| 113 | target_phys_addr_t dst_begin = dst_addr; |
| 114 | size_t want, did; |
| 115 | |
| 116 | while (nbytes) { |
| 117 | want = nbytes > sizeof(buf) ? sizeof(buf) : nbytes; |
| 118 | did = read(fd, buf, want); |
| 119 | if (did != want) break; |
| 120 | |
| 121 | cpu_physical_memory_write_rom(dst_addr, buf, did); |
| 122 | dst_addr += did; |
| 123 | nbytes -= did; |
| 124 | } |
| 125 | return dst_addr - dst_begin; |
| 126 | } |
| 127 | |
| 128 | /* return the size or -1 if error */ |
| 129 | int load_image_targphys(const char *filename, |
| 130 | target_phys_addr_t addr, int max_sz) |
| 131 | { |
| 132 | FILE *f; |
| 133 | size_t got; |
| 134 | |
| 135 | f = fopen(filename, "rb"); |
| 136 | if (!f) return -1; |
| 137 | |
| 138 | got = fread_targphys(addr, max_sz, f); |
| 139 | if (ferror(f)) { fclose(f); return -1; } |
| 140 | fclose(f); |
| 141 | |
| 142 | return got; |
| 143 | } |
| 144 | |
| 145 | void pstrcpy_targphys(target_phys_addr_t dest, int buf_size, |
| 146 | const char *source) |
| 147 | { |
| 148 | static const uint8_t nul_byte = 0; |
| 149 | const char *nulp; |
| 150 | |
| 151 | if (buf_size <= 0) return; |
| 152 | nulp = memchr(source, 0, buf_size); |
| 153 | if (nulp) { |
| 154 | cpu_physical_memory_write_rom(dest, (uint8_t *)source, |
| 155 | (nulp - source) + 1); |
| 156 | } else { |
| 157 | cpu_physical_memory_write_rom(dest, (uint8_t *)source, buf_size - 1); |
| 158 | cpu_physical_memory_write_rom(dest, &nul_byte, 1); |
| 159 | } |
| 160 | } |
| 161 | |
| 162 | /* A.OUT loader */ |
| 163 | |
| 164 | struct exec |
| 165 | { |
| 166 | uint32_t a_info; /* Use macros N_MAGIC, etc for access */ |
| 167 | uint32_t a_text; /* length of text, in bytes */ |
| 168 | uint32_t a_data; /* length of data, in bytes */ |
| 169 | uint32_t a_bss; /* length of uninitialized data area, in bytes */ |
| 170 | uint32_t a_syms; /* length of symbol table data in file, in bytes */ |
| 171 | uint32_t a_entry; /* start address */ |
| 172 | uint32_t a_trsize; /* length of relocation info for text, in bytes */ |
| 173 | uint32_t a_drsize; /* length of relocation info for data, in bytes */ |
| 174 | }; |
| 175 | |
| 176 | #ifdef BSWAP_NEEDED |
| 177 | static void bswap_ahdr(struct exec *e) |
| 178 | { |
| 179 | bswap32s(&e->a_info); |
| 180 | bswap32s(&e->a_text); |
| 181 | bswap32s(&e->a_data); |
| 182 | bswap32s(&e->a_bss); |
| 183 | bswap32s(&e->a_syms); |
| 184 | bswap32s(&e->a_entry); |
| 185 | bswap32s(&e->a_trsize); |
| 186 | bswap32s(&e->a_drsize); |
| 187 | } |
| 188 | #else |
| 189 | #define bswap_ahdr(x) do { } while (0) |
| 190 | #endif |
| 191 | |
| 192 | #define N_MAGIC(exec) ((exec).a_info & 0xffff) |
| 193 | #define OMAGIC 0407 |
| 194 | #define NMAGIC 0410 |
| 195 | #define ZMAGIC 0413 |
| 196 | #define QMAGIC 0314 |
| 197 | #define _N_HDROFF(x) (1024 - sizeof (struct exec)) |
| 198 | #define N_TXTOFF(x) \ |
| 199 | (N_MAGIC(x) == ZMAGIC ? _N_HDROFF((x)) + sizeof (struct exec) : \ |
| 200 | (N_MAGIC(x) == QMAGIC ? 0 : sizeof (struct exec))) |
| 201 | #define N_TXTADDR(x) (N_MAGIC(x) == QMAGIC ? TARGET_PAGE_SIZE : 0) |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 202 | #define _N_SEGMENT_ROUND(x) (((x) + TARGET_PAGE_SIZE - 1) & ~(TARGET_PAGE_SIZE - 1)) |
| 203 | |
| 204 | #define _N_TXTENDADDR(x) (N_TXTADDR(x)+(x).a_text) |
| 205 | |
| 206 | #define N_DATADDR(x) \ |
| 207 | (N_MAGIC(x)==OMAGIC? (_N_TXTENDADDR(x)) \ |
| 208 | : (_N_SEGMENT_ROUND (_N_TXTENDADDR(x)))) |
| 209 | |
| 210 | |
| 211 | int load_aout(const char *filename, target_phys_addr_t addr, int max_sz) |
| 212 | { |
| 213 | int fd, size, ret; |
| 214 | struct exec e; |
| 215 | uint32_t magic; |
| 216 | |
| 217 | fd = open(filename, O_RDONLY | O_BINARY); |
| 218 | if (fd < 0) |
| 219 | return -1; |
| 220 | |
| 221 | size = read(fd, &e, sizeof(e)); |
| 222 | if (size < 0) |
| 223 | goto fail; |
| 224 | |
| 225 | bswap_ahdr(&e); |
| 226 | |
| 227 | magic = N_MAGIC(e); |
| 228 | switch (magic) { |
| 229 | case ZMAGIC: |
| 230 | case QMAGIC: |
| 231 | case OMAGIC: |
| 232 | if (e.a_text + e.a_data > max_sz) |
| 233 | goto fail; |
| 234 | lseek(fd, N_TXTOFF(e), SEEK_SET); |
| 235 | size = read_targphys(fd, addr, e.a_text + e.a_data); |
| 236 | if (size < 0) |
| 237 | goto fail; |
| 238 | break; |
| 239 | case NMAGIC: |
| 240 | if (N_DATADDR(e) + e.a_data > max_sz) |
| 241 | goto fail; |
| 242 | lseek(fd, N_TXTOFF(e), SEEK_SET); |
| 243 | size = read_targphys(fd, addr, e.a_text); |
| 244 | if (size < 0) |
| 245 | goto fail; |
| 246 | ret = read_targphys(fd, addr + N_DATADDR(e), e.a_data); |
| 247 | if (ret < 0) |
| 248 | goto fail; |
| 249 | size += ret; |
| 250 | break; |
| 251 | default: |
| 252 | goto fail; |
| 253 | } |
| 254 | close(fd); |
| 255 | return size; |
| 256 | fail: |
| 257 | close(fd); |
| 258 | return -1; |
| 259 | } |
| 260 | |
| 261 | /* ELF loader */ |
| 262 | |
| 263 | static void *load_at(int fd, int offset, int size) |
| 264 | { |
| 265 | void *ptr; |
| 266 | if (lseek(fd, offset, SEEK_SET) < 0) |
| 267 | return NULL; |
| 268 | ptr = qemu_malloc(size); |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 269 | if (read(fd, ptr, size) != size) { |
| 270 | qemu_free(ptr); |
| 271 | return NULL; |
| 272 | } |
| 273 | return ptr; |
| 274 | } |
| 275 | |
| 276 | |
| 277 | #define ELF_CLASS ELFCLASS32 |
| 278 | #include "elf.h" |
| 279 | |
| 280 | #define SZ 32 |
| 281 | #define elf_word uint32_t |
| 282 | #define elf_sword int32_t |
| 283 | #define bswapSZs bswap32s |
| 284 | #include "elf_ops.h" |
| 285 | |
| 286 | #undef elfhdr |
| 287 | #undef elf_phdr |
| 288 | #undef elf_shdr |
| 289 | #undef elf_sym |
| 290 | #undef elf_note |
| 291 | #undef elf_word |
| 292 | #undef elf_sword |
| 293 | #undef bswapSZs |
| 294 | #undef SZ |
| 295 | #define elfhdr elf64_hdr |
| 296 | #define elf_phdr elf64_phdr |
| 297 | #define elf_note elf64_note |
| 298 | #define elf_shdr elf64_shdr |
| 299 | #define elf_sym elf64_sym |
| 300 | #define elf_word uint64_t |
| 301 | #define elf_sword int64_t |
| 302 | #define bswapSZs bswap64s |
| 303 | #define SZ 64 |
| 304 | #include "elf_ops.h" |
| 305 | |
| 306 | /* return < 0 if error, otherwise the number of bytes loaded in memory */ |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 307 | int load_elf(const char *filename, int64_t address_offset, |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 308 | uint64_t *pentry, uint64_t *lowaddr, uint64_t *highaddr) |
| 309 | { |
| 310 | int fd, data_order, host_data_order, must_swab, ret; |
| 311 | uint8_t e_ident[EI_NIDENT]; |
| 312 | |
| 313 | fd = open(filename, O_RDONLY | O_BINARY); |
| 314 | if (fd < 0) { |
| 315 | perror(filename); |
| 316 | return -1; |
| 317 | } |
| 318 | if (read(fd, e_ident, sizeof(e_ident)) != sizeof(e_ident)) |
| 319 | goto fail; |
| 320 | if (e_ident[0] != ELFMAG0 || |
| 321 | e_ident[1] != ELFMAG1 || |
| 322 | e_ident[2] != ELFMAG2 || |
| 323 | e_ident[3] != ELFMAG3) |
| 324 | goto fail; |
David 'Digit' Turner | 20894ae | 2010-05-10 17:07:36 -0700 | [diff] [blame] | 325 | #ifdef HOST_WORDS_BIGENDIAN |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 326 | data_order = ELFDATA2MSB; |
| 327 | #else |
| 328 | data_order = ELFDATA2LSB; |
| 329 | #endif |
| 330 | must_swab = data_order != e_ident[EI_DATA]; |
| 331 | |
| 332 | #ifdef TARGET_WORDS_BIGENDIAN |
| 333 | host_data_order = ELFDATA2MSB; |
| 334 | #else |
| 335 | host_data_order = ELFDATA2LSB; |
| 336 | #endif |
| 337 | if (host_data_order != e_ident[EI_DATA]) |
| 338 | return -1; |
| 339 | |
| 340 | lseek(fd, 0, SEEK_SET); |
| 341 | if (e_ident[EI_CLASS] == ELFCLASS64) { |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 342 | ret = load_elf64(fd, address_offset, must_swab, pentry, |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 343 | lowaddr, highaddr); |
| 344 | } else { |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 345 | ret = load_elf32(fd, address_offset, must_swab, pentry, |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 346 | lowaddr, highaddr); |
| 347 | } |
| 348 | |
| 349 | close(fd); |
| 350 | return ret; |
| 351 | |
| 352 | fail: |
| 353 | close(fd); |
| 354 | return -1; |
| 355 | } |
| 356 | |
| 357 | static void bswap_uboot_header(uboot_image_header_t *hdr) |
| 358 | { |
David 'Digit' Turner | 20894ae | 2010-05-10 17:07:36 -0700 | [diff] [blame] | 359 | #ifndef HOST_WORDS_BIGENDIAN |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 360 | bswap32s(&hdr->ih_magic); |
| 361 | bswap32s(&hdr->ih_hcrc); |
| 362 | bswap32s(&hdr->ih_time); |
| 363 | bswap32s(&hdr->ih_size); |
| 364 | bswap32s(&hdr->ih_load); |
| 365 | bswap32s(&hdr->ih_ep); |
| 366 | bswap32s(&hdr->ih_dcrc); |
| 367 | #endif |
| 368 | } |
| 369 | |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 370 | |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 371 | #define ZALLOC_ALIGNMENT 16 |
| 372 | |
| 373 | static void *zalloc(void *x, unsigned items, unsigned size) |
| 374 | { |
| 375 | void *p; |
| 376 | |
| 377 | size *= items; |
| 378 | size = (size + ZALLOC_ALIGNMENT - 1) & ~(ZALLOC_ALIGNMENT - 1); |
| 379 | |
| 380 | p = qemu_malloc(size); |
| 381 | |
| 382 | return (p); |
| 383 | } |
| 384 | |
| 385 | static void zfree(void *x, void *addr) |
| 386 | { |
| 387 | qemu_free(addr); |
| 388 | } |
| 389 | |
| 390 | |
| 391 | #define HEAD_CRC 2 |
| 392 | #define EXTRA_FIELD 4 |
| 393 | #define ORIG_NAME 8 |
| 394 | #define COMMENT 0x10 |
| 395 | #define RESERVED 0xe0 |
| 396 | |
| 397 | #define DEFLATED 8 |
| 398 | |
| 399 | /* This is the maximum in uboot, so if a uImage overflows this, it would |
| 400 | * overflow on real hardware too. */ |
| 401 | #define UBOOT_MAX_GUNZIP_BYTES 0x800000 |
| 402 | |
| 403 | static ssize_t gunzip(void *dst, size_t dstlen, uint8_t *src, |
| 404 | size_t srclen) |
| 405 | { |
| 406 | z_stream s; |
| 407 | ssize_t dstbytes; |
| 408 | int r, i, flags; |
| 409 | |
| 410 | /* skip header */ |
| 411 | i = 10; |
| 412 | flags = src[3]; |
| 413 | if (src[2] != DEFLATED || (flags & RESERVED) != 0) { |
| 414 | puts ("Error: Bad gzipped data\n"); |
| 415 | return -1; |
| 416 | } |
| 417 | if ((flags & EXTRA_FIELD) != 0) |
| 418 | i = 12 + src[10] + (src[11] << 8); |
| 419 | if ((flags & ORIG_NAME) != 0) |
| 420 | while (src[i++] != 0) |
| 421 | ; |
| 422 | if ((flags & COMMENT) != 0) |
| 423 | while (src[i++] != 0) |
| 424 | ; |
| 425 | if ((flags & HEAD_CRC) != 0) |
| 426 | i += 2; |
| 427 | if (i >= srclen) { |
| 428 | puts ("Error: gunzip out of data in header\n"); |
| 429 | return -1; |
| 430 | } |
| 431 | |
| 432 | s.zalloc = zalloc; |
| 433 | s.zfree = zfree; |
| 434 | |
| 435 | r = inflateInit2(&s, -MAX_WBITS); |
| 436 | if (r != Z_OK) { |
| 437 | printf ("Error: inflateInit2() returned %d\n", r); |
| 438 | return (-1); |
| 439 | } |
| 440 | s.next_in = src + i; |
| 441 | s.avail_in = srclen - i; |
| 442 | s.next_out = dst; |
| 443 | s.avail_out = dstlen; |
| 444 | r = inflate(&s, Z_FINISH); |
| 445 | if (r != Z_OK && r != Z_STREAM_END) { |
| 446 | printf ("Error: inflate() returned %d\n", r); |
| 447 | return -1; |
| 448 | } |
| 449 | dstbytes = s.next_out - (unsigned char *) dst; |
| 450 | inflateEnd(&s); |
| 451 | |
| 452 | return dstbytes; |
| 453 | } |
| 454 | |
| 455 | /* Load a U-Boot image. */ |
| 456 | int load_uimage(const char *filename, target_ulong *ep, target_ulong *loadaddr, |
| 457 | int *is_linux) |
| 458 | { |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 459 | int fd; |
| 460 | int size; |
| 461 | uboot_image_header_t h; |
| 462 | uboot_image_header_t *hdr = &h; |
| 463 | uint8_t *data = NULL; |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 464 | int ret = -1; |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 465 | |
| 466 | fd = open(filename, O_RDONLY | O_BINARY); |
| 467 | if (fd < 0) |
| 468 | return -1; |
| 469 | |
| 470 | size = read(fd, hdr, sizeof(uboot_image_header_t)); |
| 471 | if (size < 0) |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 472 | goto out; |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 473 | |
| 474 | bswap_uboot_header(hdr); |
| 475 | |
| 476 | if (hdr->ih_magic != IH_MAGIC) |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 477 | goto out; |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 478 | |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 479 | /* TODO: Implement other image types. */ |
| 480 | if (hdr->ih_type != IH_TYPE_KERNEL) { |
| 481 | fprintf(stderr, "Can only load u-boot image type \"kernel\"\n"); |
| 482 | goto out; |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 483 | } |
| 484 | |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 485 | switch (hdr->ih_comp) { |
| 486 | case IH_COMP_NONE: |
| 487 | case IH_COMP_GZIP: |
| 488 | break; |
| 489 | default: |
| 490 | fprintf(stderr, |
| 491 | "Unable to load u-boot images with compression type %d\n", |
| 492 | hdr->ih_comp); |
| 493 | goto out; |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 494 | } |
| 495 | |
| 496 | /* TODO: Check CPU type. */ |
| 497 | if (is_linux) { |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 498 | if (hdr->ih_os == IH_OS_LINUX) |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 499 | *is_linux = 1; |
| 500 | else |
| 501 | *is_linux = 0; |
| 502 | } |
| 503 | |
| 504 | *ep = hdr->ih_ep; |
| 505 | data = qemu_malloc(hdr->ih_size); |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 506 | |
| 507 | if (read(fd, data, hdr->ih_size) != hdr->ih_size) { |
| 508 | fprintf(stderr, "Error reading file\n"); |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 509 | goto out; |
| 510 | } |
| 511 | |
| 512 | if (hdr->ih_comp == IH_COMP_GZIP) { |
| 513 | uint8_t *compressed_data; |
| 514 | size_t max_bytes; |
| 515 | ssize_t bytes; |
| 516 | |
| 517 | compressed_data = data; |
| 518 | max_bytes = UBOOT_MAX_GUNZIP_BYTES; |
| 519 | data = qemu_malloc(max_bytes); |
| 520 | |
| 521 | bytes = gunzip(data, max_bytes, compressed_data, hdr->ih_size); |
| 522 | qemu_free(compressed_data); |
| 523 | if (bytes < 0) { |
| 524 | fprintf(stderr, "Unable to decompress gzipped image!\n"); |
| 525 | goto out; |
| 526 | } |
| 527 | hdr->ih_size = bytes; |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 528 | } |
| 529 | |
| 530 | cpu_physical_memory_write_rom(hdr->ih_load, data, hdr->ih_size); |
| 531 | |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 532 | if (loadaddr) |
| 533 | *loadaddr = hdr->ih_load; |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 534 | |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 535 | ret = hdr->ih_size; |
| 536 | |
| 537 | out: |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 538 | if (data) |
| 539 | qemu_free(data); |
| 540 | close(fd); |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 541 | return ret; |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 542 | } |