pc.c 45.2 KB
Newer Older
bellard's avatar
bellard committed
1
2
/*
 * QEMU PC System Emulator
3
 *
bellard's avatar
bellard committed
4
 * Copyright (c) 2003-2004 Fabrice Bellard
5
 *
bellard's avatar
bellard committed
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's avatar
pbrook committed
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"
aliguori's avatar
aliguori committed
34
#include "monitor.h"
35
#include "fw_cfg.h"
36
#include "hpet_emul.h"
Richard W.M. Jones's avatar
Richard W.M. Jones committed
37
#include "watchdog.h"
38
#include "smbios.h"
bellard's avatar
bellard committed
39

bellard's avatar
bellard committed
40
41
42
/* output Bochs bios info messages */
//#define DEBUG_BIOS

Alexander Graf's avatar
Alexander Graf committed
43
44
45
/* Show multiboot debug output */
//#define DEBUG_MULTIBOOT

bellard's avatar
bellard committed
46
47
#define BIOS_FILENAME "bios.bin"
#define VGABIOS_FILENAME "vgabios.bin"
48
#define VGABIOS_CIRRUS_FILENAME "vgabios-cirrus.bin"
bellard's avatar
bellard committed
49

50
51
#define PC_MAX_BIOS_SIZE (4 * 1024 * 1024)

52
53
/* Leave a chunk of memory at the top of RAM for the BIOS ACPI tables.  */
#define ACPI_DATA_SIZE       0x10000
54
#define BIOS_CFG_IOPORT 0x510
55
#define FW_CFG_ACPI_TABLES (FW_CFG_ARCH_LOCAL + 0)
56
#define FW_CFG_SMBIOS_ENTRIES (FW_CFG_ARCH_LOCAL + 1)
bellard's avatar
bellard committed
57

ths's avatar
ths committed
58
59
#define MAX_IDE_BUS 2

60
static fdctrl_t *floppy_controller;
bellard's avatar
bellard committed
61
static RTCState *rtc_state;
bellard's avatar
bellard committed
62
static PITState *pit;
63
static IOAPICState *ioapic;
bellard's avatar
bellard committed
64
static PCIDevice *i440fx_state;
bellard's avatar
bellard committed
65

66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
typedef struct rom_reset_data {
    uint8_t *data;
    target_phys_addr_t addr;
    unsigned size;
} RomResetData;

static void option_rom_reset(void *_rrd)
{
    RomResetData *rrd = _rrd;

    cpu_physical_memory_write_rom(rrd->addr, rrd->data, rrd->size);
}

static void option_rom_setup_reset(target_phys_addr_t addr, unsigned size)
{
    RomResetData *rrd = qemu_malloc(sizeof *rrd);

    rrd->data = qemu_malloc(size);
    cpu_physical_memory_read(addr, rrd->data, size);
    rrd->addr = addr;
    rrd->size = size;
87
    qemu_register_reset(option_rom_reset, rrd);
88
89
}

bellard's avatar
bellard committed
90
static void ioport80_write(void *opaque, uint32_t addr, uint32_t data)
bellard's avatar
bellard committed
91
92
93
{
}

94
/* MSDOS compatibility mode FPU exception support */
pbrook's avatar
pbrook committed
95
static qemu_irq ferr_irq;
96
97
98
/* XXX: add IGNNE support */
void cpu_set_ferr(CPUX86State *s)
{
pbrook's avatar
pbrook committed
99
    qemu_irq_raise(ferr_irq);
100
101
102
103
}

static void ioportF0_write(void *opaque, uint32_t addr, uint32_t data)
{
pbrook's avatar
pbrook committed
104
    qemu_irq_lower(ferr_irq);
105
106
}

bellard's avatar
bellard committed
107
108
109
/* TSC handling */
uint64_t cpu_get_tsc(CPUX86State *env)
{
110
111
112
    /* Note: when using kqemu, it is more logical to return the host TSC
       because kqemu does not trap the RDTSC instruction for
       performance reasons */
113
#ifdef CONFIG_KQEMU
114
115
    if (env->kqemu_enabled) {
        return cpu_get_real_ticks();
116
    } else
117
118
119
120
#endif
    {
        return cpu_get_ticks();
    }
bellard's avatar
bellard committed
121
122
}

bellard's avatar
bellard committed
123
124
125
126
127
128
129
130
/* 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's avatar
bellard committed
131
132
133
134
135
136
137
138
139
/* 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 */
140
        pic_update_irq(isa_pic);
bellard's avatar
bellard committed
141
142
143
        return intno;
    }
    /* read the irq from the PIC */
144
145
146
    if (!apic_accept_pic_intr(env))
        return -1;

bellard's avatar
bellard committed
147
148
149
150
    intno = pic_read_irq(isa_pic);
    return intno;
}

pbrook's avatar
pbrook committed
151
static void pic_irq_request(void *opaque, int irq, int level)
bellard's avatar
bellard committed
152
{
153
154
    CPUState *env = first_cpu;

aurel32's avatar
aurel32 committed
155
156
157
    if (env->apic_state) {
        while (env) {
            if (apic_accept_pic_intr(env))
158
                apic_deliver_pic_intr(env, level);
aurel32's avatar
aurel32 committed
159
160
161
            env = env->next_cpu;
        }
    } else {
aurel32's avatar
aurel32 committed
162
163
164
165
        if (level)
            cpu_interrupt(env, CPU_INTERRUPT_HARD);
        else
            cpu_reset_interrupt(env, CPU_INTERRUPT_HARD);
166
    }
bellard's avatar
bellard committed
167
168
}

bellard's avatar
bellard committed
169
170
/* PC cmos mappings */

bellard's avatar
bellard committed
171
172
#define REG_EQUIPMENT_BYTE          0x14

173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
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;
}

197
static void cmos_init_hd(int type_ofs, int info_ofs, BlockDriverState *hd)
bellard's avatar
bellard committed
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
{
    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);
}

214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
/* 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;
}

231
232
/* copy/pasted from cmos_init, should be made a general function
 and used there as well */
