Blame view

hw/pc.c 32.3 KB
1
2
/*
 * QEMU PC System Emulator
3
 *
4
 * Copyright (c) 2003-2004 Fabrice Bellard
5
 *
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
pbrook authored
24
25
26
27
28
29
30
31
32
33
#include "hw.h"
#include "pc.h"
#include "fdc.h"
#include "pci.h"
#include "block.h"
#include "sysemu.h"
#include "audio/audio.h"
#include "net.h"
#include "smbus.h"
#include "boards.h"
aurel32 authored
34
#include "console.h"
35
#include "fw_cfg.h"
aliguori authored
36
#include "virtio-blk.h"
aliguori authored
37
#include "virtio-balloon.h"
38
bellard authored
39
40
41
/* output Bochs bios info messages */
//#define DEBUG_BIOS
42
43
#define BIOS_FILENAME "bios.bin"
#define VGABIOS_FILENAME "vgabios.bin"
44
#define VGABIOS_CIRRUS_FILENAME "vgabios-cirrus.bin"
45
46
47
#define PC_MAX_BIOS_SIZE (4 * 1024 * 1024)
48
49
/* Leave a chunk of memory at the top of RAM for the BIOS ACPI tables.  */
#define ACPI_DATA_SIZE       0x10000
50
#define BIOS_CFG_IOPORT 0x510
51
52
53
#define MAX_IDE_BUS 2
54
static fdctrl_t *floppy_controller;
bellard authored
55
static RTCState *rtc_state;
bellard authored
56
static PITState *pit;
57
static IOAPICState *ioapic;
bellard authored
58
static PCIDevice *i440fx_state;
59
bellard authored
60
static void ioport80_write(void *opaque, uint32_t addr, uint32_t data)
61
62
63
{
}
64
/* MSDOS compatibility mode FPU exception support */
pbrook authored
65
static qemu_irq ferr_irq;
66
67
68
/* XXX: add IGNNE support */
void cpu_set_ferr(CPUX86State *s)
{
pbrook authored
69
    qemu_irq_raise(ferr_irq);
70
71
72
73
}

static void ioportF0_write(void *opaque, uint32_t addr, uint32_t data)
{
pbrook authored
74
    qemu_irq_lower(ferr_irq);
75
76
}
bellard authored
77
78
79
/* TSC handling */
uint64_t cpu_get_tsc(CPUX86State *env)
{
80
81
82
    /* Note: when using kqemu, it is more logical to return the host TSC
       because kqemu does not trap the RDTSC instruction for
       performance reasons */
83
#ifdef USE_KQEMU
84
85
    if (env->kqemu_enabled) {
        return cpu_get_real_ticks();
86
    } else
87
88
89
90
#endif
    {
        return cpu_get_ticks();
    }
bellard authored
91
92
}
bellard authored
93
94
95
96
97
98
99
100
/* SMM support */
void cpu_smm_update(CPUState *env)
{
    if (i440fx_state && env == first_cpu)
        i440fx_set_smm(i440fx_state, (env->hflags >> HF_SMM_SHIFT) & 1);
}
bellard authored
101
102
103
104
105
106
107
108
109
/* IRQ handling */
int cpu_get_pic_interrupt(CPUState *env)
{
    int intno;

    intno = apic_get_interrupt(env);
    if (intno >= 0) {
        /* set irq request if a PIC irq is still pending */
        /* XXX: improve that */
110
        pic_update_irq(isa_pic);
bellard authored
111
112
113
        return intno;
    }
    /* read the irq from the PIC */
114
115
116
    if (!apic_accept_pic_intr(env))
        return -1;
bellard authored
117
118
119
120
    intno = pic_read_irq(isa_pic);
    return intno;
}
pbrook authored
121
static void pic_irq_request(void *opaque, int irq, int level)
bellard authored
122
{
123
124
    CPUState *env = first_cpu;
aurel32 authored
125
126
127
    if (env->apic_state) {
        while (env) {
            if (apic_accept_pic_intr(env))
128
                apic_deliver_pic_intr(env, level);
aurel32 authored
129
130
131
            env = env->next_cpu;
        }
    } else {
132
133
134
135
        if (level)
            cpu_interrupt(env, CPU_INTERRUPT_HARD);
        else
            cpu_reset_interrupt(env, CPU_INTERRUPT_HARD);
136
    }
bellard authored
137
138
}
bellard authored
139
140
/* PC cmos mappings */
141
142
#define REG_EQUIPMENT_BYTE          0x14
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
static int cmos_get_fd_drive_type(int fd0)
{
    int val;

    switch (fd0) {
    case 0:
        /* 1.44 Mb 3"5 drive */
        val = 4;
        break;
    case 1:
        /* 2.88 Mb 3"5 drive */
        val = 5;
        break;
    case 2:
        /* 1.2 Mb 5"5 drive */
        val = 2;
        break;
    default:
        val = 0;
        break;
    }
    return val;
}
167
static void cmos_init_hd(int type_ofs, int info_ofs, BlockDriverState *hd)
bellard authored
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
{
    RTCState *s = rtc_state;
    int cylinders, heads, sectors;
    bdrv_get_geometry_hint(hd, &cylinders, &heads, &sectors);
    rtc_set_memory(s, type_ofs, 47);
    rtc_set_memory(s, info_ofs, cylinders);
    rtc_set_memory(s, info_ofs + 1, cylinders >> 8);
    rtc_set_memory(s, info_ofs + 2, heads);
    rtc_set_memory(s, info_ofs + 3, 0xff);
    rtc_set_memory(s, info_ofs + 4, 0xff);
    rtc_set_memory(s, info_ofs + 5, 0xc0 | ((heads > 8) << 3));
    rtc_set_memory(s, info_ofs + 6, cylinders);
    rtc_set_memory(s, info_ofs + 7, cylinders >> 8);
    rtc_set_memory(s, info_ofs + 8, sectors);
}
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
/* convert boot_device letter to something recognizable by the bios */
static int boot_device2nibble(char boot_device)
{
    switch(boot_device) {
    case 'a':
    case 'b':
        return 0x01; /* floppy boot */
    case 'c':
        return 0x02; /* hard drive boot */
    case 'd':
        return 0x03; /* CD-ROM boot */
    case 'n':
        return 0x04; /* Network boot */
    }
    return 0;
}
201
202
/* copy/pasted from cmos_init, should be made a general function
 and used there as well */
