#include "xilinx.h"
#include "loader.h"
#include "elf.h"
+#include "blockdev.h"
#define LMB_BRAM_SIZE (128 * 1024)
#define FLASH_SIZE (16 * 1024 * 1024)
-static uint32_t bootstrap_pc;
+static struct
+{
+ uint32_t bootstrap_pc;
+ uint32_t cmdline;
+ uint32_t fdt;
+} boot_info;
static void main_cpu_reset(void *opaque)
{
CPUState *env = opaque;
+
cpu_reset(env);
- env->sregs[SR_PC] = bootstrap_pc;
+ env->regs[5] = boot_info.cmdline;
+ env->regs[7] = boot_info.fdt;
+ env->sregs[SR_PC] = boot_info.bootstrap_pc;
}
#define BINARY_DEVICE_TREE_FILE "petalogix-s3adsp1800.dtb"
-static int petalogix_load_device_tree(a_target_phys_addr addr,
+static int petalogix_load_device_tree(target_phys_addr_t addr,
uint32_t ramsize,
- a_target_phys_addr initrd_base,
- a_target_phys_addr initrd_size,
+ target_phys_addr_t initrd_base,
+ target_phys_addr_t initrd_size,
const char *kernel_cmdline)
{
char *path;
path = qemu_find_file(QEMU_FILE_TYPE_BIOS, BINARY_DEVICE_TREE_FILE);
if (path) {
fdt = load_device_tree(path, &fdt_size);
- qemu_free(path);
+ g_free(path);
}
if (!fdt)
return 0;
path = qemu_find_file(QEMU_FILE_TYPE_BIOS, BINARY_DEVICE_TREE_FILE);
if (path) {
fdt_size = load_image_targphys(path, addr, 0x10000);
- qemu_free(path);
+ g_free(path);
}
}
return fdt_size;
}
+static uint64_t translate_kernel_address(void *opaque, uint64_t addr)
+{
+ return addr - 0x30000000LL;
+}
+
static void
-petalogix_s3adsp1800_init(a_ram_addr ram_size,
+petalogix_s3adsp1800_init(ram_addr_t ram_size,
const char *boot_device,
const char *kernel_filename,
const char *kernel_cmdline,
int kernel_size;
DriveInfo *dinfo;
int i;
- a_target_phys_addr ddr_base = 0x90000000;
- a_ram_addr phys_lmb_bram;
- a_ram_addr phys_ram;
- a_ram_addr phys_flash;
+ target_phys_addr_t ddr_base = 0x90000000;
+ ram_addr_t phys_lmb_bram;
+ ram_addr_t phys_ram;
+ ram_addr_t phys_flash;
qemu_irq irq[32], *cpu_irq;
/* init CPUs */
qemu_register_reset(main_cpu_reset, env);
/* Attach emulated BRAM through the LMB. */
- phys_lmb_bram = qemu_ram_alloc(LMB_BRAM_SIZE);
+ phys_lmb_bram = qemu_ram_alloc(NULL, "petalogix_s3adsp1800.lmb_bram",
+ LMB_BRAM_SIZE);
cpu_register_physical_memory(0x00000000, LMB_BRAM_SIZE,
phys_lmb_bram | IO_MEM_RAM);
- phys_ram = qemu_ram_alloc(ram_size);
+ phys_ram = qemu_ram_alloc(NULL, "petalogix_s3adsp1800.ram", ram_size);
cpu_register_physical_memory(ddr_base, ram_size, phys_ram | IO_MEM_RAM);
- phys_flash = qemu_ram_alloc(FLASH_SIZE);
+ phys_flash = qemu_ram_alloc(NULL, "petalogix_s3adsp1800.flash", FLASH_SIZE);
dinfo = drive_get(IF_PFLASH, 0, 0);
- pflash_cfi02_register(0xa0000000, phys_flash,
+ pflash_cfi01_register(0xa0000000, phys_flash,
dinfo ? dinfo->bdrv : NULL, (64 * 1024),
FLASH_SIZE >> 16,
- 1, 1, 0x0000, 0x0000, 0x0000, 0x0000,
- 0x555, 0x2aa);
+ 1, 0x89, 0x18, 0x0000, 0x0, 1);
cpu_irq = microblaze_pic_init_cpu(env);
dev = xilinx_intc_create(0x81800000, cpu_irq[0], 2);
if (kernel_filename) {
uint64_t entry, low, high;
- int kcmdline_len;
uint32_t base32;
+ int big_endian = 0;
+
+#ifdef TARGET_WORDS_BIGENDIAN
+ big_endian = 1;
+#endif
/* Boots a kernel elf binary. */
- kernel_size = load_elf(kernel_filename, 0,
+ kernel_size = load_elf(kernel_filename, NULL, NULL,
&entry, &low, &high,
- 1, ELF_MACHINE, 0);
+ big_endian, ELF_MACHINE, 0);
base32 = entry;
if (base32 == 0xc0000000) {
- kernel_size = load_elf(kernel_filename, -0x30000000LL,
- &entry, NULL, NULL,
- 1, ELF_MACHINE, 0);
+ kernel_size = load_elf(kernel_filename, translate_kernel_address,
+ NULL, &entry, NULL, NULL,
+ big_endian, ELF_MACHINE, 0);
}
/* Always boot into physical ram. */
- bootstrap_pc = ddr_base + (entry & 0x0fffffff);
+ boot_info.bootstrap_pc = ddr_base + (entry & 0x0fffffff);
+
+ /* If it wasn't an ELF image, try an u-boot image. */
+ if (kernel_size < 0) {
+ target_phys_addr_t uentry, loadaddr;
+
+ kernel_size = load_uimage(kernel_filename, &uentry, &loadaddr, 0);
+ boot_info.bootstrap_pc = uentry;
+ high = (loadaddr + kernel_size + 3) & ~3;
+ }
+
+ /* Not an ELF image nor an u-boot image, try a RAW image. */
if (kernel_size < 0) {
- /* If we failed loading ELF's try a raw image. */
kernel_size = load_image_targphys(kernel_filename, ddr_base,
ram_size);
- bootstrap_pc = ddr_base;
+ boot_info.bootstrap_pc = ddr_base;
+ high = (ddr_base + kernel_size + 3) & ~3;
}
- env->regs[5] = ddr_base + kernel_size;
- if (kernel_cmdline && (kcmdline_len = strlen(kernel_cmdline))) {
- pstrcpy_targphys(env->regs[5], 256, kernel_cmdline);
+ boot_info.cmdline = high + 4096;
+ if (kernel_cmdline && strlen(kernel_cmdline)) {
+ pstrcpy_targphys("cmdline", boot_info.cmdline, 256, kernel_cmdline);
}
- env->regs[6] = 0;
/* Provide a device-tree. */
- env->regs[7] = ddr_base + kernel_size + 256;
- petalogix_load_device_tree(env->regs[7], ram_size,
- env->regs[6], 0,
+ boot_info.fdt = boot_info.cmdline + 4096;
+ petalogix_load_device_tree(boot_info.fdt, ram_size,
+ 0, 0,
kernel_cmdline);
}
-
- env->sregs[SR_PC] = bootstrap_pc;
}
static QEMUMachine petalogix_s3adsp1800_machine = {
.name = "petalogix-s3adsp1800",
- .desc = "Petalogix linux refdesign for xilinx Spartan 3ADSP1800",
+ .desc = "PetaLogix linux refdesign for xilinx Spartan 3ADSP1800",
.init = petalogix_s3adsp1800_init,
.is_default = 1
};
projects / qemu.git / blobdiff