Merge branch 'tizen-arm' into develop

Conflicts:
	hw/virtio-pci.c
	tizen/emulator_configure.sh
	tizen/src/Makefile.tizen
	tizen/src/emulator.c
	tizen/src/hw/maru_board.c
	tizen/src/hw/maru_vga.c
	tizen/src/skin/client/skins/emul-320x480/default.dbi
	tizen/src/skin/client/src/org/tizen/emulator/skin/EmulatorSkin.java
	vl.c

diff --cc hw/pci-hotplug.c
Simple merge

diff --cc hw/virtio-pci.c
index b14a77d,2ce1a9a..75ad478
--- 1/hw/virtio-pci.c
--- 2/hw/virtio-pci.c
+++ b/hw/virtio-pci.c
@@@ -820,178 -921,258 +922,303 @@@ static void maru_virtio_touchscreen_exi
  
      virtio_pci_stop_ioeventfd(proxy);
      maru_virtio_touchscreen_exit(proxy->vdev);
-     return virtio_exit_pci(pci_dev);
+     virtio_exit_pci(pci_dev);
  }
- #endif
 +
- #ifdef CONFIG_MARU
 +static int virtio_keyboard_init_pci(PCIDevice *pci_dev)
 +{
 +    VirtIOPCIProxy *proxy = DO_UPCAST(VirtIOPCIProxy, pci_dev, pci_dev);
 +    VirtIODevice *vdev;
 +
 +    mloop_evcmd_set_hostkbd(pci_dev);
 +    vdev = virtio_keyboard_init(&pci_dev->qdev);
 +    if (!vdev) {
 +        return -1;
 +    }
 +    virtio_init_pci(proxy, vdev);
 +    return 0;
 +}
 +
- static int virtio_keyboard_exit_pci(PCIDevice *pci_dev)
++static void virtio_keyboard_exit_pci(PCIDevice *pci_dev)
 +{
 +    VirtIOPCIProxy *proxy = DO_UPCAST(VirtIOPCIProxy, pci_dev, pci_dev);
 +
 +    virtio_pci_stop_ioeventfd(proxy);
 +    virtio_keyboard_exit(proxy->vdev);
-     return virtio_exit_pci(pci_dev);
++    virtio_exit_pci(pci_dev);
 +}
  #endif
  