203
static int pc_boot_set(void *opaque, const char *boot_device)
204
205
{
#define PC_MAX_BOOT_DEVICES 3
206
    RTCState *s = (RTCState *)opaque;
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
    int nbds, bds[3] = { 0, };
    int i;

    nbds = strlen(boot_device);
    if (nbds > PC_MAX_BOOT_DEVICES) {
        term_printf("Too many boot devices for PC\n");
        return(1);
    }
    for (i = 0; i < nbds; i++) {
        bds[i] = boot_device2nibble(boot_device[i]);
        if (bds[i] == 0) {
            term_printf("Invalid boot device for PC: '%c'\n",
                    boot_device[i]);
            return(1);
        }
    }
    rtc_set_memory(s, 0x3d, (bds[1] << 4) | bds[0]);
    rtc_set_memory(s, 0x38, (bds[2] << 4));
    return(0);
}
bellard authored
228
/* hd_table must contain 4 block drivers */
229
230
static void cmos_init(ram_addr_t ram_size, ram_addr_t above_4g_mem_size,
                      const char *boot_device, BlockDriverState **hd_table)
231
{
bellard authored
232
    RTCState *s = rtc_state;
233
    int nbds, bds[3] = { 0, };
234
    int val;
bellard authored
235
    int fd0, fd1, nb;
bellard authored
236
    int i;
bellard authored
237
238

    /* various important CMOS locations needed by PC/Bochs bios */
239
240

    /* memory size */
bellard authored
241
242
243
244
    val = 640; /* base memory in K */
    rtc_set_memory(s, 0x15, val);
    rtc_set_memory(s, 0x16, val >> 8);
245
246
247
    val = (ram_size / 1024) - 1024;
    if (val > 65535)
        val = 65535;
bellard authored
248
249
250
251
    rtc_set_memory(s, 0x17, val);
    rtc_set_memory(s, 0x18, val >> 8);
    rtc_set_memory(s, 0x30, val);
    rtc_set_memory(s, 0x31, val >> 8);
252
253
254
255
256
257
258
    if (above_4g_mem_size) {
        rtc_set_memory(s, 0x5b, (unsigned int)above_4g_mem_size >> 16);
        rtc_set_memory(s, 0x5c, (unsigned int)above_4g_mem_size >> 24);
        rtc_set_memory(s, 0x5d, (uint64_t)above_4g_mem_size >> 32);
    }
bellard authored
259
260
261
262
    if (ram_size > (16 * 1024 * 1024))
        val = (ram_size / 65536) - ((16 * 1024 * 1024) / 65536);
    else
        val = 0;
263
264
    if (val > 65535)
        val = 65535;
bellard authored
265
266
    rtc_set_memory(s, 0x34, val);
    rtc_set_memory(s, 0x35, val >> 8);
267
268
269
270
    /* set the number of CPU */
    rtc_set_memory(s, 0x5f, smp_cpus - 1);
271
    /* set boot devices, and disable floppy signature check if requested */
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
#define PC_MAX_BOOT_DEVICES 3
    nbds = strlen(boot_device);
    if (nbds > PC_MAX_BOOT_DEVICES) {
        fprintf(stderr, "Too many boot devices for PC\n");
        exit(1);
    }
    for (i = 0; i < nbds; i++) {
        bds[i] = boot_device2nibble(boot_device[i]);
        if (bds[i] == 0) {
            fprintf(stderr, "Invalid boot device for PC: '%c'\n",
                    boot_device[i]);
            exit(1);
        }
    }
    rtc_set_memory(s, 0x3d, (bds[1] << 4) | bds[0]);
    rtc_set_memory(s, 0x38, (bds[2] << 4) | (fd_bootchk ?  0x0 : 0x1));
288
bellard authored
289
290
    /* floppy type */
291
292
    fd0 = fdctrl_get_drive_type(floppy_controller, 0);
    fd1 = fdctrl_get_drive_type(floppy_controller, 1);
293
294
    val = (cmos_get_fd_drive_type(fd0) << 4) | cmos_get_fd_drive_type(fd1);
bellard authored
295
    rtc_set_memory(s, 0x10, val);
296
bellard authored
297
    val = 0;
bellard authored
298
    nb = 0;
299
300
301
302
303
304
305
306
    if (fd0 < 3)
        nb++;
    if (fd1 < 3)
        nb++;
    switch (nb) {
    case 0:
        break;
    case 1:
bellard authored
307
        val |= 0x01; /* 1 drive, ready for boot */
308
309
        break;
    case 2:
bellard authored
310
        val |= 0x41; /* 2 drives, ready for boot */
311
312
        break;
    }
bellard authored
313
314
315
316
    val |= 0x02; /* FPU is there */
    val |= 0x04; /* PS/2 mouse installed */
    rtc_set_memory(s, REG_EQUIPMENT_BYTE, val);
bellard authored
317
318
319
320
321
    /* hard drives */

    rtc_set_memory(s, 0x12, (hd_table[0] ? 0xf0 : 0) | (hd_table[1] ? 0x0f : 0));
    if (hd_table[0])
        cmos_init_hd(0x19, 0x1b, hd_table[0]);
322
    if (hd_table[1])
bellard authored
323
324
325
        cmos_init_hd(0x1a, 0x24, hd_table[1]);

    val = 0;
326
    for (i = 0; i < 4; i++) {
bellard authored
327
        if (hd_table[i]) {
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
            int cylinders, heads, sectors, translation;
            /* NOTE: bdrv_get_geometry_hint() returns the physical
                geometry.  It is always such that: 1 <= sects <= 63, 1
                <= heads <= 16, 1 <= cylinders <= 16383. The BIOS
                geometry can be different if a translation is done. */
            translation = bdrv_get_translation_hint(hd_table[i]);
            if (translation == BIOS_ATA_TRANSLATION_AUTO) {
                bdrv_get_geometry_hint(hd_table[i], &cylinders, &heads, &sectors);
                if (cylinders <= 1024 && heads <= 16 && sectors <= 63) {
                    /* No translation. */
                    translation = 0;
                } else {
                    /* LBA translation. */
                    translation = 1;
                }
343
            } else {
344
                translation--;
bellard authored
345
346
347
            }
            val |= translation << (i * 2);
        }
348
    }
bellard authored
349
    rtc_set_memory(s, 0x39, val);
350
351
}
352
353
354
355
356
357
358
359
360
361
362
void ioport_set_a20(int enable)
{
    /* XXX: send to all CPUs ? */
    cpu_x86_set_a20(first_cpu, enable);
}

