?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
guest agent: add --enable-guest-agent config option
[qemu.git] / hw / usb-hid.c
blob9008320c863905e40e3ce312eb7b1e7c88217ade
1 /*
2 * QEMU USB HID devices
3 *
4 * Copyright (c) 2005 Fabrice Bellard
5 * Copyright (c) 2007 OpenMoko, Inc. (andrew@openedhand.com)
6 *
7 * Permission is hereby granted, free of charge, to any person obtaining a copy
8 * of this software and associated documentation files (the "Software"), to deal
9 * in the Software without restriction, including without limitation the rights
10 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11 * copies of the Software, and to permit persons to whom the Software is
12 * furnished to do so, subject to the following conditions:
13 *
14 * The above copyright notice and this permission notice shall be included in
15 * all copies or substantial portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
23 * THE SOFTWARE.
24 */
25 #include "hw.h"
26 #include "console.h"
27 #include "usb.h"
28 #include "usb-desc.h"
29 #include "qemu-timer.h"
30
31 /* HID interface requests */
32 #define GET_REPORT 0xa101
33 #define GET_IDLE 0xa102
34 #define GET_PROTOCOL 0xa103
35 #define SET_REPORT 0x2109
36 #define SET_IDLE 0x210a
37 #define SET_PROTOCOL 0x210b
38
39 /* HID descriptor types */
40 #define USB_DT_HID 0x21
41 #define USB_DT_REPORT 0x22
42 #define USB_DT_PHY 0x23
43
44 #define USB_MOUSE 1
45 #define USB_TABLET 2
46 #define USB_KEYBOARD 3
47
48 typedef struct USBPointerEvent {
49 int32_t xdx, ydy; /* relative iff it's a mouse, otherwise absolute */
50 int32_t dz, buttons_state;
51 } USBPointerEvent;
52
53 #define QUEUE_LENGTH 16 /* should be enough for a triple-click */
54 #define QUEUE_MASK (QUEUE_LENGTH-1u)
55 #define QUEUE_INCR(v) ((v)++, (v) &= QUEUE_MASK)
56
57 typedef struct USBMouseState {
58 USBPointerEvent queue[QUEUE_LENGTH];
59 int mouse_grabbed;
60 QEMUPutMouseEntry *eh_entry;
61 } USBMouseState;
62
63 typedef struct USBKeyboardState {
64 uint32_t keycodes[QUEUE_LENGTH];
65 uint16_t modifiers;
66 uint8_t leds;
67 uint8_t key[16];
68 int32_t keys;
69 } USBKeyboardState;
70
71 typedef struct USBHIDState {
72 USBDevice dev;
73 union {
74 USBMouseState ptr;
75 USBKeyboardState kbd;
76 };
77 uint32_t head; /* index into circular queue */
78 uint32_t n;
79 int kind;
80 int32_t protocol;
81 uint8_t idle;
82 int64_t next_idle_clock;
83 int changed;
84 void *datain_opaque;
85 void (*datain)(void *);
86 } USBHIDState;
87
88 enum {
89 STR_MANUFACTURER = 1,
90 STR_PRODUCT_MOUSE,
91 STR_PRODUCT_TABLET,
92 STR_PRODUCT_KEYBOARD,
93 STR_SERIALNUMBER,
94 STR_CONFIG_MOUSE,
95 STR_CONFIG_TABLET,
96 STR_CONFIG_KEYBOARD,
97 };
98
99 static const USBDescStrings desc_strings = {
100 [STR_MANUFACTURER] = "QEMU " QEMU_VERSION,
101 [STR_PRODUCT_MOUSE] = "QEMU USB Mouse",
102 [STR_PRODUCT_TABLET] = "QEMU USB Tablet",
103 [STR_PRODUCT_KEYBOARD] = "QEMU USB Keyboard",
104 [STR_SERIALNUMBER] = "42", /* == remote wakeup works */
105 [STR_CONFIG_MOUSE] = "HID Mouse",
106 [STR_CONFIG_TABLET] = "HID Tablet",
107 [STR_CONFIG_KEYBOARD] = "HID Keyboard",
108 };
109
110 static const USBDescIface desc_iface_mouse = {
111 .bInterfaceNumber = 0,
112 .bNumEndpoints = 1,
113 .bInterfaceClass = USB_CLASS_HID,
114 .bInterfaceSubClass = 0x01, /* boot */
115 .bInterfaceProtocol = 0x02,
116 .ndesc = 1,
117 .descs = (USBDescOther[]) {
118 {
119 /* HID descriptor */
120 .data = (uint8_t[]) {
121 0x09, /* u8 bLength */
122 USB_DT_HID, /* u8 bDescriptorType */
123 0x01, 0x00, /* u16 HID_class */
124 0x00, /* u8 country_code */
125 0x01, /* u8 num_descriptors */
126 USB_DT_REPORT, /* u8 type: Report */
127 52, 0, /* u16 len */
128 },
129 },
130 },
131 .eps = (USBDescEndpoint[]) {
132 {
133 .bEndpointAddress = USB_DIR_IN | 0x01,
134 .bmAttributes = USB_ENDPOINT_XFER_INT,
135 .wMaxPacketSize = 4,
136 .bInterval = 0x0a,
137 },
138 },
139 };
140
141 static const USBDescIface desc_iface_tablet = {
142 .bInterfaceNumber = 0,
143 .bNumEndpoints = 1,
144 .bInterfaceClass = USB_CLASS_HID,
145 .bInterfaceProtocol = 0x02,
146 .ndesc = 1,
147 .descs = (USBDescOther[]) {
148 {
149 /* HID descriptor */
150 .data = (uint8_t[]) {
151 0x09, /* u8 bLength */
152 USB_DT_HID, /* u8 bDescriptorType */
153 0x01, 0x00, /* u16 HID_class */
154 0x00, /* u8 country_code */
155 0x01, /* u8 num_descriptors */
156 USB_DT_REPORT, /* u8 type: Report */
157 74, 0, /* u16 len */
158 },
159 },
160 },
161 .eps = (USBDescEndpoint[]) {
162 {
163 .bEndpointAddress = USB_DIR_IN | 0x01,
164 .bmAttributes = USB_ENDPOINT_XFER_INT,
165 .wMaxPacketSize = 8,
166 .bInterval = 0x0a,
167 },
168 },
169 };
170
171 static const USBDescIface desc_iface_keyboard = {
172 .bInterfaceNumber = 0,
173 .bNumEndpoints = 1,
174 .bInterfaceClass = USB_CLASS_HID,
175 .bInterfaceSubClass = 0x01, /* boot */
176 .bInterfaceProtocol = 0x01, /* keyboard */
177 .ndesc = 1,
178 .descs = (USBDescOther[]) {
179 {
180 /* HID descriptor */
181 .data = (uint8_t[]) {
182 0x09, /* u8 bLength */
183 USB_DT_HID, /* u8 bDescriptorType */
184 0x11, 0x01, /* u16 HID_class */
185 0x00, /* u8 country_code */
186 0x01, /* u8 num_descriptors */
187 USB_DT_REPORT, /* u8 type: Report */
188 0x3f, 0, /* u16 len */
189 },
190 },
191 },
192 .eps = (USBDescEndpoint[]) {
193 {
194 .bEndpointAddress = USB_DIR_IN | 0x01,
195 .bmAttributes = USB_ENDPOINT_XFER_INT,
196 .wMaxPacketSize = 8,
197 .bInterval = 0x0a,
198 },
199 },
200 };
201
202 static const USBDescDevice desc_device_mouse = {
203 .bcdUSB = 0x0100,
204 .bMaxPacketSize0 = 8,
205 .bNumConfigurations = 1,
206 .confs = (USBDescConfig[]) {
207 {
208 .bNumInterfaces = 1,
209 .bConfigurationValue = 1,
210 .iConfiguration = STR_CONFIG_MOUSE,
211 .bmAttributes = 0xa0,
212 .bMaxPower = 50,
213 .nif = 1,
214 .ifs = &desc_iface_mouse,
215 },
216 },
217 };
218
219 static const USBDescDevice desc_device_tablet = {
220 .bcdUSB = 0x0100,
221 .bMaxPacketSize0 = 8,
222 .bNumConfigurations = 1,
223 .confs = (USBDescConfig[]) {
224 {
225 .bNumInterfaces = 1,
226 .bConfigurationValue = 1,
227 .iConfiguration = STR_CONFIG_TABLET,
228 .bmAttributes = 0xa0,
229 .bMaxPower = 50,
230 .nif = 1,
231 .ifs = &desc_iface_tablet,
232 },
233 },
234 };
235
236 static const USBDescDevice desc_device_keyboard = {
237 .bcdUSB = 0x0100,
238 .bMaxPacketSize0 = 8,
239 .bNumConfigurations = 1,
240 .confs = (USBDescConfig[]) {
241 {
242 .bNumInterfaces = 1,
243 .bConfigurationValue = 1,
244 .iConfiguration = STR_CONFIG_KEYBOARD,
245 .bmAttributes = 0xa0,
246 .bMaxPower = 50,
247 .nif = 1,
248 .ifs = &desc_iface_keyboard,
249 },
250 },
251 };
252
253 static const USBDesc desc_mouse = {
254 .id = {
255 .idVendor = 0x0627,
256 .idProduct = 0x0001,
257 .bcdDevice = 0,
258 .iManufacturer = STR_MANUFACTURER,
259 .iProduct = STR_PRODUCT_MOUSE,
260 .iSerialNumber = STR_SERIALNUMBER,
261 },
262 .full = &desc_device_mouse,
263 .str = desc_strings,
264 };
265
266 static const USBDesc desc_tablet = {
267 .id = {
268 .idVendor = 0x0627,
269 .idProduct = 0x0001,
270 .bcdDevice = 0,
271 .iManufacturer = STR_MANUFACTURER,
272 .iProduct = STR_PRODUCT_TABLET,
273 .iSerialNumber = STR_SERIALNUMBER,
274 },
275 .full = &desc_device_tablet,
276 .str = desc_strings,
277 };
278
279 static const USBDesc desc_keyboard = {
280 .id = {
281 .idVendor = 0x0627,
282 .idProduct = 0x0001,
283 .bcdDevice = 0,
284 .iManufacturer = STR_MANUFACTURER,
285 .iProduct = STR_PRODUCT_KEYBOARD,
286 .iSerialNumber = STR_SERIALNUMBER,
287 },
288 .full = &desc_device_keyboard,
289 .str = desc_strings,
290 };
291
292 static const uint8_t qemu_mouse_hid_report_descriptor[] = {
293 0x05, 0x01, /* Usage Page (Generic Desktop) */
294 0x09, 0x02, /* Usage (Mouse) */
295 0xa1, 0x01, /* Collection (Application) */
296 0x09, 0x01, /* Usage (Pointer) */
297 0xa1, 0x00, /* Collection (Physical) */
298 0x05, 0x09, /* Usage Page (Button) */
299 0x19, 0x01, /* Usage Minimum (1) */
300 0x29, 0x03, /* Usage Maximum (3) */
301 0x15, 0x00, /* Logical Minimum (0) */
302 0x25, 0x01, /* Logical Maximum (1) */
303 0x95, 0x03, /* Report Count (3) */
304 0x75, 0x01, /* Report Size (1) */
305 0x81, 0x02, /* Input (Data, Variable, Absolute) */
306 0x95, 0x01, /* Report Count (1) */
307 0x75, 0x05, /* Report Size (5) */
308 0x81, 0x01, /* Input (Constant) */
309 0x05, 0x01, /* Usage Page (Generic Desktop) */
310 0x09, 0x30, /* Usage (X) */
311 0x09, 0x31, /* Usage (Y) */
312 0x09, 0x38, /* Usage (Wheel) */
313 0x15, 0x81, /* Logical Minimum (-0x7f) */
314 0x25, 0x7f, /* Logical Maximum (0x7f) */
315 0x75, 0x08, /* Report Size (8) */
316 0x95, 0x03, /* Report Count (3) */
317 0x81, 0x06, /* Input (Data, Variable, Relative) */
318 0xc0, /* End Collection */
319 0xc0, /* End Collection */
320 };
321
322 static const uint8_t qemu_tablet_hid_report_descriptor[] = {
323 0x05, 0x01, /* Usage Page (Generic Desktop) */
324 0x09, 0x01, /* Usage (Pointer) */
325 0xa1, 0x01, /* Collection (Application) */
326 0x09, 0x01, /* Usage (Pointer) */
327 0xa1, 0x00, /* Collection (Physical) */
328 0x05, 0x09, /* Usage Page (Button) */
329 0x19, 0x01, /* Usage Minimum (1) */
330 0x29, 0x03, /* Usage Maximum (3) */
331 0x15, 0x00, /* Logical Minimum (0) */
332 0x25, 0x01, /* Logical Maximum (1) */
333 0x95, 0x03, /* Report Count (3) */
334 0x75, 0x01, /* Report Size (1) */
335 0x81, 0x02, /* Input (Data, Variable, Absolute) */
336 0x95, 0x01, /* Report Count (1) */
337 0x75, 0x05, /* Report Size (5) */
338 0x81, 0x01, /* Input (Constant) */
339 0x05, 0x01, /* Usage Page (Generic Desktop) */
340 0x09, 0x30, /* Usage (X) */
341 0x09, 0x31, /* Usage (Y) */
342 0x15, 0x00, /* Logical Minimum (0) */
343 0x26, 0xff, 0x7f, /* Logical Maximum (0x7fff) */
344 0x35, 0x00, /* Physical Minimum (0) */
345 0x46, 0xff, 0x7f, /* Physical Maximum (0x7fff) */
346 0x75, 0x10, /* Report Size (16) */
347 0x95, 0x02, /* Report Count (2) */
348 0x81, 0x02, /* Input (Data, Variable, Absolute) */
349 0x05, 0x01, /* Usage Page (Generic Desktop) */
350 0x09, 0x38, /* Usage (Wheel) */
351 0x15, 0x81, /* Logical Minimum (-0x7f) */
352 0x25, 0x7f, /* Logical Maximum (0x7f) */
353 0x35, 0x00, /* Physical Minimum (same as logical) */
354 0x45, 0x00, /* Physical Maximum (same as logical) */
355 0x75, 0x08, /* Report Size (8) */
356 0x95, 0x01, /* Report Count (1) */
357 0x81, 0x06, /* Input (Data, Variable, Relative) */
358 0xc0, /* End Collection */
359 0xc0, /* End Collection */
360 };
361
362 static const uint8_t qemu_keyboard_hid_report_descriptor[] = {
363 0x05, 0x01, /* Usage Page (Generic Desktop) */
364 0x09, 0x06, /* Usage (Keyboard) */
365 0xa1, 0x01, /* Collection (Application) */
366 0x75, 0x01, /* Report Size (1) */
367 0x95, 0x08, /* Report Count (8) */
368 0x05, 0x07, /* Usage Page (Key Codes) */
369 0x19, 0xe0, /* Usage Minimum (224) */
370 0x29, 0xe7, /* Usage Maximum (231) */
371 0x15, 0x00, /* Logical Minimum (0) */
372 0x25, 0x01, /* Logical Maximum (1) */
373 0x81, 0x02, /* Input (Data, Variable, Absolute) */
374 0x95, 0x01, /* Report Count (1) */
375 0x75, 0x08, /* Report Size (8) */
376 0x81, 0x01, /* Input (Constant) */
377 0x95, 0x05, /* Report Count (5) */
378 0x75, 0x01, /* Report Size (1) */
379 0x05, 0x08, /* Usage Page (LEDs) */
380 0x19, 0x01, /* Usage Minimum (1) */
381 0x29, 0x05, /* Usage Maximum (5) */
382 0x91, 0x02, /* Output (Data, Variable, Absolute) */
383 0x95, 0x01, /* Report Count (1) */
384 0x75, 0x03, /* Report Size (3) */
385 0x91, 0x01, /* Output (Constant) */
386 0x95, 0x06, /* Report Count (6) */
387 0x75, 0x08, /* Report Size (8) */
388 0x15, 0x00, /* Logical Minimum (0) */
389 0x25, 0xff, /* Logical Maximum (255) */
390 0x05, 0x07, /* Usage Page (Key Codes) */
391 0x19, 0x00, /* Usage Minimum (0) */
392 0x29, 0xff, /* Usage Maximum (255) */
393 0x81, 0x00, /* Input (Data, Array) */
394 0xc0, /* End Collection */
395 };
396
397 #define USB_HID_USAGE_ERROR_ROLLOVER 0x01
398 #define USB_HID_USAGE_POSTFAIL 0x02
399 #define USB_HID_USAGE_ERROR_UNDEFINED 0x03
400
401 /* Indices are QEMU keycodes, values are from HID Usage Table. Indices
402 * above 0x80 are for keys that come after 0xe0 or 0xe1+0x1d or 0xe1+0x9d. */
403 static const uint8_t usb_hid_usage_keys[0x100] = {
404 0x00, 0x29, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23,
405 0x24, 0x25, 0x26, 0x27, 0x2d, 0x2e, 0x2a, 0x2b,
406 0x14, 0x1a, 0x08, 0x15, 0x17, 0x1c, 0x18, 0x0c,
407 0x12, 0x13, 0x2f, 0x30, 0x28, 0xe0, 0x04, 0x16,
408 0x07, 0x09, 0x0a, 0x0b, 0x0d, 0x0e, 0x0f, 0x33,
409 0x34, 0x35, 0xe1, 0x31, 0x1d, 0x1b, 0x06, 0x19,
410 0x05, 0x11, 0x10, 0x36, 0x37, 0x38, 0xe5, 0x55,
411 0xe2, 0x2c, 0x32, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e,
412 0x3f, 0x40, 0x41, 0x42, 0x43, 0x53, 0x47, 0x5f,
413 0x60, 0x61, 0x56, 0x5c, 0x5d, 0x5e, 0x57, 0x59,
414 0x5a, 0x5b, 0x62, 0x63, 0x00, 0x00, 0x00, 0x44,
415 0x45, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e,
416 0xe8, 0xe9, 0x71, 0x72, 0x73, 0x00, 0x00, 0x00,
417 0x00, 0x00, 0x00, 0x85, 0x00, 0x00, 0x00, 0x00,
418 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
419 0x00, 0x00, 0x00, 0x00, 0x00, 0xe3, 0xe7, 0x65,
420
421 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
422 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
423 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
424 0x00, 0x00, 0x00, 0x00, 0x58, 0xe4, 0x00, 0x00,
425 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
426 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
427 0x00, 0x00, 0x00, 0x00, 0x00, 0x54, 0x00, 0x46,
428 0xe6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
429 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x00, 0x4a,
430 0x52, 0x4b, 0x00, 0x50, 0x00, 0x4f, 0x00, 0x4d,
431 0x51, 0x4e, 0x49, 0x4c, 0x00, 0x00, 0x00, 0x00,
432 0x00, 0x00, 0x00, 0xe3, 0xe7, 0x65, 0x00, 0x00,
433 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
434 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
435 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
436 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
437 };
438
439 static void usb_hid_changed(USBHIDState *hs)
440 {
441 hs->changed = 1;
442
443 if (hs->datain)
444 hs->datain(hs->datain_opaque);
445
446 usb_wakeup(&hs->dev);
447 }
448
449 static void usb_pointer_event_clear(USBPointerEvent *e, int buttons) {
450 e->xdx = e->ydy = e->dz = 0;
451 e->buttons_state = buttons;
452 }
453
454 static void usb_pointer_event_combine(USBPointerEvent *e, int xyrel,
455 int x1, int y1, int z1) {
456 if (xyrel) {
457 e->xdx += x1;
458 e->ydy += y1;
459 } else {
460 e->xdx = x1;
461 e->ydy = y1;
462 /* Windows drivers do not like the 0/0 position and ignore such
463 * events. */
464 if (!(x1 | y1)) {
465 x1 = 1;
466 }
467 }
468 e->dz += z1;
469 }
470
471 static void usb_pointer_event(void *opaque,
472 int x1, int y1, int z1, int buttons_state)
473 {
474 USBHIDState *hs = opaque;
475 USBMouseState *s = &hs->ptr;
476 unsigned use_slot = (hs->head + hs->n - 1) & QUEUE_MASK;
477 unsigned previous_slot = (use_slot - 1) & QUEUE_MASK;
478
479 /* We combine events where feasible to keep the queue small. We shouldn't
480 * combine anything with the first event of a particular button state, as
481 * that would change the location of the button state change. When the
482 * queue is empty, a second event is needed because we don't know if
483 * the first event changed the button state. */
484 if (hs->n == QUEUE_LENGTH) {
485 /* Queue full. Discard old button state, combine motion normally. */
486 s->queue[use_slot].buttons_state = buttons_state;
487 } else if (hs->n < 2 ||
488 s->queue[use_slot].buttons_state != buttons_state ||
489 s->queue[previous_slot].buttons_state != s->queue[use_slot].buttons_state) {
490 /* Cannot or should not combine, so add an empty item to the queue. */
491 QUEUE_INCR(use_slot);
492 hs->n++;
493 usb_pointer_event_clear(&s->queue[use_slot], buttons_state);
494 }
495 usb_pointer_event_combine(&s->queue[use_slot],
496 hs->kind == USB_MOUSE,
497 x1, y1, z1);
498 usb_hid_changed(hs);
499 }
500
501 static void usb_keyboard_event(void *opaque, int keycode)
502 {
503 USBHIDState *hs = opaque;
504 USBKeyboardState *s = &hs->kbd;
505 int slot;
506
507 if (hs->n == QUEUE_LENGTH) {
508 fprintf(stderr, "usb-kbd: warning: key event queue full\n");
509 return;
510 }
511 slot = (hs->head + hs->n) & QUEUE_MASK; hs->n++;
512 s->keycodes[slot] = keycode;
513 usb_hid_changed(hs);
514 }
515
516 static void usb_keyboard_process_keycode(USBHIDState *hs)
517 {
518 USBKeyboardState *s = &hs->kbd;
519 uint8_t hid_code, key;
520 int i, keycode, slot;
521
522 if (hs->n == 0) {
523 return;
524 }
525 slot = hs->head & QUEUE_MASK; QUEUE_INCR(hs->head); hs->n--;
526 keycode = s->keycodes[slot];
527
528 key = keycode & 0x7f;
529 hid_code = usb_hid_usage_keys[key | ((s->modifiers >> 1) & (1 << 7))];
530 s->modifiers &= ~(1 << 8);
531
532 switch (hid_code) {
533 case 0x00:
534 return;
535
536 case 0xe0:
537 if (s->modifiers & (1 << 9)) {
538 s->modifiers ^= 3 << 8;
539 return;
540 }
541 case 0xe1 ... 0xe7:
542 if (keycode & (1 << 7)) {
543 s->modifiers &= ~(1 << (hid_code & 0x0f));
544 return;
545 }
546 case 0xe8 ... 0xef:
547 s->modifiers |= 1 << (hid_code & 0x0f);
548 return;
549 }
550
551 if (keycode & (1 << 7)) {
552 for (i = s->keys - 1; i >= 0; i --)
553 if (s->key[i] == hid_code) {
554 s->key[i] = s->key[-- s->keys];
555 s->key[s->keys] = 0x00;
556 break;
557 }
558 if (i < 0)
559 return;
560 } else {
561 for (i = s->keys - 1; i >= 0; i --)
562 if (s->key[i] == hid_code)
563 break;
564 if (i < 0) {
565 if (s->keys < sizeof(s->key))
566 s->key[s->keys ++] = hid_code;
567 } else
568 return;
569 }
570 }
571
572 static inline int int_clamp(int val, int vmin, int vmax)
573 {
574 if (val < vmin)
575 return vmin;
576 else if (val > vmax)
577 return vmax;
578 else
579 return val;
580 }
581
582 static int usb_pointer_poll(USBHIDState *hs, uint8_t *buf, int len)
583 {
584 int dx, dy, dz, b, l;
585 int index;
586 USBMouseState *s = &hs->ptr;
587 USBPointerEvent *e;
588
589 if (!s->mouse_grabbed) {
590 qemu_activate_mouse_event_handler(s->eh_entry);
591 s->mouse_grabbed = 1;
592 }
593
594 /* When the buffer is empty, return the last event. Relative
595 movements will all be zero. */
596 index = (hs->n ? hs->head : hs->head - 1);
597 e = &s->queue[index & QUEUE_MASK];
598
599 if (hs->kind == USB_MOUSE) {
600 dx = int_clamp(e->xdx, -127, 127);
601 dy = int_clamp(e->ydy, -127, 127);
602 e->xdx -= dx;
603 e->ydy -= dy;
604 } else {
605 dx = e->xdx;
606 dy = e->ydy;
607 }
608 dz = int_clamp(e->dz, -127, 127);
609 e->dz -= dz;
610
611 b = 0;
612 if (e->buttons_state & MOUSE_EVENT_LBUTTON)
613 b |= 0x01;
614 if (e->buttons_state & MOUSE_EVENT_RBUTTON)
615 b |= 0x02;
616 if (e->buttons_state & MOUSE_EVENT_MBUTTON)
617 b |= 0x04;
618
619 if (hs->n &&
620 !e->dz &&
621 (hs->kind == USB_TABLET || (!e->xdx && !e->ydy))) {
622 /* that deals with this event */
623 QUEUE_INCR(hs->head);
624 hs->n--;
625 }
626
627 /* Appears we have to invert the wheel direction */
628 dz = 0 - dz;
629 l = 0;
630 switch (hs->kind) {
631 case USB_MOUSE:
632 if (len > l)
633 buf[l++] = b;
634 if (len > l)
635 buf[l++] = dx;
636 if (len > l)
637 buf[l++] = dy;
638 if (len > l)
639 buf[l++] = dz;
640 break;
641
642 case USB_TABLET:
643 if (len > l)
644 buf[l++] = b;
645 if (len > l)
646 buf[l++] = dx & 0xff;
647 if (len > l)
648 buf[l++] = dx >> 8;
649 if (len > l)
650 buf[l++] = dy & 0xff;
651 if (len > l)
652 buf[l++] = dy >> 8;
653 if (len > l)
654 buf[l++] = dz;
655 break;
656
657 default:
658 abort();
659 }
660
661 return l;
662 }
663
664 static int usb_keyboard_poll(USBHIDState *hs, uint8_t *buf, int len)
665 {
666 USBKeyboardState *s = &hs->kbd;
667 if (len < 2)
668 return 0;
669
670 usb_keyboard_process_keycode(hs);
671
672 buf[0] = s->modifiers & 0xff;
673 buf[1] = 0;
674 if (s->keys > 6)
675 memset(buf + 2, USB_HID_USAGE_ERROR_ROLLOVER, MIN(8, len) - 2);
676 else
677 memcpy(buf + 2, s->key, MIN(8, len) - 2);
678
679 return MIN(8, len);
680 }
681
682 static int usb_keyboard_write(USBKeyboardState *s, uint8_t *buf, int len)
683 {
684 if (len > 0) {
685 int ledstate = 0;
686 /* 0x01: Num Lock LED
687 * 0x02: Caps Lock LED
688 * 0x04: Scroll Lock LED
689 * 0x08: Compose LED
690 * 0x10: Kana LED */
691 s->leds = buf[0];
692 if (s->leds & 0x04)
693 ledstate |= QEMU_SCROLL_LOCK_LED;
694 if (s->leds & 0x01)
695 ledstate |= QEMU_NUM_LOCK_LED;
696 if (s->leds & 0x02)
697 ledstate |= QEMU_CAPS_LOCK_LED;
698 kbd_put_ledstate(ledstate);
699 }
700 return 0;
701 }
702
703 static void usb_mouse_handle_reset(USBDevice *dev)
704 {
705 USBHIDState *s = (USBHIDState *)dev;
706
707 memset(s->ptr.queue, 0, sizeof (s->ptr.queue));
708 s->head = 0;
709 s->n = 0;
710 s->protocol = 1;
711 }
712
713 static void usb_keyboard_handle_reset(USBDevice *dev)
714 {
715 USBHIDState *s = (USBHIDState *)dev;
716
717 qemu_add_kbd_event_handler(usb_keyboard_event, s);
718 memset(s->kbd.keycodes, 0, sizeof (s->kbd.keycodes));
719 s->head = 0;
720 s->n = 0;
721 memset(s->kbd.key, 0, sizeof (s->kbd.key));
722 s->kbd.keys = 0;
723 s->protocol = 1;
724 }
725
726 static void usb_hid_set_next_idle(USBHIDState *s, int64_t curtime)
727 {
728 s->next_idle_clock = curtime + (get_ticks_per_sec() * s->idle * 4) / 1000;
729 }
730
731 static int usb_hid_handle_control(USBDevice *dev, USBPacket *p,
732 int request, int value, int index, int length, uint8_t *data)
733 {
734 USBHIDState *s = (USBHIDState *)dev;
735 int ret;
736
737 ret = usb_desc_handle_control(dev, p, request, value, index, length, data);
738 if (ret >= 0) {
739 return ret;
740 }
741
742 ret = 0;
743 switch(request) {
744 case DeviceRequest | USB_REQ_GET_INTERFACE:
745 data[0] = 0;
746 ret = 1;
747 break;
748 case DeviceOutRequest | USB_REQ_SET_INTERFACE:
749 ret = 0;
750 break;
751 /* hid specific requests */
752 case InterfaceRequest | USB_REQ_GET_DESCRIPTOR:
753 switch(value >> 8) {
754 case 0x22:
755 if (s->kind == USB_MOUSE) {
756 memcpy(data, qemu_mouse_hid_report_descriptor,
757 sizeof(qemu_mouse_hid_report_descriptor));
758 ret = sizeof(qemu_mouse_hid_report_descriptor);
759 } else if (s->kind == USB_TABLET) {
760 memcpy(data, qemu_tablet_hid_report_descriptor,
761 sizeof(qemu_tablet_hid_report_descriptor));
762 ret = sizeof(qemu_tablet_hid_report_descriptor);
763 } else if (s->kind == USB_KEYBOARD) {
764 memcpy(data, qemu_keyboard_hid_report_descriptor,
765 sizeof(qemu_keyboard_hid_report_descriptor));
766 ret = sizeof(qemu_keyboard_hid_report_descriptor);
767 }
768 break;
769 default:
770 goto fail;
771 }
772 break;
773 case GET_REPORT:
774 if (s->kind == USB_MOUSE || s->kind == USB_TABLET) {
775 ret = usb_pointer_poll(s, data, length);
776 } else if (s->kind == USB_KEYBOARD) {
777 ret = usb_keyboard_poll(s, data, length);
778 }
779 s->changed = s->n > 0;
780 break;
781 case SET_REPORT:
782 if (s->kind == USB_KEYBOARD)
783 ret = usb_keyboard_write(&s->kbd, data, length);
784 else
785 goto fail;
786 break;
787 case GET_PROTOCOL:
788 if (s->kind != USB_KEYBOARD && s->kind != USB_MOUSE)
789 goto fail;
790 ret = 1;
791 data[0] = s->protocol;
792 break;
793 case SET_PROTOCOL:
794 if (s->kind != USB_KEYBOARD && s->kind != USB_MOUSE)
795 goto fail;
796 ret = 0;
797 s->protocol = value;
798 break;
799 case GET_IDLE:
800 ret = 1;
801 data[0] = s->idle;
802 break;
803 case SET_IDLE:
804 s->idle = (uint8_t) (value >> 8);
805 usb_hid_set_next_idle(s, qemu_get_clock_ns(vm_clock));
806 ret = 0;
807 break;
808 default:
809 fail:
810 ret = USB_RET_STALL;
811 break;
812 }
813 return ret;
814 }
815
816 static int usb_hid_handle_data(USBDevice *dev, USBPacket *p)
817 {
818 USBHIDState *s = (USBHIDState *)dev;
819 int ret = 0;
820
821 switch(p->pid) {
822 case USB_TOKEN_IN:
823 if (p->devep == 1) {
824 int64_t curtime = qemu_get_clock_ns(vm_clock);
825 if (!s->changed && (!s->idle || s->next_idle_clock - curtime > 0))
826 return USB_RET_NAK;
827 usb_hid_set_next_idle(s, curtime);
828 if (s->kind == USB_MOUSE || s->kind == USB_TABLET) {
829 ret = usb_pointer_poll(s, p->data, p->len);
830 }
831 else if (s->kind == USB_KEYBOARD) {
832 ret = usb_keyboard_poll(s, p->data, p->len);
833 }
834 s->changed = s->n > 0;
835 } else {
836 goto fail;
837 }
838 break;
839 case USB_TOKEN_OUT:
840 default:
841 fail:
842 ret = USB_RET_STALL;
843 break;
844 }
845 return ret;
846 }
847
848 static void usb_hid_handle_destroy(USBDevice *dev)
849 {
850 USBHIDState *s = (USBHIDState *)dev;
851
852 switch(s->kind) {
853 case USB_KEYBOARD:
854 qemu_remove_kbd_event_handler();
855 break;
856 default:
857 qemu_remove_mouse_event_handler(s->ptr.eh_entry);
858 }
859 }
860
861 static int usb_hid_initfn(USBDevice *dev, int kind)
862 {
863 USBHIDState *s = DO_UPCAST(USBHIDState, dev, dev);
864
865 usb_desc_init(dev);
866 s->kind = kind;
867
868 if (s->kind == USB_MOUSE) {
869 s->ptr.eh_entry = qemu_add_mouse_event_handler(usb_pointer_event, s,
870 0, "QEMU USB Mouse");
871 } else if (s->kind == USB_TABLET) {
872 s->ptr.eh_entry = qemu_add_mouse_event_handler(usb_pointer_event, s,
873 1, "QEMU USB Tablet");
874 }
875
876 /* Force poll routine to be run and grab input the first time. */
877 s->changed = 1;
878 return 0;
879 }
880
881 static int usb_tablet_initfn(USBDevice *dev)
882 {
883 return usb_hid_initfn(dev, USB_TABLET);
884 }
885
886 static int usb_mouse_initfn(USBDevice *dev)
887 {
888 return usb_hid_initfn(dev, USB_MOUSE);
889 }
890
891 static int usb_keyboard_initfn(USBDevice *dev)
892 {
893 return usb_hid_initfn(dev, USB_KEYBOARD);
894 }
895
896 void usb_hid_datain_cb(USBDevice *dev, void *opaque, void (*datain)(void *))
897 {
898 USBHIDState *s = (USBHIDState *)dev;
899
900 s->datain_opaque = opaque;
901 s->datain = datain;
902 }
903
904 static int usb_hid_post_load(void *opaque, int version_id)
905 {
906 USBHIDState *s = opaque;
907
908 if (s->idle) {
909 usb_hid_set_next_idle(s, qemu_get_clock_ns(vm_clock));
910 }
911 return 0;
912 }
913
914 static const VMStateDescription vmstate_usb_ptr_queue = {
915 .name = "usb-ptr-queue",
916 .version_id = 1,
917 .minimum_version_id = 1,
918 .fields = (VMStateField []) {
919 VMSTATE_INT32(xdx, USBPointerEvent),
920 VMSTATE_INT32(ydy, USBPointerEvent),
921 VMSTATE_INT32(dz, USBPointerEvent),
922 VMSTATE_INT32(buttons_state, USBPointerEvent),
923 VMSTATE_END_OF_LIST()
924 }
925 };
926 static const VMStateDescription vmstate_usb_ptr = {
927 .name = "usb-ptr",
928 .version_id = 1,
929 .minimum_version_id = 1,
930 .post_load = usb_hid_post_load,
931 .fields = (VMStateField []) {
932 VMSTATE_USB_DEVICE(dev, USBHIDState),
933 VMSTATE_STRUCT_ARRAY(ptr.queue, USBHIDState, QUEUE_LENGTH, 0,
934 vmstate_usb_ptr_queue, USBPointerEvent),
935 VMSTATE_UINT32(head, USBHIDState),
936 VMSTATE_UINT32(n, USBHIDState),
937 VMSTATE_INT32(protocol, USBHIDState),
938 VMSTATE_UINT8(idle, USBHIDState),
939 VMSTATE_END_OF_LIST()
940 }
941 };
942
943 static const VMStateDescription vmstate_usb_kbd = {
944 .name = "usb-kbd",
945 .version_id = 1,
946 .minimum_version_id = 1,
947 .post_load = usb_hid_post_load,
948 .fields = (VMStateField []) {
949 VMSTATE_USB_DEVICE(dev, USBHIDState),
950 VMSTATE_UINT32_ARRAY(kbd.keycodes, USBHIDState, QUEUE_LENGTH),
951 VMSTATE_UINT32(head, USBHIDState),
952 VMSTATE_UINT32(n, USBHIDState),
953 VMSTATE_UINT16(kbd.modifiers, USBHIDState),
954 VMSTATE_UINT8(kbd.leds, USBHIDState),
955 VMSTATE_UINT8_ARRAY(kbd.key, USBHIDState, 16),
956 VMSTATE_INT32(kbd.keys, USBHIDState),
957 VMSTATE_INT32(protocol, USBHIDState),
958 VMSTATE_UINT8(idle, USBHIDState),
959 VMSTATE_END_OF_LIST()
960 }
961 };
962
963 static struct USBDeviceInfo hid_info[] = {
964 {
965 .product_desc = "QEMU USB Tablet",
966 .qdev.name = "usb-tablet",
967 .usbdevice_name = "tablet",
968 .qdev.size = sizeof(USBHIDState),
969 .qdev.vmsd = &vmstate_usb_ptr,
970 .usb_desc = &desc_tablet,
971 .init = usb_tablet_initfn,
972 .handle_packet = usb_generic_handle_packet,
973 .handle_reset = usb_mouse_handle_reset,
974 .handle_control = usb_hid_handle_control,
975 .handle_data = usb_hid_handle_data,
976 .handle_destroy = usb_hid_handle_destroy,
977 },{
978 .product_desc = "QEMU USB Mouse",
979 .qdev.name = "usb-mouse",
980 .usbdevice_name = "mouse",
981 .qdev.size = sizeof(USBHIDState),
982 .qdev.vmsd = &vmstate_usb_ptr,
983 .usb_desc = &desc_mouse,
984 .init = usb_mouse_initfn,
985 .handle_packet = usb_generic_handle_packet,
986 .handle_reset = usb_mouse_handle_reset,
987 .handle_control = usb_hid_handle_control,
988 .handle_data = usb_hid_handle_data,
989 .handle_destroy = usb_hid_handle_destroy,
990 },{
991 .product_desc = "QEMU USB Keyboard",
992 .qdev.name = "usb-kbd",
993 .usbdevice_name = "keyboard",
994 .qdev.size = sizeof(USBHIDState),
995 .qdev.vmsd = &vmstate_usb_kbd,
996 .usb_desc = &desc_keyboard,
997 .init = usb_keyboard_initfn,
998 .handle_packet = usb_generic_handle_packet,
999 .handle_reset = usb_keyboard_handle_reset,
1000 .handle_control = usb_hid_handle_control,
1001 .handle_data = usb_hid_handle_data,
1002 .handle_destroy = usb_hid_handle_destroy,
1003 },{
1004 /* end of list */
1005 }
1006 };
1007
1008 static void usb_hid_register_devices(void)
1009 {
1010 usb_qdev_register_many(hid_info);
1011 }
1012 device_init(usb_hid_register_devices)
QEmu