virtio-pci: merged virtio-pci module and others.

Change-Id: I11b764cd55316377cffd96a6ea77d5590d43b3d6
Signed-off-by: Kitae Kim <kt920.kim@samsung.com>

diff --git a/hw/virtio/virtio-pci.c b/hw/virtio/virtio-pci.c
index 161ade3..2d70f36 100644 (file)
--- a/hw/virtio/virtio-pci.c
+++ b/hw/virtio/virtio-pci.c
@@ -651,7 +651,7 @@ static void virtio_pci_vq_vector_mask(VirtIOPCIProxy *proxy,
 
     /* If guest supports masking, keep irqfd but mask it.
      * Otherwise, clean it up now.
-     */ 
+     */
     if (k->guest_notifier_mask) {
         k->guest_notifier_mask(proxy->vdev, queue_no, true);
     } else {
@@ -1500,6 +1500,265 @@ static const TypeInfo virtio_rng_pci_info = {
     .class_init    = virtio_rng_pci_class_init,
 };
 
+#ifdef CONFIG_MARU
+#if 0
+#ifdef CONFIG_GL_BACKEND
+/* virtio-gl-pci */
+
+static int virtio_gl_pci_init(VirtIOPCIProxy *vpci_dev)
+{
+    VirtIOGLPCI *dev = VIRTIO_GL_PCI(vpci_dev);
+    DeviceState *vdev = DEVICE(&dev->vdev);
+
+    qdev_set_parent_bus(vdev, BUS(&vpci_dev->bus));
+    if (qdev_init(vdev) < 0) {
+        return -1;
+    }
+
+    return 0;
+}
+
+static void virtio_gl_pci_class_init(ObjectClass *klass, void *data)
+{
+//    DeviceClass *dc = DEVICE_CLASS(klass);
+    VirtioPCIClass *k = VIRTIO_PCI_CLASS(klass);
+    PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass);
+
+    k->init = virtio_gl_pci_init;
+    pcidev_k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
+    pcidev_k->device_id = PCI_DEVICE_ID_VIRTIO_GL;
+    pcidev_k->revision = VIRTIO_PCI_ABI_VERSION;
+    pcidev_k->class_id = PCI_CLASS_OTHERS;
+}
+
+static void virtio_gl_pci_instance_init(Object *obj)
+{
+    VirtIOGLPCI *dev = VIRTIO_GL_PCI(obj);
+    object_initialize(OBJECT(&dev->vdev), TYPE_VIRTIO_GL);
+    object_property_add_child(obj, "virtio-backend", OBJECT(&dev->vdev), NULL);
+}
+
+static TypeInfo virtio_gl_pci_info = {
+    .name          = TYPE_VIRTIO_GL_PCI,
+    .parent        = TYPE_PCI_DEVICE,
+    .instance_size = sizeof(VirtIOPCIProxy),
+    .instance_init = sizeof(VirtIOGL),
+    .class_init    = virtio_gl_pci_class_init,
+};
+#endif
+#endif
+
+/* virtio-touchscreen-pci */
+
+static int virtio_touchscreen_pci_init(VirtIOPCIProxy *vpci_dev)
+{
+    VirtIOTouchscreenPCI *dev = VIRTIO_TOUCHSCREEN_PCI(vpci_dev);
+    DeviceState *vdev = DEVICE(&dev->vdev);
+
+    qdev_set_parent_bus(vdev, BUS(&vpci_dev->bus));
+    if (qdev_init(vdev) < 0) {
+        return -1;
+    }
+    return 0;
+}
+
+static void virtio_touchscreen_pci_class_init(ObjectClass *klass, void *data)
+{
+//    DeviceClass *dc = DEVICE_CLASS(klass);
+    VirtioPCIClass *k = VIRTIO_PCI_CLASS(klass);
+    PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass);
+
+    k->init = virtio_touchscreen_pci_init;
+    pcidev_k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
+    pcidev_k->device_id = PCI_DEVICE_ID_VIRTIO_TOUCHSCREEN;
+    pcidev_k->revision = VIRTIO_PCI_ABI_VERSION;
+    pcidev_k->class_id = PCI_CLASS_OTHERS;
+}
+
+static void virtio_touchscreen_pci_instance_init(Object *obj)
+{
+    VirtIOTouchscreenPCI *dev = VIRTIO_TOUCHSCREEN_PCI(obj);
+    object_initialize(OBJECT(&dev->vdev), TYPE_VIRTIO_TOUCHSCREEN);
+    object_property_add_child(obj, "virtio-backend", OBJECT(&dev->vdev), NULL);
+}
+
+static TypeInfo virtio_touchscreen_pci_info = {
+    .name          = TYPE_VIRTIO_TOUCHSCREEN_PCI,
+    .parent        = TYPE_PCI_DEVICE,
+    .instance_size = sizeof(VirtIOTouchscreenPCI),
+       .instance_init = virtio_touchscreen_pci_instance_init,
+    .class_init    = virtio_touchscreen_pci_class_init,
+};
+
+/* virtio-keyboard-pci */
+
+static int virtio_keyboard_pci_init(VirtIOPCIProxy *vpci_dev)
+{
+    VirtIOKeyboardPCI *dev = VIRTIO_KEYBOARD_PCI(vpci_dev);
+    DeviceState *vdev = DEVICE(&dev->vdev);
+
+    qdev_set_parent_bus(vdev, BUS(&vpci_dev->bus));
+    if (qdev_init(vdev) < 0) {
+        return -1;
+    }
+    return 0;
+}
+
+static void virtio_keyboard_pci_class_init(ObjectClass *klass, void *data)
+{
+//    DeviceClass *dc = DEVICE_CLASS(klass);
+    VirtioPCIClass *k = VIRTIO_PCI_CLASS(klass);
+    PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass);
+
+    k->init = virtio_keyboard_pci_init;
+    pcidev_k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
+    pcidev_k->device_id = PCI_DEVICE_ID_VIRTIO_KEYBOARD;
+    pcidev_k->revision = VIRTIO_PCI_ABI_VERSION;
+    pcidev_k->class_id = PCI_CLASS_OTHERS;
+}
+
+static void virtio_keyboard_pci_instance_init(Object *obj)
+{
+    VirtIOKeyboardPCI *dev = VIRTIO_KEYBOARD_PCI(obj);
+    object_initialize(OBJECT(&dev->vdev), TYPE_VIRTIO_KEYBOARD);
+    object_property_add_child(obj, "virtio-backend", OBJECT(&dev->vdev), NULL);
+}
+
+static TypeInfo virtio_keyboard_pci_info = {
+    .name          = TYPE_VIRTIO_KEYBOARD_PCI,
+    .parent        = TYPE_PCI_DEVICE,
+    .instance_size = sizeof(VirtIOKeyboardPCI),
+       .instance_init = virtio_keyboard_pci_instance_init,
+    .class_init    = virtio_keyboard_pci_class_init,
+};
+
+/* virtio-esm-pci */
+
+static int virtio_esm_pci_init(VirtIOPCIProxy *vpci_dev)
+{
+    VirtIOESMPCI *dev = VIRTIO_ESM_PCI(vpci_dev);
+    DeviceState *vdev = DEVICE(&dev->vdev);
+
+    qdev_set_parent_bus(vdev, BUS(&vpci_dev->bus));
+    if (qdev_init(vdev) < 0) {
+        return -1;
+    }
+    return 0;
+}
+
+static void virtio_esm_pci_class_init(ObjectClass *klass, void *data)
+{
+//    DeviceClass *dc = DEVICE_CLASS(klass);
+    VirtioPCIClass *k = VIRTIO_PCI_CLASS(klass);
+    PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass);
+
+    k->init = virtio_esm_pci_init;
+    pcidev_k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
+    pcidev_k->device_id = PCI_DEVICE_ID_VIRTIO_ESM;
+    pcidev_k->revision = VIRTIO_PCI_ABI_VERSION;
+    pcidev_k->class_id = PCI_CLASS_OTHERS;
+}
+
+static void virtio_esm_pci_instance_init(Object *obj)
+{
+    VirtIOESMPCI *dev = VIRTIO_ESM_PCI(obj);
+    object_initialize(OBJECT(&dev->vdev), TYPE_VIRTIO_ESM);
+    object_property_add_child(obj, "virtio-backend", OBJECT(&dev->vdev), NULL);
+}
+
+static TypeInfo virtio_esm_pci_info = {
+    .name          = TYPE_VIRTIO_ESM_PCI,
+    .parent        = TYPE_PCI_DEVICE,
+    .instance_size = sizeof(VirtIOESMPCI),
+       .instance_init = virtio_esm_pci_instance_init,
+    .class_init    = virtio_esm_pci_class_init,
+};
+
+/* virtio-hwkey-pci */
+
+static int virtio_hwkey_pci_init(VirtIOPCIProxy *vpci_dev)
+{
+    VirtIOHWKeyPCI *dev = VIRTIO_HWKEY_PCI(vpci_dev);
+    DeviceState *vdev = DEVICE(&dev->vdev);
+
+    qdev_set_parent_bus(vdev, BUS(&vpci_dev->bus));
+    if (qdev_init(vdev) < 0) {
+        return -1;
+    }
+    return 0;
+}
+
+static void virtio_hwkey_pci_class_init(ObjectClass *klass, void *data)
+{
+//    DeviceClass *dc = DEVICE_CLASS(klass);
+    VirtioPCIClass *k = VIRTIO_PCI_CLASS(klass);
+    PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass);
+
+    k->init = virtio_hwkey_pci_init;
+    pcidev_k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
+    pcidev_k->device_id = PCI_DEVICE_ID_VIRTIO_HWKEY;
+    pcidev_k->revision = VIRTIO_PCI_ABI_VERSION;
+    pcidev_k->class_id = PCI_CLASS_OTHERS;
+}
+
+static void virtio_hwkey_pci_instance_init(Object *obj)
+{
+    VirtIOHWKeyPCI *dev = VIRTIO_HWKEY_PCI(obj);
+    object_initialize(OBJECT(&dev->vdev), TYPE_VIRTIO_HWKEY);
+    object_property_add_child(obj, "virtio-backend", OBJECT(&dev->vdev), NULL);
+}
+
+static TypeInfo virtio_hwkey_pci_info = {
+    .name          = TYPE_VIRTIO_HWKEY_PCI,
+    .parent        = TYPE_PCI_DEVICE,
+    .instance_size = sizeof(VirtIOHWKeyPCI),
+       .instance_init = virtio_hwkey_pci_instance_init,
+    .class_init    = virtio_hwkey_pci_class_init,
+};
+
+/* virtio-evdi-pci */
+
+static int virtio_evdi_pci_init(VirtIOPCIProxy *vpci_dev)
+{
+    VirtIOEVDIPCI *dev = VIRTIO_EVDI_PCI(vpci_dev);
+    DeviceState *vdev = DEVICE(&dev->vdev);
+
+    qdev_set_parent_bus(vdev, BUS(&vpci_dev->bus));
+    if (qdev_init(vdev) < 0) {
+        return -1;
+    }
+    return 0;
+}
+
+static void virtio_evdi_pci_class_init(ObjectClass *klass, void *data)
+{
+//    DeviceClass *dc = DEVICE_CLASS(klass);
+    VirtioPCIClass *k = VIRTIO_PCI_CLASS(klass);
+    PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass);
+
+    k->init = virtio_evdi_pci_init;
+    pcidev_k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
+    pcidev_k->device_id = PCI_DEVICE_ID_VIRTIO_EVDI;
+    pcidev_k->revision = VIRTIO_PCI_ABI_VERSION;
+    pcidev_k->class_id = PCI_CLASS_OTHERS;
+}
+
+static void virtio_evdi_pci_instance_init(Object *obj)
+{
+    VirtIOEVDIPCI *dev = VIRTIO_EVDI_PCI(obj);
+    object_initialize(OBJECT(&dev->vdev), TYPE_VIRTIO_EVDI);
+    object_property_add_child(obj, "virtio-backend", OBJECT(&dev->vdev), NULL);
+}
+
+static TypeInfo virtio_evdi_pci_info = {
+    .name          = TYPE_VIRTIO_EVDI_PCI,
+    .parent        = TYPE_PCI_DEVICE,
+    .instance_size = sizeof(VirtIOEVDIPCI),
+       .instance_init = virtio_evdi_pci_instance_init,
+    .class_init    = virtio_evdi_pci_class_init,
+};
+#endif
+
 /* virtio-pci-bus */
 
 static void virtio_pci_bus_new(VirtioBusState *bus, VirtIOPCIProxy *dev)