int ioport_get_a20(void)
{
    return ((first_cpu->a20_mask >> 20) & 1);
}
bellard authored
363
364
static void ioport92_write(void *opaque, uint32_t addr, uint32_t val)
{
365
    ioport_set_a20((val >> 1) & 1);
bellard authored
366
367
368
369
370
    /* XXX: bit 0 is fast reset */
}

static uint32_t ioport92_read(void *opaque, uint32_t addr)
{
371
    return ioport_get_a20() << 1;
bellard authored
372
373
}
374
375
376
/***********************************************************/
/* Bochs BIOS debug ports */
377
static void bochs_bios_write(void *opaque, uint32_t addr, uint32_t val)
378
{
379
380
    static const char shutdown_str[8] = "Shutdown";
    static int shutdown_index = 0;
381
382
383
384
385
386
387
388
389
390
391
392
393
    switch(addr) {
        /* Bochs BIOS messages */
    case 0x400:
    case 0x401:
        fprintf(stderr, "BIOS panic at rombios.c, line %d\n", val);
        exit(1);
    case 0x402:
    case 0x403:
#ifdef DEBUG_BIOS
        fprintf(stderr, "%c", val);
#endif
        break;
394
395
396
397
398
399
400
401
402
403
404
405
    case 0x8900:
        /* same as Bochs power off */
        if (val == shutdown_str[shutdown_index]) {
            shutdown_index++;
            if (shutdown_index == 8) {
                shutdown_index = 0;
                qemu_system_shutdown_request();
            }
        } else {
            shutdown_index = 0;
        }
        break;
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420

        /* LGPL'ed VGA BIOS messages */
    case 0x501:
    case 0x502:
        fprintf(stderr, "VGA BIOS panic, line %d\n", val);
        exit(1);
    case 0x500:
    case 0x503:
#ifdef DEBUG_BIOS
        fprintf(stderr, "%c", val);
#endif
        break;
    }
}
421
static void bochs_bios_init(void)
422
{
423
424
    void *fw_cfg;
bellard authored
425
426
427
428
    register_ioport_write(0x400, 1, 2, bochs_bios_write, NULL);
    register_ioport_write(0x401, 1, 2, bochs_bios_write, NULL);
    register_ioport_write(0x402, 1, 1, bochs_bios_write, NULL);
    register_ioport_write(0x403, 1, 1, bochs_bios_write, NULL);
429
    register_ioport_write(0x8900, 1, 1, bochs_bios_write, NULL);
bellard authored
430
431
432
433
434

    register_ioport_write(0x501, 1, 2, bochs_bios_write, NULL);
    register_ioport_write(0x502, 1, 2, bochs_bios_write, NULL);
    register_ioport_write(0x500, 1, 1, bochs_bios_write, NULL);
    register_ioport_write(0x503, 1, 1, bochs_bios_write, NULL);
435
436
437

    fw_cfg = fw_cfg_init(BIOS_CFG_IOPORT, BIOS_CFG_IOPORT + 1, 0, 0);
    fw_cfg_add_i32(fw_cfg, FW_CFG_ID, 1);
438
    fw_cfg_add_i64(fw_cfg, FW_CFG_RAM_SIZE, (uint64_t)ram_size);
439
440
}
441
442
/* Generate an initial boot sector which sets state and jump to
   a specified vector */
443
444
static void generate_bootsect(uint8_t *option_rom,
                              uint32_t gpr[8], uint16_t segs[6], uint16_t ip)
