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