+ static Property virtio_blk_properties[] = {
+     DEFINE_PROP_HEX32("class", VirtIOPCIProxy, class_code, 0),
+     DEFINE_BLOCK_PROPERTIES(VirtIOPCIProxy, blk.conf),
+     DEFINE_BLOCK_CHS_PROPERTIES(VirtIOPCIProxy, blk.conf),
+     DEFINE_PROP_STRING("serial", VirtIOPCIProxy, blk.serial),
+ #ifdef __linux__
+     DEFINE_PROP_BIT("scsi", VirtIOPCIProxy, blk.scsi, 0, true),
+ #endif
+     DEFINE_PROP_BIT("config-wce", VirtIOPCIProxy, blk.config_wce, 0, true),
+     DEFINE_PROP_BIT("ioeventfd", VirtIOPCIProxy, flags, VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT, true),
+     DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy, nvectors, 2),
+     DEFINE_VIRTIO_BLK_FEATURES(VirtIOPCIProxy, host_features),
+     DEFINE_PROP_END_OF_LIST(),
+ };
+ 
+ static void virtio_blk_class_init(ObjectClass *klass, void *data)
+ {
+     DeviceClass *dc = DEVICE_CLASS(klass);
+     PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);
+ 
+     k->init = virtio_blk_init_pci;
+     k->exit = virtio_blk_exit_pci;
+     k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
+     k->device_id = PCI_DEVICE_ID_VIRTIO_BLOCK;
+     k->revision = VIRTIO_PCI_ABI_VERSION;
+     k->class_id = PCI_CLASS_STORAGE_SCSI;
+     dc->reset = virtio_pci_reset;
+     dc->props = virtio_blk_properties;
+ }
+ 
+ static TypeInfo virtio_blk_info = {
+     .name          = "virtio-blk-pci",
+     .parent        = TYPE_PCI_DEVICE,
+     .instance_size = sizeof(VirtIOPCIProxy),
+     .class_init    = virtio_blk_class_init,
+ };
+ 
+ static Property virtio_net_properties[] = {
+     DEFINE_PROP_BIT("ioeventfd", VirtIOPCIProxy, flags, VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT, false),
+     DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy, nvectors, 3),
+     DEFINE_VIRTIO_NET_FEATURES(VirtIOPCIProxy, host_features),
+     DEFINE_NIC_PROPERTIES(VirtIOPCIProxy, nic),
+     DEFINE_PROP_UINT32("x-txtimer", VirtIOPCIProxy, net.txtimer, TX_TIMER_INTERVAL),
+     DEFINE_PROP_INT32("x-txburst", VirtIOPCIProxy, net.txburst, TX_BURST),
+     DEFINE_PROP_STRING("tx", VirtIOPCIProxy, net.tx),
+     DEFINE_PROP_END_OF_LIST(),
+ };
+ 
+ static void virtio_net_class_init(ObjectClass *klass, void *data)
+ {
+     DeviceClass *dc = DEVICE_CLASS(klass);
+     PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);
+ 
+     k->init = virtio_net_init_pci;
+     k->exit = virtio_net_exit_pci;
+     k->romfile = "pxe-virtio.rom";
+     k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
+     k->device_id = PCI_DEVICE_ID_VIRTIO_NET;
+     k->revision = VIRTIO_PCI_ABI_VERSION;
+     k->class_id = PCI_CLASS_NETWORK_ETHERNET;
+     dc->reset = virtio_pci_reset;
+     dc->props = virtio_net_properties;
+ }
+ 
+ static TypeInfo virtio_net_info = {
+     .name          = "virtio-net-pci",
+     .parent        = TYPE_PCI_DEVICE,
+     .instance_size = sizeof(VirtIOPCIProxy),
+     .class_init    = virtio_net_class_init,
+ };
+ 
+ static Property virtio_serial_properties[] = {
+     DEFINE_PROP_BIT("ioeventfd", VirtIOPCIProxy, flags, VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT, true),
+     DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy, nvectors, DEV_NVECTORS_UNSPECIFIED),
+     DEFINE_PROP_HEX32("class", VirtIOPCIProxy, class_code, 0),
+     DEFINE_VIRTIO_COMMON_FEATURES(VirtIOPCIProxy, host_features),
+     DEFINE_PROP_UINT32("max_ports", VirtIOPCIProxy, serial.max_virtserial_ports, 31),
+     DEFINE_PROP_END_OF_LIST(),
+ };
+ 
+ static void virtio_serial_class_init(ObjectClass *klass, void *data)
+ {
+     DeviceClass *dc = DEVICE_CLASS(klass);
+     PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);
+ 
+     k->init = virtio_serial_init_pci;
+     k->exit = virtio_serial_exit_pci;
+     k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
+     k->device_id = PCI_DEVICE_ID_VIRTIO_CONSOLE;
+     k->revision = VIRTIO_PCI_ABI_VERSION;
+     k->class_id = PCI_CLASS_COMMUNICATION_OTHER;
+     dc->reset = virtio_pci_reset;
+     dc->props = virtio_serial_properties;
+ }
+ 
+ static TypeInfo virtio_serial_info = {
+     .name          = "virtio-serial-pci",
+     .parent        = TYPE_PCI_DEVICE,
+     .instance_size = sizeof(VirtIOPCIProxy),
+     .class_init    = virtio_serial_class_init,
+ };
+ 
+ static Property virtio_balloon_properties[] = {
+     DEFINE_VIRTIO_COMMON_FEATURES(VirtIOPCIProxy, host_features),
+     DEFINE_PROP_HEX32("class", VirtIOPCIProxy, class_code, 0),
+     DEFINE_PROP_END_OF_LIST(),
+ };
+ 
+ static void virtio_balloon_class_init(ObjectClass *klass, void *data)
+ {
+     DeviceClass *dc = DEVICE_CLASS(klass);
+     PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);
+ 
+     k->init = virtio_balloon_init_pci;
+     k->exit = virtio_balloon_exit_pci;
+     k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
+     k->device_id = PCI_DEVICE_ID_VIRTIO_BALLOON;
+     k->revision = VIRTIO_PCI_ABI_VERSION;
+     k->class_id = PCI_CLASS_OTHERS;
+     dc->reset = virtio_pci_reset;
+     dc->props = virtio_balloon_properties;
+ }
+ 
+ static TypeInfo virtio_balloon_info = {
+     .name          = "virtio-balloon-pci",
+     .parent        = TYPE_PCI_DEVICE,
+     .instance_size = sizeof(VirtIOPCIProxy),
+     .class_init    = virtio_balloon_class_init,
+ };
+ 
+ static int virtio_scsi_init_pci(PCIDevice *pci_dev)
+ {
+     VirtIOPCIProxy *proxy = DO_UPCAST(VirtIOPCIProxy, pci_dev, pci_dev);
+     VirtIODevice *vdev;
+ 
+     vdev = virtio_scsi_init(&pci_dev->qdev, &proxy->scsi);
+     if (!vdev) {
+         return -EINVAL;
+     }
+ 
+     vdev->nvectors = proxy->nvectors == DEV_NVECTORS_UNSPECIFIED
+                                         ? proxy->scsi.num_queues + 3
+                                         : proxy->nvectors;
+     virtio_init_pci(proxy, vdev);
+ 
+     /* make the actual value visible */
+     proxy->nvectors = vdev->nvectors;
+     return 0;
+ }
+ 
+ static void virtio_scsi_exit_pci(PCIDevice *pci_dev)
+ {
+     VirtIOPCIProxy *proxy = DO_UPCAST(VirtIOPCIProxy, pci_dev, pci_dev);
+ 
+     virtio_scsi_exit(proxy->vdev);
+     virtio_exit_pci(pci_dev);
+ }
+ 
+ static Property virtio_scsi_properties[] = {
+     DEFINE_PROP_BIT("ioeventfd", VirtIOPCIProxy, flags, VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT, true),
+     DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy, nvectors, DEV_NVECTORS_UNSPECIFIED),
+     DEFINE_VIRTIO_SCSI_PROPERTIES(VirtIOPCIProxy, host_features, scsi),
+     DEFINE_PROP_END_OF_LIST(),
+ };
+ 
+ static void virtio_scsi_class_init(ObjectClass *klass, void *data)
+ {
+     DeviceClass *dc = DEVICE_CLASS(klass);
+     PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);
+ 
+     k->init = virtio_scsi_init_pci;
+     k->exit = virtio_scsi_exit_pci;
+     k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
+     k->device_id = PCI_DEVICE_ID_VIRTIO_SCSI;
+     k->revision = 0x00;
+     k->class_id = PCI_CLASS_STORAGE_SCSI;
+     dc->reset = virtio_pci_reset;
+     dc->props = virtio_scsi_properties;
+ }
+ 
+ static TypeInfo virtio_scsi_info = {
+     .name          = "virtio-scsi-pci",
+     .parent        = TYPE_PCI_DEVICE,
+     .instance_size = sizeof(VirtIOPCIProxy),
+     .class_init    = virtio_scsi_class_init,
+ };
  