233
static int pc_boot_set(void *opaque, const char *boot_device)
234
{
aliguori's avatar
aliguori committed
235
    Monitor *mon = cur_mon;
236
#define PC_MAX_BOOT_DEVICES 3
237
    RTCState *s = (RTCState *)opaque;
238
239
240
241
242
    int nbds, bds[3] = { 0, };
    int i;

    nbds = strlen(boot_device);
    if (nbds > PC_MAX_BOOT_DEVICES) {
aliguori's avatar
aliguori committed
243
        monitor_printf(mon, "Too many boot devices for PC\n");
244
245
246
247
248
        return(1);
    }
    for (i = 0; i < nbds; i++) {
        bds[i] = boot_device2nibble(boot_device[i]);
        if (bds[i] == 0) {
aliguori's avatar
aliguori committed
249
250
            monitor_printf(mon, "Invalid boot device for PC: '%c'\n",
                           boot_device[i]);
251
252
253
254
255
256
257
258
            return(1);
        }
    }
    rtc_set_memory(s, 0x3d, (bds[1] << 4) | bds[0]);
    rtc_set_memory(s, 0x38, (bds[2] << 4));
    return(0);
}

bellard's avatar
bellard committed
259
/* hd_table must contain 4 block drivers */
260
261
static void cmos_init(ram_addr_t ram_size, ram_addr_t above_4g_mem_size,
                      const char *boot_device, BlockDriverState **hd_table)
bellard's avatar
bellard committed
262
{
bellard's avatar
bellard committed
263
    RTCState *s = rtc_state;
264
    int nbds, bds[3] = { 0, };
bellard's avatar
bellard committed
265
    int val;
bellard's avatar
bellard committed
266
    int fd0, fd1, nb;
bellard's avatar
bellard committed
267
    int i;
bellard's avatar
bellard committed
268
269

    /* various important CMOS locations needed by PC/Bochs bios */
bellard's avatar
bellard committed
270
271

    /* memory size */
bellard's avatar
bellard committed
272
273
274
275
    val = 640; /* base memory in K */
    rtc_set_memory(s, 0x15, val);
    rtc_set_memory(s, 0x16, val >> 8);

bellard's avatar
bellard committed
276
277
278
    val = (ram_size / 1024) - 1024;
    if (val > 65535)
        val = 65535;
bellard's avatar
bellard committed
279
280
281
282
    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);
bellard's avatar
bellard committed
283

284
285
286
287
288
289
    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's avatar
bellard committed
290
291
292
293
    if (ram_size > (16 * 1024 * 1024))
        val = (ram_size / 65536) - ((16 * 1024 * 1024) / 65536);
    else
        val = 0;
bellard's avatar
bellard committed
294
295
    if (val > 65535)
        val = 65535;
bellard's avatar
bellard committed
296
297
    rtc_set_memory(s, 0x34, val);
    rtc_set_memory(s, 0x35, val >> 8);
298

aurel32's avatar
aurel32 committed
299
300
301
    /* set the number of CPU */
    rtc_set_memory(s, 0x5f, smp_cpus - 1);

302
    /* set boot devices, and disable floppy signature check if requested */
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
#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));
bellard's avatar
bellard committed
319

bellard's avatar
bellard committed
320
321
    /* floppy type */

322
323
    fd0 = fdctrl_get_drive_type(floppy_controller, 0);
    fd1 = fdctrl_get_drive_type(floppy_controller, 1);
bellard's avatar
bellard committed
324

325
    val = (cmos_get_fd_drive_type(fd0) << 4) | cmos_get_fd_drive_type(fd1);
bellard's avatar
bellard committed
326
    rtc_set_memory(s, 0x10, val);
327

bellard's avatar
bellard committed
328
    val = 0;
bellard's avatar
bellard committed
329
    nb = 0;
bellard's avatar
bellard committed
330
331
332
333
334
335
336
337
    if (fd0 < 3)
        nb++;
    if (fd1 < 3)
        nb++;
    switch (nb) {
    case 0:
        break;
    case 1:
bellard's avatar
bellard committed
338
        val |= 0x01; /* 1 drive, ready for boot */
bellard's avatar
bellard committed
339
340
        break;
    case 2:
bellard's avatar
bellard committed
341
        val |= 0x41; /* 2 drives, ready for boot */
bellard's avatar
bellard committed
342
343
        break;
    }
bellard's avatar
bellard committed
344
345
346
347
    val |= 0x02; /* FPU is there */
    val |= 0x04; /* PS/2 mouse installed */
    rtc_set_memory(s, REG_EQUIPMENT_BYTE, val);

bellard's avatar
bellard committed
348
349
350
351
352
    /* 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]);
353
    if (hd_table[1])
bellard's avatar
bellard committed
354
355
356
        cmos_init_hd(0x1a, 0x24, hd_table[1]);

    val = 0;
bellard's avatar
bellard committed
357
    for (i = 0; i < 4; i++) {
bellard's avatar
bellard committed
358
        if (hd_table[i]) {
bellard's avatar
bellard committed
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
            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;
                }
bellard's avatar
bellard committed
374
            } else {
bellard's avatar
bellard committed
375
                translation--;
bellard's avatar
bellard committed
376
377
378
            }
            val |= translation << (i * 2);
        }
bellard's avatar
bellard committed
379
    }
bellard's avatar
bellard committed
380
    rtc_set_memory(s, 0x39, val);
bellard's avatar
bellard committed
381
382
}

383
384
385
386
387
388
389
390
391
392
393
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's avatar
bellard committed
394
395
static void ioport92_write(void *opaque, uint32_t addr, uint32_t val)
{
396
    ioport_set_a20((val >> 1) & 1);
bellard's avatar
bellard committed
397
398
399
400
401
    /* XXX: bit 0 is fast reset */
}

static uint32_t ioport92_read(void *opaque, uint32_t addr)
{
402
    return ioport_get_a20() << 1;
bellard's avatar
bellard committed
403
404
}

bellard's avatar
bellard committed
405
406
407
/***********************************************************/
/* Bochs BIOS debug ports */

