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