- static PCIDeviceInfo virtio_info[] = {
-     {
-         .qdev.name = "virtio-blk-pci",
-         .qdev.alias = "virtio-blk",
-         .qdev.size = sizeof(VirtIOPCIProxy),
-         .init      = virtio_blk_init_pci,
-         .exit      = virtio_blk_exit_pci,
-         .vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET,
-         .device_id = PCI_DEVICE_ID_VIRTIO_BLOCK,
-         .revision  = VIRTIO_PCI_ABI_VERSION,
-         .class_id  = PCI_CLASS_STORAGE_SCSI,
-         .qdev.props = (Property[]) {
-             DEFINE_PROP_HEX32("class", VirtIOPCIProxy, class_code, 0),
-             DEFINE_BLOCK_PROPERTIES(VirtIOPCIProxy, block),
-             DEFINE_PROP_STRING("serial", VirtIOPCIProxy, block_serial),
-             DEFINE_PROP_BIT("ioeventfd", VirtIOPCIProxy, flags,
-                             VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT, true),
-             DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy, nvectors, 2),
-             DEFINE_VIRTIO_BLK_FEATURES(VirtIOPCIProxy, host_features),
-             DEFINE_PROP_END_OF_LIST(),
-         },
-         .qdev.reset = virtio_pci_reset,
-     },{
-         .qdev.name  = "virtio-net-pci",
-         .qdev.alias = "virtio-net",
-         .qdev.size  = sizeof(VirtIOPCIProxy),
-         .init       = virtio_net_init_pci,
-         .exit       = virtio_net_exit_pci,
-         .romfile    = "pxe-virtio.rom",
-         .vendor_id  = PCI_VENDOR_ID_REDHAT_QUMRANET,
-         .device_id  = PCI_DEVICE_ID_VIRTIO_NET,
-         .revision   = VIRTIO_PCI_ABI_VERSION,
-         .class_id   = PCI_CLASS_NETWORK_ETHERNET,
-         .qdev.props = (Property[]) {
-             DEFINE_PROP_BIT("ioeventfd", VirtIOPCIProxy, flags,
-                             VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT, false),
-             DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy, nvectors, 3),
-             DEFINE_VIRTIO_NET_FEATURES(VirtIOPCIProxy, host_features),
-             DEFINE_NIC_PROPERTIES(VirtIOPCIProxy, nic),
-             DEFINE_PROP_UINT32("x-txtimer", VirtIOPCIProxy,
-                                net.txtimer, TX_TIMER_INTERVAL),
-             DEFINE_PROP_INT32("x-txburst", VirtIOPCIProxy,
-                               net.txburst, TX_BURST),
-             DEFINE_PROP_STRING("tx", VirtIOPCIProxy, net.tx),
-             DEFINE_PROP_END_OF_LIST(),
-         },
-         .qdev.reset = virtio_pci_reset,
-     },{
-         .qdev.name = "virtio-serial-pci",
-         .qdev.alias = "virtio-serial",
-         .qdev.size = sizeof(VirtIOPCIProxy),
-         .init      = virtio_serial_init_pci,
-         .exit      = virtio_serial_exit_pci,
-         .vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET,
-         .device_id = PCI_DEVICE_ID_VIRTIO_CONSOLE,
-         .revision  = VIRTIO_PCI_ABI_VERSION,
-         .class_id  = PCI_CLASS_COMMUNICATION_OTHER,
-         .qdev.props = (Property[]) {
-             DEFINE_PROP_BIT("ioeventfd", VirtIOPCIProxy, flags,
-                             VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT, true),
-             DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy, nvectors,
-                                DEV_NVECTORS_UNSPECIFIED),
-             DEFINE_PROP_HEX32("class", VirtIOPCIProxy, class_code, 0),
-             DEFINE_VIRTIO_COMMON_FEATURES(VirtIOPCIProxy, host_features),
-             DEFINE_PROP_UINT32("max_ports", VirtIOPCIProxy,
-                                serial.max_virtserial_ports, 31),
-             DEFINE_PROP_END_OF_LIST(),
-         },
-         .qdev.reset = virtio_pci_reset,
-     },{
-         .qdev.name = "virtio-balloon-pci",
-         .qdev.alias = "virtio-balloon",
-         .qdev.size = sizeof(VirtIOPCIProxy),
-         .init      = virtio_balloon_init_pci,
-         .exit      = virtio_balloon_exit_pci,
-         .vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET,
-         .device_id = PCI_DEVICE_ID_VIRTIO_BALLOON,
-         .revision  = VIRTIO_PCI_ABI_VERSION,
-         .class_id  = PCI_CLASS_MEMORY_RAM,
-         .qdev.props = (Property[]) {
-             DEFINE_VIRTIO_COMMON_FEATURES(VirtIOPCIProxy, host_features),
-             DEFINE_PROP_END_OF_LIST(),
-         },
-         .qdev.reset = virtio_pci_reset,
-     },{
  #if defined(CONFIG_MARU) && (!defined(CONFIG_DARWIN))
-         .qdev.name = "virtio-gl-pci",
-         .qdev.alias = "virtio-gl",
-         .qdev.size = sizeof(VirtIOPCIProxy),
-         .init      = virtio_gl_init_pci,
-         .exit      = virtio_exit_pci,
-         .vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET,
-         .device_id = PCI_DEVICE_ID_VIRTIO_GL,
-         .revision  = VIRTIO_PCI_ABI_VERSION,
-         .class_id  = PCI_CLASS_OTHERS,
-         .qdev.props = (Property[]) {
-             DEFINE_PROP_END_OF_LIST(),
-         },
-         .qdev.reset = virtio_pci_reset,
-     },{
- #endif
+ #ifdef CONFIG_GL_BACKEND
+ static void virtio_gl_class_init(ObjectClass *klass, void *data)
+ {
+     DeviceClass *dc = DEVICE_CLASS(klass);
+     PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);
+ 
+     k->init = virtio_gl_init_pci;
+     k->exit = virtio_exit_pci;
+     k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
+     k->device_id = PCI_DEVICE_ID_VIRTIO_GL;
+     k->revision = VIRTIO_PCI_ABI_VERSION;
+     k->class_id = PCI_CLASS_OTHERS;
+     dc->reset = virtio_pci_reset;
+ }
  
