git.maemo.org Git - qemu/blob - hw/mips_mipssim.c

   1 /*
   2  * QEMU/mipssim emulation
   3  *
   4  * Emulates a very simple machine model similiar to the one use by the
   5  * proprietary MIPS emulator.
   6  *
   7  * Copyright (c) 2007 Thiemo Seufer
   8  *
   9  * Permission is hereby granted, free of charge, to any person obtaining a copy
  10  * of this software and associated documentation files (the "Software"), to deal
  11  * in the Software without restriction, including without limitation the rights
  12  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  13  * copies of the Software, and to permit persons to whom the Software is
  14  * furnished to do so, subject to the following conditions:
  15  *
  16  * The above copyright notice and this permission notice shall be included in
  17  * all copies or substantial portions of the Software.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  20  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  22  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  23  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  24  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  25  * THE SOFTWARE.
  26  */
  27 #include "vl.h"
  28
  29 #ifdef TARGET_WORDS_BIGENDIAN
  30 #define BIOS_FILENAME "mips_bios.bin"
  31 #else
  32 #define BIOS_FILENAME "mipsel_bios.bin"
  33 #endif
  34
  35 #ifdef TARGET_MIPS64
  36 #define PHYS_TO_VIRT(x) ((x) | ~0x7fffffffULL)
  37 #else
  38 #define PHYS_TO_VIRT(x) ((x) | ~0x7fffffffU)
  39 #endif
  40
  41 #define VIRT_TO_PHYS_ADDEND (-((int64_t)(int32_t)0x80000000))
  42
  43 static struct _loaderparams {
  44     int ram_size;
  45     const char *kernel_filename;
  46     const char *kernel_cmdline;
  47     const char *initrd_filename;
  48 } loaderparams;
  49
  50 static void load_kernel (CPUState *env)
  51 {
  52     int64_t entry, kernel_low, kernel_high;
  53     long kernel_size;
  54     long initrd_size;
  55     ram_addr_t initrd_offset;
  56
  57     kernel_size = load_elf(loaderparams.kernel_filename, VIRT_TO_PHYS_ADDEND,
  58                            &entry, &kernel_low, &kernel_high);
  59     if (kernel_size >= 0) {
  60         if ((entry & ~0x7fffffffULL) == 0x80000000)
  61             entry = (int32_t)entry;
  62         env->PC[env->current_tc] = entry;
  63     } else {
  64         fprintf(stderr, "qemu: could not load kernel '%s'\n",
  65                 loaderparams.kernel_filename);
  66         exit(1);
  67     }
  68
  69     /* load initrd */
  70     initrd_size = 0;
  71     initrd_offset = 0;
  72     if (loaderparams.initrd_filename) {
  73         initrd_size = get_image_size (loaderparams.initrd_filename);
  74         if (initrd_size > 0) {
  75             initrd_offset = (kernel_high + ~TARGET_PAGE_MASK) & TARGET_PAGE_MASK;
  76             if (initrd_offset + initrd_size > loaderparams.ram_size) {
  77                 fprintf(stderr,
  78                         "qemu: memory too small for initial ram disk '%s'\n",
  79                         loaderparams.initrd_filename);
  80                 exit(1);
  81             }
  82             initrd_size = load_image(loaderparams.initrd_filename,
  83                                      phys_ram_base + initrd_offset);
  84         }
  85         if (initrd_size == (target_ulong) -1) {
  86             fprintf(stderr, "qemu: could not load initial ram disk '%s'\n",
  87                     loaderparams.initrd_filename);
  88             exit(1);
  89         }
  90     }
  91 }
  92
  93 static void main_cpu_reset(void *opaque)
  94 {
  95     CPUState *env = opaque;
  96     cpu_reset(env);
  97
  98     if (loaderparams.kernel_filename)
  99         load_kernel (env);
 100 }
 101
 102 static void
 103 mips_mipssim_init (int ram_size, int vga_ram_size, const char *boot_device,
 104                    DisplayState *ds, const char **fd_filename, int snapshot,
 105                    const char *kernel_filename, const char *kernel_cmdline,
 106                    const char *initrd_filename, const char *cpu_model)
 107 {
 108     char buf[1024];
 109     unsigned long bios_offset;
 110     CPUState *env;
 111     int bios_size;
 112     mips_def_t *def;
 113
 114     /* Init CPUs. */
 115     if (cpu_model == NULL) {
 116 #ifdef TARGET_MIPS64
 117         cpu_model = "5Kf";
 118 #else
 119         cpu_model = "24Kf";
 120 #endif
 121     }
 122     env = cpu_init(cpu_model);
 123     if (!env) {
 124         fprintf(stderr, "Unable to find CPU definition\n");
 125         exit(1);
 126     }
 127     register_savevm("cpu", 0, 3, cpu_save, cpu_load, env);
 128     qemu_register_reset(main_cpu_reset, env);
 129
 130     /* Allocate RAM. */
 131     cpu_register_physical_memory(0, ram_size, IO_MEM_RAM);
 132
 133     /* Load a BIOS / boot exception handler image. */
 134     bios_offset = ram_size + vga_ram_size;
 135     if (bios_name == NULL)
 136         bios_name = BIOS_FILENAME;
 137     snprintf(buf, sizeof(buf), "%s/%s", bios_dir, bios_name);
 138     bios_size = load_image(buf, phys_ram_base + bios_offset);
 139     if ((bios_size < 0 || bios_size > BIOS_SIZE) && !kernel_filename) {
 140         /* Bail out if we have neither a kernel image nor boot vector code. */
 141         fprintf(stderr,
 142                 "qemu: Could not load MIPS bios '%s', and no -kernel argument was specified\n",
 143                 buf);
 144         exit(1);
 145     } else {
 146         /* Map the BIOS / boot exception handler. */
 147         cpu_register_physical_memory(0x1fc00000LL,
 148                                      bios_size, bios_offset | IO_MEM_ROM);
 149         /* We have a boot vector start address. */
 150         env->PC[env->current_tc] = (target_long)(int32_t)0xbfc00000;
 151     }
 152
 153     if (kernel_filename) {
 154         loaderparams.ram_size = ram_size;
 155         loaderparams.kernel_filename = kernel_filename;
 156         loaderparams.kernel_cmdline = kernel_cmdline;
 157         loaderparams.initrd_filename = initrd_filename;
 158         load_kernel(env);
 159     }
 160
 161     /* Init CPU internal devices. */
 162     cpu_mips_irq_init_cpu(env);
 163     cpu_mips_clock_init(env);
 164     cpu_mips_irqctrl_init();
 165
 166     /* Register 64 KB of ISA IO space at 0x1fd00000. */
 167     isa_mmio_init(0x1fd00000, 0x00010000);
 168
 169     /* A single 16450 sits at offset 0x3f8. It is attached to
 170        MIPS CPU INT2, which is interrupt 4. */
 171     if (serial_hds[0])
 172         serial_init(0x3f8, env->irq[4], serial_hds[0]);
 173
 174     if (nd_table[0].vlan) {
 175         if (nd_table[0].model == NULL
 176             || strcmp(nd_table[0].model, "mipsnet") == 0) {
 177             /* MIPSnet uses the MIPS CPU INT0, which is interrupt 2. */
 178             mipsnet_init(0x4200, env->irq[2], &nd_table[0]);
 179         } else if (strcmp(nd_table[0].model, "?") == 0) {
 180             fprintf(stderr, "qemu: Supported NICs: mipsnet\n");
 181             exit (1);
 182         } else {
 183             fprintf(stderr, "qemu: Unsupported NIC: %s\n", nd_table[0].model);
 184             exit (1);
 185         }
 186     }
 187 }
 188
 189 QEMUMachine mips_mipssim_machine = {
 190     "mipssim",
 191     "MIPS MIPSsim platform",
 192     mips_mipssim_init,
 193 };