Statistics
| Branch: | Revision:

root / hw / sun4m.c @ 40ce0a9a

History | View | Annotate | Download (19.3 kB)

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, -0xf0000000, NULL, NULL, NULL);
444
        if (kernel_size < 0)
445
            kernel_size = load_aout(kernel_filename, phys_ram_base + KERNEL_LOAD_ADDR);
446
        if (kernel_size < 0)
447
            kernel_size = load_image(kernel_filename, phys_ram_base + KERNEL_LOAD_ADDR);
448
        if (kernel_size < 0) {
449
            fprintf(stderr, "qemu: could not load kernel '%s'\n",
450
                    kernel_filename);
451
            exit(1);
452
        }
453

    
454
        /* load initrd */
455
        initrd_size = 0;
456
        if (initrd_filename) {
457
            initrd_size = load_image(initrd_filename, phys_ram_base + INITRD_LOAD_ADDR);
458
            if (initrd_size < 0) {
459
                fprintf(stderr, "qemu: could not load initial ram disk '%s'\n",
460
                        initrd_filename);
461
                exit(1);
462
            }
463
        }
464
        if (initrd_size > 0) {
465
            for (i = 0; i < 64 * TARGET_PAGE_SIZE; i += TARGET_PAGE_SIZE) {
466
                if (ldl_raw(phys_ram_base + KERNEL_LOAD_ADDR + i)
467
                    == 0x48647253) { // HdrS
468
                    stl_raw(phys_ram_base + KERNEL_LOAD_ADDR + i + 16, INITRD_LOAD_ADDR);
469
                    stl_raw(phys_ram_base + KERNEL_LOAD_ADDR + i + 20, initrd_size);
470
                    break;
471
                }
472
            }
473
        }
474
    }
475
    nvram_init(nvram, (uint8_t *)&nd_table[0].macaddr, kernel_cmdline,
476
               boot_device, RAM_size, kernel_size, graphic_width,
477
               graphic_height, graphic_depth, machine_id);
478
}
479

    
480
static const struct hwdef hwdefs[] = {
481
    /* SS-5 */
482
    {
483
        .iommu_base   = 0x10000000,
484
        .tcx_base     = 0x50000000,
485
        .cs_base      = 0x6c000000,
486
        .slavio_base  = 0x70000000,
487
        .ms_kb_base   = 0x71000000,
488
        .serial_base  = 0x71100000,
489
        .nvram_base   = 0x71200000,
490
        .fd_base      = 0x71400000,
491
        .counter_base = 0x71d00000,
492
        .intctl_base  = 0x71e00000,
493
        .dma_base     = 0x78400000,
494
        .esp_base     = 0x78800000,
495
        .le_base      = 0x78c00000,
496
        .power_base   = 0x7a000000,
497
        .vram_size    = 0x00100000,
498
        .nvram_size   = 0x2000,
499
        .esp_irq = 18,
500
        .le_irq = 16,
501
        .clock_irq = 7,
502
        .clock1_irq = 19,
503
        .ms_kb_irq = 14,
504
        .ser_irq = 15,
505
        .fd_irq = 22,
506
        .me_irq = 30,
507
        .cs_irq = 5,
508
        .machine_id = 0x80,
509
        .intbit_to_level = {
510
            2, 3, 5, 7, 9, 11, 0, 14,        3, 5, 7, 9, 11, 13, 12, 12,
511
            6, 0, 4, 10, 8, 0, 11, 0,        0, 0, 0, 0, 15, 0, 15, 0,
512
        },
513
    },
514
    /* SS-10 */
515
    {
516
        .iommu_base   = 0xfe0000000ULL,
517
        .tcx_base     = 0xe20000000ULL,
518
        .cs_base      = -1,
519
        .slavio_base  = 0xff0000000ULL,
520
        .ms_kb_base   = 0xff1000000ULL,
521
        .serial_base  = 0xff1100000ULL,
522
        .nvram_base   = 0xff1200000ULL,
523
        .fd_base      = 0xff1700000ULL,
524
        .counter_base = 0xff1300000ULL,
525
        .intctl_base  = 0xff1400000ULL,
526
        .dma_base     = 0xef0400000ULL,
527
        .esp_base     = 0xef0800000ULL,
528
        .le_base      = 0xef0c00000ULL,
529
        .power_base   = 0xefa000000ULL,
530
        .vram_size    = 0x00100000,
531
        .nvram_size   = 0x2000,
532
        .esp_irq = 18,
533
        .le_irq = 16,
534
        .clock_irq = 7,
535
        .clock1_irq = 19,
536
        .ms_kb_irq = 14,
537
        .ser_irq = 15,
538
        .fd_irq = 22,
539
        .me_irq = 30,
540
        .cs_irq = -1,
541
        .machine_id = 0x72,
542
        .intbit_to_level = {
543
            2, 3, 5, 7, 9, 11, 0, 14,        3, 5, 7, 9, 11, 13, 12, 12,
544
            6, 0, 4, 10, 8, 0, 11, 0,        0, 0, 0, 0, 15, 0, 15, 0,
545
        },
546
    },
547
};
548

    
549
static void sun4m_common_init(int RAM_size, int boot_device, DisplayState *ds,
550
                              const char *kernel_filename, const char *kernel_cmdline,
551
                              const char *initrd_filename, const char *cpu_model,
552
                              unsigned int machine, int max_ram)
