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 "qemu/iov.h" 9 10 #include "hw/qdev.h" 11 #include "hw/virtio/virtio.h" 12 #include "hw/virtio/virtio-input.h" 13 14 #undef CONFIG_CURSES 15 #include "ui/console.h" 16 17 #include "standard-headers/linux/input.h" 18 19 #define VIRTIO_ID_NAME_KEYBOARD "QEMU Virtio Keyboard" 20 #define VIRTIO_ID_NAME_MOUSE "QEMU Virtio Mouse" 21 #define VIRTIO_ID_NAME_TABLET "QEMU Virtio Tablet" 22 23 /* ----------------------------------------------------------------- */ 24 25 static const unsigned int keymap_qcode[Q_KEY_CODE__MAX] = { 26 [Q_KEY_CODE_ESC] = KEY_ESC, 27 [Q_KEY_CODE_1] = KEY_1, 28 [Q_KEY_CODE_2] = KEY_2, 29 [Q_KEY_CODE_3] = KEY_3, 30 [Q_KEY_CODE_4] = KEY_4, 31 [Q_KEY_CODE_5] = KEY_5, 32 [Q_KEY_CODE_6] = KEY_6, 33 [Q_KEY_CODE_7] = KEY_7, 34 [Q_KEY_CODE_8] = KEY_8, 35 [Q_KEY_CODE_9] = KEY_9, 36 [Q_KEY_CODE_0] = KEY_0, 37 [Q_KEY_CODE_MINUS] = KEY_MINUS, 38 [Q_KEY_CODE_EQUAL] = KEY_EQUAL, 39 [Q_KEY_CODE_BACKSPACE] = KEY_BACKSPACE, 40 41 [Q_KEY_CODE_TAB] = KEY_TAB, 42 [Q_KEY_CODE_Q] = KEY_Q, 43 [Q_KEY_CODE_W] = KEY_W, 44 [Q_KEY_CODE_E] = KEY_E, 45 [Q_KEY_CODE_R] = KEY_R, 46 [Q_KEY_CODE_T] = KEY_T, 47 [Q_KEY_CODE_Y] = KEY_Y, 48 [Q_KEY_CODE_U] = KEY_U, 49 [Q_KEY_CODE_I] = KEY_I, 50 [Q_KEY_CODE_O] = KEY_O, 51 [Q_KEY_CODE_P] = KEY_P, 52 [Q_KEY_CODE_BRACKET_LEFT] = KEY_LEFTBRACE, 53 [Q_KEY_CODE_BRACKET_RIGHT] = KEY_RIGHTBRACE, 54 [Q_KEY_CODE_RET] = KEY_ENTER, 55 56 [Q_KEY_CODE_CTRL] = KEY_LEFTCTRL, 57 [Q_KEY_CODE_A] = KEY_A, 58 [Q_KEY_CODE_S] = KEY_S, 59 [Q_KEY_CODE_D] = KEY_D, 60 [Q_KEY_CODE_F] = KEY_F, 61 [Q_KEY_CODE_G] = KEY_G, 62 [Q_KEY_CODE_H] = KEY_H, 63 [Q_KEY_CODE_J] = KEY_J, 64 [Q_KEY_CODE_K] = KEY_K, 65 [Q_KEY_CODE_L] = KEY_L, 66 [Q_KEY_CODE_SEMICOLON] = KEY_SEMICOLON, 67 [Q_KEY_CODE_APOSTROPHE] = KEY_APOSTROPHE, 68 [Q_KEY_CODE_GRAVE_ACCENT] = KEY_GRAVE, 69 70 [Q_KEY_CODE_SHIFT] = KEY_LEFTSHIFT, 71 [Q_KEY_CODE_BACKSLASH] = KEY_BACKSLASH, 72 [Q_KEY_CODE_LESS] = KEY_102ND, 73 [Q_KEY_CODE_Z] = KEY_Z, 74 [Q_KEY_CODE_X] = KEY_X, 75 [Q_KEY_CODE_C] = KEY_C, 76 [Q_KEY_CODE_V] = KEY_V, 77 [Q_KEY_CODE_B] = KEY_B, 78 [Q_KEY_CODE_N] = KEY_N, 79 [Q_KEY_CODE_M] = KEY_M, 80 [Q_KEY_CODE_COMMA] = KEY_COMMA, 81 [Q_KEY_CODE_DOT] = KEY_DOT, 82 [Q_KEY_CODE_SLASH] = KEY_SLASH, 83 [Q_KEY_CODE_SHIFT_R] = KEY_RIGHTSHIFT, 84 85 [Q_KEY_CODE_ALT] = KEY_LEFTALT, 86 [Q_KEY_CODE_SPC] = KEY_SPACE, 87 [Q_KEY_CODE_CAPS_LOCK] = KEY_CAPSLOCK, 88 89 [Q_KEY_CODE_F1] = KEY_F1, 90 [Q_KEY_CODE_F2] = KEY_F2, 91 [Q_KEY_CODE_F3] = KEY_F3, 92 [Q_KEY_CODE_F4] = KEY_F4, 93 [Q_KEY_CODE_F5] = KEY_F5, 94 [Q_KEY_CODE_F6] = KEY_F6, 95 [Q_KEY_CODE_F7] = KEY_F7, 96 [Q_KEY_CODE_F8] = KEY_F8, 97 [Q_KEY_CODE_F9] = KEY_F9, 98 [Q_KEY_CODE_F10] = KEY_F10, 99 [Q_KEY_CODE_NUM_LOCK] = KEY_NUMLOCK, 100 [Q_KEY_CODE_SCROLL_LOCK] = KEY_SCROLLLOCK, 101 102 [Q_KEY_CODE_KP_0] = KEY_KP0, 103 [Q_KEY_CODE_KP_1] = KEY_KP1, 104 [Q_KEY_CODE_KP_2] = KEY_KP2, 105 [Q_KEY_CODE_KP_3] = KEY_KP3, 106 [Q_KEY_CODE_KP_4] = KEY_KP4, 107 [Q_KEY_CODE_KP_5] = KEY_KP5, 108 [Q_KEY_CODE_KP_6] = KEY_KP6, 109 [Q_KEY_CODE_KP_7] = KEY_KP7, 110 [Q_KEY_CODE_KP_8] = KEY_KP8, 111 [Q_KEY_CODE_KP_9] = KEY_KP9, 112 [Q_KEY_CODE_KP_SUBTRACT] = KEY_KPMINUS, 113 [Q_KEY_CODE_KP_ADD] = KEY_KPPLUS, 114 [Q_KEY_CODE_KP_DECIMAL] = KEY_KPDOT, 115 [Q_KEY_CODE_KP_ENTER] = KEY_KPENTER, 116 [Q_KEY_CODE_KP_DIVIDE] = KEY_KPSLASH, 117 [Q_KEY_CODE_KP_MULTIPLY] = KEY_KPASTERISK, 118 119 [Q_KEY_CODE_F11] = KEY_F11, 120 [Q_KEY_CODE_F12] = KEY_F12, 121 122 [Q_KEY_CODE_CTRL_R] = KEY_RIGHTCTRL, 123 [Q_KEY_CODE_SYSRQ] = KEY_SYSRQ, 124 [Q_KEY_CODE_PRINT] = KEY_SYSRQ, 125 [Q_KEY_CODE_PAUSE] = KEY_PAUSE, 126 [Q_KEY_CODE_ALT_R] = KEY_RIGHTALT, 127 128 [Q_KEY_CODE_HOME] = KEY_HOME, 129 [Q_KEY_CODE_UP] = KEY_UP, 130 [Q_KEY_CODE_PGUP] = KEY_PAGEUP, 131 [Q_KEY_CODE_LEFT] = KEY_LEFT, 132 [Q_KEY_CODE_RIGHT] = KEY_RIGHT, 133 [Q_KEY_CODE_END] = KEY_END, 134 [Q_KEY_CODE_DOWN] = KEY_DOWN, 135 [Q_KEY_CODE_PGDN] = KEY_PAGEDOWN, 136 [Q_KEY_CODE_INSERT] = KEY_INSERT, 137 [Q_KEY_CODE_DELETE] = KEY_DELETE, 138 139 [Q_KEY_CODE_META_L] = KEY_LEFTMETA, 140 [Q_KEY_CODE_META_R] = KEY_RIGHTMETA, 141 [Q_KEY_CODE_MENU] = KEY_MENU, 142 }; 143 144 static const unsigned int keymap_button[INPUT_BUTTON__MAX] = { 145 [INPUT_BUTTON_LEFT] = BTN_LEFT, 146 [INPUT_BUTTON_RIGHT] = BTN_RIGHT, 147 [INPUT_BUTTON_MIDDLE] = BTN_MIDDLE, 148 [INPUT_BUTTON_WHEEL_UP] = BTN_GEAR_UP, 149 [INPUT_BUTTON_WHEEL_DOWN] = BTN_GEAR_DOWN, 150 }; 151 152 static const unsigned int axismap_rel[INPUT_AXIS__MAX] = { 153 [INPUT_AXIS_X] = REL_X, 154 [INPUT_AXIS_Y] = REL_Y, 155 }; 156 157 static const unsigned int axismap_abs[INPUT_AXIS__MAX] = { 158 [INPUT_AXIS_X] = ABS_X, 159 [INPUT_AXIS_Y] = ABS_Y, 160 }; 161 162 /* ----------------------------------------------------------------- */ 163 164 static void virtio_input_key_config(VirtIOInput *vinput, 165 const unsigned int *keymap, 166 size_t mapsize) 167 { 168 virtio_input_config keys; 169 int i, bit, byte, bmax = 0; 170 171 memset(&keys, 0, sizeof(keys)); 172 for (i = 0; i < mapsize; i++) { 173 bit = keymap[i]; 174 if (!bit) { 175 continue; 176 } 177 byte = bit / 8; 178 bit = bit % 8; 179 keys.u.bitmap[byte] |= (1 << bit); 180 if (bmax < byte+1) { 181 bmax = byte+1; 182 } 183 } 184 keys.select = VIRTIO_INPUT_CFG_EV_BITS; 185 keys.subsel = EV_KEY; 186 keys.size = bmax; 187 virtio_input_add_config(vinput, &keys); 188 } 189 190 static void virtio_input_handle_event(DeviceState *dev, QemuConsole *src, 191 InputEvent *evt) 192 { 193 VirtIOInput *vinput = VIRTIO_INPUT(dev); 194 virtio_input_event event; 195 int qcode; 196 InputKeyEvent *key; 197 InputMoveEvent *move; 198 InputBtnEvent *btn; 199 200 switch (evt->type) { 201 case INPUT_EVENT_KIND_KEY: 202 key = evt->u.key.data; 203 qcode = qemu_input_key_value_to_qcode(key->key); 204 if (qcode && keymap_qcode[qcode]) { 205 event.type = cpu_to_le16(EV_KEY); 206 event.code = cpu_to_le16(keymap_qcode[qcode]); 207 event.value = cpu_to_le32(key->down ? 1 : 0); 208 virtio_input_send(vinput, &event); 209 } else { 210 if (key->down) { 211 fprintf(stderr, "%s: unmapped key: %d [%s]\n", __func__, 212 qcode, QKeyCode_lookup[qcode]); 213 } 214 } 215 break; 216 case INPUT_EVENT_KIND_BTN: 217 btn = evt->u.btn.data; 218 if (keymap_button[btn->button]) { 219 event.type = cpu_to_le16(EV_KEY); 220 event.code = cpu_to_le16(keymap_button[btn->button]); 221 event.value = cpu_to_le32(btn->down ? 1 : 0); 222 virtio_input_send(vinput, &event); 223 } else { 224 if (btn->down) { 225 fprintf(stderr, "%s: unmapped button: %d [%s]\n", __func__, 226 btn->button, 227 InputButton_lookup[btn->button]); 228 } 229 } 230 break; 231 case INPUT_EVENT_KIND_REL: 232 move = evt->u.rel.data; 233 event.type = cpu_to_le16(EV_REL); 234 event.code = cpu_to_le16(axismap_rel[move->axis]); 235 event.value = cpu_to_le32(move->value); 236 virtio_input_send(vinput, &event); 237 break; 238 case INPUT_EVENT_KIND_ABS: 239 move = evt->u.abs.data; 240 event.type = cpu_to_le16(EV_ABS); 241 event.code = cpu_to_le16(axismap_abs[move->axis]); 242 event.value = cpu_to_le32(move->value); 243 virtio_input_send(vinput, &event); 244 break; 245 default: 246 /* keep gcc happy */ 247 break; 248 } 249 } 250 251 static void virtio_input_handle_sync(DeviceState *dev) 252 { 253 VirtIOInput *vinput = VIRTIO_INPUT(dev); 254 virtio_input_event event = { 255 .type = cpu_to_le16(EV_SYN), 256 .code = cpu_to_le16(SYN_REPORT), 257 .value = 0, 258 }; 259 260 virtio_input_send(vinput, &event); 261 } 262 263 static void virtio_input_hid_realize(DeviceState *dev, Error **errp) 264 { 265 VirtIOInputHID *vhid = VIRTIO_INPUT_HID(dev); 266 267 vhid->hs = qemu_input_handler_register(dev, vhid->handler); 268 if (vhid->display && vhid->hs) { 269 qemu_input_handler_bind(vhid->hs, vhid->display, vhid->head, NULL); 270 } 271 } 272 273 static void virtio_input_hid_unrealize(DeviceState *dev, Error **errp) 274 { 275 VirtIOInputHID *vhid = VIRTIO_INPUT_HID(dev); 276 qemu_input_handler_unregister(vhid->hs); 277 } 278 279 static void virtio_input_hid_change_active(VirtIOInput *vinput) 280 { 281 VirtIOInputHID *vhid = VIRTIO_INPUT_HID(vinput); 282 283 if (vinput->active) { 284 qemu_input_handler_activate(vhid->hs); 285 } else { 286 qemu_input_handler_deactivate(vhid->hs); 287 } 288 } 289 290 static void virtio_input_hid_handle_status(VirtIOInput *vinput, 291 virtio_input_event *event) 292 { 293 VirtIOInputHID *vhid = VIRTIO_INPUT_HID(vinput); 294 int ledbit = 0; 295 296 switch (le16_to_cpu(event->type)) { 297 case EV_LED: 298 if (event->code == LED_NUML) { 299 ledbit = QEMU_NUM_LOCK_LED; 300 } else if (event->code == LED_CAPSL) { 301 ledbit = QEMU_CAPS_LOCK_LED; 302 } else if (event->code == LED_SCROLLL) { 303 ledbit = QEMU_SCROLL_LOCK_LED; 304 } 305 if (event->value) { 306 vhid->ledstate |= ledbit; 307 } else { 308 vhid->ledstate &= ~ledbit; 309 } 310 kbd_put_ledstate(vhid->ledstate); 311 break; 312 default: 313 fprintf(stderr, "%s: unknown type %d\n", __func__, 314 le16_to_cpu(event->type)); 315 break; 316 } 317 } 318 319 static Property virtio_input_hid_properties[] = { 320 DEFINE_PROP_STRING("display", VirtIOInputHID, display), 321 DEFINE_PROP_UINT32("head", VirtIOInputHID, head, 0), 322 DEFINE_PROP_END_OF_LIST(), 323 }; 324 325 static void virtio_input_hid_class_init(ObjectClass *klass, void *data) 326 { 327 DeviceClass *dc = DEVICE_CLASS(klass); 328 VirtIOInputClass *vic = VIRTIO_INPUT_CLASS(klass); 329 330 dc->props = virtio_input_hid_properties; 331 vic->realize = virtio_input_hid_realize; 332 vic->unrealize = virtio_input_hid_unrealize; 333 vic->change_active = virtio_input_hid_change_active; 334 vic->handle_status = virtio_input_hid_handle_status; 335 } 336 337 static const TypeInfo virtio_input_hid_info = { 338 .name = TYPE_VIRTIO_INPUT_HID, 339 .parent = TYPE_VIRTIO_INPUT, 340 .instance_size = sizeof(VirtIOInputHID), 341 .class_init = virtio_input_hid_class_init, 342 .abstract = true, 343 }; 344 345 /* ----------------------------------------------------------------- */ 346 347 static QemuInputHandler virtio_keyboard_handler = { 348 .name = VIRTIO_ID_NAME_KEYBOARD, 349 .mask = INPUT_EVENT_MASK_KEY, 350 .event = virtio_input_handle_event, 351 .sync = virtio_input_handle_sync, 352 }; 353 354 static struct virtio_input_config virtio_keyboard_config[] = { 355 { 356 .select = VIRTIO_INPUT_CFG_ID_NAME, 357 .size = sizeof(VIRTIO_ID_NAME_KEYBOARD), 358 .u.string = VIRTIO_ID_NAME_KEYBOARD, 359 },{ 360 .select = VIRTIO_INPUT_CFG_ID_DEVIDS, 361 .size = sizeof(struct virtio_input_devids), 362 .u.ids = { 363 .bustype = const_le16(BUS_VIRTUAL), 364 .vendor = const_le16(0x0627), /* same we use for usb hid devices */ 365 .product = const_le16(0x0001), 366 .version = const_le16(0x0001), 367 }, 368 },{ 369 .select = VIRTIO_INPUT_CFG_EV_BITS, 370 .subsel = EV_REP, 371 .size = 1, 372 },{ 373 .select = VIRTIO_INPUT_CFG_EV_BITS, 374 .subsel = EV_LED, 375 .size = 1, 376 .u.bitmap = { 377 (1 << LED_NUML) | (1 << LED_CAPSL) | (1 << LED_SCROLLL), 378 }, 379 }, 380 { /* end of list */ }, 381 }; 382 383 static void virtio_keyboard_init(Object *obj) 384 { 385 VirtIOInputHID *vhid = VIRTIO_INPUT_HID(obj); 386 VirtIOInput *vinput = VIRTIO_INPUT(obj); 387 388 vhid->handler = &virtio_keyboard_handler; 389 virtio_input_init_config(vinput, virtio_keyboard_config); 390 virtio_input_key_config(vinput, keymap_qcode, 391 ARRAY_SIZE(keymap_qcode)); 392 } 393 394 static const TypeInfo virtio_keyboard_info = { 395 .name = TYPE_VIRTIO_KEYBOARD, 396 .parent = TYPE_VIRTIO_INPUT_HID, 397 .instance_size = sizeof(VirtIOInputHID), 398 .instance_init = virtio_keyboard_init, 399 }; 400 401 /* ----------------------------------------------------------------- */ 402 403 static QemuInputHandler virtio_mouse_handler = { 404 .name = VIRTIO_ID_NAME_MOUSE, 405 .mask = INPUT_EVENT_MASK_BTN | INPUT_EVENT_MASK_REL, 406 .event = virtio_input_handle_event, 407 .sync = virtio_input_handle_sync, 408 }; 409 410 static struct virtio_input_config virtio_mouse_config[] = { 411 { 412 .select = VIRTIO_INPUT_CFG_ID_NAME, 413 .size = sizeof(VIRTIO_ID_NAME_MOUSE), 414 .u.string = VIRTIO_ID_NAME_MOUSE, 415 },{ 416 .select = VIRTIO_INPUT_CFG_ID_DEVIDS, 417 .size = sizeof(struct virtio_input_devids), 418 .u.ids = { 419 .bustype = const_le16(BUS_VIRTUAL), 420 .vendor = const_le16(0x0627), /* same we use for usb hid devices */ 421 .product = const_le16(0x0002), 422 .version = const_le16(0x0001), 423 }, 424 },{ 425 .select = VIRTIO_INPUT_CFG_EV_BITS, 426 .subsel = EV_REL, 427 .size = 1, 428 .u.bitmap = { 429 (1 << REL_X) | (1 << REL_Y), 430 }, 431 }, 432 { /* end of list */ }, 433 }; 434 435 static void virtio_mouse_init(Object *obj) 436 { 437 VirtIOInputHID *vhid = VIRTIO_INPUT_HID(obj); 438 VirtIOInput *vinput = VIRTIO_INPUT(obj); 439 440 vhid->handler = &virtio_mouse_handler; 441 virtio_input_init_config(vinput, virtio_mouse_config); 442 virtio_input_key_config(vinput, keymap_button, 443 ARRAY_SIZE(keymap_button)); 444 } 445 446 static const TypeInfo virtio_mouse_info = { 447 .name = TYPE_VIRTIO_MOUSE, 448 .parent = TYPE_VIRTIO_INPUT_HID, 449 .instance_size = sizeof(VirtIOInputHID), 450 .instance_init = virtio_mouse_init, 451 }; 452 453 /* ----------------------------------------------------------------- */ 454 455 static QemuInputHandler virtio_tablet_handler = { 456 .name = VIRTIO_ID_NAME_TABLET, 457 .mask = INPUT_EVENT_MASK_BTN | INPUT_EVENT_MASK_ABS, 458 .event = virtio_input_handle_event, 459 .sync = virtio_input_handle_sync, 460 }; 461 462 static struct virtio_input_config virtio_tablet_config[] = { 463 { 464 .select = VIRTIO_INPUT_CFG_ID_NAME, 465 .size = sizeof(VIRTIO_ID_NAME_TABLET), 466 .u.string = VIRTIO_ID_NAME_TABLET, 467 },{ 468 .select = VIRTIO_INPUT_CFG_ID_DEVIDS, 469 .size = sizeof(struct virtio_input_devids), 470 .u.ids = { 471 .bustype = const_le16(BUS_VIRTUAL), 472 .vendor = const_le16(0x0627), /* same we use for usb hid devices */ 473 .product = const_le16(0x0003), 474 .version = const_le16(0x0001), 475 }, 476 },{ 477 .select = VIRTIO_INPUT_CFG_EV_BITS, 478 .subsel = EV_ABS, 479 .size = 1, 480 .u.bitmap = { 481 (1 << ABS_X) | (1 << ABS_Y), 482 }, 483 },{ 484 .select = VIRTIO_INPUT_CFG_ABS_INFO, 485 .subsel = ABS_X, 486 .size = sizeof(virtio_input_absinfo), 487 .u.abs.min = const_le32(INPUT_EVENT_ABS_MIN), 488 .u.abs.max = const_le32(INPUT_EVENT_ABS_MAX), 489 },{ 490 .select = VIRTIO_INPUT_CFG_ABS_INFO, 491 .subsel = ABS_Y, 492 .size = sizeof(virtio_input_absinfo), 493 .u.abs.min = const_le32(INPUT_EVENT_ABS_MIN), 494 .u.abs.max = const_le32(INPUT_EVENT_ABS_MAX), 495 }, 496 { /* end of list */ }, 497 }; 498 499 static void virtio_tablet_init(Object *obj) 500 { 501 VirtIOInputHID *vhid = VIRTIO_INPUT_HID(obj); 502 VirtIOInput *vinput = VIRTIO_INPUT(obj); 503 504 vhid->handler = &virtio_tablet_handler; 505 virtio_input_init_config(vinput, virtio_tablet_config); 506 virtio_input_key_config(vinput, keymap_button, 507 ARRAY_SIZE(keymap_button)); 508 } 509 510 static const TypeInfo virtio_tablet_info = { 511 .name = TYPE_VIRTIO_TABLET, 512 .parent = TYPE_VIRTIO_INPUT_HID, 513 .instance_size = sizeof(VirtIOInputHID), 514 .instance_init = virtio_tablet_init, 515 }; 516 517 /* ----------------------------------------------------------------- */ 518 519 static void virtio_register_types(void) 520 { 521 type_register_static(&virtio_input_hid_info); 522 type_register_static(&virtio_keyboard_info); 523 type_register_static(&virtio_mouse_info); 524 type_register_static(&virtio_tablet_info); 525 } 526 527 type_init(virtio_register_types) 528