upstream: virtio device used 'realize' instead of 'init'

Virtio device should use 'realize'ed initialization.
Removed duplicate properties.

Change-Id: I019185bed12f6c9cdacb72864191f7f667d6784f
Signed-off-by: SeokYeon Hwang <syeon.hwang@samsung.com>

diff --git a/tizen/src/hw/virtio/maru_virtio_esm.c b/tizen/src/hw/virtio/maru_virtio_esm.c
index 80f5666..5541857 100644 (file)
--- a/tizen/src/hw/virtio/maru_virtio_esm.c
+++ b/tizen/src/hw/virtio/maru_virtio_esm.c
@@ -112,7 +112,8 @@ static void virtio_esm_handle(VirtIODevice *vdev, VirtQueue *vq)
     virtio_notify(&vesm->vdev, vesm->vq);
 }
 
-static uint32_t virtio_esm_get_features(VirtIODevice *vdev, uint32_t feature)
+static uint64_t virtio_esm_get_features(VirtIODevice *vdev,
+        uint64_t feature, Error **Errp)
 {
     TRACE("virtio_esm_get_features.\n");
     return feature;

diff --git a/tizen/src/hw/virtio/maru_virtio_evdi.c b/tizen/src/hw/virtio/maru_virtio_evdi.c
index 2b2006b..a860284 100644 (file)
--- a/tizen/src/hw/virtio/maru_virtio_evdi.c
+++ b/tizen/src/hw/virtio/maru_virtio_evdi.c
@@ -211,8 +211,8 @@ static void virtio_evdi_send(VirtIODevice *vdev, VirtQueue *vq)
     virtio_notify(&vio_evdi->vdev, vq);
 }
 
-static uint32_t virtio_evdi_get_features(VirtIODevice *vdev,
-                                            uint32_t request_feature)
+static uint64_t virtio_evdi_get_features(VirtIODevice *vdev,
+        uint64_t request_feature, Error **errp)
 {
     TRACE("virtio_evdi_get_features.\n");
     return 0;

diff --git a/tizen/src/hw/virtio/maru_virtio_hwkey.c b/tizen/src/hw/virtio/maru_virtio_hwkey.c
index ab4b710..412e571 100644 (file)
--- a/tizen/src/hw/virtio/maru_virtio_hwkey.c
+++ b/tizen/src/hw/virtio/maru_virtio_hwkey.c
@@ -182,8 +182,8 @@ void maru_virtio_hwkey_notify(void)
     }
 }
 
-static uint32_t virtio_hwkey_get_features(
-    VirtIODevice *vdev, uint32_t request_features)
+static uint64_t virtio_hwkey_get_features(
+        VirtIODevice *vdev, uint64_t request_features, Error **errp)
 {
     return request_features;
 }

diff --git a/tizen/src/hw/virtio/maru_virtio_jack.c b/tizen/src/hw/virtio/maru_virtio_jack.c
index eb7139a..319d1c0 100644 (file)
--- a/tizen/src/hw/virtio/maru_virtio_jack.c
+++ b/tizen/src/hw/virtio/maru_virtio_jack.c
@@ -297,8 +297,8 @@ static void virtio_jack_reset(VirtIODevice *vdev)
     TRACE("virtio_jack_reset.\n");
 }
 
-static uint32_t virtio_jack_get_features(VirtIODevice *vdev,
-                                            uint32_t request_feature)
+static uint64_t virtio_jack_get_features(VirtIODevice *vdev,
+        uint64_t request_feature, Error **errp)
 {
     TRACE("virtio_jack_get_features.\n");
     return 0;

diff --git a/tizen/src/hw/virtio/maru_virtio_keyboard.c b/tizen/src/hw/virtio/maru_virtio_keyboard.c
index 3b8b727..e49447d 100644 (file)
--- a/tizen/src/hw/virtio/maru_virtio_keyboard.c
+++ b/tizen/src/hw/virtio/maru_virtio_keyboard.c
@@ -315,8 +315,8 @@ void virtio_keyboard_event(int keycode)
     qemu_bh_schedule(vkbd->bh);
 }
 