553
{
554
    void *nvram;
555

    
556
    if ((unsigned int)RAM_size > (unsigned int)max_ram) {
557
        fprintf(stderr, "qemu: Too much memory for this machine: %d, maximum %d\n",
558
                (unsigned int)RAM_size / (1024 * 1024),
559
                (unsigned int)max_ram / (1024 * 1024));
560
        exit(1);
561
    }
562
    nvram = sun4m_hw_init(&hwdefs[machine], RAM_size, ds, cpu_model);
563

    
564
    sun4m_load_kernel(hwdefs[machine].vram_size, RAM_size, boot_device,
565
                      kernel_filename, kernel_cmdline, initrd_filename,
566
                      hwdefs[machine].machine_id, nvram);
567
}
568

    
569
/* SPARCstation 5 hardware initialisation */
570
static void ss5_init(int RAM_size, int vga_ram_size, int boot_device,
571
                       DisplayState *ds, const char **fd_filename, int snapshot,
572
                       const char *kernel_filename, const char *kernel_cmdline,
573
                       const char *initrd_filename, const char *cpu_model)
574
{
575
    if (cpu_model == NULL)
576
        cpu_model = "Fujitsu MB86904";
577
    sun4m_common_init(RAM_size, boot_device, ds, kernel_filename,
578
                      kernel_cmdline, initrd_filename, cpu_model,
579
                      0, 0x10000000);
580
}
581

    
582
/* SPARCstation 10 hardware initialisation */
583
static void ss10_init(int RAM_size, int vga_ram_size, int boot_device,
584
                            DisplayState *ds, const char **fd_filename, int snapshot,
585
                            const char *kernel_filename, const char *kernel_cmdline,
586
                            const char *initrd_filename, const char *cpu_model)
587
{
588
    if (cpu_model == NULL)
589
        cpu_model = "TI SuperSparc II";
590
    sun4m_common_init(RAM_size, boot_device, ds, kernel_filename,
591
                      kernel_cmdline, initrd_filename, cpu_model,
592
                      1, 0xffffffff); // XXX actually first 62GB ok
593
}
594

    
595
QEMUMachine ss5_machine = {
596
    "SS-5",
597
    "Sun4m platform, SPARCstation 5",
598
    ss5_init,
599
};
600

    
601
QEMUMachine ss10_machine = {
602
    "SS-10",
603
    "Sun4m platform, SPARCstation 10",
604
    ss10_init,
605
};