hw/arm_boot.c

   1 /*
   2  * ARM kernel loader.
   3  *
   4  * Copyright (c) 2006-2007 CodeSourcery.
   5  * Written by Paul Brook
   6  *
   7  * This code is licenced under the GPL.
   8  */
   9
  10 #include "hw.h"
  11 #include "arm-misc.h"
  12 #include "sysemu.h"
  13
  14 #define KERNEL_ARGS_ADDR 0x100
  15 #define KERNEL_LOAD_ADDR 0x00010000
  16 #define INITRD_LOAD_ADDR 0x00800000
  17
  18 /* The worlds second smallest bootloader.  Set r0-r2, then jump to kernel.  */
  19 static uint32_t bootloader[] = {
  20   0xe3a00000, /* mov     r0, #0 */
  21   0xe3a01000, /* mov     r1, #0x?? */
  22   0xe3811c00, /* orr     r1, r1, #0x??00 */
  23   0xe59f2000, /* ldr     r2, [pc, #0] */
  24   0xe59ff000, /* ldr     pc, [pc, #0] */
  25   0, /* Address of kernel args.  Set by integratorcp_init.  */
  26   0  /* Kernel entry point.  Set by integratorcp_init.  */
  27 };
  28
  29 /* Entry point for secondary CPUs.  Enable interrupt controller and
  30    Issue WFI until start address is written to system controller.  */
  31 static uint32_t smpboot[] = {
  32   0xe3a00201, /* mov     r0, #0x10000000 */
  33   0xe3800601, /* orr     r0, r0, #0x001000000 */
  34   0xe3a01001, /* mov     r1, #1 */
  35   0xe5801100, /* str     r1, [r0, #0x100] */
  36   0xe3a00201, /* mov     r0, #0x10000000 */
  37   0xe3800030, /* orr     r0, #0x30 */
  38   0xe320f003, /* wfi */
  39   0xe5901000, /* ldr     r1, [r0] */
  40   0xe3110003, /* tst     r1, #3 */
  41   0x1afffffb, /* bne     <wfi> */
  42   0xe12fff11  /* bx      r1 */
  43 };
  44
  45 static void main_cpu_reset(void *opaque)
  46 {
  47     CPUState *env = opaque;
  48
  49     cpu_reset(env);
  50     if (env->boot_info)
  51         arm_load_kernel(env, env->boot_info);
  52
  53     /* TODO:  Reset secondary CPUs.  */
  54 }
  55
  56 #define WRITE_WORD(p, value) do { \
  57     stl_phys_notdirty(p, value);  \
  58     p += 4;                       \
  59 } while (0)
  60
  61 static void set_kernel_args(struct arm_boot_info *info,
  62                 int initrd_size, target_phys_addr_t base)
  63 {
  64     target_phys_addr_t p;
  65
  66     p = base + KERNEL_ARGS_ADDR;
  67     /* ATAG_CORE */
  68     WRITE_WORD(p, 5);
  69     WRITE_WORD(p, 0x54410001);
  70     WRITE_WORD(p, 1);
  71     WRITE_WORD(p, 0x1000);
  72     WRITE_WORD(p, 0);
  73     /* ATAG_MEM */
  74     /* TODO: handle multiple chips on one ATAG list */
  75     WRITE_WORD(p, 4);
  76     WRITE_WORD(p, 0x54410002);
  77     WRITE_WORD(p, info->ram_size);
  78     WRITE_WORD(p, info->loader_start);
  79     if (initrd_size) {
  80         /* ATAG_INITRD2 */
  81         WRITE_WORD(p, 4);
  82         WRITE_WORD(p, 0x54420005);
  83         WRITE_WORD(p, info->loader_start + INITRD_LOAD_ADDR);
  84         WRITE_WORD(p, initrd_size);
  85     }
  86     if (info->kernel_cmdline && *info->kernel_cmdline) {
  87         /* ATAG_CMDLINE */
  88         int cmdline_size;
  89
  90         cmdline_size = strlen(info->kernel_cmdline);
  91         cpu_physical_memory_write(p + 8, (void *)info->kernel_cmdline,
  92                                   cmdline_size + 1);
  93         cmdline_size = (cmdline_size >> 2) + 1;
  94         WRITE_WORD(p, cmdline_size + 2);
  95         WRITE_WORD(p, 0x54410009);
  96         p += cmdline_size * 4;
  97     }
  98     if (info->atag_board) {
  99         /* ATAG_BOARD */
 100         int atag_board_len;
 101         uint8_t atag_board_buf[0x1000];
 102
 103         atag_board_len = (info->atag_board(info, atag_board_buf) + 3) & ~3;
 104         WRITE_WORD(p, (atag_board_len + 8) >> 2);
 105         WRITE_WORD(p, 0x414f4d50);
 106         cpu_physical_memory_write(p, atag_board_buf, atag_board_len);
 107         p += atag_board_len;
 108     }
 109     /* ATAG_END */
 110     WRITE_WORD(p, 0);
 111     WRITE_WORD(p, 0);
 112 }
 113
 114 static void set_kernel_args_old(struct arm_boot_info *info,
 115                 int initrd_size, target_phys_addr_t base)
 116 {
 117     target_phys_addr_t p;
 118     const char *s;
 119
 120
 121     /* see linux/include/asm-arm/setup.h */
 122     p = base + KERNEL_ARGS_ADDR;
 123     /* page_size */
 124     WRITE_WORD(p, 4096);
 125     /* nr_pages */
 126     WRITE_WORD(p, info->ram_size / 4096);
 127     /* ramdisk_size */
 128     WRITE_WORD(p, 0);
 129 #define FLAG_READONLY   1
 130 #define FLAG_RDLOAD     4
 131 #define FLAG_RDPROMPT   8
 132     /* flags */
 133     WRITE_WORD(p, FLAG_READONLY | FLAG_RDLOAD | FLAG_RDPROMPT);
 134     /* rootdev */
 135     WRITE_WORD(p, (31 << 8) | 0);       /* /dev/mtdblock0 */
 136     /* video_num_cols */
 137     WRITE_WORD(p, 0);
 138     /* video_num_rows */
 139     WRITE_WORD(p, 0);
 140     /* video_x */
 141     WRITE_WORD(p, 0);
 142     /* video_y */
 143     WRITE_WORD(p, 0);
 144     /* memc_control_reg */
 145     WRITE_WORD(p, 0);
 146     /* unsigned char sounddefault */
 147     /* unsigned char adfsdrives */
 148     /* unsigned char bytes_per_char_h */
 149     /* unsigned char bytes_per_char_v */
 150     WRITE_WORD(p, 0);
 151     /* pages_in_bank[4] */
 152     WRITE_WORD(p, 0);
 153     WRITE_WORD(p, 0);
 154     WRITE_WORD(p, 0);
 155     WRITE_WORD(p, 0);
 156     /* pages_in_vram */
 157     WRITE_WORD(p, 0);
 158     /* initrd_start */
 159     if (initrd_size)
 160         WRITE_WORD(p, info->loader_start + INITRD_LOAD_ADDR);
 161     else
 162         WRITE_WORD(p, 0);
 163     /* initrd_size */
 164     WRITE_WORD(p, initrd_size);
 165     /* rd_start */
 166     WRITE_WORD(p, 0);
 167     /* system_rev */
 168     WRITE_WORD(p, 0);
 169     /* system_serial_low */
 170     WRITE_WORD(p, 0);
 171     /* system_serial_high */
 172     WRITE_WORD(p, 0);
 173     /* mem_fclk_21285 */
 174     WRITE_WORD(p, 0);
 175     /* zero unused fields */
 176     while (p < base + KERNEL_ARGS_ADDR + 256 + 1024) {
 177         WRITE_WORD(p, 0);
 178     }
 179     s = info->kernel_cmdline;
 180     if (s) {
 181         cpu_physical_memory_write(p, (void *)s, strlen(s) + 1);
 182     } else {
 183         WRITE_WORD(p, 0);
 184     }
 185 }
 186
 187 void arm_load_kernel(CPUState *env, struct arm_boot_info *info)
 188 {
 189     int kernel_size;
 190     int initrd_size;
 191     int n;
 192     int is_linux = 0;
 193     uint64_t elf_entry;
 194     target_ulong entry;
 195
 196     /* Load the kernel.  */
 197     if (!info->kernel_filename) {
 198         fprintf(stderr, "Kernel image must be specified\n");
 199         exit(1);
 200     }
 201
 202     if (!env->boot_info) {
 203         if (info->nb_cpus == 0)
 204             info->nb_cpus = 1;
 205         env->boot_info = info;
 206         qemu_register_reset(main_cpu_reset, 0, env);
 207     }
 208
 209     /* Assume that raw images are linux kernels, and ELF images are not.  */
 210     kernel_size = load_elf(info->kernel_filename, 0, &elf_entry, NULL, NULL);
 211     entry = elf_entry;
 212     if (kernel_size < 0) {
 213         kernel_size = load_uimage(info->kernel_filename, &entry, NULL,
 214                                   &is_linux);
 215     }
 216     if (kernel_size < 0) {
 217         entry = info->loader_start + KERNEL_LOAD_ADDR;
 218         kernel_size = load_image_targphys(info->kernel_filename, entry,
 219                                           ram_size - KERNEL_LOAD_ADDR);
 220         is_linux = 1;
 221     }
 222     if (kernel_size < 0) {
 223         fprintf(stderr, "qemu: could not load kernel '%s'\n",
 224                 info->kernel_filename);
 225         exit(1);
 226     }
 227     if (!is_linux) {
 228         /* Jump to the entry point.  */
 229         env->regs[15] = entry & 0xfffffffe;
 230         env->thumb = entry & 1;
 231     } else {
 232         if (info->initrd_filename) {
 233             initrd_size = load_image_targphys(info->initrd_filename,
 234                                               info->loader_start
 235                                               + INITRD_LOAD_ADDR,
 236                                               ram_size - INITRD_LOAD_ADDR);
 237             if (initrd_size < 0) {
 238                 fprintf(stderr, "qemu: could not load initrd '%s'\n",
 239                         info->initrd_filename);
 240                 exit(1);
 241             }
 242         } else {
 243             initrd_size = 0;
 244         }
 245         bootloader[1] |= info->board_id & 0xff;
 246         bootloader[2] |= (info->board_id >> 8) & 0xff;
 247         bootloader[5] = info->loader_start + KERNEL_ARGS_ADDR;
 248         bootloader[6] = entry;
 249         for (n = 0; n < sizeof(bootloader) / 4; n++) {
 250             stl_phys_notdirty(info->loader_start + (n * 4), bootloader[n]);
 251         }
 252         if (info->nb_cpus > 1) {
 253             for (n = 0; n < sizeof(smpboot) / 4; n++) {
 254                 stl_phys_notdirty(info->smp_loader_start + (n * 4), smpboot[n]);
 255             }
 256         }
 257         if (old_param)
 258             set_kernel_args_old(info, initrd_size, info->loader_start);
 259         else
 260             set_kernel_args(info, initrd_size, info->loader_start);
 261     }
 262 }