From 70af20826f2dbb4117838362aafab829ed14e80b Mon Sep 17 00:00:00 2001 From: Kitae Kim Date: Tue, 9 Jul 2013 16:09:18 +0900 Subject: [PATCH] virtio-pci: merged virtio-pci module and others. Change-Id: I11b764cd55316377cffd96a6ea77d5590d43b3d6 Signed-off-by: Kitae Kim --- hw/virtio/virtio-pci.c | 273 ++++++++++++++++++++++++++++++++- hw/virtio/virtio-pci.h | 101 ++++++++++++ tizen/src/hw/maru_virtio_esm.c | 12 +- tizen/src/hw/maru_virtio_esm.h | 12 +- tizen/src/hw/maru_virtio_evdi.c | 19 +-- tizen/src/hw/maru_virtio_evdi.h | 15 +- tizen/src/hw/maru_virtio_hwkey.h | 15 +- tizen/src/hw/maru_virtio_keyboard.h | 2 +- tizen/src/hw/maru_virtio_touchscreen.h | 9 +- 9 files changed, 432 insertions(+), 26 deletions(-) diff --git a/hw/virtio/virtio-pci.c b/hw/virtio/virtio-pci.c index 161ade3..2d70f36 100644 --- 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 --- 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 --- 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 --- 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 --- 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; }; -typedef struct VirtIO_EVDI{ +#if 0 +typedef struct VirtIOEVDI{ VirtIODevice vdev; VirtQueue *rvq; VirtQueue *svq; DeviceState *qdev; QEMUBH *bh; -} VirtIO_EVDI; +} VirtIOEVDI; +#endif - -VirtIO_EVDI* vio_evdi; +VirtIOEVDI* vio_evdi; static int g_cnt = 0; @@ -100,7 +101,7 @@ static void virtio_evdi_recv(VirtIODevice *vdev, VirtQueue *vq) _msg.use, _msg.buf, elem.in_sg[0].iov_len); - virtqueue_push(vq, &elem, sizeof(VirtIO_EVDI)); + virtqueue_push(vq, &elem, sizeof(VirtIOEVDI)); virtio_notify(&vio_evdi->vdev, vq); } } @@ -111,7 +112,7 @@ static void virtio_evdi_recv(VirtIODevice *vdev, VirtQueue *vq) static void virtio_evdi_send(VirtIODevice *vdev, VirtQueue *vq) { - VirtIO_EVDI *vevdi = (VirtIO_EVDI *)vdev; + VirtIOEVDI *vevdi = (VirtIOEVDI *)vdev; int index = 0; struct msg_info _msg; @@ -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); } - virtqueue_push(vq, &elem, sizeof(VirtIO_EVDI)); + virtqueue_push(vq, &elem, sizeof(VirtIOEVDI)); virtio_notify(&vio_evdi->vdev, vq); } @@ -166,8 +167,8 @@ VirtIODevice *virtio_evdi_init(DeviceState *dev) { INFO("initialize evdi device\n"); - vio_evdi = (VirtIO_EVDI *)virtio_common_init(VIRTIO_EVDI_DEVICE_NAME, - VIRTIO_ID_EVDI, 0, sizeof(VirtIO_EVDI)); + vio_evdi = (VirtIOEVDI *)virtio_common_init(VIRTIO_EVDI_DEVICE_NAME, + VIRTIO_ID_EVDI, 0, sizeof(VirtIOEVDI)); if (vio_evdi == NULL) { ERR("failed to initialize evdi device\n"); return NULL; diff --git a/tizen/src/hw/maru_virtio_evdi.h b/tizen/src/hw/maru_virtio_evdi.h index ad88b68..25d8f5f 100644 --- a/tizen/src/hw/maru_virtio_evdi.h +++ b/tizen/src/hw/maru_virtio_evdi.h @@ -12,7 +12,20 @@ extern "C" { #endif -#include "hw/virtio.h" +#include "hw/virtio/virtio.h" + +#define TYPE_VIRTIO_EVDI "virtio-evdi-device" +#define VIRTIO_EVDI(obj) \ + OBJECT_CHECK(VirtIOEVDI, (obj), TYPE_VIRTIO_EVDI) + +typedef struct VirtIOEVDI { + VirtIODevice vdev; + VirtQueue *rvq; + VirtQueue *svq; + DeviceState *qdev; + + QEMUBH *bh; +} VirtIOEVDI; VirtIODevice *virtio_evdi_init(DeviceState *dev); diff --git a/tizen/src/hw/maru_virtio_hwkey.h b/tizen/src/hw/maru_virtio_hwkey.h index 6ce3e98..9e48da8 100644 --- 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 --- 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 --- 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 { -- 2.7.4