408
static void bochs_bios_write(void *opaque, uint32_t addr, uint32_t val)
bellard's avatar
bellard committed
409
{
bellard's avatar
bellard committed
410
411
    static const char shutdown_str[8] = "Shutdown";
    static int shutdown_index = 0;
412

bellard's avatar
bellard committed
413
414
415
416
417
418
419
420
421
422
423
424
    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;
bellard's avatar
bellard committed
425
426
427
428
429
430
431
432
433
434
435
436
    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;
bellard's avatar
bellard committed
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451

        /* 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;
    }
}

452
453
extern uint64_t node_cpumask[MAX_NODES];

Alexander Graf's avatar
Alexander Graf committed
454
static void *bochs_bios_init(void)
bellard's avatar
bellard committed
455
{
456
    void *fw_cfg;
457
458
    uint8_t *smbios_table;
    size_t smbios_len;
459
460
    uint64_t *numa_fw_cfg;
    int i, j;
461

bellard's avatar
bellard committed
462
463
464
465
    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);
bellard's avatar
bellard committed
466
    register_ioport_write(0x8900, 1, 1, bochs_bios_write, NULL);
bellard's avatar
bellard committed
467
468
469
470
471

    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);
472
473

    fw_cfg = fw_cfg_init(BIOS_CFG_IOPORT, BIOS_CFG_IOPORT + 1, 0, 0);
Alexander Graf's avatar
Alexander Graf committed
474

475
    fw_cfg_add_i32(fw_cfg, FW_CFG_ID, 1);
476
    fw_cfg_add_i64(fw_cfg, FW_CFG_RAM_SIZE, (uint64_t)ram_size);
477
478
    fw_cfg_add_bytes(fw_cfg, FW_CFG_ACPI_TABLES, (uint8_t *)acpi_tables,
                     acpi_tables_len);
479
480
481
482
483

    smbios_table = smbios_get_table(&smbios_len);
    if (smbios_table)
        fw_cfg_add_bytes(fw_cfg, FW_CFG_SMBIOS_ENTRIES,
                         smbios_table, smbios_len);
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503

    /* allocate memory for the NUMA channel: one (64bit) word for the number
     * of nodes, one word for each VCPU->node and one word for each node to
     * hold the amount of memory.
     */
    numa_fw_cfg = qemu_mallocz((1 + smp_cpus + nb_numa_nodes) * 8);
    numa_fw_cfg[0] = cpu_to_le64(nb_numa_nodes);
    for (i = 0; i < smp_cpus; i++) {
        for (j = 0; j < nb_numa_nodes; j++) {
            if (node_cpumask[j] & (1 << i)) {
                numa_fw_cfg[i + 1] = cpu_to_le64(j);
                break;
            }
        }
    }
    for (i = 0; i < nb_numa_nodes; i++) {
        numa_fw_cfg[smp_cpus + 1 + i] = cpu_to_le64(node_mem[i]);
    }
    fw_cfg_add_bytes(fw_cfg, FW_CFG_NUMA, (uint8_t *)numa_fw_cfg,
                     (1 + smp_cpus + nb_numa_nodes) * 8);
Alexander Graf's avatar
Alexander Graf committed
504
505

    return fw_cfg;
bellard's avatar
bellard committed
506
507
}

ths's avatar
ths committed
508
509
/* Generate an initial boot sector which sets state and jump to
   a specified vector */
510
static void generate_bootsect(target_phys_addr_t option_rom,
511
                              uint32_t gpr[8], uint16_t segs[6], uint16_t ip)
ths's avatar
ths committed
512
{
513
514
    uint8_t rom[512], *p, *reloc;
    uint8_t sum;
ths's avatar
ths committed
515
516
    int i;

517
518
519
520
521
522
    memset(rom, 0, sizeof(rom));

    p = rom;
    /* Make sure we have an option rom signature */
    *p++ = 0x55;
    *p++ = 0xaa;
ths's avatar
ths committed
523

524
525
    /* ROM size in sectors*/
    *p++ = 1;
ths's avatar
ths committed
526

527
    /* Hook int19 */
ths's avatar
ths committed
528

529
530
531
532
    *p++ = 0x50;		/* push ax */
    *p++ = 0x1e;		/* push ds */
    *p++ = 0x31; *p++ = 0xc0;	/* xor ax, ax */
    *p++ = 0x8e; *p++ = 0xd8;	/* mov ax, ds */
ths's avatar
ths committed
533

534
535
536
537
538
539
540
541
542
543
544
545
    *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 */
    
ths's avatar
ths committed
546
    /* Actual code */
547
548
    *reloc = (p - rom);

ths's avatar
ths committed
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
    *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;

578
579
580
581
582
583
    /* sign rom */
    sum = 0;
    for (i = 0; i < (sizeof(rom) - 1); i++)
        sum += rom[i];
    rom[sizeof(rom) - 1] = -sum;

584
    cpu_physical_memory_write_rom(option_rom, rom, sizeof(rom));
Glauber Costa's avatar
Glauber Costa committed
585
    option_rom_setup_reset(option_rom, sizeof (rom));
ths's avatar
ths committed
586
}
bellard's avatar
bellard committed
587

ths's avatar
ths committed
588
589
590
591
592
593
594
595
596
597
598
599
600
601
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;
}

Alexander Graf's avatar
Alexander Graf committed
602
603
604
605
606
607
608
609
610
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
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
#define MULTIBOOT_STRUCT_ADDR 0x9000

#if MULTIBOOT_STRUCT_ADDR > 0xf0000
#error multiboot struct needs to fit in 16 bit real mode
#endif

