git.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        (512 * 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                        const char *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[0] & 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     qemu_irq *cpu_irqs[MAX_CPUS], *slavio_irq, *slavio_cpu_irq,
 317         *espdma_irq, *ledma_irq;
 318     qemu_irq *esp_reset, *le_reset;
 319
 320     /* init CPUs */
 321
 322     for(i = 0; i < smp_cpus; i++) {
 323         env = cpu_init(cpu_model);
 324         if (!env) {
 325             fprintf(stderr, "Unable to find Sparc CPU definition\n");
 326             exit(1);
 327         }
 328         cpu_sparc_set_id(env, i);
 329         envs[i] = env;
 330         if (i == 0) {
 331             qemu_register_reset(main_cpu_reset, env);
 332         } else {
 333             qemu_register_reset(secondary_cpu_reset, env);
 334             env->halted = 1;
 335         }
 336         register_savevm("cpu", i, 3, cpu_save, cpu_load, env);
 337         cpu_irqs[i] = qemu_allocate_irqs(cpu_set_irq, envs[i], MAX_PILS);
 338     }
 339
 340     for (i = smp_cpus; i < MAX_CPUS; i++)
 341         cpu_irqs[i] = qemu_allocate_irqs(dummy_cpu_set_irq, NULL, MAX_PILS);
 342
 343     /* allocate RAM */
 344     cpu_register_physical_memory(0, RAM_size, 0);
 345
 346     iommu = iommu_init(hwdef->iommu_base);
 347     slavio_intctl = slavio_intctl_init(hwdef->intctl_base,
 348                                        hwdef->intctl_base + 0x10000ULL,
 349                                        &hwdef->intbit_to_level[0],
 350                                        &slavio_irq, &slavio_cpu_irq,
 351                                        cpu_irqs,
 352                                        hwdef->clock_irq);
 353
 354     espdma = sparc32_dma_init(hwdef->dma_base, slavio_irq[hwdef->esp_irq],
 355                               iommu, &espdma_irq, &esp_reset);
 356
 357     ledma = sparc32_dma_init(hwdef->dma_base + 16ULL,
 358                              slavio_irq[hwdef->le_irq], iommu, &ledma_irq,
 359                              &le_reset);
 360
 361     if (graphic_depth != 8 && graphic_depth != 24) {
 362         fprintf(stderr, "qemu: Unsupported depth: %d\n", graphic_depth);
 363         exit (1);
 364     }
 365     tcx_init(ds, hwdef->tcx_base, phys_ram_base + RAM_size, RAM_size,
 366              hwdef->vram_size, graphic_width, graphic_height, graphic_depth);
 367
 368     if (nd_table[0].model == NULL
 369         || strcmp(nd_table[0].model, "lance") == 0) {
 370         lance_init(&nd_table[0], hwdef->le_base, ledma, *ledma_irq, le_reset);
 371     } else if (strcmp(nd_table[0].model, "?") == 0) {
 372         fprintf(stderr, "qemu: Supported NICs: lance\n");
 373         exit (1);
 374     } else {
 375         fprintf(stderr, "qemu: Unsupported NIC: %s\n", nd_table[0].model);
 376         exit (1);
 377     }
 378
 379     nvram = m48t59_init(slavio_irq[0], hwdef->nvram_base, 0,
 380                         hwdef->nvram_size, 8);
 381
 382     slavio_timer_init_all(hwdef->counter_base, slavio_irq[hwdef->clock1_irq],
 383                           slavio_cpu_irq);
 384
 385     slavio_serial_ms_kbd_init(hwdef->ms_kb_base, slavio_irq[hwdef->ms_kb_irq]);
 386     // Slavio TTYA (base+4, Linux ttyS0) is the first Qemu serial device
 387     // Slavio TTYB (base+0, Linux ttyS1) is the second Qemu serial device
 388     slavio_serial_init(hwdef->serial_base, slavio_irq[hwdef->ser_irq],
 389                        serial_hds[1], serial_hds[0]);
 390
 391     sun4m_fdctrl_init(slavio_irq[hwdef->fd_irq], hwdef->fd_base, fd_table);
 392
 393     main_esp = esp_init(bs_table, hwdef->esp_base, espdma, *espdma_irq,
 394                         esp_reset);
 395
 396     for (i = 0; i < MAX_DISKS; i++) {
 397         if (bs_table[i]) {
 398             esp_scsi_attach(main_esp, bs_table[i], i);
 399         }
 400     }
 401
 402     slavio_misc = slavio_misc_init(hwdef->slavio_base, hwdef->power_base,
 403                                    slavio_irq[hwdef->me_irq]);
 404     if (hwdef->cs_base != (target_phys_addr_t)-1)
 405         cs_init(hwdef->cs_base, hwdef->cs_irq, slavio_intctl);
 406
 407     return nvram;
 408 }
 409
 410 static void sun4m_load_kernel(long vram_size, int RAM_size,
 411                               const char *boot_device,
 412                               const char *kernel_filename,
 413                               const char *kernel_cmdline,
 414                               const char *initrd_filename,
 415                               int machine_id,
 416                               void *nvram)
 417 {
 418     int ret, linux_boot;
 419     char buf[1024];
 420     unsigned int i;
 421     long prom_offset, initrd_size, kernel_size;
 422
 423     linux_boot = (kernel_filename != NULL);
 424
 425     prom_offset = RAM_size + vram_size;
 426     cpu_register_physical_memory(PROM_PADDR,
 427                                  (PROM_SIZE_MAX + TARGET_PAGE_SIZE - 1) & TARGET_PAGE_MASK,
 428                                  prom_offset | IO_MEM_ROM);
 429
 430     if (bios_name == NULL)
 431         bios_name = PROM_FILENAME;
 432     snprintf(buf, sizeof(buf), "%s/%s", bios_dir, bios_name);
 433     ret = load_elf(buf, PROM_PADDR - PROM_VADDR, NULL, NULL, NULL);
 434     if (ret < 0 || ret > PROM_SIZE_MAX)
 435         ret = load_image(buf, phys_ram_base + prom_offset);
 436     if (ret < 0 || ret > PROM_SIZE_MAX) {
 437         fprintf(stderr, "qemu: could not load prom '%s'\n",
 438                 buf);
 439         exit(1);
 440     }
 441
 442     kernel_size = 0;
 443     if (linux_boot) {
 444         kernel_size = load_elf(kernel_filename, -0xf0000000ULL, NULL, NULL,
 445                                NULL);
 446         if (kernel_size < 0)
 447             kernel_size = load_aout(kernel_filename, phys_ram_base + KERNEL_LOAD_ADDR);
 448         if (kernel_size < 0)
 449             kernel_size = load_image(kernel_filename, phys_ram_base + KERNEL_LOAD_ADDR);
 450         if (kernel_size < 0) {
 451             fprintf(stderr, "qemu: could not load kernel '%s'\n",
 452                     kernel_filename);
 453             exit(1);
 454         }
 455
 456         /* load initrd */
 457         initrd_size = 0;
 458         if (initrd_filename) {
 459             initrd_size = load_image(initrd_filename, phys_ram_base + INITRD_LOAD_ADDR);
 460             if (initrd_size < 0) {
 461                 fprintf(stderr, "qemu: could not load initial ram disk '%s'\n",
 462                         initrd_filename);
 463                 exit(1);
 464             }
 465         }
 466         if (initrd_size > 0) {
 467             for (i = 0; i < 64 * TARGET_PAGE_SIZE; i += TARGET_PAGE_SIZE) {
 468                 if (ldl_raw(phys_ram_base + KERNEL_LOAD_ADDR + i)
 469                     == 0x48647253) { // HdrS
 470                     stl_raw(phys_ram_base + KERNEL_LOAD_ADDR + i + 16, INITRD_LOAD_ADDR);
 471                     stl_raw(phys_ram_base + KERNEL_LOAD_ADDR + i + 20, initrd_size);
 472                     break;
 473                 }
 474             }
 475         }
 476     }
 477     nvram_init(nvram, (uint8_t *)&nd_table[0].macaddr, kernel_cmdline,
 478                boot_device, RAM_size, kernel_size, graphic_width,
 479                graphic_height, graphic_depth, machine_id);
 480 }
 481
 482 static const struct hwdef hwdefs[] = {
 483     /* SS-5 */
 484     {
 485         .iommu_base   = 0x10000000,
 486         .tcx_base     = 0x50000000,
 487         .cs_base      = 0x6c000000,
 488         .slavio_base  = 0x70000000,
 489         .ms_kb_base   = 0x71000000,
 490         .serial_base  = 0x71100000,
 491         .nvram_base   = 0x71200000,
 492         .fd_base      = 0x71400000,
 493         .counter_base = 0x71d00000,
 494         .intctl_base  = 0x71e00000,
 495         .dma_base     = 0x78400000,
 496         .esp_base     = 0x78800000,
 497         .le_base      = 0x78c00000,
 498         .power_base   = 0x7a000000,
 499         .vram_size    = 0x00100000,
 500         .nvram_size   = 0x2000,
 501         .esp_irq = 18,
 502         .le_irq = 16,
 503         .clock_irq = 7,
 504         .clock1_irq = 19,
 505         .ms_kb_irq = 14,
 506         .ser_irq = 15,
 507         .fd_irq = 22,
 508         .me_irq = 30,
 509         .cs_irq = 5,
 510         .machine_id = 0x80,
 511         .intbit_to_level = {
 512             2, 3, 5, 7, 9, 11, 0, 14,   3, 5, 7, 9, 11, 13, 12, 12,
 513             6, 0, 4, 10, 8, 0, 11, 0,   0, 0, 0, 0, 15, 0, 15, 0,
 514         },
 515     },
 516     /* SS-10 */
 517     {
 518         .iommu_base   = 0xfe0000000ULL,
 519         .tcx_base     = 0xe20000000ULL,
 520         .cs_base      = -1,
 521         .slavio_base  = 0xff0000000ULL,
 522         .ms_kb_base   = 0xff1000000ULL,
 523         .serial_base  = 0xff1100000ULL,
 524         .nvram_base   = 0xff1200000ULL,
 525         .fd_base      = 0xff1700000ULL,
 526         .counter_base = 0xff1300000ULL,
 527         .intctl_base  = 0xff1400000ULL,
 528         .dma_base     = 0xef0400000ULL,
 529         .esp_base     = 0xef0800000ULL,
 530         .le_base      = 0xef0c00000ULL,
 531         .power_base   = 0xefa000000ULL,
 532         .vram_size    = 0x00100000,
 533         .nvram_size   = 0x2000,
 534         .esp_irq = 18,
 535         .le_irq = 16,
 536         .clock_irq = 7,
 537         .clock1_irq = 19,
 538         .ms_kb_irq = 14,
 539         .ser_irq = 15,
 540         .fd_irq = 22,
 541         .me_irq = 30,
 542         .cs_irq = -1,
 543         .machine_id = 0x72,
 544         .intbit_to_level = {
 545             2, 3, 5, 7, 9, 11, 0, 14,   3, 5, 7, 9, 11, 13, 12, 12,
 546             6, 0, 4, 10, 8, 0, 11, 0,   0, 0, 0, 0, 15, 0, 15, 0,
 547         },
 548     },
 549 };
 550
 551 static void sun4m_common_init(int RAM_size, const char *boot_device, DisplayState *ds,
 552                               const char *kernel_filename, const char *kernel_cmdline,
 553                               const char *initrd_filename, const char *cpu_model,
 554                               unsigned int machine, int max_ram)
 555 {
 556     void *nvram;
 557
 558     if ((unsigned int)RAM_size > (unsigned int)max_ram) {
 559         fprintf(stderr, "qemu: Too much memory for this machine: %d, maximum %d\n",
 560                 (unsigned int)RAM_size / (1024 * 1024),
 561                 (unsigned int)max_ram / (1024 * 1024));
 562         exit(1);
 563     }
 564     nvram = sun4m_hw_init(&hwdefs[machine], RAM_size, ds, cpu_model);
 565
 566     sun4m_load_kernel(hwdefs[machine].vram_size, RAM_size, boot_device,
 567                       kernel_filename, kernel_cmdline, initrd_filename,
 568                       hwdefs[machine].machine_id, nvram);
 569 }
 570
 571 /* SPARCstation 5 hardware initialisation */
 572 static void ss5_init(int RAM_size, int vga_ram_size, const char *boot_device,
 573                        DisplayState *ds, const char **fd_filename, int snapshot,
 574                        const char *kernel_filename, const char *kernel_cmdline,
 575                        const char *initrd_filename, const char *cpu_model)
 576 {
 577     if (cpu_model == NULL)
 578         cpu_model = "Fujitsu MB86904";
 579     sun4m_common_init(RAM_size, boot_device, ds, kernel_filename,
 580                       kernel_cmdline, initrd_filename, cpu_model,
 581                       0, 0x10000000);
 582 }
 583
 584 /* SPARCstation 10 hardware initialisation */
 585 static void ss10_init(int RAM_size, int vga_ram_size, const char *boot_device,
 586                             DisplayState *ds, const char **fd_filename, int snapshot,
 587                             const char *kernel_filename, const char *kernel_cmdline,
 588                             const char *initrd_filename, const char *cpu_model)
 589 {
 590     if (cpu_model == NULL)
 591         cpu_model = "TI SuperSparc II";
 592     sun4m_common_init(RAM_size, boot_device, ds, kernel_filename,
 593                       kernel_cmdline, initrd_filename, cpu_model,
 594                       1, 0xffffffff); // XXX actually first 62GB ok
 595 }
 596
 597 QEMUMachine ss5_machine = {
 598     "SS-5",
 599     "Sun4m platform, SPARCstation 5",
 600     ss5_init,
 601 };
 602
 603 QEMUMachine ss10_machine = {
 604     "SS-10",
 605     "Sun4m platform, SPARCstation 10",
 606     ss10_init,
 607 };