Revision 409dbce5
| b/Makefile.target | ||
|---|---|---|
| 237 | 237 |
obj-ppc-$(CONFIG_FDT) += device_tree.o |
| 238 | 238 |
|
| 239 | 239 |
obj-mips-y = mips_r4k.o mips_jazz.o mips_malta.o mips_mipssim.o |
| 240 |
obj-mips-y += mips_timer.o mips_int.o dma.o vga.o serial.o i8254.o i8259.o rc4030.o |
|
| 240 |
obj-mips-y += mips_addr.o mips_timer.o mips_int.o |
|
| 241 |
obj-mips-y += dma.o vga.o serial.o i8254.o i8259.o rc4030.o |
|
| 241 | 242 |
obj-mips-y += vga-pci.o vga-isa.o vga-isa-mm.o |
| 242 | 243 |
obj-mips-y += g364fb.o jazz_led.o dp8393x.o |
| 243 | 244 |
obj-mips-y += ide/core.o ide/qdev.o ide/isa.o ide/pci.o ide/piix.o |
| b/hw/an5206.c | ||
|---|---|---|
| 68 | 68 |
exit(1); |
| 69 | 69 |
} |
| 70 | 70 |
|
| 71 |
kernel_size = load_elf(kernel_filename, 0, &elf_entry, NULL, NULL,
|
|
| 72 |
1, ELF_MACHINE, 0); |
|
| 71 |
kernel_size = load_elf(kernel_filename, NULL, NULL, &elf_entry,
|
|
| 72 |
NULL, NULL, 1, ELF_MACHINE, 0);
|
|
| 73 | 73 |
entry = elf_entry; |
| 74 | 74 |
if (kernel_size < 0) {
|
| 75 | 75 |
kernel_size = load_uimage(kernel_filename, &entry, NULL, NULL); |
| b/hw/arm_boot.c | ||
|---|---|---|
| 225 | 225 |
#endif |
| 226 | 226 |
|
| 227 | 227 |
/* Assume that raw images are linux kernels, and ELF images are not. */ |
| 228 |
kernel_size = load_elf(info->kernel_filename, 0, &elf_entry, NULL, NULL,
|
|
| 229 |
big_endian, ELF_MACHINE, 1); |
|
| 228 |
kernel_size = load_elf(info->kernel_filename, NULL, NULL, &elf_entry,
|
|
| 229 |
NULL, NULL, big_endian, ELF_MACHINE, 1);
|
|
| 230 | 230 |
entry = elf_entry; |
| 231 | 231 |
if (kernel_size < 0) {
|
| 232 | 232 |
kernel_size = load_uimage(info->kernel_filename, &entry, NULL, |
| b/hw/armv7m.c | ||
|---|---|---|
| 215 | 215 |
big_endian = 0; |
| 216 | 216 |
#endif |
| 217 | 217 |
|
| 218 |
image_size = load_elf(kernel_filename, 0, &entry, &lowaddr, NULL,
|
|
| 219 |
big_endian, ELF_MACHINE, 1); |
|
| 218 |
image_size = load_elf(kernel_filename, NULL, NULL, &entry, &lowaddr,
|
|
| 219 |
NULL, big_endian, ELF_MACHINE, 1);
|
|
| 220 | 220 |
if (image_size < 0) {
|
| 221 | 221 |
image_size = load_image_targphys(kernel_filename, 0, flash_size); |
| 222 | 222 |
lowaddr = 0; |
| b/hw/axis_dev88.c | ||
|---|---|---|
| 249 | 249 |
env->pc = bootstrap_pc; |
| 250 | 250 |
} |
| 251 | 251 |
|
| 252 |
static uint64_t translate_kernel_address(void *opaque, uint64_t addr) |
|
| 253 |
{
|
|
| 254 |
return addr - 0x80000000LL; |
|
| 255 |
} |
|
| 256 |
|
|
| 252 | 257 |
static |
| 253 | 258 |
void axisdev88_init (ram_addr_t ram_size, |
| 254 | 259 |
const char *boot_device, |
| ... | ... | |
| 345 | 350 |
|
| 346 | 351 |
/* Boots a kernel elf binary, os/linux-2.6/vmlinux from the axis |
| 347 | 352 |
devboard SDK. */ |
| 348 |
kernel_size = load_elf(kernel_filename, -0x80000000LL,
|
|
| 353 |
kernel_size = load_elf(kernel_filename, translate_kernel_address, NULL,
|
|
| 349 | 354 |
&entry, NULL, &high, 0, ELF_MACHINE, 0); |
| 350 | 355 |
bootstrap_pc = entry; |
| 351 | 356 |
if (kernel_size < 0) {
|
| b/hw/dummy_m68k.c | ||
|---|---|---|
| 43 | 43 |
|
| 44 | 44 |
/* Load kernel. */ |
| 45 | 45 |
if (kernel_filename) {
|
| 46 |
kernel_size = load_elf(kernel_filename, 0, &elf_entry, NULL, NULL,
|
|
| 47 |
1, ELF_MACHINE, 0); |
|
| 46 |
kernel_size = load_elf(kernel_filename, NULL, NULL, &elf_entry,
|
|
| 47 |
NULL, NULL, 1, ELF_MACHINE, 0);
|
|
| 48 | 48 |
entry = elf_entry; |
| 49 | 49 |
if (kernel_size < 0) {
|
| 50 | 50 |
kernel_size = load_uimage(kernel_filename, &entry, NULL, NULL); |
| b/hw/elf_ops.h | ||
|---|---|---|
| 184 | 184 |
return -1; |
| 185 | 185 |
} |
| 186 | 186 |
|
| 187 |
static int glue(load_elf, SZ)(const char *name, int fd, int64_t address_offset, |
|
| 187 |
static int glue(load_elf, SZ)(const char *name, int fd, |
|
| 188 |
uint64_t (*translate_fn)(void *, uint64_t), |
|
| 189 |
void *translate_opaque, |
|
| 188 | 190 |
int must_swab, uint64_t *pentry, |
| 189 | 191 |
uint64_t *lowaddr, uint64_t *highaddr, |
| 190 | 192 |
int elf_machine, int clear_lsb) |
| ... | ... | |
| 253 | 255 |
} |
| 254 | 256 |
/* address_offset is hack for kernel images that are |
| 255 | 257 |
linked at the wrong physical address. */ |
| 256 |
addr = ph->p_paddr + address_offset; |
|
| 258 |
if (translate_fn) {
|
|
| 259 |
addr = translate_fn(translate_opaque, ph->p_paddr); |
|
| 260 |
} else {
|
|
| 261 |
addr = ph->p_paddr; |
|
| 262 |
} |
|
| 257 | 263 |
|
| 258 | 264 |
snprintf(label, sizeof(label), "phdr #%d: %s", i, name); |
| 259 | 265 |
rom_add_blob_fixed(label, data, mem_size, addr); |
| b/hw/etraxfs.c | ||
|---|---|---|
| 44 | 44 |
env->pc = bootstrap_pc; |
| 45 | 45 |
} |
| 46 | 46 |
|
| 47 |
static uint64_t translate_kernel_address(void *opaque, uint64_t addr) |
|
| 48 |
{
|
|
| 49 |
return addr - 0x80000000LL; |
|
| 50 |
} |
|
| 51 |
|
|
| 47 | 52 |
static |
| 48 | 53 |
void bareetraxfs_init (ram_addr_t ram_size, |
| 49 | 54 |
const char *boot_device, |
| ... | ... | |
| 137 | 142 |
|
| 138 | 143 |
/* Boots a kernel elf binary, os/linux-2.6/vmlinux from the axis |
| 139 | 144 |
devboard SDK. */ |
| 140 |
kernel_size = load_elf(kernel_filename, -0x80000000LL,
|
|
| 145 |
kernel_size = load_elf(kernel_filename, translate_kernel_address, NULL,
|
|
| 141 | 146 |
&entry, NULL, &high, 0, ELF_MACHINE, 0); |
| 142 | 147 |
bootstrap_pc = entry; |
| 143 | 148 |
if (kernel_size < 0) {
|
| b/hw/loader.c | ||
|---|---|---|
| 276 | 276 |
#include "elf_ops.h" |
| 277 | 277 |
|
| 278 | 278 |
/* return < 0 if error, otherwise the number of bytes loaded in memory */ |
| 279 |
int load_elf(const char *filename, int64_t address_offset,
|
|
| 280 |
uint64_t *pentry, uint64_t *lowaddr, uint64_t *highaddr,
|
|
| 281 |
int big_endian, int elf_machine, int clear_lsb) |
|
| 279 |
int load_elf(const char *filename, uint64_t (*translate_fn)(void *, uint64_t),
|
|
| 280 |
void *translate_opaque, uint64_t *pentry, uint64_t *lowaddr,
|
|
| 281 |
uint64_t *highaddr, int big_endian, int elf_machine, int clear_lsb)
|
|
| 282 | 282 |
{
|
| 283 | 283 |
int fd, data_order, target_data_order, must_swab, ret; |
| 284 | 284 |
uint8_t e_ident[EI_NIDENT]; |
| ... | ... | |
| 312 | 312 |
|
| 313 | 313 |
lseek(fd, 0, SEEK_SET); |
| 314 | 314 |
if (e_ident[EI_CLASS] == ELFCLASS64) {
|
| 315 |
ret = load_elf64(filename, fd, address_offset, must_swab, pentry,
|
|
| 316 |
lowaddr, highaddr, elf_machine, clear_lsb); |
|
| 315 |
ret = load_elf64(filename, fd, translate_fn, translate_opaque, must_swab,
|
|
| 316 |
pentry, lowaddr, highaddr, elf_machine, clear_lsb);
|
|
| 317 | 317 |
} else {
|
| 318 |
ret = load_elf32(filename, fd, address_offset, must_swab, pentry,
|
|
| 319 |
lowaddr, highaddr, elf_machine, clear_lsb); |
|
| 318 |
ret = load_elf32(filename, fd, translate_fn, translate_opaque, must_swab,
|
|
| 319 |
pentry, lowaddr, highaddr, elf_machine, clear_lsb);
|
|
| 320 | 320 |
} |
| 321 | 321 |
|
| 322 | 322 |
close(fd); |
| b/hw/loader.h | ||
|---|---|---|
| 5 | 5 |
int get_image_size(const char *filename); |
| 6 | 6 |
int load_image(const char *filename, uint8_t *addr); /* deprecated */ |
| 7 | 7 |
int load_image_targphys(const char *filename, target_phys_addr_t, int max_sz); |
| 8 |
int load_elf(const char *filename, int64_t address_offset, |
|
| 9 |
uint64_t *pentry, uint64_t *lowaddr, uint64_t *highaddr, |
|
| 10 |
int big_endian, int elf_machine, int clear_lsb); |
|
| 8 |
int load_elf(const char *filename, uint64_t (*translate_fn)(void *, uint64_t), |
|
| 9 |
void *translate_opaque, uint64_t *pentry, uint64_t *lowaddr, |
|
| 10 |
uint64_t *highaddr, int big_endian, int elf_machine, |
|
| 11 |
int clear_lsb); |
|
| 11 | 12 |
int load_aout(const char *filename, target_phys_addr_t addr, int max_sz, |
| 12 | 13 |
int bswap_needed, target_phys_addr_t target_page_size); |
| 13 | 14 |
int load_uimage(const char *filename, target_phys_addr_t *ep, |
| b/hw/mcf5208.c | ||
|---|---|---|
| 270 | 270 |
exit(1); |
| 271 | 271 |
} |
| 272 | 272 |
|
| 273 |
kernel_size = load_elf(kernel_filename, 0, &elf_entry, NULL, NULL,
|
|
| 274 |
1, ELF_MACHINE, 0); |
|
| 273 |
kernel_size = load_elf(kernel_filename, NULL, NULL, &elf_entry,
|
|
| 274 |
NULL, NULL, 1, ELF_MACHINE, 0);
|
|
| 275 | 275 |
entry = elf_entry; |
| 276 | 276 |
if (kernel_size < 0) {
|
| 277 | 277 |
kernel_size = load_uimage(kernel_filename, &entry, NULL, NULL); |
| b/hw/mips.h | ||
|---|---|---|
| 20 | 20 |
/* jazz_led.c */ |
| 21 | 21 |
extern void jazz_led_init(target_phys_addr_t base); |
| 22 | 22 |
|
| 23 |
/* mips_addr.c */ |
|
| 24 |
uint64_t cpu_mips_kseg0_to_phys(void *opaque, uint64_t addr); |
|
| 25 |
uint64_t cpu_mips_phys_to_kseg0(void *opaque, uint64_t addr); |
|
| 26 |
|
|
| 23 | 27 |
/* mips_int.c */ |
| 24 | 28 |
extern void cpu_mips_irq_init_cpu(CPUState *env); |
| 25 | 29 |
|
| b/hw/mips_addr.c | ||
|---|---|---|
| 1 |
/* |
|
| 2 |
* QEMU MIPS address translation support |
|
| 3 |
* |
|
| 4 |
* Permission is hereby granted, free of charge, to any person obtaining a copy |
|
| 5 |
* of this software and associated documentation files (the "Software"), to deal |
|
| 6 |
* in the Software without restriction, including without limitation the rights |
|
| 7 |
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
|
| 8 |
* copies of the Software, and to permit persons to whom the Software is |
|
| 9 |
* furnished to do so, subject to the following conditions: |
|
| 10 |
* |
|
| 11 |
* The above copyright notice and this permission notice shall be included in |
|
| 12 |
* all copies or substantial portions of the Software. |
|
| 13 |
* |
|
| 14 |
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
|
| 15 |
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
|
| 16 |
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
|
| 17 |
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
|
| 18 |
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
|
| 19 |
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
|
| 20 |
* THE SOFTWARE. |
|
| 21 |
*/ |
|
| 22 |
|
|
| 23 |
#include "hw.h" |
|
| 24 |
#include "mips.h" |
|
| 25 |
|
|
| 26 |
uint64_t cpu_mips_kseg0_to_phys(void *opaque, uint64_t addr) |
|
| 27 |
{
|
|
| 28 |
return addr & 0x7fffffffll; |
|
| 29 |
} |
|
| 30 |
|
|
| 31 |
uint64_t cpu_mips_phys_to_kseg0(void *opaque, uint64_t addr) |
|
| 32 |
{
|
|
| 33 |
return addr | ~0x7fffffffll; |
|
| 34 |
} |
|
| b/hw/mips_malta.c | ||
|---|---|---|
| 46 | 46 |
|
| 47 | 47 |
//#define DEBUG_BOARD_INIT |
| 48 | 48 |
|
| 49 |
#ifdef TARGET_MIPS64 |
|
| 50 |
#define PHYS_TO_VIRT(x) ((x) | ~0x7fffffffULL) |
|
| 51 |
#else |
|
| 52 |
#define PHYS_TO_VIRT(x) ((x) | ~0x7fffffffU) |
|
| 53 |
#endif |
|
| 54 |
|
|
| 55 |
#define ENVP_ADDR (int32_t)0x80002000 |
|
| 56 |
#define VIRT_TO_PHYS_ADDEND (-((int64_t)(int32_t)0x80000000)) |
|
| 57 |
|
|
| 49 |
#define ENVP_ADDR 0x80002000l |
|
| 58 | 50 |
#define ENVP_NB_ENTRIES 16 |
| 59 | 51 |
#define ENVP_ENTRY_SIZE 256 |
| 60 | 52 |
|
| ... | ... | |
| 681 | 673 |
/* Kernel */ |
| 682 | 674 |
static int64_t load_kernel (void) |
| 683 | 675 |
{
|
| 684 |
int64_t kernel_entry, kernel_low, kernel_high;
|
|
| 676 |
int64_t kernel_entry, kernel_high; |
|
| 685 | 677 |
long initrd_size; |
| 686 | 678 |
ram_addr_t initrd_offset; |
| 687 | 679 |
int big_endian; |
| ... | ... | |
| 695 | 687 |
big_endian = 0; |
| 696 | 688 |
#endif |
| 697 | 689 |
|
| 698 |
if (load_elf(loaderparams.kernel_filename, VIRT_TO_PHYS_ADDEND,
|
|
| 699 |
(uint64_t *)&kernel_entry, (uint64_t *)&kernel_low,
|
|
| 700 |
(uint64_t *)&kernel_high, big_endian, ELF_MACHINE, 1) < 0) {
|
|
| 690 |
if (load_elf(loaderparams.kernel_filename, cpu_mips_kseg0_to_phys, NULL,
|
|
| 691 |
(uint64_t *)&kernel_entry, NULL, (uint64_t *)&kernel_high,
|
|
| 692 |
big_endian, ELF_MACHINE, 1) < 0) {
|
|
| 701 | 693 |
fprintf(stderr, "qemu: could not load kernel '%s'\n", |
| 702 | 694 |
loaderparams.kernel_filename); |
| 703 | 695 |
exit(1); |
| ... | ... | |
| 733 | 725 |
|
| 734 | 726 |
prom_set(prom_buf, prom_index++, loaderparams.kernel_filename); |
| 735 | 727 |
if (initrd_size > 0) {
|
| 736 |
prom_set(prom_buf, prom_index++, "rd_start=0x" TARGET_FMT_lx " rd_size=%li %s",
|
|
| 737 |
PHYS_TO_VIRT(initrd_offset), initrd_size,
|
|
| 728 |
prom_set(prom_buf, prom_index++, "rd_start=0x%" PRIx64 " rd_size=%li %s",
|
|
| 729 |
cpu_mips_phys_to_kseg0(NULL, initrd_offset), initrd_size,
|
|
| 738 | 730 |
loaderparams.kernel_cmdline); |
| 739 | 731 |
} else {
|
| 740 | 732 |
prom_set(prom_buf, prom_index++, loaderparams.kernel_cmdline); |
| ... | ... | |
| 747 | 739 |
prom_set(prom_buf, prom_index++, NULL); |
| 748 | 740 |
|
| 749 | 741 |
rom_add_blob_fixed("prom", prom_buf, prom_size,
|
| 750 |
ENVP_ADDR + VIRT_TO_PHYS_ADDEND);
|
|
| 742 |
cpu_mips_kseg0_to_phys(NULL, ENVP_ADDR));
|
|
| 751 | 743 |
|
| 752 | 744 |
return kernel_entry; |
| 753 | 745 |
} |
| b/hw/mips_mipssim.c | ||
|---|---|---|
| 35 | 35 |
#include "loader.h" |
| 36 | 36 |
#include "elf.h" |
| 37 | 37 |
|
| 38 |
#ifdef TARGET_MIPS64 |
|
| 39 |
#define PHYS_TO_VIRT(x) ((x) | ~0x7fffffffULL) |
|
| 40 |
#else |
|
| 41 |
#define PHYS_TO_VIRT(x) ((x) | ~0x7fffffffU) |
|
| 42 |
#endif |
|
| 43 |
|
|
| 44 |
#define VIRT_TO_PHYS_ADDEND (-((int64_t)(int32_t)0x80000000)) |
|
| 45 |
|
|
| 46 | 38 |
static struct _loaderparams {
|
| 47 | 39 |
int ram_size; |
| 48 | 40 |
const char *kernel_filename; |
| ... | ... | |
| 57 | 49 |
|
| 58 | 50 |
static int64_t load_kernel(void) |
| 59 | 51 |
{
|
| 60 |
int64_t entry, kernel_low, kernel_high;
|
|
| 52 |
int64_t entry, kernel_high; |
|
| 61 | 53 |
long kernel_size; |
| 62 | 54 |
long initrd_size; |
| 63 | 55 |
ram_addr_t initrd_offset; |
| ... | ... | |
| 69 | 61 |
big_endian = 0; |
| 70 | 62 |
#endif |
| 71 | 63 |
|
| 72 |
kernel_size = load_elf(loaderparams.kernel_filename, VIRT_TO_PHYS_ADDEND, |
|
| 73 |
(uint64_t *)&entry, (uint64_t *)&kernel_low, |
|
| 74 |
(uint64_t *)&kernel_high, big_endian, ELF_MACHINE, 1); |
|
| 64 |
kernel_size = load_elf(loaderparams.kernel_filename, cpu_mips_kseg0_to_phys, |
|
| 65 |
NULL, (uint64_t *)&entry, NULL, |
|
| 66 |
(uint64_t *)&kernel_high, big_endian, |
|
| 67 |
ELF_MACHINE, 1); |
|
| 75 | 68 |
if (kernel_size >= 0) {
|
| 76 | 69 |
if ((entry & ~0x7fffffffULL) == 0x80000000) |
| 77 | 70 |
entry = (int32_t)entry; |
| b/hw/mips_r4k.c | ||
|---|---|---|
| 21 | 21 |
#include "loader.h" |
| 22 | 22 |
#include "elf.h" |
| 23 | 23 |
|
| 24 |
#define PHYS_TO_VIRT(x) ((x) | ~(target_ulong)0x7fffffff) |
|
| 25 |
|
|
| 26 |
#define VIRT_TO_PHYS_ADDEND (-((int64_t)(int32_t)0x80000000)) |
|
| 27 |
|
|
| 28 | 24 |
#define MAX_IDE_BUS 2 |
| 29 | 25 |
|
| 30 | 26 |
static const int ide_iobase[2] = { 0x1f0, 0x170 };
|
| ... | ... | |
| 77 | 73 |
|
| 78 | 74 |
static int64_t load_kernel(void) |
| 79 | 75 |
{
|
| 80 |
int64_t entry, kernel_low, kernel_high;
|
|
| 76 |
int64_t entry, kernel_high; |
|
| 81 | 77 |
long kernel_size, initrd_size, params_size; |
| 82 | 78 |
ram_addr_t initrd_offset; |
| 83 | 79 |
uint32_t *params_buf; |
| ... | ... | |
| 88 | 84 |
#else |
| 89 | 85 |
big_endian = 0; |
| 90 | 86 |
#endif |
| 91 |
kernel_size = load_elf(loaderparams.kernel_filename, VIRT_TO_PHYS_ADDEND, |
|
| 92 |
(uint64_t *)&entry, (uint64_t *)&kernel_low, |
|
| 93 |
(uint64_t *)&kernel_high, big_endian, ELF_MACHINE, 1); |
|
| 87 |
kernel_size = load_elf(loaderparams.kernel_filename, cpu_mips_kseg0_to_phys, |
|
| 88 |
NULL, (uint64_t *)&entry, NULL, |
|
| 89 |
(uint64_t *)&kernel_high, big_endian, |
|
| 90 |
ELF_MACHINE, 1); |
|
| 94 | 91 |
if (kernel_size >= 0) {
|
| 95 | 92 |
if ((entry & ~0x7fffffffULL) == 0x80000000) |
| 96 | 93 |
entry = (int32_t)entry; |
| ... | ... | |
| 132 | 129 |
params_buf[1] = tswap32(0x12345678); |
| 133 | 130 |
|
| 134 | 131 |
if (initrd_size > 0) {
|
| 135 |
snprintf((char *)params_buf + 8, 256, "rd_start=0x" TARGET_FMT_lx " rd_size=%li %s",
|
|
| 136 |
PHYS_TO_VIRT((uint32_t)initrd_offset),
|
|
| 132 |
snprintf((char *)params_buf + 8, 256, "rd_start=0x%" PRIx64 " rd_size=%li %s",
|
|
| 133 |
cpu_mips_phys_to_kseg0(NULL, initrd_offset),
|
|
| 137 | 134 |
initrd_size, loaderparams.kernel_cmdline); |
| 138 | 135 |
} else {
|
| 139 | 136 |
snprintf((char *)params_buf + 8, 256, "%s", loaderparams.kernel_cmdline); |
| b/hw/multiboot.c | ||
|---|---|---|
| 170 | 170 |
uint64_t elf_low, elf_high; |
| 171 | 171 |
int kernel_size; |
| 172 | 172 |
fclose(f); |
| 173 |
kernel_size = load_elf(kernel_filename, 0, &elf_entry, &elf_low, &elf_high,
|
|
| 174 |
0, ELF_MACHINE, 0); |
|
| 173 |
kernel_size = load_elf(kernel_filename, NULL, NULL, &elf_entry,
|
|
| 174 |
&elf_low, &elf_high, 0, ELF_MACHINE, 0);
|
|
| 175 | 175 |
if (kernel_size < 0) {
|
| 176 | 176 |
fprintf(stderr, "Error while loading elf kernel\n"); |
| 177 | 177 |
exit(1); |
| b/hw/petalogix_s3adsp1800_mmu.c | ||
|---|---|---|
| 104 | 104 |
return fdt_size; |
| 105 | 105 |
} |
| 106 | 106 |
|
| 107 |
static uint64_t translate_kernel_address(void *opaque, uint64_t addr) |
|
| 108 |
{
|
|
| 109 |
return addr - 0x30000000LL; |
|
| 110 |
} |
|
| 111 |
|
|
| 107 | 112 |
static void |
| 108 | 113 |
petalogix_s3adsp1800_init(ram_addr_t ram_size, |
| 109 | 114 |
const char *boot_device, |
| ... | ... | |
| 163 | 168 |
uint32_t base32; |
| 164 | 169 |
|
| 165 | 170 |
/* Boots a kernel elf binary. */ |
| 166 |
kernel_size = load_elf(kernel_filename, 0,
|
|
| 171 |
kernel_size = load_elf(kernel_filename, NULL, NULL,
|
|
| 167 | 172 |
&entry, &low, &high, |
| 168 | 173 |
1, ELF_MACHINE, 0); |
| 169 | 174 |
base32 = entry; |
| 170 | 175 |
if (base32 == 0xc0000000) {
|
| 171 |
kernel_size = load_elf(kernel_filename, -0x30000000LL,
|
|
| 172 |
&entry, NULL, NULL, |
|
| 176 |
kernel_size = load_elf(kernel_filename, translate_kernel_address,
|
|
| 177 |
NULL, &entry, NULL, NULL,
|
|
| 173 | 178 |
1, ELF_MACHINE, 0); |
| 174 | 179 |
} |
| 175 | 180 |
/* Always boot into physical ram. */ |
| b/hw/ppc440_bamboo.c | ||
|---|---|---|
| 120 | 120 |
if (kernel_filename) {
|
| 121 | 121 |
kernel_size = load_uimage(kernel_filename, &entry, &loadaddr, NULL); |
| 122 | 122 |
if (kernel_size < 0) {
|
| 123 |
kernel_size = load_elf(kernel_filename, 0, &elf_entry, &elf_lowaddr,
|
|
| 124 |
NULL, 1, ELF_MACHINE, 0); |
|
| 123 |
kernel_size = load_elf(kernel_filename, NULL, NULL, &elf_entry,
|
|
| 124 |
&elf_lowaddr, NULL, 1, ELF_MACHINE, 0);
|
|
| 125 | 125 |
entry = elf_entry; |
| 126 | 126 |
loadaddr = elf_lowaddr; |
| 127 | 127 |
} |
| b/hw/ppc_newworld.c | ||
|---|---|---|
| 115 | 115 |
return 0; |
| 116 | 116 |
} |
| 117 | 117 |
|
| 118 |
static uint64_t translate_kernel_address(void *opaque, uint64_t addr) |
|
| 119 |
{
|
|
| 120 |
return (addr & 0x0fffffff) + KERNEL_LOAD_ADDR; |
|
| 121 |
} |
|
| 122 |
|
|
| 118 | 123 |
/* PowerPC Mac99 hardware initialisation */ |
| 119 | 124 |
static void ppc_core99_init (ram_addr_t ram_size, |
| 120 | 125 |
const char *boot_device, |
| ... | ... | |
| 180 | 185 |
|
| 181 | 186 |
/* Load OpenBIOS (ELF) */ |
| 182 | 187 |
if (filename) {
|
| 183 |
bios_size = load_elf(filename, 0, NULL, NULL, NULL, 1, ELF_MACHINE, 0); |
|
| 188 |
bios_size = load_elf(filename, NULL, NULL, NULL, |
|
| 189 |
NULL, NULL, 1, ELF_MACHINE, 0); |
|
| 184 | 190 |
|
| 185 | 191 |
qemu_free(filename); |
| 186 | 192 |
} else {
|
| ... | ... | |
| 232 | 238 |
#endif |
| 233 | 239 |
kernel_base = KERNEL_LOAD_ADDR; |
| 234 | 240 |
|
| 235 |
/* Now we can load the kernel. The first step tries to load the kernel |
|
| 236 |
supposing PhysAddr = 0x00000000. If that was wrong the kernel is |
|
| 237 |
loaded again, the new PhysAddr being computed from lowaddr. */ |
|
| 238 |
kernel_size = load_elf(kernel_filename, kernel_base, NULL, &lowaddr, NULL, |
|
| 239 |
1, ELF_MACHINE, 0); |
|
| 240 |
if (kernel_size > 0 && lowaddr != KERNEL_LOAD_ADDR) {
|
|
| 241 |
kernel_size = load_elf(kernel_filename, (2 * kernel_base) - lowaddr, |
|
| 242 |
NULL, NULL, NULL, 1, ELF_MACHINE, 0); |
|
| 243 |
} |
|
| 241 |
kernel_size = load_elf(kernel_filename, translate_kernel_address, NULL, |
|
| 242 |
NULL, &lowaddr, NULL, 1, ELF_MACHINE, 0); |
|
| 244 | 243 |
if (kernel_size < 0) |
| 245 | 244 |
kernel_size = load_aout(kernel_filename, kernel_base, |
| 246 | 245 |
ram_size - kernel_base, bswap_needed, |
| b/hw/ppc_oldworld.c | ||
|---|---|---|
| 122 | 122 |
return 0; |
| 123 | 123 |
} |
| 124 | 124 |
|
| 125 |
|
|
| 126 |
static uint64_t translate_kernel_address(void *opaque, uint64_t addr) |
|
| 127 |
{
|
|
| 128 |
return (addr & 0x0fffffff) + KERNEL_LOAD_ADDR; |
|
| 129 |
} |
|
| 130 |
|
|
| 125 | 131 |
static void ppc_heathrow_init (ram_addr_t ram_size, |
| 126 | 132 |
const char *boot_device, |
| 127 | 133 |
const char *kernel_filename, |
| ... | ... | |
| 185 | 191 |
|
| 186 | 192 |
/* Load OpenBIOS (ELF) */ |
| 187 | 193 |
if (filename) {
|
| 188 |
bios_size = load_elf(filename, 0, NULL, NULL, NULL, |
|
| 189 |
1, ELF_MACHINE, 0);
|
|
| 194 |
bios_size = load_elf(filename, 0, NULL, NULL, NULL, NULL,
|
|
| 195 |
1, ELF_MACHINE, 0); |
|
| 190 | 196 |
qemu_free(filename); |
| 191 | 197 |
} else {
|
| 192 | 198 |
bios_size = -1; |
| ... | ... | |
| 236 | 242 |
bswap_needed = 0; |
| 237 | 243 |
#endif |
| 238 | 244 |
kernel_base = KERNEL_LOAD_ADDR; |
| 239 |
/* Now we can load the kernel. The first step tries to load the kernel |
|
| 240 |
supposing PhysAddr = 0x00000000. If that was wrong the kernel is |
|
| 241 |
loaded again, the new PhysAddr being computed from lowaddr. */ |
|
| 242 |
kernel_size = load_elf(kernel_filename, kernel_base, NULL, &lowaddr, NULL, |
|
| 243 |
1, ELF_MACHINE, 0); |
|
| 244 |
if (kernel_size > 0 && lowaddr != KERNEL_LOAD_ADDR) {
|
|
| 245 |
kernel_size = load_elf(kernel_filename, (2 * kernel_base) - lowaddr, |
|
| 246 |
NULL, NULL, NULL, 1, ELF_MACHINE, 0); |
|
| 247 |
} |
|
| 245 |
kernel_size = load_elf(kernel_filename, translate_kernel_address, NULL, |
|
| 246 |
NULL, &lowaddr, NULL, 1, ELF_MACHINE, 0); |
|
| 248 | 247 |
if (kernel_size < 0) |
| 249 | 248 |
kernel_size = load_aout(kernel_filename, kernel_base, |
| 250 | 249 |
ram_size - kernel_base, bswap_needed, |
| b/hw/ppce500_mpc8544ds.c | ||
|---|---|---|
| 231 | 231 |
if (kernel_filename) {
|
| 232 | 232 |
kernel_size = load_uimage(kernel_filename, &entry, &loadaddr, NULL); |
| 233 | 233 |
if (kernel_size < 0) {
|
| 234 |
kernel_size = load_elf(kernel_filename, 0, &elf_entry, &elf_lowaddr,
|
|
| 235 |
NULL, 1, ELF_MACHINE, 0); |
|
| 234 |
kernel_size = load_elf(kernel_filename, NULL, NULL, &elf_entry,
|
|
| 235 |
&elf_lowaddr, NULL, 1, ELF_MACHINE, 0);
|
|
| 236 | 236 |
entry = elf_entry; |
| 237 | 237 |
loadaddr = elf_lowaddr; |
| 238 | 238 |
} |
| b/hw/sun4m.c | ||
|---|---|---|
| 292 | 292 |
cpu_interrupt(cpu_single_env, CPU_INTERRUPT_HALT); |
| 293 | 293 |
} |
| 294 | 294 |
|
| 295 |
static uint64_t translate_kernel_address(void *opaque, uint64_t addr) |
|
| 296 |
{
|
|
| 297 |
return addr - 0xf0000000ULL; |
|
| 298 |
} |
|
| 299 |
|
|
| 295 | 300 |
static unsigned long sun4m_load_kernel(const char *kernel_filename, |
| 296 | 301 |
const char *initrd_filename, |
| 297 | 302 |
ram_addr_t RAM_size) |
| ... | ... | |
| 312 | 317 |
#else |
| 313 | 318 |
bswap_needed = 0; |
| 314 | 319 |
#endif |
| 315 |
kernel_size = load_elf(kernel_filename, -0xf0000000ULL, NULL, NULL,
|
|
| 316 |
NULL, 1, ELF_MACHINE, 0); |
|
| 320 |
kernel_size = load_elf(kernel_filename, translate_kernel_address, NULL,
|
|
| 321 |
NULL, NULL, NULL, 1, ELF_MACHINE, 0);
|
|
| 317 | 322 |
if (kernel_size < 0) |
| 318 | 323 |
kernel_size = load_aout(kernel_filename, KERNEL_LOAD_ADDR, |
| 319 | 324 |
RAM_size - KERNEL_LOAD_ADDR, bswap_needed, |
| ... | ... | |
| 636 | 641 |
device_init(afx_register_devices); |
| 637 | 642 |
|
| 638 | 643 |
/* Boot PROM (OpenBIOS) */ |
| 644 |
static uint64_t translate_prom_address(void *opaque, uint64_t addr) |
|
| 645 |
{
|
|
| 646 |
target_phys_addr_t *base_addr = (target_phys_addr_t *)opaque; |
|
| 647 |
return addr + *base_addr - PROM_VADDR; |
|
| 648 |
} |
|
| 649 |
|
|
| 639 | 650 |
static void prom_init(target_phys_addr_t addr, const char *bios_name) |
| 640 | 651 |
{
|
| 641 | 652 |
DeviceState *dev; |
| ... | ... | |
| 655 | 666 |
} |
| 656 | 667 |
filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, bios_name); |
| 657 | 668 |
if (filename) {
|
| 658 |
ret = load_elf(filename, addr - PROM_VADDR, NULL, NULL, NULL,
|
|
| 659 |
1, ELF_MACHINE, 0); |
|
| 669 |
ret = load_elf(filename, translate_prom_address, &addr, NULL,
|
|
| 670 |
NULL, NULL, 1, ELF_MACHINE, 0);
|
|
| 660 | 671 |
if (ret < 0 || ret > PROM_SIZE_MAX) {
|
| 661 | 672 |
ret = load_image_targphys(filename, addr, PROM_SIZE_MAX); |
| 662 | 673 |
} |
| b/hw/sun4u.c | ||
|---|---|---|
| 189 | 189 |
#else |
| 190 | 190 |
bswap_needed = 0; |
| 191 | 191 |
#endif |
| 192 |
kernel_size = load_elf(kernel_filename, 0, NULL, NULL, NULL,
|
|
| 193 |
1, ELF_MACHINE, 0); |
|
| 192 |
kernel_size = load_elf(kernel_filename, NULL, NULL, NULL, |
|
| 193 |
NULL, NULL, 1, ELF_MACHINE, 0);
|
|
| 194 | 194 |
if (kernel_size < 0) |
| 195 | 195 |
kernel_size = load_aout(kernel_filename, KERNEL_LOAD_ADDR, |
| 196 | 196 |
RAM_size - KERNEL_LOAD_ADDR, bswap_needed, |
| ... | ... | |
| 580 | 580 |
|
| 581 | 581 |
device_init(pci_ebus_register); |
| 582 | 582 |
|
| 583 |
static uint64_t translate_prom_address(void *opaque, uint64_t addr) |
|
| 584 |
{
|
|
| 585 |
target_phys_addr_t *base_addr = (target_phys_addr_t *)opaque; |
|
| 586 |
return addr + *base_addr - PROM_VADDR; |
|
| 587 |
} |
|
| 588 |
|
|
| 583 | 589 |
/* Boot PROM (OpenBIOS) */ |
| 584 | 590 |
static void prom_init(target_phys_addr_t addr, const char *bios_name) |
| 585 | 591 |
{
|
| ... | ... | |
| 600 | 606 |
} |
| 601 | 607 |
filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, bios_name); |
| 602 | 608 |
if (filename) {
|
| 603 |
ret = load_elf(filename, addr - PROM_VADDR, NULL, NULL, NULL,
|
|
| 604 |
1, ELF_MACHINE, 0); |
|
| 609 |
ret = load_elf(filename, translate_prom_address, &addr,
|
|
| 610 |
NULL, NULL, NULL, 1, ELF_MACHINE, 0);
|
|
| 605 | 611 |
if (ret < 0 || ret > PROM_SIZE_MAX) {
|
| 606 | 612 |
ret = load_image_targphys(filename, addr, PROM_SIZE_MAX); |
| 607 | 613 |
} |
Also available in: Unified diff