445
{
446
447
    uint8_t rom[512], *p, *reloc;
    uint8_t sum;
448
449
    int i;
450
451
452
453
454
455
    memset(rom, 0, sizeof(rom));

    p = rom;
    /* Make sure we have an option rom signature */
    *p++ = 0x55;
    *p++ = 0xaa;
456
457
458
    /* ROM size in sectors*/
    *p++ = 1;
459
460
    /* Hook int19 */
461
462
463
464
465
    *p++ = 0x50;		/* push ax */
    *p++ = 0x1e;		/* push ds */
    *p++ = 0x31; *p++ = 0xc0;	/* xor ax, ax */
    *p++ = 0x8e; *p++ = 0xd8;	/* mov ax, ds */
466
467
468
469
470
471
472
473
474
475
476
477
478
    *p++ = 0xc7; *p++ = 0x06;   /* movvw _start,0x64 */
    *p++ = 0x64; *p++ = 0x00;
    reloc = p;
    *p++ = 0x00; *p++ = 0x00;

    *p++ = 0x8c; *p++ = 0x0e;   /* mov cs,0x66 */
    *p++ = 0x66; *p++ = 0x00;

    *p++ = 0x1f;		/* pop ds */
    *p++ = 0x58;		/* pop ax */
    *p++ = 0xcb;		/* lret */
479
    /* Actual code */
480
481
    *reloc = (p - rom);
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
    *p++ = 0xfa;		/* CLI */
    *p++ = 0xfc;		/* CLD */

    for (i = 0; i < 6; i++) {
	if (i == 1)		/* Skip CS */
	    continue;

	*p++ = 0xb8;		/* MOV AX,imm16 */
	*p++ = segs[i];
	*p++ = segs[i] >> 8;
	*p++ = 0x8e;		/* MOV <seg>,AX */
	*p++ = 0xc0 + (i << 3);
    }

    for (i = 0; i < 8; i++) {
	*p++ = 0x66;		/* 32-bit operand size */
	*p++ = 0xb8 + i;	/* MOV <reg>,imm32 */
	*p++ = gpr[i];
	*p++ = gpr[i] >> 8;
	*p++ = gpr[i] >> 16;
	*p++ = gpr[i] >> 24;
    }

    *p++ = 0xea;		/* JMP FAR */
    *p++ = ip;			/* IP */
    *p++ = ip >> 8;
    *p++ = segs[1];		/* CS */
    *p++ = segs[1] >> 8;
511
512
513
514
515
516
517
    /* sign rom */
    sum = 0;
    for (i = 0; i < (sizeof(rom) - 1); i++)
        sum += rom[i];
    rom[sizeof(rom) - 1] = -sum;

    memcpy(option_rom, rom, sizeof(rom));
518
}
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
static long get_file_size(FILE *f)
{
    long where, size;

    /* XXX: on Unix systems, using fstat() probably makes more sense */

    where = ftell(f);
    fseek(f, 0, SEEK_END);
    size = ftell(f);
    fseek(f, where, SEEK_SET);

    return size;
}
534
535
static void load_linux(uint8_t *option_rom,
                       const char *kernel_filename,
536
537
538
539
540
541
542
543
544
545
		       const char *initrd_filename,
		       const char *kernel_cmdline)
{
    uint16_t protocol;
    uint32_t gpr[8];
    uint16_t seg[6];
    uint16_t real_seg;
    int setup_size, kernel_size, initrd_size, cmdline_size;
    uint32_t initrd_max;
    uint8_t header[1024];
546
    target_phys_addr_t real_addr, prot_addr, cmdline_addr, initrd_addr;
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
    FILE *f, *fi;

    /* Align to 16 bytes as a paranoia measure */
    cmdline_size = (strlen(kernel_cmdline)+16) & ~15;

    /* load the kernel header */
    f = fopen(kernel_filename, "rb");
    if (!f || !(kernel_size = get_file_size(f)) ||
	fread(header, 1, 1024, f) != 1024) {
	fprintf(stderr, "qemu: could not load kernel '%s'\n",
		kernel_filename);
	exit(1);
    }

    /* kernel protocol version */
bellard authored
562
#if 0
563
    fprintf(stderr, "header magic: %#x\n", ldl_p(header+0x202));
bellard authored
564
#endif
565
566
567
568
569
570
571
    if (ldl_p(header+0x202) == 0x53726448)
	protocol = lduw_p(header+0x206);
    else
	protocol = 0;

    if (protocol < 0x200 || !(header[0x211] & 0x01)) {
	/* Low kernel */
572
573
574
	real_addr    = 0x90000;
	cmdline_addr = 0x9a000 - cmdline_size;
	prot_addr    = 0x10000;
575
576
    } else if (protocol < 0x202) {
	/* High but ancient kernel */
577
578
579
	real_addr    = 0x90000;
	cmdline_addr = 0x9a000 - cmdline_size;
	prot_addr    = 0x100000;
580
581
    } else {
	/* High and recent kernel */
582
583
584
	real_addr    = 0x10000;
	cmdline_addr = 0x20000;
	prot_addr    = 0x100000;
585
586
    }
bellard authored
587
#if 0
588
    fprintf(stderr,
589
590
591
	    "qemu: real_addr     = 0x" TARGET_FMT_plx "\n"
	    "qemu: cmdline_addr  = 0x" TARGET_FMT_plx "\n"
	    "qemu: prot_addr     = 0x" TARGET_FMT_plx "\n",
592
593
594
	    real_addr,
	    cmdline_addr,
	    prot_addr);
bellard authored
595
#endif
596
597
598
599
600
601
602
603
604
605
606

    /* highest address for loading the initrd */
    if (protocol >= 0x203)
	initrd_max = ldl_p(header+0x22c);
    else
	initrd_max = 0x37ffffff;

    if (initrd_max >= ram_size-ACPI_DATA_SIZE)
	initrd_max = ram_size-ACPI_DATA_SIZE-1;

    /* kernel command line */
607
    pstrcpy_targphys(cmdline_addr, 4096, kernel_cmdline);
608
609

    if (protocol >= 0x202) {
610
	stl_p(header+0x228, cmdline_addr);
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
    } else {
	stw_p(header+0x20, 0xA33F);
	stw_p(header+0x22, cmdline_addr-real_addr);
    }

    /* loader type */
    /* High nybble = B reserved for Qemu; low nybble is revision number.
       If this code is substantially changed, you may want to consider
       incrementing the revision. */
    if (protocol >= 0x200)
	header[0x210] = 0xB0;

    /* heap */
    if (protocol >= 0x201) {
	header[0x211] |= 0x80;	/* CAN_USE_HEAP */
	stw_p(header+0x224, cmdline_addr-real_addr-0x200);
    }

    /* load initrd */
    if (initrd_filename) {
	if (protocol < 0x200) {
	    fprintf(stderr, "qemu: linux kernel too old to load a ram disk\n");
	    exit(1);
	}

	fi = fopen(initrd_filename, "rb");
	if (!fi) {
	    fprintf(stderr, "qemu: could not load initial ram disk '%s'\n",
		    initrd_filename);
	    exit(1);
	}

	initrd_size = get_file_size(fi);
644
	initrd_addr = (initrd_max-initrd_size) & ~4095;
645
646
647
        fprintf(stderr, "qemu: loading initrd (%#x bytes) at 0x" TARGET_FMT_plx
                "\n", initrd_size, initrd_addr);
648
649
	if (!fread_targphys_ok(initrd_addr, initrd_size, fi)) {
650
651
652
653
654
655
	    fprintf(stderr, "qemu: read error on initial ram disk '%s'\n",
		    initrd_filename);
	    exit(1);
	}
	fclose(fi);
656
	stl_p(header+0x218, initrd_addr);
657
658
659
660
	stl_p(header+0x21c, initrd_size);
    }

    /* store the finalized header and load the rest of the kernel */
661
    cpu_physical_memory_write(real_addr, header, 1024);
662
663
664
665
666
667
668
669

    setup_size = header[0x1f1];
    if (setup_size == 0)
	setup_size = 4;

    setup_size = (setup_size+1)*512;
    kernel_size -= setup_size;	/* Size of protected-mode code */
670
671
    if (!fread_targphys_ok(real_addr+1024, setup_size-1024, f) ||
	!fread_targphys_ok(prot_addr, kernel_size, f)) {
672
673
674
675
676
677
678
	fprintf(stderr, "qemu: read error on kernel '%s'\n",
		kernel_filename);
	exit(1);
    }
    fclose(f);

    /* generate bootsector to set up the initial register state */
679
    real_seg = real_addr >> 4;
680
681
682
683
684
    seg[0] = seg[2] = seg[3] = seg[4] = seg[4] = real_seg;
    seg[1] = real_seg+0x20;	/* CS */
    memset(gpr, 0, sizeof gpr);
    gpr[4] = cmdline_addr-real_addr-16;	/* SP (-16 is paranoia) */
685
    generate_bootsect(option_rom, gpr, seg, 0);
686
687
}
688
689
690
691
692
693
static void main_cpu_reset(void *opaque)
{
    CPUState *env = opaque;
    cpu_reset(env);
}
bellard authored
694
695
696
697
698
699
static const int ide_iobase[2] = { 0x1f0, 0x170 };
static const int ide_iobase2[2] = { 0x3f6, 0x376 };
static const int ide_irq[2] = { 14, 15 };