static int load_multiboot(void *fw_cfg,
                          FILE *f,
                          const char *kernel_filename,
                          const char *initrd_filename,
                          const char *kernel_cmdline,
                          uint8_t *header)
{
    int i, t, is_multiboot = 0;
    uint32_t flags = 0;
    uint32_t mh_entry_addr;
    uint32_t mh_load_addr;
    uint32_t mb_kernel_size;
    uint32_t mmap_addr = MULTIBOOT_STRUCT_ADDR;
    uint32_t mb_bootinfo = MULTIBOOT_STRUCT_ADDR + 0x500;
    uint32_t mb_cmdline = mb_bootinfo + 0x200;
    uint32_t mb_mod_end;

    /* Ok, let's see if it is a multiboot image.
       The header is 12x32bit long, so the latest entry may be 8192 - 48. */
    for (i = 0; i < (8192 - 48); i += 4) {
        if (ldl_p(header+i) == 0x1BADB002) {
            uint32_t checksum = ldl_p(header+i+8);
            flags = ldl_p(header+i+4);
            checksum += flags;
            checksum += (uint32_t)0x1BADB002;
            if (!checksum) {
                is_multiboot = 1;
                break;
            }
        }
    }

    if (!is_multiboot)
        return 0; /* no multiboot */

#ifdef DEBUG_MULTIBOOT
    fprintf(stderr, "qemu: I believe we found a multiboot image!\n");
#endif

    if (flags & 0x00000004) { /* MULTIBOOT_HEADER_HAS_VBE */
        fprintf(stderr, "qemu: multiboot knows VBE. we don't.\n");
    }
    if (!(flags & 0x00010000)) { /* MULTIBOOT_HEADER_HAS_ADDR */
        uint64_t elf_entry;
        int kernel_size;
        fclose(f);
        kernel_size = load_elf(kernel_filename, 0, &elf_entry, NULL, NULL);
        if (kernel_size < 0) {
            fprintf(stderr, "Error while loading elf kernel\n");
            exit(1);
        }
        mh_load_addr = mh_entry_addr = elf_entry;
        mb_kernel_size = kernel_size;

#ifdef DEBUG_MULTIBOOT
        fprintf(stderr, "qemu: loading multiboot-elf kernel (%#x bytes) with entry %#zx\n",
                mb_kernel_size, (size_t)mh_entry_addr);
#endif
    } else {
        /* Valid if mh_flags sets MULTIBOOT_HEADER_HAS_ADDR. */
        uint32_t mh_header_addr = ldl_p(header+i+12);
        mh_load_addr = ldl_p(header+i+16);
#ifdef DEBUG_MULTIBOOT
        uint32_t mh_load_end_addr = ldl_p(header+i+20);
        uint32_t mh_bss_end_addr = ldl_p(header+i+24);
#endif
        uint32_t mb_kernel_text_offset = i - (mh_header_addr - mh_load_addr);

        mh_entry_addr = ldl_p(header+i+28);
        mb_kernel_size = get_file_size(f) - mb_kernel_text_offset;

        /* Valid if mh_flags sets MULTIBOOT_HEADER_HAS_VBE.
        uint32_t mh_mode_type = ldl_p(header+i+32);
        uint32_t mh_width = ldl_p(header+i+36);
        uint32_t mh_height = ldl_p(header+i+40);
        uint32_t mh_depth = ldl_p(header+i+44); */

#ifdef DEBUG_MULTIBOOT
        fprintf(stderr, "multiboot: mh_header_addr = %#x\n", mh_header_addr);
        fprintf(stderr, "multiboot: mh_load_addr = %#x\n", mh_load_addr);
        fprintf(stderr, "multiboot: mh_load_end_addr = %#x\n", mh_load_end_addr);
        fprintf(stderr, "multiboot: mh_bss_end_addr = %#x\n", mh_bss_end_addr);
#endif

        fseek(f, mb_kernel_text_offset, SEEK_SET);

#ifdef DEBUG_MULTIBOOT
        fprintf(stderr, "qemu: loading multiboot kernel (%#x bytes) at %#x\n",
                mb_kernel_size, mh_load_addr);
#endif

        if (!fread_targphys_ok(mh_load_addr, mb_kernel_size, f)) {
            fprintf(stderr, "qemu: read error on multiboot kernel '%s' (%#x)\n",
                    kernel_filename, mb_kernel_size);
            exit(1);
        }
        fclose(f);
    }

    /* blob size is only the kernel for now */
    mb_mod_end = mh_load_addr + mb_kernel_size;

    /* load modules */
    stl_phys(mb_bootinfo + 20, 0x0); /* mods_count */
    if (initrd_filename) {
        uint32_t mb_mod_info = mb_bootinfo + 0x100;
        uint32_t mb_mod_cmdline = mb_bootinfo + 0x300;
        uint32_t mb_mod_start = mh_load_addr;
        uint32_t mb_mod_length = mb_kernel_size;
        char *next_initrd;
        char *next_space;
        int mb_mod_count = 0;

        do {
            next_initrd = strchr(initrd_filename, ',');
            if (next_initrd)
                *next_initrd = '\0';
            /* if a space comes after the module filename, treat everything
               after that as parameters */
            cpu_physical_memory_write(mb_mod_cmdline, (uint8_t*)initrd_filename,
                                      strlen(initrd_filename) + 1);
            stl_phys(mb_mod_info + 8, mb_mod_cmdline); /* string */
            mb_mod_cmdline += strlen(initrd_filename) + 1;
            if ((next_space = strchr(initrd_filename, ' ')))
                *next_space = '\0';
#ifdef DEBUG_MULTIBOOT
	     printf("multiboot loading module: %s\n", initrd_filename);
#endif
            f = fopen(initrd_filename, "rb");
            if (f) {
                mb_mod_start = (mb_mod_start + mb_mod_length + (TARGET_PAGE_SIZE - 1))
                             & (TARGET_PAGE_MASK);
                mb_mod_length = get_file_size(f);
                mb_mod_end = mb_mod_start + mb_mod_length;

                if (!fread_targphys_ok(mb_mod_start, mb_mod_length, f)) {
                    fprintf(stderr, "qemu: read error on multiboot module '%s' (%#x)\n",
                            initrd_filename, mb_mod_length);
                    exit(1);
                }

                mb_mod_count++;
                stl_phys(mb_mod_info + 0, mb_mod_start);
                stl_phys(mb_mod_info + 4, mb_mod_start + mb_mod_length);
#ifdef DEBUG_MULTIBOOT
                printf("mod_start: %#x\nmod_end:   %#x\n", mb_mod_start,
                       mb_mod_start + mb_mod_length);
#endif
                stl_phys(mb_mod_info + 12, 0x0); /* reserved */
            }
            initrd_filename = next_initrd+1;
            mb_mod_info += 16;
        } while (next_initrd);
        stl_phys(mb_bootinfo + 20, mb_mod_count); /* mods_count */
        stl_phys(mb_bootinfo + 24, mb_bootinfo + 0x100); /* mods_addr */
    }

    /* Make sure we're getting kernel + modules back after reset */
    option_rom_setup_reset(mh_load_addr, mb_mod_end - mh_load_addr);

    /* Commandline support */
    stl_phys(mb_bootinfo + 16, mb_cmdline);
    t = strlen(kernel_filename);
    cpu_physical_memory_write(mb_cmdline, (uint8_t*)kernel_filename, t);
    mb_cmdline += t;
    stb_phys(mb_cmdline++, ' ');
    t = strlen(kernel_cmdline) + 1;
    cpu_physical_memory_write(mb_cmdline, (uint8_t*)kernel_cmdline, t);

    /* the kernel is where we want it to be now */

#define MULTIBOOT_FLAGS_MEMORY (1 << 0)
#define MULTIBOOT_FLAGS_BOOT_DEVICE (1 << 1)
#define MULTIBOOT_FLAGS_CMDLINE (1 << 2)
#define MULTIBOOT_FLAGS_MODULES (1 << 3)
#define MULTIBOOT_FLAGS_MMAP (1 << 6)
    stl_phys(mb_bootinfo, MULTIBOOT_FLAGS_MEMORY
                        | MULTIBOOT_FLAGS_BOOT_DEVICE
                        | MULTIBOOT_FLAGS_CMDLINE
                        | MULTIBOOT_FLAGS_MODULES
                        | MULTIBOOT_FLAGS_MMAP);
    stl_phys(mb_bootinfo + 4, 640); /* mem_lower */
    stl_phys(mb_bootinfo + 8, ram_size / 1024); /* mem_upper */
    stl_phys(mb_bootinfo + 12, 0x8001ffff); /* XXX: use the -boot switch? */
    stl_phys(mb_bootinfo + 48, mmap_addr); /* mmap_addr */

#ifdef DEBUG_MULTIBOOT
    fprintf(stderr, "multiboot: mh_entry_addr = %#x\n", mh_entry_addr);
#endif

    /* Pass variables to option rom */
    fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_ADDR, mh_entry_addr);
    fw_cfg_add_i32(fw_cfg, FW_CFG_INITRD_ADDR, mb_bootinfo);
    fw_cfg_add_i32(fw_cfg, FW_CFG_INITRD_SIZE, mmap_addr);

    /* Make sure we're getting the config space back after reset */
    option_rom_setup_reset(mb_bootinfo, 0x500);

    option_rom[nb_option_roms] = "multiboot.bin";
    nb_option_roms++;

    return 1; /* yes, we are multiboot */
}