- #ifdef CONFIG_MARU
-         .qdev.name = "virtio-touchscreen-pci",
-         .qdev.alias = "virtio-touchscreen",
-         .qdev.size = sizeof(VirtIOPCIProxy),
-         .init      = maru_virtio_touchscreen_init_pci,
-         .exit      = maru_virtio_touchscreen_exit_pci,
-         .vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET,
-         .device_id = PCI_DEVICE_ID_VIRTIO_TOUCHSCREEN,
-         .revision  = VIRTIO_PCI_ABI_VERSION,
-         .class_id  = PCI_CLASS_OTHERS,
-         .qdev.props = (Property[]) {
-             DEFINE_PROP_END_OF_LIST(),
-         },
-         .qdev.reset = virtio_pci_reset,
-     },{
+ static TypeInfo virtio_gl_info = {
+     .name          = "virtio-gl-pci",
+     .parent        = TYPE_PCI_DEVICE,
+     .instance_size = sizeof(VirtIOPCIProxy),
+     .class_init    = virtio_gl_class_init,
+ };
+ #endif
  #endif
  
  #ifdef CONFIG_MARU
-         .qdev.name = "virtio-keyboard-pci",
-         .qdev.alias = "virtio-keyboard",
-         .qdev.size = sizeof(VirtIOPCIProxy),
-         .init      = virtio_keyboard_init_pci,
-         .exit      = virtio_keyboard_exit_pci,
-         .vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET,
-         .device_id = PCI_DEVICE_ID_VIRTIO_KEYBOARD,
-         .revision  = VIRTIO_PCI_ABI_VERSION,
-         .class_id  = PCI_CLASS_OTHERS,
-         .qdev.props = (Property[]) {
-             DEFINE_PROP_END_OF_LIST(),
-         },
-         .qdev.reset = virtio_pci_reset,
-     },{
- #endif
-         /* end of list */
-     }
+ static void maru_virtio_touchscreen_class_init(ObjectClass *klass, void *data)
+ {
+     DeviceClass *dc = DEVICE_CLASS(klass);
+     PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);
+ 
+     k->init = maru_virtio_touchscreen_init_pci;
+     k->exit = maru_virtio_touchscreen_exit_pci;
+     k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
+     k->device_id = PCI_DEVICE_ID_VIRTIO_TOUCHSCREEN;
+     k->revision = VIRTIO_PCI_ABI_VERSION;
+     k->class_id = PCI_CLASS_OTHERS;
+     dc->reset = virtio_pci_reset;
+ }
+ 
+ static TypeInfo maru_virtio_touchscreen_info = {
+     .name          = "virtio-touchscreen-pci",
+     .parent        = TYPE_PCI_DEVICE,
+     .instance_size = sizeof(VirtIOPCIProxy),
+     .class_init    = maru_virtio_touchscreen_class_init,
  };
 -#endif
 +