#define NE2000_NB_MAX 6
700
static int ne2000_io[NE2000_NB_MAX] = { 0x300, 0x320, 0x340, 0x360, 0x280, 0x380 };
bellard authored
701
702
static int ne2000_irq[NE2000_NB_MAX] = { 9, 10, 11, 3, 4, 5 };
703
704
705
static int serial_io[MAX_SERIAL_PORTS] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8 };
static int serial_irq[MAX_SERIAL_PORTS] = { 4, 3, 4, 3 };
706
707
708
static int parallel_io[MAX_PARALLEL_PORTS] = { 0x378, 0x278, 0x3bc };
static int parallel_irq[MAX_PARALLEL_PORTS] = { 7, 7, 7 };
709
#ifdef HAS_AUDIO
pbrook authored
710
static void audio_init (PCIBus *pci_bus, qemu_irq *pic)
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
{
    struct soundhw *c;
    int audio_enabled = 0;

    for (c = soundhw; !audio_enabled && c->name; ++c) {
        audio_enabled = c->enabled;
    }

    if (audio_enabled) {
        AudioState *s;

        s = AUD_init ();
        if (s) {
            for (c = soundhw; c->name; ++c) {
                if (c->enabled) {
                    if (c->isa) {
pbrook authored
727
                        c->init.init_isa (s, pic);
728
729
730
731
732
733
734
735
736
737
738
739
740
                    }
                    else {
                        if (pci_bus) {
                            c->init.init_pci (pci_bus, s);
                        }
                    }
                }
            }
        }
    }
}
#endif
pbrook authored
741
static void pc_init_ne2k_isa(NICInfo *nd, qemu_irq *pic)
742
743
744
745
746
{
    static int nb_ne2k = 0;

    if (nb_ne2k == NE2000_NB_MAX)
        return;
pbrook authored
747
    isa_ne2000_init(ne2000_io[nb_ne2k], pic[ne2000_irq[nb_ne2k]], nd);
748
749
750
    nb_ne2k++;
}
751
/* PC hardware initialisation */
752
static void pc_init1(ram_addr_t ram_size, int vga_ram_size,
753
                     const char *boot_device, DisplayState *ds,
bellard authored
754
                     const char *kernel_filename, const char *kernel_cmdline,
755
                     const char *initrd_filename,
756
                     int pci_enabled, const char *cpu_model)