@@ -1555,6 +1814,18 @@ static void virtio_pci_register_types(void)
 #ifdef CONFIG_VHOST_SCSI
     type_register_static(&vhost_scsi_pci_info);
 #endif
+#ifdef CONFIG_MARU
+#if 0
+#ifdef CONFIG_GL_BACKEND
+    type_register_static(&virtio_gl_pci_info);
+#endif
+#endif
+    type_register_static(&virtio_evdi_pci_info);
+    type_register_static(&virtio_esm_pci_info);
+    type_register_static(&virtio_hwkey_pci_info);
+    type_register_static(&virtio_keyboard_pci_info);
+    type_register_static(&virtio_touchscreen_pci_info);
+#endif
 }
 
 type_init(virtio_pci_register_types)

diff --git a/hw/virtio/virtio-pci.h b/hw/virtio/virtio-pci.h
index 917bcc5..ec2e4d0 100644 (file)
--- a/hw/virtio/virtio-pci.h
+++ b/hw/virtio/virtio-pci.h
@@ -31,6 +31,19 @@
 #include "hw/virtio/vhost-scsi.h"
 #endif
 
+#ifdef CONFIG_MARU
+#ifdef CONFIG_GL_BACKEND
+// #include "../tizen/src/hw/maru_virtio_gl.h"
+#endif
+#include "../tizen/src/mloop_event.h"
+#include "../tizen/src/hw/maru_device_ids.h"
+#include "../tizen/src/hw/maru_virtio_evdi.h"
+#include "../tizen/src/hw/maru_virtio_esm.h"
+#include "../tizen/src/hw/maru_virtio_hwkey.h"
+#include "../tizen/src/hw/maru_virtio_keyboard.h"
+#include "../tizen/src/hw/maru_virtio_touchscreen.h"
+#endif
+
 typedef struct VirtIOPCIProxy VirtIOPCIProxy;
 typedef struct VirtIOBlkPCI VirtIOBlkPCI;
 typedef struct VirtIOSCSIPCI VirtIOSCSIPCI;
