]> git.proxmox.com Git - qemu.git/blob - hw/usb-hid.c
projects / qemu.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
add event queueing to USB HID
[qemu.git] / hw / usb-hid.c
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 "sysemu.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 uint32_t head; /* index into circular queue */
60 uint32_t n;
61 int mouse_grabbed;
62 QEMUPutMouseEntry *eh_entry;
63 } USBMouseState;
64
65 typedef struct USBKeyboardState {
66 uint16_t modifiers;
67 uint8_t leds;
68 uint8_t key[16];
69 int keys;
70 } USBKeyboardState;
71
72 typedef struct USBHIDState {
73 USBDevice dev;
74 union {
75 USBMouseState ptr;
76 USBKeyboardState kbd;
77 };
78 int kind;
79 int protocol;
80 uint8_t idle;
81 int64_t next_idle_clock;
82 int changed;
83 void *datain_opaque;
84 void (*datain)(void *);
85 } USBHIDState;
86
87 enum {
88 STR_MANUFACTURER = 1,
89 STR_PRODUCT_MOUSE,
90 STR_PRODUCT_TABLET,
91 STR_PRODUCT_KEYBOARD,
92 STR_SERIALNUMBER,
93 STR_CONFIG_MOUSE,
94 STR_CONFIG_TABLET,
95 STR_CONFIG_KEYBOARD,
96 };
97
98 static const USBDescStrings desc_strings = {
99 [STR_MANUFACTURER] = "QEMU " QEMU_VERSION,
100 [STR_PRODUCT_MOUSE] = "QEMU USB Mouse",
101 [STR_PRODUCT_TABLET] = "QEMU USB Tablet",
102 [STR_PRODUCT_KEYBOARD] = "QEMU USB Keyboard",
103 [STR_SERIALNUMBER] = "42", /* == remote wakeup works */
104 [STR_CONFIG_MOUSE] = "HID Mouse",
105 [STR_CONFIG_TABLET] = "HID Tablet",
106 [STR_CONFIG_KEYBOARD] = "HID Keyboard",
107 };
108
109 static const USBDescIface desc_iface_mouse = {
110 .bInterfaceNumber = 0,
111 .bNumEndpoints = 1,
112 .bInterfaceClass = USB_CLASS_HID,
113 .bInterfaceSubClass = 0x01, /* boot */
114 .bInterfaceProtocol = 0x02,
115 .ndesc = 1,
116 .descs = (USBDescOther[]) {
117 {
118 /* HID descriptor */
119 .data = (uint8_t[]) {
120 0x09, /* u8 bLength */
121 USB_DT_HID, /* u8 bDescriptorType */
122 0x01, 0x00, /* u16 HID_class */
123 0x00, /* u8 country_code */
124 0x01, /* u8 num_descriptors */
125 USB_DT_REPORT, /* u8 type: Report */
126 52, 0, /* u16 len */
127 },
128 },
129 },
130 .eps = (USBDescEndpoint[]) {
131 {
132 .bEndpointAddress = USB_DIR_IN | 0x01,
133 .bmAttributes = USB_ENDPOINT_XFER_INT,
134 .wMaxPacketSize = 4,
135 .bInterval = 0x0a,
136 },
137 },
138 };
139
140 static const USBDescIface desc_iface_tablet = {
141 .bInterfaceNumber = 0,
142 .bNumEndpoints = 1,
143 .bInterfaceClass = USB_CLASS_HID,
144 .bInterfaceSubClass = 0x01, /* boot */
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 .ifs = &desc_iface_mouse,
214 },
215 },
216 };
217
218 static const USBDescDevice desc_device_tablet = {
219 .bcdUSB = 0x0100,
220 .bMaxPacketSize0 = 8,
221 .bNumConfigurations = 1,
222 .confs = (USBDescConfig[]) {
223 {
224 .bNumInterfaces = 1,
225 .bConfigurationValue = 1,
226 .iConfiguration = STR_CONFIG_TABLET,
227 .bmAttributes = 0xa0,
228 .bMaxPower = 50,
229 .ifs = &desc_iface_tablet,
230 },
231 },
232 };
233
234 static const USBDescDevice desc_device_keyboard = {
235 .bcdUSB = 0x0100,
236 .bMaxPacketSize0 = 8,
237 .bNumConfigurations = 1,
238 .confs = (USBDescConfig[]) {
239 {
240 .bNumInterfaces = 1,
241 .bConfigurationValue = 1,
242 .iConfiguration = STR_CONFIG_KEYBOARD,
243 .bmAttributes = 0xa0,
244 .bMaxPower = 50,
245 .ifs = &desc_iface_keyboard,
246 },
247 },
248 };
249
250 static const USBDesc desc_mouse = {
251 .id = {
252 .idVendor = 0x0627,
253 .idProduct = 0x0001,
254 .bcdDevice = 0,
255 .iManufacturer = STR_MANUFACTURER,
256 .iProduct = STR_PRODUCT_MOUSE,
257 .iSerialNumber = STR_SERIALNUMBER,
258 },
259 .full = &desc_device_mouse,
260 .str = desc_strings,
261 };
262
263 static const USBDesc desc_tablet = {
264 .id = {
265 .idVendor = 0x0627,
266 .idProduct = 0x0001,
267 .bcdDevice = 0,
268 .iManufacturer = STR_MANUFACTURER,
269 .iProduct = STR_PRODUCT_TABLET,
270 .iSerialNumber = STR_SERIALNUMBER,
271 },
272 .full = &desc_device_tablet,
273 .str = desc_strings,
274 };
275
276 static const USBDesc desc_keyboard = {
277 .id = {
278 .idVendor = 0x0627,
279 .idProduct = 0x0001,
280 .bcdDevice = 0,
281 .iManufacturer = STR_MANUFACTURER,
282 .iProduct = STR_PRODUCT_KEYBOARD,
283 .iSerialNumber = STR_SERIALNUMBER,
284 },
285 .full = &desc_device_keyboard,
286 .str = desc_strings,
287 };
288
289 static const uint8_t qemu_mouse_hid_report_descriptor[] = {
290 0x05, 0x01, /* Usage Page (Generic Desktop) */
291 0x09, 0x02, /* Usage (Mouse) */
292 0xa1, 0x01, /* Collection (Application) */
293 0x09, 0x01, /* Usage (Pointer) */
294 0xa1, 0x00, /* Collection (Physical) */
295 0x05, 0x09, /* Usage Page (Button) */
296 0x19, 0x01, /* Usage Minimum (1) */
297 0x29, 0x03, /* Usage Maximum (3) */
298 0x15, 0x00, /* Logical Minimum (0) */
299 0x25, 0x01, /* Logical Maximum (1) */
300 0x95, 0x03, /* Report Count (3) */
301 0x75, 0x01, /* Report Size (1) */
302 0x81, 0x02, /* Input (Data, Variable, Absolute) */
303 0x95, 0x01, /* Report Count (1) */
304 0x75, 0x05, /* Report Size (5) */
305 0x81, 0x01, /* Input (Constant) */
306 0x05, 0x01, /* Usage Page (Generic Desktop) */
307 0x09, 0x30, /* Usage (X) */
308 0x09, 0x31, /* Usage (Y) */
309 0x09, 0x38, /* Usage (Wheel) */
310 0x15, 0x81, /* Logical Minimum (-0x7f) */
311 0x25, 0x7f, /* Logical Maximum (0x7f) */
312 0x75, 0x08, /* Report Size (8) */
313 0x95, 0x03, /* Report Count (3) */
314 0x81, 0x06, /* Input (Data, Variable, Relative) */
315 0xc0, /* End Collection */
316 0xc0, /* End Collection */
317 };
318
319 static const uint8_t qemu_tablet_hid_report_descriptor[] = {
320 0x05, 0x01, /* Usage Page (Generic Desktop) */
321 0x09, 0x01, /* Usage (Pointer) */
322 0xa1, 0x01, /* Collection (Application) */
323 0x09, 0x01, /* Usage (Pointer) */
324 0xa1, 0x00, /* Collection (Physical) */
325 0x05, 0x09, /* Usage Page (Button) */
326 0x19, 0x01, /* Usage Minimum (1) */
327 0x29, 0x03, /* Usage Maximum (3) */
328 0x15, 0x00, /* Logical Minimum (0) */
329 0x25, 0x01, /* Logical Maximum (1) */
330 0x95, 0x03, /* Report Count (3) */
331 0x75, 0x01, /* Report Size (1) */
332 0x81, 0x02, /* Input (Data, Variable, Absolute) */
333 0x95, 0x01, /* Report Count (1) */
334 0x75, 0x05, /* Report Size (5) */
335 0x81, 0x01, /* Input (Constant) */
336 0x05, 0x01, /* Usage Page (Generic Desktop) */
337 0x09, 0x30, /* Usage (X) */
338 0x09, 0x31, /* Usage (Y) */
339 0x15, 0x00, /* Logical Minimum (0) */
340 0x26, 0xff, 0x7f, /* Logical Maximum (0x7fff) */
341 0x35, 0x00, /* Physical Minimum (0) */
342 0x46, 0xff, 0x7f, /* Physical Maximum (0x7fff) */
343 0x75, 0x10, /* Report Size (16) */
344 0x95, 0x02, /* Report Count (2) */
345 0x81, 0x02, /* Input (Data, Variable, Absolute) */
346 0x05, 0x01, /* Usage Page (Generic Desktop) */
347 0x09, 0x38, /* Usage (Wheel) */
348 0x15, 0x81, /* Logical Minimum (-0x7f) */
349 0x25, 0x7f, /* Logical Maximum (0x7f) */
350 0x35, 0x00, /* Physical Minimum (same as logical) */
351 0x45, 0x00, /* Physical Maximum (same as logical) */
352 0x75, 0x08, /* Report Size (8) */
353 0x95, 0x01, /* Report Count (1) */
354 0x81, 0x06, /* Input (Data, Variable, Relative) */
355 0xc0, /* End Collection */
356 0xc0, /* End Collection */
357 };
358
359 static const uint8_t qemu_keyboard_hid_report_descriptor[] = {
360 0x05, 0x01, /* Usage Page (Generic Desktop) */
361 0x09, 0x06, /* Usage (Keyboard) */
362 0xa1, 0x01, /* Collection (Application) */
363 0x75, 0x01, /* Report Size (1) */
364 0x95, 0x08, /* Report Count (8) */
365 0x05, 0x07, /* Usage Page (Key Codes) */
366 0x19, 0xe0, /* Usage Minimum (224) */
367 0x29, 0xe7, /* Usage Maximum (231) */
368 0x15, 0x00, /* Logical Minimum (0) */
369 0x25, 0x01, /* Logical Maximum (1) */
370 0x81, 0x02, /* Input (Data, Variable, Absolute) */
371 0x95, 0x01, /* Report Count (1) */
372 0x75, 0x08, /* Report Size (8) */
373 0x81, 0x01, /* Input (Constant) */
374 0x95, 0x05, /* Report Count (5) */
375 0x75, 0x01, /* Report Size (1) */
376 0x05, 0x08, /* Usage Page (LEDs) */
377 0x19, 0x01, /* Usage Minimum (1) */
378 0x29, 0x05, /* Usage Maximum (5) */
379 0x91, 0x02, /* Output (Data, Variable, Absolute) */
380 0x95, 0x01, /* Report Count (1) */
381 0x75, 0x03, /* Report Size (3) */
382 0x91, 0x01, /* Output (Constant) */
383 0x95, 0x06, /* Report Count (6) */
384 0x75, 0x08, /* Report Size (8) */
385 0x15, 0x00, /* Logical Minimum (0) */
386 0x25, 0xff, /* Logical Maximum (255) */
387 0x05, 0x07, /* Usage Page (Key Codes) */
388 0x19, 0x00, /* Usage Minimum (0) */
389 0x29, 0xff, /* Usage Maximum (255) */
390 0x81, 0x00, /* Input (Data, Array) */
391 0xc0, /* End Collection */
392 };
393
394 #define USB_HID_USAGE_ERROR_ROLLOVER 0x01
395 #define USB_HID_USAGE_POSTFAIL 0x02
396 #define USB_HID_USAGE_ERROR_UNDEFINED 0x03
397
398 /* Indices are QEMU keycodes, values are from HID Usage Table. Indices
399 * above 0x80 are for keys that come after 0xe0 or 0xe1+0x1d or 0xe1+0x9d. */
400 static const uint8_t usb_hid_usage_keys[0x100] = {
401 0x00, 0x29, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23,
402 0x24, 0x25, 0x26, 0x27, 0x2d, 0x2e, 0x2a, 0x2b,
403 0x14, 0x1a, 0x08, 0x15, 0x17, 0x1c, 0x18, 0x0c,
404 0x12, 0x13, 0x2f, 0x30, 0x28, 0xe0, 0x04, 0x16,
405 0x07, 0x09, 0x0a, 0x0b, 0x0d, 0x0e, 0x0f, 0x33,
406 0x34, 0x35, 0xe1, 0x31, 0x1d, 0x1b, 0x06, 0x19,
407 0x05, 0x11, 0x10, 0x36, 0x37, 0x38, 0xe5, 0x55,
408 0xe2, 0x2c, 0x32, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e,
409 0x3f, 0x40, 0x41, 0x42, 0x43, 0x53, 0x47, 0x5f,
410 0x60, 0x61, 0x56, 0x5c, 0x5d, 0x5e, 0x57, 0x59,
411 0x5a, 0x5b, 0x62, 0x63, 0x00, 0x00, 0x00, 0x44,
412 0x45, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e,
413 0xe8, 0xe9, 0x71, 0x72, 0x73, 0x00, 0x00, 0x00,
414 0x00, 0x00, 0x00, 0x85, 0x00, 0x00, 0x00, 0x00,
415 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
416 0x00, 0x00, 0x00, 0x00, 0x00, 0xe3, 0xe7, 0x65,
417
418 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
419 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
420 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
421 0x00, 0x00, 0x00, 0x00, 0x58, 0xe4, 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, 0x00, 0x54, 0x00, 0x46,
425 0xe6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
426 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x00, 0x4a,
427 0x52, 0x4b, 0x00, 0x50, 0x00, 0x4f, 0x00, 0x4d,
428 0x51, 0x4e, 0x49, 0x4c, 0x00, 0x00, 0x00, 0x00,
429 0x00, 0x00, 0x00, 0xe3, 0xe7, 0x65, 0x00, 0x00,
430 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
431 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
432 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
433 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
434 };
435
436 static void usb_hid_changed(USBHIDState *hs)
437 {
438 hs->changed = 1;
439
440 if (hs->datain)
441 hs->datain(hs->datain_opaque);
442
443 usb_wakeup(&hs->dev);
444 }
445
446 static void usb_pointer_event_clear(USBPointerEvent *e, int buttons) {
447 e->xdx = e->ydy = e->dz = 0;
448 e->buttons_state = buttons;
449 }
450
451 static void usb_pointer_event_combine(USBPointerEvent *e, int xyrel,
452 int x1, int y1, int z1) {
453 if (xyrel) {
454 e->xdx += x1;
455 e->ydy += y1;
456 } else {
457 e->xdx = x1;
458 e->ydy = y1;
459 }
460 e->dz += z1;
461 }
462
463 static void usb_pointer_event(void *opaque,
464 int x1, int y1, int z1, int buttons_state)
465 {
466 USBHIDState *hs = opaque;
467 USBMouseState *s = &hs->ptr;
468 unsigned use_slot = (s->head + s->n - 1) & QUEUE_MASK;
469 unsigned previous_slot = (use_slot - 1) & QUEUE_MASK;
470
471 /* We combine events where feasible to keep the queue small. We shouldn't
472 * combine anything with the first event of a particular button state, as
473 * that would change the location of the button state change. When the
474 * queue is empty, a second event is needed because we don't know if
475 * the first event changed the button state. */
476 if (s->n == QUEUE_LENGTH) {
477 /* Queue full. Discard old button state, combine motion normally. */
478 s->queue[use_slot].buttons_state = buttons_state;
479 } else if (s->n < 2 ||
480 s->queue[use_slot].buttons_state != buttons_state ||
481 s->queue[previous_slot].buttons_state != s->queue[use_slot].buttons_state) {
482 /* Cannot or should not combine, so add an empty item to the queue. */
483 QUEUE_INCR(use_slot);
484 s->n++;
485 usb_pointer_event_clear(&s->queue[use_slot], buttons_state);
486 }
487 usb_pointer_event_combine(&s->queue[use_slot],
488 hs->kind == USB_MOUSE,
489 x1, y1, z1);
490 usb_hid_changed(hs);
491 }
492
493 static void usb_keyboard_event(void *opaque, int keycode)
494 {
495 USBHIDState *hs = opaque;
496 USBKeyboardState *s = &hs->kbd;
497 uint8_t hid_code, key;
498 int i;
499
500 key = keycode & 0x7f;
501 hid_code = usb_hid_usage_keys[key | ((s->modifiers >> 1) & (1 << 7))];
502 s->modifiers &= ~(1 << 8);
503
504 switch (hid_code) {
505 case 0x00:
506 return;
507
508 case 0xe0:
509 if (s->modifiers & (1 << 9)) {
510 s->modifiers ^= 3 << 8;
511 usb_hid_changed(hs);
512 return;
513 }
514 case 0xe1 ... 0xe7:
515 if (keycode & (1 << 7)) {
516 s->modifiers &= ~(1 << (hid_code & 0x0f));
517 usb_hid_changed(hs);
518 return;
519 }
520 case 0xe8 ... 0xef:
521 s->modifiers |= 1 << (hid_code & 0x0f);
522 usb_hid_changed(hs);
523 return;
524 }
525
526 if (keycode & (1 << 7)) {
527 for (i = s->keys - 1; i >= 0; i --)
528 if (s->key[i] == hid_code) {
529 s->key[i] = s->key[-- s->keys];
530 s->key[s->keys] = 0x00;
531 usb_hid_changed(hs);
532 break;
533 }
534 if (i < 0)
535 return;
536 } else {
537 for (i = s->keys - 1; i >= 0; i --)
538 if (s->key[i] == hid_code)
539 break;
540 if (i < 0) {
541 if (s->keys < sizeof(s->key))
542 s->key[s->keys ++] = hid_code;
543 } else
544 return;
545 }
546
547 usb_hid_changed(hs);
548 }
549
550 static inline int int_clamp(int val, int vmin, int vmax)
551 {
552 if (val < vmin)
553 return vmin;
554 else if (val > vmax)
555 return vmax;
556 else
557 return val;
558 }
559
560 static int usb_pointer_poll(USBHIDState *hs, uint8_t *buf, int len)
561 {
562 int dx, dy, dz, b, l;
563 int index;
564 USBMouseState *s = &hs->ptr;
565 USBPointerEvent *e;
566
567 if (!s->mouse_grabbed) {
568 qemu_activate_mouse_event_handler(s->eh_entry);
569 s->mouse_grabbed = 1;
570 }
571
572 /* When the buffer is empty, return the last event. Relative
573 movements will all be zero. */
574 index = (s->n ? s->head : s->head - 1);
575 e = &s->queue[index & QUEUE_MASK];
576
577 if (hs->kind == USB_MOUSE) {
578 dx = int_clamp(e->xdx, -127, 127);
579 dy = int_clamp(e->ydy, -127, 127);
580 e->xdx -= dx;
581 e->ydy -= dy;
582 } else {
583 dx = e->xdx;
584 dy = e->ydy;
585 }
586 dz = int_clamp(e->dz, -127, 127);
587 e->dz -= dz;
588
589 b = 0;
590 if (e->buttons_state & MOUSE_EVENT_LBUTTON)
591 b |= 0x01;
592 if (e->buttons_state & MOUSE_EVENT_RBUTTON)
593 b |= 0x02;
594 if (e->buttons_state & MOUSE_EVENT_MBUTTON)
595 b |= 0x04;
596
597 if (s->n &&
598 !e->dz &&
599 (hs->kind == USB_TABLET || (!e->xdx && !e->ydy))) {
600 /* that deals with this event */
601 QUEUE_INCR(s->head);
602 s->n--;
603 }
604
605 /* Appears we have to invert the wheel direction */
606 dz = 0 - dz;
607 l = 0;
608 switch (hs->kind) {
609 case USB_MOUSE:
610 if (len > l)
611 buf[l++] = b;
612 if (len > l)
613 buf[l++] = dx;
614 if (len > l)
615 buf[l++] = dy;
616 if (len > l)
617 buf[l++] = dz;
618 break;
619
620 case USB_TABLET:
621 if (len > l)
622 buf[l++] = b;
623 if (len > l)
624 buf[l++] = dx & 0xff;
625 if (len > l)
626 buf[l++] = dx >> 8;
627 if (len > l)
628 buf[l++] = dy & 0xff;
629 if (len > l)
630 buf[l++] = dy >> 8;
631 if (len > l)
632 buf[l++] = dz;
633 break;
634
635 default:
636 abort();
637 }
638
639 return l;
640 }
641
642 static int usb_keyboard_poll(USBHIDState *hs, uint8_t *buf, int len)
643 {
644 USBKeyboardState *s = &hs->kbd;
645 if (len < 2)
646 return 0;
647
648 buf[0] = s->modifiers & 0xff;
649 buf[1] = 0;
650 if (s->keys > 6)
651 memset(buf + 2, USB_HID_USAGE_ERROR_ROLLOVER, MIN(8, len) - 2);
652 else
653 memcpy(buf + 2, s->key, MIN(8, len) - 2);
654
655 return MIN(8, len);
656 }
657
658 static int usb_keyboard_write(USBKeyboardState *s, uint8_t *buf, int len)
659 {
660 if (len > 0) {
661 int ledstate = 0;
662 /* 0x01: Num Lock LED
663 * 0x02: Caps Lock LED
664 * 0x04: Scroll Lock LED
665 * 0x08: Compose LED
666 * 0x10: Kana LED */
667 s->leds = buf[0];
668 if (s->leds & 0x04)
669 ledstate |= QEMU_SCROLL_LOCK_LED;
670 if (s->leds & 0x01)
671 ledstate |= QEMU_NUM_LOCK_LED;
672 if (s->leds & 0x02)
673 ledstate |= QEMU_CAPS_LOCK_LED;
674 kbd_put_ledstate(ledstate);
675 }
676 return 0;
677 }
678
679 static void usb_mouse_handle_reset(USBDevice *dev)
680 {
681 USBHIDState *s = (USBHIDState *)dev;
682
683 memset (s->ptr.queue, 0, sizeof (s->ptr.queue));
684 s->ptr.head = 0;
685 s->ptr.n = 0;
686 s->protocol = 1;
687 }
688
689 static void usb_keyboard_handle_reset(USBDevice *dev)
690 {
691 USBHIDState *s = (USBHIDState *)dev;
692
693 qemu_add_kbd_event_handler(usb_keyboard_event, s);
694 s->protocol = 1;
695 }
696
697 static void usb_hid_set_next_idle(USBHIDState *s, int64_t curtime)
698 {
699 s->next_idle_clock = curtime + (get_ticks_per_sec() * s->idle * 4) / 1000;
700 }
701
702 static int usb_hid_handle_control(USBDevice *dev, int request, int value,
703 int index, int length, uint8_t *data)
704 {
705 USBHIDState *s = (USBHIDState *)dev;
706 int ret;
707
708 ret = usb_desc_handle_control(dev, request, value, index, length, data);
709 if (ret >= 0) {
710 return ret;
711 }
712
713 ret = 0;
714 switch(request) {
715 case DeviceRequest | USB_REQ_GET_INTERFACE:
716 data[0] = 0;
717 ret = 1;
718 break;
719 case DeviceOutRequest | USB_REQ_SET_INTERFACE:
720 ret = 0;
721 break;
722 /* hid specific requests */
723 case InterfaceRequest | USB_REQ_GET_DESCRIPTOR:
724 switch(value >> 8) {
725 case 0x22:
726 if (s->kind == USB_MOUSE) {
727 memcpy(data, qemu_mouse_hid_report_descriptor,
728 sizeof(qemu_mouse_hid_report_descriptor));
729 ret = sizeof(qemu_mouse_hid_report_descriptor);
730 } else if (s->kind == USB_TABLET) {
731 memcpy(data, qemu_tablet_hid_report_descriptor,
732 sizeof(qemu_tablet_hid_report_descriptor));
733 ret = sizeof(qemu_tablet_hid_report_descriptor);
734 } else if (s->kind == USB_KEYBOARD) {
735 memcpy(data, qemu_keyboard_hid_report_descriptor,
736 sizeof(qemu_keyboard_hid_report_descriptor));
737 ret = sizeof(qemu_keyboard_hid_report_descriptor);
738 }
739 break;
740 default:
741 goto fail;
742 }
743 break;
744 case GET_REPORT:
745 if (s->kind == USB_MOUSE || s->kind == USB_TABLET)
746 ret = usb_pointer_poll(s, data, length);
747 else if (s->kind == USB_KEYBOARD)
748 ret = usb_keyboard_poll(s, data, length);
749 break;
750 case SET_REPORT:
751 if (s->kind == USB_KEYBOARD)
752 ret = usb_keyboard_write(&s->kbd, data, length);
753 else
754 goto fail;
755 break;
756 case GET_PROTOCOL:
757 if (s->kind != USB_KEYBOARD)
758 goto fail;
759 ret = 1;
760 data[0] = s->protocol;
761 break;
762 case SET_PROTOCOL:
763 if (s->kind != USB_KEYBOARD)
764 goto fail;
765 ret = 0;
766 s->protocol = value;
767 break;
768 case GET_IDLE:
769 ret = 1;
770 data[0] = s->idle;
771 break;
772 case SET_IDLE:
773 s->idle = (uint8_t) (value >> 8);
774 usb_hid_set_next_idle(s, qemu_get_clock(vm_clock));
775 ret = 0;
776 break;
777 default:
778 fail:
779 ret = USB_RET_STALL;
780 break;
781 }
782 return ret;
783 }
784
785 static int usb_hid_handle_data(USBDevice *dev, USBPacket *p)
786 {
787 USBHIDState *s = (USBHIDState *)dev;
788 int ret = 0;
789
790 switch(p->pid) {
791 case USB_TOKEN_IN:
792 if (p->devep == 1) {
793 int64_t curtime = qemu_get_clock(vm_clock);
794 if (!s->changed && (!s->idle || s->next_idle_clock - curtime > 0))
795 return USB_RET_NAK;
796 usb_hid_set_next_idle(s, curtime);
797 if (s->kind == USB_MOUSE || s->kind == USB_TABLET) {
798 ret = usb_pointer_poll(s, p->data, p->len);
799 s->changed = s->ptr.n > 0;
800 }
801 else if (s->kind == USB_KEYBOARD) {
802 ret = usb_keyboard_poll(s, p->data, p->len);
803 s->changed = 0;
804 }
805 } else {
806 goto fail;
807 }
808 break;
809 case USB_TOKEN_OUT:
810 default:
811 fail:
812 ret = USB_RET_STALL;
813 break;
814 }
815 return ret;
816 }
817
818 static void usb_hid_handle_destroy(USBDevice *dev)
819 {
820 USBHIDState *s = (USBHIDState *)dev;
821
822 switch(s->kind) {
823 case USB_KEYBOARD:
824 qemu_remove_kbd_event_handler();
825 break;
826 default:
827 qemu_remove_mouse_event_handler(s->ptr.eh_entry);
828 }
829 }
830
831 static int usb_hid_initfn(USBDevice *dev, int kind)
832 {
833 USBHIDState *s = DO_UPCAST(USBHIDState, dev, dev);
834
835 usb_desc_init(dev);
836 s->kind = kind;
837
838 if (s->kind == USB_MOUSE) {
839 s->ptr.eh_entry = qemu_add_mouse_event_handler(usb_pointer_event, s,
840 0, "QEMU USB Mouse");
841 } else if (s->kind == USB_TABLET) {
842 s->ptr.eh_entry = qemu_add_mouse_event_handler(usb_pointer_event, s,
843 1, "QEMU USB Tablet");
844 }
845
846 /* Force poll routine to be run and grab input the first time. */
847 s->changed = 1;
848 return 0;
849 }
850
851 static int usb_tablet_initfn(USBDevice *dev)
852 {
853 return usb_hid_initfn(dev, USB_TABLET);
854 }
855
856 static int usb_mouse_initfn(USBDevice *dev)
857 {
858 return usb_hid_initfn(dev, USB_MOUSE);
859 }
860
861 static int usb_keyboard_initfn(USBDevice *dev)
862 {
863 return usb_hid_initfn(dev, USB_KEYBOARD);
864 }
865
866 void usb_hid_datain_cb(USBDevice *dev, void *opaque, void (*datain)(void *))
867 {
868 USBHIDState *s = (USBHIDState *)dev;
869
870 s->datain_opaque = opaque;
871 s->datain = datain;
872 }
873
874 static struct USBDeviceInfo hid_info[] = {
875 {
876 .product_desc = "QEMU USB Tablet",
877 .qdev.name = "usb-tablet",
878 .usbdevice_name = "tablet",
879 .qdev.size = sizeof(USBHIDState),
880 .usb_desc = &desc_tablet,
881 .init = usb_tablet_initfn,
882 .handle_packet = usb_generic_handle_packet,
883 .handle_reset = usb_mouse_handle_reset,
884 .handle_control = usb_hid_handle_control,
885 .handle_data = usb_hid_handle_data,
886 .handle_destroy = usb_hid_handle_destroy,
887 },{
888 .product_desc = "QEMU USB Mouse",
889 .qdev.name = "usb-mouse",
890 .usbdevice_name = "mouse",
891 .qdev.size = sizeof(USBHIDState),
892 .usb_desc = &desc_mouse,
893 .init = usb_mouse_initfn,
894 .handle_packet = usb_generic_handle_packet,
895 .handle_reset = usb_mouse_handle_reset,
896 .handle_control = usb_hid_handle_control,
897 .handle_data = usb_hid_handle_data,
898 .handle_destroy = usb_hid_handle_destroy,
899 },{
900 .product_desc = "QEMU USB Keyboard",
901 .qdev.name = "usb-kbd",
902 .usbdevice_name = "keyboard",
903 .qdev.size = sizeof(USBHIDState),
904 .usb_desc = &desc_keyboard,
905 .init = usb_keyboard_initfn,
906 .handle_packet = usb_generic_handle_packet,
907 .handle_reset = usb_keyboard_handle_reset,
908 .handle_control = usb_hid_handle_control,
909 .handle_data = usb_hid_handle_data,
910 .handle_destroy = usb_hid_handle_destroy,
911 },{
912 /* end of list */
913 }
914 };
915
916 static void usb_hid_register_devices(void)
917 {
918 usb_qdev_register_many(hid_info);
919 }
920 device_init(usb_hid_register_devices)
Qemu copy for testing