bellard | 80cabfa | 2004-03-14 12:20:30 +0000 | [diff] [blame] | 1 | /* |
| 2 | * QEMU PC System Emulator |
ths | 5fafdf2 | 2007-09-16 21:08:06 +0000 | [diff] [blame] | 3 | * |
bellard | 80cabfa | 2004-03-14 12:20:30 +0000 | [diff] [blame] | 4 | * Copyright (c) 2003-2004 Fabrice Bellard |
ths | 5fafdf2 | 2007-09-16 21:08:06 +0000 | [diff] [blame] | 5 | * |
bellard | 80cabfa | 2004-03-14 12:20:30 +0000 | [diff] [blame] | 6 | * Permission is hereby granted, free of charge, to any person obtaining a copy |
| 7 | * of this software and associated documentation files (the "Software"), to deal |
| 8 | * in the Software without restriction, including without limitation the rights |
| 9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
| 10 | * copies of the Software, and to permit persons to whom the Software is |
| 11 | * furnished to do so, subject to the following conditions: |
| 12 | * |
| 13 | * The above copyright notice and this permission notice shall be included in |
| 14 | * all copies or substantial portions of the Software. |
| 15 | * |
| 16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| 17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| 18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
| 19 | * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| 20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
| 21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
| 22 | * THE SOFTWARE. |
| 23 | */ |
Paolo Bonzini | 83c9f4c | 2013-02-04 15:40:22 +0100 | [diff] [blame] | 24 | #include "hw/hw.h" |
Paolo Bonzini | 0d09e41 | 2013-02-05 17:06:20 +0100 | [diff] [blame] | 25 | #include "hw/i386/pc.h" |
| 26 | #include "hw/char/serial.h" |
| 27 | #include "hw/i386/apic.h" |
| 28 | #include "hw/block/fdc.h" |
Paolo Bonzini | 83c9f4c | 2013-02-04 15:40:22 +0100 | [diff] [blame] | 29 | #include "hw/ide.h" |
| 30 | #include "hw/pci/pci.h" |
Paolo Bonzini | 83c9089 | 2012-12-17 18:19:49 +0100 | [diff] [blame] | 31 | #include "monitor/monitor.h" |
Paolo Bonzini | 0d09e41 | 2013-02-05 17:06:20 +0100 | [diff] [blame] | 32 | #include "hw/nvram/fw_cfg.h" |
| 33 | #include "hw/timer/hpet.h" |
| 34 | #include "hw/i386/smbios.h" |
Paolo Bonzini | 83c9f4c | 2013-02-04 15:40:22 +0100 | [diff] [blame] | 35 | #include "hw/loader.h" |
Blue Swirl | ca20cf3 | 2009-09-20 14:58:02 +0000 | [diff] [blame] | 36 | #include "elf.h" |
Paolo Bonzini | 47b43a1 | 2013-03-18 17:36:02 +0100 | [diff] [blame] | 37 | #include "multiboot.h" |
Paolo Bonzini | 0d09e41 | 2013-02-05 17:06:20 +0100 | [diff] [blame] | 38 | #include "hw/timer/mc146818rtc.h" |
| 39 | #include "hw/timer/i8254.h" |
| 40 | #include "hw/audio/pcspk.h" |
Paolo Bonzini | 83c9f4c | 2013-02-04 15:40:22 +0100 | [diff] [blame] | 41 | #include "hw/pci/msi.h" |
| 42 | #include "hw/sysbus.h" |
Paolo Bonzini | 9c17d61 | 2012-12-17 18:20:04 +0100 | [diff] [blame] | 43 | #include "sysemu/sysemu.h" |
| 44 | #include "sysemu/kvm.h" |
Peter Maydell | 1d31f66 | 2012-07-26 15:35:13 +0100 | [diff] [blame] | 45 | #include "kvm_i386.h" |
Paolo Bonzini | 0d09e41 | 2013-02-05 17:06:20 +0100 | [diff] [blame] | 46 | #include "hw/xen/xen.h" |
Paolo Bonzini | 9c17d61 | 2012-12-17 18:20:04 +0100 | [diff] [blame] | 47 | #include "sysemu/blockdev.h" |
Paolo Bonzini | 0d09e41 | 2013-02-05 17:06:20 +0100 | [diff] [blame] | 48 | #include "hw/block/block.h" |
Gerd Hoffmann | a19cbfb | 2010-04-27 11:50:11 +0200 | [diff] [blame] | 49 | #include "ui/qemu-spice.h" |
Paolo Bonzini | 022c62c | 2012-12-17 18:19:49 +0100 | [diff] [blame] | 50 | #include "exec/memory.h" |
| 51 | #include "exec/address-spaces.h" |
Paolo Bonzini | 9c17d61 | 2012-12-17 18:20:04 +0100 | [diff] [blame] | 52 | #include "sysemu/arch_init.h" |
Paolo Bonzini | 1de7afc | 2012-12-17 18:20:00 +0100 | [diff] [blame] | 53 | #include "qemu/bitmap.h" |
Laszlo Ersek | 0c764a9 | 2013-03-21 00:23:17 +0100 | [diff] [blame] | 54 | #include "qemu/config-file.h" |
Michael S. Tsirkin | 0445259 | 2013-04-15 09:19:22 +0300 | [diff] [blame] | 55 | #include "hw/acpi/acpi.h" |
Igor Mammedov | 53a89e2 | 2013-04-29 19:03:01 +0200 | [diff] [blame] | 56 | #include "hw/cpu/icc_bus.h" |
Igor Mammedov | c649983 | 2013-04-30 18:00:53 +0200 | [diff] [blame] | 57 | #include "hw/boards.h" |
bellard | 80cabfa | 2004-03-14 12:20:30 +0000 | [diff] [blame] | 58 | |
Blue Swirl | 471fd34 | 2010-05-29 20:23:49 +0000 | [diff] [blame] | 59 | /* debug PC/ISA interrupts */ |
| 60 | //#define DEBUG_IRQ |
| 61 | |
| 62 | #ifdef DEBUG_IRQ |
| 63 | #define DPRINTF(fmt, ...) \ |
| 64 | do { printf("CPUIRQ: " fmt , ## __VA_ARGS__); } while (0) |
| 65 | #else |
| 66 | #define DPRINTF(fmt, ...) |
| 67 | #endif |
| 68 | |
pbrook | a80274c | 2007-03-31 19:41:22 +0000 | [diff] [blame] | 69 | /* Leave a chunk of memory at the top of RAM for the BIOS ACPI tables. */ |
| 70 | #define ACPI_DATA_SIZE 0x10000 |
blueswir1 | 3cce624 | 2008-09-18 18:27:29 +0000 | [diff] [blame] | 71 | #define BIOS_CFG_IOPORT 0x510 |
aliguori | 8a92ea2 | 2009-02-27 20:12:36 +0000 | [diff] [blame] | 72 | #define FW_CFG_ACPI_TABLES (FW_CFG_ARCH_LOCAL + 0) |
aliguori | b6f6e3d | 2009-04-17 18:59:56 +0000 | [diff] [blame] | 73 | #define FW_CFG_SMBIOS_ENTRIES (FW_CFG_ARCH_LOCAL + 1) |
Jes Sorensen | 6b35e7b | 2009-08-06 16:25:50 +0200 | [diff] [blame] | 74 | #define FW_CFG_IRQ0_OVERRIDE (FW_CFG_ARCH_LOCAL + 2) |
Jes Sorensen | 4c5b10b | 2010-02-15 18:33:46 +0100 | [diff] [blame] | 75 | #define FW_CFG_E820_TABLE (FW_CFG_ARCH_LOCAL + 3) |
Gleb Natapov | 40ac17c | 2010-06-14 11:29:28 +0300 | [diff] [blame] | 76 | #define FW_CFG_HPET (FW_CFG_ARCH_LOCAL + 4) |
bellard | 80cabfa | 2004-03-14 12:20:30 +0000 | [diff] [blame] | 77 | |
Laszlo Ersek | 3a4a469 | 2013-03-21 00:23:21 +0100 | [diff] [blame] | 78 | #define IO_APIC_DEFAULT_ADDRESS 0xfec00000 |
| 79 | |
Jes Sorensen | 4c5b10b | 2010-02-15 18:33:46 +0100 | [diff] [blame] | 80 | #define E820_NR_ENTRIES 16 |
| 81 | |
| 82 | struct e820_entry { |
| 83 | uint64_t address; |
| 84 | uint64_t length; |
| 85 | uint32_t type; |
Stefan Weil | 541dc0d | 2011-08-31 12:38:01 +0200 | [diff] [blame] | 86 | } QEMU_PACKED __attribute((__aligned__(4))); |
Jes Sorensen | 4c5b10b | 2010-02-15 18:33:46 +0100 | [diff] [blame] | 87 | |
| 88 | struct e820_table { |
| 89 | uint32_t count; |
| 90 | struct e820_entry entry[E820_NR_ENTRIES]; |
Stefan Weil | 541dc0d | 2011-08-31 12:38:01 +0200 | [diff] [blame] | 91 | } QEMU_PACKED __attribute((__aligned__(4))); |
Jes Sorensen | 4c5b10b | 2010-02-15 18:33:46 +0100 | [diff] [blame] | 92 | |
| 93 | static struct e820_table e820_table; |
Blue Swirl | dd703b9 | 2011-02-05 14:35:00 +0000 | [diff] [blame] | 94 | struct hpet_fw_config hpet_cfg = {.count = UINT8_MAX}; |
Jes Sorensen | 4c5b10b | 2010-02-15 18:33:46 +0100 | [diff] [blame] | 95 | |
Jan Kiszka | b881fbe | 2011-10-07 09:19:35 +0200 | [diff] [blame] | 96 | void gsi_handler(void *opaque, int n, int level) |
Avi Kivity | 1452411 | 2009-08-09 19:44:55 +0300 | [diff] [blame] | 97 | { |
Jan Kiszka | b881fbe | 2011-10-07 09:19:35 +0200 | [diff] [blame] | 98 | GSIState *s = opaque; |
Avi Kivity | 1452411 | 2009-08-09 19:44:55 +0300 | [diff] [blame] | 99 | |
Jan Kiszka | b881fbe | 2011-10-07 09:19:35 +0200 | [diff] [blame] | 100 | DPRINTF("pc: %s GSI %d\n", level ? "raising" : "lowering", n); |
| 101 | if (n < ISA_NUM_IRQS) { |
| 102 | qemu_set_irq(s->i8259_irq[n], level); |
Avi Kivity | 1632dc6 | 2009-08-09 19:44:56 +0300 | [diff] [blame] | 103 | } |
Jan Kiszka | b881fbe | 2011-10-07 09:19:35 +0200 | [diff] [blame] | 104 | qemu_set_irq(s->ioapic_irq[n], level); |
Jan Kiszka | 2e9947d | 2011-10-07 09:19:34 +0200 | [diff] [blame] | 105 | } |
Avi Kivity | 1452411 | 2009-08-09 19:44:55 +0300 | [diff] [blame] | 106 | |
Julien Grall | 258711c | 2012-09-19 12:50:08 +0100 | [diff] [blame] | 107 | static void ioport80_write(void *opaque, hwaddr addr, uint64_t data, |
| 108 | unsigned size) |
bellard | 80cabfa | 2004-03-14 12:20:30 +0000 | [diff] [blame] | 109 | { |
| 110 | } |
| 111 | |
Julien Grall | c02e1ea | 2013-01-09 18:10:22 +0000 | [diff] [blame] | 112 | static uint64_t ioport80_read(void *opaque, hwaddr addr, unsigned size) |
| 113 | { |
Julien Grall | a6fc23e | 2013-01-11 16:41:43 +0000 | [diff] [blame] | 114 | return 0xffffffffffffffffULL; |
Julien Grall | c02e1ea | 2013-01-09 18:10:22 +0000 | [diff] [blame] | 115 | } |
| 116 | |
bellard | f929aad | 2004-05-08 21:03:41 +0000 | [diff] [blame] | 117 | /* MSDOS compatibility mode FPU exception support */ |
pbrook | d537cf6 | 2007-04-07 18:14:41 +0000 | [diff] [blame] | 118 | static qemu_irq ferr_irq; |
Isaku Yamahata | 8e78eb2 | 2010-05-14 16:29:09 +0900 | [diff] [blame] | 119 | |
| 120 | void pc_register_ferr_irq(qemu_irq irq) |
| 121 | { |
| 122 | ferr_irq = irq; |
| 123 | } |
| 124 | |
bellard | f929aad | 2004-05-08 21:03:41 +0000 | [diff] [blame] | 125 | /* XXX: add IGNNE support */ |
| 126 | void cpu_set_ferr(CPUX86State *s) |
| 127 | { |
pbrook | d537cf6 | 2007-04-07 18:14:41 +0000 | [diff] [blame] | 128 | qemu_irq_raise(ferr_irq); |
bellard | f929aad | 2004-05-08 21:03:41 +0000 | [diff] [blame] | 129 | } |
| 130 | |
Julien Grall | 258711c | 2012-09-19 12:50:08 +0100 | [diff] [blame] | 131 | static void ioportF0_write(void *opaque, hwaddr addr, uint64_t data, |
| 132 | unsigned size) |
bellard | f929aad | 2004-05-08 21:03:41 +0000 | [diff] [blame] | 133 | { |
pbrook | d537cf6 | 2007-04-07 18:14:41 +0000 | [diff] [blame] | 134 | qemu_irq_lower(ferr_irq); |
bellard | f929aad | 2004-05-08 21:03:41 +0000 | [diff] [blame] | 135 | } |
| 136 | |
Julien Grall | c02e1ea | 2013-01-09 18:10:22 +0000 | [diff] [blame] | 137 | static uint64_t ioportF0_read(void *opaque, hwaddr addr, unsigned size) |
| 138 | { |
Julien Grall | a6fc23e | 2013-01-11 16:41:43 +0000 | [diff] [blame] | 139 | return 0xffffffffffffffffULL; |
Julien Grall | c02e1ea | 2013-01-09 18:10:22 +0000 | [diff] [blame] | 140 | } |
| 141 | |
bellard | 28ab0e2 | 2004-05-20 14:02:14 +0000 | [diff] [blame] | 142 | /* TSC handling */ |
bellard | 28ab0e2 | 2004-05-20 14:02:14 +0000 | [diff] [blame] | 143 | uint64_t cpu_get_tsc(CPUX86State *env) |
| 144 | { |
Anthony Liguori | 4a1418e | 2009-08-10 17:07:24 -0500 | [diff] [blame] | 145 | return cpu_get_ticks(); |
bellard | 28ab0e2 | 2004-05-20 14:02:14 +0000 | [diff] [blame] | 146 | } |
| 147 | |
bellard | a5954d5 | 2006-09-24 18:48:00 +0000 | [diff] [blame] | 148 | /* SMM support */ |
Isaku Yamahata | f885f1e | 2010-05-14 16:29:04 +0900 | [diff] [blame] | 149 | |
| 150 | static cpu_set_smm_t smm_set; |
| 151 | static void *smm_arg; |
| 152 | |
| 153 | void cpu_smm_register(cpu_set_smm_t callback, void *arg) |
| 154 | { |
| 155 | assert(smm_set == NULL); |
| 156 | assert(smm_arg == NULL); |
| 157 | smm_set = callback; |
| 158 | smm_arg = arg; |
| 159 | } |
| 160 | |
Andreas Färber | 4a8fa5d | 2012-03-14 01:38:23 +0100 | [diff] [blame] | 161 | void cpu_smm_update(CPUX86State *env) |
bellard | a5954d5 | 2006-09-24 18:48:00 +0000 | [diff] [blame] | 162 | { |
Isaku Yamahata | f885f1e | 2010-05-14 16:29:04 +0900 | [diff] [blame] | 163 | if (smm_set && smm_arg && env == first_cpu) |
| 164 | smm_set(!!(env->hflags & HF_SMM_MASK), smm_arg); |
bellard | a5954d5 | 2006-09-24 18:48:00 +0000 | [diff] [blame] | 165 | } |
| 166 | |
| 167 | |
bellard | 3de388f | 2005-07-02 18:11:44 +0000 | [diff] [blame] | 168 | /* IRQ handling */ |
Andreas Färber | 4a8fa5d | 2012-03-14 01:38:23 +0100 | [diff] [blame] | 169 | int cpu_get_pic_interrupt(CPUX86State *env) |
bellard | 3de388f | 2005-07-02 18:11:44 +0000 | [diff] [blame] | 170 | { |
| 171 | int intno; |
| 172 | |
Blue Swirl | cf6d64b | 2010-06-19 10:42:08 +0300 | [diff] [blame] | 173 | intno = apic_get_interrupt(env->apic_state); |
bellard | 3de388f | 2005-07-02 18:11:44 +0000 | [diff] [blame] | 174 | if (intno >= 0) { |
bellard | 3de388f | 2005-07-02 18:11:44 +0000 | [diff] [blame] | 175 | return intno; |
| 176 | } |
bellard | 3de388f | 2005-07-02 18:11:44 +0000 | [diff] [blame] | 177 | /* read the irq from the PIC */ |
Blue Swirl | cf6d64b | 2010-06-19 10:42:08 +0300 | [diff] [blame] | 178 | if (!apic_accept_pic_intr(env->apic_state)) { |
ths | 0e21e12 | 2007-10-09 03:08:56 +0000 | [diff] [blame] | 179 | return -1; |
Blue Swirl | cf6d64b | 2010-06-19 10:42:08 +0300 | [diff] [blame] | 180 | } |
ths | 0e21e12 | 2007-10-09 03:08:56 +0000 | [diff] [blame] | 181 | |
bellard | 3de388f | 2005-07-02 18:11:44 +0000 | [diff] [blame] | 182 | intno = pic_read_irq(isa_pic); |
| 183 | return intno; |
| 184 | } |
| 185 | |
pbrook | d537cf6 | 2007-04-07 18:14:41 +0000 | [diff] [blame] | 186 | static void pic_irq_request(void *opaque, int irq, int level) |
bellard | 3de388f | 2005-07-02 18:11:44 +0000 | [diff] [blame] | 187 | { |
Andreas Färber | 4a8fa5d | 2012-03-14 01:38:23 +0100 | [diff] [blame] | 188 | CPUX86State *env = first_cpu; |
aurel32 | a5b38b5 | 2008-04-13 16:08:30 +0000 | [diff] [blame] | 189 | |
Blue Swirl | 471fd34 | 2010-05-29 20:23:49 +0000 | [diff] [blame] | 190 | DPRINTF("pic_irqs: %s irq %d\n", level? "raise" : "lower", irq); |
aurel32 | d552947 | 2008-08-19 12:55:20 +0000 | [diff] [blame] | 191 | if (env->apic_state) { |
| 192 | while (env) { |
Blue Swirl | cf6d64b | 2010-06-19 10:42:08 +0300 | [diff] [blame] | 193 | if (apic_accept_pic_intr(env->apic_state)) { |
| 194 | apic_deliver_pic_intr(env->apic_state, level); |
| 195 | } |
aurel32 | d552947 | 2008-08-19 12:55:20 +0000 | [diff] [blame] | 196 | env = env->next_cpu; |
| 197 | } |
| 198 | } else { |
Andreas Färber | d8ed887 | 2013-01-17 22:30:20 +0100 | [diff] [blame] | 199 | CPUState *cs = CPU(x86_env_get_cpu(env)); |
| 200 | if (level) { |
Andreas Färber | c3affe5 | 2013-01-18 15:03:43 +0100 | [diff] [blame] | 201 | cpu_interrupt(cs, CPU_INTERRUPT_HARD); |
Andreas Färber | d8ed887 | 2013-01-17 22:30:20 +0100 | [diff] [blame] | 202 | } else { |
| 203 | cpu_reset_interrupt(cs, CPU_INTERRUPT_HARD); |
| 204 | } |
aurel32 | a5b38b5 | 2008-04-13 16:08:30 +0000 | [diff] [blame] | 205 | } |
bellard | 3de388f | 2005-07-02 18:11:44 +0000 | [diff] [blame] | 206 | } |
| 207 | |
bellard | b0a21b5 | 2004-03-31 18:58:38 +0000 | [diff] [blame] | 208 | /* PC cmos mappings */ |
| 209 | |
bellard | 80cabfa | 2004-03-14 12:20:30 +0000 | [diff] [blame] | 210 | #define REG_EQUIPMENT_BYTE 0x14 |
| 211 | |
Blue Swirl | d288c7b | 2011-02-12 21:23:12 +0000 | [diff] [blame] | 212 | static int cmos_get_fd_drive_type(FDriveType fd0) |
bellard | 777428f | 2004-05-23 16:26:20 +0000 | [diff] [blame] | 213 | { |
| 214 | int val; |
| 215 | |
| 216 | switch (fd0) { |
Blue Swirl | d288c7b | 2011-02-12 21:23:12 +0000 | [diff] [blame] | 217 | case FDRIVE_DRV_144: |
bellard | 777428f | 2004-05-23 16:26:20 +0000 | [diff] [blame] | 218 | /* 1.44 Mb 3"5 drive */ |
| 219 | val = 4; |
| 220 | break; |
Blue Swirl | d288c7b | 2011-02-12 21:23:12 +0000 | [diff] [blame] | 221 | case FDRIVE_DRV_288: |
bellard | 777428f | 2004-05-23 16:26:20 +0000 | [diff] [blame] | 222 | /* 2.88 Mb 3"5 drive */ |
| 223 | val = 5; |
| 224 | break; |
Blue Swirl | d288c7b | 2011-02-12 21:23:12 +0000 | [diff] [blame] | 225 | case FDRIVE_DRV_120: |
bellard | 777428f | 2004-05-23 16:26:20 +0000 | [diff] [blame] | 226 | /* 1.2 Mb 5"5 drive */ |
| 227 | val = 2; |
| 228 | break; |
Blue Swirl | d288c7b | 2011-02-12 21:23:12 +0000 | [diff] [blame] | 229 | case FDRIVE_DRV_NONE: |
bellard | 777428f | 2004-05-23 16:26:20 +0000 | [diff] [blame] | 230 | default: |
| 231 | val = 0; |
| 232 | break; |
| 233 | } |
| 234 | return val; |
| 235 | } |
| 236 | |
Markus Armbruster | 9139046 | 2012-07-10 11:12:38 +0200 | [diff] [blame] | 237 | static void cmos_init_hd(ISADevice *s, int type_ofs, int info_ofs, |
| 238 | int16_t cylinders, int8_t heads, int8_t sectors) |
bellard | ba6c237 | 2004-10-09 16:47:59 +0000 | [diff] [blame] | 239 | { |
bellard | ba6c237 | 2004-10-09 16:47:59 +0000 | [diff] [blame] | 240 | rtc_set_memory(s, type_ofs, 47); |
| 241 | rtc_set_memory(s, info_ofs, cylinders); |
| 242 | rtc_set_memory(s, info_ofs + 1, cylinders >> 8); |
| 243 | rtc_set_memory(s, info_ofs + 2, heads); |
| 244 | rtc_set_memory(s, info_ofs + 3, 0xff); |
| 245 | rtc_set_memory(s, info_ofs + 4, 0xff); |
| 246 | rtc_set_memory(s, info_ofs + 5, 0xc0 | ((heads > 8) << 3)); |
| 247 | rtc_set_memory(s, info_ofs + 6, cylinders); |
| 248 | rtc_set_memory(s, info_ofs + 7, cylinders >> 8); |
| 249 | rtc_set_memory(s, info_ofs + 8, sectors); |
| 250 | } |
| 251 | |
balrog | 6ac0e82 | 2007-10-31 01:54:04 +0000 | [diff] [blame] | 252 | /* convert boot_device letter to something recognizable by the bios */ |
| 253 | static int boot_device2nibble(char boot_device) |
| 254 | { |
| 255 | switch(boot_device) { |
| 256 | case 'a': |
| 257 | case 'b': |
| 258 | return 0x01; /* floppy boot */ |
| 259 | case 'c': |
| 260 | return 0x02; /* hard drive boot */ |
| 261 | case 'd': |
| 262 | return 0x03; /* CD-ROM boot */ |
| 263 | case 'n': |
| 264 | return 0x04; /* Network boot */ |
| 265 | } |
| 266 | return 0; |
| 267 | } |
| 268 | |
Isaku Yamahata | 1d914fa | 2010-05-14 16:29:17 +0900 | [diff] [blame] | 269 | static int set_boot_dev(ISADevice *s, const char *boot_device, int fd_bootchk) |
aurel32 | 0ecdffb | 2008-05-04 20:11:34 +0000 | [diff] [blame] | 270 | { |
| 271 | #define PC_MAX_BOOT_DEVICES 3 |
aurel32 | 0ecdffb | 2008-05-04 20:11:34 +0000 | [diff] [blame] | 272 | int nbds, bds[3] = { 0, }; |
| 273 | int i; |
| 274 | |
| 275 | nbds = strlen(boot_device); |
| 276 | if (nbds > PC_MAX_BOOT_DEVICES) { |
Markus Armbruster | 1ecda02 | 2010-02-18 17:25:24 +0100 | [diff] [blame] | 277 | error_report("Too many boot devices for PC"); |
aurel32 | 0ecdffb | 2008-05-04 20:11:34 +0000 | [diff] [blame] | 278 | return(1); |
| 279 | } |
| 280 | for (i = 0; i < nbds; i++) { |
| 281 | bds[i] = boot_device2nibble(boot_device[i]); |
| 282 | if (bds[i] == 0) { |
Markus Armbruster | 1ecda02 | 2010-02-18 17:25:24 +0100 | [diff] [blame] | 283 | error_report("Invalid boot device for PC: '%c'", |
| 284 | boot_device[i]); |
aurel32 | 0ecdffb | 2008-05-04 20:11:34 +0000 | [diff] [blame] | 285 | return(1); |
| 286 | } |
| 287 | } |
| 288 | rtc_set_memory(s, 0x3d, (bds[1] << 4) | bds[0]); |
Markus Armbruster | d9346e8 | 2010-02-17 18:07:48 +0100 | [diff] [blame] | 289 | rtc_set_memory(s, 0x38, (bds[2] << 4) | (fd_bootchk ? 0x0 : 0x1)); |
aurel32 | 0ecdffb | 2008-05-04 20:11:34 +0000 | [diff] [blame] | 290 | return(0); |
| 291 | } |
| 292 | |
Markus Armbruster | d9346e8 | 2010-02-17 18:07:48 +0100 | [diff] [blame] | 293 | static int pc_boot_set(void *opaque, const char *boot_device) |
| 294 | { |
| 295 | return set_boot_dev(opaque, boot_device, 0); |
| 296 | } |
| 297 | |
Markus Armbruster | c0897e0 | 2010-06-24 19:58:20 +0200 | [diff] [blame] | 298 | typedef struct pc_cmos_init_late_arg { |
| 299 | ISADevice *rtc_state; |
Markus Armbruster | 9139046 | 2012-07-10 11:12:38 +0200 | [diff] [blame] | 300 | BusState *idebus[2]; |
Markus Armbruster | c0897e0 | 2010-06-24 19:58:20 +0200 | [diff] [blame] | 301 | } pc_cmos_init_late_arg; |
| 302 | |
| 303 | static void pc_cmos_init_late(void *opaque) |
| 304 | { |
| 305 | pc_cmos_init_late_arg *arg = opaque; |
| 306 | ISADevice *s = arg->rtc_state; |
Markus Armbruster | 9139046 | 2012-07-10 11:12:38 +0200 | [diff] [blame] | 307 | int16_t cylinders; |
| 308 | int8_t heads, sectors; |
Markus Armbruster | c0897e0 | 2010-06-24 19:58:20 +0200 | [diff] [blame] | 309 | int val; |
Markus Armbruster | 2adc99b | 2012-07-10 11:12:53 +0200 | [diff] [blame] | 310 | int i, trans; |
Markus Armbruster | c0897e0 | 2010-06-24 19:58:20 +0200 | [diff] [blame] | 311 | |
Markus Armbruster | 9139046 | 2012-07-10 11:12:38 +0200 | [diff] [blame] | 312 | val = 0; |
| 313 | if (ide_get_geometry(arg->idebus[0], 0, |
| 314 | &cylinders, &heads, §ors) >= 0) { |
| 315 | cmos_init_hd(s, 0x19, 0x1b, cylinders, heads, sectors); |
| 316 | val |= 0xf0; |
| 317 | } |
| 318 | if (ide_get_geometry(arg->idebus[0], 1, |
| 319 | &cylinders, &heads, §ors) >= 0) { |
| 320 | cmos_init_hd(s, 0x1a, 0x24, cylinders, heads, sectors); |
| 321 | val |= 0x0f; |
| 322 | } |
| 323 | rtc_set_memory(s, 0x12, val); |
Markus Armbruster | c0897e0 | 2010-06-24 19:58:20 +0200 | [diff] [blame] | 324 | |
| 325 | val = 0; |
| 326 | for (i = 0; i < 4; i++) { |
Markus Armbruster | 9139046 | 2012-07-10 11:12:38 +0200 | [diff] [blame] | 327 | /* NOTE: ide_get_geometry() returns the physical |
| 328 | geometry. It is always such that: 1 <= sects <= 63, 1 |
| 329 | <= heads <= 16, 1 <= cylinders <= 16383. The BIOS |
| 330 | geometry can be different if a translation is done. */ |
| 331 | if (ide_get_geometry(arg->idebus[i / 2], i % 2, |
| 332 | &cylinders, &heads, §ors) >= 0) { |
Markus Armbruster | 2adc99b | 2012-07-10 11:12:53 +0200 | [diff] [blame] | 333 | trans = ide_get_bios_chs_trans(arg->idebus[i / 2], i % 2) - 1; |
| 334 | assert((trans & ~3) == 0); |
| 335 | val |= trans << (i * 2); |
Markus Armbruster | c0897e0 | 2010-06-24 19:58:20 +0200 | [diff] [blame] | 336 | } |
| 337 | } |
| 338 | rtc_set_memory(s, 0x39, val); |
| 339 | |
| 340 | qemu_unregister_reset(pc_cmos_init_late, opaque); |
| 341 | } |
| 342 | |
Igor Mammedov | b8b7456 | 2013-04-23 10:29:40 +0200 | [diff] [blame] | 343 | typedef struct RTCCPUHotplugArg { |
| 344 | Notifier cpu_added_notifier; |
| 345 | ISADevice *rtc_state; |
| 346 | } RTCCPUHotplugArg; |
| 347 | |
| 348 | static void rtc_notify_cpu_added(Notifier *notifier, void *data) |
| 349 | { |
| 350 | RTCCPUHotplugArg *arg = container_of(notifier, RTCCPUHotplugArg, |
| 351 | cpu_added_notifier); |
| 352 | ISADevice *s = arg->rtc_state; |
| 353 | |
| 354 | /* increment the number of CPUs */ |
| 355 | rtc_set_memory(s, 0x5f, rtc_get_memory(s, 0x5f) + 1); |
| 356 | } |
| 357 | |
Isaku Yamahata | 845773a | 2010-05-14 16:29:15 +0900 | [diff] [blame] | 358 | void pc_cmos_init(ram_addr_t ram_size, ram_addr_t above_4g_mem_size, |
Markus Armbruster | c0897e0 | 2010-06-24 19:58:20 +0200 | [diff] [blame] | 359 | const char *boot_device, |
Kevin Wolf | 34d4260 | 2011-10-20 16:37:26 +0200 | [diff] [blame] | 360 | ISADevice *floppy, BusState *idebus0, BusState *idebus1, |
Blue Swirl | 63ffb56 | 2011-02-05 16:32:23 +0000 | [diff] [blame] | 361 | ISADevice *s) |
bellard | 80cabfa | 2004-03-14 12:20:30 +0000 | [diff] [blame] | 362 | { |
Markus Armbruster | 61a8d64 | 2012-07-10 11:12:27 +0200 | [diff] [blame] | 363 | int val, nb, i; |
Peter Maydell | 980bda8 | 2011-11-09 21:59:50 +0000 | [diff] [blame] | 364 | FDriveType fd_type[2] = { FDRIVE_DRV_NONE, FDRIVE_DRV_NONE }; |
Markus Armbruster | c0897e0 | 2010-06-24 19:58:20 +0200 | [diff] [blame] | 365 | static pc_cmos_init_late_arg arg; |
Igor Mammedov | b8b7456 | 2013-04-23 10:29:40 +0200 | [diff] [blame] | 366 | static RTCCPUHotplugArg cpu_hotplug_cb; |
bellard | 80cabfa | 2004-03-14 12:20:30 +0000 | [diff] [blame] | 367 | |
bellard | b0a21b5 | 2004-03-31 18:58:38 +0000 | [diff] [blame] | 368 | /* various important CMOS locations needed by PC/Bochs bios */ |
bellard | 80cabfa | 2004-03-14 12:20:30 +0000 | [diff] [blame] | 369 | |
| 370 | /* memory size */ |
Markus Armbruster | e89001f | 2012-08-15 13:12:20 +0200 | [diff] [blame] | 371 | /* base memory (first MiB) */ |
| 372 | val = MIN(ram_size / 1024, 640); |
bellard | 333190e | 2004-04-07 20:51:30 +0000 | [diff] [blame] | 373 | rtc_set_memory(s, 0x15, val); |
| 374 | rtc_set_memory(s, 0x16, val >> 8); |
Markus Armbruster | e89001f | 2012-08-15 13:12:20 +0200 | [diff] [blame] | 375 | /* extended memory (next 64MiB) */ |
| 376 | if (ram_size > 1024 * 1024) { |
| 377 | val = (ram_size - 1024 * 1024) / 1024; |
| 378 | } else { |
| 379 | val = 0; |
| 380 | } |
bellard | 80cabfa | 2004-03-14 12:20:30 +0000 | [diff] [blame] | 381 | if (val > 65535) |
| 382 | val = 65535; |
bellard | b0a21b5 | 2004-03-31 18:58:38 +0000 | [diff] [blame] | 383 | rtc_set_memory(s, 0x17, val); |
| 384 | rtc_set_memory(s, 0x18, val >> 8); |
| 385 | rtc_set_memory(s, 0x30, val); |
| 386 | rtc_set_memory(s, 0x31, val >> 8); |
Markus Armbruster | e89001f | 2012-08-15 13:12:20 +0200 | [diff] [blame] | 387 | /* memory between 16MiB and 4GiB */ |
| 388 | if (ram_size > 16 * 1024 * 1024) { |
| 389 | val = (ram_size - 16 * 1024 * 1024) / 65536; |
| 390 | } else { |
bellard | 9da9886 | 2004-06-26 15:53:17 +0000 | [diff] [blame] | 391 | val = 0; |
Markus Armbruster | e89001f | 2012-08-15 13:12:20 +0200 | [diff] [blame] | 392 | } |
bellard | 80cabfa | 2004-03-14 12:20:30 +0000 | [diff] [blame] | 393 | if (val > 65535) |
| 394 | val = 65535; |
bellard | b0a21b5 | 2004-03-31 18:58:38 +0000 | [diff] [blame] | 395 | rtc_set_memory(s, 0x34, val); |
| 396 | rtc_set_memory(s, 0x35, val >> 8); |
Markus Armbruster | e89001f | 2012-08-15 13:12:20 +0200 | [diff] [blame] | 397 | /* memory above 4GiB */ |
| 398 | val = above_4g_mem_size / 65536; |
| 399 | rtc_set_memory(s, 0x5b, val); |
| 400 | rtc_set_memory(s, 0x5c, val >> 8); |
| 401 | rtc_set_memory(s, 0x5d, val >> 16); |
ths | 3b46e62 | 2007-09-17 08:09:54 +0000 | [diff] [blame] | 402 | |
aurel32 | 298e01b | 2008-03-28 22:28:08 +0000 | [diff] [blame] | 403 | /* set the number of CPU */ |
| 404 | rtc_set_memory(s, 0x5f, smp_cpus - 1); |
Igor Mammedov | b8b7456 | 2013-04-23 10:29:40 +0200 | [diff] [blame] | 405 | /* init CPU hotplug notifier */ |
| 406 | cpu_hotplug_cb.rtc_state = s; |
| 407 | cpu_hotplug_cb.cpu_added_notifier.notify = rtc_notify_cpu_added; |
| 408 | qemu_register_cpu_added_notifier(&cpu_hotplug_cb.cpu_added_notifier); |
aurel32 | 298e01b | 2008-03-28 22:28:08 +0000 | [diff] [blame] | 409 | |
balrog | 6ac0e82 | 2007-10-31 01:54:04 +0000 | [diff] [blame] | 410 | /* set boot devices, and disable floppy signature check if requested */ |
Markus Armbruster | d9346e8 | 2010-02-17 18:07:48 +0100 | [diff] [blame] | 411 | if (set_boot_dev(s, boot_device, fd_bootchk)) { |
j_mayer | 28c5af5 | 2007-11-11 01:50:45 +0000 | [diff] [blame] | 412 | exit(1); |
| 413 | } |
bellard | 80cabfa | 2004-03-14 12:20:30 +0000 | [diff] [blame] | 414 | |
bellard | b41a2cd | 2004-03-14 21:46:48 +0000 | [diff] [blame] | 415 | /* floppy type */ |
Kevin Wolf | 34d4260 | 2011-10-20 16:37:26 +0200 | [diff] [blame] | 416 | if (floppy) { |
Kevin Wolf | 34d4260 | 2011-10-20 16:37:26 +0200 | [diff] [blame] | 417 | for (i = 0; i < 2; i++) { |
Markus Armbruster | 61a8d64 | 2012-07-10 11:12:27 +0200 | [diff] [blame] | 418 | fd_type[i] = isa_fdc_get_drive_type(floppy, i); |
Blue Swirl | 63ffb56 | 2011-02-05 16:32:23 +0000 | [diff] [blame] | 419 | } |
| 420 | } |
| 421 | val = (cmos_get_fd_drive_type(fd_type[0]) << 4) | |
| 422 | cmos_get_fd_drive_type(fd_type[1]); |
bellard | b0a21b5 | 2004-03-31 18:58:38 +0000 | [diff] [blame] | 423 | rtc_set_memory(s, 0x10, val); |
ths | 3b46e62 | 2007-09-17 08:09:54 +0000 | [diff] [blame] | 424 | |
bellard | b0a21b5 | 2004-03-31 18:58:38 +0000 | [diff] [blame] | 425 | val = 0; |
bellard | b41a2cd | 2004-03-14 21:46:48 +0000 | [diff] [blame] | 426 | nb = 0; |
Blue Swirl | 63ffb56 | 2011-02-05 16:32:23 +0000 | [diff] [blame] | 427 | if (fd_type[0] < FDRIVE_DRV_NONE) { |
bellard | 80cabfa | 2004-03-14 12:20:30 +0000 | [diff] [blame] | 428 | nb++; |
Blue Swirl | d288c7b | 2011-02-12 21:23:12 +0000 | [diff] [blame] | 429 | } |
Blue Swirl | 63ffb56 | 2011-02-05 16:32:23 +0000 | [diff] [blame] | 430 | if (fd_type[1] < FDRIVE_DRV_NONE) { |
bellard | 80cabfa | 2004-03-14 12:20:30 +0000 | [diff] [blame] | 431 | nb++; |
Blue Swirl | d288c7b | 2011-02-12 21:23:12 +0000 | [diff] [blame] | 432 | } |
bellard | 80cabfa | 2004-03-14 12:20:30 +0000 | [diff] [blame] | 433 | switch (nb) { |
| 434 | case 0: |
| 435 | break; |
| 436 | case 1: |
bellard | b0a21b5 | 2004-03-31 18:58:38 +0000 | [diff] [blame] | 437 | val |= 0x01; /* 1 drive, ready for boot */ |
bellard | 80cabfa | 2004-03-14 12:20:30 +0000 | [diff] [blame] | 438 | break; |
| 439 | case 2: |
bellard | b0a21b5 | 2004-03-31 18:58:38 +0000 | [diff] [blame] | 440 | val |= 0x41; /* 2 drives, ready for boot */ |
bellard | 80cabfa | 2004-03-14 12:20:30 +0000 | [diff] [blame] | 441 | break; |
| 442 | } |
bellard | b0a21b5 | 2004-03-31 18:58:38 +0000 | [diff] [blame] | 443 | val |= 0x02; /* FPU is there */ |
| 444 | val |= 0x04; /* PS/2 mouse installed */ |
| 445 | rtc_set_memory(s, REG_EQUIPMENT_BYTE, val); |
| 446 | |
bellard | ba6c237 | 2004-10-09 16:47:59 +0000 | [diff] [blame] | 447 | /* hard drives */ |
Markus Armbruster | c0897e0 | 2010-06-24 19:58:20 +0200 | [diff] [blame] | 448 | arg.rtc_state = s; |
Markus Armbruster | 9139046 | 2012-07-10 11:12:38 +0200 | [diff] [blame] | 449 | arg.idebus[0] = idebus0; |
| 450 | arg.idebus[1] = idebus1; |
Markus Armbruster | c0897e0 | 2010-06-24 19:58:20 +0200 | [diff] [blame] | 451 | qemu_register_reset(pc_cmos_init_late, &arg); |
bellard | 80cabfa | 2004-03-14 12:20:30 +0000 | [diff] [blame] | 452 | } |
| 453 | |
Andreas Färber | a0881c6 | 2013-04-27 22:18:46 +0200 | [diff] [blame] | 454 | #define TYPE_PORT92 "port92" |
| 455 | #define PORT92(obj) OBJECT_CHECK(Port92State, (obj), TYPE_PORT92) |
| 456 | |
Blue Swirl | 4b78a80 | 2011-01-06 18:24:35 +0000 | [diff] [blame] | 457 | /* port 92 stuff: could be split off */ |
| 458 | typedef struct Port92State { |
Andreas Färber | a0881c6 | 2013-04-27 22:18:46 +0200 | [diff] [blame] | 459 | ISADevice parent_obj; |
| 460 | |
Richard Henderson | 23af670 | 2011-08-16 08:32:44 -0700 | [diff] [blame] | 461 | MemoryRegion io; |
Blue Swirl | 4b78a80 | 2011-01-06 18:24:35 +0000 | [diff] [blame] | 462 | uint8_t outport; |
| 463 | qemu_irq *a20_out; |
| 464 | } Port92State; |
| 465 | |
Alexander Graf | 93ef419 | 2012-10-08 13:24:52 +0200 | [diff] [blame] | 466 | static void port92_write(void *opaque, hwaddr addr, uint64_t val, |
| 467 | unsigned size) |
Blue Swirl | 4b78a80 | 2011-01-06 18:24:35 +0000 | [diff] [blame] | 468 | { |
| 469 | Port92State *s = opaque; |
| 470 | |
| 471 | DPRINTF("port92: write 0x%02x\n", val); |
| 472 | s->outport = val; |
| 473 | qemu_set_irq(*s->a20_out, (val >> 1) & 1); |
| 474 | if (val & 1) { |
| 475 | qemu_system_reset_request(); |
| 476 | } |
| 477 | } |
| 478 | |
Alexander Graf | 93ef419 | 2012-10-08 13:24:52 +0200 | [diff] [blame] | 479 | static uint64_t port92_read(void *opaque, hwaddr addr, |
| 480 | unsigned size) |
Blue Swirl | 4b78a80 | 2011-01-06 18:24:35 +0000 | [diff] [blame] | 481 | { |
| 482 | Port92State *s = opaque; |
| 483 | uint32_t ret; |
| 484 | |
| 485 | ret = s->outport; |
| 486 | DPRINTF("port92: read 0x%02x\n", ret); |
| 487 | return ret; |
| 488 | } |
| 489 | |
| 490 | static void port92_init(ISADevice *dev, qemu_irq *a20_out) |
| 491 | { |
Andreas Färber | a0881c6 | 2013-04-27 22:18:46 +0200 | [diff] [blame] | 492 | Port92State *s = PORT92(dev); |
Blue Swirl | 4b78a80 | 2011-01-06 18:24:35 +0000 | [diff] [blame] | 493 | |
| 494 | s->a20_out = a20_out; |
| 495 | } |
| 496 | |
| 497 | static const VMStateDescription vmstate_port92_isa = { |
| 498 | .name = "port92", |
| 499 | .version_id = 1, |
| 500 | .minimum_version_id = 1, |
| 501 | .minimum_version_id_old = 1, |
| 502 | .fields = (VMStateField []) { |
| 503 | VMSTATE_UINT8(outport, Port92State), |
| 504 | VMSTATE_END_OF_LIST() |
| 505 | } |
| 506 | }; |
| 507 | |
| 508 | static void port92_reset(DeviceState *d) |
| 509 | { |
Andreas Färber | a0881c6 | 2013-04-27 22:18:46 +0200 | [diff] [blame] | 510 | Port92State *s = PORT92(d); |
Blue Swirl | 4b78a80 | 2011-01-06 18:24:35 +0000 | [diff] [blame] | 511 | |
| 512 | s->outport &= ~1; |
| 513 | } |
| 514 | |
Richard Henderson | 23af670 | 2011-08-16 08:32:44 -0700 | [diff] [blame] | 515 | static const MemoryRegionOps port92_ops = { |
Alexander Graf | 93ef419 | 2012-10-08 13:24:52 +0200 | [diff] [blame] | 516 | .read = port92_read, |
| 517 | .write = port92_write, |
| 518 | .impl = { |
| 519 | .min_access_size = 1, |
| 520 | .max_access_size = 1, |
| 521 | }, |
| 522 | .endianness = DEVICE_LITTLE_ENDIAN, |
Richard Henderson | 23af670 | 2011-08-16 08:32:44 -0700 | [diff] [blame] | 523 | }; |
| 524 | |
Andreas Färber | db895a1 | 2012-11-25 02:37:14 +0100 | [diff] [blame] | 525 | static void port92_initfn(Object *obj) |
Blue Swirl | 4b78a80 | 2011-01-06 18:24:35 +0000 | [diff] [blame] | 526 | { |
Andreas Färber | db895a1 | 2012-11-25 02:37:14 +0100 | [diff] [blame] | 527 | Port92State *s = PORT92(obj); |
Blue Swirl | 4b78a80 | 2011-01-06 18:24:35 +0000 | [diff] [blame] | 528 | |
Richard Henderson | 23af670 | 2011-08-16 08:32:44 -0700 | [diff] [blame] | 529 | memory_region_init_io(&s->io, &port92_ops, s, "port92", 1); |
Richard Henderson | 23af670 | 2011-08-16 08:32:44 -0700 | [diff] [blame] | 530 | |
Blue Swirl | 4b78a80 | 2011-01-06 18:24:35 +0000 | [diff] [blame] | 531 | s->outport = 0; |
Andreas Färber | db895a1 | 2012-11-25 02:37:14 +0100 | [diff] [blame] | 532 | } |
| 533 | |
| 534 | static void port92_realizefn(DeviceState *dev, Error **errp) |
| 535 | { |
| 536 | ISADevice *isadev = ISA_DEVICE(dev); |
| 537 | Port92State *s = PORT92(dev); |
| 538 | |
| 539 | isa_register_ioport(isadev, &s->io, 0x92); |
Blue Swirl | 4b78a80 | 2011-01-06 18:24:35 +0000 | [diff] [blame] | 540 | } |
| 541 | |
Anthony Liguori | 8f04ee0 | 2011-12-04 11:52:49 -0600 | [diff] [blame] | 542 | static void port92_class_initfn(ObjectClass *klass, void *data) |
| 543 | { |
Anthony Liguori | 39bffca | 2011-12-07 21:34:16 -0600 | [diff] [blame] | 544 | DeviceClass *dc = DEVICE_CLASS(klass); |
Andreas Färber | db895a1 | 2012-11-25 02:37:14 +0100 | [diff] [blame] | 545 | |
Anthony Liguori | 39bffca | 2011-12-07 21:34:16 -0600 | [diff] [blame] | 546 | dc->no_user = 1; |
Andreas Färber | db895a1 | 2012-11-25 02:37:14 +0100 | [diff] [blame] | 547 | dc->realize = port92_realizefn; |
Anthony Liguori | 39bffca | 2011-12-07 21:34:16 -0600 | [diff] [blame] | 548 | dc->reset = port92_reset; |
| 549 | dc->vmsd = &vmstate_port92_isa; |
Anthony Liguori | 8f04ee0 | 2011-12-04 11:52:49 -0600 | [diff] [blame] | 550 | } |
| 551 | |
Andreas Färber | 8c43a6f | 2013-01-10 16:19:07 +0100 | [diff] [blame] | 552 | static const TypeInfo port92_info = { |
Andreas Färber | a0881c6 | 2013-04-27 22:18:46 +0200 | [diff] [blame] | 553 | .name = TYPE_PORT92, |
Anthony Liguori | 39bffca | 2011-12-07 21:34:16 -0600 | [diff] [blame] | 554 | .parent = TYPE_ISA_DEVICE, |
| 555 | .instance_size = sizeof(Port92State), |
Andreas Färber | db895a1 | 2012-11-25 02:37:14 +0100 | [diff] [blame] | 556 | .instance_init = port92_initfn, |
Anthony Liguori | 39bffca | 2011-12-07 21:34:16 -0600 | [diff] [blame] | 557 | .class_init = port92_class_initfn, |
Blue Swirl | 4b78a80 | 2011-01-06 18:24:35 +0000 | [diff] [blame] | 558 | }; |
| 559 | |
Andreas Färber | 83f7d43 | 2012-02-09 15:20:55 +0100 | [diff] [blame] | 560 | static void port92_register_types(void) |
Blue Swirl | 4b78a80 | 2011-01-06 18:24:35 +0000 | [diff] [blame] | 561 | { |
Anthony Liguori | 39bffca | 2011-12-07 21:34:16 -0600 | [diff] [blame] | 562 | type_register_static(&port92_info); |
Blue Swirl | 4b78a80 | 2011-01-06 18:24:35 +0000 | [diff] [blame] | 563 | } |
Andreas Färber | 83f7d43 | 2012-02-09 15:20:55 +0100 | [diff] [blame] | 564 | |
| 565 | type_init(port92_register_types) |
Blue Swirl | 4b78a80 | 2011-01-06 18:24:35 +0000 | [diff] [blame] | 566 | |
Blue Swirl | 956a3e6 | 2010-05-22 07:59:01 +0000 | [diff] [blame] | 567 | static void handle_a20_line_change(void *opaque, int irq, int level) |
bellard | 59b8ad8 | 2005-11-21 23:34:32 +0000 | [diff] [blame] | 568 | { |
Andreas Färber | cc36a7a | 2013-01-18 15:19:06 +0100 | [diff] [blame] | 569 | X86CPU *cpu = opaque; |
Blue Swirl | 956a3e6 | 2010-05-22 07:59:01 +0000 | [diff] [blame] | 570 | |
bellard | 59b8ad8 | 2005-11-21 23:34:32 +0000 | [diff] [blame] | 571 | /* XXX: send to all CPUs ? */ |
Blue Swirl | 4b78a80 | 2011-01-06 18:24:35 +0000 | [diff] [blame] | 572 | /* XXX: add logic to handle multiple A20 line sources */ |
Andreas Färber | cc36a7a | 2013-01-18 15:19:06 +0100 | [diff] [blame] | 573 | x86_cpu_set_a20(cpu, level); |
bellard | e1a2374 | 2004-04-05 20:26:03 +0000 | [diff] [blame] | 574 | } |
| 575 | |
Jes Sorensen | 4c5b10b | 2010-02-15 18:33:46 +0100 | [diff] [blame] | 576 | int e820_add_entry(uint64_t address, uint64_t length, uint32_t type) |
| 577 | { |
Alex Williamson | 8ca209a | 2010-11-07 20:57:00 -0700 | [diff] [blame] | 578 | int index = le32_to_cpu(e820_table.count); |
Jes Sorensen | 4c5b10b | 2010-02-15 18:33:46 +0100 | [diff] [blame] | 579 | struct e820_entry *entry; |
| 580 | |
| 581 | if (index >= E820_NR_ENTRIES) |
| 582 | return -EBUSY; |
Alex Williamson | 8ca209a | 2010-11-07 20:57:00 -0700 | [diff] [blame] | 583 | entry = &e820_table.entry[index++]; |
Jes Sorensen | 4c5b10b | 2010-02-15 18:33:46 +0100 | [diff] [blame] | 584 | |
Alex Williamson | 8ca209a | 2010-11-07 20:57:00 -0700 | [diff] [blame] | 585 | entry->address = cpu_to_le64(address); |
| 586 | entry->length = cpu_to_le64(length); |
| 587 | entry->type = cpu_to_le32(type); |
Jes Sorensen | 4c5b10b | 2010-02-15 18:33:46 +0100 | [diff] [blame] | 588 | |
Alex Williamson | 8ca209a | 2010-11-07 20:57:00 -0700 | [diff] [blame] | 589 | e820_table.count = cpu_to_le32(index); |
| 590 | return index; |
Jes Sorensen | 4c5b10b | 2010-02-15 18:33:46 +0100 | [diff] [blame] | 591 | } |
| 592 | |
Eduardo Habkost | 1d934e8 | 2013-01-23 15:51:18 -0200 | [diff] [blame] | 593 | /* Calculates the limit to CPU APIC ID values |
| 594 | * |
| 595 | * This function returns the limit for the APIC ID value, so that all |
| 596 | * CPU APIC IDs are < pc_apic_id_limit(). |
| 597 | * |
| 598 | * This is used for FW_CFG_MAX_CPUS. See comments on bochs_bios_init(). |
| 599 | */ |
| 600 | static unsigned int pc_apic_id_limit(unsigned int max_cpus) |
| 601 | { |
| 602 | return x86_cpu_apic_id_from_index(max_cpus - 1) + 1; |
| 603 | } |
| 604 | |
Laszlo Ersek | a88b362 | 2013-04-16 02:24:08 +0200 | [diff] [blame] | 605 | static FWCfgState *bochs_bios_init(void) |
bellard | 80cabfa | 2004-03-14 12:20:30 +0000 | [diff] [blame] | 606 | { |
Laszlo Ersek | a88b362 | 2013-04-16 02:24:08 +0200 | [diff] [blame] | 607 | FWCfgState *fw_cfg; |
aliguori | b6f6e3d | 2009-04-17 18:59:56 +0000 | [diff] [blame] | 608 | uint8_t *smbios_table; |
| 609 | size_t smbios_len; |
aliguori | 11c2fd3 | 2009-04-21 22:31:41 +0000 | [diff] [blame] | 610 | uint64_t *numa_fw_cfg; |
| 611 | int i, j; |
Eduardo Habkost | 1d934e8 | 2013-01-23 15:51:18 -0200 | [diff] [blame] | 612 | unsigned int apic_id_limit = pc_apic_id_limit(max_cpus); |
blueswir1 | 3cce624 | 2008-09-18 18:27:29 +0000 | [diff] [blame] | 613 | |
| 614 | fw_cfg = fw_cfg_init(BIOS_CFG_IOPORT, BIOS_CFG_IOPORT + 1, 0, 0); |
Eduardo Habkost | 1d934e8 | 2013-01-23 15:51:18 -0200 | [diff] [blame] | 615 | /* FW_CFG_MAX_CPUS is a bit confusing/problematic on x86: |
| 616 | * |
| 617 | * SeaBIOS needs FW_CFG_MAX_CPUS for CPU hotplug, but the CPU hotplug |
| 618 | * QEMU<->SeaBIOS interface is not based on the "CPU index", but on the APIC |
| 619 | * ID of hotplugged CPUs[1]. This means that FW_CFG_MAX_CPUS is not the |
| 620 | * "maximum number of CPUs", but the "limit to the APIC ID values SeaBIOS |
| 621 | * may see". |
| 622 | * |
| 623 | * So, this means we must not use max_cpus, here, but the maximum possible |
| 624 | * APIC ID value, plus one. |
| 625 | * |
| 626 | * [1] The only kind of "CPU identifier" used between SeaBIOS and QEMU is |
| 627 | * the APIC ID, not the "CPU index" |
| 628 | */ |
| 629 | fw_cfg_add_i16(fw_cfg, FW_CFG_MAX_CPUS, (uint16_t)apic_id_limit); |
blueswir1 | 3cce624 | 2008-09-18 18:27:29 +0000 | [diff] [blame] | 630 | fw_cfg_add_i32(fw_cfg, FW_CFG_ID, 1); |
blueswir1 | 905fdcb | 2008-09-18 18:33:18 +0000 | [diff] [blame] | 631 | fw_cfg_add_i64(fw_cfg, FW_CFG_RAM_SIZE, (uint64_t)ram_size); |
Markus Armbruster | 089da57 | 2013-01-16 14:50:28 +0100 | [diff] [blame] | 632 | fw_cfg_add_bytes(fw_cfg, FW_CFG_ACPI_TABLES, |
| 633 | acpi_tables, acpi_tables_len); |
Jan Kiszka | 9b5b76d | 2011-10-15 14:08:26 +0200 | [diff] [blame] | 634 | fw_cfg_add_i32(fw_cfg, FW_CFG_IRQ0_OVERRIDE, kvm_allows_irq0_override()); |
aliguori | b6f6e3d | 2009-04-17 18:59:56 +0000 | [diff] [blame] | 635 | |
| 636 | smbios_table = smbios_get_table(&smbios_len); |
| 637 | if (smbios_table) |
| 638 | fw_cfg_add_bytes(fw_cfg, FW_CFG_SMBIOS_ENTRIES, |
| 639 | smbios_table, smbios_len); |
Markus Armbruster | 089da57 | 2013-01-16 14:50:28 +0100 | [diff] [blame] | 640 | fw_cfg_add_bytes(fw_cfg, FW_CFG_E820_TABLE, |
| 641 | &e820_table, sizeof(e820_table)); |
aliguori | 11c2fd3 | 2009-04-21 22:31:41 +0000 | [diff] [blame] | 642 | |
Markus Armbruster | 089da57 | 2013-01-16 14:50:28 +0100 | [diff] [blame] | 643 | fw_cfg_add_bytes(fw_cfg, FW_CFG_HPET, &hpet_cfg, sizeof(hpet_cfg)); |
aliguori | 11c2fd3 | 2009-04-21 22:31:41 +0000 | [diff] [blame] | 644 | /* allocate memory for the NUMA channel: one (64bit) word for the number |
| 645 | * of nodes, one word for each VCPU->node and one word for each node to |
| 646 | * hold the amount of memory. |
| 647 | */ |
Eduardo Habkost | 1d934e8 | 2013-01-23 15:51:18 -0200 | [diff] [blame] | 648 | numa_fw_cfg = g_new0(uint64_t, 1 + apic_id_limit + nb_numa_nodes); |
aliguori | 11c2fd3 | 2009-04-21 22:31:41 +0000 | [diff] [blame] | 649 | numa_fw_cfg[0] = cpu_to_le64(nb_numa_nodes); |
Vasilis Liaskovitis | 991dfef | 2011-10-26 14:19:00 +0200 | [diff] [blame] | 650 | for (i = 0; i < max_cpus; i++) { |
Eduardo Habkost | 1d934e8 | 2013-01-23 15:51:18 -0200 | [diff] [blame] | 651 | unsigned int apic_id = x86_cpu_apic_id_from_index(i); |
| 652 | assert(apic_id < apic_id_limit); |
aliguori | 11c2fd3 | 2009-04-21 22:31:41 +0000 | [diff] [blame] | 653 | for (j = 0; j < nb_numa_nodes; j++) { |
Chegu Vinod | ee785fe | 2012-07-16 21:31:30 -0700 | [diff] [blame] | 654 | if (test_bit(i, node_cpumask[j])) { |
Eduardo Habkost | 1d934e8 | 2013-01-23 15:51:18 -0200 | [diff] [blame] | 655 | numa_fw_cfg[apic_id + 1] = cpu_to_le64(j); |
aliguori | 11c2fd3 | 2009-04-21 22:31:41 +0000 | [diff] [blame] | 656 | break; |
| 657 | } |
| 658 | } |
| 659 | } |
| 660 | for (i = 0; i < nb_numa_nodes; i++) { |
Eduardo Habkost | 1d934e8 | 2013-01-23 15:51:18 -0200 | [diff] [blame] | 661 | numa_fw_cfg[apic_id_limit + 1 + i] = cpu_to_le64(node_mem[i]); |
aliguori | 11c2fd3 | 2009-04-21 22:31:41 +0000 | [diff] [blame] | 662 | } |
Markus Armbruster | 089da57 | 2013-01-16 14:50:28 +0100 | [diff] [blame] | 663 | fw_cfg_add_bytes(fw_cfg, FW_CFG_NUMA, numa_fw_cfg, |
Eduardo Habkost | 1d934e8 | 2013-01-23 15:51:18 -0200 | [diff] [blame] | 664 | (1 + apic_id_limit + nb_numa_nodes) * |
| 665 | sizeof(*numa_fw_cfg)); |
Alexander Graf | bf48339 | 2009-06-29 15:37:38 +0200 | [diff] [blame] | 666 | |
| 667 | return fw_cfg; |
bellard | 80cabfa | 2004-03-14 12:20:30 +0000 | [diff] [blame] | 668 | } |
| 669 | |
ths | 642a4f9 | 2007-05-19 21:04:38 +0000 | [diff] [blame] | 670 | static long get_file_size(FILE *f) |
| 671 | { |
| 672 | long where, size; |
| 673 | |
| 674 | /* XXX: on Unix systems, using fstat() probably makes more sense */ |
| 675 | |
| 676 | where = ftell(f); |
| 677 | fseek(f, 0, SEEK_END); |
| 678 | size = ftell(f); |
| 679 | fseek(f, where, SEEK_SET); |
| 680 | |
| 681 | return size; |
| 682 | } |
| 683 | |
Laszlo Ersek | a88b362 | 2013-04-16 02:24:08 +0200 | [diff] [blame] | 684 | static void load_linux(FWCfgState *fw_cfg, |
aliguori | 4fc9af5 | 2008-11-08 16:27:07 +0000 | [diff] [blame] | 685 | const char *kernel_filename, |
liguang | 0f9d76e | 2013-03-26 16:43:19 +0800 | [diff] [blame] | 686 | const char *initrd_filename, |
| 687 | const char *kernel_cmdline, |
Avi Kivity | a8170e5 | 2012-10-23 12:30:10 +0200 | [diff] [blame] | 688 | hwaddr max_ram_size) |
ths | 642a4f9 | 2007-05-19 21:04:38 +0000 | [diff] [blame] | 689 | { |
| 690 | uint16_t protocol; |
Paul Brook | 5cea859 | 2009-05-30 00:52:44 +0100 | [diff] [blame] | 691 | int setup_size, kernel_size, initrd_size = 0, cmdline_size; |
ths | 642a4f9 | 2007-05-19 21:04:38 +0000 | [diff] [blame] | 692 | uint32_t initrd_max; |
Alexander Graf | 57a46d0 | 2009-11-12 21:53:14 +0100 | [diff] [blame] | 693 | uint8_t header[8192], *setup, *kernel, *initrd_data; |
Avi Kivity | a8170e5 | 2012-10-23 12:30:10 +0200 | [diff] [blame] | 694 | hwaddr real_addr, prot_addr, cmdline_addr, initrd_addr = 0; |
Gerd Hoffmann | 45a50b1 | 2009-10-01 16:42:33 +0200 | [diff] [blame] | 695 | FILE *f; |
Pascal Terjan | bf4e5d9 | 2009-07-13 17:46:42 +0200 | [diff] [blame] | 696 | char *vmode; |
ths | 642a4f9 | 2007-05-19 21:04:38 +0000 | [diff] [blame] | 697 | |
| 698 | /* Align to 16 bytes as a paranoia measure */ |
| 699 | cmdline_size = (strlen(kernel_cmdline)+16) & ~15; |
| 700 | |
| 701 | /* load the kernel header */ |
| 702 | f = fopen(kernel_filename, "rb"); |
| 703 | if (!f || !(kernel_size = get_file_size(f)) || |
liguang | 0f9d76e | 2013-03-26 16:43:19 +0800 | [diff] [blame] | 704 | fread(header, 1, MIN(ARRAY_SIZE(header), kernel_size), f) != |
| 705 | MIN(ARRAY_SIZE(header), kernel_size)) { |
| 706 | fprintf(stderr, "qemu: could not load kernel '%s': %s\n", |
| 707 | kernel_filename, strerror(errno)); |
| 708 | exit(1); |
ths | 642a4f9 | 2007-05-19 21:04:38 +0000 | [diff] [blame] | 709 | } |
| 710 | |
| 711 | /* kernel protocol version */ |
bellard | bc4edd7 | 2007-11-07 16:54:42 +0000 | [diff] [blame] | 712 | #if 0 |
ths | 642a4f9 | 2007-05-19 21:04:38 +0000 | [diff] [blame] | 713 | fprintf(stderr, "header magic: %#x\n", ldl_p(header+0x202)); |
bellard | bc4edd7 | 2007-11-07 16:54:42 +0000 | [diff] [blame] | 714 | #endif |
liguang | 0f9d76e | 2013-03-26 16:43:19 +0800 | [diff] [blame] | 715 | if (ldl_p(header+0x202) == 0x53726448) { |
| 716 | protocol = lduw_p(header+0x206); |
| 717 | } else { |
| 718 | /* This looks like a multiboot kernel. If it is, let's stop |
| 719 | treating it like a Linux kernel. */ |
Adam Lackorzynski | 5200144 | 2009-12-26 14:13:46 +0100 | [diff] [blame] | 720 | if (load_multiboot(fw_cfg, f, kernel_filename, initrd_filename, |
liguang | 0f9d76e | 2013-03-26 16:43:19 +0800 | [diff] [blame] | 721 | kernel_cmdline, kernel_size, header)) { |
Blue Swirl | 82663ee | 2009-09-06 16:31:58 +0000 | [diff] [blame] | 722 | return; |
liguang | 0f9d76e | 2013-03-26 16:43:19 +0800 | [diff] [blame] | 723 | } |
| 724 | protocol = 0; |
Alexander Graf | f16408d | 2009-06-29 15:37:39 +0200 | [diff] [blame] | 725 | } |
ths | 642a4f9 | 2007-05-19 21:04:38 +0000 | [diff] [blame] | 726 | |
| 727 | if (protocol < 0x200 || !(header[0x211] & 0x01)) { |
liguang | 0f9d76e | 2013-03-26 16:43:19 +0800 | [diff] [blame] | 728 | /* Low kernel */ |
| 729 | real_addr = 0x90000; |
| 730 | cmdline_addr = 0x9a000 - cmdline_size; |
| 731 | prot_addr = 0x10000; |
ths | 642a4f9 | 2007-05-19 21:04:38 +0000 | [diff] [blame] | 732 | } else if (protocol < 0x202) { |
liguang | 0f9d76e | 2013-03-26 16:43:19 +0800 | [diff] [blame] | 733 | /* High but ancient kernel */ |
| 734 | real_addr = 0x90000; |
| 735 | cmdline_addr = 0x9a000 - cmdline_size; |
| 736 | prot_addr = 0x100000; |
ths | 642a4f9 | 2007-05-19 21:04:38 +0000 | [diff] [blame] | 737 | } else { |
liguang | 0f9d76e | 2013-03-26 16:43:19 +0800 | [diff] [blame] | 738 | /* High and recent kernel */ |
| 739 | real_addr = 0x10000; |
| 740 | cmdline_addr = 0x20000; |
| 741 | prot_addr = 0x100000; |
ths | 642a4f9 | 2007-05-19 21:04:38 +0000 | [diff] [blame] | 742 | } |
| 743 | |
bellard | bc4edd7 | 2007-11-07 16:54:42 +0000 | [diff] [blame] | 744 | #if 0 |
ths | 642a4f9 | 2007-05-19 21:04:38 +0000 | [diff] [blame] | 745 | fprintf(stderr, |
liguang | 0f9d76e | 2013-03-26 16:43:19 +0800 | [diff] [blame] | 746 | "qemu: real_addr = 0x" TARGET_FMT_plx "\n" |
| 747 | "qemu: cmdline_addr = 0x" TARGET_FMT_plx "\n" |
| 748 | "qemu: prot_addr = 0x" TARGET_FMT_plx "\n", |
| 749 | real_addr, |
| 750 | cmdline_addr, |
| 751 | prot_addr); |
bellard | bc4edd7 | 2007-11-07 16:54:42 +0000 | [diff] [blame] | 752 | #endif |
ths | 642a4f9 | 2007-05-19 21:04:38 +0000 | [diff] [blame] | 753 | |
| 754 | /* highest address for loading the initrd */ |
liguang | 0f9d76e | 2013-03-26 16:43:19 +0800 | [diff] [blame] | 755 | if (protocol >= 0x203) { |
| 756 | initrd_max = ldl_p(header+0x22c); |
| 757 | } else { |
| 758 | initrd_max = 0x37ffffff; |
| 759 | } |
ths | 642a4f9 | 2007-05-19 21:04:38 +0000 | [diff] [blame] | 760 | |
Glauber Costa | e6ade76 | 2009-05-18 16:35:58 -0400 | [diff] [blame] | 761 | if (initrd_max >= max_ram_size-ACPI_DATA_SIZE) |
| 762 | initrd_max = max_ram_size-ACPI_DATA_SIZE-1; |
ths | 642a4f9 | 2007-05-19 21:04:38 +0000 | [diff] [blame] | 763 | |
Alexander Graf | 57a46d0 | 2009-11-12 21:53:14 +0100 | [diff] [blame] | 764 | fw_cfg_add_i32(fw_cfg, FW_CFG_CMDLINE_ADDR, cmdline_addr); |
| 765 | fw_cfg_add_i32(fw_cfg, FW_CFG_CMDLINE_SIZE, strlen(kernel_cmdline)+1); |
Markus Armbruster | 96f8058 | 2013-01-16 14:50:25 +0100 | [diff] [blame] | 766 | fw_cfg_add_string(fw_cfg, FW_CFG_CMDLINE_DATA, kernel_cmdline); |
ths | 642a4f9 | 2007-05-19 21:04:38 +0000 | [diff] [blame] | 767 | |
| 768 | if (protocol >= 0x202) { |
liguang | 0f9d76e | 2013-03-26 16:43:19 +0800 | [diff] [blame] | 769 | stl_p(header+0x228, cmdline_addr); |
ths | 642a4f9 | 2007-05-19 21:04:38 +0000 | [diff] [blame] | 770 | } else { |
liguang | 0f9d76e | 2013-03-26 16:43:19 +0800 | [diff] [blame] | 771 | stw_p(header+0x20, 0xA33F); |
| 772 | stw_p(header+0x22, cmdline_addr-real_addr); |
ths | 642a4f9 | 2007-05-19 21:04:38 +0000 | [diff] [blame] | 773 | } |
| 774 | |
Pascal Terjan | bf4e5d9 | 2009-07-13 17:46:42 +0200 | [diff] [blame] | 775 | /* handle vga= parameter */ |
| 776 | vmode = strstr(kernel_cmdline, "vga="); |
| 777 | if (vmode) { |
| 778 | unsigned int video_mode; |
| 779 | /* skip "vga=" */ |
| 780 | vmode += 4; |
| 781 | if (!strncmp(vmode, "normal", 6)) { |
| 782 | video_mode = 0xffff; |
| 783 | } else if (!strncmp(vmode, "ext", 3)) { |
| 784 | video_mode = 0xfffe; |
| 785 | } else if (!strncmp(vmode, "ask", 3)) { |
| 786 | video_mode = 0xfffd; |
| 787 | } else { |
| 788 | video_mode = strtol(vmode, NULL, 0); |
| 789 | } |
| 790 | stw_p(header+0x1fa, video_mode); |
| 791 | } |
| 792 | |
ths | 642a4f9 | 2007-05-19 21:04:38 +0000 | [diff] [blame] | 793 | /* loader type */ |
Stefan Weil | 5cbdb3a | 2012-04-07 09:23:39 +0200 | [diff] [blame] | 794 | /* High nybble = B reserved for QEMU; low nybble is revision number. |
ths | 642a4f9 | 2007-05-19 21:04:38 +0000 | [diff] [blame] | 795 | If this code is substantially changed, you may want to consider |
| 796 | incrementing the revision. */ |
liguang | 0f9d76e | 2013-03-26 16:43:19 +0800 | [diff] [blame] | 797 | if (protocol >= 0x200) { |
| 798 | header[0x210] = 0xB0; |
| 799 | } |
ths | 642a4f9 | 2007-05-19 21:04:38 +0000 | [diff] [blame] | 800 | /* heap */ |
| 801 | if (protocol >= 0x201) { |
liguang | 0f9d76e | 2013-03-26 16:43:19 +0800 | [diff] [blame] | 802 | header[0x211] |= 0x80; /* CAN_USE_HEAP */ |
| 803 | stw_p(header+0x224, cmdline_addr-real_addr-0x200); |
ths | 642a4f9 | 2007-05-19 21:04:38 +0000 | [diff] [blame] | 804 | } |
| 805 | |
| 806 | /* load initrd */ |
| 807 | if (initrd_filename) { |
liguang | 0f9d76e | 2013-03-26 16:43:19 +0800 | [diff] [blame] | 808 | if (protocol < 0x200) { |
| 809 | fprintf(stderr, "qemu: linux kernel too old to load a ram disk\n"); |
| 810 | exit(1); |
| 811 | } |
ths | 642a4f9 | 2007-05-19 21:04:38 +0000 | [diff] [blame] | 812 | |
liguang | 0f9d76e | 2013-03-26 16:43:19 +0800 | [diff] [blame] | 813 | initrd_size = get_image_size(initrd_filename); |
M. Mohan Kumar | d6fa4b7 | 2010-04-12 10:01:33 +0530 | [diff] [blame] | 814 | if (initrd_size < 0) { |
| 815 | fprintf(stderr, "qemu: error reading initrd %s\n", |
| 816 | initrd_filename); |
| 817 | exit(1); |
| 818 | } |
| 819 | |
Gerd Hoffmann | 45a50b1 | 2009-10-01 16:42:33 +0200 | [diff] [blame] | 820 | initrd_addr = (initrd_max-initrd_size) & ~4095; |
Alexander Graf | 57a46d0 | 2009-11-12 21:53:14 +0100 | [diff] [blame] | 821 | |
Anthony Liguori | 7267c09 | 2011-08-20 22:09:37 -0500 | [diff] [blame] | 822 | initrd_data = g_malloc(initrd_size); |
Alexander Graf | 57a46d0 | 2009-11-12 21:53:14 +0100 | [diff] [blame] | 823 | load_image(initrd_filename, initrd_data); |
| 824 | |
| 825 | fw_cfg_add_i32(fw_cfg, FW_CFG_INITRD_ADDR, initrd_addr); |
| 826 | fw_cfg_add_i32(fw_cfg, FW_CFG_INITRD_SIZE, initrd_size); |
| 827 | fw_cfg_add_bytes(fw_cfg, FW_CFG_INITRD_DATA, initrd_data, initrd_size); |
ths | 642a4f9 | 2007-05-19 21:04:38 +0000 | [diff] [blame] | 828 | |
liguang | 0f9d76e | 2013-03-26 16:43:19 +0800 | [diff] [blame] | 829 | stl_p(header+0x218, initrd_addr); |
| 830 | stl_p(header+0x21c, initrd_size); |
ths | 642a4f9 | 2007-05-19 21:04:38 +0000 | [diff] [blame] | 831 | } |
| 832 | |
Gerd Hoffmann | 45a50b1 | 2009-10-01 16:42:33 +0200 | [diff] [blame] | 833 | /* load kernel and setup */ |
ths | 642a4f9 | 2007-05-19 21:04:38 +0000 | [diff] [blame] | 834 | setup_size = header[0x1f1]; |
liguang | 0f9d76e | 2013-03-26 16:43:19 +0800 | [diff] [blame] | 835 | if (setup_size == 0) { |
| 836 | setup_size = 4; |
| 837 | } |
ths | 642a4f9 | 2007-05-19 21:04:38 +0000 | [diff] [blame] | 838 | setup_size = (setup_size+1)*512; |
Gerd Hoffmann | 45a50b1 | 2009-10-01 16:42:33 +0200 | [diff] [blame] | 839 | kernel_size -= setup_size; |
ths | 642a4f9 | 2007-05-19 21:04:38 +0000 | [diff] [blame] | 840 | |
Anthony Liguori | 7267c09 | 2011-08-20 22:09:37 -0500 | [diff] [blame] | 841 | setup = g_malloc(setup_size); |
| 842 | kernel = g_malloc(kernel_size); |
Gerd Hoffmann | 45a50b1 | 2009-10-01 16:42:33 +0200 | [diff] [blame] | 843 | fseek(f, 0, SEEK_SET); |
Kirill A. Shutemov | 5a41ecc | 2009-12-25 18:19:17 +0000 | [diff] [blame] | 844 | if (fread(setup, 1, setup_size, f) != setup_size) { |
| 845 | fprintf(stderr, "fread() failed\n"); |
| 846 | exit(1); |
| 847 | } |
| 848 | if (fread(kernel, 1, kernel_size, f) != kernel_size) { |
| 849 | fprintf(stderr, "fread() failed\n"); |
| 850 | exit(1); |
| 851 | } |
ths | 642a4f9 | 2007-05-19 21:04:38 +0000 | [diff] [blame] | 852 | fclose(f); |
Gerd Hoffmann | 45a50b1 | 2009-10-01 16:42:33 +0200 | [diff] [blame] | 853 | memcpy(setup, header, MIN(sizeof(header), setup_size)); |
ths | 642a4f9 | 2007-05-19 21:04:38 +0000 | [diff] [blame] | 854 | |
Alexander Graf | 57a46d0 | 2009-11-12 21:53:14 +0100 | [diff] [blame] | 855 | fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_ADDR, prot_addr); |
| 856 | fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_SIZE, kernel_size); |
| 857 | fw_cfg_add_bytes(fw_cfg, FW_CFG_KERNEL_DATA, kernel, kernel_size); |
ths | 642a4f9 | 2007-05-19 21:04:38 +0000 | [diff] [blame] | 858 | |
Alexander Graf | 57a46d0 | 2009-11-12 21:53:14 +0100 | [diff] [blame] | 859 | fw_cfg_add_i32(fw_cfg, FW_CFG_SETUP_ADDR, real_addr); |
| 860 | fw_cfg_add_i32(fw_cfg, FW_CFG_SETUP_SIZE, setup_size); |
| 861 | fw_cfg_add_bytes(fw_cfg, FW_CFG_SETUP_DATA, setup, setup_size); |
| 862 | |
Gleb Natapov | 2e55e84 | 2010-12-08 13:35:07 +0200 | [diff] [blame] | 863 | option_rom[nb_option_roms].name = "linuxboot.bin"; |
| 864 | option_rom[nb_option_roms].bootindex = 0; |
Alexander Graf | 57a46d0 | 2009-11-12 21:53:14 +0100 | [diff] [blame] | 865 | nb_option_roms++; |
ths | 642a4f9 | 2007-05-19 21:04:38 +0000 | [diff] [blame] | 866 | } |
| 867 | |
bellard | b41a2cd | 2004-03-14 21:46:48 +0000 | [diff] [blame] | 868 | #define NE2000_NB_MAX 6 |
| 869 | |
Blue Swirl | 675d6f8 | 2009-09-13 08:32:37 +0000 | [diff] [blame] | 870 | static const int ne2000_io[NE2000_NB_MAX] = { 0x300, 0x320, 0x340, 0x360, |
| 871 | 0x280, 0x380 }; |
| 872 | static const int ne2000_irq[NE2000_NB_MAX] = { 9, 10, 11, 3, 4, 5 }; |
bellard | b41a2cd | 2004-03-14 21:46:48 +0000 | [diff] [blame] | 873 | |
Blue Swirl | 675d6f8 | 2009-09-13 08:32:37 +0000 | [diff] [blame] | 874 | static const int parallel_io[MAX_PARALLEL_PORTS] = { 0x378, 0x278, 0x3bc }; |
| 875 | static const int parallel_irq[MAX_PARALLEL_PORTS] = { 7, 7, 7 }; |
bellard | 6508fe5 | 2005-01-15 12:02:56 +0000 | [diff] [blame] | 876 | |
Hervé Poussineau | 48a18b3 | 2011-12-15 22:09:51 +0100 | [diff] [blame] | 877 | void pc_init_ne2k_isa(ISABus *bus, NICInfo *nd) |
pbrook | a41b2ff | 2006-02-05 04:14:41 +0000 | [diff] [blame] | 878 | { |
| 879 | static int nb_ne2k = 0; |
| 880 | |
| 881 | if (nb_ne2k == NE2000_NB_MAX) |
| 882 | return; |
Hervé Poussineau | 48a18b3 | 2011-12-15 22:09:51 +0100 | [diff] [blame] | 883 | isa_ne2000_init(bus, ne2000_io[nb_ne2k], |
Gerd Hoffmann | 9453c5b | 2009-09-10 11:43:33 +0200 | [diff] [blame] | 884 | ne2000_irq[nb_ne2k], nd); |
pbrook | a41b2ff | 2006-02-05 04:14:41 +0000 | [diff] [blame] | 885 | nb_ne2k++; |
| 886 | } |
| 887 | |
Blue Swirl | 92a16d7 | 2010-06-19 07:47:42 +0000 | [diff] [blame] | 888 | DeviceState *cpu_get_current_apic(void) |
Blue Swirl | 0e26b7b | 2010-06-19 10:42:34 +0300 | [diff] [blame] | 889 | { |
| 890 | if (cpu_single_env) { |
| 891 | return cpu_single_env->apic_state; |
| 892 | } else { |
| 893 | return NULL; |
| 894 | } |
| 895 | } |
| 896 | |
Isaku Yamahata | 845773a | 2010-05-14 16:29:15 +0900 | [diff] [blame] | 897 | void pc_acpi_smi_interrupt(void *opaque, int irq, int level) |
Blue Swirl | 53b67b3 | 2010-03-29 19:23:52 +0000 | [diff] [blame] | 898 | { |
Andreas Färber | c3affe5 | 2013-01-18 15:03:43 +0100 | [diff] [blame] | 899 | X86CPU *cpu = opaque; |
Blue Swirl | 53b67b3 | 2010-03-29 19:23:52 +0000 | [diff] [blame] | 900 | |
| 901 | if (level) { |
Andreas Färber | c3affe5 | 2013-01-18 15:03:43 +0100 | [diff] [blame] | 902 | cpu_interrupt(CPU(cpu), CPU_INTERRUPT_SMI); |
Blue Swirl | 53b67b3 | 2010-03-29 19:23:52 +0000 | [diff] [blame] | 903 | } |
| 904 | } |
| 905 | |
Igor Mammedov | 62fc403 | 2013-04-29 18:54:13 +0200 | [diff] [blame] | 906 | static X86CPU *pc_new_cpu(const char *cpu_model, int64_t apic_id, |
| 907 | DeviceState *icc_bridge, Error **errp) |
Igor Mammedov | 3105093 | 2013-04-25 16:05:26 +0200 | [diff] [blame] | 908 | { |
| 909 | X86CPU *cpu; |
| 910 | Error *local_err = NULL; |
| 911 | |
Igor Mammedov | 62fc403 | 2013-04-29 18:54:13 +0200 | [diff] [blame] | 912 | cpu = cpu_x86_create(cpu_model, icc_bridge, errp); |
Igor Mammedov | 3105093 | 2013-04-25 16:05:26 +0200 | [diff] [blame] | 913 | if (!cpu) { |
| 914 | return cpu; |
| 915 | } |
| 916 | |
| 917 | object_property_set_int(OBJECT(cpu), apic_id, "apic-id", &local_err); |
| 918 | object_property_set_bool(OBJECT(cpu), true, "realized", &local_err); |
| 919 | |
| 920 | if (local_err) { |
| 921 | if (cpu != NULL) { |
| 922 | object_unref(OBJECT(cpu)); |
| 923 | cpu = NULL; |
| 924 | } |
| 925 | error_propagate(errp, local_err); |
| 926 | } |
| 927 | return cpu; |
| 928 | } |
| 929 | |
Igor Mammedov | c649983 | 2013-04-30 18:00:53 +0200 | [diff] [blame] | 930 | static const char *current_cpu_model; |
| 931 | |
| 932 | void pc_hot_add_cpu(const int64_t id, Error **errp) |
| 933 | { |
| 934 | DeviceState *icc_bridge; |
| 935 | int64_t apic_id = x86_cpu_apic_id_from_index(id); |
| 936 | |
| 937 | if (cpu_exists(apic_id)) { |
| 938 | error_setg(errp, "Unable to add CPU: %" PRIi64 |
| 939 | ", it already exists", id); |
| 940 | return; |
| 941 | } |
| 942 | |
| 943 | if (id >= max_cpus) { |
| 944 | error_setg(errp, "Unable to add CPU: %" PRIi64 |
| 945 | ", max allowed: %d", id, max_cpus - 1); |
| 946 | return; |
| 947 | } |
| 948 | |
| 949 | icc_bridge = DEVICE(object_resolve_path_type("icc-bridge", |
| 950 | TYPE_ICC_BRIDGE, NULL)); |
| 951 | pc_new_cpu(current_cpu_model, apic_id, icc_bridge, errp); |
| 952 | } |
| 953 | |
Igor Mammedov | 62fc403 | 2013-04-29 18:54:13 +0200 | [diff] [blame] | 954 | void pc_cpus_init(const char *cpu_model, DeviceState *icc_bridge) |
Isaku Yamahata | 7016647 | 2010-05-14 16:29:10 +0900 | [diff] [blame] | 955 | { |
| 956 | int i; |
Igor Mammedov | 53a89e2 | 2013-04-29 19:03:01 +0200 | [diff] [blame] | 957 | X86CPU *cpu = NULL; |
Igor Mammedov | 3105093 | 2013-04-25 16:05:26 +0200 | [diff] [blame] | 958 | Error *error = NULL; |
Isaku Yamahata | 7016647 | 2010-05-14 16:29:10 +0900 | [diff] [blame] | 959 | |
| 960 | /* init CPUs */ |
| 961 | if (cpu_model == NULL) { |
| 962 | #ifdef TARGET_X86_64 |
| 963 | cpu_model = "qemu64"; |
| 964 | #else |
| 965 | cpu_model = "qemu32"; |
| 966 | #endif |
| 967 | } |
Igor Mammedov | c649983 | 2013-04-30 18:00:53 +0200 | [diff] [blame] | 968 | current_cpu_model = cpu_model; |
Isaku Yamahata | 7016647 | 2010-05-14 16:29:10 +0900 | [diff] [blame] | 969 | |
Igor Mammedov | bdeec80 | 2012-10-13 22:35:39 +0200 | [diff] [blame] | 970 | for (i = 0; i < smp_cpus; i++) { |
Igor Mammedov | 53a89e2 | 2013-04-29 19:03:01 +0200 | [diff] [blame] | 971 | cpu = pc_new_cpu(cpu_model, x86_cpu_apic_id_from_index(i), |
| 972 | icc_bridge, &error); |
Igor Mammedov | 3105093 | 2013-04-25 16:05:26 +0200 | [diff] [blame] | 973 | if (error) { |
| 974 | fprintf(stderr, "%s\n", error_get_pretty(error)); |
| 975 | error_free(error); |
Igor Mammedov | bdeec80 | 2012-10-13 22:35:39 +0200 | [diff] [blame] | 976 | exit(1); |
| 977 | } |
Isaku Yamahata | 7016647 | 2010-05-14 16:29:10 +0900 | [diff] [blame] | 978 | } |
Igor Mammedov | 53a89e2 | 2013-04-29 19:03:01 +0200 | [diff] [blame] | 979 | |
| 980 | /* map APIC MMIO area if CPU has APIC */ |
| 981 | if (cpu && cpu->env.apic_state) { |
| 982 | /* XXX: what if the base changes? */ |
| 983 | sysbus_mmio_map_overlap(SYS_BUS_DEVICE(icc_bridge), 0, |
| 984 | APIC_DEFAULT_ADDRESS, 0x1000); |
| 985 | } |
Isaku Yamahata | 7016647 | 2010-05-14 16:29:10 +0900 | [diff] [blame] | 986 | } |
| 987 | |
Gerd Hoffmann | f7e4dd6 | 2012-12-03 10:47:27 +0100 | [diff] [blame] | 988 | void pc_acpi_init(const char *default_dsdt) |
| 989 | { |
Laszlo Ersek | c5a98cf | 2013-03-21 00:23:22 +0100 | [diff] [blame] | 990 | char *filename; |
Gerd Hoffmann | f7e4dd6 | 2012-12-03 10:47:27 +0100 | [diff] [blame] | 991 | |
| 992 | if (acpi_tables != NULL) { |
| 993 | /* manually set via -acpitable, leave it alone */ |
| 994 | return; |
| 995 | } |
| 996 | |
| 997 | filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, default_dsdt); |
| 998 | if (filename == NULL) { |
| 999 | fprintf(stderr, "WARNING: failed to find %s\n", default_dsdt); |
Laszlo Ersek | c5a98cf | 2013-03-21 00:23:22 +0100 | [diff] [blame] | 1000 | } else { |
| 1001 | char *arg; |
| 1002 | QemuOpts *opts; |
| 1003 | Error *err = NULL; |
| 1004 | |
| 1005 | arg = g_strdup_printf("file=%s", filename); |
| 1006 | |
| 1007 | /* creates a deep copy of "arg" */ |
| 1008 | opts = qemu_opts_parse(qemu_find_opts("acpi"), arg, 0); |
| 1009 | g_assert(opts != NULL); |
| 1010 | |
| 1011 | acpi_table_add(opts, &err); |
| 1012 | if (err) { |
| 1013 | fprintf(stderr, "WARNING: failed to load %s: %s\n", filename, |
| 1014 | error_get_pretty(err)); |
| 1015 | error_free(err); |
| 1016 | } |
| 1017 | g_free(arg); |
| 1018 | g_free(filename); |
Gerd Hoffmann | f7e4dd6 | 2012-12-03 10:47:27 +0100 | [diff] [blame] | 1019 | } |
Gerd Hoffmann | f7e4dd6 | 2012-12-03 10:47:27 +0100 | [diff] [blame] | 1020 | } |
| 1021 | |
Laszlo Ersek | a88b362 | 2013-04-16 02:24:08 +0200 | [diff] [blame] | 1022 | FWCfgState *pc_memory_init(MemoryRegion *system_memory, |
| 1023 | const char *kernel_filename, |
| 1024 | const char *kernel_cmdline, |
| 1025 | const char *initrd_filename, |
| 1026 | ram_addr_t below_4g_mem_size, |
| 1027 | ram_addr_t above_4g_mem_size, |
| 1028 | MemoryRegion *rom_memory, |
| 1029 | MemoryRegion **ram_memory) |
bellard | 80cabfa | 2004-03-14 12:20:30 +0000 | [diff] [blame] | 1030 | { |
Jordan Justen | cbc5b5f | 2012-02-21 23:18:51 -0800 | [diff] [blame] | 1031 | int linux_boot, i; |
| 1032 | MemoryRegion *ram, *option_rom_mr; |
Avi Kivity | 00cb2a9 | 2011-07-26 14:26:17 +0300 | [diff] [blame] | 1033 | MemoryRegion *ram_below_4g, *ram_above_4g; |
Laszlo Ersek | a88b362 | 2013-04-16 02:24:08 +0200 | [diff] [blame] | 1034 | FWCfgState *fw_cfg; |
bellard | d592d30 | 2005-07-23 19:05:37 +0000 | [diff] [blame] | 1035 | |
bellard | 80cabfa | 2004-03-14 12:20:30 +0000 | [diff] [blame] | 1036 | linux_boot = (kernel_filename != NULL); |
| 1037 | |
Avi Kivity | 00cb2a9 | 2011-07-26 14:26:17 +0300 | [diff] [blame] | 1038 | /* Allocate RAM. We allocate it as a single memory region and use |
Dong Xu Wang | 66a0a2c | 2011-11-29 16:52:39 +0800 | [diff] [blame] | 1039 | * aliases to address portions of it, mostly for backwards compatibility |
Avi Kivity | 00cb2a9 | 2011-07-26 14:26:17 +0300 | [diff] [blame] | 1040 | * with older qemus that used qemu_ram_alloc(). |
| 1041 | */ |
Anthony Liguori | 7267c09 | 2011-08-20 22:09:37 -0500 | [diff] [blame] | 1042 | ram = g_malloc(sizeof(*ram)); |
Avi Kivity | c5705a7 | 2011-12-20 15:59:12 +0200 | [diff] [blame] | 1043 | memory_region_init_ram(ram, "pc.ram", |
Avi Kivity | 00cb2a9 | 2011-07-26 14:26:17 +0300 | [diff] [blame] | 1044 | below_4g_mem_size + above_4g_mem_size); |
Avi Kivity | c5705a7 | 2011-12-20 15:59:12 +0200 | [diff] [blame] | 1045 | vmstate_register_ram_global(ram); |
Avi Kivity | ae0a546 | 2011-08-15 17:17:38 +0300 | [diff] [blame] | 1046 | *ram_memory = ram; |
Anthony Liguori | 7267c09 | 2011-08-20 22:09:37 -0500 | [diff] [blame] | 1047 | ram_below_4g = g_malloc(sizeof(*ram_below_4g)); |
Avi Kivity | 00cb2a9 | 2011-07-26 14:26:17 +0300 | [diff] [blame] | 1048 | memory_region_init_alias(ram_below_4g, "ram-below-4g", ram, |
| 1049 | 0, below_4g_mem_size); |
| 1050 | memory_region_add_subregion(system_memory, 0, ram_below_4g); |
Alex Williamson | bbe80ad | 2010-07-06 10:37:17 -0600 | [diff] [blame] | 1051 | if (above_4g_mem_size > 0) { |
Anthony Liguori | 7267c09 | 2011-08-20 22:09:37 -0500 | [diff] [blame] | 1052 | ram_above_4g = g_malloc(sizeof(*ram_above_4g)); |
Avi Kivity | 00cb2a9 | 2011-07-26 14:26:17 +0300 | [diff] [blame] | 1053 | memory_region_init_alias(ram_above_4g, "ram-above-4g", ram, |
| 1054 | below_4g_mem_size, above_4g_mem_size); |
| 1055 | memory_region_add_subregion(system_memory, 0x100000000ULL, |
| 1056 | ram_above_4g); |
Alex Williamson | bbe80ad | 2010-07-06 10:37:17 -0600 | [diff] [blame] | 1057 | } |
aliguori | 82b36dc | 2008-09-15 16:01:01 +0000 | [diff] [blame] | 1058 | |
Jordan Justen | cbc5b5f | 2012-02-21 23:18:51 -0800 | [diff] [blame] | 1059 | |
| 1060 | /* Initialize PC system firmware */ |
| 1061 | pc_system_firmware_init(rom_memory); |
ths | 9ae0255 | 2007-01-05 17:39:04 +0000 | [diff] [blame] | 1062 | |
Anthony Liguori | 7267c09 | 2011-08-20 22:09:37 -0500 | [diff] [blame] | 1063 | option_rom_mr = g_malloc(sizeof(*option_rom_mr)); |
Avi Kivity | c5705a7 | 2011-12-20 15:59:12 +0200 | [diff] [blame] | 1064 | memory_region_init_ram(option_rom_mr, "pc.rom", PC_ROM_SIZE); |
| 1065 | vmstate_register_ram_global(option_rom_mr); |
Jan Kiszka | 4463aee | 2011-09-21 20:49:29 +0200 | [diff] [blame] | 1066 | memory_region_add_subregion_overlap(rom_memory, |
Avi Kivity | 00cb2a9 | 2011-07-26 14:26:17 +0300 | [diff] [blame] | 1067 | PC_ROM_MIN_VGA, |
| 1068 | option_rom_mr, |
| 1069 | 1); |
pbrook | f753ff1 | 2009-04-09 20:59:05 +0000 | [diff] [blame] | 1070 | |
Alexander Graf | bf48339 | 2009-06-29 15:37:38 +0200 | [diff] [blame] | 1071 | fw_cfg = bochs_bios_init(); |
Gerd Hoffmann | 8832cb8 | 2010-01-08 15:25:40 +0100 | [diff] [blame] | 1072 | rom_set_fw(fw_cfg); |
Alexander Graf | 1d108d9 | 2009-06-29 15:37:37 +0200 | [diff] [blame] | 1073 | |
pbrook | f753ff1 | 2009-04-09 20:59:05 +0000 | [diff] [blame] | 1074 | if (linux_boot) { |
Eduard - Gabriel Munteanu | 81a204e | 2010-05-20 09:14:04 +0300 | [diff] [blame] | 1075 | load_linux(fw_cfg, kernel_filename, initrd_filename, kernel_cmdline, below_4g_mem_size); |
pbrook | f753ff1 | 2009-04-09 20:59:05 +0000 | [diff] [blame] | 1076 | } |
| 1077 | |
| 1078 | for (i = 0; i < nb_option_roms; i++) { |
Gleb Natapov | 2e55e84 | 2010-12-08 13:35:07 +0200 | [diff] [blame] | 1079 | rom_add_option(option_rom[i].name, option_rom[i].bootindex); |
Glauber Costa | 406c8df | 2009-06-17 09:05:30 -0400 | [diff] [blame] | 1080 | } |
Gleb Natapov | 459ae5e | 2012-06-04 14:31:55 +0300 | [diff] [blame] | 1081 | return fw_cfg; |
Isaku Yamahata | 3d53f5c | 2010-05-14 16:29:11 +0900 | [diff] [blame] | 1082 | } |
| 1083 | |
Isaku Yamahata | 845773a | 2010-05-14 16:29:15 +0900 | [diff] [blame] | 1084 | qemu_irq *pc_allocate_cpu_irq(void) |
| 1085 | { |
| 1086 | return qemu_allocate_irqs(pic_irq_request, NULL, 1); |
| 1087 | } |
| 1088 | |
Hervé Poussineau | 48a18b3 | 2011-12-15 22:09:51 +0100 | [diff] [blame] | 1089 | DeviceState *pc_vga_init(ISABus *isa_bus, PCIBus *pci_bus) |
Isaku Yamahata | 765d790 | 2010-05-14 16:29:12 +0900 | [diff] [blame] | 1090 | { |
Anthony Liguori | ad6d45f | 2011-12-12 14:29:41 -0600 | [diff] [blame] | 1091 | DeviceState *dev = NULL; |
| 1092 | |
Aurelien Jarno | 16094b7 | 2012-09-08 12:47:45 +0200 | [diff] [blame] | 1093 | if (pci_bus) { |
| 1094 | PCIDevice *pcidev = pci_vga_init(pci_bus); |
| 1095 | dev = pcidev ? &pcidev->qdev : NULL; |
| 1096 | } else if (isa_bus) { |
| 1097 | ISADevice *isadev = isa_vga_init(isa_bus); |
Andreas Färber | 4a17cc4 | 2013-06-07 13:49:13 +0200 | [diff] [blame^] | 1098 | dev = isadev ? DEVICE(isadev) : NULL; |
Isaku Yamahata | 765d790 | 2010-05-14 16:29:12 +0900 | [diff] [blame] | 1099 | } |
Anthony Liguori | ad6d45f | 2011-12-12 14:29:41 -0600 | [diff] [blame] | 1100 | return dev; |
Isaku Yamahata | 765d790 | 2010-05-14 16:29:12 +0900 | [diff] [blame] | 1101 | } |
| 1102 | |
Blue Swirl | 4556bd8 | 2010-05-22 08:00:52 +0000 | [diff] [blame] | 1103 | static void cpu_request_exit(void *opaque, int irq, int level) |
| 1104 | { |
Andreas Färber | 4a8fa5d | 2012-03-14 01:38:23 +0100 | [diff] [blame] | 1105 | CPUX86State *env = cpu_single_env; |
Blue Swirl | 4556bd8 | 2010-05-22 08:00:52 +0000 | [diff] [blame] | 1106 | |
| 1107 | if (env && level) { |
| 1108 | cpu_exit(env); |
| 1109 | } |
| 1110 | } |
| 1111 | |
Julien Grall | 258711c | 2012-09-19 12:50:08 +0100 | [diff] [blame] | 1112 | static const MemoryRegionOps ioport80_io_ops = { |
| 1113 | .write = ioport80_write, |
Julien Grall | c02e1ea | 2013-01-09 18:10:22 +0000 | [diff] [blame] | 1114 | .read = ioport80_read, |
Julien Grall | 258711c | 2012-09-19 12:50:08 +0100 | [diff] [blame] | 1115 | .endianness = DEVICE_NATIVE_ENDIAN, |
| 1116 | .impl = { |
| 1117 | .min_access_size = 1, |
| 1118 | .max_access_size = 1, |
| 1119 | }, |
| 1120 | }; |
| 1121 | |
| 1122 | static const MemoryRegionOps ioportF0_io_ops = { |
| 1123 | .write = ioportF0_write, |
Julien Grall | c02e1ea | 2013-01-09 18:10:22 +0000 | [diff] [blame] | 1124 | .read = ioportF0_read, |
Julien Grall | 258711c | 2012-09-19 12:50:08 +0100 | [diff] [blame] | 1125 | .endianness = DEVICE_NATIVE_ENDIAN, |
| 1126 | .impl = { |
| 1127 | .min_access_size = 1, |
| 1128 | .max_access_size = 1, |
| 1129 | }, |
| 1130 | }; |
| 1131 | |
Hervé Poussineau | 48a18b3 | 2011-12-15 22:09:51 +0100 | [diff] [blame] | 1132 | void pc_basic_device_init(ISABus *isa_bus, qemu_irq *gsi, |
Anthony PERARD | 1611977 | 2011-05-03 17:06:54 +0100 | [diff] [blame] | 1133 | ISADevice **rtc_state, |
Kevin Wolf | 34d4260 | 2011-10-20 16:37:26 +0200 | [diff] [blame] | 1134 | ISADevice **floppy, |
Anthony PERARD | 1611977 | 2011-05-03 17:06:54 +0100 | [diff] [blame] | 1135 | bool no_vmport) |
Isaku Yamahata | ffe513d | 2010-05-14 16:29:13 +0900 | [diff] [blame] | 1136 | { |
| 1137 | int i; |
| 1138 | DriveInfo *fd[MAX_FD]; |
Jan Kiszka | ce967e2 | 2012-02-01 20:31:41 +0100 | [diff] [blame] | 1139 | DeviceState *hpet = NULL; |
| 1140 | int pit_isa_irq = 0; |
| 1141 | qemu_irq pit_alt_irq = NULL; |
Jan Kiszka | 7d932df | 2010-06-13 14:15:40 +0200 | [diff] [blame] | 1142 | qemu_irq rtc_irq = NULL; |
Blue Swirl | 956a3e6 | 2010-05-22 07:59:01 +0000 | [diff] [blame] | 1143 | qemu_irq *a20_line; |
Stefano Stabellini | c2d8d31 | 2011-11-14 15:07:01 +0000 | [diff] [blame] | 1144 | ISADevice *i8042, *port92, *vmmouse, *pit = NULL; |
Blue Swirl | 4556bd8 | 2010-05-22 08:00:52 +0000 | [diff] [blame] | 1145 | qemu_irq *cpu_exit_irq; |
Julien Grall | 258711c | 2012-09-19 12:50:08 +0100 | [diff] [blame] | 1146 | MemoryRegion *ioport80_io = g_new(MemoryRegion, 1); |
| 1147 | MemoryRegion *ioportF0_io = g_new(MemoryRegion, 1); |
Isaku Yamahata | ffe513d | 2010-05-14 16:29:13 +0900 | [diff] [blame] | 1148 | |
Julien Grall | 258711c | 2012-09-19 12:50:08 +0100 | [diff] [blame] | 1149 | memory_region_init_io(ioport80_io, &ioport80_io_ops, NULL, "ioport80", 1); |
| 1150 | memory_region_add_subregion(isa_bus->address_space_io, 0x80, ioport80_io); |
Isaku Yamahata | ffe513d | 2010-05-14 16:29:13 +0900 | [diff] [blame] | 1151 | |
Julien Grall | 258711c | 2012-09-19 12:50:08 +0100 | [diff] [blame] | 1152 | memory_region_init_io(ioportF0_io, &ioportF0_io_ops, NULL, "ioportF0", 1); |
| 1153 | memory_region_add_subregion(isa_bus->address_space_io, 0xf0, ioportF0_io); |
Isaku Yamahata | ffe513d | 2010-05-14 16:29:13 +0900 | [diff] [blame] | 1154 | |
Jan Kiszka | 5d17c0d | 2012-03-02 20:28:49 +0100 | [diff] [blame] | 1155 | /* |
| 1156 | * Check if an HPET shall be created. |
| 1157 | * |
| 1158 | * Without KVM_CAP_PIT_STATE2, we cannot switch off the in-kernel PIT |
| 1159 | * when the HPET wants to take over. Thus we have to disable the latter. |
| 1160 | */ |
| 1161 | if (!no_hpet && (!kvm_irqchip_in_kernel() || kvm_has_pit_state2())) { |
Jan Kiszka | ce967e2 | 2012-02-01 20:31:41 +0100 | [diff] [blame] | 1162 | hpet = sysbus_try_create_simple("hpet", HPET_BASE, NULL); |
Jan Kiszka | 822557e | 2010-06-13 14:15:38 +0200 | [diff] [blame] | 1163 | |
Blue Swirl | dd703b9 | 2011-02-05 14:35:00 +0000 | [diff] [blame] | 1164 | if (hpet) { |
Jan Kiszka | b881fbe | 2011-10-07 09:19:35 +0200 | [diff] [blame] | 1165 | for (i = 0; i < GSI_NUM_PINS; i++) { |
Andreas Färber | 1356b98 | 2013-01-20 02:47:33 +0100 | [diff] [blame] | 1166 | sysbus_connect_irq(SYS_BUS_DEVICE(hpet), i, gsi[i]); |
Blue Swirl | dd703b9 | 2011-02-05 14:35:00 +0000 | [diff] [blame] | 1167 | } |
Jan Kiszka | ce967e2 | 2012-02-01 20:31:41 +0100 | [diff] [blame] | 1168 | pit_isa_irq = -1; |
| 1169 | pit_alt_irq = qdev_get_gpio_in(hpet, HPET_LEGACY_PIT_INT); |
| 1170 | rtc_irq = qdev_get_gpio_in(hpet, HPET_LEGACY_RTC_INT); |
Jan Kiszka | 822557e | 2010-06-13 14:15:38 +0200 | [diff] [blame] | 1171 | } |
Isaku Yamahata | ffe513d | 2010-05-14 16:29:13 +0900 | [diff] [blame] | 1172 | } |
Hervé Poussineau | 48a18b3 | 2011-12-15 22:09:51 +0100 | [diff] [blame] | 1173 | *rtc_state = rtc_init(isa_bus, 2000, rtc_irq); |
Jan Kiszka | 7d932df | 2010-06-13 14:15:40 +0200 | [diff] [blame] | 1174 | |
| 1175 | qemu_register_boot_set(pc_boot_set, *rtc_state); |
| 1176 | |
Stefano Stabellini | c2d8d31 | 2011-11-14 15:07:01 +0000 | [diff] [blame] | 1177 | if (!xen_enabled()) { |
| 1178 | if (kvm_irqchip_in_kernel()) { |
| 1179 | pit = kvm_pit_init(isa_bus, 0x40); |
| 1180 | } else { |
| 1181 | pit = pit_init(isa_bus, 0x40, pit_isa_irq, pit_alt_irq); |
| 1182 | } |
| 1183 | if (hpet) { |
| 1184 | /* connect PIT to output control line of the HPET */ |
Andreas Färber | 4a17cc4 | 2013-06-07 13:49:13 +0200 | [diff] [blame^] | 1185 | qdev_connect_gpio_out(hpet, 0, qdev_get_gpio_in(DEVICE(pit), 0)); |
Stefano Stabellini | c2d8d31 | 2011-11-14 15:07:01 +0000 | [diff] [blame] | 1186 | } |
| 1187 | pcspk_init(isa_bus, pit); |
Jan Kiszka | 5d17c0d | 2012-03-02 20:28:49 +0100 | [diff] [blame] | 1188 | } |
Isaku Yamahata | ffe513d | 2010-05-14 16:29:13 +0900 | [diff] [blame] | 1189 | |
| 1190 | for(i = 0; i < MAX_SERIAL_PORTS; i++) { |
| 1191 | if (serial_hds[i]) { |
Hervé Poussineau | 48a18b3 | 2011-12-15 22:09:51 +0100 | [diff] [blame] | 1192 | serial_isa_init(isa_bus, i, serial_hds[i]); |
Isaku Yamahata | ffe513d | 2010-05-14 16:29:13 +0900 | [diff] [blame] | 1193 | } |
| 1194 | } |
| 1195 | |
| 1196 | for(i = 0; i < MAX_PARALLEL_PORTS; i++) { |
| 1197 | if (parallel_hds[i]) { |
Hervé Poussineau | 48a18b3 | 2011-12-15 22:09:51 +0100 | [diff] [blame] | 1198 | parallel_init(isa_bus, i, parallel_hds[i]); |
Isaku Yamahata | ffe513d | 2010-05-14 16:29:13 +0900 | [diff] [blame] | 1199 | } |
| 1200 | } |
| 1201 | |
Andreas Färber | cc36a7a | 2013-01-18 15:19:06 +0100 | [diff] [blame] | 1202 | a20_line = qemu_allocate_irqs(handle_a20_line_change, |
| 1203 | x86_env_get_cpu(first_cpu), 2); |
Hervé Poussineau | 48a18b3 | 2011-12-15 22:09:51 +0100 | [diff] [blame] | 1204 | i8042 = isa_create_simple(isa_bus, "i8042"); |
Blue Swirl | 4b78a80 | 2011-01-06 18:24:35 +0000 | [diff] [blame] | 1205 | i8042_setup_a20_line(i8042, &a20_line[0]); |
Anthony PERARD | 1611977 | 2011-05-03 17:06:54 +0100 | [diff] [blame] | 1206 | if (!no_vmport) { |
Hervé Poussineau | 48a18b3 | 2011-12-15 22:09:51 +0100 | [diff] [blame] | 1207 | vmport_init(isa_bus); |
| 1208 | vmmouse = isa_try_create(isa_bus, "vmmouse"); |
Anthony PERARD | 1611977 | 2011-05-03 17:06:54 +0100 | [diff] [blame] | 1209 | } else { |
| 1210 | vmmouse = NULL; |
| 1211 | } |
Blue Swirl | 86d8641 | 2011-02-05 14:34:52 +0000 | [diff] [blame] | 1212 | if (vmmouse) { |
Andreas Färber | 4a17cc4 | 2013-06-07 13:49:13 +0200 | [diff] [blame^] | 1213 | DeviceState *dev = DEVICE(vmmouse); |
| 1214 | qdev_prop_set_ptr(dev, "ps2_mouse", i8042); |
| 1215 | qdev_init_nofail(dev); |
Blue Swirl | 86d8641 | 2011-02-05 14:34:52 +0000 | [diff] [blame] | 1216 | } |
Hervé Poussineau | 48a18b3 | 2011-12-15 22:09:51 +0100 | [diff] [blame] | 1217 | port92 = isa_create_simple(isa_bus, "port92"); |
Blue Swirl | 4b78a80 | 2011-01-06 18:24:35 +0000 | [diff] [blame] | 1218 | port92_init(port92, &a20_line[1]); |
Blue Swirl | 956a3e6 | 2010-05-22 07:59:01 +0000 | [diff] [blame] | 1219 | |
Blue Swirl | 4556bd8 | 2010-05-22 08:00:52 +0000 | [diff] [blame] | 1220 | cpu_exit_irq = qemu_allocate_irqs(cpu_request_exit, NULL, 1); |
| 1221 | DMA_init(0, cpu_exit_irq); |
Isaku Yamahata | ffe513d | 2010-05-14 16:29:13 +0900 | [diff] [blame] | 1222 | |
| 1223 | for(i = 0; i < MAX_FD; i++) { |
| 1224 | fd[i] = drive_get(IF_FLOPPY, 0, i); |
| 1225 | } |
Hervé Poussineau | 48a18b3 | 2011-12-15 22:09:51 +0100 | [diff] [blame] | 1226 | *floppy = fdctrl_init_isa(isa_bus, fd); |
Isaku Yamahata | ffe513d | 2010-05-14 16:29:13 +0900 | [diff] [blame] | 1227 | } |
| 1228 | |
Isaku Yamahata | 9011a1a | 2012-11-14 15:54:01 -0500 | [diff] [blame] | 1229 | void pc_nic_init(ISABus *isa_bus, PCIBus *pci_bus) |
| 1230 | { |
| 1231 | int i; |
| 1232 | |
| 1233 | for (i = 0; i < nb_nics; i++) { |
| 1234 | NICInfo *nd = &nd_table[i]; |
| 1235 | |
| 1236 | if (!pci_bus || (nd->model && strcmp(nd->model, "ne2k_isa") == 0)) { |
| 1237 | pc_init_ne2k_isa(isa_bus, nd); |
| 1238 | } else { |
| 1239 | pci_nic_init_nofail(nd, "e1000", NULL); |
| 1240 | } |
| 1241 | } |
| 1242 | } |
| 1243 | |
Isaku Yamahata | 845773a | 2010-05-14 16:29:15 +0900 | [diff] [blame] | 1244 | void pc_pci_device_init(PCIBus *pci_bus) |
Isaku Yamahata | e3a5cf4 | 2010-05-14 16:29:14 +0900 | [diff] [blame] | 1245 | { |
| 1246 | int max_bus; |
| 1247 | int bus; |
| 1248 | |
| 1249 | max_bus = drive_get_max_bus(IF_SCSI); |
| 1250 | for (bus = 0; bus <= max_bus; bus++) { |
| 1251 | pci_create_simple(pci_bus, -1, "lsi53c895a"); |
| 1252 | } |
| 1253 | } |
Jason Baron | a39e356 | 2012-11-14 15:54:01 -0500 | [diff] [blame] | 1254 | |
| 1255 | void ioapic_init_gsi(GSIState *gsi_state, const char *parent_name) |
| 1256 | { |
| 1257 | DeviceState *dev; |
| 1258 | SysBusDevice *d; |
| 1259 | unsigned int i; |
| 1260 | |
| 1261 | if (kvm_irqchip_in_kernel()) { |
| 1262 | dev = qdev_create(NULL, "kvm-ioapic"); |
| 1263 | } else { |
| 1264 | dev = qdev_create(NULL, "ioapic"); |
| 1265 | } |
| 1266 | if (parent_name) { |
| 1267 | object_property_add_child(object_resolve_path(parent_name, NULL), |
| 1268 | "ioapic", OBJECT(dev), NULL); |
| 1269 | } |
| 1270 | qdev_init_nofail(dev); |
Andreas Färber | 1356b98 | 2013-01-20 02:47:33 +0100 | [diff] [blame] | 1271 | d = SYS_BUS_DEVICE(dev); |
Laszlo Ersek | 3a4a469 | 2013-03-21 00:23:21 +0100 | [diff] [blame] | 1272 | sysbus_mmio_map(d, 0, IO_APIC_DEFAULT_ADDRESS); |
Jason Baron | a39e356 | 2012-11-14 15:54:01 -0500 | [diff] [blame] | 1273 | |
| 1274 | for (i = 0; i < IOAPIC_NUM_PINS; i++) { |
| 1275 | gsi_state->ioapic_irq[i] = qdev_get_gpio_in(dev, i); |
| 1276 | } |
| 1277 | } |