-static uint32_t virtio_keyboard_get_features(VirtIODevice *vdev,
-                                            uint32_t request_feature)
+static uint64_t virtio_keyboard_get_features(VirtIODevice *vdev,
+        uint64_t request_feature, Error **errp)
 {
     TRACE("virtio_keyboard_get_features.\n");
     return 0;

diff --git a/tizen/src/hw/virtio/maru_virtio_nfc.c b/tizen/src/hw/virtio/maru_virtio_nfc.c
index 76aa9da..70c4149 100644 (file)
--- a/tizen/src/hw/virtio/maru_virtio_nfc.c
+++ b/tizen/src/hw/virtio/maru_virtio_nfc.c
@@ -232,8 +232,8 @@ static void virtio_nfc_send(VirtIODevice *vdev, VirtQueue *vq)
     virtio_notify(&vio_nfc->vdev, vq);
 }
 
-static uint32_t virtio_nfc_get_features(VirtIODevice *vdev,
-        uint32_t request_feature)
+static uint64_t virtio_nfc_get_features(VirtIODevice *vdev,
+        uint64_t request_feature, Error **errp)
 {
     TRACE("virtio_nfc_get_features.\n");
     return 0;

diff --git a/tizen/src/hw/virtio/maru_virtio_pci.c b/tizen/src/hw/virtio/maru_virtio_pci.c
index 9d425f4..1443761 100644 (file)
--- a/tizen/src/hw/virtio/maru_virtio_pci.c
+++ b/tizen/src/hw/virtio/maru_virtio_pci.c
@@ -199,21 +199,16 @@ struct VirtIORotaryPCI {
 /* virtio-touchscreen-pci */
 
 static Property virtio_touchscreen_pci_properties[] = {
-    DEFINE_PROP_UINT32(TOUCHSCREEN_OPTION_NAME,
-        VirtIOTouchscreenPCI, vdev.max_finger, DEFAULT_MAX_FINGER),
     DEFINE_PROP_END_OF_LIST(),
 };
 
-static int virtio_touchscreen_pci_init(VirtIOPCIProxy *vpci_dev)
+static void virtio_touchscreen_pci_realize(VirtIOPCIProxy *vpci_dev, Error **errp)
 {
     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;
+    object_property_set_bool(OBJECT(vdev), true, "realized", errp);
 }
 
 static void virtio_touchscreen_pci_class_init(ObjectClass *klass, void *data)
@@ -223,7 +218,7 @@ static void virtio_touchscreen_pci_class_init(ObjectClass *klass, void *data)
     PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass);
 
     dc->props = virtio_touchscreen_pci_properties;
-    k->init = virtio_touchscreen_pci_init;
+    k->realize = virtio_touchscreen_pci_realize;
     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;
@@ -233,8 +228,8 @@ static void virtio_touchscreen_pci_class_init(ObjectClass *klass, void *data)
 static void virtio_touchscreen_pci_instance_init(Object *obj)
 {
     VirtIOTouchscreenPCI *dev = VIRTIO_TOUCHSCREEN_PCI(obj);
-    object_initialize(&dev->vdev, sizeof(dev->vdev), TYPE_VIRTIO_TOUCHSCREEN);
-    object_property_add_child(obj, "virtio-backend", OBJECT(&dev->vdev), NULL);
+    virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
+                                TYPE_VIRTIO_TOUCHSCREEN);
 
     dev->vdev.max_finger = DEFAULT_MAX_FINGER;
 }
