?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge remote-tracking branch 'amit/for-anthony' into staging
[qemu.git] / hw / usb-hid.c
blobd711b5c0be3690d2a6d921a5a753b066b26a2b87
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 }
463 e->dz += z1;
464 }
465
466 static void usb_pointer_event(void *opaque,
467 int x1, int y1, int z1, int buttons_state)
468 {
469 USBHIDState *hs = opaque;
470 USBMouseState *s = &hs->ptr;
471 unsigned use_slot = (hs->head + hs->n - 1) & QUEUE_MASK;
472 unsigned previous_slot = (use_slot - 1) & QUEUE_MASK;
473
474 /* We combine events where feasible to keep the queue small. We shouldn't
475 * combine anything with the first event of a particular button state, as
476 * that would change the location of the button state change. When the
477 * queue is empty, a second event is needed because we don't know if
478 * the first event changed the button state. */
479 if (hs->n == QUEUE_LENGTH) {
480 /* Queue full. Discard old button state, combine motion normally. */
481 s->queue[use_slot].buttons_state = buttons_state;
482 } else if (hs->n < 2 ||
483 s->queue[use_slot].buttons_state != buttons_state ||
484 s->queue[previous_slot].buttons_state != s->queue[use_slot].buttons_state) {
485 /* Cannot or should not combine, so add an empty item to the queue. */
486 QUEUE_INCR(use_slot);
487 hs->n++;
488 usb_pointer_event_clear(&s->queue[use_slot], buttons_state);
489 }
490 usb_pointer_event_combine(&s->queue[use_slot],
491 hs->kind == USB_MOUSE,
492 x1, y1, z1);
493 usb_hid_changed(hs);
494 }
495
496 static void usb_keyboard_event(void *opaque, int keycode)
497 {
498 USBHIDState *hs = opaque;
499 USBKeyboardState *s = &hs->kbd;
500 int slot;
501
502 if (hs->n == QUEUE_LENGTH) {
503 fprintf(stderr, "usb-kbd: warning: key event queue full\n");
504 return;
505 }
506 slot = (hs->head + hs->n) & QUEUE_MASK; hs->n++;
507 s->keycodes[slot] = keycode;
508 usb_hid_changed(hs);
509 }
510
511 static void usb_keyboard_process_keycode(USBHIDState *hs)
512 {
513 USBKeyboardState *s = &hs->kbd;
514 uint8_t hid_code, key;
515 int i, keycode, slot;
516
517 if (hs->n == 0) {
518 return;
519 }
520 slot = hs->head & QUEUE_MASK; QUEUE_INCR(hs->head); hs->n--;
521 keycode = s->keycodes[slot];
522
523 key = keycode & 0x7f;
524 hid_code = usb_hid_usage_keys[key | ((s->modifiers >> 1) & (1 << 7))];
525 s->modifiers &= ~(1 << 8);
526
527 switch (hid_code) {
528 case 0x00:
529 return;
530
531 case 0xe0:
532 if (s->modifiers & (1 << 9)) {
533 s->modifiers ^= 3 << 8;
534 usb_hid_changed(hs);
535 return;
536 }
537 case 0xe1 ... 0xe7:
538 if (keycode & (1 << 7)) {
539 s->modifiers &= ~(1 << (hid_code & 0x0f));
540 usb_hid_changed(hs);
541 return;
542 }
543 case 0xe8 ... 0xef:
544 s->modifiers |= 1 << (hid_code & 0x0f);
545 usb_hid_changed(hs);
546 return;
547 }
548
549 if (keycode & (1 << 7)) {
550 for (i = s->keys - 1; i >= 0; i --)
551 if (s->key[i] == hid_code) {
552 s->key[i] = s->key[-- s->keys];
553 s->key[s->keys] = 0x00;
554 break;
555 }
556 if (i < 0)
557 return;
558 } else {
559 for (i = s->keys - 1; i >= 0; i --)
560 if (s->key[i] == hid_code)
561 break;
562 if (i < 0) {
563 if (s->keys < sizeof(s->key))
564 s->key[s->keys ++] = hid_code;
565 } else
566 return;
567 }
568 }
569
570 static inline int int_clamp(int val, int vmin, int vmax)
571 {
572 if (val < vmin)
573 return vmin;
574 else if (val > vmax)
575 return vmax;
576 else
577 return val;
578 }
579
580 static int usb_pointer_poll(USBHIDState *hs, uint8_t *buf, int len)
581 {
582 int dx, dy, dz, b, l;
583 int index;
584 USBMouseState *s = &hs->ptr;
585 USBPointerEvent *e;
586
587 if (!s->mouse_grabbed) {
588 qemu_activate_mouse_event_handler(s->eh_entry);
589 s->mouse_grabbed = 1;
590 }
591
592 /* When the buffer is empty, return the last event. Relative
593 movements will all be zero. */
594 index = (hs->n ? hs->head : hs->head - 1);
595 e = &s->queue[index & QUEUE_MASK];
596
597 if (hs->kind == USB_MOUSE) {
598 dx = int_clamp(e->xdx, -127, 127);
599 dy = int_clamp(e->ydy, -127, 127);
600 e->xdx -= dx;
601 e->ydy -= dy;
602 } else {
603 dx = e->xdx;
604 dy = e->ydy;
605 }
606 dz = int_clamp(e->dz, -127, 127);
607 e->dz -= dz;
608
609 b = 0;
610 if (e->buttons_state & MOUSE_EVENT_LBUTTON)
611 b |= 0x01;
612 if (e->buttons_state & MOUSE_EVENT_RBUTTON)
613 b |= 0x02;
614 if (e->buttons_state & MOUSE_EVENT_MBUTTON)
615 b |= 0x04;
616
617 if (hs->n &&
618 !e->dz &&
619 (hs->kind == USB_TABLET || (!e->xdx && !e->ydy))) {
620 /* that deals with this event */
621 QUEUE_INCR(hs->head);
622 hs->n--;
623 }
624
625 /* Appears we have to invert the wheel direction */
626 dz = 0 - dz;
627 l = 0;
628 switch (hs->kind) {
629 case USB_MOUSE:
630 if (len > l)
631 buf[l++] = b;
632 if (len > l)
633 buf[l++] = dx;
634 if (len > l)
635 buf[l++] = dy;
636 if (len > l)
637 buf[l++] = dz;
638 break;
639
640 case USB_TABLET:
641 if (len > l)
642 buf[l++] = b;
643 if (len > l)
644 buf[l++] = dx & 0xff;
645 if (len > l)
646 buf[l++] = dx >> 8;
647 if (len > l)
648 buf[l++] = dy & 0xff;
649 if (len > l)
650 buf[l++] = dy >> 8;
651 if (len > l)
652 buf[l++] = dz;
653 break;
654
655 default:
656 abort();
657 }
658
659 return l;
660 }
661
662 static int usb_keyboard_poll(USBHIDState *hs, uint8_t *buf, int len)
663 {
664 USBKeyboardState *s = &hs->kbd;
665 if (len < 2)
666 return 0;
667
668 usb_keyboard_process_keycode(hs);
669
670 buf[0] = s->modifiers & 0xff;
671 buf[1] = 0;
672 if (s->keys > 6)
673 memset(buf + 2, USB_HID_USAGE_ERROR_ROLLOVER, MIN(8, len) - 2);
674 else
675 memcpy(buf + 2, s->key, MIN(8, len) - 2);
676
677 return MIN(8, len);
678 }
679
680 static int usb_keyboard_write(USBKeyboardState *s, uint8_t *buf, int len)
681 {
682 if (len > 0) {
683 int ledstate = 0;
684 /* 0x01: Num Lock LED
685 * 0x02: Caps Lock LED
686 * 0x04: Scroll Lock LED
687 * 0x08: Compose LED
688 * 0x10: Kana LED */
689 s->leds = buf[0];
690 if (s->leds & 0x04)
691 ledstate |= QEMU_SCROLL_LOCK_LED;
692 if (s->leds & 0x01)
693 ledstate |= QEMU_NUM_LOCK_LED;
694 if (s->leds & 0x02)
695 ledstate |= QEMU_CAPS_LOCK_LED;
696 kbd_put_ledstate(ledstate);
697 }
698 return 0;
699 }
700
701 static void usb_mouse_handle_reset(USBDevice *dev)
702 {
703 USBHIDState *s = (USBHIDState *)dev;
704
705 memset(s->ptr.queue, 0, sizeof (s->ptr.queue));
706 s->head = 0;
707 s->n = 0;
708 s->protocol = 1;
709 }
710
711 static void usb_keyboard_handle_reset(USBDevice *dev)
712 {
713 USBHIDState *s = (USBHIDState *)dev;
714
715 qemu_add_kbd_event_handler(usb_keyboard_event, s);
716 memset(s->kbd.keycodes, 0, sizeof (s->kbd.keycodes));
717 s->head = 0;
718 s->n = 0;
719 memset(s->kbd.key, 0, sizeof (s->kbd.key));
720 s->kbd.keys = 0;
721 s->protocol = 1;
722 }
723
724 static void usb_hid_set_next_idle(USBHIDState *s, int64_t curtime)
725 {
726 s->next_idle_clock = curtime + (get_ticks_per_sec() * s->idle * 4) / 1000;
727 }
728
729 static int usb_hid_handle_control(USBDevice *dev, USBPacket *p,
730 int request, int value, int index, int length, uint8_t *data)
731 {
732 USBHIDState *s = (USBHIDState *)dev;
733 int ret;
734
735 ret = usb_desc_handle_control(dev, p, request, value, index, length, data);
736 if (ret >= 0) {
737 return ret;
738 }
739
740 ret = 0;
741 switch(request) {
742 case DeviceRequest | USB_REQ_GET_INTERFACE:
743 data[0] = 0;
744 ret = 1;
745 break;
746 case DeviceOutRequest | USB_REQ_SET_INTERFACE:
747 ret = 0;
748 break;
749 /* hid specific requests */
750 case InterfaceRequest | USB_REQ_GET_DESCRIPTOR:
751 switch(value >> 8) {
752 case 0x22:
753 if (s->kind == USB_MOUSE) {
754 memcpy(data, qemu_mouse_hid_report_descriptor,
755 sizeof(qemu_mouse_hid_report_descriptor));
756 ret = sizeof(qemu_mouse_hid_report_descriptor);
757 } else if (s->kind == USB_TABLET) {
758 memcpy(data, qemu_tablet_hid_report_descriptor,
759 sizeof(qemu_tablet_hid_report_descriptor));
760 ret = sizeof(qemu_tablet_hid_report_descriptor);
761 } else if (s->kind == USB_KEYBOARD) {
762 memcpy(data, qemu_keyboard_hid_report_descriptor,
763 sizeof(qemu_keyboard_hid_report_descriptor));
764 ret = sizeof(qemu_keyboard_hid_report_descriptor);
765 }
766 break;
767 default:
768 goto fail;
769 }
770 break;
771 case GET_REPORT:
772 if (s->kind == USB_MOUSE || s->kind == USB_TABLET)
773 ret = usb_pointer_poll(s, data, length);
774 else if (s->kind == USB_KEYBOARD)
775 ret = usb_keyboard_poll(s, data, length);
776 break;
777 case SET_REPORT:
778 if (s->kind == USB_KEYBOARD)
779 ret = usb_keyboard_write(&s->kbd, data, length);
780 else
781 goto fail;
782 break;
783 case GET_PROTOCOL:
784 if (s->kind != USB_KEYBOARD && s->kind != USB_MOUSE)
785 goto fail;
786 ret = 1;
787 data[0] = s->protocol;
788 break;
789 case SET_PROTOCOL:
790 if (s->kind != USB_KEYBOARD && s->kind != USB_MOUSE)
791 goto fail;
792 ret = 0;
793 s->protocol = value;
794 break;
795 case GET_IDLE:
796 ret = 1;
797 data[0] = s->idle;
798 break;
799 case SET_IDLE:
800 s->idle = (uint8_t) (value >> 8);
801 usb_hid_set_next_idle(s, qemu_get_clock_ns(vm_clock));
802 ret = 0;
803 break;
804 default:
805 fail:
806 ret = USB_RET_STALL;
807 break;
808 }
809 return ret;
810 }
811
812 static int usb_hid_handle_data(USBDevice *dev, USBPacket *p)
813 {
814 USBHIDState *s = (USBHIDState *)dev;
815 int ret = 0;
816
817 switch(p->pid) {
818 case USB_TOKEN_IN:
819 if (p->devep == 1) {
820 int64_t curtime = qemu_get_clock_ns(vm_clock);
821 if (!s->changed && (!s->idle || s->next_idle_clock - curtime > 0))
822 return USB_RET_NAK;
823 usb_hid_set_next_idle(s, curtime);
824 if (s->kind == USB_MOUSE || s->kind == USB_TABLET) {
825 ret = usb_pointer_poll(s, p->data, p->len);
826 }
827 else if (s->kind == USB_KEYBOARD) {
828 ret = usb_keyboard_poll(s, p->data, p->len);
829 }
830 s->changed = s->n > 0;
831 } else {
832 goto fail;
833 }
834 break;
835 case USB_TOKEN_OUT:
836 default:
837 fail:
838 ret = USB_RET_STALL;
839 break;
840 }
841 return ret;
842 }
843
844 static void usb_hid_handle_destroy(USBDevice *dev)
845 {
846 USBHIDState *s = (USBHIDState *)dev;
847
848 switch(s->kind) {
849 case USB_KEYBOARD:
850 qemu_remove_kbd_event_handler();
851 break;
852 default:
853 qemu_remove_mouse_event_handler(s->ptr.eh_entry);
854 }
855 }
856
857 static int usb_hid_initfn(USBDevice *dev, int kind)
858 {
859 USBHIDState *s = DO_UPCAST(USBHIDState, dev, dev);
860
861 usb_desc_init(dev);
862 s->kind = kind;
863
864 if (s->kind == USB_MOUSE) {
865 s->ptr.eh_entry = qemu_add_mouse_event_handler(usb_pointer_event, s,
866 0, "QEMU USB Mouse");
867 } else if (s->kind == USB_TABLET) {
868 s->ptr.eh_entry = qemu_add_mouse_event_handler(usb_pointer_event, s,
869 1, "QEMU USB Tablet");
870 }
871
872 /* Force poll routine to be run and grab input the first time. */
873 s->changed = 1;
874 return 0;
875 }
876
877 static int usb_tablet_initfn(USBDevice *dev)
878 {
879 return usb_hid_initfn(dev, USB_TABLET);
880 }
881
882 static int usb_mouse_initfn(USBDevice *dev)
883 {
884 return usb_hid_initfn(dev, USB_MOUSE);
885 }
886
887 static int usb_keyboard_initfn(USBDevice *dev)
888 {
889 return usb_hid_initfn(dev, USB_KEYBOARD);
890 }
891
892 void usb_hid_datain_cb(USBDevice *dev, void *opaque, void (*datain)(void *))
893 {
894 USBHIDState *s = (USBHIDState *)dev;
895
896 s->datain_opaque = opaque;
897 s->datain = datain;
898 }
899
900 static int usb_hid_post_load(void *opaque, int version_id)
901 {
902 USBHIDState *s = opaque;
903
904 if (s->idle) {
905 usb_hid_set_next_idle(s, qemu_get_clock_ns(vm_clock));
906 }
907 return 0;
908 }
909
910 static const VMStateDescription vmstate_usb_ptr_queue = {
911 .name = "usb-ptr-queue",
912 .version_id = 1,
913 .minimum_version_id = 1,
914 .fields = (VMStateField []) {
915 VMSTATE_INT32(xdx, USBPointerEvent),
916 VMSTATE_INT32(ydy, USBPointerEvent),
917 VMSTATE_INT32(dz, USBPointerEvent),
918 VMSTATE_INT32(buttons_state, USBPointerEvent),
919 VMSTATE_END_OF_LIST()
920 }
921 };
922 static const VMStateDescription vmstate_usb_ptr = {
923 .name = "usb-ptr",
924 .version_id = 1,
925 .minimum_version_id = 1,
926 .post_load = usb_hid_post_load,
927 .fields = (VMStateField []) {
928 VMSTATE_USB_DEVICE(dev, USBHIDState),
929 VMSTATE_STRUCT_ARRAY(ptr.queue, USBHIDState, QUEUE_LENGTH, 0,
930 vmstate_usb_ptr_queue, USBPointerEvent),
931 VMSTATE_UINT32(head, USBHIDState),
932 VMSTATE_UINT32(n, USBHIDState),
933 VMSTATE_INT32(protocol, USBHIDState),
934 VMSTATE_UINT8(idle, USBHIDState),
935 VMSTATE_END_OF_LIST()
936 }
937 };
938
939 static const VMStateDescription vmstate_usb_kbd = {
940 .name = "usb-kbd",
941 .version_id = 1,
942 .minimum_version_id = 1,
943 .post_load = usb_hid_post_load,
944 .fields = (VMStateField []) {
945 VMSTATE_USB_DEVICE(dev, USBHIDState),
946 VMSTATE_UINT32_ARRAY(kbd.keycodes, USBHIDState, QUEUE_LENGTH),
947 VMSTATE_UINT32(head, USBHIDState),
948 VMSTATE_UINT32(n, USBHIDState),
949 VMSTATE_UINT16(kbd.modifiers, USBHIDState),
950 VMSTATE_UINT8(kbd.leds, USBHIDState),
951 VMSTATE_UINT8_ARRAY(kbd.key, USBHIDState, 16),
952 VMSTATE_INT32(kbd.keys, USBHIDState),
953 VMSTATE_INT32(protocol, USBHIDState),
954 VMSTATE_UINT8(idle, USBHIDState),
955 VMSTATE_END_OF_LIST()
956 }
957 };
958
959 static struct USBDeviceInfo hid_info[] = {
960 {
961 .product_desc = "QEMU USB Tablet",
962 .qdev.name = "usb-tablet",
963 .usbdevice_name = "tablet",
964 .qdev.size = sizeof(USBHIDState),
965 .qdev.vmsd = &vmstate_usb_ptr,
966 .usb_desc = &desc_tablet,
967 .init = usb_tablet_initfn,
968 .handle_packet = usb_generic_handle_packet,
969 .handle_reset = usb_mouse_handle_reset,
970 .handle_control = usb_hid_handle_control,
971 .handle_data = usb_hid_handle_data,
972 .handle_destroy = usb_hid_handle_destroy,
973 },{
974 .product_desc = "QEMU USB Mouse",
975 .qdev.name = "usb-mouse",
976 .usbdevice_name = "mouse",
977 .qdev.size = sizeof(USBHIDState),
978 .qdev.vmsd = &vmstate_usb_ptr,
979 .usb_desc = &desc_mouse,
980 .init = usb_mouse_initfn,
981 .handle_packet = usb_generic_handle_packet,
982 .handle_reset = usb_mouse_handle_reset,
983 .handle_control = usb_hid_handle_control,
984 .handle_data = usb_hid_handle_data,
985 .handle_destroy = usb_hid_handle_destroy,
986 },{
987 .product_desc = "QEMU USB Keyboard",
988 .qdev.name = "usb-kbd",
989 .usbdevice_name = "keyboard",
990 .qdev.size = sizeof(USBHIDState),
991 .qdev.vmsd = &vmstate_usb_kbd,
992 .usb_desc = &desc_keyboard,
993 .init = usb_keyboard_initfn,
994 .handle_packet = usb_generic_handle_packet,
995 .handle_reset = usb_keyboard_handle_reset,
996 .handle_control = usb_hid_handle_control,
997 .handle_data = usb_hid_handle_data,
998 .handle_destroy = usb_hid_handle_destroy,
999 },{
1000 /* end of list */
1001 }
1002 };
1003
1004 static void usb_hid_register_devices(void)
1005 {
1006 usb_qdev_register_many(hid_info);
1007 }
1008 device_init(usb_hid_register_devices)
QEmu