757
758
{
    char buf[1024];
759
    int ret, linux_boot, i;
bellard authored
760
    ram_addr_t ram_addr, vga_ram_addr, bios_offset, vga_bios_offset;
761
    ram_addr_t below_4g_mem_size, above_4g_mem_size = 0;
bellard authored
762
    int bios_size, isa_bios_size, vga_bios_size;
bellard authored
763
    PCIBus *pci_bus;
pbrook authored
764
    int piix3_devfn = -1;
765
    CPUState *env;
766
    NICInfo *nd;
pbrook authored
767
768
    qemu_irq *cpu_irq;
    qemu_irq *i8259;
769
770
771
    int index;
    BlockDriverState *hd[MAX_IDE_BUS * MAX_IDE_DEVS];
    BlockDriverState *fd[MAX_FD];
772
773
774
775
776
777
778
779
    if (ram_size >= 0xe0000000 ) {
        above_4g_mem_size = ram_size - 0xe0000000;
        below_4g_mem_size = 0xe0000000;
    } else {
        below_4g_mem_size = ram_size;
    }
780
781
    linux_boot = (kernel_filename != NULL);
782
    /* init CPUs */
783
784
785
786
787
788
789
790
    if (cpu_model == NULL) {
#ifdef TARGET_X86_64
        cpu_model = "qemu64";
#else
        cpu_model = "qemu32";
#endif
    }
791
    for(i = 0; i < smp_cpus; i++) {
792
793
794
795
796
        env = cpu_init(cpu_model);
        if (!env) {
            fprintf(stderr, "Unable to find x86 CPU definition\n");
            exit(1);
        }
797
        if (i != 0)
798
            env->halted = 1;
799
800
801
802
803
804
805
806
807
808
        if (smp_cpus > 1) {
            /* XXX: enable it in all cases */
            env->cpuid_features |= CPUID_APIC;
        }
        qemu_register_reset(main_cpu_reset, env);
        if (pci_enabled) {
            apic_init(env);
        }
    }
aurel32 authored
809
810
    vmport_init();
811
    /* allocate RAM */
812
813
814
815
816
817
818
819
820
821
822
823
    ram_addr = qemu_ram_alloc(0xa0000);
    cpu_register_physical_memory(0, 0xa0000, ram_addr);

    /* Allocate, even though we won't register, so we don't break the
     * phys_ram_base + PA assumption. This range includes vga (0xa0000 - 0xc0000),
     * and some bios areas, which will be registered later
     */
    ram_addr = qemu_ram_alloc(0x100000 - 0xa0000);
    ram_addr = qemu_ram_alloc(below_4g_mem_size - 0x100000);
    cpu_register_physical_memory(0x100000,
                 below_4g_mem_size - 0x100000,
                 ram_addr);
824
825
826

    /* above 4giga memory allocation */
    if (above_4g_mem_size > 0) {
827
828
        ram_addr = qemu_ram_alloc(above_4g_mem_size);
        cpu_register_physical_memory(0x100000000ULL,
829
                                     above_4g_mem_size,
830
                                     ram_addr);
831
    }
832
833
bellard authored
834
835
    /* allocate VGA RAM */
    vga_ram_addr = qemu_ram_alloc(vga_ram_size);
bellard authored
836
bellard authored
837
    /* BIOS load */
838
839
840
    if (bios_name == NULL)
        bios_name = BIOS_FILENAME;
    snprintf(buf, sizeof(buf), "%s/%s", bios_dir, bios_name);
bellard authored
841
    bios_size = get_image_size(buf);
842
    if (bios_size <= 0 ||
bellard authored
843
        (bios_size % 65536) != 0) {
bellard authored
844
845
        goto bios_error;
    }
bellard authored
846
    bios_offset = qemu_ram_alloc(bios_size);
bellard authored
847
848
849
    ret = load_image(buf, phys_ram_base + bios_offset);
    if (ret != bios_size) {
    bios_error:
bellard authored
850
        fprintf(stderr, "qemu: could not load PC BIOS '%s'\n", buf);
851
852
        exit(1);
    }
bellard authored
853
854
    /* VGA BIOS load */
855
856
857
858
859
    if (cirrus_vga_enabled) {
        snprintf(buf, sizeof(buf), "%s/%s", bios_dir, VGABIOS_CIRRUS_FILENAME);
    } else {
        snprintf(buf, sizeof(buf), "%s/%s", bios_dir, VGABIOS_FILENAME);
    }
bellard authored
860
    vga_bios_size = get_image_size(buf);
861
    if (vga_bios_size <= 0 || vga_bios_size > 65536)
bellard authored
862
863
864
        goto vga_bios_error;
    vga_bios_offset = qemu_ram_alloc(65536);
bellard authored
865
    ret = load_image(buf, phys_ram_base + vga_bios_offset);
bellard authored
866
867
868
869
870
871
    if (ret != vga_bios_size) {
    vga_bios_error:
        fprintf(stderr, "qemu: could not load VGA BIOS '%s'\n", buf);
        exit(1);
    }
872
    /* setup basic memory access */
873
    cpu_register_physical_memory(0xc0000, 0x10000,
bellard authored
874
875
876
877
878
879
                                 vga_bios_offset | IO_MEM_ROM);

    /* map the last 128KB of the BIOS in ISA space */
    isa_bios_size = bios_size;
    if (isa_bios_size > (128 * 1024))
        isa_bios_size = 128 * 1024;
880
881
    cpu_register_physical_memory(0x100000 - isa_bios_size,
                                 isa_bios_size,
bellard authored
882
                                 (bios_offset + bios_size - isa_bios_size) | IO_MEM_ROM);
883
bellard authored
884
885
886
887
888
    {
        ram_addr_t option_rom_offset;
        int size, offset;

        offset = 0;
889
890
891
892
893
894
895
896
897
        if (linux_boot) {
            option_rom_offset = qemu_ram_alloc(TARGET_PAGE_SIZE);
            load_linux(phys_ram_base + option_rom_offset,
                       kernel_filename, initrd_filename, kernel_cmdline);
            cpu_register_physical_memory(0xd0000, TARGET_PAGE_SIZE,
                                         option_rom_offset | IO_MEM_ROM);
            offset = TARGET_PAGE_SIZE;
        }
bellard authored
898
899
900
        for (i = 0; i < nb_option_roms; i++) {
            size = get_image_size(option_rom[i]);
            if (size < 0) {
901
                fprintf(stderr, "Could not load option rom '%s'\n",
bellard authored
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
                        option_rom[i]);
                exit(1);
            }
            if (size > (0x10000 - offset))
                goto option_rom_error;
            option_rom_offset = qemu_ram_alloc(size);
            ret = load_image(option_rom[i], phys_ram_base + option_rom_offset);
            if (ret != size) {
            option_rom_error:
                fprintf(stderr, "Too many option ROMS\n");
                exit(1);
            }
            size = (size + 4095) & ~4095;
            cpu_register_physical_memory(0xd0000 + offset,
                                         size, option_rom_offset | IO_MEM_ROM);
            offset += size;
        }
919
920
    }
bellard authored
921
    /* map all the bios at the top of memory */
922
    cpu_register_physical_memory((uint32_t)(-bios_size),
bellard authored
923
                                 bios_size, bios_offset | IO_MEM_ROM);
924
925
926
    bochs_bios_init();
927
    cpu_irq = qemu_allocate_irqs(pic_irq_request, NULL, 1);
pbrook authored
928
929
930
    i8259 = i8259_init(cpu_irq[0]);
    ferr_irq = i8259[13];
bellard authored
931
    if (pci_enabled) {
pbrook authored
932
        pci_bus = i440fx_init(&i440fx_state, i8259);
933
        piix3_devfn = piix3_init(pci_bus, -1);
bellard authored
934
935
    } else {
        pci_bus = NULL;
bellard authored
936
937
    }
938
    /* init basic PC hardware */
bellard authored
939
    register_ioport_write(0x80, 1, 1, ioport80_write, NULL);
940
941
942
    register_ioport_write(0xf0, 1, 1, ioportF0_write, NULL);
bellard authored
943
944
    if (cirrus_vga_enabled) {
        if (pci_enabled) {
945
946
            pci_cirrus_vga_init(pci_bus,
                                ds, phys_ram_base + vga_ram_addr,
bellard authored
947
                                vga_ram_addr, vga_ram_size);
bellard authored
948
        } else {
949
            isa_cirrus_vga_init(ds, phys_ram_base + vga_ram_addr,
bellard authored
950
                                vga_ram_addr, vga_ram_size);
bellard authored
951
        }
952
953
    } else if (vmsvga_enabled) {
        if (pci_enabled)
954
955
            pci_vmsvga_init(pci_bus, ds, phys_ram_base + vga_ram_addr,
                            vga_ram_addr, vga_ram_size);
956
957
        else
            fprintf(stderr, "%s: vmware_vga: no PCI bus\n", __FUNCTION__);
bellard authored
958
    } else {
bellard authored
959
        if (pci_enabled) {
960
            pci_vga_init(pci_bus, ds, phys_ram_base + vga_ram_addr,
bellard authored
961
                         vga_ram_addr, vga_ram_size, 0, 0);
bellard authored
962
        } else {
963
            isa_vga_init(ds, phys_ram_base + vga_ram_addr,
bellard authored
964
                         vga_ram_addr, vga_ram_size);
bellard authored
965
        }
bellard authored
966
    }
967
pbrook authored
968
    rtc_state = rtc_init(0x70, i8259[8]);
969
970
971
    qemu_register_boot_set(pc_boot_set, rtc_state);
bellard authored
972
973
974
    register_ioport_read(0x92, 1, 1, ioport92_read, NULL);
    register_ioport_write(0x92, 1, 1, ioport92_write, NULL);
975
976
977
    if (pci_enabled) {
        ioapic = ioapic_init();
    }
pbrook authored
978
    pit = pit_init(0x40, i8259[0]);
979
    pcspk_init(pit);
980
981
982
    if (pci_enabled) {
        pic_set_alt_irq_func(isa_pic, ioapic_set_irq, ioapic);
    }
bellard authored
983
984
985
    for(i = 0; i < MAX_SERIAL_PORTS; i++) {
        if (serial_hds[i]) {
986
987
            serial_init(serial_io[i], i8259[serial_irq[i]], 115200,
                        serial_hds[i]);
988
989
        }
    }
bellard authored
990
991
992
    for(i = 0; i < MAX_PARALLEL_PORTS; i++) {
        if (parallel_hds[i]) {
pbrook authored
993
994
            parallel_init(parallel_io[i], i8259[parallel_irq[i]],
                          parallel_hds[i]);
995
996
997
        }
    }
998
999
1000
1001
1002
1003
1004
1005
    for(i = 0; i < nb_nics; i++) {
        nd = &nd_table[i];
        if (!nd->model) {
            if (pci_enabled) {
                nd->model = "ne2k_pci";
            } else {
                nd->model = "ne2k_isa";
            }
bellard authored
1006
        }
1007
        if (strcmp(nd->model, "ne2k_isa") == 0) {
pbrook authored
1008
            pc_init_ne2k_isa(nd, i8259);
1009
        } else if (pci_enabled) {
1010
1011
            if (strcmp(nd->model, "?") == 0)
                fprintf(stderr, "qemu: Supported ISA NICs: ne2k_isa\n");
1012
            pci_nic_init(pci_bus, nd, -1);
1013
1014
1015
        } else if (strcmp(nd->model, "?") == 0) {
            fprintf(stderr, "qemu: Supported ISA NICs: ne2k_isa\n");
            exit(1);
1016
1017
1018
        } else {
            fprintf(stderr, "qemu: Unsupported NIC: %s\n", nd->model);
            exit(1);
bellard authored
1019
        }
1020
    }
bellard authored
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
    if (drive_get_max_bus(IF_IDE) >= MAX_IDE_BUS) {
        fprintf(stderr, "qemu: too many IDE bus\n");
        exit(1);
    }

    for(i = 0; i < MAX_IDE_BUS * MAX_IDE_DEVS; i++) {
        index = drive_get_index(IF_IDE, i / MAX_IDE_DEVS, i % MAX_IDE_DEVS);
	if (index != -1)
	    hd[i] = drives_table[index].bdrv;
	else
	    hd[i] = NULL;
    }
1035
    if (pci_enabled) {
1036
        pci_piix3_ide_init(pci_bus, hd, piix3_devfn + 1, i8259);
1037
    } else {
1038
        for(i = 0; i < MAX_IDE_BUS; i++) {
pbrook authored
1039
            isa_ide_init(ide_iobase[i], ide_iobase2[i], i8259[ide_irq[i]],
1040
	                 hd[MAX_IDE_DEVS * i], hd[MAX_IDE_DEVS * i + 1]);
bellard authored
1041
        }
bellard authored
1042
    }
bellard authored
1043
pbrook authored
1044
    i8042_init(i8259[1], i8259[12], 0x60);
bellard authored
1045
    DMA_init(0);
1046
#ifdef HAS_AUDIO
pbrook authored
1047
    audio_init(pci_enabled ? pci_bus : NULL, i8259);
1048
#endif
1049
1050
1051
1052
1053
1054
1055
1056
1057
    for(i = 0; i < MAX_FD; i++) {
        index = drive_get_index(IF_FLOPPY, 0, i);
	if (index != -1)
	    fd[i] = drives_table[index].bdrv;
	else
	    fd[i] = NULL;
    }
    floppy_controller = fdctrl_init(i8259[6], 2, 0, 0x3f0, fd);
bellard authored
1058
1059
    cmos_init(below_4g_mem_size, above_4g_mem_size, boot_device, hd);
bellard authored
1060
bellard authored
1061
    if (pci_enabled && usb_enabled) {
1062
        usb_uhci_piix3_init(pci_bus, piix3_devfn + 2);
bellard authored
1063
1064
    }
bellard authored
1065
    if (pci_enabled && acpi_enabled) {
1066
        uint8_t *eeprom_buf = qemu_mallocz(8 * 256); /* XXX: make this persistent */
pbrook authored
1067
1068
1069
        i2c_bus *smbus;

        /* TODO: Populate SPD eeprom data.  */
aurel32 authored
1070
        smbus = piix4_pm_init(pci_bus, piix3_devfn + 3, 0xb100, i8259[9]);
1071
        for (i = 0; i < 8; i++) {
pbrook authored
1072
            smbus_eeprom_device_init(smbus, 0x50 + i, eeprom_buf + (i * 256));
1073
        }
bellard authored
1074
    }
1075
bellard authored
1076
1077
1078
    if (i440fx_state) {
        i440fx_init_memory_mappings(i440fx_state);
    }
1079
pbrook authored
1080
    if (pci_enabled) {
1081
1082
	int max_bus;
        int bus, unit;
pbrook authored
1083
        void *scsi;
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
        max_bus = drive_get_max_bus(IF_SCSI);

	for (bus = 0; bus <= max_bus; bus++) {
            scsi = lsi_scsi_init(pci_bus, -1);
            for (unit = 0; unit < LSI_MAX_DEVS; unit++) {
	        index = drive_get_index(IF_SCSI, bus, unit);
		if (index == -1)
		    continue;
		lsi_scsi_attach(scsi, drives_table[index].bdrv, unit);
	    }
        }
pbrook authored
1096
    }
aliguori authored
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108

    /* Add virtio block devices */
    if (pci_enabled) {
        int index;
        int unit_id = 0;

        while ((index = drive_get_index(IF_VIRTIO, 0, unit_id)) != -1) {
            virtio_blk_init(pci_bus, 0x1AF4, 0x1001,
                            drives_table[index].bdrv);
            unit_id++;
        }
    }
aliguori authored
1109
1110
1111
1112

    /* Add virtio balloon device */
    if (pci_enabled)
        virtio_balloon_init(pci_bus);
1113
}
bellard authored
1114
1115
static void pc_init_pci(ram_addr_t ram_size, int vga_ram_size,
1116
                        const char *boot_device, DisplayState *ds,
1117
                        const char *kernel_filename,
1118
                        const char *kernel_cmdline,
1119
1120
                        const char *initrd_filename,
                        const char *cpu_model)
