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 if (!g_unix_set_fd_nonblocking(vih->fd, true, NULL)) { 118 error_setg_errno(errp, errno, "Failed to set FD nonblocking"); 119 goto err_close; 120 } 121 122 rc = ioctl(vih->fd, EVIOCGVERSION, &ver); 123 if (rc < 0) { 124 error_setg(errp, "%s: is not an evdev device", vih->evdev); 125 goto err_close; 126 } 127 128 rc = ioctl(vih->fd, EVIOCGRAB, 1); 129 if (rc < 0) { 130 error_setg_errno(errp, errno, "%s: failed to get exclusive access", 131 vih->evdev); 132 goto err_close; 133 } 134 135 memset(&id, 0, sizeof(id)); 136 ioctl(vih->fd, EVIOCGNAME(sizeof(id.u.string)-1), id.u.string); 137 id.select = VIRTIO_INPUT_CFG_ID_NAME; 138 id.size = strlen(id.u.string); 139 virtio_input_add_config(vinput, &id); 140 141 if (ioctl(vih->fd, EVIOCGID, &ids) == 0) { 142 memset(&id, 0, sizeof(id)); 143 id.select = VIRTIO_INPUT_CFG_ID_DEVIDS; 144 id.size = sizeof(struct virtio_input_devids); 145 id.u.ids.bustype = cpu_to_le16(ids.bustype); 146 id.u.ids.vendor = cpu_to_le16(ids.vendor); 147 id.u.ids.product = cpu_to_le16(ids.product); 148 id.u.ids.version = cpu_to_le16(ids.version); 149 virtio_input_add_config(vinput, &id); 150 } 151 152 virtio_input_bits_config(vih, EV_KEY, KEY_CNT); 153 virtio_input_bits_config(vih, EV_REL, REL_CNT); 154 virtio_input_bits_config(vih, EV_ABS, ABS_CNT); 155 virtio_input_bits_config(vih, EV_MSC, MSC_CNT); 156 virtio_input_bits_config(vih, EV_SW, SW_CNT); 157 virtio_input_bits_config(vih, EV_LED, LED_CNT); 158 159 abs = virtio_input_find_config(VIRTIO_INPUT(vih), 160 VIRTIO_INPUT_CFG_EV_BITS, EV_ABS); 161 if (abs) { 162 for (i = 0; i < abs->size; i++) { 163 byte = abs->u.bitmap[i]; 164 axis = 8 * i; 165 while (byte) { 166 if (byte & 1) { 167 virtio_input_abs_config(vih, axis); 168 } 169 axis++; 170 byte >>= 1; 171 } 172 } 173 } 174 175 qemu_set_fd_handler(vih->fd, virtio_input_host_event, NULL, vih); 176 return; 177 178 err_close: 179 close(vih->fd); 180 vih->fd = -1; 181 return; 182 } 183 184 static void virtio_input_host_unrealize(DeviceState *dev) 185 { 186 VirtIOInputHost *vih = VIRTIO_INPUT_HOST(dev); 187 188 if (vih->fd > 0) { 189 qemu_set_fd_handler(vih->fd, NULL, NULL, NULL); 190 close(vih->fd); 191 } 192 } 193 194 static void virtio_input_host_handle_status(VirtIOInput *vinput, 195 virtio_input_event *event) 196 { 197 VirtIOInputHost *vih = VIRTIO_INPUT_HOST(vinput); 198 struct input_event evdev; 199 struct timeval tval; 200 int rc; 201 202 if (gettimeofday(&tval, NULL)) { 203 perror("virtio_input_host_handle_status: gettimeofday"); 204 return; 205 } 206 207 evdev.input_event_sec = tval.tv_sec; 208 evdev.input_event_usec = tval.tv_usec; 209 evdev.type = le16_to_cpu(event->type); 210 evdev.code = le16_to_cpu(event->code); 211 evdev.value = le32_to_cpu(event->value); 212 213 rc = write(vih->fd, &evdev, sizeof(evdev)); 214 if (rc == -1) { 215 perror("virtio_input_host_handle_status: write"); 216 } 217 } 218 219 static const VMStateDescription vmstate_virtio_input_host = { 220 .name = "virtio-input-host", 221 .unmigratable = 1, 222 }; 223 224 static Property virtio_input_host_properties[] = { 225 DEFINE_PROP_STRING("evdev", VirtIOInputHost, evdev), 226 DEFINE_PROP_END_OF_LIST(), 227 }; 228 229 static void virtio_input_host_class_init(ObjectClass *klass, void *data) 230 { 231 VirtIOInputClass *vic = VIRTIO_INPUT_CLASS(klass); 232 DeviceClass *dc = DEVICE_CLASS(klass); 233 234 dc->vmsd = &vmstate_virtio_input_host; 235 device_class_set_props(dc, virtio_input_host_properties); 236 vic->realize = virtio_input_host_realize; 237 vic->unrealize = virtio_input_host_unrealize; 238 vic->handle_status = virtio_input_host_handle_status; 239 } 240 241 static void virtio_input_host_init(Object *obj) 242 { 243 VirtIOInput *vinput = VIRTIO_INPUT(obj); 244 245 virtio_input_init_config(vinput, virtio_input_host_config); 246 } 247 248 static const TypeInfo virtio_input_host_info = { 249 .name = TYPE_VIRTIO_INPUT_HOST, 250 .parent = TYPE_VIRTIO_INPUT, 251 .instance_size = sizeof(VirtIOInputHost), 252 .instance_init = virtio_input_host_init, 253 .class_init = virtio_input_host_class_init, 254 }; 255 256 /* ----------------------------------------------------------------- */ 257 258 static void virtio_register_types(void) 259 { 260 type_register_static(&virtio_input_host_info); 261 } 262 263 type_init(virtio_register_types) 264