hw/arm_boot.c

   1 /*
   2  * ARM kernel loader.
   3  *
   4  * Copyright (c) 2006 CodeSourcery.
   5  * Written by Paul Brook
   6  *
   7  * This code is licenced under the GPL.
   8  */
   9
  10 #include "vl.h"
  11
  12 #define KERNEL_ARGS_ADDR 0x100
  13 #define KERNEL_LOAD_ADDR 0x00010000
  14 #define INITRD_LOAD_ADDR 0x00800000
  15
  16 /* The worlds second smallest bootloader.  Set r0-r2, then jump to kernel.  */
  17 static uint32_t bootloader[] = {
  18   0xe3a00000, /* mov     r0, #0 */
  19   0xe3a01000, /* mov     r1, #0x?? */
  20   0xe3811c00, /* orr     r1, r1, #0x??00 */
  21   0xe59f2000, /* ldr     r2, [pc, #0] */
  22   0xe59ff000, /* ldr     pc, [pc, #0] */
  23   0, /* Address of kernel args.  Set by integratorcp_init.  */
  24   0  /* Kernel entry point.  Set by integratorcp_init.  */
  25 };
  26
  27 static void main_cpu_reset(void *opaque)
  28 {
  29     CPUState *env = opaque;
  30
  31     cpu_reset(env);
  32     if (env->kernel_filename)
  33         arm_load_kernel(env, env->ram_size, env->kernel_filename,
  34                         env->kernel_cmdline, env->initrd_filename,
  35                         env->board_id, env->loader_start);
  36 }
  37
  38 static void set_kernel_args(uint32_t ram_size, int initrd_size,
  39                             const char *kernel_cmdline,
  40                             target_phys_addr_t loader_start)
  41 {
  42     uint32_t *p;
  43
  44     p = (uint32_t *)(phys_ram_base + KERNEL_ARGS_ADDR);
  45     /* ATAG_CORE */
  46     stl_raw(p++, 5);
  47     stl_raw(p++, 0x54410001);
  48     stl_raw(p++, 1);
  49     stl_raw(p++, 0x1000);
  50     stl_raw(p++, 0);
  51     /* ATAG_MEM */
  52     stl_raw(p++, 4);
  53     stl_raw(p++, 0x54410002);
  54     stl_raw(p++, ram_size);
  55     stl_raw(p++, loader_start);
  56     if (initrd_size) {
  57         /* ATAG_INITRD2 */
  58         stl_raw(p++, 4);
  59         stl_raw(p++, 0x54420005);
  60         stl_raw(p++, loader_start + INITRD_LOAD_ADDR);
  61         stl_raw(p++, initrd_size);
  62     }
  63     if (kernel_cmdline && *kernel_cmdline) {
  64         /* ATAG_CMDLINE */
  65         int cmdline_size;
  66
  67         cmdline_size = strlen(kernel_cmdline);
  68         memcpy (p + 2, kernel_cmdline, cmdline_size + 1);
  69         cmdline_size = (cmdline_size >> 2) + 1;
  70         stl_raw(p++, cmdline_size + 2);
  71         stl_raw(p++, 0x54410009);
  72         p += cmdline_size;
  73     }
  74     /* ATAG_END */
  75     stl_raw(p++, 0);
  76     stl_raw(p++, 0);
  77 }
  78
  79 static void set_kernel_args_old(uint32_t ram_size, int initrd_size,
  80                                 const char *kernel_cmdline,
  81                                 target_phys_addr_t loader_start)
  82 {
  83     uint32_t *p;
  84     unsigned char *s;
  85
  86     /* see linux/include/asm-arm/setup.h */
  87     p = (uint32_t *)(phys_ram_base + KERNEL_ARGS_ADDR);
  88     /* page_size */
  89     stl_raw(p++, 4096);
  90     /* nr_pages */
  91     stl_raw(p++, ram_size / 4096);
  92     /* ramdisk_size */
  93     stl_raw(p++, 0);
  94 #define FLAG_READONLY   1
  95 #define FLAG_RDLOAD     4
  96 #define FLAG_RDPROMPT   8
  97     /* flags */
  98     stl_raw(p++, FLAG_READONLY | FLAG_RDLOAD | FLAG_RDPROMPT);
  99     /* rootdev */
 100     stl_raw(p++, (31 << 8) | 0);        /* /dev/mtdblock0 */
 101     /* video_num_cols */
 102     stl_raw(p++, 0);
 103     /* video_num_rows */
 104     stl_raw(p++, 0);
 105     /* video_x */
 106     stl_raw(p++, 0);
 107     /* video_y */
 108     stl_raw(p++, 0);
 109     /* memc_control_reg */
 110     stl_raw(p++, 0);
 111     /* unsigned char sounddefault */
 112     /* unsigned char adfsdrives */
 113     /* unsigned char bytes_per_char_h */
 114     /* unsigned char bytes_per_char_v */
 115     stl_raw(p++, 0);
 116     /* pages_in_bank[4] */
 117     stl_raw(p++, 0);
 118     stl_raw(p++, 0);
 119     stl_raw(p++, 0);
 120     stl_raw(p++, 0);
 121     /* pages_in_vram */
 122     stl_raw(p++, 0);
 123     /* initrd_start */
 124     if (initrd_size)
 125         stl_raw(p++, loader_start + INITRD_LOAD_ADDR);
 126     else
 127         stl_raw(p++, 0);
 128     /* initrd_size */
 129     stl_raw(p++, initrd_size);
 130     /* rd_start */
 131     stl_raw(p++, 0);
 132     /* system_rev */
 133     stl_raw(p++, 0);
 134     /* system_serial_low */
 135     stl_raw(p++, 0);
 136     /* system_serial_high */
 137     stl_raw(p++, 0);
 138     /* mem_fclk_21285 */
 139     stl_raw(p++, 0);
 140     /* zero unused fields */
 141     memset(p, 0, 256 + 1024 -
 142            (p - ((uint32_t *)(phys_ram_base + KERNEL_ARGS_ADDR))));
 143     s = phys_ram_base + KERNEL_ARGS_ADDR + 256 + 1024;
 144     if (kernel_cmdline)
 145         strcpy (s, kernel_cmdline);
 146     else
 147         stb_raw(s, 0);
 148 }
 149
 150 void arm_load_kernel(CPUState *env, int ram_size, const char *kernel_filename,
 151                      const char *kernel_cmdline, const char *initrd_filename,
 152                      int board_id, target_phys_addr_t loader_start)
 153 {
 154     int kernel_size;
 155     int initrd_size;
 156     int n;
 157     int is_linux = 0;
 158     uint64_t elf_entry;
 159     target_ulong entry;
 160
 161     /* Load the kernel.  */
 162     if (!kernel_filename) {
 163         fprintf(stderr, "Kernel image must be specified\n");
 164         exit(1);
 165     }
 166
 167     if (!env->kernel_filename) {
 168         env->ram_size = ram_size;
 169         env->kernel_filename = kernel_filename;
 170         env->kernel_cmdline = kernel_cmdline;
 171         env->initrd_filename = initrd_filename;
 172         env->board_id = board_id;
 173         env->loader_start = loader_start;
 174         qemu_register_reset(main_cpu_reset, env);
 175     }
 176     /* Assume that raw images are linux kernels, and ELF images are not.  */
 177     kernel_size = load_elf(kernel_filename, 0, &elf_entry, NULL, NULL);
 178     entry = elf_entry;
 179     if (kernel_size < 0) {
 180         kernel_size = load_uboot(kernel_filename, &entry, &is_linux);
 181     }
 182     if (kernel_size < 0) {
 183         kernel_size = load_image(kernel_filename,
 184                                  phys_ram_base + KERNEL_LOAD_ADDR);
 185         entry = loader_start + KERNEL_LOAD_ADDR;
 186         is_linux = 1;
 187     }
 188     if (kernel_size < 0) {
 189         fprintf(stderr, "qemu: could not load kernel '%s'\n", kernel_filename);
 190         exit(1);
 191     }
 192     if (!is_linux) {
 193         /* Jump to the entry point.  */
 194         env->regs[15] = entry & 0xfffffffe;
 195         env->thumb = entry & 1;
 196     } else {
 197         if (initrd_filename) {
 198             initrd_size = load_image(initrd_filename,
 199                                      phys_ram_base + INITRD_LOAD_ADDR);
 200             if (initrd_size < 0) {
 201                 fprintf(stderr, "qemu: could not load initrd '%s'\n",
 202                         initrd_filename);
 203                 exit(1);
 204             }
 205         } else {
 206             initrd_size = 0;
 207         }
 208         bootloader[1] |= board_id & 0xff;
 209         bootloader[2] |= (board_id >> 8) & 0xff;
 210         bootloader[5] = loader_start + KERNEL_ARGS_ADDR;
 211         bootloader[6] = entry;
 212         for (n = 0; n < sizeof(bootloader) / 4; n++)
 213             stl_raw(phys_ram_base + (n * 4), bootloader[n]);
 214         if (old_param)
 215             set_kernel_args_old(ram_size, initrd_size,
 216                                 kernel_cmdline, loader_start);
 217         else
 218             set_kernel_args(ram_size, initrd_size,
 219                             kernel_cmdline, loader_start);
 220     }
 221 }