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