static void load_linux(void *fw_cfg,
                       target_phys_addr_t option_rom,
814
                       const char *kernel_filename,
ths's avatar
ths committed
815
		       const char *initrd_filename,
Glauber Costa's avatar
Glauber Costa committed
816
817
		       const char *kernel_cmdline,
               target_phys_addr_t max_ram_size)
ths's avatar
ths committed
818
819
820
821
822
{
    uint16_t protocol;
    uint32_t gpr[8];
    uint16_t seg[6];
    uint16_t real_seg;
Paul Brook's avatar
Paul Brook committed
823
    int setup_size, kernel_size, initrd_size = 0, cmdline_size;
ths's avatar
ths committed
824
    uint32_t initrd_max;
Alexander Graf's avatar
Alexander Graf committed
825
    uint8_t header[8192];
Paul Brook's avatar
Paul Brook committed
826
    target_phys_addr_t real_addr, prot_addr, cmdline_addr, initrd_addr = 0;
ths's avatar
ths committed
827
    FILE *f, *fi;
Pascal Terjan's avatar
Pascal Terjan committed
828
    char *vmode;
ths's avatar
ths committed
829
830
831
832
833
834
835

    /* 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)) ||
Alexander Graf's avatar
Alexander Graf committed
836
837
	fread(header, 1, MIN(ARRAY_SIZE(header), kernel_size), f) !=
	MIN(ARRAY_SIZE(header), kernel_size)) {
ths's avatar
ths committed
838
839
840
841
842
843
	fprintf(stderr, "qemu: could not load kernel '%s'\n",
		kernel_filename);
	exit(1);
    }

    /* kernel protocol version */
bellard's avatar
bellard committed
844
#if 0
ths's avatar
ths committed
845
    fprintf(stderr, "header magic: %#x\n", ldl_p(header+0x202));
bellard's avatar
bellard committed
846
#endif
ths's avatar
ths committed
847
848
    if (ldl_p(header+0x202) == 0x53726448)
	protocol = lduw_p(header+0x206);
Alexander Graf's avatar
Alexander Graf committed
849
850
851
852
853
854
    else {
	/* This looks like a multiboot kernel. If it is, let's stop
	   treating it like a Linux kernel. */
	if (load_multiboot(fw_cfg, f, kernel_filename,
                           initrd_filename, kernel_cmdline, header))
	   return;
ths's avatar
ths committed
855
	protocol = 0;
Alexander Graf's avatar
Alexander Graf committed
856
    }
ths's avatar
ths committed
857
858
859

    if (protocol < 0x200 || !(header[0x211] & 0x01)) {
	/* Low kernel */
860
861
862
	real_addr    = 0x90000;
	cmdline_addr = 0x9a000 - cmdline_size;
	prot_addr    = 0x10000;
ths's avatar
ths committed
863
864
    } else if (protocol < 0x202) {
	/* High but ancient kernel */
865
866
867
	real_addr    = 0x90000;
	cmdline_addr = 0x9a000 - cmdline_size;
	prot_addr    = 0x100000;
ths's avatar
ths committed
868
869
    } else {
	/* High and recent kernel */
870
871
872
	real_addr    = 0x10000;
	cmdline_addr = 0x20000;
	prot_addr    = 0x100000;
ths's avatar
ths committed
873
874
    }

bellard's avatar
bellard committed
875
#if 0
ths's avatar
ths committed
876
    fprintf(stderr,
877
878
879
	    "qemu: real_addr     = 0x" TARGET_FMT_plx "\n"
	    "qemu: cmdline_addr  = 0x" TARGET_FMT_plx "\n"
	    "qemu: prot_addr     = 0x" TARGET_FMT_plx "\n",
880
881
882
	    real_addr,
	    cmdline_addr,
	    prot_addr);
bellard's avatar
bellard committed
883
#endif
ths's avatar
ths committed
884
885
886
887
888
889
890

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

Glauber Costa's avatar
Glauber Costa committed
891
892
    if (initrd_max >= max_ram_size-ACPI_DATA_SIZE)
    	initrd_max = max_ram_size-ACPI_DATA_SIZE-1;
ths's avatar
ths committed
893
894

    /* kernel command line */
895
    pstrcpy_targphys(cmdline_addr, 4096, kernel_cmdline);
ths's avatar
ths committed
896
897

    if (protocol >= 0x202) {
898
	stl_p(header+0x228, cmdline_addr);
ths's avatar
ths committed
899
900
901
902
903
    } else {
	stw_p(header+0x20, 0xA33F);
	stw_p(header+0x22, cmdline_addr-real_addr);
    }

Pascal Terjan's avatar
Pascal Terjan committed
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
    /* handle vga= parameter */
    vmode = strstr(kernel_cmdline, "vga=");
    if (vmode) {
        unsigned int video_mode;
        /* skip "vga=" */
        vmode += 4;
        if (!strncmp(vmode, "normal", 6)) {
            video_mode = 0xffff;
        } else if (!strncmp(vmode, "ext", 3)) {
            video_mode = 0xfffe;
        } else if (!strncmp(vmode, "ask", 3)) {
            video_mode = 0xfffd;
        } else {
            video_mode = strtol(vmode, NULL, 0);
        }
        stw_p(header+0x1fa, video_mode);
    }

ths's avatar
ths committed
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
    /* 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);
950
	initrd_addr = (initrd_max-initrd_size) & ~4095;
ths's avatar
ths committed
951

952
	if (!fread_targphys_ok(initrd_addr, initrd_size, fi)) {
ths's avatar
ths committed
953
954
955
956
957
958
	    fprintf(stderr, "qemu: read error on initial ram disk '%s'\n",
		    initrd_filename);
	    exit(1);
	}
	fclose(fi);

959
	stl_p(header+0x218, initrd_addr);
ths's avatar
ths committed
960
961
962
963
	stl_p(header+0x21c, initrd_size);
    }

    /* store the finalized header and load the rest of the kernel */
Alexander Graf's avatar
Alexander Graf committed
964
    cpu_physical_memory_write(real_addr, header, ARRAY_SIZE(header));
ths's avatar
ths committed
965
966
967
968
969
970

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

    setup_size = (setup_size+1)*512;
Alexander Graf's avatar
Alexander Graf committed
971
972
973
974
975
976
977
978
979
    /* Size of protected-mode code */
    kernel_size -= (setup_size > ARRAY_SIZE(header)) ? setup_size : ARRAY_SIZE(header);

    /* In case we have read too much already, copy that over */
    if (setup_size < ARRAY_SIZE(header)) {
        cpu_physical_memory_write(prot_addr, header + setup_size, ARRAY_SIZE(header) - setup_size);
        prot_addr += (ARRAY_SIZE(header) - setup_size);
        setup_size = ARRAY_SIZE(header);
    }
ths's avatar
ths committed
980

Alexander Graf's avatar
Alexander Graf committed
981
982
    if (!fread_targphys_ok(real_addr + ARRAY_SIZE(header),
                           setup_size - ARRAY_SIZE(header), f) ||
983
	!fread_targphys_ok(prot_addr, kernel_size, f)) {
ths's avatar
ths committed
984
985
986
987
988
989
990
	fprintf(stderr, "qemu: read error on kernel '%s'\n",
		kernel_filename);
	exit(1);
    }
    fclose(f);

    /* generate bootsector to set up the initial register state */
991
    real_seg = real_addr >> 4;
ths's avatar
ths committed
992
993
994
995
996
    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) */