@@ -40,6 +53,17 @@ typedef struct VirtIONetPCI VirtIONetPCI;
 typedef struct VHostSCSIPCI VHostSCSIPCI;
 typedef struct VirtIORngPCI VirtIORngPCI;
 
+#ifdef CONFIG_MARU
+#ifdef CONFIG_GL_BACKEND
+// typedef struct VirtIOGLPCI VirtIOGLPCI;
+#endif
+typedef struct VirtIOTouchscreenPCI VirtIOTouchscreenPCI;
+typedef struct VirtIOEVDIPCI VirtIOEVDIPCI;
+typedef struct VirtIOESMPCI VirtIOESMPCI;
+typedef struct VirtIOHWKeyPCI VirtIOHWKeyPCI;
+typedef struct VirtIOKeyboardPCI VirtIOKeyboardPCI;
+#endif
+
 /* virtio-pci-bus */
 
 typedef struct VirtioBusState VirtioPCIBusState;
@@ -200,6 +224,83 @@ struct VirtIORngPCI {
     VirtIORNG vdev;
 };
 
+#ifdef CONFIG_MARU
+#ifdef CONFIG_GL_BACKEND
+
+#if 0
+/*
+ * virtio-gl-pci: This extends VirtioPCIProxy.
+ */
+#define TYPE_VIRTIO_GL_PCI "virtio-gl-pci"
+#define VIRTIO_GL_PCI(obj) \
+        OBJECT_CHECK(VirtIOGLPCI, (obj), TYPE_VIRTIO_GL_PCI)
+
+struct VirtIOGLPCI {
+    VirtIOPCIProxy parent_obj;
+    VirtIOGL vdev;
+};
+#endif
+#endif
+
+/*
+ * virtio-touchscreen-pci: This extends VirtioPCIProxy.
+ */
+#define TYPE_VIRTIO_TOUCHSCREEN_PCI "virtio-touchscreen-pci"
+#define VIRTIO_TOUCHSCREEN_PCI(obj) \
+        OBJECT_CHECK(VirtIOTouchscreenPCI, (obj), TYPE_VIRTIO_TOUCHSCREEN_PCI)
+
+struct VirtIOTouchscreenPCI {
+    VirtIOPCIProxy parent_obj;
+    VirtIOTouchscreen vdev;
+};
+
+/*
+ * virtio-keyboard-pci: This extends VirtioPCIProxy.
+ */
+#define TYPE_VIRTIO_KEYBOARD_PCI "virtio-keyboard-pci"
+#define VIRTIO_KEYBOARD_PCI(obj) \
+        OBJECT_CHECK(VirtIOKeyboardPCI, (obj), TYPE_VIRTIO_KEYBOARD_PCI)
+
+struct VirtIOKeyboardPCI {
+    VirtIOPCIProxy parent_obj;
+    VirtIOKeyboard vdev;
+};
+
+/*
+ * virtio-evdi-pci: This extends VirtioPCIProxy.
+ */
+#define TYPE_VIRTIO_EVDI_PCI "virtio-evdi-pci"
+#define VIRTIO_EVDI_PCI(obj) \
+        OBJECT_CHECK(VirtIOEVDIPCI, (obj), TYPE_VIRTIO_EVDI_PCI)
+
+struct VirtIOEVDIPCI {
+    VirtIOPCIProxy parent_obj;
+    VirtIOEVDI vdev;
+};
+
+/*
+ * virtio-esm-pci: This extends VirtioPCIProxy.
+ */
+#define TYPE_VIRTIO_ESM_PCI "virtio-esm-pci"
+#define VIRTIO_ESM_PCI(obj) \
+        OBJECT_CHECK(VirtIOESMPCI, (obj), TYPE_VIRTIO_ESM_PCI)
+struct VirtIOESMPCI {
+    VirtIOPCIProxy parent_obj;
+    VirtIOESM vdev;
+};
+
+/*
+ * virtio-hwkey-pci: This extends VirtioPCIProxy.
+ */
+#define TYPE_VIRTIO_HWKEY_PCI "virtio-hwkey-pci"
+#define VIRTIO_HWKEY_PCI(obj) \
+        OBJECT_CHECK(VirtIOHWKeyPCI, (obj), TYPE_VIRTIO_HWKEY_PCI)
+struct VirtIOHWKeyPCI {
+    VirtIOPCIProxy parent_obj;
+    VirtIOHWKey vdev;
+};
+#endif
+
 /* Virtio ABI version, if we increment this, we break the guest driver. */
 #define VIRTIO_PCI_ABI_VERSION          0
 

