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