#include "boards.h"
#include "monitor.h"
#include "fw_cfg.h"
-#include "virtio-blk.h"
-#include "virtio-balloon.h"
-#include "virtio-console.h"
#include "hpet_emul.h"
#include "watchdog.h"
#include "smbios.h"
static IOAPICState *ioapic;
static PCIDevice *i440fx_state;
+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;
+ qemu_register_reset(option_rom_reset, 0, rrd);
+}
+
static void ioport80_write(void *opaque, uint32_t addr, uint32_t data)
{
}
rom[sizeof(rom) - 1] = -sum;
cpu_physical_memory_write_rom(option_rom, rom, sizeof(rom));
+ option_rom_setup_reset(option_rom, sizeof (rom));
}
static long get_file_size(FILE *f)
static void load_linux(target_phys_addr_t option_rom,
const char *kernel_filename,
const char *initrd_filename,
- const char *kernel_cmdline)
+ const char *kernel_cmdline,
+ target_phys_addr_t max_ram_size)
{
uint16_t protocol;
uint32_t gpr[8];
else
initrd_max = 0x37ffffff;
- if (initrd_max >= ram_size-ACPI_DATA_SIZE)
- initrd_max = ram_size-ACPI_DATA_SIZE-1;
+ if (initrd_max >= max_ram_size-ACPI_DATA_SIZE)
+ initrd_max = max_ram_size-ACPI_DATA_SIZE-1;
/* kernel command line */
pstrcpy_targphys(cmdline_addr, 4096, kernel_cmdline);
initrd_size = get_file_size(fi);
initrd_addr = (initrd_max-initrd_size) & ~4095;
- fprintf(stderr, "qemu: loading initrd (%#x bytes) at 0x" TARGET_FMT_plx
- "\n", initrd_size, initrd_addr);
-
if (!fread_targphys_ok(initrd_addr, initrd_size, fi)) {
fprintf(stderr, "qemu: read error on initial ram disk '%s'\n",
initrd_filename);
memset(gpr, 0, sizeof gpr);
gpr[4] = cmdline_addr-real_addr-16; /* SP (-16 is paranoia) */
+ 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);
+
generate_bootsect(option_rom, gpr, seg, 0);
}
static void audio_init (PCIBus *pci_bus, qemu_irq *pic)
{
struct soundhw *c;
- int audio_enabled = 0;
-
- for (c = soundhw; !audio_enabled && c->name; ++c) {
- audio_enabled = c->enabled;
- }
- if (audio_enabled) {
- AudioState *s;
-
- s = AUD_init ();
- if (s) {
- for (c = soundhw; c->name; ++c) {
- if (c->enabled) {
- if (c->isa) {
- c->init.init_isa (s, pic);
- }
- else {
- if (pci_bus) {
- c->init.init_pci (pci_bus, s);
- }
- }
+ 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);
}
}
}
}
/* Round up optiom rom size to the next 2k boundary */
size = (size + 2047) & ~2047;
+ option_rom_setup_reset(start, size);
return size;
}
/* PC hardware initialisation */
-static void pc_init1(ram_addr_t ram_size, int vga_ram_size,
+static void pc_init1(ram_addr_t ram_size,
const char *boot_device,
const char *kernel_filename, const char *kernel_cmdline,
const char *initrd_filename,
/* XXX: enable it in all cases */
env->cpuid_features |= CPUID_APIC;
}
- qemu_register_reset(main_cpu_reset, env);
+ qemu_register_reset(main_cpu_reset, 0, env);
if (pci_enabled) {
apic_init(env);
}
/* above 4giga memory allocation */
if (above_4g_mem_size > 0) {
+#if TARGET_PHYS_ADDR_BITS == 32
+ hw_error("To much RAM for 32-bit physical address");
+#else
ram_addr = qemu_ram_alloc(above_4g_mem_size);
cpu_register_physical_memory(0x100000000ULL,
above_4g_mem_size,
ram_addr);
+#endif
}
option_rom_offset = qemu_ram_alloc(0x20000);
oprom_area_size = 0;
- cpu_register_physical_memory(0xc0000, 0x20000,
- option_rom_offset | IO_MEM_ROM);
+ cpu_register_physical_memory(0xc0000, 0x20000, option_rom_offset);
if (using_vga) {
/* VGA BIOS load */
if (linux_boot) {
load_linux(0xc0000 + oprom_area_size,
- kernel_filename, initrd_filename, kernel_cmdline);
+ kernel_filename, initrd_filename, kernel_cmdline, below_4g_mem_size);
oprom_area_size += 2048;
}
if (cirrus_vga_enabled) {
if (pci_enabled) {
- pci_cirrus_vga_init(pci_bus, vga_ram_size);
+ pci_cirrus_vga_init(pci_bus);
} else {
- isa_cirrus_vga_init(vga_ram_size);
+ isa_cirrus_vga_init();
}
} else if (vmsvga_enabled) {
if (pci_enabled)
- pci_vmsvga_init(pci_bus, vga_ram_size);
+ pci_vmsvga_init(pci_bus);
else
fprintf(stderr, "%s: vmware_vga: no PCI bus\n", __FUNCTION__);
} else if (std_vga_enabled) {
if (pci_enabled) {
- pci_vga_init(pci_bus, vga_ram_size, 0, 0);
+ pci_vga_init(pci_bus, 0, 0);
} else {
- isa_vga_init(vga_ram_size);
+ isa_vga_init();
}
}
/* TODO: Populate SPD eeprom data. */
smbus = piix4_pm_init(pci_bus, piix3_devfn + 3, 0xb100, i8259[9]);
for (i = 0; i < 8; i++) {
- smbus_eeprom_device_init(smbus, 0x50 + i, eeprom_buf + (i * 256));
+ DeviceState *eeprom;
+ eeprom = qdev_create((BusState *)smbus, "smbus-eeprom");
+ qdev_set_prop_int(eeprom, "address", 0x50 + i);
+ qdev_set_prop_ptr(eeprom, "data", eeprom_buf + (i * 256));
+ qdev_init(eeprom);
}
}
if (pci_enabled) {
int max_bus;
- int bus, unit;
- void *scsi;
+ int bus;
max_bus = drive_get_max_bus(IF_SCSI);
-
for (bus = 0; bus <= max_bus; bus++) {
- scsi = lsi_scsi_init(pci_bus, -1);
- for (unit = 0; unit < LSI_MAX_DEVS; unit++) {
- index = drive_get_index(IF_SCSI, bus, unit);
- if (index == -1)
- continue;
- lsi_scsi_attach(scsi, drives_table[index].bdrv, unit);
- }
+ pci_create_simple(pci_bus, -1, "lsi53c895a");
}
}
int unit_id = 0;
while ((index = drive_get_index(IF_VIRTIO, 0, unit_id)) != -1) {
- virtio_blk_init(pci_bus, drives_table[index].bdrv);
+ pci_create_simple(pci_bus, -1, "virtio-blk-pci");
unit_id++;
}
}
/* Add virtio balloon device */
- if (pci_enabled)
- virtio_balloon_init(pci_bus);
+ if (pci_enabled) {
+ pci_create_simple(pci_bus, -1, "virtio-balloon-pci");
+ }
/* Add virtio console devices */
if (pci_enabled) {
for(i = 0; i < MAX_VIRTIO_CONSOLES; i++) {
- if (virtcon_hds[i])
- virtio_console_init(pci_bus, virtcon_hds[i]);
+ if (virtcon_hds[i]) {
+ pci_create_simple(pci_bus, -1, "virtio-console-pci");
+ }
}
}
}
-static void pc_init_pci(ram_addr_t ram_size, int vga_ram_size,
+static void pc_init_pci(ram_addr_t ram_size,
const char *boot_device,
const char *kernel_filename,
const char *kernel_cmdline,
const char *initrd_filename,
const char *cpu_model)
{
- pc_init1(ram_size, vga_ram_size, boot_device,
+ pc_init1(ram_size, boot_device,
kernel_filename, kernel_cmdline,
initrd_filename, 1, cpu_model);
}
-static void pc_init_isa(ram_addr_t ram_size, int vga_ram_size,
+static void pc_init_isa(ram_addr_t ram_size,
const char *boot_device,
const char *kernel_filename,
const char *kernel_cmdline,
const char *initrd_filename,
const char *cpu_model)
{
- pc_init1(ram_size, vga_ram_size, boot_device,
+ pc_init1(ram_size, boot_device,
kernel_filename, kernel_cmdline,
initrd_filename, 0, cpu_model);
}
rtc_set_memory(rtc_state, 0xF, 0xFE);
}
-QEMUMachine pc_machine = {
+static QEMUMachine pc_machine = {
.name = "pc",
.desc = "Standard PC",
.init = pc_init_pci,
.max_cpus = 255,
+ .is_default = 1,
};
-QEMUMachine isapc_machine = {
+static QEMUMachine isapc_machine = {
.name = "isapc",
.desc = "ISA-only PC",
.init = pc_init_isa,
.max_cpus = 1,
};
+
+static void pc_machine_init(void)
+{
+ qemu_register_machine(&pc_machine);
+ qemu_register_machine(&isapc_machine);
+}
+
+machine_init(pc_machine_init);
projects / qemu / blobdiff