- static void virtio_pci_register_devices(void)
++static void virtio_keyboard_class_init(ObjectClass *klass, void *data)
 +{
-     pci_qdev_register_many(virtio_info);
++    DeviceClass *dc = DEVICE_CLASS(klass);
++    PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);
++
++    k->init = virtio_keyboard_init_pci;
++    k->exit = virtio_keyboard_exit_pci;
++    k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
++    k->device_id = PCI_DEVICE_ID_VIRTIO_KEYBOARD;
++    k->revision = VIRTIO_PCI_ABI_VERSION;
++    k->class_id = PCI_CLASS_OTHERS;
++    dc->reset = virtio_pci_reset;
++}
++
++static TypeInfo virtio_keyboard_info = {
++    .name          = "virtio-keyboard-pci",
++    .parent        = TYPE_PCI_DEVICE,
++    .instance_size = sizeof(VirtIOPCIProxy),
++    .class_init    = virtio_keyboard_class_init,
++};
++#endif /* CONFIG_MARU */
+ 
+ static void virtio_pci_register_types(void)
+ {
+     type_register_static(&virtio_blk_info);
+     type_register_static(&virtio_net_info);
+     type_register_static(&virtio_serial_info);
+     type_register_static(&virtio_balloon_info);
+     type_register_static(&virtio_scsi_info);
+ #ifdef CONFIG_GL_BACKEND
+     type_register_static(&virtio_gl_info);
+ #endif
+ #ifdef CONFIG_MARU
+     type_register_static(&maru_virtio_touchscreen_info);
++    type_register_static(&virtio_keyboard_info);
+ #endif
  }
  