Glauber Costa's avatar
Glauber Costa committed
997
998
999
1000
1001
1002
    option_rom_setup_reset(real_addr, setup_size);
    option_rom_setup_reset(prot_addr, kernel_size);
    option_rom_setup_reset(cmdline_addr, cmdline_size);
    if (initrd_filename)
        option_rom_setup_reset(initrd_addr, initrd_size);

1003
    generate_bootsect(option_rom, gpr, seg, 0);
ths's avatar
ths committed
1004
1005
}

bellard's avatar
bellard committed
1006
1007
1008
1009
1010
1011
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

1012
static int ne2000_io[NE2000_NB_MAX] = { 0x300, 0x320, 0x340, 0x360, 0x280, 0x380 };
bellard's avatar
bellard committed
1013
1014
static int ne2000_irq[NE2000_NB_MAX] = { 9, 10, 11, 3, 4, 5 };

1015
1016
1017
static int serial_io[MAX_SERIAL_PORTS] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8 };
static int serial_irq[MAX_SERIAL_PORTS] = { 4, 3, 4, 3 };

1018
1019
1020
static int parallel_io[MAX_PARALLEL_PORTS] = { 0x378, 0x278, 0x3bc };
static int parallel_irq[MAX_PARALLEL_PORTS] = { 7, 7, 7 };

1021
#ifdef HAS_AUDIO
pbrook's avatar
pbrook committed
1022
static void audio_init (PCIBus *pci_bus, qemu_irq *pic)
1023
1024
1025
{
    struct soundhw *c;

malc's avatar
malc committed
1026
1027
1028
1029
1030
1031
1032
    for (c = soundhw; c->name; ++c) {
        if (c->enabled) {
            if (c->isa) {
                c->init.init_isa(pic);
            } else {
                if (pci_bus) {
                    c->init.init_pci(pci_bus);
1033
1034
1035
1036
1037
1038
1039
                }
            }
        }
    }
}
#endif

pbrook's avatar
pbrook committed
1040
static void pc_init_ne2k_isa(NICInfo *nd, qemu_irq *pic)
1041
1042
1043
1044
1045
{
    static int nb_ne2k = 0;

    if (nb_ne2k == NE2000_NB_MAX)
        return;
pbrook's avatar
pbrook committed
1046
    isa_ne2000_init(ne2000_io[nb_ne2k], pic[ne2000_irq[nb_ne2k]], nd);
1047
1048
1049
    nb_ne2k++;
}

