hw/virtio/virtio-input-pci.c

   1 /*
   2  * Virtio input PCI Bindings
   3  *
   4  * This work is licensed under the terms of the GNU GPL, version 2 or
   5  * (at your option) any later version.  See the COPYING file in the
   6  * top-level directory.
   7  */
   8
   9 #include "qemu/osdep.h"
  10
  11 #include "virtio-pci.h"
  12 #include "hw/qdev-properties.h"
  13 #include "hw/virtio/virtio-input.h"
  14 #include "qemu/module.h"
  15 #include "qom/object.h"
  16
  17
  18 /*
  19  * virtio-input-pci: This extends VirtioPCIProxy.
  20  */
  21 OBJECT_DECLARE_SIMPLE_TYPE(VirtIOInputPCI, VIRTIO_INPUT_PCI)
  22
  23 struct VirtIOInputPCI {
  24     VirtIOPCIProxy parent_obj;
  25     VirtIOInput vdev;
  26 };
  27
  28 #define TYPE_VIRTIO_INPUT_HID_PCI "virtio-input-hid-pci"
  29 #define TYPE_VIRTIO_KEYBOARD_PCI  "virtio-keyboard-pci"
  30 #define TYPE_VIRTIO_MOUSE_PCI     "virtio-mouse-pci"
  31 #define TYPE_VIRTIO_TABLET_PCI    "virtio-tablet-pci"
  32 OBJECT_DECLARE_SIMPLE_TYPE(VirtIOInputHIDPCI, VIRTIO_INPUT_HID_PCI)
  33
  34 struct VirtIOInputHIDPCI {
  35     VirtIOPCIProxy parent_obj;
  36     VirtIOInputHID vdev;
  37 };
  38
  39 static Property virtio_input_pci_properties[] = {
  40     DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy, nvectors, 2),
  41     DEFINE_PROP_END_OF_LIST(),
  42 };
  43
  44 static void virtio_input_pci_realize(VirtIOPCIProxy *vpci_dev, Error **errp)
  45 {
  46     VirtIOInputPCI *vinput = VIRTIO_INPUT_PCI(vpci_dev);
  47     DeviceState *vdev = DEVICE(&vinput->vdev);
  48
  49     virtio_pci_force_virtio_1(vpci_dev);
  50     qdev_realize(vdev, BUS(&vpci_dev->bus), errp);
  51 }
  52
  53 static void virtio_input_pci_class_init(ObjectClass *klass, void *data)
  54 {
  55     DeviceClass *dc = DEVICE_CLASS(klass);
  56     VirtioPCIClass *k = VIRTIO_PCI_CLASS(klass);
  57     PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass);
  58
  59     device_class_set_props(dc, virtio_input_pci_properties);
  60     k->realize = virtio_input_pci_realize;
  61     set_bit(DEVICE_CATEGORY_INPUT, dc->categories);
  62
  63     pcidev_k->class_id = PCI_CLASS_INPUT_OTHER;
  64 }
  65
  66 static void virtio_input_hid_kbd_pci_class_init(ObjectClass *klass, void *data)
  67 {
  68     PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass);
  69
  70     pcidev_k->class_id = PCI_CLASS_INPUT_KEYBOARD;
  71 }
  72
  73 static void virtio_input_hid_mouse_pci_class_init(ObjectClass *klass,
  74                                                   void *data)
  75 {
  76     PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass);
  77
  78     pcidev_k->class_id = PCI_CLASS_INPUT_MOUSE;
  79 }
  80
  81 static void virtio_keyboard_initfn(Object *obj)
  82 {
  83     VirtIOInputHIDPCI *dev = VIRTIO_INPUT_HID_PCI(obj);
  84
  85     virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
  86                                 TYPE_VIRTIO_KEYBOARD);
  87 }
  88
  89 static void virtio_mouse_initfn(Object *obj)
  90 {
  91     VirtIOInputHIDPCI *dev = VIRTIO_INPUT_HID_PCI(obj);
  92
  93     virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
  94                                 TYPE_VIRTIO_MOUSE);
  95 }
  96
  97 static void virtio_tablet_initfn(Object *obj)
  98 {
  99     VirtIOInputHIDPCI *dev = VIRTIO_INPUT_HID_PCI(obj);
 100
 101     virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
 102                                 TYPE_VIRTIO_TABLET);
 103 }
 104
 105 static const TypeInfo virtio_input_pci_info = {
 106     .name          = TYPE_VIRTIO_INPUT_PCI,
 107     .parent        = TYPE_VIRTIO_PCI,
 108     .instance_size = sizeof(VirtIOInputPCI),
 109     .class_init    = virtio_input_pci_class_init,
 110     .abstract      = true,
 111 };
 112
 113 static const TypeInfo virtio_input_hid_pci_info = {
 114     .name          = TYPE_VIRTIO_INPUT_HID_PCI,
 115     .parent        = TYPE_VIRTIO_INPUT_PCI,
 116     .instance_size = sizeof(VirtIOInputHIDPCI),
 117     .abstract      = true,
 118 };
 119
 120 static const VirtioPCIDeviceTypeInfo virtio_keyboard_pci_info = {
 121     .generic_name  = TYPE_VIRTIO_KEYBOARD_PCI,
 122     .parent        = TYPE_VIRTIO_INPUT_HID_PCI,
 123     .class_init    = virtio_input_hid_kbd_pci_class_init,
 124     .instance_size = sizeof(VirtIOInputHIDPCI),
 125     .instance_init = virtio_keyboard_initfn,
 126 };
 127
 128 static const VirtioPCIDeviceTypeInfo virtio_mouse_pci_info = {
 129     .generic_name  = TYPE_VIRTIO_MOUSE_PCI,
 130     .parent        = TYPE_VIRTIO_INPUT_HID_PCI,
 131     .class_init    = virtio_input_hid_mouse_pci_class_init,
 132     .instance_size = sizeof(VirtIOInputHIDPCI),
 133     .instance_init = virtio_mouse_initfn,
 134 };
 135
 136 static const VirtioPCIDeviceTypeInfo virtio_tablet_pci_info = {
 137     .generic_name  = TYPE_VIRTIO_TABLET_PCI,
 138     .parent        = TYPE_VIRTIO_INPUT_HID_PCI,
 139     .instance_size = sizeof(VirtIOInputHIDPCI),
 140     .instance_init = virtio_tablet_initfn,
 141 };
 142
 143 static void virtio_pci_input_register(void)
 144 {
 145     /* Base types: */
 146     type_register_static(&virtio_input_pci_info);
 147     type_register_static(&virtio_input_hid_pci_info);
 148
 149     /* Implementations: */
 150     virtio_pci_types_register(&virtio_keyboard_pci_info);
 151     virtio_pci_types_register(&virtio_mouse_pci_info);
 152     virtio_pci_types_register(&virtio_tablet_pci_info);
 153 }
 154
 155 type_init(virtio_pci_input_register)