@@ -249,16 +244,13 @@ static TypeInfo virtio_touchscreen_pci_info = {
 
 /* virtio-keyboard-pci */
 
-static int virtio_keyboard_pci_init(VirtIOPCIProxy *vpci_dev)
+static void virtio_keyboard_pci_realize(VirtIOPCIProxy *vpci_dev, Error **errp)
 {
     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;
+    object_property_set_bool(OBJECT(vdev), true, "realized", errp);
 }
 
 static void virtio_keyboard_pci_class_init(ObjectClass *klass, void *data)
@@ -266,7 +258,7 @@ static void virtio_keyboard_pci_class_init(ObjectClass *klass, void *data)
     VirtioPCIClass *k = VIRTIO_PCI_CLASS(klass);
     PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass);
 
-    k->init = virtio_keyboard_pci_init;
+    k->realize = virtio_keyboard_pci_realize;
     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;
@@ -276,8 +268,8 @@ static void virtio_keyboard_pci_class_init(ObjectClass *klass, void *data)
 static void virtio_keyboard_pci_instance_init(Object *obj)
 {
     VirtIOKeyboardPCI *dev = VIRTIO_KEYBOARD_PCI(obj);
-    object_initialize(&dev->vdev, sizeof(dev->vdev), TYPE_VIRTIO_KEYBOARD);
-    object_property_add_child(obj, "virtio-backend", OBJECT(&dev->vdev), NULL);
+    virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
+                                TYPE_VIRTIO_KEYBOARD);
 }
 
 static TypeInfo virtio_keyboard_pci_info = {
@@ -290,16 +282,13 @@ static TypeInfo virtio_keyboard_pci_info = {
 
 /* virtio-esm-pci */
 
-static int virtio_esm_pci_init(VirtIOPCIProxy *vpci_dev)
+static void virtio_esm_pci_realize(VirtIOPCIProxy *vpci_dev, Error **errp)
 {
     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;
+    object_property_set_bool(OBJECT(vdev), true, "realized", errp);
 }
 
 static void virtio_esm_pci_class_init(ObjectClass *klass, void *data)
@@ -307,7 +296,7 @@ static void virtio_esm_pci_class_init(ObjectClass *klass, void *data)
     VirtioPCIClass *k = VIRTIO_PCI_CLASS(klass);
     PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass);
 
-    k->init = virtio_esm_pci_init;
+    k->realize = virtio_esm_pci_realize;
     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;
@@ -317,8 +306,8 @@ static void virtio_esm_pci_class_init(ObjectClass *klass, void *data)
 static void virtio_esm_pci_instance_init(Object *obj)
 {
     VirtIOESMPCI *dev = VIRTIO_ESM_PCI(obj);
-    object_initialize(&dev->vdev, sizeof(dev->vdev), TYPE_VIRTIO_ESM);
-    object_property_add_child(obj, "virtio-backend", OBJECT(&dev->vdev), NULL);
+    virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
+                                TYPE_VIRTIO_ESM);
 }
 
 static TypeInfo virtio_esm_pci_info = {
@@ -331,25 +320,21 @@ static TypeInfo virtio_esm_pci_info = {
 
 /* virtio-hwkey-pci */
 
-static int virtio_hwkey_pci_init(VirtIOPCIProxy *vpci_dev)
+static void virtio_hwkey_pci_realize(VirtIOPCIProxy *vpci_dev, Error **errp)
 {
     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;
+    object_property_set_bool(OBJECT(vdev), true, "realized", errp);
 }
 
 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;
+    k->realize= virtio_hwkey_pci_realize;
     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;
@@ -359,8 +344,8 @@ static void virtio_hwkey_pci_class_init(ObjectClass *klass, void *data)
 static void virtio_hwkey_pci_instance_init(Object *obj)
 {
     VirtIOHWKeyPCI *dev = VIRTIO_HWKEY_PCI(obj);
-    object_initialize(&dev->vdev, sizeof(dev->vdev), TYPE_VIRTIO_HWKEY);
-    object_property_add_child(obj, "virtio-backend", OBJECT(&dev->vdev), NULL);
+    virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
+                                TYPE_VIRTIO_HWKEY);
 }
 
 static TypeInfo virtio_hwkey_pci_info = {
@@ -373,16 +358,13 @@ static TypeInfo virtio_hwkey_pci_info = {
 
 /* virtio-tablet-pci */
 
-static int virtio_tablet_pci_init(VirtIOPCIProxy *vpci_dev)
+static void virtio_tablet_pci_realize(VirtIOPCIProxy *vpci_dev, Error **errp)
 {
     VirtIOTabletPCI *dev = VIRTIO_TABLET_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;
+    object_property_set_bool(OBJECT(vdev), true, "realized", errp);
 }
 
 static void virtio_tablet_pci_class_init(ObjectClass *klass, void *data)
@@ -390,7 +372,7 @@ static void virtio_tablet_pci_class_init(ObjectClass *klass, void *data)
     VirtioPCIClass *k = VIRTIO_PCI_CLASS(klass);
     PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass);
 
-    k->init = virtio_tablet_pci_init;
+    k->realize = virtio_tablet_pci_realize;
     pcidev_k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
     pcidev_k->device_id = PCI_DEVICE_ID_VIRTIO_TABLET;
     pcidev_k->revision = VIRTIO_PCI_ABI_VERSION;
@@ -400,8 +382,8 @@ static void virtio_tablet_pci_class_init(ObjectClass *klass, void *data)
 static void virtio_tablet_pci_instance_init(Object *obj)
 {
     VirtIOTabletPCI *dev = VIRTIO_TABLET_PCI(obj);
-    object_initialize(&dev->vdev, sizeof(dev->vdev), TYPE_VIRTIO_TABLET);
-    object_property_add_child(obj, "virtio-backend", OBJECT(&dev->vdev), NULL);
+    virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
+                                TYPE_VIRTIO_TABLET);
 }
 
 static TypeInfo virtio_tablet_pci_info = {
@@ -418,16 +400,13 @@ static Property virtio_evdi_pci_properties[] = {
     DEFINE_PROP_END_OF_LIST(),
 };
 
-static int virtio_evdi_pci_init(VirtIOPCIProxy *vpci_dev)
+static void virtio_evdi_pci_realize(VirtIOPCIProxy *vpci_dev, Error **errp)
 {
     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;
+    object_property_set_bool(OBJECT(vdev), true, "realized", errp);
 }
 
 static void virtio_evdi_pci_class_init(ObjectClass *klass, void *data)
@@ -436,7 +415,7 @@ static void virtio_evdi_pci_class_init(ObjectClass *klass, void *data)
     VirtioPCIClass *k = VIRTIO_PCI_CLASS(klass);
     PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass);
 
-    k->init = virtio_evdi_pci_init;
+    k->realize = virtio_evdi_pci_realize;
     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;
@@ -447,8 +426,8 @@ static void virtio_evdi_pci_class_init(ObjectClass *klass, void *data)
 static void virtio_evdi_pci_instance_init(Object *obj)
 {
     VirtIOEVDIPCI *dev = VIRTIO_EVDI_PCI(obj);
-    object_initialize(&dev->vdev, sizeof(dev->vdev), TYPE_VIRTIO_EVDI);
-    object_property_add_child(obj, "virtio-backend", OBJECT(&dev->vdev), NULL);
+    virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
+                                TYPE_VIRTIO_EVDI);
 }
 
 static TypeInfo virtio_evdi_pci_info = {
@@ -461,30 +440,26 @@ static TypeInfo virtio_evdi_pci_info = {
 
 /* virtio-sensor-pci */
 
-static int virtio_sensor_pci_init(VirtIOPCIProxy *vpci_dev)
+static Property virtio_sensor_pci_properties[] = {
+    DEFINE_PROP_END_OF_LIST(),
+};
+
+static void virtio_sensor_pci_realize(VirtIOPCIProxy *vpci_dev, Error **errp)
 {
     VirtIOSENSORPCI *dev = VIRTIO_SENSOR_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;
+    object_property_set_bool(OBJECT(vdev), true, "realized", errp);
 }
 
-static Property virtio_sensor_pci_properties[] = {
-    DEFINE_PROP_STRING(ATTRIBUTE_NAME_SENSORS, VirtIOSENSORPCI, vdev.sensors),
-    DEFINE_PROP_END_OF_LIST(),
-};
-
 static void virtio_sensor_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_sensor_pci_init;
+    k->realize = virtio_sensor_pci_realize;
     pcidev_k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
     pcidev_k->device_id = PCI_DEVICE_ID_VIRTIO_SENSOR;
     pcidev_k->revision = VIRTIO_PCI_ABI_VERSION;
@@ -495,8 +470,8 @@ static void virtio_sensor_pci_class_init(ObjectClass *klass, void *data)
 static void virtio_sensor_pci_instance_init(Object *obj)
 {
     VirtIOSENSORPCI *dev = VIRTIO_SENSOR_PCI(obj);
-    object_initialize(&dev->vdev, sizeof(dev->vdev), TYPE_VIRTIO_SENSOR);
-    object_property_add_child(obj, "virtio-backend", OBJECT(&dev->vdev), NULL);
+    virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
+                                TYPE_VIRTIO_SENSOR);
 }
 
 static TypeInfo virtio_sensor_pci_info = {
@@ -509,16 +484,13 @@ static TypeInfo virtio_sensor_pci_info = {
 
 /* virtio NFC */
 
-static int virtio_nfc_pci_init(VirtIOPCIProxy *vpci_dev)
+static void virtio_nfc_pci_realize(VirtIOPCIProxy *vpci_dev, Error **errp)
 {
     VirtIONFCPCI *dev = VIRTIO_NFC_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;
+    object_property_set_bool(OBJECT(vdev), true, "realized", errp);
 }
 
 static void virtio_nfc_pci_class_init(ObjectClass *klass, void *data)
@@ -526,7 +498,7 @@ static void virtio_nfc_pci_class_init(ObjectClass *klass, void *data)
     VirtioPCIClass *k = VIRTIO_PCI_CLASS(klass);
     PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass);
 
-    k->init = virtio_nfc_pci_init;
+    k->realize = virtio_nfc_pci_realize;
     pcidev_k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
     pcidev_k->device_id = PCI_DEVICE_ID_VIRTIO_NFC;
     pcidev_k->revision = VIRTIO_PCI_ABI_VERSION;
@@ -536,8 +508,8 @@ static void virtio_nfc_pci_class_init(ObjectClass *klass, void *data)
 static void virtio_nfc_pci_instance_init(Object *obj)
 {
     VirtIONFCPCI *dev = VIRTIO_NFC_PCI(obj);
-    object_initialize(&dev->vdev, sizeof(dev->vdev), TYPE_VIRTIO_NFC);
-    object_property_add_child(obj, "virtio-backend", OBJECT(&dev->vdev), NULL);
+    virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
+                                TYPE_VIRTIO_NFC);
 }
 
 static TypeInfo virtio_nfc_pci_info = {
@@ -550,30 +522,26 @@ static TypeInfo virtio_nfc_pci_info = {
 
 /* virtio-jack-pci */
 
-static int virtio_jack_pci_init(VirtIOPCIProxy *vpci_dev)
+static Property virtio_jack_pci_properties[] = {
+    DEFINE_PROP_END_OF_LIST(),
+};
+
+static void virtio_jack_pci_realize(VirtIOPCIProxy *vpci_dev, Error **errp)
 {
     VirtIOJACKPCI *dev = VIRTIO_JACK_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;
+    object_property_set_bool(OBJECT(vdev), true, "realized", errp);
 }
 
-static Property virtio_jack_pci_properties[] = {
-    DEFINE_PROP_STRING(ATTRIBUTE_NAME_JACKS, VirtIOJACKPCI, vdev.jacks),
-    DEFINE_PROP_END_OF_LIST(),
-};
-
 static void virtio_jack_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_jack_pci_init;
+    k->realize = virtio_jack_pci_realize;
     pcidev_k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
     pcidev_k->device_id = PCI_DEVICE_ID_VIRTIO_JACK;
     pcidev_k->revision = VIRTIO_PCI_ABI_VERSION;
@@ -584,8 +552,8 @@ static void virtio_jack_pci_class_init(ObjectClass *klass, void *data)
 static void virtio_jack_pci_instance_init(Object *obj)
 {
     VirtIOJACKPCI *dev = VIRTIO_JACK_PCI(obj);
-    object_initialize(&dev->vdev, sizeof(dev->vdev), TYPE_VIRTIO_JACK);
-    object_property_add_child(obj, "virtio-backend", OBJECT(&dev->vdev), NULL);
+    virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
+                                TYPE_VIRTIO_JACK);
 }
 
 static TypeInfo virtio_jack_pci_info = {
@@ -598,16 +566,13 @@ static TypeInfo virtio_jack_pci_info = {
 
 /* virtio-power-pci */
 
-static int virtio_power_pci_init(VirtIOPCIProxy *vpci_dev)
+static void virtio_power_pci_realize(VirtIOPCIProxy *vpci_dev, Error **errp)
 {
     VirtIOPOWERPCI *dev = VIRTIO_POWER_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;
+    object_property_set_bool(OBJECT(vdev), true, "realized", errp);
 }
 
 static void virtio_power_pci_class_init(ObjectClass *klass, void *data)
@@ -615,7 +580,7 @@ static void virtio_power_pci_class_init(ObjectClass *klass, void *data)
     VirtioPCIClass *k = VIRTIO_PCI_CLASS(klass);
     PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass);
 
-    k->init = virtio_power_pci_init;
+    k->realize = virtio_power_pci_realize;
     pcidev_k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
     pcidev_k->device_id = PCI_DEVICE_ID_VIRTIO_POWER;
     pcidev_k->revision = VIRTIO_PCI_ABI_VERSION;
@@ -625,8 +590,8 @@ static void virtio_power_pci_class_init(ObjectClass *klass, void *data)
 static void virtio_power_pci_instance_init(Object *obj)
 {
     VirtIOPOWERPCI *dev = VIRTIO_POWER_PCI(obj);
-    object_initialize(&dev->vdev, sizeof(dev->vdev), TYPE_VIRTIO_POWER);
-    object_property_add_child(obj, "virtio-backend", OBJECT(&dev->vdev), NULL);
+    virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
+                                TYPE_VIRTIO_POWER);
 }
 
 static TypeInfo virtio_power_pci_info = {
@@ -639,16 +604,13 @@ static TypeInfo virtio_power_pci_info = {
 
 /* virtio-vmodem-pci */
 
-static int virtio_vmodem_pci_init(VirtIOPCIProxy *vpci_dev)
+static void virtio_vmodem_pci_realize(VirtIOPCIProxy *vpci_dev, Error **errp)
 {
     VirtIOVModemPCI *dev = VIRTIO_VMODEM_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;
+    object_property_set_bool(OBJECT(vdev), true, "realized", errp);
 }
 
 static void virtio_vmodem_pci_class_init(ObjectClass *klass, void *data)
@@ -656,7 +618,7 @@ static void virtio_vmodem_pci_class_init(ObjectClass *klass, void *data)
     VirtioPCIClass *k = VIRTIO_PCI_CLASS(klass);
     PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass);
 
-    k->init = virtio_vmodem_pci_init;
+    k->realize = virtio_vmodem_pci_realize;
     pcidev_k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
     pcidev_k->device_id = PCI_DEVICE_ID_VIRTIO_VMODEM;
     pcidev_k->revision = VIRTIO_PCI_ABI_VERSION;
@@ -666,8 +628,8 @@ static void virtio_vmodem_pci_class_init(ObjectClass *klass, void *data)
 static void virtio_vmodem_pci_instance_init(Object *obj)
 {
     VirtIOVModemPCI *dev = VIRTIO_VMODEM_PCI(obj);
-    object_initialize(&dev->vdev, sizeof(dev->vdev), TYPE_VIRTIO_VMODEM);
-    object_property_add_child(obj, "virtio-backend", OBJECT(&dev->vdev), NULL);
+    virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
+                                TYPE_VIRTIO_VMODEM);
 }
 
 static TypeInfo virtio_vmodem_pci_info = {
@@ -680,16 +642,13 @@ static TypeInfo virtio_vmodem_pci_info = {
 
 /* virtio-rotary-pci */
 
-static int virtio_rotary_pci_init(VirtIOPCIProxy *vpci_dev)
+static void virtio_rotary_pci_realize(VirtIOPCIProxy *vpci_dev, Error **errp)
 {
     VirtIORotaryPCI *dev = VIRTIO_ROTARY_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;
+    object_property_set_bool(OBJECT(vdev), true, "realized", errp);
 }
 
 static void virtio_rotary_pci_class_init(ObjectClass *klass, void *data)
@@ -697,7 +656,7 @@ static void virtio_rotary_pci_class_init(ObjectClass *klass, void *data)
     VirtioPCIClass *k = VIRTIO_PCI_CLASS(klass);
     PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass);
 
-    k->init = virtio_rotary_pci_init;
+    k->realize = virtio_rotary_pci_realize;
     pcidev_k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
     pcidev_k->device_id = PCI_DEVICE_ID_VIRTIO_ROTARY;
     pcidev_k->revision = VIRTIO_PCI_ABI_VERSION;
@@ -707,8 +666,8 @@ static void virtio_rotary_pci_class_init(ObjectClass *klass, void *data)
 static void virtio_rotary_pci_instance_init(Object *obj)
 {
     VirtIORotaryPCI *dev = VIRTIO_ROTARY_PCI(obj);
-    object_initialize(&dev->vdev, sizeof(dev->vdev), TYPE_VIRTIO_ROTARY);
-    object_property_add_child(obj, "virtio-backend", OBJECT(&dev->vdev), NULL);
+    virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
+                                TYPE_VIRTIO_ROTARY);
 }
 
 static TypeInfo virtio_rotary_pci_info = {

diff --git a/tizen/src/hw/virtio/maru_virtio_power.c b/tizen/src/hw/virtio/maru_virtio_power.c
index 38dd4fd..ef1a16d 100644 (file)
--- a/tizen/src/hw/virtio/maru_virtio_power.c
+++ b/tizen/src/hw/virtio/maru_virtio_power.c
@@ -237,8 +237,8 @@ static void virtio_power_reset(VirtIODevice *vdev)
     TRACE("virtio_power_reset.\n");
 }
 
-static uint32_t virtio_power_get_features(VirtIODevice *vdev,
-                                            uint32_t request_feature)
+static uint64_t virtio_power_get_features(VirtIODevice *vdev,
+        uint64_t request_feature, Error **errp)
 {
     TRACE("virtio_power_get_features.\n");
     return 0;

diff --git a/tizen/src/hw/virtio/maru_virtio_rotary.c b/tizen/src/hw/virtio/maru_virtio_rotary.c
index ffd1858..713e875 100644 (file)
--- a/tizen/src/hw/virtio/maru_virtio_rotary.c
+++ b/tizen/src/hw/virtio/maru_virtio_rotary.c
@@ -145,8 +145,8 @@ static void virtio_rotary_bh(void *opaque)
     LOG_TRACE("[%s] LEAVE\n", __func__);
 }
 
-static uint32_t virtio_rotary_get_features(VirtIODevice *vdev,
-                                           uint32_t request_features)
+static uint64_t virtio_rotary_get_features(VirtIODevice *vdev,
+        uint64_t request_features, Error **errp)
 {
     return request_features;
 }

diff --git a/tizen/src/hw/virtio/maru_virtio_sensor.c b/tizen/src/hw/virtio/maru_virtio_sensor.c
index b362128..bb1f33a 100644 (file)
--- a/tizen/src/hw/virtio/maru_virtio_sensor.c
+++ b/tizen/src/hw/virtio/maru_virtio_sensor.c
@@ -691,7 +691,8 @@ static void virtio_sensor_realize(DeviceState *dev, Error **errp)
 
     if (vsensor == NULL) {
         LOG_SEVERE("failed to initialize sensor device\n");
-        error_set(errp, QERR_DEVICE_INIT_FAILED, SENSOR_DEVICE_NAME);
+        //error_set(errp, QERR_DEVICE_INIT_FAILED, SENSOR_DEVICE_NAME);
+        error_setg(errp, "Failed to initialize sensor device\n");
         return;
     }
 
@@ -738,8 +739,8 @@ static void virtio_sensor_reset(VirtIODevice *vdev)
     LOG_TRACE("virtio_sensor_reset.\n");
 }
 
-static uint32_t virtio_sensor_get_features(VirtIODevice *vdev,
-                                            uint32_t request_feature)
+static uint64_t virtio_sensor_get_features(VirtIODevice *vdev,
+        uint64_t request_feature, Error **errp)
 {
     LOG_TRACE("virtio_sensor_get_features.\n");
     return 0;

diff --git a/tizen/src/hw/virtio/maru_virtio_tablet.c b/tizen/src/hw/virtio/maru_virtio_tablet.c
index 9c1427f..6db6053 100644 (file)
--- a/tizen/src/hw/virtio/maru_virtio_tablet.c
+++ b/tizen/src/hw/virtio/maru_virtio_tablet.c
@@ -180,8 +180,8 @@ void maru_virtio_tablet_notify(void)
     }
 }
 
