?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge remote branch 'mst/for_anthony' into staging
[qemu.git] / hw / usb-hid.c
blob12bf46fa7e92b97a608de8ccfa92fad47c2e5aec
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 "sysemu.h"
29
30 /* HID interface requests */
31 #define GET_REPORT 0xa101
32 #define GET_IDLE 0xa102
33 #define GET_PROTOCOL 0xa103
34 #define SET_REPORT 0x2109
35 #define SET_IDLE 0x210a
36 #define SET_PROTOCOL 0x210b
37
38 /* HID descriptor types */
39 #define USB_DT_HID 0x21
40 #define USB_DT_REPORT 0x22
41 #define USB_DT_PHY 0x23
42
43 #define USB_MOUSE 1
44 #define USB_TABLET 2
45 #define USB_KEYBOARD 3
46
47 typedef struct USBMouseState {
48 int dx, dy, dz, buttons_state;
49 int x, y;
50 int mouse_grabbed;
51 QEMUPutMouseEntry *eh_entry;
52 } USBMouseState;
53
54 typedef struct USBKeyboardState {
55 uint16_t modifiers;
56 uint8_t leds;
57 uint8_t key[16];
58 int keys;
59 } USBKeyboardState;
60
61 typedef struct USBHIDState {
62 USBDevice dev;
63 union {
64 USBMouseState ptr;
65 USBKeyboardState kbd;
66 };
67 int kind;
68 int protocol;
69 uint8_t idle;
70 int64_t next_idle_clock;
71 int changed;
72 void *datain_opaque;
73 void (*datain)(void *);
74 } USBHIDState;
75
76 /* mostly the same values as the Bochs USB Mouse device */
77 static const uint8_t qemu_mouse_dev_descriptor[] = {
78 0x12, /* u8 bLength; */
79 0x01, /* u8 bDescriptorType; Device */
80 0x00, 0x01, /* u16 bcdUSB; v1.0 */
81
82 0x00, /* u8 bDeviceClass; */
83 0x00, /* u8 bDeviceSubClass; */
84 0x00, /* u8 bDeviceProtocol; [ low/full speeds only ] */
85 0x08, /* u8 bMaxPacketSize0; 8 Bytes */
86
87 0x27, 0x06, /* u16 idVendor; */
88 0x01, 0x00, /* u16 idProduct; */
89 0x00, 0x00, /* u16 bcdDevice */
90
91 0x03, /* u8 iManufacturer; */
92 0x02, /* u8 iProduct; */
93 0x01, /* u8 iSerialNumber; */
94 0x01 /* u8 bNumConfigurations; */
95 };
96
97 static const uint8_t qemu_mouse_config_descriptor[] = {
98 /* one configuration */
99 0x09, /* u8 bLength; */
100 0x02, /* u8 bDescriptorType; Configuration */
101 0x22, 0x00, /* u16 wTotalLength; */
102 0x01, /* u8 bNumInterfaces; (1) */
103 0x01, /* u8 bConfigurationValue; */
104 0x04, /* u8 iConfiguration; */
105 0xe0, /* u8 bmAttributes;
106 Bit 7: must be set,
107 6: Self-powered,
108 5: Remote wakeup,
109 4..0: resvd */
110 50, /* u8 MaxPower; */
111
112 /* USB 1.1:
113 * USB 2.0, single TT organization (mandatory):
114 * one interface, protocol 0
115 *
116 * USB 2.0, multiple TT organization (optional):
117 * two interfaces, protocols 1 (like single TT)
118 * and 2 (multiple TT mode) ... config is
119 * sometimes settable
120 * NOT IMPLEMENTED
121 */
122
123 /* one interface */
124 0x09, /* u8 if_bLength; */
125 0x04, /* u8 if_bDescriptorType; Interface */
126 0x00, /* u8 if_bInterfaceNumber; */
127 0x00, /* u8 if_bAlternateSetting; */
128 0x01, /* u8 if_bNumEndpoints; */
129 0x03, /* u8 if_bInterfaceClass; */
130 0x01, /* u8 if_bInterfaceSubClass; */
131 0x02, /* u8 if_bInterfaceProtocol; [usb1.1 or single tt] */
132 0x07, /* u8 if_iInterface; */
133
134 /* HID descriptor */
135 0x09, /* u8 bLength; */
136 0x21, /* u8 bDescriptorType; */
137 0x01, 0x00, /* u16 HID_class */
138 0x00, /* u8 country_code */
139 0x01, /* u8 num_descriptors */
140 0x22, /* u8 type; Report */
141 52, 0, /* u16 len */
142
143 /* one endpoint (status change endpoint) */
144 0x07, /* u8 ep_bLength; */
145 0x05, /* u8 ep_bDescriptorType; Endpoint */
146 0x81, /* u8 ep_bEndpointAddress; IN Endpoint 1 */
147 0x03, /* u8 ep_bmAttributes; Interrupt */
148 0x04, 0x00, /* u16 ep_wMaxPacketSize; */
149 0x0a, /* u8 ep_bInterval; (255ms -- usb 2.0 spec) */
150 };
151
152 static const uint8_t qemu_tablet_config_descriptor[] = {
153 /* one configuration */
154 0x09, /* u8 bLength; */
155 0x02, /* u8 bDescriptorType; Configuration */
156 0x22, 0x00, /* u16 wTotalLength; */
157 0x01, /* u8 bNumInterfaces; (1) */
158 0x01, /* u8 bConfigurationValue; */
159 0x05, /* u8 iConfiguration; */
160 0xa0, /* u8 bmAttributes;
161 Bit 7: must be set,
162 6: Self-powered,
163 5: Remote wakeup,
164 4..0: resvd */
165 50, /* u8 MaxPower; */
166
167 /* USB 1.1:
168 * USB 2.0, single TT organization (mandatory):
169 * one interface, protocol 0
170 *
171 * USB 2.0, multiple TT organization (optional):
172 * two interfaces, protocols 1 (like single TT)
173 * and 2 (multiple TT mode) ... config is
174 * sometimes settable
175 * NOT IMPLEMENTED
176 */
177
178 /* one interface */
179 0x09, /* u8 if_bLength; */
180 0x04, /* u8 if_bDescriptorType; Interface */
181 0x00, /* u8 if_bInterfaceNumber; */
182 0x00, /* u8 if_bAlternateSetting; */
183 0x01, /* u8 if_bNumEndpoints; */
184 0x03, /* u8 if_bInterfaceClass; */
185 0x01, /* u8 if_bInterfaceSubClass; */
186 0x02, /* u8 if_bInterfaceProtocol; [usb1.1 or single tt] */
187 0x07, /* u8 if_iInterface; */
188
189 /* HID descriptor */
190 0x09, /* u8 bLength; */
191 0x21, /* u8 bDescriptorType; */
192 0x01, 0x00, /* u16 HID_class */
193 0x00, /* u8 country_code */
194 0x01, /* u8 num_descriptors */
195 0x22, /* u8 type; Report */
196 74, 0, /* u16 len */
197
198 /* one endpoint (status change endpoint) */
199 0x07, /* u8 ep_bLength; */
200 0x05, /* u8 ep_bDescriptorType; Endpoint */
201 0x81, /* u8 ep_bEndpointAddress; IN Endpoint 1 */
202 0x03, /* u8 ep_bmAttributes; Interrupt */
203 0x08, 0x00, /* u16 ep_wMaxPacketSize; */
204 0x0a, /* u8 ep_bInterval; (255ms -- usb 2.0 spec) */
205 };
206
207 static const uint8_t qemu_keyboard_config_descriptor[] = {
208 /* one configuration */
209 0x09, /* u8 bLength; */
210 USB_DT_CONFIG, /* u8 bDescriptorType; Configuration */
211 0x22, 0x00, /* u16 wTotalLength; */
212 0x01, /* u8 bNumInterfaces; (1) */
213 0x01, /* u8 bConfigurationValue; */
214 0x06, /* u8 iConfiguration; */
215 0xa0, /* u8 bmAttributes;
216 Bit 7: must be set,
217 6: Self-powered,
218 5: Remote wakeup,
219 4..0: resvd */
220 0x32, /* u8 MaxPower; */
221
222 /* USB 1.1:
223 * USB 2.0, single TT organization (mandatory):
224 * one interface, protocol 0
225 *
226 * USB 2.0, multiple TT organization (optional):
227 * two interfaces, protocols 1 (like single TT)
228 * and 2 (multiple TT mode) ... config is
229 * sometimes settable
230 * NOT IMPLEMENTED
231 */
232
233 /* one interface */
234 0x09, /* u8 if_bLength; */
235 USB_DT_INTERFACE, /* u8 if_bDescriptorType; Interface */
236 0x00, /* u8 if_bInterfaceNumber; */
237 0x00, /* u8 if_bAlternateSetting; */
238 0x01, /* u8 if_bNumEndpoints; */
239 0x03, /* u8 if_bInterfaceClass; HID */
240 0x01, /* u8 if_bInterfaceSubClass; Boot */
241 0x01, /* u8 if_bInterfaceProtocol; Keyboard */
242 0x07, /* u8 if_iInterface; */
243
244 /* HID descriptor */
245 0x09, /* u8 bLength; */
246 USB_DT_HID, /* u8 bDescriptorType; */
247 0x11, 0x01, /* u16 HID_class */
248 0x00, /* u8 country_code */
249 0x01, /* u8 num_descriptors */
250 USB_DT_REPORT, /* u8 type; Report */
251 0x3f, 0x00, /* u16 len */
252
253 /* one endpoint (status change endpoint) */
254 0x07, /* u8 ep_bLength; */
255 USB_DT_ENDPOINT, /* u8 ep_bDescriptorType; Endpoint */
256 USB_DIR_IN | 0x01, /* u8 ep_bEndpointAddress; IN Endpoint 1 */
257 0x03, /* u8 ep_bmAttributes; Interrupt */
258 0x08, 0x00, /* u16 ep_wMaxPacketSize; */
259 0x0a, /* u8 ep_bInterval; (255ms -- usb 2.0 spec) */
260 };
261
262 static const uint8_t qemu_mouse_hid_report_descriptor[] = {
263 0x05, 0x01, /* Usage Page (Generic Desktop) */
264 0x09, 0x02, /* Usage (Mouse) */
265 0xa1, 0x01, /* Collection (Application) */
266 0x09, 0x01, /* Usage (Pointer) */
267 0xa1, 0x00, /* Collection (Physical) */
268 0x05, 0x09, /* Usage Page (Button) */
269 0x19, 0x01, /* Usage Minimum (1) */
270 0x29, 0x03, /* Usage Maximum (3) */
271 0x15, 0x00, /* Logical Minimum (0) */
272 0x25, 0x01, /* Logical Maximum (1) */
273 0x95, 0x03, /* Report Count (3) */
274 0x75, 0x01, /* Report Size (1) */
275 0x81, 0x02, /* Input (Data, Variable, Absolute) */
276 0x95, 0x01, /* Report Count (1) */
277 0x75, 0x05, /* Report Size (5) */
278 0x81, 0x01, /* Input (Constant) */
279 0x05, 0x01, /* Usage Page (Generic Desktop) */
280 0x09, 0x30, /* Usage (X) */
281 0x09, 0x31, /* Usage (Y) */
282 0x09, 0x38, /* Usage (Wheel) */
283 0x15, 0x81, /* Logical Minimum (-0x7f) */
284 0x25, 0x7f, /* Logical Maximum (0x7f) */
285 0x75, 0x08, /* Report Size (8) */
286 0x95, 0x03, /* Report Count (3) */
287 0x81, 0x06, /* Input (Data, Variable, Relative) */
288 0xc0, /* End Collection */
289 0xc0, /* End Collection */
290 };
291
292 static const uint8_t qemu_tablet_hid_report_descriptor[] = {
293 0x05, 0x01, /* Usage Page (Generic Desktop) */
294 0x09, 0x01, /* Usage (Pointer) */
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 0x15, 0x00, /* Logical Minimum (0) */
313 0x26, 0xff, 0x7f, /* Logical Maximum (0x7fff) */
314 0x35, 0x00, /* Physical Minimum (0) */
315 0x46, 0xff, 0x7f, /* Physical Maximum (0x7fff) */
316 0x75, 0x10, /* Report Size (16) */
317 0x95, 0x02, /* Report Count (2) */
318 0x81, 0x02, /* Input (Data, Variable, Absolute) */
319 0x05, 0x01, /* Usage Page (Generic Desktop) */
320 0x09, 0x38, /* Usage (Wheel) */
321 0x15, 0x81, /* Logical Minimum (-0x7f) */
322 0x25, 0x7f, /* Logical Maximum (0x7f) */
323 0x35, 0x00, /* Physical Minimum (same as logical) */
324 0x45, 0x00, /* Physical Maximum (same as logical) */
325 0x75, 0x08, /* Report Size (8) */
326 0x95, 0x01, /* Report Count (1) */
327 0x81, 0x06, /* Input (Data, Variable, Relative) */
328 0xc0, /* End Collection */
329 0xc0, /* End Collection */
330 };
331
332 static const uint8_t qemu_keyboard_hid_report_descriptor[] = {
333 0x05, 0x01, /* Usage Page (Generic Desktop) */
334 0x09, 0x06, /* Usage (Keyboard) */
335 0xa1, 0x01, /* Collection (Application) */
336 0x75, 0x01, /* Report Size (1) */
337 0x95, 0x08, /* Report Count (8) */
338 0x05, 0x07, /* Usage Page (Key Codes) */
339 0x19, 0xe0, /* Usage Minimum (224) */
340 0x29, 0xe7, /* Usage Maximum (231) */
341 0x15, 0x00, /* Logical Minimum (0) */
342 0x25, 0x01, /* Logical Maximum (1) */
343 0x81, 0x02, /* Input (Data, Variable, Absolute) */
344 0x95, 0x01, /* Report Count (1) */
345 0x75, 0x08, /* Report Size (8) */
346 0x81, 0x01, /* Input (Constant) */
347 0x95, 0x05, /* Report Count (5) */
348 0x75, 0x01, /* Report Size (1) */
349 0x05, 0x08, /* Usage Page (LEDs) */
350 0x19, 0x01, /* Usage Minimum (1) */
351 0x29, 0x05, /* Usage Maximum (5) */
352 0x91, 0x02, /* Output (Data, Variable, Absolute) */
353 0x95, 0x01, /* Report Count (1) */
354 0x75, 0x03, /* Report Size (3) */
355 0x91, 0x01, /* Output (Constant) */
356 0x95, 0x06, /* Report Count (6) */
357 0x75, 0x08, /* Report Size (8) */
358 0x15, 0x00, /* Logical Minimum (0) */
359 0x25, 0xff, /* Logical Maximum (255) */
360 0x05, 0x07, /* Usage Page (Key Codes) */
361 0x19, 0x00, /* Usage Minimum (0) */
362 0x29, 0xff, /* Usage Maximum (255) */
363 0x81, 0x00, /* Input (Data, Array) */
364 0xc0, /* End Collection */
365 };
366
367 #define USB_HID_USAGE_ERROR_ROLLOVER 0x01
368 #define USB_HID_USAGE_POSTFAIL 0x02
369 #define USB_HID_USAGE_ERROR_UNDEFINED 0x03
370
371 /* Indices are QEMU keycodes, values are from HID Usage Table. Indices
372 * above 0x80 are for keys that come after 0xe0 or 0xe1+0x1d or 0xe1+0x9d. */
373 static const uint8_t usb_hid_usage_keys[0x100] = {
374 0x00, 0x29, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23,
375 0x24, 0x25, 0x26, 0x27, 0x2d, 0x2e, 0x2a, 0x2b,
376 0x14, 0x1a, 0x08, 0x15, 0x17, 0x1c, 0x18, 0x0c,
377 0x12, 0x13, 0x2f, 0x30, 0x28, 0xe0, 0x04, 0x16,
378 0x07, 0x09, 0x0a, 0x0b, 0x0d, 0x0e, 0x0f, 0x33,
379 0x34, 0x35, 0xe1, 0x31, 0x1d, 0x1b, 0x06, 0x19,
380 0x05, 0x11, 0x10, 0x36, 0x37, 0x38, 0xe5, 0x55,
381 0xe2, 0x2c, 0x32, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e,
382 0x3f, 0x40, 0x41, 0x42, 0x43, 0x53, 0x47, 0x5f,
383 0x60, 0x61, 0x56, 0x5c, 0x5d, 0x5e, 0x57, 0x59,
384 0x5a, 0x5b, 0x62, 0x63, 0x00, 0x00, 0x00, 0x44,
385 0x45, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e,
386 0xe8, 0xe9, 0x71, 0x72, 0x73, 0x00, 0x00, 0x00,
387 0x00, 0x00, 0x00, 0x85, 0x00, 0x00, 0x00, 0x00,
388 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
389 0x00, 0x00, 0x00, 0x00, 0x00, 0xe3, 0xe7, 0x65,
390
391 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
392 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
393 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
394 0x00, 0x00, 0x00, 0x00, 0x58, 0xe4, 0x00, 0x00,
395 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
396 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
397 0x00, 0x00, 0x00, 0x00, 0x00, 0x54, 0x00, 0x46,
398 0xe6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
399 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x00, 0x4a,
400 0x52, 0x4b, 0x00, 0x50, 0x00, 0x4f, 0x00, 0x4d,
401 0x51, 0x4e, 0x49, 0x4c, 0x00, 0x00, 0x00, 0x00,
402 0x00, 0x00, 0x00, 0xe3, 0xe7, 0x65, 0x00, 0x00,
403 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
404 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
405 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
406 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
407 };
408
409 static void usb_hid_changed(USBHIDState *hs)
410 {
411 hs->changed = 1;
412
413 if (hs->datain)
414 hs->datain(hs->datain_opaque);
415 }
416
417 static void usb_mouse_event(void *opaque,
418 int dx1, int dy1, int dz1, int buttons_state)
419 {
420 USBHIDState *hs = opaque;
421 USBMouseState *s = &hs->ptr;
422
423 s->dx += dx1;
424 s->dy += dy1;
425 s->dz += dz1;
426 s->buttons_state = buttons_state;
427
428 usb_hid_changed(hs);
429 }
430
431 static void usb_tablet_event(void *opaque,
432 int x, int y, int dz, int buttons_state)
433 {
434 USBHIDState *hs = opaque;
435 USBMouseState *s = &hs->ptr;
436
437 s->x = x;
438 s->y = y;
439 s->dz += dz;
440 s->buttons_state = buttons_state;
441
442 usb_hid_changed(hs);
443 }
444
445 static void usb_keyboard_event(void *opaque, int keycode)
446 {
447 USBHIDState *hs = opaque;
448 USBKeyboardState *s = &hs->kbd;
449 uint8_t hid_code, key;
450 int i;
451
452 key = keycode & 0x7f;
453 hid_code = usb_hid_usage_keys[key | ((s->modifiers >> 1) & (1 << 7))];
454 s->modifiers &= ~(1 << 8);
455
456 switch (hid_code) {
457 case 0x00:
458 return;
459
460 case 0xe0:
461 if (s->modifiers & (1 << 9)) {
462 s->modifiers ^= 3 << 8;
463 usb_hid_changed(hs);
464 return;
465 }
466 case 0xe1 ... 0xe7:
467 if (keycode & (1 << 7)) {
468 s->modifiers &= ~(1 << (hid_code & 0x0f));
469 usb_hid_changed(hs);
470 return;
471 }
472 case 0xe8 ... 0xef:
473 s->modifiers |= 1 << (hid_code & 0x0f);
474 usb_hid_changed(hs);
475 return;
476 }
477
478 if (keycode & (1 << 7)) {
479 for (i = s->keys - 1; i >= 0; i --)
480 if (s->key[i] == hid_code) {
481 s->key[i] = s->key[-- s->keys];
482 s->key[s->keys] = 0x00;
483 usb_hid_changed(hs);
484 break;
485 }
486 if (i < 0)
487 return;
488 } else {
489 for (i = s->keys - 1; i >= 0; i --)
490 if (s->key[i] == hid_code)
491 break;
492 if (i < 0) {
493 if (s->keys < sizeof(s->key))
494 s->key[s->keys ++] = hid_code;
495 } else
496 return;
497 }
498
499 usb_hid_changed(hs);
500 }
501
502 static inline int int_clamp(int val, int vmin, int vmax)
503 {
504 if (val < vmin)
505 return vmin;
506 else if (val > vmax)
507 return vmax;
508 else
509 return val;
510 }
511
512 static int usb_mouse_poll(USBHIDState *hs, uint8_t *buf, int len)
513 {
514 int dx, dy, dz, b, l;
515 USBMouseState *s = &hs->ptr;
516
517 if (!s->mouse_grabbed) {
518 qemu_activate_mouse_event_handler(s->eh_entry);
519 s->mouse_grabbed = 1;
520 }
521
522 dx = int_clamp(s->dx, -127, 127);
523 dy = int_clamp(s->dy, -127, 127);
524 dz = int_clamp(s->dz, -127, 127);
525
526 s->dx -= dx;
527 s->dy -= dy;
528 s->dz -= dz;
529
530 /* Appears we have to invert the wheel direction */
531 dz = 0 - dz;
532
533 b = 0;
534 if (s->buttons_state & MOUSE_EVENT_LBUTTON)
535 b |= 0x01;
536 if (s->buttons_state & MOUSE_EVENT_RBUTTON)
537 b |= 0x02;
538 if (s->buttons_state & MOUSE_EVENT_MBUTTON)
539 b |= 0x04;
540
541 l = 0;
542 if (len > l)
543 buf[l ++] = b;
544 if (len > l)
545 buf[l ++] = dx;
546 if (len > l)
547 buf[l ++] = dy;
548 if (len > l)
549 buf[l ++] = dz;
550 return l;
551 }
552
553 static int usb_tablet_poll(USBHIDState *hs, uint8_t *buf, int len)
554 {
555 int dz, b, l;
556 USBMouseState *s = &hs->ptr;
557
558 if (!s->mouse_grabbed) {
559 qemu_activate_mouse_event_handler(s->eh_entry);
560 s->mouse_grabbed = 1;
561 }
562
563 dz = int_clamp(s->dz, -127, 127);
564 s->dz -= dz;
565
566 /* Appears we have to invert the wheel direction */
567 dz = 0 - dz;
568 b = 0;
569 if (s->buttons_state & MOUSE_EVENT_LBUTTON)
570 b |= 0x01;
571 if (s->buttons_state & MOUSE_EVENT_RBUTTON)
572 b |= 0x02;
573 if (s->buttons_state & MOUSE_EVENT_MBUTTON)
574 b |= 0x04;
575
576 buf[0] = b;
577 buf[1] = s->x & 0xff;
578 buf[2] = s->x >> 8;
579 buf[3] = s->y & 0xff;
580 buf[4] = s->y >> 8;
581 buf[5] = dz;
582 l = 6;
583
584 return l;
585 }
586
587 static int usb_keyboard_poll(USBKeyboardState *s, uint8_t *buf, int len)
588 {
589 if (len < 2)
590 return 0;
591
592 buf[0] = s->modifiers & 0xff;
593 buf[1] = 0;
594 if (s->keys > 6)
595 memset(buf + 2, USB_HID_USAGE_ERROR_ROLLOVER, MIN(8, len) - 2);
596 else
597 memcpy(buf + 2, s->key, MIN(8, len) - 2);
598
599 return MIN(8, len);
600 }
601
602 static int usb_keyboard_write(USBKeyboardState *s, uint8_t *buf, int len)
603 {
604 if (len > 0) {
605 int ledstate = 0;
606 /* 0x01: Num Lock LED
607 * 0x02: Caps Lock LED
608 * 0x04: Scroll Lock LED
609 * 0x08: Compose LED
610 * 0x10: Kana LED */
611 s->leds = buf[0];
612 if (s->leds & 0x04)
613 ledstate |= QEMU_SCROLL_LOCK_LED;
614 if (s->leds & 0x01)
615 ledstate |= QEMU_NUM_LOCK_LED;
616 if (s->leds & 0x02)
617 ledstate |= QEMU_CAPS_LOCK_LED;
618 kbd_put_ledstate(ledstate);
619 }
620 return 0;
621 }
622
623 static void usb_mouse_handle_reset(USBDevice *dev)
624 {
625 USBHIDState *s = (USBHIDState *)dev;
626
627 s->ptr.dx = 0;
628 s->ptr.dy = 0;
629 s->ptr.dz = 0;
630 s->ptr.x = 0;
631 s->ptr.y = 0;
632 s->ptr.buttons_state = 0;
633 s->protocol = 1;
634 }
635
636 static void usb_keyboard_handle_reset(USBDevice *dev)
637 {
638 USBHIDState *s = (USBHIDState *)dev;
639
640 qemu_add_kbd_event_handler(usb_keyboard_event, s);
641 s->protocol = 1;
642 }
643
644 static void usb_hid_set_next_idle(USBHIDState *s, int64_t curtime)
645 {
646 s->next_idle_clock = curtime + (get_ticks_per_sec() * s->idle * 4) / 1000;
647 }
648
649 static int usb_hid_handle_control(USBDevice *dev, int request, int value,
650 int index, int length, uint8_t *data)
651 {
652 USBHIDState *s = (USBHIDState *)dev;
653 int ret = 0;
654
655 switch(request) {
656 case DeviceRequest | USB_REQ_GET_STATUS:
657 data[0] = (1 << USB_DEVICE_SELF_POWERED) |
658 (dev->remote_wakeup << USB_DEVICE_REMOTE_WAKEUP);
659 data[1] = 0x00;
660 ret = 2;
661 break;
662 case DeviceOutRequest | USB_REQ_CLEAR_FEATURE:
663 if (value == USB_DEVICE_REMOTE_WAKEUP) {
664 dev->remote_wakeup = 0;
665 } else {
666 goto fail;
667 }
668 ret = 0;
669 break;
670 case DeviceOutRequest | USB_REQ_SET_FEATURE:
671 if (value == USB_DEVICE_REMOTE_WAKEUP) {
672 dev->remote_wakeup = 1;
673 } else {
674 goto fail;
675 }
676 ret = 0;
677 break;
678 case DeviceOutRequest | USB_REQ_SET_ADDRESS:
679 dev->addr = value;
680 ret = 0;
681 break;
682 case DeviceRequest | USB_REQ_GET_DESCRIPTOR:
683 switch(value >> 8) {
684 case USB_DT_DEVICE:
685 memcpy(data, qemu_mouse_dev_descriptor,
686 sizeof(qemu_mouse_dev_descriptor));
687 ret = sizeof(qemu_mouse_dev_descriptor);
688 break;
689 case USB_DT_CONFIG:
690 if (s->kind == USB_MOUSE) {
691 memcpy(data, qemu_mouse_config_descriptor,
692 sizeof(qemu_mouse_config_descriptor));
693 ret = sizeof(qemu_mouse_config_descriptor);
694 } else if (s->kind == USB_TABLET) {
695 memcpy(data, qemu_tablet_config_descriptor,
696 sizeof(qemu_tablet_config_descriptor));
697 ret = sizeof(qemu_tablet_config_descriptor);
698 } else if (s->kind == USB_KEYBOARD) {
699 memcpy(data, qemu_keyboard_config_descriptor,
700 sizeof(qemu_keyboard_config_descriptor));
701 ret = sizeof(qemu_keyboard_config_descriptor);
702 }
703 break;
704 case USB_DT_STRING:
705 switch(value & 0xff) {
706 case 0:
707 /* language ids */
708 data[0] = 4;
709 data[1] = 3;
710 data[2] = 0x09;
711 data[3] = 0x04;
712 ret = 4;
713 break;
714 case 1:
715 /* serial number */
716 ret = set_usb_string(data, "1");
717 break;
718 case 2:
719 /* product description */
720 ret = set_usb_string(data, s->dev.product_desc);
721 break;
722 case 3:
723 /* vendor description */
724 ret = set_usb_string(data, "QEMU " QEMU_VERSION);
725 break;
726 case 4:
727 ret = set_usb_string(data, "HID Mouse");
728 break;
729 case 5:
730 ret = set_usb_string(data, "HID Tablet");
731 break;
732 case 6:
733 ret = set_usb_string(data, "HID Keyboard");
734 break;
735 case 7:
736 ret = set_usb_string(data, "Endpoint1 Interrupt Pipe");
737 break;
738 default:
739 goto fail;
740 }
741 break;
742 default:
743 goto fail;
744 }
745 break;
746 case DeviceRequest | USB_REQ_GET_CONFIGURATION:
747 data[0] = 1;
748 ret = 1;
749 break;
750 case DeviceOutRequest | USB_REQ_SET_CONFIGURATION:
751 ret = 0;
752 break;
753 case DeviceRequest | USB_REQ_GET_INTERFACE:
754 data[0] = 0;
755 ret = 1;
756 break;
757 case DeviceOutRequest | USB_REQ_SET_INTERFACE:
758 ret = 0;
759 break;
760 /* hid specific requests */
761 case InterfaceRequest | USB_REQ_GET_DESCRIPTOR:
762 switch(value >> 8) {
763 case 0x22:
764 if (s->kind == USB_MOUSE) {
765 memcpy(data, qemu_mouse_hid_report_descriptor,
766 sizeof(qemu_mouse_hid_report_descriptor));
767 ret = sizeof(qemu_mouse_hid_report_descriptor);
768 } else if (s->kind == USB_TABLET) {
769 memcpy(data, qemu_tablet_hid_report_descriptor,
770 sizeof(qemu_tablet_hid_report_descriptor));
771 ret = sizeof(qemu_tablet_hid_report_descriptor);
772 } else if (s->kind == USB_KEYBOARD) {
773 memcpy(data, qemu_keyboard_hid_report_descriptor,
774 sizeof(qemu_keyboard_hid_report_descriptor));
775 ret = sizeof(qemu_keyboard_hid_report_descriptor);
776 }
777 break;
778 default:
779 goto fail;
780 }
781 break;
782 case GET_REPORT:
783 if (s->kind == USB_MOUSE)
784 ret = usb_mouse_poll(s, data, length);
785 else if (s->kind == USB_TABLET)
786 ret = usb_tablet_poll(s, data, length);
787 else if (s->kind == USB_KEYBOARD)
788 ret = usb_keyboard_poll(&s->kbd, data, length);
789 break;
790 case SET_REPORT:
791 if (s->kind == USB_KEYBOARD)
792 ret = usb_keyboard_write(&s->kbd, data, length);
793 else
794 goto fail;
795 break;
796 case GET_PROTOCOL:
797 if (s->kind != USB_KEYBOARD)
798 goto fail;
799 ret = 1;
800 data[0] = s->protocol;
801 break;
802 case SET_PROTOCOL:
803 if (s->kind != USB_KEYBOARD)
804 goto fail;
805 ret = 0;
806 s->protocol = value;
807 break;
808 case GET_IDLE:
809 ret = 1;
810 data[0] = s->idle;
811 break;
812 case SET_IDLE:
813 s->idle = (uint8_t) (value >> 8);
814 usb_hid_set_next_idle(s, qemu_get_clock(vm_clock));
815 ret = 0;
816 break;
817 default:
818 fail:
819 ret = USB_RET_STALL;
820 break;
821 }
822 return ret;
823 }
824
825 static int usb_hid_handle_data(USBDevice *dev, USBPacket *p)
826 {
827 USBHIDState *s = (USBHIDState *)dev;
828 int ret = 0;
829
830 switch(p->pid) {
831 case USB_TOKEN_IN:
832 if (p->devep == 1) {
833 int64_t curtime = qemu_get_clock(vm_clock);
834 if (!s->changed && (!s->idle || s->next_idle_clock - curtime > 0))
835 return USB_RET_NAK;
836 usb_hid_set_next_idle(s, curtime);
837 s->changed = 0;
838 if (s->kind == USB_MOUSE)
839 ret = usb_mouse_poll(s, p->data, p->len);
840 else if (s->kind == USB_TABLET)
841 ret = usb_tablet_poll(s, p->data, p->len);
842 else if (s->kind == USB_KEYBOARD)
843 ret = usb_keyboard_poll(&s->kbd, p->data, p->len);
844 } else {
845 goto fail;
846 }
847 break;
848 case USB_TOKEN_OUT:
849 default:
850 fail:
851 ret = USB_RET_STALL;
852 break;
853 }
854 return ret;
855 }
856
857 static void usb_hid_handle_destroy(USBDevice *dev)
858 {
859 USBHIDState *s = (USBHIDState *)dev;
860
861 switch(s->kind) {
862 case USB_KEYBOARD:
863 qemu_remove_kbd_event_handler();
864 break;
865 default:
866 qemu_remove_mouse_event_handler(s->ptr.eh_entry);
867 }
868 }
869
870 static int usb_hid_initfn(USBDevice *dev, int kind)
871 {
872 USBHIDState *s = DO_UPCAST(USBHIDState, dev, dev);
873 s->dev.speed = USB_SPEED_FULL;
874 s->kind = kind;
875
876 if (s->kind == USB_MOUSE) {
877 s->ptr.eh_entry = qemu_add_mouse_event_handler(usb_mouse_event, s,
878 0, "QEMU USB Mouse");
879 } else if (s->kind == USB_TABLET) {
880 s->ptr.eh_entry = qemu_add_mouse_event_handler(usb_tablet_event, s,
881 1, "QEMU USB Tablet");
882 }
883
884 /* Force poll routine to be run and grab input the first time. */
885 s->changed = 1;
886 return 0;
887 }
888
889 static int usb_tablet_initfn(USBDevice *dev)
890 {
891 return usb_hid_initfn(dev, USB_TABLET);
892 }
893
894 static int usb_mouse_initfn(USBDevice *dev)
895 {
896 return usb_hid_initfn(dev, USB_MOUSE);
897 }
898
899 static int usb_keyboard_initfn(USBDevice *dev)
900 {
901 return usb_hid_initfn(dev, USB_KEYBOARD);
902 }
903
904 void usb_hid_datain_cb(USBDevice *dev, void *opaque, void (*datain)(void *))
905 {
906 USBHIDState *s = (USBHIDState *)dev;
907
908 s->datain_opaque = opaque;
909 s->datain = datain;
910 }
911
912 static struct USBDeviceInfo hid_info[] = {
913 {
914 .product_desc = "QEMU USB Tablet",
915 .qdev.name = "usb-tablet",
916 .usbdevice_name = "tablet",
917 .qdev.size = sizeof(USBHIDState),
918 .init = usb_tablet_initfn,
919 .handle_packet = usb_generic_handle_packet,
920 .handle_reset = usb_mouse_handle_reset,
921 .handle_control = usb_hid_handle_control,
922 .handle_data = usb_hid_handle_data,
923 .handle_destroy = usb_hid_handle_destroy,
924 },{
925 .product_desc = "QEMU USB Mouse",
926 .qdev.name = "usb-mouse",
927 .usbdevice_name = "mouse",
928 .qdev.size = sizeof(USBHIDState),
929 .init = usb_mouse_initfn,
930 .handle_packet = usb_generic_handle_packet,
931 .handle_reset = usb_mouse_handle_reset,
932 .handle_control = usb_hid_handle_control,
933 .handle_data = usb_hid_handle_data,
934 .handle_destroy = usb_hid_handle_destroy,
935 },{
936 .product_desc = "QEMU USB Keyboard",
937 .qdev.name = "usb-kbd",
938 .usbdevice_name = "keyboard",
939 .qdev.size = sizeof(USBHIDState),
940 .init = usb_keyboard_initfn,
941 .handle_packet = usb_generic_handle_packet,
942 .handle_reset = usb_keyboard_handle_reset,
943 .handle_control = usb_hid_handle_control,
944 .handle_data = usb_hid_handle_data,
945 .handle_destroy = usb_hid_handle_destroy,
946 },{
947 /* end of list */
948 }
949 };
950
951 static void usb_hid_register_devices(void)
952 {
953 usb_qdev_register_many(hid_info);
954 }
955 device_init(usb_hid_register_devices)
QEmu