1050
1051
1052
1053
static int load_option_rom(const char *oprom, target_phys_addr_t start,
                           target_phys_addr_t end)
{
        int size;
Paul Brook's avatar
Paul Brook committed
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
        char *filename;

        filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, oprom);
        if (filename) {
            size = get_image_size(filename);
            if (size > 0 && start + size > end) {
                fprintf(stderr, "Not enough space to load option rom '%s'\n",
                        oprom);
                exit(1);
            }
            size = load_image_targphys(filename, start, end - start);
            qemu_free(filename);
        } else {
            size = -1;
1068
1069
1070
1071
1072
1073
1074
        }
        if (size < 0) {
            fprintf(stderr, "Could not load option rom '%s'\n", oprom);
            exit(1);
        }
        /* Round up optiom rom size to the next 2k boundary */
        size = (size + 2047) & ~2047;
1075
        option_rom_setup_reset(start, size);
1076
1077
1078
        return size;
}

Gleb Natapov's avatar
Gleb Natapov committed
1079
1080
1081
1082
1083
int cpu_is_bsp(CPUState *env)
{
	return env->cpuid_apic_id == 0;
}

Jan Kiszka's avatar
Jan Kiszka committed
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
static CPUState *pc_new_cpu(const char *cpu_model)
{
    CPUState *env;

    env = cpu_init(cpu_model);
    if (!env) {
        fprintf(stderr, "Unable to find x86 CPU definition\n");
        exit(1);
    }
    if ((env->cpuid_features & CPUID_APIC) || smp_cpus > 1) {
        env->cpuid_apic_id = env->cpu_index;
        /* APIC reset callback resets cpu */
        apic_init(env);
    } else {
        qemu_register_reset((QEMUResetHandler*)cpu_reset, env);
    }
    return env;
}

1103
1104
1105
1106
1107
enum {
    COMPAT_DEFAULT = 0,
    COMPAT_0_10, /* compatible with qemu 0.10.x */
};

bellard's avatar
bellard committed
1108
/* PC hardware initialisation */
Paul Brook's avatar
Paul Brook committed
1109
static void pc_init1(ram_addr_t ram_size,
1110
                     const char *boot_device,
1111
1112
                     const char *kernel_filename,
                     const char *kernel_cmdline,
1113
                     const char *initrd_filename,
1114
1115
1116
                     const char *cpu_model,
                     int pci_enabled,
                     int compat_level)
bellard's avatar
bellard committed
1117
{
Paul Brook's avatar
Paul Brook committed
1118
    char *filename;
ths's avatar
ths committed
1119
    int ret, linux_boot, i;
pbrook's avatar
pbrook committed
1120
    ram_addr_t ram_addr, bios_offset, option_rom_offset;
1121
    ram_addr_t below_4g_mem_size, above_4g_mem_size = 0;
1122
    int bios_size, isa_bios_size, oprom_area_size;
bellard's avatar
bellard committed
1123
    PCIBus *pci_bus;
1124
    PCIDevice *pci_dev;
pbrook's avatar
pbrook committed
1125
    int piix3_devfn = -1;
1126
    CPUState *env;
pbrook's avatar
pbrook committed
1127
1128
    qemu_irq *cpu_irq;
    qemu_irq *i8259;
ths's avatar
ths committed
1129
1130
1131
    int index;
    BlockDriverState *hd[MAX_IDE_BUS * MAX_IDE_DEVS];
    BlockDriverState *fd[MAX_FD];
aliguori's avatar
aliguori committed
1132
    int using_vga = cirrus_vga_enabled || std_vga_enabled || vmsvga_enabled;
Alexander Graf's avatar
Alexander Graf committed
1133
    void *fw_cfg;
1134
    const char *virtio_blk_name, *virtio_console_name;
1135

1136
1137
1138
1139
1140
1141
1142
    if (ram_size >= 0xe0000000 ) {
        above_4g_mem_size = ram_size - 0xe0000000;
        below_4g_mem_size = 0xe0000000;
    } else {
        below_4g_mem_size = ram_size;
    }

bellard's avatar
bellard committed
1143
1144
    linux_boot = (kernel_filename != NULL);

1145
    /* init CPUs */
1146
1147
1148
1149
1150
1151
1152
    if (cpu_model == NULL) {
#ifdef TARGET_X86_64
        cpu_model = "qemu64";
#else
        cpu_model = "qemu32";
#endif
    }
Jan Kiszka's avatar
Jan Kiszka committed
1153
1154
1155

    for (i = 0; i < smp_cpus; i++) {
        env = pc_new_cpu(cpu_model);
1156
1157
    }

aurel32's avatar
aurel32 committed
1158
1159
    vmport_init();

bellard's avatar
bellard committed
1160
    /* allocate RAM */
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
    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);
1173
1174
1175

    /* above 4giga memory allocation */
    if (above_4g_mem_size > 0) {
1176
1177
1178
#if TARGET_PHYS_ADDR_BITS == 32
        hw_error("To much RAM for 32-bit physical address");
#else
1179
1180
        ram_addr = qemu_ram_alloc(above_4g_mem_size);
        cpu_register_physical_memory(0x100000000ULL,
1181
                                     above_4g_mem_size,
1182
                                     ram_addr);
1183
#endif
1184
    }
bellard's avatar
bellard committed
1185

1186

bellard's avatar
bellard committed
1187
    /* BIOS load */
1188
1189
    if (bios_name == NULL)
        bios_name = BIOS_FILENAME;
Paul Brook's avatar
Paul Brook committed
1190
1191
1192
1193
1194
1195
    filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, bios_name);
    if (filename) {
        bios_size = get_image_size(filename);
    } else {
        bios_size = -1;
    }
1196
    if (bios_size <= 0 ||
bellard's avatar
bellard committed
1197
        (bios_size % 65536) != 0) {
bellard's avatar
bellard committed
1198
1199
        goto bios_error;
    }
bellard's avatar
bellard committed
1200
    bios_offset = qemu_ram_alloc(bios_size);
Paul Brook's avatar
Paul Brook committed
1201
    ret = load_image(filename, qemu_get_ram_ptr(bios_offset));