-static uint32_t virtio_tablet_get_features(
-    VirtIODevice *vdev, uint32_t request_features)
+static uint64_t virtio_tablet_get_features(
+        VirtIODevice *vdev, uint64_t request_features, Error **errp)
 {
     return request_features;
 }

diff --git a/tizen/src/hw/virtio/maru_virtio_touchscreen.c b/tizen/src/hw/virtio/maru_virtio_touchscreen.c
index 3d9b32b..dbc88c4 100644 (file)
--- a/tizen/src/hw/virtio/maru_virtio_touchscreen.c
+++ b/tizen/src/hw/virtio/maru_virtio_touchscreen.c
@@ -289,8 +289,8 @@ static void virtio_touchscreen_set_config(
     /* do nothing */
 }
 
-static uint32_t virtio_touchscreen_get_features(
-    VirtIODevice *vdev, uint32_t request_features)
+static uint64_t virtio_touchscreen_get_features(
+        VirtIODevice *vdev, uint64_t request_features, Error **errp)
 {
     /* do nothing */
 

diff --git a/tizen/src/hw/virtio/maru_virtio_vmodem.c b/tizen/src/hw/virtio/maru_virtio_vmodem.c
index 3e6bb10..d2c461a 100644 (file)
--- a/tizen/src/hw/virtio/maru_virtio_vmodem.c
+++ b/tizen/src/hw/virtio/maru_virtio_vmodem.c
@@ -168,8 +168,8 @@ static void virtio_vmodem_send(VirtIODevice *vdev, VirtQueue *vq)
     virtio_notify(&vio_vmodem->vdev, vq);
 }
 
-static uint32_t virtio_vmodem_get_features(VirtIODevice *vdev,
-                                            uint32_t request_feature)
+static uint64_t virtio_vmodem_get_features(VirtIODevice *vdev,
+        uint64_t request_feature, Error **errp)
 {
     LOG_TRACE("virtio_vmodem_get_features.\n");
     return 0;