GL_CUR_PATH = $(SRC_PATH)/tizen/src/hw
GL_CFLAGS += -I$(GL_CUR_PATH) -I$(SRC_PATH)/fpu
-GL_CFLAGS += -I$(SRC_PATH)/$(TARGET_ARCH)-softmmu $(QEMU_CFLAGS) $(CFLAGS)
+GL_CFLAGS += -I$(SRC_PATH)/$(TARGET_NAME)-softmmu $(QEMU_CFLAGS) $(CFLAGS)
parse_gl_h: parse_gl_h.c
$(CC) -g -o $@ $<
static const int ide_irq[MAX_IDE_BUS] = { 14, 15 };
static bool has_pvpanic = true;
+static bool has_pci_info = true;
MemoryRegion *global_ram_memory;
MemoryRegion *rom_memory;
DeviceState *icc_bridge;
void *fw_cfg = NULL;
+ PcGuestInfo *guest_info;
+
#if defined(__linux__)
Display *display = XOpenDisplay(0);
if (!display && !enable_spice) {
#endif
struct winsys_interface *vigs_wsi = NULL;
+ if (xen_enabled() && xen_hvm_init() != 0) {
+ fprintf(stderr, "xen hardware virtual machine initialisation failed\n");
+ exit(1);
+ }
+
icc_bridge = qdev_create(NULL, TYPE_ICC_BRIDGE);
object_property_add_child(qdev_get_machine(), "icc-bridge",
OBJECT(icc_bridge), NULL);
if (pci_enabled) {
pci_memory = g_new(MemoryRegion, 1);
- memory_region_init(pci_memory, "pci", INT64_MAX);
+ memory_region_init(pci_memory, NULL, "pci", INT64_MAX);
rom_memory = pci_memory;
} else {
pci_memory = NULL;
rom_memory = system_memory;
}
+ guest_info = pc_guest_info_init(below_4g_mem_size, above_4g_mem_size);
+ guest_info->has_pci_info = has_pci_info;
+ guest_info->isapc_ram_fw = !pci_enabled;
+
/* allocate ram and load rom/bios */
if (!xen_enabled()) {
// W/A for allocate larger continuous heap.
fw_cfg = pc_memory_init(system_memory,
kernel_filename, kernel_cmdline, initrd_filename,
below_4g_mem_size, above_4g_mem_size,
- rom_memory, &ram_memory);
+ rom_memory, &ram_memory, guest_info);
}
// for ramdump...
system_memory, system_io, ram_size,
below_4g_mem_size,
0x100000000ULL - below_4g_mem_size,
- 0x100000000ULL + above_4g_mem_size,
- (sizeof(hwaddr) == 4
- ? 0
- : ((uint64_t)1 << 62)),
+ above_4g_mem_size,
pci_memory, ram_memory);
} else {
pci_bus = NULL;
dev = isa_ide_init(isa_bus, ide_iobase[i], ide_iobase2[i],
ide_irq[i],
hd[MAX_IDE_DEVS * i], hd[MAX_IDE_DEVS * i + 1]);
- idebus[i] = qdev_get_child_bus(&dev->qdev, "ide.0");
+ idebus[i] = qdev_get_child_bus(DEVICE(dev), "ide.0");
}
}
if (pci_enabled && acpi_enabled) {
i2c_bus *smbus;
- smi_irq = qemu_allocate_irqs(pc_acpi_smi_interrupt,
- x86_env_get_cpu(first_cpu), 1);
+ smi_irq = qemu_allocate_irqs(pc_acpi_smi_interrupt, first_cpu, 1);
/* TODO: Populate SPD eeprom data. */
smbus = piix4_pm_init(pci_bus, piix3_devfn + 3, 0xb100,
gsi[9], *smi_irq,
static void maru_x86_board_init(QEMUMachineInitArgs *args)
{
+ has_pci_info = false;
+
ram_addr_t ram_size = args->ram_size;
const char *cpu_model = args->cpu_model;
const char *kernel_filename = args->kernel_filename;
pci_config_set_device_id(pci_conf, PCI_DEVICE_ID_VIRTUAL_BRIGHTNESS);
pci_config_set_class(pci_conf, PCI_CLASS_DISPLAY_OTHER);
- memory_region_init_io(&s->mmio_addr, &brightness_mmio_ops, s,
+ memory_region_init_io(&s->mmio_addr, OBJECT(s), &brightness_mmio_ops, s,
"maru_brightness_mmio", BRIGHTNESS_REG_SIZE);
pci_register_bar(&s->dev, 1, PCI_BASE_ADDRESS_SPACE_MEMORY, &s->mmio_addr);
pci_config_set_interrupt_pin(pci_conf, 0x03);
- memory_region_init_ram(&s->vram, "marucamera.ram", MARUCAM_MEM_SIZE);
+ memory_region_init_ram(&s->vram, OBJECT(s), "marucamera.ram", MARUCAM_MEM_SIZE);
s->vaddr = memory_region_get_ram_ptr(&s->vram);
memset(s->vaddr, 0, MARUCAM_MEM_SIZE);
- memory_region_init_io(&s->mmio,
+ memory_region_init_io(&s->mmio, OBJECT(s),
&maru_camera_mmio_ops,
s,
"maru-camera-mmio",
pci_config_set_interrupt_pin(pci_conf, 1);
- memory_region_init_ram(&s->vram, "codec.ram", MARU_CODEC_MEM_SIZE);
+ memory_region_init_ram(&s->vram, OBJECT(s), "codec.ram", MARU_CODEC_MEM_SIZE);
s->vaddr = memory_region_get_ram_ptr(&s->vram);
- memory_region_init_io(&s->mmio, &codec_mmio_ops, s,
+ memory_region_init_io(&s->mmio, OBJECT(s), &codec_mmio_ops, s,
"codec-mmio", MARU_CODEC_REG_SIZE);
pci_register_bar(&s->dev, 0, PCI_BASE_ADDRESS_MEM_PREFETCH, &s->vram);
pci_config_set_device_id(pci_conf, PCI_DEVICE_ID_VIRTUAL_OVERLAY);
pci_config_set_class(pci_conf, PCI_CLASS_DISPLAY_OTHER);
- memory_region_init_ram(&s->mem_addr, "maru_overlay.ram", OVERLAY_MEM_SIZE);
+ memory_region_init_ram(&s->mem_addr, NULL, "maru_overlay.ram", OVERLAY_MEM_SIZE);
overlay_ptr = memory_region_get_ram_ptr(&s->mem_addr);
- memory_region_init_io(&s->mmio_addr, &overlay_mmio_ops,
+ memory_region_init_io(&s->mmio_addr, NULL, &overlay_mmio_ops,
s,
"maru_overlay_mmio",
OVERLAY_REG_SIZE);
static void piix4_pm_machine_ready(Notifier *n, void *opaque)
{
PIIX4PMState *s = container_of(n, PIIX4PMState, machine_ready);
+ PCIDevice *d = PCI_DEVICE(s);
+ MemoryRegion *io_as = pci_address_space_io(d);
uint8_t *pci_conf;
- pci_conf = s->dev.config;
- pci_conf[0x5f] = (isa_is_ioport_assigned(0x378) ? 0x80 : 0) | 0x10;
+ pci_conf = d->config;
+ pci_conf[0x5f] = 0x10 |
+ (memory_region_present(io_as, 0x378) ? 0x80 : 0);
pci_conf[0x63] = 0x60;
- pci_conf[0x67] = (isa_is_ioport_assigned(0x3f8) ? 0x08 : 0) |
- (isa_is_ioport_assigned(0x2f8) ? 0x90 : 0);
-
+ pci_conf[0x67] = (memory_region_present(io_as, 0x3f8) ? 0x08 : 0) |
+ (memory_region_present(io_as, 0x2f8) ? 0x90 : 0);
}
static int piix4_pm_initfn(PCIDevice *dev)
memory_region_add_subregion(pci_address_space_io(dev),
s->smb_io_base, &s->smb.io);
- memory_region_init(&s->io, "maru-pm", 64);
+ memory_region_init(&s->io, OBJECT(s), "maru-pm", 64);
memory_region_set_enabled(&s->io, false);
memory_region_add_subregion(pci_address_space_io(dev),
0, &s->io);
acpi_pm1_evt_init(&s->ar, pm_tmr_timer, &s->io);
acpi_pm1_cnt_init(&s->ar, &s->io, s->s4_val);
#if defined(CONFIG_MARU)
- memory_region_init_io(&s->ar.pm1.cnt.io, &maru_pm_cnt_ops, &s->ar, "acpi-cnt", 2);
+ memory_region_init_io(&s->ar.pm1.cnt.io, OBJECT(s), &maru_pm_cnt_ops, &s->ar, "acpi-cnt", 2);
#endif
acpi_gpe_init(&s->ar, GPE_LEN);
static void piix4_acpi_system_hot_add_init(MemoryRegion *parent,
PCIBus *bus, PIIX4PMState *s)
{
-
- memory_region_init_io(&s->io_gpe, &piix4_gpe_ops, s, "apci-gpe0",
- GPE_LEN);
+ memory_region_init_io(&s->io_gpe, OBJECT(s), &piix4_gpe_ops, s,
+ "acpi-gpe0", GPE_LEN);
memory_region_add_subregion(parent, GPE_BASE, &s->io_gpe);
- memory_region_init_io(&s->io_pci, &piix4_pci_ops, s, "apci-pci-hotplug",
- PCI_HOTPLUG_SIZE);
+ memory_region_init_io(&s->io_pci, OBJECT(s), &piix4_pci_ops, s,
+ "acpi-pci-hotplug", PCI_HOTPLUG_SIZE);
memory_region_add_subregion(parent, PCI_HOTPLUG_ADDR,
&s->io_pci);
- pci_bus_hotplug(bus, piix4_device_hotplug, &s->dev.qdev);
+ pci_bus_hotplug(bus, piix4_device_hotplug, DEVICE(s));
qemu_for_each_cpu(piix4_init_cpu_status, &s->gpe_cpu);
- memory_region_init_io(&s->io_cpu, &cpu_hotplug_ops, s, "apci-cpu-hotplug",
- PIIX4_PROC_LEN);
+ memory_region_init_io(&s->io_cpu, OBJECT(s), &cpu_hotplug_ops, s,
+ "acpi-cpu-hotplug", PIIX4_PROC_LEN);
memory_region_add_subregion(parent, PIIX4_PROC_BASE, &s->io_cpu);
s->cpu_added_notifier.notify = piix4_cpu_added_req;
qemu_register_cpu_added_notifier(&s->cpu_added_notifier);
.text_update = vga_update_text,
};
-void maru_vga_common_init(VGACommonState *s)
+void maru_vga_common_init(VGACommonState *s, Object *obj)
{
int i, j, v, b;
s->vram_size_mb = s->vram_size >> 20;
s->is_vbe_vmstate = 1;
- memory_region_init_ram(&s->vram, "maru_vga.vram", s->vram_size);
+ memory_region_init_ram(&s->vram, obj, "maru_vga.vram", s->vram_size);
vmstate_register_ram_global(&s->vram);
xen_register_framebuffer(&s->vram);
s->vram_ptr = memory_region_get_ram_ptr(&s->vram);
#ifndef MARU_VGA_INT_H_
#define MARU_VGA_INT_H_
-void maru_vga_common_init(VGACommonState *s);
+void maru_vga_common_init(VGACommonState *s, Object *obj);
void maru_vga_common_fini(void);
#endif /* MARU_VGA_INT_H_ */
* with this program; if not, see <http://www.gnu.org/licenses/>.
*/
-#include "virtio.h"
+#include "hw/virtio/virtio.h"
VirtIODevice *virtio_gl_init(DeviceState *dev)
{
#include "monitor/monitor.h"
#include "hw/pci/pci.h"
#include "sysemu/sysemu.h"
+#include "exec/memory-internal.h"
#include "emulator.h"
#include "guest_debug.h"
hostkbd = do_pci_device_hot_add(cur_mon, qdict);
if (hostkbd) {
- TRACE("virtio-keyboard device: domain %d, bus %d, slot %d, function %d\n",
- pci_find_domain(hostkbd->bus), pci_bus_num(hostkbd->bus),
+ TRACE("virtio-keyboard device: root_bus_path %s, bus %d, slot %d, function %d\n",
+ pci_root_bus_path(hostkbd), pci_bus_num(hostkbd->bus),
PCI_SLOT(hostkbd->devfn), PCI_FUNC(hostkbd->devfn));
} else {
ERR("failed to hot_add keyboard device.\n");
virtio_sdcard = do_pci_device_hot_add(cur_mon, qdict);
if (virtio_sdcard) {
INFO("hot add virtio storage device with [%s]\n", opts);
- INFO("virtio-sdcard device: domain %d, bus %d, slot %d, function %d\n",
- pci_find_domain(virtio_sdcard->bus), pci_bus_num(virtio_sdcard->bus),
+ INFO("virtio-sdcard device: root_bus_path %s, bus %d, slot %d, function %d\n",
+ pci_root_bus_path(virtio_sdcard), pci_bus_num(virtio_sdcard->bus),
PCI_SLOT(virtio_sdcard->devfn), PCI_FUNC(virtio_sdcard->devfn));
} else {
ERR("failed to create a sdcard device.\n");