- device_init(virtio_pci_register_devices)
+ type_init(virtio_pci_register_types)

diff --cc input.c
Simple merge

diff --cc tizen/src/Makefile
index f30e30e,5185654..c2d98df
--- 1/tizen/src/Makefile
--- 2/tizen/src/Makefile
+++ b/tizen/src/Makefile
@@@ -108,11 -202,16 +202,18 @@@ endi
        cp skin/client/emulator-skin.jar $(EMUL_DIR)/bin
  ifdef CONFIG_WIN32
        cp check-hax.exe $(EMUL_DIR)/bin
 -else
 -      
 +endif
 +
 +ifdef CONFIG_DARWIN
 +      cp check-hax $(EMUL_DIR)/bin
  endif
+ ifdef CONFIG_LINUX
+       echo "Copying tizen-kvm to $(EMUL_DIR)/etc"
+       cp -pPr ../distrib/initscript/tizen-kvm $(EMUL_DIR)/etc
+       cp -pPr ../distrib/initscript/45-tizen-kvm.rules $(EMUL_DIR)/etc
+ else
+ 
+ endif
  
  ifndef CONFIG_DARWIN
        cp ../../qemu-img $(EMUL_DIR)/bin

diff --cc tizen/src/Makefile.tizen
index f898cd0,0bdb516..d00bcb0
--- 1/tizen/src/Makefile.tizen
--- 2/tizen/src/Makefile.tizen
+++ b/tizen/src/Makefile.tizen
@@@ -80,22 -103,15 +103,16 @@@ obj-y += mloop_event.
  obj-y += debug_ch.o
  
  # maru hardware
- obj-i386-y += maru_board.o
- obj-i386-y += maru_overlay.o
- ifndef CONFIG_DARWIN
- obj-i386-y += maru_codec.o
- endif
- obj-i386-y += maru_pm.o
- obj-i386-y += maru_vga.o
- obj-i386-y += maru_brightness.o
- obj-i386-y += maru_usb_touchscreen.o maru_virtio_touchscreen.o
- obj-i386-y += maru_virtio_keyboard.o
+ include $(SRC_PATH)/tizen/src/Makefile.tizen.$(TARGET_BASE_ARCH)
  
- # FIXME: camera disabled
+ obj-y += maru_brightness.o
+ obj-y += maru_usb_touchscreen.o maru_virtio_touchscreen.o
++obj-y += maru_virtio_keyboard.o
  ifndef CONFIG_DARWIN
