vcs.maemo.org Git - qemu/blob - hw/sun4m.c

   1 /*
   2  * QEMU Sun4m System Emulator
   3  *
   4  * Copyright (c) 2003-2005 Fabrice Bellard
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  */
  24 #include "vl.h"
  25 //#define DEBUG_IRQ
  26
  27 /*
  28  * Sun4m architecture was used in the following machines:
  29  *
  30  * SPARCserver 6xxMP/xx
  31  * SPARCclassic (SPARCclassic Server)(SPARCstation LC) (4/15), SPARCclassic X (4/10)
  32  * SPARCstation LX/ZX (4/30)
  33  * SPARCstation Voyager
  34  * SPARCstation 10/xx, SPARCserver 10/xx
  35  * SPARCstation 5, SPARCserver 5
  36  * SPARCstation 20/xx, SPARCserver 20
  37  * SPARCstation 4
  38  *
  39  * See for example: http://www.sunhelp.org/faq/sunref1.html
  40  */
  41
  42 #ifdef DEBUG_IRQ
  43 #define DPRINTF(fmt, args...)                           \
  44     do { printf("CPUIRQ: " fmt , ##args); } while (0)
  45 #else
  46 #define DPRINTF(fmt, args...)
  47 #endif
  48
  49 #define KERNEL_LOAD_ADDR     0x00004000
  50 #define CMDLINE_ADDR         0x007ff000
  51 #define INITRD_LOAD_ADDR     0x00800000
  52 #define PROM_SIZE_MAX        (256 * 1024)
  53 #define PROM_PADDR           0xff0000000ULL
  54 #define PROM_VADDR           0xffd00000
  55 #define PROM_FILENAME        "openbios-sparc32"
  56
  57 #define MAX_CPUS 16
  58 #define MAX_PILS 16
  59
  60 struct hwdef {
  61     target_phys_addr_t iommu_base, slavio_base;
  62     target_phys_addr_t intctl_base, counter_base, nvram_base, ms_kb_base;
  63     target_phys_addr_t serial_base, fd_base;
  64     target_phys_addr_t dma_base, esp_base, le_base;
  65     target_phys_addr_t tcx_base, cs_base, power_base;
  66     long vram_size, nvram_size;
  67     // IRQ numbers are not PIL ones, but master interrupt controller register
  68     // bit numbers
  69     int intctl_g_intr, esp_irq, le_irq, clock_irq, clock1_irq;
  70     int ser_irq, ms_kb_irq, fd_irq, me_irq, cs_irq;
  71     int machine_id; // For NVRAM
  72     uint32_t intbit_to_level[32];
  73 };
  74
  75 /* TSC handling */
  76
  77 uint64_t cpu_get_tsc()
  78 {
  79     return qemu_get_clock(vm_clock);
  80 }
  81
  82 int DMA_get_channel_mode (int nchan)
  83 {
  84     return 0;
  85 }
  86 int DMA_read_memory (int nchan, void *buf, int pos, int size)
  87 {
  88     return 0;
  89 }
  90 int DMA_write_memory (int nchan, void *buf, int pos, int size)
  91 {
  92     return 0;
  93 }
  94 void DMA_hold_DREQ (int nchan) {}
  95 void DMA_release_DREQ (int nchan) {}
  96 void DMA_schedule(int nchan) {}
  97 void DMA_run (void) {}
  98 void DMA_init (int high_page_enable) {}
  99 void DMA_register_channel (int nchan,
 100                            DMA_transfer_handler transfer_handler,
 101                            void *opaque)
 102 {
 103 }
 104
 105 static void nvram_set_word (m48t59_t *nvram, uint32_t addr, uint16_t value)
 106 {
 107     m48t59_write(nvram, addr++, (value >> 8) & 0xff);
 108     m48t59_write(nvram, addr++, value & 0xff);
 109 }
 110
 111 static void nvram_set_lword (m48t59_t *nvram, uint32_t addr, uint32_t value)
 112 {
 113     m48t59_write(nvram, addr++, value >> 24);
 114     m48t59_write(nvram, addr++, (value >> 16) & 0xff);
 115     m48t59_write(nvram, addr++, (value >> 8) & 0xff);
 116     m48t59_write(nvram, addr++, value & 0xff);
 117 }
 118
 119 static void nvram_set_string (m48t59_t *nvram, uint32_t addr,
 120                        const unsigned char *str, uint32_t max)
 121 {
 122     unsigned int i;
 123
 124     for (i = 0; i < max && str[i] != '\0'; i++) {
 125         m48t59_write(nvram, addr + i, str[i]);
 126     }
 127     m48t59_write(nvram, addr + max - 1, '\0');
 128 }
 129
 130 static uint32_t nvram_set_var (m48t59_t *nvram, uint32_t addr,
 131                                 const unsigned char *str)
 132 {
 133     uint32_t len;
 134
 135     len = strlen(str) + 1;
 136     nvram_set_string(nvram, addr, str, len);
 137
 138     return addr + len;
 139 }
 140
 141 static void nvram_finish_partition (m48t59_t *nvram, uint32_t start,
 142                                     uint32_t end)
 143 {
 144     unsigned int i, sum;
 145
 146     // Length divided by 16
 147     m48t59_write(nvram, start + 2, ((end - start) >> 12) & 0xff);
 148     m48t59_write(nvram, start + 3, ((end - start) >> 4) & 0xff);
 149     // Checksum
 150     sum = m48t59_read(nvram, start);
 151     for (i = 0; i < 14; i++) {
 152         sum += m48t59_read(nvram, start + 2 + i);
 153         sum = (sum + ((sum & 0xff00) >> 8)) & 0xff;
 154     }
 155     m48t59_write(nvram, start + 1, sum & 0xff);
 156 }
 157
 158 extern int nographic;
 159
 160 static void nvram_init(m48t59_t *nvram, uint8_t *macaddr, const char *cmdline,
 161                        int boot_device, uint32_t RAM_size,
 162                        uint32_t kernel_size,
 163                        int width, int height, int depth,
 164                        int machine_id)
 165 {
 166     unsigned char tmp = 0;
 167     unsigned int i, j;
 168     uint32_t start, end;
 169
 170     // Try to match PPC NVRAM
 171     nvram_set_string(nvram, 0x00, "QEMU_BIOS", 16);
 172     nvram_set_lword(nvram,  0x10, 0x00000001); /* structure v1 */
 173     // NVRAM_size, arch not applicable
 174     m48t59_write(nvram, 0x2D, smp_cpus & 0xff);
 175     m48t59_write(nvram, 0x2E, 0);
 176     m48t59_write(nvram, 0x2F, nographic & 0xff);
 177     nvram_set_lword(nvram,  0x30, RAM_size);
 178     m48t59_write(nvram, 0x34, boot_device & 0xff);
 179     nvram_set_lword(nvram,  0x38, KERNEL_LOAD_ADDR);
 180     nvram_set_lword(nvram,  0x3C, kernel_size);
 181     if (cmdline) {
 182         strcpy(phys_ram_base + CMDLINE_ADDR, cmdline);
 183         nvram_set_lword(nvram,  0x40, CMDLINE_ADDR);
 184         nvram_set_lword(nvram,  0x44, strlen(cmdline));
 185     }
 186     // initrd_image, initrd_size passed differently
 187     nvram_set_word(nvram,   0x54, width);
 188     nvram_set_word(nvram,   0x56, height);
 189     nvram_set_word(nvram,   0x58, depth);
 190
 191     // OpenBIOS nvram variables
 192     // Variable partition
 193     start = 252;
 194     m48t59_write(nvram, start, 0x70);
 195     nvram_set_string(nvram, start + 4, "system", 12);
 196
 197     end = start + 16;
 198     for (i = 0; i < nb_prom_envs; i++)
 199         end = nvram_set_var(nvram, end, prom_envs[i]);
 200
 201     m48t59_write(nvram, end++ , 0);
 202     end = start + ((end - start + 15) & ~15);
 203     nvram_finish_partition(nvram, start, end);
 204
 205     // free partition
 206     start = end;
 207     m48t59_write(nvram, start, 0x7f);
 208     nvram_set_string(nvram, start + 4, "free", 12);
 209
 210     end = 0x1fd0;
 211     nvram_finish_partition(nvram, start, end);
 212
 213     // Sun4m specific use
 214     start = i = 0x1fd8;
 215     m48t59_write(nvram, i++, 0x01);
 216     m48t59_write(nvram, i++, machine_id);
 217     j = 0;
 218     m48t59_write(nvram, i++, macaddr[j++]);
 219     m48t59_write(nvram, i++, macaddr[j++]);
 220     m48t59_write(nvram, i++, macaddr[j++]);
 221     m48t59_write(nvram, i++, macaddr[j++]);
 222     m48t59_write(nvram, i++, macaddr[j++]);
 223     m48t59_write(nvram, i, macaddr[j]);
 224
 225     /* Calculate checksum */
 226     for (i = start; i < start + 15; i++) {
 227         tmp ^= m48t59_read(nvram, i);
 228     }
 229     m48t59_write(nvram, start + 15, tmp);
 230 }
 231
 232 static void *slavio_intctl;
 233
 234 void pic_info()
 235 {
 236     slavio_pic_info(slavio_intctl);
 237 }
 238
 239 void irq_info()
 240 {
 241     slavio_irq_info(slavio_intctl);
 242 }
 243
 244 void cpu_check_irqs(CPUState *env)
 245 {
 246     if (env->pil_in && (env->interrupt_index == 0 ||
 247                         (env->interrupt_index & ~15) == TT_EXTINT)) {
 248         unsigned int i;
 249
 250         for (i = 15; i > 0; i--) {
 251             if (env->pil_in & (1 << i)) {
 252                 int old_interrupt = env->interrupt_index;
 253
 254                 env->interrupt_index = TT_EXTINT | i;
 255                 if (old_interrupt != env->interrupt_index)
 256                     cpu_interrupt(env, CPU_INTERRUPT_HARD);
 257                 break;
 258             }
 259         }
 260     } else if (!env->pil_in && (env->interrupt_index & ~15) == TT_EXTINT) {
 261         env->interrupt_index = 0;
 262         cpu_reset_interrupt(env, CPU_INTERRUPT_HARD);
 263     }
 264 }
 265
 266 static void cpu_set_irq(void *opaque, int irq, int level)
 267 {
 268     CPUState *env = opaque;
 269
 270     if (level) {
 271         DPRINTF("Raise CPU IRQ %d\n", irq);
 272         env->halted = 0;
 273         env->pil_in |= 1 << irq;
 274         cpu_check_irqs(env);
 275     } else {
 276         DPRINTF("Lower CPU IRQ %d\n", irq);
 277         env->pil_in &= ~(1 << irq);
 278         cpu_check_irqs(env);
 279     }
 280 }
 281
 282 static void dummy_cpu_set_irq(void *opaque, int irq, int level)
 283 {
 284 }
 285
 286 static void *slavio_misc;
 287
 288 void qemu_system_powerdown(void)
 289 {
 290     slavio_set_power_fail(slavio_misc, 1);
 291 }
 292
 293 static void main_cpu_reset(void *opaque)
 294 {
 295     CPUState *env = opaque;
 296
 297     cpu_reset(env);
 298     env->halted = 0;
 299 }
 300
 301 static void secondary_cpu_reset(void *opaque)
 302 {
 303     CPUState *env = opaque;
 304
 305     cpu_reset(env);
 306     env->halted = 1;
 307 }
 308
 309 static void *sun4m_hw_init(const struct hwdef *hwdef, int RAM_size,
 310                            DisplayState *ds, const char *cpu_model)
 311
 312 {
 313     CPUState *env, *envs[MAX_CPUS];
 314     unsigned int i;
 315     void *iommu, *espdma, *ledma, *main_esp, *nvram;
 316     const sparc_def_t *def;
 317     qemu_irq *cpu_irqs[MAX_CPUS], *slavio_irq, *slavio_cpu_irq,
 318         *espdma_irq, *ledma_irq;
 319     qemu_irq *esp_reset, *le_reset;
 320
 321     /* init CPUs */
 322     sparc_find_by_name(cpu_model, &def);
 323     if (def == NULL) {
 324         fprintf(stderr, "Unable to find Sparc CPU definition\n");
 325         exit(1);
 326     }
 327
 328     for(i = 0; i < smp_cpus; i++) {
 329         env = cpu_init();
 330         cpu_sparc_register(env, def);
 331         envs[i] = env;
 332         if (i == 0) {
 333             qemu_register_reset(main_cpu_reset, env);
 334         } else {
 335             qemu_register_reset(secondary_cpu_reset, env);
 336             env->halted = 1;
 337         }
 338         register_savevm("cpu", i, 3, cpu_save, cpu_load, env);
 339         cpu_irqs[i] = qemu_allocate_irqs(cpu_set_irq, envs[i], MAX_PILS);
 340     }
 341
 342     for (i = smp_cpus; i < MAX_CPUS; i++)
 343         cpu_irqs[i] = qemu_allocate_irqs(dummy_cpu_set_irq, NULL, MAX_PILS);
 344
 345     /* allocate RAM */
 346     cpu_register_physical_memory(0, RAM_size, 0);
 347
 348     iommu = iommu_init(hwdef->iommu_base);
 349     slavio_intctl = slavio_intctl_init(hwdef->intctl_base,
 350                                        hwdef->intctl_base + 0x10000ULL,
 351                                        &hwdef->intbit_to_level[0],
 352                                        &slavio_irq, &slavio_cpu_irq,
 353                                        cpu_irqs,
 354                                        hwdef->clock_irq);
 355
 356     espdma = sparc32_dma_init(hwdef->dma_base, slavio_irq[hwdef->esp_irq],
 357                               iommu, &espdma_irq, &esp_reset);
 358
 359     ledma = sparc32_dma_init(hwdef->dma_base + 16ULL,
 360                              slavio_irq[hwdef->le_irq], iommu, &ledma_irq,
 361                              &le_reset);
 362
 363     if (graphic_depth != 8 && graphic_depth != 24) {
 364         fprintf(stderr, "qemu: Unsupported depth: %d\n", graphic_depth);
 365         exit (1);
 366     }
 367     tcx_init(ds, hwdef->tcx_base, phys_ram_base + RAM_size, RAM_size,
 368              hwdef->vram_size, graphic_width, graphic_height, graphic_depth);
 369
 370     if (nd_table[0].model == NULL
 371         || strcmp(nd_table[0].model, "lance") == 0) {
 372         lance_init(&nd_table[0], hwdef->le_base, ledma, *ledma_irq, le_reset);
 373     } else if (strcmp(nd_table[0].model, "?") == 0) {
 374         fprintf(stderr, "qemu: Supported NICs: lance\n");
 375         exit (1);
 376     } else {
 377         fprintf(stderr, "qemu: Unsupported NIC: %s\n", nd_table[0].model);
 378         exit (1);
 379     }
 380
 381     nvram = m48t59_init(slavio_irq[0], hwdef->nvram_base, 0,
 382                         hwdef->nvram_size, 8);
 383     for (i = 0; i < MAX_CPUS; i++) {
 384         slavio_timer_init(hwdef->counter_base +
 385                           (target_phys_addr_t)(i * TARGET_PAGE_SIZE),
 386                            slavio_cpu_irq[i], 0);
 387     }
 388     slavio_timer_init(hwdef->counter_base + 0x10000ULL,
 389                       slavio_irq[hwdef->clock1_irq], 2);
 390     slavio_serial_ms_kbd_init(hwdef->ms_kb_base, slavio_irq[hwdef->ms_kb_irq]);
 391     // Slavio TTYA (base+4, Linux ttyS0) is the first Qemu serial device
 392     // Slavio TTYB (base+0, Linux ttyS1) is the second Qemu serial device
 393     slavio_serial_init(hwdef->serial_base, slavio_irq[hwdef->ser_irq],
 394                        serial_hds[1], serial_hds[0]);
 395     fdctrl_init(slavio_irq[hwdef->fd_irq], 0, 1, hwdef->fd_base, fd_table);
 396
 397     main_esp = esp_init(bs_table, hwdef->esp_base, espdma, *espdma_irq,
 398                         esp_reset);
 399
 400     for (i = 0; i < MAX_DISKS; i++) {
 401         if (bs_table[i]) {
 402             esp_scsi_attach(main_esp, bs_table[i], i);
 403         }
 404     }
 405
 406     slavio_misc = slavio_misc_init(hwdef->slavio_base, hwdef->power_base,
 407                                    slavio_irq[hwdef->me_irq]);
 408     if (hwdef->cs_base != (target_phys_addr_t)-1)
 409         cs_init(hwdef->cs_base, hwdef->cs_irq, slavio_intctl);
 410
 411     return nvram;
 412 }
 413
 414 static void sun4m_load_kernel(long vram_size, int RAM_size, int boot_device,
 415                               const char *kernel_filename,
 416                               const char *kernel_cmdline,
 417                               const char *initrd_filename,
 418                               int machine_id,
 419                               void *nvram)
 420 {
 421     int ret, linux_boot;
 422     char buf[1024];
 423     unsigned int i;
 424     long prom_offset, initrd_size, kernel_size;
 425
 426     linux_boot = (kernel_filename != NULL);
 427
 428     prom_offset = RAM_size + vram_size;
 429     cpu_register_physical_memory(PROM_PADDR,
 430                                  (PROM_SIZE_MAX + TARGET_PAGE_SIZE - 1) & TARGET_PAGE_MASK,
 431                                  prom_offset | IO_MEM_ROM);
 432
 433     snprintf(buf, sizeof(buf), "%s/%s", bios_dir, PROM_FILENAME);
 434     ret = load_elf(buf, PROM_PADDR - PROM_VADDR, NULL, NULL, NULL);
 435     if (ret < 0) {
 436         fprintf(stderr, "qemu: could not load prom '%s'\n",
 437                 buf);
 438         exit(1);
 439     }
 440
 441     kernel_size = 0;
 442     if (linux_boot) {
 443         kernel_size = load_elf(kernel_filename, -0xf0000000ULL, NULL, NULL,
 444                                NULL);
 445         if (kernel_size < 0)
 446             kernel_size = load_aout(kernel_filename, phys_ram_base + KERNEL_LOAD_ADDR);
 447         if (kernel_size < 0)
 448             kernel_size = load_image(kernel_filename, phys_ram_base + KERNEL_LOAD_ADDR);
 449         if (kernel_size < 0) {
 450             fprintf(stderr, "qemu: could not load kernel '%s'\n",
 451                     kernel_filename);
 452             exit(1);
 453         }
 454
 455         /* load initrd */
 456         initrd_size = 0;
 457         if (initrd_filename) {
 458             initrd_size = load_image(initrd_filename, phys_ram_base + INITRD_LOAD_ADDR);
 459             if (initrd_size < 0) {
 460                 fprintf(stderr, "qemu: could not load initial ram disk '%s'\n",
 461                         initrd_filename);
 462                 exit(1);
 463             }
 464         }
 465         if (initrd_size > 0) {
 466             for (i = 0; i < 64 * TARGET_PAGE_SIZE; i += TARGET_PAGE_SIZE) {
 467                 if (ldl_raw(phys_ram_base + KERNEL_LOAD_ADDR + i)
 468                     == 0x48647253) { // HdrS
 469                     stl_raw(phys_ram_base + KERNEL_LOAD_ADDR + i + 16, INITRD_LOAD_ADDR);
 470                     stl_raw(phys_ram_base + KERNEL_LOAD_ADDR + i + 20, initrd_size);
 471                     break;
 472                 }
 473             }
 474         }
 475     }
 476     nvram_init(nvram, (uint8_t *)&nd_table[0].macaddr, kernel_cmdline,
 477                boot_device, RAM_size, kernel_size, graphic_width,
 478                graphic_height, graphic_depth, machine_id);
 479 }
 480
 481 static const struct hwdef hwdefs[] = {
 482     /* SS-5 */
 483     {
 484         .iommu_base   = 0x10000000,
 485         .tcx_base     = 0x50000000,
 486         .cs_base      = 0x6c000000,
 487         .slavio_base  = 0x70000000,
 488         .ms_kb_base   = 0x71000000,
 489         .serial_base  = 0x71100000,
 490         .nvram_base   = 0x71200000,
 491         .fd_base      = 0x71400000,
 492         .counter_base = 0x71d00000,
 493         .intctl_base  = 0x71e00000,
 494         .dma_base     = 0x78400000,
 495         .esp_base     = 0x78800000,
 496         .le_base      = 0x78c00000,
 497         .power_base   = 0x7a000000,
 498         .vram_size    = 0x00100000,
 499         .nvram_size   = 0x2000,
 500         .esp_irq = 18,
 501         .le_irq = 16,
 502         .clock_irq = 7,
 503         .clock1_irq = 19,
 504         .ms_kb_irq = 14,
 505         .ser_irq = 15,
 506         .fd_irq = 22,
 507         .me_irq = 30,
 508         .cs_irq = 5,
 509         .machine_id = 0x80,
 510         .intbit_to_level = {
 511             2, 3, 5, 7, 9, 11, 0, 14,   3, 5, 7, 9, 11, 13, 12, 12,
 512             6, 0, 4, 10, 8, 0, 11, 0,   0, 0, 0, 0, 15, 0, 15, 0,
 513         },
 514     },
 515     /* SS-10 */
 516     {
 517         .iommu_base   = 0xfe0000000ULL,
 518         .tcx_base     = 0xe20000000ULL,
 519         .cs_base      = -1,
 520         .slavio_base  = 0xff0000000ULL,
 521         .ms_kb_base   = 0xff1000000ULL,
 522         .serial_base  = 0xff1100000ULL,
 523         .nvram_base   = 0xff1200000ULL,
 524         .fd_base      = 0xff1700000ULL,
 525         .counter_base = 0xff1300000ULL,
 526         .intctl_base  = 0xff1400000ULL,
 527         .dma_base     = 0xef0400000ULL,
 528         .esp_base     = 0xef0800000ULL,
 529         .le_base      = 0xef0c00000ULL,
 530         .power_base   = 0xefa000000ULL,
 531         .vram_size    = 0x00100000,
 532         .nvram_size   = 0x2000,
 533         .esp_irq = 18,
 534         .le_irq = 16,
 535         .clock_irq = 7,
 536         .clock1_irq = 19,
 537         .ms_kb_irq = 14,
 538         .ser_irq = 15,
 539         .fd_irq = 22,
 540         .me_irq = 30,
 541         .cs_irq = -1,
 542         .machine_id = 0x72,
 543         .intbit_to_level = {
 544             2, 3, 5, 7, 9, 11, 0, 14,   3, 5, 7, 9, 11, 13, 12, 12,
 545             6, 0, 4, 10, 8, 0, 11, 0,   0, 0, 0, 0, 15, 0, 15, 0,
 546         },
 547     },
 548 };
 549
 550 static void sun4m_common_init(int RAM_size, int boot_device, DisplayState *ds,
 551                               const char *kernel_filename, const char *kernel_cmdline,
 552                               const char *initrd_filename, const char *cpu_model,
 553                               unsigned int machine, int max_ram)
 554 {
 555     void *nvram;
 556
 557     if ((unsigned int)RAM_size > (unsigned int)max_ram) {
 558         fprintf(stderr, "qemu: Too much memory for this machine: %d, maximum %d\n",
 559                 (unsigned int)RAM_size / (1024 * 1024),
 560                 (unsigned int)max_ram / (1024 * 1024));
 561         exit(1);
 562     }
 563     nvram = sun4m_hw_init(&hwdefs[machine], RAM_size, ds, cpu_model);
 564
 565     sun4m_load_kernel(hwdefs[machine].vram_size, RAM_size, boot_device,
 566                       kernel_filename, kernel_cmdline, initrd_filename,
 567                       hwdefs[machine].machine_id, nvram);
 568 }
 569
 570 /* SPARCstation 5 hardware initialisation */
 571 static void ss5_init(int RAM_size, int vga_ram_size, int boot_device,
 572                        DisplayState *ds, const char **fd_filename, int snapshot,
 573                        const char *kernel_filename, const char *kernel_cmdline,
 574                        const char *initrd_filename, const char *cpu_model)
 575 {
 576     if (cpu_model == NULL)
 577         cpu_model = "Fujitsu MB86904";
 578     sun4m_common_init(RAM_size, boot_device, ds, kernel_filename,
 579                       kernel_cmdline, initrd_filename, cpu_model,
 580                       0, 0x10000000);
 581 }
 582
 583 /* SPARCstation 10 hardware initialisation */
 584 static void ss10_init(int RAM_size, int vga_ram_size, int boot_device,
 585                             DisplayState *ds, const char **fd_filename, int snapshot,
 586                             const char *kernel_filename, const char *kernel_cmdline,
 587                             const char *initrd_filename, const char *cpu_model)
 588 {
 589     if (cpu_model == NULL)
 590         cpu_model = "TI SuperSparc II";
 591     sun4m_common_init(RAM_size, boot_device, ds, kernel_filename,
 592                       kernel_cmdline, initrd_filename, cpu_model,
 593                       1, 0xffffffff); // XXX actually first 62GB ok
 594 }
 595
 596 QEMUMachine ss5_machine = {
 597     "SS-5",
 598     "Sun4m platform, SPARCstation 5",
 599     ss5_init,
 600 };
 601
 602 QEMUMachine ss10_machine = {
 603     "SS-10",
 604     "Sun4m platform, SPARCstation 10",
 605     ss10_init,
 606 };