1 #include "qemu/osdep.h" 2 #include "sysemu/sysemu.h" 3 #include "qapi/error.h" 4 #include "qapi/qapi-commands-ui.h" 5 #include "trace.h" 6 #include "ui/input.h" 7 #include "ui/console.h" 8 #include "sysemu/replay.h" 9 #include "sysemu/runstate.h" 10 11 struct QemuInputHandlerState { 12 DeviceState *dev; 13 QemuInputHandler *handler; 14 int id; 15 int events; 16 QemuConsole *con; 17 QTAILQ_ENTRY(QemuInputHandlerState) node; 18 }; 19 20 typedef struct QemuInputEventQueue QemuInputEventQueue; 21 typedef QTAILQ_HEAD(QemuInputEventQueueHead, QemuInputEventQueue) 22 QemuInputEventQueueHead; 23 24 struct QemuInputEventQueue { 25 enum { 26 QEMU_INPUT_QUEUE_DELAY = 1, 27 QEMU_INPUT_QUEUE_EVENT, 28 QEMU_INPUT_QUEUE_SYNC, 29 } type; 30 QEMUTimer *timer; 31 uint32_t delay_ms; 32 QemuConsole *src; 33 InputEvent *evt; 34 QTAILQ_ENTRY(QemuInputEventQueue) node; 35 }; 36 37 static QTAILQ_HEAD(, QemuInputHandlerState) handlers = 38 QTAILQ_HEAD_INITIALIZER(handlers); 39 static NotifierList mouse_mode_notifiers = 40 NOTIFIER_LIST_INITIALIZER(mouse_mode_notifiers); 41 42 static QemuInputEventQueueHead kbd_queue = QTAILQ_HEAD_INITIALIZER(kbd_queue); 43 static QEMUTimer *kbd_timer; 44 static uint32_t kbd_default_delay_ms = 10; 45 static uint32_t queue_count; 46 static uint32_t queue_limit = 1024; 47 48 QemuInputHandlerState *qemu_input_handler_register(DeviceState *dev, 49 QemuInputHandler *handler) 50 { 51 QemuInputHandlerState *s = g_new0(QemuInputHandlerState, 1); 52 static int id = 1; 53 54 s->dev = dev; 55 s->handler = handler; 56 s->id = id++; 57 QTAILQ_INSERT_TAIL(&handlers, s, node); 58 59 notifier_list_notify(&mouse_mode_notifiers, NULL); 60 return s; 61 } 62 63 void qemu_input_handler_activate(QemuInputHandlerState *s) 64 { 65 QTAILQ_REMOVE(&handlers, s, node); 66 QTAILQ_INSERT_HEAD(&handlers, s, node); 67 notifier_list_notify(&mouse_mode_notifiers, NULL); 68 } 69 70 void qemu_input_handler_deactivate(QemuInputHandlerState *s) 71 { 72 QTAILQ_REMOVE(&handlers, s, node); 73 QTAILQ_INSERT_TAIL(&handlers, s, node); 74 notifier_list_notify(&mouse_mode_notifiers, NULL); 75 } 76 77 void qemu_input_handler_unregister(QemuInputHandlerState *s) 78 { 79 QTAILQ_REMOVE(&handlers, s, node); 80 g_free(s); 81 notifier_list_notify(&mouse_mode_notifiers, NULL); 82 } 83 84 void qemu_input_handler_bind(QemuInputHandlerState *s, 85 const char *device_id, int head, 86 Error **errp) 87 { 88 QemuConsole *con; 89 Error *err = NULL; 90 91 con = qemu_console_lookup_by_device_name(device_id, head, &err); 92 if (err) { 93 error_propagate(errp, err); 94 return; 95 } 96 97 s->con = con; 98 } 99 100 static QemuInputHandlerState* 101 qemu_input_find_handler(uint32_t mask, QemuConsole *con) 102 { 103 QemuInputHandlerState *s; 104 105 QTAILQ_FOREACH(s, &handlers, node) { 106 if (s->con == NULL || s->con != con) { 107 continue; 108 } 109 if (mask & s->handler->mask) { 110 return s; 111 } 112 } 113 114 QTAILQ_FOREACH(s, &handlers, node) { 115 if (s->con != NULL) { 116 continue; 117 } 118 if (mask & s->handler->mask) { 119 return s; 120 } 121 } 122 return NULL; 123 } 124 125 void qmp_input_send_event(const char *device, 126 bool has_head, int64_t head, 127 InputEventList *events, Error **errp) 128 { 129 InputEventList *e; 130 QemuConsole *con; 131 Error *err = NULL; 132 133 con = NULL; 134 if (device) { 135 if (!has_head) { 136 head = 0; 137 } 138 con = qemu_console_lookup_by_device_name(device, head, &err); 139 if (err) { 140 error_propagate(errp, err); 141 return; 142 } 143 } 144 145 if (!runstate_is_running() && !runstate_check(RUN_STATE_SUSPENDED)) { 146 error_setg(errp, "VM not running"); 147 return; 148 } 149 150 for (e = events; e != NULL; e = e->next) { 151 InputEvent *event = e->value; 152 153 if (!qemu_input_find_handler(1 << event->type, con)) { 154 error_setg(errp, "Input handler not found for " 155 "event type %s", 156 InputEventKind_str(event->type)); 157 return; 158 } 159 } 160 161 for (e = events; e != NULL; e = e->next) { 162 InputEvent *evt = e->value; 163 164 if (evt->type == INPUT_EVENT_KIND_KEY && 165 evt->u.key.data->key->type == KEY_VALUE_KIND_NUMBER) { 166 KeyValue *key = evt->u.key.data->key; 167 QKeyCode code = qemu_input_key_number_to_qcode(key->u.number.data); 168 qemu_input_event_send_key_qcode(con, code, evt->u.key.data->down); 169 } else { 170 qemu_input_event_send(con, evt); 171 } 172 } 173 174 qemu_input_event_sync(); 175 } 176 177 static int qemu_input_transform_invert_abs_value(int value) 178 { 179 return (int64_t)INPUT_EVENT_ABS_MAX - value + INPUT_EVENT_ABS_MIN; 180 } 181 182 static void qemu_input_transform_abs_rotate(InputEvent *evt) 183 { 184 InputMoveEvent *move = evt->u.abs.data; 185 switch (graphic_rotate) { 186 case 90: 187 if (move->axis == INPUT_AXIS_X) { 188 move->axis = INPUT_AXIS_Y; 189 } else if (move->axis == INPUT_AXIS_Y) { 190 move->axis = INPUT_AXIS_X; 191 move->value = qemu_input_transform_invert_abs_value(move->value); 192 } 193 break; 194 case 180: 195 move->value = qemu_input_transform_invert_abs_value(move->value); 196 break; 197 case 270: 198 if (move->axis == INPUT_AXIS_X) { 199 move->axis = INPUT_AXIS_Y; 200 move->value = qemu_input_transform_invert_abs_value(move->value); 201 } else if (move->axis == INPUT_AXIS_Y) { 202 move->axis = INPUT_AXIS_X; 203 } 204 break; 205 } 206 } 207 208 static void qemu_input_event_trace(QemuConsole *src, InputEvent *evt) 209 { 210 const char *name; 211 int qcode, idx = -1; 212 InputKeyEvent *key; 213 InputBtnEvent *btn; 214 InputMoveEvent *move; 215 InputMultiTouchEvent *mtt; 216 217 if (src) { 218 idx = qemu_console_get_index(src); 219 } 220 switch (evt->type) { 221 case INPUT_EVENT_KIND_KEY: 222 key = evt->u.key.data; 223 switch (key->key->type) { 224 case KEY_VALUE_KIND_NUMBER: 225 qcode = qemu_input_key_number_to_qcode(key->key->u.number.data); 226 name = QKeyCode_str(qcode); 227 trace_input_event_key_number(idx, key->key->u.number.data, 228 name, key->down); 229 break; 230 case KEY_VALUE_KIND_QCODE: 231 name = QKeyCode_str(key->key->u.qcode.data); 232 trace_input_event_key_qcode(idx, name, key->down); 233 break; 234 case KEY_VALUE_KIND__MAX: 235 /* keep gcc happy */ 236 break; 237 } 238 break; 239 case INPUT_EVENT_KIND_BTN: 240 btn = evt->u.btn.data; 241 name = InputButton_str(btn->button); 242 trace_input_event_btn(idx, name, btn->down); 243 break; 244 case INPUT_EVENT_KIND_REL: 245 move = evt->u.rel.data; 246 name = InputAxis_str(move->axis); 247 trace_input_event_rel(idx, name, move->value); 248 break; 249 case INPUT_EVENT_KIND_ABS: 250 move = evt->u.abs.data; 251 name = InputAxis_str(move->axis); 252 trace_input_event_abs(idx, name, move->value); 253 break; 254 case INPUT_EVENT_KIND_MTT: 255 mtt = evt->u.mtt.data; 256 name = InputAxis_str(mtt->axis); 257 trace_input_event_mtt(idx, name, mtt->value); 258 break; 259 case INPUT_EVENT_KIND__MAX: 260 /* keep gcc happy */ 261 break; 262 } 263 } 264 265 static void qemu_input_queue_process(void *opaque) 266 { 267 QemuInputEventQueueHead *queue = opaque; 268 QemuInputEventQueue *item; 269 270 g_assert(!QTAILQ_EMPTY(queue)); 271 item = QTAILQ_FIRST(queue); 272 g_assert(item->type == QEMU_INPUT_QUEUE_DELAY); 273 QTAILQ_REMOVE(queue, item, node); 274 queue_count--; 275 g_free(item); 276 277 while (!QTAILQ_EMPTY(queue)) { 278 item = QTAILQ_FIRST(queue); 279 switch (item->type) { 280 case QEMU_INPUT_QUEUE_DELAY: 281 timer_mod(item->timer, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) 282 + item->delay_ms); 283 return; 284 case QEMU_INPUT_QUEUE_EVENT: 285 qemu_input_event_send(item->src, item->evt); 286 qapi_free_InputEvent(item->evt); 287 break; 288 case QEMU_INPUT_QUEUE_SYNC: 289 qemu_input_event_sync(); 290 break; 291 } 292 QTAILQ_REMOVE(queue, item, node); 293 queue_count--; 294 g_free(item); 295 } 296 } 297 298 static void qemu_input_queue_delay(QemuInputEventQueueHead *queue, 299 QEMUTimer *timer, uint32_t delay_ms) 300 { 301 QemuInputEventQueue *item = g_new0(QemuInputEventQueue, 1); 302 bool start_timer = QTAILQ_EMPTY(queue); 303 304 item->type = QEMU_INPUT_QUEUE_DELAY; 305 item->delay_ms = delay_ms; 306 item->timer = timer; 307 QTAILQ_INSERT_TAIL(queue, item, node); 308 queue_count++; 309 310 if (start_timer) { 311 timer_mod(item->timer, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) 312 + item->delay_ms); 313 } 314 } 315 316 static void qemu_input_queue_event(QemuInputEventQueueHead *queue, 317 QemuConsole *src, InputEvent *evt) 318 { 319 QemuInputEventQueue *item = g_new0(QemuInputEventQueue, 1); 320 321 item->type = QEMU_INPUT_QUEUE_EVENT; 322 item->src = src; 323 item->evt = evt; 324 QTAILQ_INSERT_TAIL(queue, item, node); 325 queue_count++; 326 } 327 328 static void qemu_input_queue_sync(QemuInputEventQueueHead *queue) 329 { 330 QemuInputEventQueue *item = g_new0(QemuInputEventQueue, 1); 331 332 item->type = QEMU_INPUT_QUEUE_SYNC; 333 QTAILQ_INSERT_TAIL(queue, item, node); 334 queue_count++; 335 } 336 337 void qemu_input_event_send_impl(QemuConsole *src, InputEvent *evt) 338 { 339 QemuInputHandlerState *s; 340 341 qemu_input_event_trace(src, evt); 342 343 /* pre processing */ 344 if (graphic_rotate && (evt->type == INPUT_EVENT_KIND_ABS)) { 345 qemu_input_transform_abs_rotate(evt); 346 } 347 348 /* send event */ 349 s = qemu_input_find_handler(1 << evt->type, src); 350 if (!s) { 351 return; 352 } 353 s->handler->event(s->dev, src, evt); 354 s->events++; 355 } 356 357 void qemu_input_event_send(QemuConsole *src, InputEvent *evt) 358 { 359 /* Expect all parts of QEMU to send events with QCodes exclusively. 360 * Key numbers are only supported as end-user input via QMP */ 361 assert(!(evt->type == INPUT_EVENT_KIND_KEY && 362 evt->u.key.data->key->type == KEY_VALUE_KIND_NUMBER)); 363 364 365 /* 366 * 'sysrq' was mistakenly added to hack around the fact that 367 * the ps2 driver was not generating correct scancodes sequences 368 * when 'alt+print' was pressed. This flaw is now fixed and the 369 * 'sysrq' key serves no further purpose. We normalize it to 370 * 'print', so that downstream receivers of the event don't 371 * need to deal with this mistake 372 */ 373 if (evt->type == INPUT_EVENT_KIND_KEY && 374 evt->u.key.data->key->u.qcode.data == Q_KEY_CODE_SYSRQ) { 375 evt->u.key.data->key->u.qcode.data = Q_KEY_CODE_PRINT; 376 } 377 378 if (!runstate_is_running() && !runstate_check(RUN_STATE_SUSPENDED)) { 379 return; 380 } 381 382 replay_input_event(src, evt); 383 } 384 385 void qemu_input_event_sync_impl(void) 386 { 387 QemuInputHandlerState *s; 388 389 trace_input_event_sync(); 390 391 QTAILQ_FOREACH(s, &handlers, node) { 392 if (!s->events) { 393 continue; 394 } 395 if (s->handler->sync) { 396 s->handler->sync(s->dev); 397 } 398 s->events = 0; 399 } 400 } 401 402 void qemu_input_event_sync(void) 403 { 404 if (!runstate_is_running() && !runstate_check(RUN_STATE_SUSPENDED)) { 405 return; 406 } 407 408 replay_input_sync_event(); 409 } 410 411 static InputEvent *qemu_input_event_new_key(KeyValue *key, bool down) 412 { 413 InputEvent *evt = g_new0(InputEvent, 1); 414 evt->u.key.data = g_new0(InputKeyEvent, 1); 415 evt->type = INPUT_EVENT_KIND_KEY; 416 evt->u.key.data->key = key; 417 evt->u.key.data->down = down; 418 return evt; 419 } 420 421 void qemu_input_event_send_key(QemuConsole *src, KeyValue *key, bool down) 422 { 423 InputEvent *evt; 424 evt = qemu_input_event_new_key(key, down); 425 if (QTAILQ_EMPTY(&kbd_queue)) { 426 qemu_input_event_send(src, evt); 427 qemu_input_event_sync(); 428 qapi_free_InputEvent(evt); 429 } else if (queue_count < queue_limit) { 430 qemu_input_queue_event(&kbd_queue, src, evt); 431 qemu_input_queue_sync(&kbd_queue); 432 } else { 433 qapi_free_InputEvent(evt); 434 } 435 } 436 437 void qemu_input_event_send_key_number(QemuConsole *src, int num, bool down) 438 { 439 QKeyCode code = qemu_input_key_number_to_qcode(num); 440 qemu_input_event_send_key_qcode(src, code, down); 441 } 442 443 void qemu_input_event_send_key_qcode(QemuConsole *src, QKeyCode q, bool down) 444 { 445 KeyValue *key = g_new0(KeyValue, 1); 446 key->type = KEY_VALUE_KIND_QCODE; 447 key->u.qcode.data = q; 448 qemu_input_event_send_key(src, key, down); 449 } 450 451 void qemu_input_event_send_key_delay(uint32_t delay_ms) 452 { 453 if (!runstate_is_running() && !runstate_check(RUN_STATE_SUSPENDED)) { 454 return; 455 } 456 457 if (!kbd_timer) { 458 kbd_timer = timer_new_full(NULL, QEMU_CLOCK_VIRTUAL, 459 SCALE_MS, QEMU_TIMER_ATTR_EXTERNAL, 460 qemu_input_queue_process, &kbd_queue); 461 } 462 if (queue_count < queue_limit) { 463 qemu_input_queue_delay(&kbd_queue, kbd_timer, 464 delay_ms ? delay_ms : kbd_default_delay_ms); 465 } 466 } 467 468 void qemu_input_queue_btn(QemuConsole *src, InputButton btn, bool down) 469 { 470 InputBtnEvent bevt = { 471 .button = btn, 472 .down = down, 473 }; 474 InputEvent evt = { 475 .type = INPUT_EVENT_KIND_BTN, 476 .u.btn.data = &bevt, 477 }; 478 479 qemu_input_event_send(src, &evt); 480 } 481 482 void qemu_input_update_buttons(QemuConsole *src, uint32_t *button_map, 483 uint32_t button_old, uint32_t button_new) 484 { 485 InputButton btn; 486 uint32_t mask; 487 488 for (btn = 0; btn < INPUT_BUTTON__MAX; btn++) { 489 mask = button_map[btn]; 490 if ((button_old & mask) == (button_new & mask)) { 491 continue; 492 } 493 qemu_input_queue_btn(src, btn, button_new & mask); 494 } 495 } 496 497 bool qemu_input_is_absolute(QemuConsole *con) 498 { 499 QemuInputHandlerState *s; 500 501 s = qemu_input_find_handler(INPUT_EVENT_MASK_REL | INPUT_EVENT_MASK_ABS, 502 con); 503 return (s != NULL) && (s->handler->mask & INPUT_EVENT_MASK_ABS); 504 } 505 506 int qemu_input_scale_axis(int value, 507 int min_in, int max_in, 508 int min_out, int max_out) 509 { 510 int64_t range_in = (int64_t)max_in - min_in; 511 int64_t range_out = (int64_t)max_out - min_out; 512 513 if (range_in < 1) { 514 return min_out + range_out / 2; 515 } 516 return ((int64_t)value - min_in) * range_out / range_in + min_out; 517 } 518 519 void qemu_input_queue_rel(QemuConsole *src, InputAxis axis, int value) 520 { 521 InputMoveEvent move = { 522 .axis = axis, 523 .value = value, 524 }; 525 InputEvent evt = { 526 .type = INPUT_EVENT_KIND_REL, 527 .u.rel.data = &move, 528 }; 529 530 qemu_input_event_send(src, &evt); 531 } 532 533 void qemu_input_queue_abs(QemuConsole *src, InputAxis axis, int value, 534 int min_in, int max_in) 535 { 536 InputMoveEvent move = { 537 .axis = axis, 538 .value = qemu_input_scale_axis(value, min_in, max_in, 539 INPUT_EVENT_ABS_MIN, 540 INPUT_EVENT_ABS_MAX), 541 }; 542 InputEvent evt = { 543 .type = INPUT_EVENT_KIND_ABS, 544 .u.abs.data = &move, 545 }; 546 547 qemu_input_event_send(src, &evt); 548 } 549 550 void qemu_input_queue_mtt(QemuConsole *src, InputMultiTouchType type, 551 int slot, int tracking_id) 552 { 553 InputMultiTouchEvent mtt = { 554 .type = type, 555 .slot = slot, 556 .tracking_id = tracking_id, 557 }; 558 InputEvent evt = { 559 .type = INPUT_EVENT_KIND_MTT, 560 .u.mtt.data = &mtt, 561 }; 562 563 qemu_input_event_send(src, &evt); 564 } 565 566 void qemu_input_queue_mtt_abs(QemuConsole *src, InputAxis axis, int value, 567 int min_in, int max_in, int slot, int tracking_id) 568 { 569 InputMultiTouchEvent mtt = { 570 .type = INPUT_MULTI_TOUCH_TYPE_DATA, 571 .slot = slot, 572 .tracking_id = tracking_id, 573 .axis = axis, 574 .value = qemu_input_scale_axis(value, min_in, max_in, 575 INPUT_EVENT_ABS_MIN, 576 INPUT_EVENT_ABS_MAX), 577 }; 578 InputEvent evt = { 579 .type = INPUT_EVENT_KIND_MTT, 580 .u.mtt.data = &mtt, 581 }; 582 583 qemu_input_event_send(src, &evt); 584 } 585 586 void qemu_add_mouse_mode_change_notifier(Notifier *notify) 587 { 588 notifier_list_add(&mouse_mode_notifiers, notify); 589 } 590 591 void qemu_remove_mouse_mode_change_notifier(Notifier *notify) 592 { 593 notifier_remove(notify); 594 } 595 596 MouseInfoList *qmp_query_mice(Error **errp) 597 { 598 MouseInfoList *mice_list = NULL; 599 MouseInfo *info; 600 QemuInputHandlerState *s; 601 bool current = true; 602 603 QTAILQ_FOREACH(s, &handlers, node) { 604 if (!(s->handler->mask & 605 (INPUT_EVENT_MASK_REL | INPUT_EVENT_MASK_ABS))) { 606 continue; 607 } 608 609 info = g_new0(MouseInfo, 1); 610 info->index = s->id; 611 info->name = g_strdup(s->handler->name); 612 info->absolute = s->handler->mask & INPUT_EVENT_MASK_ABS; 613 info->current = current; 614 615 current = false; 616 QAPI_LIST_PREPEND(mice_list, info); 617 } 618 619 return mice_list; 620 } 621 622 bool qemu_mouse_set(int index, Error **errp) 623 { 624 QemuInputHandlerState *s; 625 626 QTAILQ_FOREACH(s, &handlers, node) { 627 if (s->id == index) { 628 break; 629 } 630 } 631 632 if (!s) { 633 error_setg(errp, "Mouse at index '%d' not found", index); 634 return false; 635 } 636 637 if (!(s->handler->mask & (INPUT_EVENT_MASK_REL | 638 INPUT_EVENT_MASK_ABS))) { 639 error_setg(errp, "Input device '%s' is not a mouse", 640 s->handler->name); 641 return false; 642 } 643 644 qemu_input_handler_activate(s); 645 notifier_list_notify(&mouse_mode_notifiers, NULL); 646 return true; 647 } 648