- obj-i386-$(CONFIG_PCI) += maru_camera_common_pci.o
- obj-i386-$(CONFIG_LINUX) += maru_camera_linux_pci.o
- obj-i386-$(CONFIG_WIN32) += maru_camera_win32_pci.o
+ obj-y += maru_codec.o
+ obj-$(CONFIG_PCI) += maru_camera_common_pci.o
+ obj-$(CONFIG_LINUX) += maru_camera_linux_pci.o
+ obj-$(CONFIG_WIN32) += maru_camera_win32_pci.o
  endif
  
  ifdef CONFIG_LINUX # libs for maru camera on linux host

diff --cc tizen/src/emulator.h
Simple merge

diff --cc tizen/src/hw/maru_board.c
index ea7c671,5a55a22..ff65e37
--- 1/tizen/src/hw/maru_board.c
--- 2/tizen/src/hw/maru_board.c
+++ b/tizen/src/hw/maru_board.c
@@@ -63,8 -63,11 +63,12 @@@
  #  include <xen/hvm/hvm_info_table.h>
  #endif
  
 +#include "maru_common.h"
  #include "guest_debug.h"
+ #include "maru_pm.h"
+ 
+ int codec_init(PCIBus *bus);
+ 
  
  #define MAX_IDE_BUS 2
  
@@@ -150,13 -202,7 +203,13 @@@ static void maru_x86_machine_init(Memor
  
      /* allocate ram and load rom/bios */
      if (!xen_enabled()) {
-         pc_memory_init(system_memory,
 +      // W/A for allocate larger continuous heap.
 +        // see vl.c
 +        if(preallocated_ptr != NULL) {
 +            qemu_vfree(preallocated_ptr);
 +        }
 +      //
+         fw_cfg = pc_memory_init(system_memory,
                         kernel_filename, kernel_cmdline, initrd_filename,
                         below_4g_mem_size, above_4g_mem_size,
                         pci_enabled ? rom_memory : system_memory, &ram_memory);
@@@ -277,31 -327,12 +334,12 @@@
  #ifndef CONFIG_DARWIN
      // maru specialized device init...
      if (pci_enabled) {
 -      //tizen_ac97_init(pci_bus);
 -              codec_init(pci_bus);        
 +        //tizen_ac97_init(pci_bus);
 +        codec_init(pci_bus);        
      }
  #endif
- }
- 
- static void maru_arm_machine_init(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)
- {
- }
- 
- static void maru_common_init(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)
- {
- // prepare for universal virtual board...
- #if defined(TARGET_I386)
- #elif defined(TARGET_ARM)
+ #ifdef CONFIG_YAGL
+     pci_create_simple(pci_bus, -1, "yagl");
  #endif
  }
  

diff --cc tizen/src/hw/maru_vga.c
Simple merge

diff --cc tizen/src/mloop_event.c
index ee17346,aadb33a..ccab8f1
--- 1/tizen/src/mloop_event.c
--- 2/tizen/src/mloop_event.c
+++ b/tizen/src/mloop_event.c
@@@ -41,11 -41,8 +41,12 @@@
  #include "mloop_event.h"
  #include "console.h"
  #include "emul_state.h"
 +#include "tizen/src/debug_ch.h"
 +#include "monitor.h"
 +#include "pci.h"
++#include "sysemu.h"
  
 -#define error_report(x, ...)
 +MULTI_DEBUG_CHANNEL(qemu, mloop_event);
  
  struct mloop_evsock {
      int sockno;
@@@ -277,77 -267,6 +278,79 @@@ static void mloop_evhandle_touch(struc
      maru_virtio_touchscreen_notify();
  }
  
 +static void mloop_evhandle_keyboard(long data)
 +{
 +    virtio_keyboard_notify((void*)data);
 +}
 +
++#ifdef TARGET_I386
 +static void mloop_evhandle_kbd_add(char *name)
 +{
 +    TRACE("mloop_evhandle_kbd_add\n");
 +
 +    if (name == NULL) {
 +        ERR("packet data is NULL.\n");
 +        return;
 +    }
 +
 +    if (strcmp(name, "keyboard") == 0) {
 +        QDict *qdict = qdict_new();
 +
 +        qdict_put(qdict, "pci_addr", qstring_from_str("auto"));
 +        qdict_put(qdict, "type", qstring_from_str(name));
 +
 +        TRACE("hot_add keyboard device.\n");
 +        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),
 +                    PCI_SLOT(hostkbd->devfn), PCI_FUNC(hostkbd->devfn));
 +        } else {
 +            ERR("failed to hot_add keyboard device.\n");
 +        }
 +
 +        QDECREF(qdict);
 +    } else {
 +        WARN("There is no %s device.\n", name);
 +    }
 +}
 +
 +static void mloop_evhandle_kbd_del(char *name)
 +{
 +    TRACE("mloop_evhandle_kbd_del\n");
 +
 +    if (name == NULL) {
 +        ERR("packet data is NULL.\n");
 +        return;
 +    }
 +
 +    if (strcmp(name, "keyboard") == 0) {
 +        QDict *qdict = qdict_new();
 +        int slot = 0;
 +        char slotbuf[4] = {0,};
 +
 +        if (hostkbd) {
 +            slot = PCI_SLOT(hostkbd->devfn);
 +            snprintf(slotbuf, sizeof(slotbuf), "%x", slot);
 +            TRACE("virtio-keyboard slot %s.\n", slotbuf);
 +        } else {
 +            ERR("failed to hot_remove keyboard because hostkbd is NULL.\n");
 +            return;
 +        }
 +
 +        qdict_put(qdict, "pci_addr", qstring_from_str(slotbuf));
 +
 +        TRACE("hot_remove keyboard.\n");
 +        do_pci_device_hot_remove(cur_mon, qdict);
 +
 +        QDECREF(qdict);
 +    } else {
 +        WARN("There is no %s device.\n", name);
 +    }
 +}
