149ab747fSPaolo Bonzini /* 249ab747fSPaolo Bonzini * QEMU HID devices 349ab747fSPaolo Bonzini * 449ab747fSPaolo Bonzini * Copyright (c) 2005 Fabrice Bellard 549ab747fSPaolo Bonzini * Copyright (c) 2007 OpenMoko, Inc. (andrew@openedhand.com) 649ab747fSPaolo Bonzini * 749ab747fSPaolo Bonzini * Permission is hereby granted, free of charge, to any person obtaining a copy 849ab747fSPaolo Bonzini * of this software and associated documentation files (the "Software"), to deal 949ab747fSPaolo Bonzini * in the Software without restriction, including without limitation the rights 1049ab747fSPaolo Bonzini * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 1149ab747fSPaolo Bonzini * copies of the Software, and to permit persons to whom the Software is 1249ab747fSPaolo Bonzini * furnished to do so, subject to the following conditions: 1349ab747fSPaolo Bonzini * 1449ab747fSPaolo Bonzini * The above copyright notice and this permission notice shall be included in 1549ab747fSPaolo Bonzini * all copies or substantial portions of the Software. 1649ab747fSPaolo Bonzini * 1749ab747fSPaolo Bonzini * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 1849ab747fSPaolo Bonzini * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 1949ab747fSPaolo Bonzini * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 2049ab747fSPaolo Bonzini * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 2149ab747fSPaolo Bonzini * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 2249ab747fSPaolo Bonzini * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 2349ab747fSPaolo Bonzini * THE SOFTWARE. 2449ab747fSPaolo Bonzini */ 250430891cSPeter Maydell #include "qemu/osdep.h" 2649ab747fSPaolo Bonzini #include "hw/hw.h" 2749ab747fSPaolo Bonzini #include "ui/console.h" 2849ab747fSPaolo Bonzini #include "qemu/timer.h" 2949ab747fSPaolo Bonzini #include "hw/input/hid.h" 3049ab747fSPaolo Bonzini 3149ab747fSPaolo Bonzini #define HID_USAGE_ERROR_ROLLOVER 0x01 3249ab747fSPaolo Bonzini #define HID_USAGE_POSTFAIL 0x02 3349ab747fSPaolo Bonzini #define HID_USAGE_ERROR_UNDEFINED 0x03 3449ab747fSPaolo Bonzini 3549ab747fSPaolo Bonzini /* Indices are QEMU keycodes, values are from HID Usage Table. Indices 3649ab747fSPaolo Bonzini * above 0x80 are for keys that come after 0xe0 or 0xe1+0x1d or 0xe1+0x9d. */ 3749ab747fSPaolo Bonzini static const uint8_t hid_usage_keys[0x100] = { 3849ab747fSPaolo Bonzini 0x00, 0x29, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 3949ab747fSPaolo Bonzini 0x24, 0x25, 0x26, 0x27, 0x2d, 0x2e, 0x2a, 0x2b, 4049ab747fSPaolo Bonzini 0x14, 0x1a, 0x08, 0x15, 0x17, 0x1c, 0x18, 0x0c, 4149ab747fSPaolo Bonzini 0x12, 0x13, 0x2f, 0x30, 0x28, 0xe0, 0x04, 0x16, 4249ab747fSPaolo Bonzini 0x07, 0x09, 0x0a, 0x0b, 0x0d, 0x0e, 0x0f, 0x33, 4349ab747fSPaolo Bonzini 0x34, 0x35, 0xe1, 0x31, 0x1d, 0x1b, 0x06, 0x19, 4449ab747fSPaolo Bonzini 0x05, 0x11, 0x10, 0x36, 0x37, 0x38, 0xe5, 0x55, 450ee4de58SDinar Valeev 0xe2, 0x2c, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 4649ab747fSPaolo Bonzini 0x3f, 0x40, 0x41, 0x42, 0x43, 0x53, 0x47, 0x5f, 4749ab747fSPaolo Bonzini 0x60, 0x61, 0x56, 0x5c, 0x5d, 0x5e, 0x57, 0x59, 4891dbeedaSDaniel Serpell 0x5a, 0x5b, 0x62, 0x63, 0x00, 0x00, 0x64, 0x44, 4949ab747fSPaolo Bonzini 0x45, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 5049ab747fSPaolo Bonzini 0xe8, 0xe9, 0x71, 0x72, 0x73, 0x00, 0x00, 0x00, 5149ab747fSPaolo Bonzini 0x00, 0x00, 0x00, 0x85, 0x00, 0x00, 0x00, 0x00, 5249ab747fSPaolo Bonzini 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 5349ab747fSPaolo Bonzini 0x00, 0x00, 0x00, 0x00, 0x00, 0xe3, 0xe7, 0x65, 5449ab747fSPaolo Bonzini 5549ab747fSPaolo Bonzini 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 5649ab747fSPaolo Bonzini 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 5749ab747fSPaolo Bonzini 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 5849ab747fSPaolo Bonzini 0x00, 0x00, 0x00, 0x00, 0x58, 0xe4, 0x00, 0x00, 5949ab747fSPaolo Bonzini 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 6049ab747fSPaolo Bonzini 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 6149ab747fSPaolo Bonzini 0x00, 0x00, 0x00, 0x00, 0x00, 0x54, 0x00, 0x46, 6249ab747fSPaolo Bonzini 0xe6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 6349ab747fSPaolo Bonzini 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x00, 0x4a, 6449ab747fSPaolo Bonzini 0x52, 0x4b, 0x00, 0x50, 0x00, 0x4f, 0x00, 0x4d, 6549ab747fSPaolo Bonzini 0x51, 0x4e, 0x49, 0x4c, 0x00, 0x00, 0x00, 0x00, 6649ab747fSPaolo Bonzini 0x00, 0x00, 0x00, 0xe3, 0xe7, 0x65, 0x00, 0x00, 6749ab747fSPaolo Bonzini 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 6849ab747fSPaolo Bonzini 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 6949ab747fSPaolo Bonzini 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 7049ab747fSPaolo Bonzini 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 7149ab747fSPaolo Bonzini }; 7249ab747fSPaolo Bonzini 7349ab747fSPaolo Bonzini bool hid_has_events(HIDState *hs) 7449ab747fSPaolo Bonzini { 7549ab747fSPaolo Bonzini return hs->n > 0 || hs->idle_pending; 7649ab747fSPaolo Bonzini } 7749ab747fSPaolo Bonzini 7849ab747fSPaolo Bonzini static void hid_idle_timer(void *opaque) 7949ab747fSPaolo Bonzini { 8049ab747fSPaolo Bonzini HIDState *hs = opaque; 8149ab747fSPaolo Bonzini 8249ab747fSPaolo Bonzini hs->idle_pending = true; 8349ab747fSPaolo Bonzini hs->event(hs); 8449ab747fSPaolo Bonzini } 8549ab747fSPaolo Bonzini 8649ab747fSPaolo Bonzini static void hid_del_idle_timer(HIDState *hs) 8749ab747fSPaolo Bonzini { 8849ab747fSPaolo Bonzini if (hs->idle_timer) { 89bc72ad67SAlex Bligh timer_del(hs->idle_timer); 90bc72ad67SAlex Bligh timer_free(hs->idle_timer); 9149ab747fSPaolo Bonzini hs->idle_timer = NULL; 9249ab747fSPaolo Bonzini } 9349ab747fSPaolo Bonzini } 9449ab747fSPaolo Bonzini 9549ab747fSPaolo Bonzini void hid_set_next_idle(HIDState *hs) 9649ab747fSPaolo Bonzini { 9749ab747fSPaolo Bonzini if (hs->idle) { 98bc72ad67SAlex Bligh uint64_t expire_time = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + 9949ab747fSPaolo Bonzini get_ticks_per_sec() * hs->idle * 4 / 1000; 10049ab747fSPaolo Bonzini if (!hs->idle_timer) { 101bc72ad67SAlex Bligh hs->idle_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL, hid_idle_timer, hs); 10249ab747fSPaolo Bonzini } 103bc72ad67SAlex Bligh timer_mod_ns(hs->idle_timer, expire_time); 10449ab747fSPaolo Bonzini } else { 10549ab747fSPaolo Bonzini hid_del_idle_timer(hs); 10649ab747fSPaolo Bonzini } 10749ab747fSPaolo Bonzini } 10849ab747fSPaolo Bonzini 1098b84286fSGerd Hoffmann static void hid_pointer_event(DeviceState *dev, QemuConsole *src, 1108b84286fSGerd Hoffmann InputEvent *evt) 11149ab747fSPaolo Bonzini { 1127fb1cf16SEric Blake static const int bmap[INPUT_BUTTON__MAX] = { 1138b84286fSGerd Hoffmann [INPUT_BUTTON_LEFT] = 0x01, 1148b84286fSGerd Hoffmann [INPUT_BUTTON_RIGHT] = 0x02, 1158b84286fSGerd Hoffmann [INPUT_BUTTON_MIDDLE] = 0x04, 1168b84286fSGerd Hoffmann }; 1178b84286fSGerd Hoffmann HIDState *hs = (HIDState *)dev; 1188b84286fSGerd Hoffmann HIDPointerEvent *e; 119b5a1b443SEric Blake InputMoveEvent *move; 120b5a1b443SEric Blake InputBtnEvent *btn; 12149ab747fSPaolo Bonzini 1228b84286fSGerd Hoffmann assert(hs->n < QUEUE_LENGTH); 1238b84286fSGerd Hoffmann e = &hs->ptr.queue[(hs->head + hs->n) & QUEUE_MASK]; 1248b84286fSGerd Hoffmann 125568c73a4SEric Blake switch (evt->type) { 1268b84286fSGerd Hoffmann case INPUT_EVENT_KIND_REL: 127*32bafa8fSEric Blake move = evt->u.rel.data; 128b5a1b443SEric Blake if (move->axis == INPUT_AXIS_X) { 129b5a1b443SEric Blake e->xdx += move->value; 130b5a1b443SEric Blake } else if (move->axis == INPUT_AXIS_Y) { 131b5a1b443SEric Blake e->ydy += move->value; 1328b84286fSGerd Hoffmann } 1338b84286fSGerd Hoffmann break; 1348b84286fSGerd Hoffmann 1358b84286fSGerd Hoffmann case INPUT_EVENT_KIND_ABS: 136*32bafa8fSEric Blake move = evt->u.abs.data; 137b5a1b443SEric Blake if (move->axis == INPUT_AXIS_X) { 138b5a1b443SEric Blake e->xdx = move->value; 139b5a1b443SEric Blake } else if (move->axis == INPUT_AXIS_Y) { 140b5a1b443SEric Blake e->ydy = move->value; 1418b84286fSGerd Hoffmann } 1428b84286fSGerd Hoffmann break; 1438b84286fSGerd Hoffmann 1448b84286fSGerd Hoffmann case INPUT_EVENT_KIND_BTN: 145*32bafa8fSEric Blake btn = evt->u.btn.data; 146b5a1b443SEric Blake if (btn->down) { 147b5a1b443SEric Blake e->buttons_state |= bmap[btn->button]; 148b5a1b443SEric Blake if (btn->button == INPUT_BUTTON_WHEEL_UP) { 1498b84286fSGerd Hoffmann e->dz--; 150b5a1b443SEric Blake } else if (btn->button == INPUT_BUTTON_WHEEL_DOWN) { 1518b84286fSGerd Hoffmann e->dz++; 1528b84286fSGerd Hoffmann } 15349ab747fSPaolo Bonzini } else { 154b5a1b443SEric Blake e->buttons_state &= ~bmap[btn->button]; 15549ab747fSPaolo Bonzini } 1568b84286fSGerd Hoffmann break; 1578b84286fSGerd Hoffmann 1588b84286fSGerd Hoffmann default: 1598b84286fSGerd Hoffmann /* keep gcc happy */ 1608b84286fSGerd Hoffmann break; 16149ab747fSPaolo Bonzini } 16249ab747fSPaolo Bonzini 1638b84286fSGerd Hoffmann } 1648b84286fSGerd Hoffmann 1658b84286fSGerd Hoffmann static void hid_pointer_sync(DeviceState *dev) 16649ab747fSPaolo Bonzini { 1678b84286fSGerd Hoffmann HIDState *hs = (HIDState *)dev; 1688b84286fSGerd Hoffmann HIDPointerEvent *prev, *curr, *next; 1698b84286fSGerd Hoffmann bool event_compression = false; 17049ab747fSPaolo Bonzini 1718b84286fSGerd Hoffmann if (hs->n == QUEUE_LENGTH-1) { 1728b84286fSGerd Hoffmann /* 1735d831be2SStefan Weil * Queue full. We are losing information, but we at least 1748b84286fSGerd Hoffmann * keep track of most recent button state. 1758b84286fSGerd Hoffmann */ 1768b84286fSGerd Hoffmann return; 17749ab747fSPaolo Bonzini } 1788b84286fSGerd Hoffmann 1798b84286fSGerd Hoffmann prev = &hs->ptr.queue[(hs->head + hs->n - 1) & QUEUE_MASK]; 1808b84286fSGerd Hoffmann curr = &hs->ptr.queue[(hs->head + hs->n) & QUEUE_MASK]; 1818b84286fSGerd Hoffmann next = &hs->ptr.queue[(hs->head + hs->n + 1) & QUEUE_MASK]; 1828b84286fSGerd Hoffmann 1838b84286fSGerd Hoffmann if (hs->n > 0) { 1848b84286fSGerd Hoffmann /* 1858b84286fSGerd Hoffmann * No button state change between previous and current event 1868b84286fSGerd Hoffmann * (and previous wasn't seen by the guest yet), so there is 1878b84286fSGerd Hoffmann * motion information only and we can combine the two event 1888b84286fSGerd Hoffmann * into one. 1898b84286fSGerd Hoffmann */ 1908b84286fSGerd Hoffmann if (curr->buttons_state == prev->buttons_state) { 1918b84286fSGerd Hoffmann event_compression = true; 1928b84286fSGerd Hoffmann } 1938b84286fSGerd Hoffmann } 1948b84286fSGerd Hoffmann 1958b84286fSGerd Hoffmann if (event_compression) { 1968b84286fSGerd Hoffmann /* add current motion to previous, clear current */ 1978b84286fSGerd Hoffmann if (hs->kind == HID_MOUSE) { 1988b84286fSGerd Hoffmann prev->xdx += curr->xdx; 1998b84286fSGerd Hoffmann curr->xdx = 0; 20035e83d10SChristian Burger prev->ydy += curr->ydy; 2018b84286fSGerd Hoffmann curr->ydy = 0; 2028b84286fSGerd Hoffmann } else { 2038b84286fSGerd Hoffmann prev->xdx = curr->xdx; 2048b84286fSGerd Hoffmann prev->ydy = curr->ydy; 2058b84286fSGerd Hoffmann } 2068b84286fSGerd Hoffmann prev->dz += curr->dz; 2078b84286fSGerd Hoffmann curr->dz = 0; 2088b84286fSGerd Hoffmann } else { 2098b84286fSGerd Hoffmann /* prepate next (clear rel, copy abs + btns) */ 2108b84286fSGerd Hoffmann if (hs->kind == HID_MOUSE) { 2118b84286fSGerd Hoffmann next->xdx = 0; 2128b84286fSGerd Hoffmann next->ydy = 0; 2138b84286fSGerd Hoffmann } else { 2148b84286fSGerd Hoffmann next->xdx = curr->xdx; 2158b84286fSGerd Hoffmann next->ydy = curr->ydy; 2168b84286fSGerd Hoffmann } 2178b84286fSGerd Hoffmann next->dz = 0; 2188b84286fSGerd Hoffmann next->buttons_state = curr->buttons_state; 2198b84286fSGerd Hoffmann /* make current guest visible, notify guest */ 2208b84286fSGerd Hoffmann hs->n++; 22149ab747fSPaolo Bonzini hs->event(hs); 22249ab747fSPaolo Bonzini } 2238b84286fSGerd Hoffmann } 22449ab747fSPaolo Bonzini 2251ff5eeddSGerd Hoffmann static void hid_keyboard_event(DeviceState *dev, QemuConsole *src, 2261ff5eeddSGerd Hoffmann InputEvent *evt) 22749ab747fSPaolo Bonzini { 2281ff5eeddSGerd Hoffmann HIDState *hs = (HIDState *)dev; 2291ff5eeddSGerd Hoffmann int scancodes[3], i, count; 23049ab747fSPaolo Bonzini int slot; 231*32bafa8fSEric Blake InputKeyEvent *key = evt->u.key.data; 23249ab747fSPaolo Bonzini 233b5a1b443SEric Blake count = qemu_input_key_value_to_scancode(key->key, 234b5a1b443SEric Blake key->down, 2351ff5eeddSGerd Hoffmann scancodes); 2361ff5eeddSGerd Hoffmann if (hs->n + count > QUEUE_LENGTH) { 23749ab747fSPaolo Bonzini fprintf(stderr, "usb-kbd: warning: key event queue full\n"); 23849ab747fSPaolo Bonzini return; 23949ab747fSPaolo Bonzini } 2401ff5eeddSGerd Hoffmann for (i = 0; i < count; i++) { 24149ab747fSPaolo Bonzini slot = (hs->head + hs->n) & QUEUE_MASK; hs->n++; 2421ff5eeddSGerd Hoffmann hs->kbd.keycodes[slot] = scancodes[i]; 2431ff5eeddSGerd Hoffmann } 24449ab747fSPaolo Bonzini hs->event(hs); 24549ab747fSPaolo Bonzini } 24649ab747fSPaolo Bonzini 24749ab747fSPaolo Bonzini static void hid_keyboard_process_keycode(HIDState *hs) 24849ab747fSPaolo Bonzini { 249562f9375SPaolo Bonzini uint8_t hid_code, index, key; 25049ab747fSPaolo Bonzini int i, keycode, slot; 25149ab747fSPaolo Bonzini 25249ab747fSPaolo Bonzini if (hs->n == 0) { 25349ab747fSPaolo Bonzini return; 25449ab747fSPaolo Bonzini } 25549ab747fSPaolo Bonzini slot = hs->head & QUEUE_MASK; QUEUE_INCR(hs->head); hs->n--; 25649ab747fSPaolo Bonzini keycode = hs->kbd.keycodes[slot]; 25749ab747fSPaolo Bonzini 25849ab747fSPaolo Bonzini key = keycode & 0x7f; 259562f9375SPaolo Bonzini index = key | ((hs->kbd.modifiers & (1 << 8)) >> 1); 260562f9375SPaolo Bonzini hid_code = hid_usage_keys[index]; 26149ab747fSPaolo Bonzini hs->kbd.modifiers &= ~(1 << 8); 26249ab747fSPaolo Bonzini 26349ab747fSPaolo Bonzini switch (hid_code) { 26449ab747fSPaolo Bonzini case 0x00: 26549ab747fSPaolo Bonzini return; 26649ab747fSPaolo Bonzini 26749ab747fSPaolo Bonzini case 0xe0: 268562f9375SPaolo Bonzini assert(key == 0x1d); 26949ab747fSPaolo Bonzini if (hs->kbd.modifiers & (1 << 9)) { 270562f9375SPaolo Bonzini /* The hid_codes for the 0xe1/0x1d scancode sequence are 0xe9/0xe0. 271562f9375SPaolo Bonzini * Here we're processing the second hid_code. By dropping bit 9 272562f9375SPaolo Bonzini * and setting bit 8, the scancode after 0x1d will access the 273562f9375SPaolo Bonzini * second half of the table. 274562f9375SPaolo Bonzini */ 275562f9375SPaolo Bonzini hs->kbd.modifiers ^= (1 << 8) | (1 << 9); 27649ab747fSPaolo Bonzini return; 27749ab747fSPaolo Bonzini } 278562f9375SPaolo Bonzini /* fall through to process Ctrl_L */ 27949ab747fSPaolo Bonzini case 0xe1 ... 0xe7: 280562f9375SPaolo Bonzini /* Ctrl_L/Ctrl_R, Shift_L/Shift_R, Alt_L/Alt_R, Win_L/Win_R. 281562f9375SPaolo Bonzini * Handle releases here, or fall through to process presses. 282562f9375SPaolo Bonzini */ 28349ab747fSPaolo Bonzini if (keycode & (1 << 7)) { 28449ab747fSPaolo Bonzini hs->kbd.modifiers &= ~(1 << (hid_code & 0x0f)); 28549ab747fSPaolo Bonzini return; 28649ab747fSPaolo Bonzini } 287562f9375SPaolo Bonzini /* fall through */ 288562f9375SPaolo Bonzini case 0xe8 ... 0xe9: 289562f9375SPaolo Bonzini /* USB modifiers are just 1 byte long. Bits 8 and 9 of 290562f9375SPaolo Bonzini * hs->kbd.modifiers implement a state machine that detects the 291562f9375SPaolo Bonzini * 0xe0 and 0xe1/0x1d sequences. These bits do not follow the 292562f9375SPaolo Bonzini * usual rules where bit 7 marks released keys; they are cleared 293562f9375SPaolo Bonzini * elsewhere in the function as the state machine dictates. 294562f9375SPaolo Bonzini */ 29549ab747fSPaolo Bonzini hs->kbd.modifiers |= 1 << (hid_code & 0x0f); 29649ab747fSPaolo Bonzini return; 297562f9375SPaolo Bonzini 298562f9375SPaolo Bonzini case 0xea ... 0xef: 299562f9375SPaolo Bonzini abort(); 300562f9375SPaolo Bonzini 301562f9375SPaolo Bonzini default: 302562f9375SPaolo Bonzini break; 30349ab747fSPaolo Bonzini } 30449ab747fSPaolo Bonzini 30549ab747fSPaolo Bonzini if (keycode & (1 << 7)) { 30649ab747fSPaolo Bonzini for (i = hs->kbd.keys - 1; i >= 0; i--) { 30749ab747fSPaolo Bonzini if (hs->kbd.key[i] == hid_code) { 30849ab747fSPaolo Bonzini hs->kbd.key[i] = hs->kbd.key[-- hs->kbd.keys]; 30949ab747fSPaolo Bonzini hs->kbd.key[hs->kbd.keys] = 0x00; 31049ab747fSPaolo Bonzini break; 31149ab747fSPaolo Bonzini } 31249ab747fSPaolo Bonzini } 31349ab747fSPaolo Bonzini if (i < 0) { 31449ab747fSPaolo Bonzini return; 31549ab747fSPaolo Bonzini } 31649ab747fSPaolo Bonzini } else { 31749ab747fSPaolo Bonzini for (i = hs->kbd.keys - 1; i >= 0; i--) { 31849ab747fSPaolo Bonzini if (hs->kbd.key[i] == hid_code) { 31949ab747fSPaolo Bonzini break; 32049ab747fSPaolo Bonzini } 32149ab747fSPaolo Bonzini } 32249ab747fSPaolo Bonzini if (i < 0) { 32349ab747fSPaolo Bonzini if (hs->kbd.keys < sizeof(hs->kbd.key)) { 32449ab747fSPaolo Bonzini hs->kbd.key[hs->kbd.keys++] = hid_code; 32549ab747fSPaolo Bonzini } 32649ab747fSPaolo Bonzini } else { 32749ab747fSPaolo Bonzini return; 32849ab747fSPaolo Bonzini } 32949ab747fSPaolo Bonzini } 33049ab747fSPaolo Bonzini } 33149ab747fSPaolo Bonzini 33249ab747fSPaolo Bonzini static inline int int_clamp(int val, int vmin, int vmax) 33349ab747fSPaolo Bonzini { 33449ab747fSPaolo Bonzini if (val < vmin) { 33549ab747fSPaolo Bonzini return vmin; 33649ab747fSPaolo Bonzini } else if (val > vmax) { 33749ab747fSPaolo Bonzini return vmax; 33849ab747fSPaolo Bonzini } else { 33949ab747fSPaolo Bonzini return val; 34049ab747fSPaolo Bonzini } 34149ab747fSPaolo Bonzini } 34249ab747fSPaolo Bonzini 34349ab747fSPaolo Bonzini void hid_pointer_activate(HIDState *hs) 34449ab747fSPaolo Bonzini { 34549ab747fSPaolo Bonzini if (!hs->ptr.mouse_grabbed) { 3468b84286fSGerd Hoffmann qemu_input_handler_activate(hs->s); 34749ab747fSPaolo Bonzini hs->ptr.mouse_grabbed = 1; 34849ab747fSPaolo Bonzini } 34949ab747fSPaolo Bonzini } 35049ab747fSPaolo Bonzini 35149ab747fSPaolo Bonzini int hid_pointer_poll(HIDState *hs, uint8_t *buf, int len) 35249ab747fSPaolo Bonzini { 3538b84286fSGerd Hoffmann int dx, dy, dz, l; 35449ab747fSPaolo Bonzini int index; 35549ab747fSPaolo Bonzini HIDPointerEvent *e; 35649ab747fSPaolo Bonzini 35749ab747fSPaolo Bonzini hs->idle_pending = false; 35849ab747fSPaolo Bonzini 35949ab747fSPaolo Bonzini hid_pointer_activate(hs); 36049ab747fSPaolo Bonzini 36149ab747fSPaolo Bonzini /* When the buffer is empty, return the last event. Relative 36249ab747fSPaolo Bonzini movements will all be zero. */ 36349ab747fSPaolo Bonzini index = (hs->n ? hs->head : hs->head - 1); 36449ab747fSPaolo Bonzini e = &hs->ptr.queue[index & QUEUE_MASK]; 36549ab747fSPaolo Bonzini 36649ab747fSPaolo Bonzini if (hs->kind == HID_MOUSE) { 36749ab747fSPaolo Bonzini dx = int_clamp(e->xdx, -127, 127); 36849ab747fSPaolo Bonzini dy = int_clamp(e->ydy, -127, 127); 36949ab747fSPaolo Bonzini e->xdx -= dx; 37049ab747fSPaolo Bonzini e->ydy -= dy; 37149ab747fSPaolo Bonzini } else { 37249ab747fSPaolo Bonzini dx = e->xdx; 37349ab747fSPaolo Bonzini dy = e->ydy; 37449ab747fSPaolo Bonzini } 37549ab747fSPaolo Bonzini dz = int_clamp(e->dz, -127, 127); 37649ab747fSPaolo Bonzini e->dz -= dz; 37749ab747fSPaolo Bonzini 37849ab747fSPaolo Bonzini if (hs->n && 37949ab747fSPaolo Bonzini !e->dz && 38049ab747fSPaolo Bonzini (hs->kind == HID_TABLET || (!e->xdx && !e->ydy))) { 38149ab747fSPaolo Bonzini /* that deals with this event */ 38249ab747fSPaolo Bonzini QUEUE_INCR(hs->head); 38349ab747fSPaolo Bonzini hs->n--; 38449ab747fSPaolo Bonzini } 38549ab747fSPaolo Bonzini 38649ab747fSPaolo Bonzini /* Appears we have to invert the wheel direction */ 38749ab747fSPaolo Bonzini dz = 0 - dz; 38849ab747fSPaolo Bonzini l = 0; 38949ab747fSPaolo Bonzini switch (hs->kind) { 39049ab747fSPaolo Bonzini case HID_MOUSE: 39149ab747fSPaolo Bonzini if (len > l) { 3928b84286fSGerd Hoffmann buf[l++] = e->buttons_state; 39349ab747fSPaolo Bonzini } 39449ab747fSPaolo Bonzini if (len > l) { 39549ab747fSPaolo Bonzini buf[l++] = dx; 39649ab747fSPaolo Bonzini } 39749ab747fSPaolo Bonzini if (len > l) { 39849ab747fSPaolo Bonzini buf[l++] = dy; 39949ab747fSPaolo Bonzini } 40049ab747fSPaolo Bonzini if (len > l) { 40149ab747fSPaolo Bonzini buf[l++] = dz; 40249ab747fSPaolo Bonzini } 40349ab747fSPaolo Bonzini break; 40449ab747fSPaolo Bonzini 40549ab747fSPaolo Bonzini case HID_TABLET: 40649ab747fSPaolo Bonzini if (len > l) { 4078b84286fSGerd Hoffmann buf[l++] = e->buttons_state; 40849ab747fSPaolo Bonzini } 40949ab747fSPaolo Bonzini if (len > l) { 41049ab747fSPaolo Bonzini buf[l++] = dx & 0xff; 41149ab747fSPaolo Bonzini } 41249ab747fSPaolo Bonzini if (len > l) { 41349ab747fSPaolo Bonzini buf[l++] = dx >> 8; 41449ab747fSPaolo Bonzini } 41549ab747fSPaolo Bonzini if (len > l) { 41649ab747fSPaolo Bonzini buf[l++] = dy & 0xff; 41749ab747fSPaolo Bonzini } 41849ab747fSPaolo Bonzini if (len > l) { 41949ab747fSPaolo Bonzini buf[l++] = dy >> 8; 42049ab747fSPaolo Bonzini } 42149ab747fSPaolo Bonzini if (len > l) { 42249ab747fSPaolo Bonzini buf[l++] = dz; 42349ab747fSPaolo Bonzini } 42449ab747fSPaolo Bonzini break; 42549ab747fSPaolo Bonzini 42649ab747fSPaolo Bonzini default: 42749ab747fSPaolo Bonzini abort(); 42849ab747fSPaolo Bonzini } 42949ab747fSPaolo Bonzini 43049ab747fSPaolo Bonzini return l; 43149ab747fSPaolo Bonzini } 43249ab747fSPaolo Bonzini 43349ab747fSPaolo Bonzini int hid_keyboard_poll(HIDState *hs, uint8_t *buf, int len) 43449ab747fSPaolo Bonzini { 43549ab747fSPaolo Bonzini hs->idle_pending = false; 43649ab747fSPaolo Bonzini 43749ab747fSPaolo Bonzini if (len < 2) { 43849ab747fSPaolo Bonzini return 0; 43949ab747fSPaolo Bonzini } 44049ab747fSPaolo Bonzini 44149ab747fSPaolo Bonzini hid_keyboard_process_keycode(hs); 44249ab747fSPaolo Bonzini 44349ab747fSPaolo Bonzini buf[0] = hs->kbd.modifiers & 0xff; 44449ab747fSPaolo Bonzini buf[1] = 0; 44549ab747fSPaolo Bonzini if (hs->kbd.keys > 6) { 44649ab747fSPaolo Bonzini memset(buf + 2, HID_USAGE_ERROR_ROLLOVER, MIN(8, len) - 2); 44749ab747fSPaolo Bonzini } else { 44849ab747fSPaolo Bonzini memcpy(buf + 2, hs->kbd.key, MIN(8, len) - 2); 44949ab747fSPaolo Bonzini } 45049ab747fSPaolo Bonzini 45149ab747fSPaolo Bonzini return MIN(8, len); 45249ab747fSPaolo Bonzini } 45349ab747fSPaolo Bonzini 45449ab747fSPaolo Bonzini int hid_keyboard_write(HIDState *hs, uint8_t *buf, int len) 45549ab747fSPaolo Bonzini { 45649ab747fSPaolo Bonzini if (len > 0) { 45749ab747fSPaolo Bonzini int ledstate = 0; 45849ab747fSPaolo Bonzini /* 0x01: Num Lock LED 45949ab747fSPaolo Bonzini * 0x02: Caps Lock LED 46049ab747fSPaolo Bonzini * 0x04: Scroll Lock LED 46149ab747fSPaolo Bonzini * 0x08: Compose LED 46249ab747fSPaolo Bonzini * 0x10: Kana LED */ 46349ab747fSPaolo Bonzini hs->kbd.leds = buf[0]; 46449ab747fSPaolo Bonzini if (hs->kbd.leds & 0x04) { 46549ab747fSPaolo Bonzini ledstate |= QEMU_SCROLL_LOCK_LED; 46649ab747fSPaolo Bonzini } 46749ab747fSPaolo Bonzini if (hs->kbd.leds & 0x01) { 46849ab747fSPaolo Bonzini ledstate |= QEMU_NUM_LOCK_LED; 46949ab747fSPaolo Bonzini } 47049ab747fSPaolo Bonzini if (hs->kbd.leds & 0x02) { 47149ab747fSPaolo Bonzini ledstate |= QEMU_CAPS_LOCK_LED; 47249ab747fSPaolo Bonzini } 47349ab747fSPaolo Bonzini kbd_put_ledstate(ledstate); 47449ab747fSPaolo Bonzini } 47549ab747fSPaolo Bonzini return 0; 47649ab747fSPaolo Bonzini } 47749ab747fSPaolo Bonzini 47849ab747fSPaolo Bonzini void hid_reset(HIDState *hs) 47949ab747fSPaolo Bonzini { 48049ab747fSPaolo Bonzini switch (hs->kind) { 48149ab747fSPaolo Bonzini case HID_KEYBOARD: 48249ab747fSPaolo Bonzini memset(hs->kbd.keycodes, 0, sizeof(hs->kbd.keycodes)); 48349ab747fSPaolo Bonzini memset(hs->kbd.key, 0, sizeof(hs->kbd.key)); 48449ab747fSPaolo Bonzini hs->kbd.keys = 0; 48549ab747fSPaolo Bonzini break; 48649ab747fSPaolo Bonzini case HID_MOUSE: 48749ab747fSPaolo Bonzini case HID_TABLET: 48849ab747fSPaolo Bonzini memset(hs->ptr.queue, 0, sizeof(hs->ptr.queue)); 48949ab747fSPaolo Bonzini break; 49049ab747fSPaolo Bonzini } 49149ab747fSPaolo Bonzini hs->head = 0; 49249ab747fSPaolo Bonzini hs->n = 0; 49349ab747fSPaolo Bonzini hs->protocol = 1; 49449ab747fSPaolo Bonzini hs->idle = 0; 49549ab747fSPaolo Bonzini hs->idle_pending = false; 49649ab747fSPaolo Bonzini hid_del_idle_timer(hs); 49749ab747fSPaolo Bonzini } 49849ab747fSPaolo Bonzini 49949ab747fSPaolo Bonzini void hid_free(HIDState *hs) 50049ab747fSPaolo Bonzini { 5011ff5eeddSGerd Hoffmann qemu_input_handler_unregister(hs->s); 50249ab747fSPaolo Bonzini hid_del_idle_timer(hs); 50349ab747fSPaolo Bonzini } 50449ab747fSPaolo Bonzini 5051ff5eeddSGerd Hoffmann static QemuInputHandler hid_keyboard_handler = { 5061ff5eeddSGerd Hoffmann .name = "QEMU HID Keyboard", 5071ff5eeddSGerd Hoffmann .mask = INPUT_EVENT_MASK_KEY, 5081ff5eeddSGerd Hoffmann .event = hid_keyboard_event, 5091ff5eeddSGerd Hoffmann }; 5101ff5eeddSGerd Hoffmann 5118b84286fSGerd Hoffmann static QemuInputHandler hid_mouse_handler = { 5128b84286fSGerd Hoffmann .name = "QEMU HID Mouse", 5138b84286fSGerd Hoffmann .mask = INPUT_EVENT_MASK_BTN | INPUT_EVENT_MASK_REL, 5148b84286fSGerd Hoffmann .event = hid_pointer_event, 5158b84286fSGerd Hoffmann .sync = hid_pointer_sync, 5168b84286fSGerd Hoffmann }; 5178b84286fSGerd Hoffmann 5188b84286fSGerd Hoffmann static QemuInputHandler hid_tablet_handler = { 5198b84286fSGerd Hoffmann .name = "QEMU HID Tablet", 5208b84286fSGerd Hoffmann .mask = INPUT_EVENT_MASK_BTN | INPUT_EVENT_MASK_ABS, 5218b84286fSGerd Hoffmann .event = hid_pointer_event, 5228b84286fSGerd Hoffmann .sync = hid_pointer_sync, 5238b84286fSGerd Hoffmann }; 5248b84286fSGerd Hoffmann 52549ab747fSPaolo Bonzini void hid_init(HIDState *hs, int kind, HIDEventFunc event) 52649ab747fSPaolo Bonzini { 52749ab747fSPaolo Bonzini hs->kind = kind; 52849ab747fSPaolo Bonzini hs->event = event; 52949ab747fSPaolo Bonzini 53049ab747fSPaolo Bonzini if (hs->kind == HID_KEYBOARD) { 5311ff5eeddSGerd Hoffmann hs->s = qemu_input_handler_register((DeviceState *)hs, 5321ff5eeddSGerd Hoffmann &hid_keyboard_handler); 5331ff5eeddSGerd Hoffmann qemu_input_handler_activate(hs->s); 53449ab747fSPaolo Bonzini } else if (hs->kind == HID_MOUSE) { 5358b84286fSGerd Hoffmann hs->s = qemu_input_handler_register((DeviceState *)hs, 5368b84286fSGerd Hoffmann &hid_mouse_handler); 53749ab747fSPaolo Bonzini } else if (hs->kind == HID_TABLET) { 5388b84286fSGerd Hoffmann hs->s = qemu_input_handler_register((DeviceState *)hs, 5398b84286fSGerd Hoffmann &hid_tablet_handler); 54049ab747fSPaolo Bonzini } 54149ab747fSPaolo Bonzini } 54249ab747fSPaolo Bonzini 54349ab747fSPaolo Bonzini static int hid_post_load(void *opaque, int version_id) 54449ab747fSPaolo Bonzini { 54549ab747fSPaolo Bonzini HIDState *s = opaque; 54649ab747fSPaolo Bonzini 54749ab747fSPaolo Bonzini hid_set_next_idle(s); 548ba4d2606SGerd Hoffmann 549ba4d2606SGerd Hoffmann if (s->n == QUEUE_LENGTH && (s->kind == HID_TABLET || 550ba4d2606SGerd Hoffmann s->kind == HID_MOUSE)) { 551ba4d2606SGerd Hoffmann /* 552ba4d2606SGerd Hoffmann * Handle ptr device migration from old qemu with full queue. 553ba4d2606SGerd Hoffmann * 554ba4d2606SGerd Hoffmann * Throw away everything but the last event, so we propagate 555ba4d2606SGerd Hoffmann * at least the current button state to the guest. Also keep 556ba4d2606SGerd Hoffmann * current position for the tablet, signal "no motion" for the 557ba4d2606SGerd Hoffmann * mouse. 558ba4d2606SGerd Hoffmann */ 559ba4d2606SGerd Hoffmann HIDPointerEvent evt; 560ba4d2606SGerd Hoffmann evt = s->ptr.queue[(s->head+s->n) & QUEUE_MASK]; 561ba4d2606SGerd Hoffmann if (s->kind == HID_MOUSE) { 562ba4d2606SGerd Hoffmann evt.xdx = 0; 563ba4d2606SGerd Hoffmann evt.ydy = 0; 564ba4d2606SGerd Hoffmann } 565ba4d2606SGerd Hoffmann s->ptr.queue[0] = evt; 566ba4d2606SGerd Hoffmann s->head = 0; 567ba4d2606SGerd Hoffmann s->n = 1; 568ba4d2606SGerd Hoffmann } 56949ab747fSPaolo Bonzini return 0; 57049ab747fSPaolo Bonzini } 57149ab747fSPaolo Bonzini 57249ab747fSPaolo Bonzini static const VMStateDescription vmstate_hid_ptr_queue = { 57349ab747fSPaolo Bonzini .name = "HIDPointerEventQueue", 57449ab747fSPaolo Bonzini .version_id = 1, 57549ab747fSPaolo Bonzini .minimum_version_id = 1, 57649ab747fSPaolo Bonzini .fields = (VMStateField[]) { 57749ab747fSPaolo Bonzini VMSTATE_INT32(xdx, HIDPointerEvent), 57849ab747fSPaolo Bonzini VMSTATE_INT32(ydy, HIDPointerEvent), 57949ab747fSPaolo Bonzini VMSTATE_INT32(dz, HIDPointerEvent), 58049ab747fSPaolo Bonzini VMSTATE_INT32(buttons_state, HIDPointerEvent), 58149ab747fSPaolo Bonzini VMSTATE_END_OF_LIST() 58249ab747fSPaolo Bonzini } 58349ab747fSPaolo Bonzini }; 58449ab747fSPaolo Bonzini 58549ab747fSPaolo Bonzini const VMStateDescription vmstate_hid_ptr_device = { 58649ab747fSPaolo Bonzini .name = "HIDPointerDevice", 58749ab747fSPaolo Bonzini .version_id = 1, 58849ab747fSPaolo Bonzini .minimum_version_id = 1, 58949ab747fSPaolo Bonzini .post_load = hid_post_load, 59049ab747fSPaolo Bonzini .fields = (VMStateField[]) { 59149ab747fSPaolo Bonzini VMSTATE_STRUCT_ARRAY(ptr.queue, HIDState, QUEUE_LENGTH, 0, 59249ab747fSPaolo Bonzini vmstate_hid_ptr_queue, HIDPointerEvent), 59349ab747fSPaolo Bonzini VMSTATE_UINT32(head, HIDState), 59449ab747fSPaolo Bonzini VMSTATE_UINT32(n, HIDState), 59549ab747fSPaolo Bonzini VMSTATE_INT32(protocol, HIDState), 59649ab747fSPaolo Bonzini VMSTATE_UINT8(idle, HIDState), 59749ab747fSPaolo Bonzini VMSTATE_END_OF_LIST(), 59849ab747fSPaolo Bonzini } 59949ab747fSPaolo Bonzini }; 60049ab747fSPaolo Bonzini 60149ab747fSPaolo Bonzini const VMStateDescription vmstate_hid_keyboard_device = { 60249ab747fSPaolo Bonzini .name = "HIDKeyboardDevice", 60349ab747fSPaolo Bonzini .version_id = 1, 60449ab747fSPaolo Bonzini .minimum_version_id = 1, 60549ab747fSPaolo Bonzini .post_load = hid_post_load, 60649ab747fSPaolo Bonzini .fields = (VMStateField[]) { 60749ab747fSPaolo Bonzini VMSTATE_UINT32_ARRAY(kbd.keycodes, HIDState, QUEUE_LENGTH), 60849ab747fSPaolo Bonzini VMSTATE_UINT32(head, HIDState), 60949ab747fSPaolo Bonzini VMSTATE_UINT32(n, HIDState), 61049ab747fSPaolo Bonzini VMSTATE_UINT16(kbd.modifiers, HIDState), 61149ab747fSPaolo Bonzini VMSTATE_UINT8(kbd.leds, HIDState), 61249ab747fSPaolo Bonzini VMSTATE_UINT8_ARRAY(kbd.key, HIDState, 16), 61349ab747fSPaolo Bonzini VMSTATE_INT32(kbd.keys, HIDState), 61449ab747fSPaolo Bonzini VMSTATE_INT32(protocol, HIDState), 61549ab747fSPaolo Bonzini VMSTATE_UINT8(idle, HIDState), 61649ab747fSPaolo Bonzini VMSTATE_END_OF_LIST(), 61749ab747fSPaolo Bonzini } 61849ab747fSPaolo Bonzini }; 619