diff --git a/tizen/src/hw/maru_virtio_esm.c b/tizen/src/hw/maru_virtio_esm.c
index 325dba5..0625f9e 100644 (file)
--- a/tizen/src/hw/maru_virtio_esm.c
+++ b/tizen/src/hw/maru_virtio_esm.c
@@ -39,18 +39,20 @@ struct progress_info {
        uint16_t percentage;
 };
 
+#if 0
 typedef struct VirtIOEmulatorStatusMedium {
     VirtIODevice    vdev;
     VirtQueue       *vq;
     DeviceState     *qdev;
-} VirtIO_ESM;
+} VirtIOESM;
+#endif
 
 static VirtQueueElement elem;
 struct progress_info progress;
 
 static void virtio_esm_handle(VirtIODevice *vdev, VirtQueue *vq)
 {
-    VirtIO_ESM *vesm = (VirtIO_ESM *)vdev;
+    VirtIOESM *vesm = (VirtIOESM *)vdev;
     int index = 0;
 
     TRACE("virtqueue handler.\n");
@@ -95,11 +97,11 @@ static uint32_t virtio_esm_get_features(VirtIODevice *vdev,
 
 VirtIODevice *virtio_esm_init(DeviceState *dev)
 {
-    VirtIO_ESM *vesm;
+    VirtIOESM *vesm;
     INFO("initialize virtio-esm device\n");
 
-    vesm = (VirtIO_ESM *)virtio_common_init("virtio-esm",
-            VIRTIO_ID_ESM, 0, sizeof(VirtIO_ESM));
+    vesm = (VirtIOESM *)virtio_common_init("virtio-esm",
+            VIRTIO_ID_ESM, 0, sizeof(VirtIOESM));
     if (vesm == NULL) {
         ERR("failed to initialize device\n");
         return NULL;

diff --git a/tizen/src/hw/maru_virtio_esm.h b/tizen/src/hw/maru_virtio_esm.h
index 75e3db7..934dfe9 100644 (file)
--- a/tizen/src/hw/maru_virtio_esm.h
+++ b/tizen/src/hw/maru_virtio_esm.h
@@ -33,7 +33,17 @@
 extern "C" {
 #endif
 
-#include "hw/virtio.h"
+#include "hw/virtio/virtio.h"
+
+#define TYPE_VIRTIO_ESM "virtio-esm-device"
+#define VIRTIO_ESM(obj) \
+        OBJECT_CHECK(VirtIOESM, (obj), TYPE_VIRTIO_ESM)
+
+typedef struct VirtIOEmulatorStatusMedium {
+    VirtIODevice    vdev;
+    VirtQueue       *vq;
+    DeviceState     *qdev;
+} VirtIOESM;
 
 VirtIODevice *virtio_esm_init(DeviceState *dev);
 

diff --git a/tizen/src/hw/maru_virtio_evdi.c b/tizen/src/hw/maru_virtio_evdi.c
index 01d54eb..5e1a520 100644 (file)
--- a/tizen/src/hw/maru_virtio_evdi.c
+++ b/tizen/src/hw/maru_virtio_evdi.c
@@ -46,17 +46,18 @@ struct msg_info {
        uint32_t use;\r
 };\r
 \r
-typedef struct VirtIO_EVDI{\r
+#if 0\r
+typedef struct VirtIOEVDI{\r
     VirtIODevice    vdev;\r
     VirtQueue       *rvq;\r
     VirtQueue          *svq;\r
     DeviceState     *qdev;\r
 \r
     QEMUBH *bh;\r
-} VirtIO_EVDI;\r
+} VirtIOEVDI;\r
+#endif\r
 \r
-\r
-VirtIO_EVDI* vio_evdi;\r
+VirtIOEVDI* vio_evdi;\r
 \r
 static int g_cnt = 0;\r
 \r
@@ -100,7 +101,7 @@ static void virtio_evdi_recv(VirtIODevice *vdev, VirtQueue *vq)
                                        _msg.use, _msg.buf, elem.in_sg[0].iov_len);\r
 \r
 \r
-                       virtqueue_push(vq, &elem, sizeof(VirtIO_EVDI));\r
+                       virtqueue_push(vq, &elem, sizeof(VirtIOEVDI));\r
                        virtio_notify(&vio_evdi->vdev, vq);\r
        }\r
        }\r
@@ -111,7 +112,7 @@ static void virtio_evdi_recv(VirtIODevice *vdev, VirtQueue *vq)
 \r
 static void virtio_evdi_send(VirtIODevice *vdev, VirtQueue *vq)\r
 {\r
-       VirtIO_EVDI *vevdi = (VirtIO_EVDI *)vdev;\r
+       VirtIOEVDI *vevdi = (VirtIOEVDI *)vdev;\r
     int index = 0;\r
     struct msg_info _msg;\r
 \r
@@ -141,7 +142,7 @@ static void virtio_evdi_send(VirtIODevice *vdev, VirtQueue *vq)
                INFO("<< evdisend : recv from guest len = %d, msg = %s \n", _msg.use, _msg.buf);\r
     }\r
 \r
-       virtqueue_push(vq, &elem, sizeof(VirtIO_EVDI));\r
+       virtqueue_push(vq, &elem, sizeof(VirtIOEVDI));\r
        virtio_notify(&vio_evdi->vdev, vq);\r
 }\r
 \r
@@ -166,8 +167,8 @@ VirtIODevice *virtio_evdi_init(DeviceState *dev)
 {\r
     INFO("initialize evdi device\n");\r
 \r
-    vio_evdi = (VirtIO_EVDI *)virtio_common_init(VIRTIO_EVDI_DEVICE_NAME,\r
-            VIRTIO_ID_EVDI, 0, sizeof(VirtIO_EVDI));\r
+    vio_evdi = (VirtIOEVDI *)virtio_common_init(VIRTIO_EVDI_DEVICE_NAME,\r
+            VIRTIO_ID_EVDI, 0, sizeof(VirtIOEVDI));\r
     if (vio_evdi == NULL) {\r
         ERR("failed to initialize evdi device\n");\r
         return NULL;\r

diff --git a/tizen/src/hw/maru_virtio_evdi.h b/tizen/src/hw/maru_virtio_evdi.h
index ad88b68..25d8f5f 100644 (file)
--- a/tizen/src/hw/maru_virtio_evdi.h
+++ b/tizen/src/hw/maru_virtio_evdi.h
@@ -12,7 +12,20 @@
 extern "C" {\r
 #endif\r
 \r
-#include "hw/virtio.h"\r
+#include "hw/virtio/virtio.h"\r
+\r
+#define TYPE_VIRTIO_EVDI "virtio-evdi-device"\r
+#define VIRTIO_EVDI(obj) \\r
+        OBJECT_CHECK(VirtIOEVDI, (obj), TYPE_VIRTIO_EVDI)\r
+\r
+typedef struct VirtIOEVDI {\r
+    VirtIODevice    vdev;\r
+    VirtQueue       *rvq;\r
+    VirtQueue          *svq;\r
+    DeviceState     *qdev;\r
+\r
+    QEMUBH *bh;\r
+} VirtIOEVDI;\r
 \r
 VirtIODevice *virtio_evdi_init(DeviceState *dev);\r
 \r

diff --git a/tizen/src/hw/maru_virtio_hwkey.h b/tizen/src/hw/maru_virtio_hwkey.h
index 6ce3e98..9e48da8 100644 (file)
--- a/tizen/src/hw/maru_virtio_hwkey.h
+++ b/tizen/src/hw/maru_virtio_hwkey.h
@@ -31,9 +31,14 @@
 #define MARU_HWKEY_H_
 
 #include "ui/console.h"
-#include "hw/virtio.h"
+#include "hw/virtio/virtio.h"
 
-typedef struct VirtIOHwKey
+#define TYPE_VIRTIO_HWKEY "virtio-hwkey-device"
+#define VIRTIO_HWKEY(obj) \
+        OBJECT_CHECK(VirtIOHWKey, (obj), TYPE_VIRTIO_HWKEY)
+
+
+typedef struct VirtIOHWKey
 {
     VirtIODevice vdev;
     /* simply a queue into which buffers are posted
@@ -42,13 +47,13 @@ typedef struct VirtIOHwKey
 
     QEMUBH *bh;
     DeviceState *qdev;
-} VirtIOHwKey;
+} VirtIOHWKey;
 
 /* This structure must match the kernel definitions */
-typedef struct EmulHwKeyEvent {
+typedef struct EmulHWKeyEvent {
     uint8_t event_type;
     uint32_t keycode;
-} EmulHwKeyEvent;
+} EmulHWKeyEvent;
 
 
 VirtIODevice *maru_virtio_hwkey_init(DeviceState *dev);

diff --git a/tizen/src/hw/maru_virtio_keyboard.h b/tizen/src/hw/maru_virtio_keyboard.h
index e5b38a6..17aa0bd 100644 (file)
--- a/tizen/src/hw/maru_virtio_keyboard.h
+++ b/tizen/src/hw/maru_virtio_keyboard.h
@@ -38,7 +38,7 @@ extern "C" {
 #include "qemu/thread.h"
 #include "hw/virtio/virtio.h"
 
-#define VIRTIO_KBD_DEVICE_NAME "virtio-keyboard"
+#define TYPE_VIRTIO_KEYBOARD "virtio-keyboard-device"
 #define VIRTIO_KBD_QUEUE_SIZE  100
 
 typedef struct EmulKbdEvent {

diff --git a/tizen/src/hw/maru_virtio_touchscreen.h b/tizen/src/hw/maru_virtio_touchscreen.h
index 00fde84..777d3ef 100644 (file)
--- a/tizen/src/hw/maru_virtio_touchscreen.h
+++ b/tizen/src/hw/maru_virtio_touchscreen.h
@@ -33,8 +33,11 @@
 #include "ui/console.h"
 #include "hw/virtio/virtio.h"
 
-typedef struct TouchscreenState
-{
+#define TYPE_VIRTIO_TOUCHSCREEN "virtio-touschreen-device"
+#define VIRTIO_TOUCHSCREEN(obj) \
+        OBJECT_CHECK(VirtIOTouchscreen, (obj), TYPE_VIRTIO_TOUCHSCREEN)
+
+typedef struct VirtIOTouchscreen {
     VirtIODevice vdev;
     /* simply a queue into which buffers are posted
     by the guest for consumption by the host */
@@ -44,7 +47,7 @@ typedef struct TouchscreenState
     QEMUBH *bh;
     DeviceState *qdev;
     QEMUPutMouseEntry *eh_entry;
-} TouchscreenState;
+} VirtIOTouchscreen;
 
 /* This structure must match the kernel definitions */
 typedef struct EmulTouchEvent {