bellard's avatar
bellard committed
1202
1203
    if (ret != bios_size) {
    bios_error:
Paul Brook's avatar
Paul Brook committed
1204
        fprintf(stderr, "qemu: could not load PC BIOS '%s'\n", bios_name);
bellard's avatar
bellard committed
1205
1206
        exit(1);
    }
Paul Brook's avatar
Paul Brook committed
1207
1208
1209
    if (filename) {
        qemu_free(filename);
    }
bellard's avatar
bellard committed
1210
1211
1212
1213
    /* 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;
1214
1215
    cpu_register_physical_memory(0x100000 - isa_bios_size,
                                 isa_bios_size,
bellard's avatar
bellard committed
1216
                                 (bios_offset + bios_size - isa_bios_size) | IO_MEM_ROM);
1217

1218

1219
1220
1221

    option_rom_offset = qemu_ram_alloc(0x20000);
    oprom_area_size = 0;
1222
    cpu_register_physical_memory(0xc0000, 0x20000, option_rom_offset);
1223
1224

    if (using_vga) {
Paul Brook's avatar
Paul Brook committed
1225
        const char *vgabios_filename;
1226
1227
        /* VGA BIOS load */
        if (cirrus_vga_enabled) {
Paul Brook's avatar
Paul Brook committed
1228
            vgabios_filename = VGABIOS_CIRRUS_FILENAME;
1229
        } else {
Paul Brook's avatar
Paul Brook committed
1230
            vgabios_filename = VGABIOS_FILENAME;
bellard's avatar
bellard committed
1231
        }
Paul Brook's avatar
Paul Brook committed
1232
        oprom_area_size = load_option_rom(vgabios_filename, 0xc0000, 0xe0000);
1233
1234
1235
1236
1237
1238
1239
    }
    /* Although video roms can grow larger than 0x8000, the area between
     * 0xc0000 - 0xc8000 is reserved for them. It means we won't be looking
     * for any other kind of option rom inside this area */
    if (oprom_area_size < 0x8000)
        oprom_area_size = 0x8000;

Alexander Graf's avatar
Alexander Graf committed
1240
1241
1242
1243
    /* map all the bios at the top of memory */
    cpu_register_physical_memory((uint32_t)(-bios_size),
                                 bios_size, bios_offset | IO_MEM_ROM);

Alexander Graf's avatar
Alexander Graf committed
1244
    fw_cfg = bochs_bios_init();
Alexander Graf's avatar
Alexander Graf committed
1245

1246
    if (linux_boot) {
Alexander Graf's avatar
Alexander Graf committed
1247
        load_linux(fw_cfg, 0xc0000 + oprom_area_size,
Glauber Costa's avatar
Glauber Costa committed
1248
                   kernel_filename, initrd_filename, kernel_cmdline, below_4g_mem_size);
1249
1250
1251
1252
        oprom_area_size += 2048;
    }

    for (i = 0; i < nb_option_roms; i++) {
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
        oprom_area_size += load_option_rom(option_rom[i], 0xc0000 + oprom_area_size,
                                           0xe0000);
    }

    for (i = 0; i < nb_nics; i++) {
        char nic_oprom[1024];
        const char *model = nd_table[i].model;

        if (!nd_table[i].bootable)
            continue;

        if (model == NULL)
            model = "ne2k_pci";
        snprintf(nic_oprom, sizeof(nic_oprom), "pxe-%s.bin", model);

        oprom_area_size += load_option_rom(nic_oprom, 0xc0000 + oprom_area_size,
                                           0xe0000);
1270
1271
    }

1272
    cpu_irq = qemu_allocate_irqs(pic_irq_request, NULL, 1);
pbrook's avatar
pbrook committed
1273
1274
1275
    i8259 = i8259_init(cpu_irq[0]);
    ferr_irq = i8259[13];

bellard's avatar
bellard committed
1276
    if (pci_enabled) {
pbrook's avatar
pbrook committed
1277
        pci_bus = i440fx_init(&i440fx_state, i8259);
1278
        piix3_devfn = piix3_init(pci_bus, -1);
bellard's avatar
bellard committed
1279
1280
    } else {
        pci_bus = NULL;
bellard's avatar
bellard committed
1281
1282
    }

bellard's avatar
bellard committed
1283
    /* init basic PC hardware */
bellard's avatar
bellard committed
1284
    register_ioport_write(0x80, 1, 1, ioport80_write, NULL);
bellard's avatar
bellard committed
1285

1286
1287
    register_ioport_write(0xf0, 1, 1, ioportF0_write, NULL);

bellard's avatar
bellard committed
1288
1289
    if (cirrus_vga_enabled) {
        if (pci_enabled) {
Paul Brook's avatar
Paul Brook committed
1290
            pci_cirrus_vga_init(pci_bus);
bellard's avatar
bellard committed
1291
        } else {
Paul Brook's avatar
Paul Brook committed
1292
            isa_cirrus_vga_init();
bellard's avatar
bellard committed
1293
        }
1294
1295
    } else if (vmsvga_enabled) {
        if (pci_enabled)
Paul Brook's avatar
Paul Brook committed
1296
            pci_vmsvga_init(pci_bus);
1297
1298
        else
            fprintf(stderr, "%s: vmware_vga: no PCI bus\n", __FUNCTION__);
1299
    } else if (std_vga_enabled) {
bellard's avatar
bellard committed
1300
        if (pci_enabled) {
Paul Brook's avatar
Paul Brook committed
1301
            pci_vga_init(pci_bus, 0, 0);
bellard's avatar
bellard committed
1302
        } else {
Paul Brook's avatar
Paul Brook committed
1303
            isa_vga_init();
bellard's avatar
bellard committed
1304
        }
bellard's avatar
bellard committed
1305
    }
bellard's avatar
bellard committed
1306

1307
    rtc_state = rtc_init(0x70, i8259[8], 2000);
bellard's avatar
bellard committed
1308

1309
1310
    qemu_register_boot_set(pc_boot_set, rtc_state);

bellard's avatar
bellard committed
1311
1312
1313
    register_ioport_read(0x92, 1, 1, ioport92_read, NULL);
    register_ioport_write(0x92, 1, 1, ioport92_write, NULL);