1 /* 2 * This work is licensed under the terms of the GNU GPL, version 2 or 3 * (at your option) any later version. See the COPYING file in the 4 * top-level directory. 5 */ 6 7 #include "qemu/osdep.h" 8 #include "qapi/error.h" 9 #include "qemu/module.h" 10 #include "qemu/sockets.h" 11 12 #include "hw/virtio/virtio.h" 13 #include "hw/qdev-properties.h" 14 #include "hw/virtio/virtio-input.h" 15 16 #include <sys/ioctl.h> 17 #include "standard-headers/linux/input.h" 18 19 /* ----------------------------------------------------------------- */ 20 21 static struct virtio_input_config virtio_input_host_config[] = { 22 { /* empty list */ }, 23 }; 24 25 static void virtio_input_host_event(void *opaque) 26 { 27 VirtIOInputHost *vih = opaque; 28 VirtIOInput *vinput = VIRTIO_INPUT(vih); 29 struct virtio_input_event virtio; 30 struct input_event evdev; 31 int rc; 32 33 for (;;) { 34 rc = read(vih->fd, &evdev, sizeof(evdev)); 35 if (rc != sizeof(evdev)) { 36 break; 37 } 38 39 virtio.type = cpu_to_le16(evdev.type); 40 virtio.code = cpu_to_le16(evdev.code); 41 virtio.value = cpu_to_le32(evdev.value); 42 virtio_input_send(vinput, &virtio); 43 } 44 } 45 46 static void virtio_input_bits_config(VirtIOInputHost *vih, 47 int type, int count) 48 { 49 virtio_input_config bits; 50 int rc, i, size = 0; 51 52 memset(&bits, 0, sizeof(bits)); 53 rc = ioctl(vih->fd, EVIOCGBIT(type, count/8), bits.u.bitmap); 54 if (rc < 0) { 55 return; 56 } 57 58 for (i = 0; i < count/8; i++) { 59 if (bits.u.bitmap[i]) { 60 size = i+1; 61 } 62 } 63 if (size == 0) { 64 return; 65 } 66 67 bits.select = VIRTIO_INPUT_CFG_EV_BITS; 68 bits.subsel = type; 69 bits.size = size; 70 virtio_input_add_config(VIRTIO_INPUT(vih), &bits); 71 } 72 73 static void virtio_input_abs_config(VirtIOInputHost *vih, int axis) 74 { 75 virtio_input_config config; 76 struct input_absinfo absinfo; 77 int rc; 78 79 rc = ioctl(vih->fd, EVIOCGABS(axis), &absinfo); 80 if (rc < 0) { 81 return; 82 } 83 84 memset(&config, 0, sizeof(config)); 85 config.select = VIRTIO_INPUT_CFG_ABS_INFO; 86 config.subsel = axis; 87 config.size = sizeof(virtio_input_absinfo); 88 89 config.u.abs.min = cpu_to_le32(absinfo.minimum); 90 config.u.abs.max = cpu_to_le32(absinfo.maximum); 91 config.u.abs.fuzz = cpu_to_le32(absinfo.fuzz); 92 config.u.abs.flat = cpu_to_le32(absinfo.flat); 93 config.u.abs.res = cpu_to_le32(absinfo.resolution); 94 95 virtio_input_add_config(VIRTIO_INPUT(vih), &config); 96 } 97 98 static void virtio_input_host_realize(DeviceState *dev, Error **errp) 99 { 100 VirtIOInputHost *vih = VIRTIO_INPUT_HOST(dev); 101 VirtIOInput *vinput = VIRTIO_INPUT(dev); 102 virtio_input_config id, *abs; 103 struct input_id ids; 104 int rc, ver, i, axis; 105 uint8_t byte; 106 107 if (!vih->evdev) { 108 error_setg(errp, "evdev property is required"); 109 return; 110 } 111 112 vih->fd = open(vih->evdev, O_RDWR); 113 if (vih->fd < 0) { 114 error_setg_file_open(errp, errno, vih->evdev); 115 return; 116 } 117 qemu_set_nonblock(vih->fd); 118 119 rc = ioctl(vih->fd, EVIOCGVERSION, &ver); 120 if (rc < 0) { 121 error_setg(errp, "%s: is not an evdev device", vih->evdev); 122 goto err_close; 123 } 124 125 rc = ioctl(vih->fd, EVIOCGRAB, 1); 126 if (rc < 0) { 127 error_setg_errno(errp, errno, "%s: failed to get exclusive access", 128 vih->evdev); 129 goto err_close; 130 } 131 132 memset(&id, 0, sizeof(id)); 133 ioctl(vih->fd, EVIOCGNAME(sizeof(id.u.string)-1), id.u.string); 134 id.select = VIRTIO_INPUT_CFG_ID_NAME; 135 id.size = strlen(id.u.string); 136 virtio_input_add_config(vinput, &id); 137 138 if (ioctl(vih->fd, EVIOCGID, &ids) == 0) { 139 memset(&id, 0, sizeof(id)); 140 id.select = VIRTIO_INPUT_CFG_ID_DEVIDS; 141 id.size = sizeof(struct virtio_input_devids); 142 id.u.ids.bustype = cpu_to_le16(ids.bustype); 143 id.u.ids.vendor = cpu_to_le16(ids.vendor); 144 id.u.ids.product = cpu_to_le16(ids.product); 145 id.u.ids.version = cpu_to_le16(ids.version); 146 virtio_input_add_config(vinput, &id); 147 } 148 149 virtio_input_bits_config(vih, EV_KEY, KEY_CNT); 150 virtio_input_bits_config(vih, EV_REL, REL_CNT); 151 virtio_input_bits_config(vih, EV_ABS, ABS_CNT); 152 virtio_input_bits_config(vih, EV_MSC, MSC_CNT); 153 virtio_input_bits_config(vih, EV_SW, SW_CNT); 154 virtio_input_bits_config(vih, EV_LED, LED_CNT); 155 156 abs = virtio_input_find_config(VIRTIO_INPUT(vih), 157 VIRTIO_INPUT_CFG_EV_BITS, EV_ABS); 158 if (abs) { 159 for (i = 0; i < abs->size; i++) { 160 byte = abs->u.bitmap[i]; 161 axis = 8 * i; 162 while (byte) { 163 if (byte & 1) { 164 virtio_input_abs_config(vih, axis); 165 } 166 axis++; 167 byte >>= 1; 168 } 169 } 170 } 171 172 qemu_set_fd_handler(vih->fd, virtio_input_host_event, NULL, vih); 173 return; 174 175 err_close: 176 close(vih->fd); 177 vih->fd = -1; 178 return; 179 } 180 181 static void virtio_input_host_unrealize(DeviceState *dev, Error **errp) 182 { 183 VirtIOInputHost *vih = VIRTIO_INPUT_HOST(dev); 184 185 if (vih->fd > 0) { 186 qemu_set_fd_handler(vih->fd, NULL, NULL, NULL); 187 close(vih->fd); 188 } 189 } 190 191 static void virtio_input_host_handle_status(VirtIOInput *vinput, 192 virtio_input_event *event) 193 { 194 VirtIOInputHost *vih = VIRTIO_INPUT_HOST(vinput); 195 struct input_event evdev; 196 int rc; 197 198 if (gettimeofday(&evdev.time, NULL)) { 199 perror("virtio_input_host_handle_status: gettimeofday"); 200 return; 201 } 202 203 evdev.type = le16_to_cpu(event->type); 204 evdev.code = le16_to_cpu(event->code); 205 evdev.value = le32_to_cpu(event->value); 206 207 rc = write(vih->fd, &evdev, sizeof(evdev)); 208 if (rc == -1) { 209 perror("virtio_input_host_handle_status: write"); 210 } 211 } 212 213 static const VMStateDescription vmstate_virtio_input_host = { 214 .name = "virtio-input-host", 215 .unmigratable = 1, 216 }; 217 218 static Property virtio_input_host_properties[] = { 219 DEFINE_PROP_STRING("evdev", VirtIOInputHost, evdev), 220 DEFINE_PROP_END_OF_LIST(), 221 }; 222 223 static void virtio_input_host_class_init(ObjectClass *klass, void *data) 224 { 225 VirtIOInputClass *vic = VIRTIO_INPUT_CLASS(klass); 226 DeviceClass *dc = DEVICE_CLASS(klass); 227 228 dc->vmsd = &vmstate_virtio_input_host; 229 dc->props = virtio_input_host_properties; 230 vic->realize = virtio_input_host_realize; 231 vic->unrealize = virtio_input_host_unrealize; 232 vic->handle_status = virtio_input_host_handle_status; 233 } 234 235 static void virtio_input_host_init(Object *obj) 236 { 237 VirtIOInput *vinput = VIRTIO_INPUT(obj); 238 239 virtio_input_init_config(vinput, virtio_input_host_config); 240 } 241 242 static const TypeInfo virtio_input_host_info = { 243 .name = TYPE_VIRTIO_INPUT_HOST, 244 .parent = TYPE_VIRTIO_INPUT, 245 .instance_size = sizeof(VirtIOInputHost), 246 .instance_init = virtio_input_host_init, 247 .class_init = virtio_input_host_class_init, 248 }; 249 250 /* ----------------------------------------------------------------- */ 251 252 static void virtio_register_types(void) 253 { 254 type_register_static(&virtio_input_host_info); 255 } 256 257 type_init(virtio_register_types) 258