++#endif
 +
  static void mloop_evcb_recv(struct mloop_evsock *ev)
  {
      struct mloop_evpack pack;
@@@ -391,15 -310,6 +394,17 @@@
      case MLOOP_EVTYPE_TOUCH:
          mloop_evhandle_touch(&pack);
          break;
 +    case MLOOP_EVTYPE_KEYBOARD:
 +        mloop_evhandle_keyboard(ntohl(*(long*)&pack.data[0]));
 +        break;
++#ifdef TARGET_I386
 +    case MLOOP_EVTYPE_KBD_ADD:
 +        mloop_evhandle_kbd_add(pack.data);
 +        break;
 +    case MLOOP_EVTYPE_KBD_DEL:
 +        mloop_evhandle_kbd_del(pack.data);
 +        break;
++#endif
      default:
          break;
      }

diff --cc tizen/src/skin/maruskin_operation.c
Simple merge

diff --cc tizen/src/skin/maruskin_server.c
Simple merge

diff --cc vl.c
index 356790c,69456cd..1200298
--- 1/vl.c
--- 2/vl.c
+++ b/vl.c
@@@ -2285,15 -2456,13 +2457,18 @@@ static int find_device_opt (QemuOpts *o
  
  int use_qemu_display = 0; //0:use tizen qemu sdl, 1:use original qemu sdl
  
+ int qemu_init_main_loop(void)
+ {
+     return main_loop_init();
+ }
  
 +#ifdef CONFIG_MARU
 +// W/A for preserve larger continuous heap for RAM.
 +void *preallocated_ptr = 0;
 +#endif
 +
  int main(int argc, char **argv, char **envp)
  {
-     const char *gdbstub_dev = NULL;
      int i;
      int snapshot, linux_boot;
      const char *icount_option = NULL;
@@@ -3438,14 -3646,13 +3652,17 @@@
      if (ram_size == 0) {
          ram_size = DEFAULT_RAM_SIZE * 1024 * 1024;
      }
 +#ifdef CONFIG_MARU
 +    // W/A for preserve larger continuous heap for RAM.
 +    preallocated_ptr = qemu_vmalloc(ram_size);
 +#endif
  
- #ifdef CONFIG_HAX
      hax_pre_init(ram_size);
- #endif
+ 
+     if (qemu_opts_foreach(qemu_find_opts("device"), device_help_func, NULL, 0)
+         != 0) {
+         exit(0);
+     }
  
      configure_accelerator();