1121
{
1122
    pc_init1(ram_size, vga_ram_size, boot_device, ds,
1123
             kernel_filename, kernel_cmdline,
1124
             initrd_filename, 1, cpu_model);
1125
1126
}
1127
static void pc_init_isa(ram_addr_t ram_size, int vga_ram_size,
1128
                        const char *boot_device, DisplayState *ds,
1129
                        const char *kernel_filename,
1130
                        const char *kernel_cmdline,
1131
1132
                        const char *initrd_filename,
                        const char *cpu_model)
1133
{
1134
    pc_init1(ram_size, vga_ram_size, boot_device, ds,
1135
             kernel_filename, kernel_cmdline,
1136
             initrd_filename, 0, cpu_model);
1137
1138
}
bellard authored
1139
QEMUMachine pc_machine = {
aurel32 authored
1140
1141
1142
1143
    .name = "pc",
    .desc = "Standard PC",
    .init = pc_init_pci,
    .ram_require = VGA_RAM_SIZE + PC_MAX_BIOS_SIZE,
1144
    .max_cpus = 255,
1145
1146
1147
};

QEMUMachine isapc_machine = {
aurel32 authored
1148
1149
1150
1151
    .name = "isapc",
    .desc = "ISA-only PC",
    .init = pc_init_isa,
    .ram_require = VGA_RAM_SIZE + PC_MAX_BIOS_SIZE,
1152
    .max_cpus = 1,
bellard authored
1153
};