?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
scsi-disk: propagate the required alignment
[qemu/kevin.git] / hw / usb-hid.c
blob882d93346645ba79536aa03c899e3100ae7af9f1
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, 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 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 return;
464 }
465 case 0xe1 ... 0xe7:
466 if (keycode & (1 << 7)) {
467 s->modifiers &= ~(1 << (hid_code & 0x0f));
468 return;
469 }
470 case 0xe8 ... 0xef:
471 s->modifiers |= 1 << (hid_code & 0x0f);
472 return;
473 }
474
475 if (keycode & (1 << 7)) {
476 for (i = s->keys - 1; i >= 0; i --)
477 if (s->key[i] == hid_code) {
478 s->key[i] = s->key[-- s->keys];
479 s->key[s->keys] = 0x00;
480 usb_hid_changed(hs);
481 break;
482 }
483 if (i < 0)
484 return;
485 } else {
486 for (i = s->keys - 1; i >= 0; i --)
487 if (s->key[i] == hid_code)
488 break;
489 if (i < 0) {
490 if (s->keys < sizeof(s->key))
491 s->key[s->keys ++] = hid_code;
492 } else
493 return;
494 }
495
496 usb_hid_changed(hs);
497 }
498
499 static inline int int_clamp(int val, int vmin, int vmax)
500 {
501 if (val < vmin)
502 return vmin;
503 else if (val > vmax)
504 return vmax;
505 else
506 return val;
507 }
508
509 static int usb_mouse_poll(USBHIDState *hs, uint8_t *buf, int len)
510 {
511 int dx, dy, dz, b, l;
512 USBMouseState *s = &hs->ptr;
513
514 if (!s->mouse_grabbed) {
515 qemu_activate_mouse_event_handler(s->eh_entry);
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 qemu_activate_mouse_event_handler(s->eh_entry);
557 s->mouse_grabbed = 1;
558 }
559
560 dz = int_clamp(s->dz, -127, 127);
561 s->dz -= dz;
562
563 /* Appears we have to invert the wheel direction */
564 dz = 0 - dz;
565 b = 0;
566 if (s->buttons_state & MOUSE_EVENT_LBUTTON)
567 b |= 0x01;
568 if (s->buttons_state & MOUSE_EVENT_RBUTTON)
569 b |= 0x02;
570 if (s->buttons_state & MOUSE_EVENT_MBUTTON)
571 b |= 0x04;
572
573 buf[0] = b;
574 buf[1] = s->x & 0xff;
575 buf[2] = s->x >> 8;
576 buf[3] = s->y & 0xff;
577 buf[4] = s->y >> 8;
578 buf[5] = dz;
579 l = 6;
580
581 return l;
582 }
583
584 static int usb_keyboard_poll(USBKeyboardState *s, uint8_t *buf, int len)
585 {
586 if (len < 2)
587 return 0;
588
589 buf[0] = s->modifiers & 0xff;
590 buf[1] = 0;
591 if (s->keys > 6)
592 memset(buf + 2, USB_HID_USAGE_ERROR_ROLLOVER, MIN(8, len) - 2);
593 else
594 memcpy(buf + 2, s->key, MIN(8, len) - 2);
595
596 return MIN(8, len);
597 }
598
599 static int usb_keyboard_write(USBKeyboardState *s, uint8_t *buf, int len)
600 {
601 if (len > 0) {
602 int ledstate = 0;
603 /* 0x01: Num Lock LED
604 * 0x02: Caps Lock LED
605 * 0x04: Scroll Lock LED
606 * 0x08: Compose LED
607 * 0x10: Kana LED */
608 s->leds = buf[0];
609 if (s->leds & 0x04)
610 ledstate |= QEMU_SCROLL_LOCK_LED;
611 if (s->leds & 0x01)
612 ledstate |= QEMU_NUM_LOCK_LED;
613 if (s->leds & 0x02)
614 ledstate |= QEMU_CAPS_LOCK_LED;
615 kbd_put_ledstate(ledstate);
616 }
617 return 0;
618 }
619
620 static void usb_mouse_handle_reset(USBDevice *dev)
621 {
622 USBHIDState *s = (USBHIDState *)dev;
623
624 s->ptr.dx = 0;
625 s->ptr.dy = 0;
626 s->ptr.dz = 0;
627 s->ptr.x = 0;
628 s->ptr.y = 0;
629 s->ptr.buttons_state = 0;
630 s->protocol = 1;
631 }
632
633 static void usb_keyboard_handle_reset(USBDevice *dev)
634 {
635 USBHIDState *s = (USBHIDState *)dev;
636
637 qemu_add_kbd_event_handler(usb_keyboard_event, s);
638 s->protocol = 1;
639 }
640
641 static void usb_hid_set_next_idle(USBHIDState *s, int64_t curtime)
642 {
643 s->next_idle_clock = curtime + (get_ticks_per_sec() * s->idle * 4) / 1000;
644 }
645
646 static int usb_hid_handle_control(USBDevice *dev, int request, int value,
647 int index, int length, uint8_t *data)
648 {
649 USBHIDState *s = (USBHIDState *)dev;
650 int ret = 0;
651
652 switch(request) {
653 case DeviceRequest | USB_REQ_GET_STATUS:
654 data[0] = (1 << USB_DEVICE_SELF_POWERED) |
655 (dev->remote_wakeup << USB_DEVICE_REMOTE_WAKEUP);
656 data[1] = 0x00;
657 ret = 2;
658 break;
659 case DeviceOutRequest | USB_REQ_CLEAR_FEATURE:
660 if (value == USB_DEVICE_REMOTE_WAKEUP) {
661 dev->remote_wakeup = 0;
662 } else {
663 goto fail;
664 }
665 ret = 0;
666 break;
667 case DeviceOutRequest | USB_REQ_SET_FEATURE:
668 if (value == USB_DEVICE_REMOTE_WAKEUP) {
669 dev->remote_wakeup = 1;
670 } else {
671 goto fail;
672 }
673 ret = 0;
674 break;
675 case DeviceOutRequest | USB_REQ_SET_ADDRESS:
676 dev->addr = value;
677 ret = 0;
678 break;
679 case DeviceRequest | USB_REQ_GET_DESCRIPTOR:
680 switch(value >> 8) {
681 case USB_DT_DEVICE:
682 memcpy(data, qemu_mouse_dev_descriptor,
683 sizeof(qemu_mouse_dev_descriptor));
684 ret = sizeof(qemu_mouse_dev_descriptor);
685 break;
686 case USB_DT_CONFIG:
687 if (s->kind == USB_MOUSE) {
688 memcpy(data, qemu_mouse_config_descriptor,
689 sizeof(qemu_mouse_config_descriptor));
690 ret = sizeof(qemu_mouse_config_descriptor);
691 } else if (s->kind == USB_TABLET) {
692 memcpy(data, qemu_tablet_config_descriptor,
693 sizeof(qemu_tablet_config_descriptor));
694 ret = sizeof(qemu_tablet_config_descriptor);
695 } else if (s->kind == USB_KEYBOARD) {
696 memcpy(data, qemu_keyboard_config_descriptor,
697 sizeof(qemu_keyboard_config_descriptor));
698 ret = sizeof(qemu_keyboard_config_descriptor);
699 }
700 break;
701 case USB_DT_STRING:
702 switch(value & 0xff) {
703 case 0:
704 /* language ids */
705 data[0] = 4;
706 data[1] = 3;
707 data[2] = 0x09;
708 data[3] = 0x04;
709 ret = 4;
710 break;
711 case 1:
712 /* serial number */
713 ret = set_usb_string(data, "1");
714 break;
715 case 2:
716 /* product description */
717 ret = set_usb_string(data, s->dev.product_desc);
718 break;
719 case 3:
720 /* vendor description */
721 ret = set_usb_string(data, "QEMU " QEMU_VERSION);
722 break;
723 case 4:
724 ret = set_usb_string(data, "HID Mouse");
725 break;
726 case 5:
727 ret = set_usb_string(data, "HID Tablet");
728 break;
729 case 6:
730 ret = set_usb_string(data, "HID Keyboard");
731 break;
732 case 7:
733 ret = set_usb_string(data, "Endpoint1 Interrupt Pipe");
734 break;
735 default:
736 goto fail;
737 }
738 break;
739 default:
740 goto fail;
741 }
742 break;
743 case DeviceRequest | USB_REQ_GET_CONFIGURATION:
744 data[0] = 1;
745 ret = 1;
746 break;
747 case DeviceOutRequest | USB_REQ_SET_CONFIGURATION:
748 ret = 0;
749 break;
750 case DeviceRequest | USB_REQ_GET_INTERFACE:
751 data[0] = 0;
752 ret = 1;
753 break;
754 case DeviceOutRequest | USB_REQ_SET_INTERFACE:
755 ret = 0;
756 break;
757 /* hid specific requests */
758 case InterfaceRequest | USB_REQ_GET_DESCRIPTOR:
759 switch(value >> 8) {
760 case 0x22:
761 if (s->kind == USB_MOUSE) {
762 memcpy(data, qemu_mouse_hid_report_descriptor,
763 sizeof(qemu_mouse_hid_report_descriptor));
764 ret = sizeof(qemu_mouse_hid_report_descriptor);
765 } else if (s->kind == USB_TABLET) {
766 memcpy(data, qemu_tablet_hid_report_descriptor,
767 sizeof(qemu_tablet_hid_report_descriptor));
768 ret = sizeof(qemu_tablet_hid_report_descriptor);
769 } else if (s->kind == USB_KEYBOARD) {
770 memcpy(data, qemu_keyboard_hid_report_descriptor,
771 sizeof(qemu_keyboard_hid_report_descriptor));
772 ret = sizeof(qemu_keyboard_hid_report_descriptor);
773 }
774 break;
775 default:
776 goto fail;
777 }
778 break;
779 case GET_REPORT:
780 if (s->kind == USB_MOUSE)
781 ret = usb_mouse_poll(s, data, length);
782 else if (s->kind == USB_TABLET)
783 ret = usb_tablet_poll(s, data, length);
784 else if (s->kind == USB_KEYBOARD)
785 ret = usb_keyboard_poll(&s->kbd, data, length);
786 break;
787 case SET_REPORT:
788 if (s->kind == USB_KEYBOARD)
789 ret = usb_keyboard_write(&s->kbd, data, length);
790 else
791 goto fail;
792 break;
793 case GET_PROTOCOL:
794 if (s->kind != USB_KEYBOARD)
795 goto fail;
796 ret = 1;
797 data[0] = s->protocol;
798 break;
799 case SET_PROTOCOL:
800 if (s->kind != USB_KEYBOARD)
801 goto fail;
802 ret = 0;
803 s->protocol = value;
804 break;
805 case GET_IDLE:
806 ret = 1;
807 data[0] = s->idle;
808 break;
809 case SET_IDLE:
810 s->idle = (uint8_t) (value >> 8);
811 usb_hid_set_next_idle(s, qemu_get_clock(vm_clock));
812 ret = 0;
813 break;
814 default:
815 fail:
816 ret = USB_RET_STALL;
817 break;
818 }
819 return ret;
820 }
821
822 static int usb_hid_handle_data(USBDevice *dev, USBPacket *p)
823 {
824 USBHIDState *s = (USBHIDState *)dev;
825 int ret = 0;
826
827 switch(p->pid) {
828 case USB_TOKEN_IN:
829 if (p->devep == 1) {
830 int64_t curtime = qemu_get_clock(vm_clock);
831 if (!s->changed && (!s->idle || s->next_idle_clock - curtime > 0))
832 return USB_RET_NAK;
833 usb_hid_set_next_idle(s, curtime);
834 s->changed = 0;
835 if (s->kind == USB_MOUSE)
836 ret = usb_mouse_poll(s, p->data, p->len);
837 else if (s->kind == USB_TABLET)
838 ret = usb_tablet_poll(s, p->data, p->len);
839 else if (s->kind == USB_KEYBOARD)
840 ret = usb_keyboard_poll(&s->kbd, p->data, p->len);
841 } else {
842 goto fail;
843 }
844 break;
845 case USB_TOKEN_OUT:
846 default:
847 fail:
848 ret = USB_RET_STALL;
849 break;
850 }
851 return ret;
852 }
853
854 static void usb_hid_handle_destroy(USBDevice *dev)
855 {
856 USBHIDState *s = (USBHIDState *)dev;
857
858 switch(s->kind) {
859 case USB_KEYBOARD:
860 qemu_remove_kbd_event_handler();
861 break;
862 default:
863 qemu_remove_mouse_event_handler(s->ptr.eh_entry);
864 }
865 }
866
867 static int usb_hid_initfn(USBDevice *dev, int kind)
868 {
869 USBHIDState *s = DO_UPCAST(USBHIDState, dev, dev);
870 s->dev.speed = USB_SPEED_FULL;
871 s->kind = kind;
872
873 if (s->kind == USB_MOUSE) {
874 s->ptr.eh_entry = qemu_add_mouse_event_handler(usb_mouse_event, s,
875 0, "QEMU USB Mouse");
876 } else if (s->kind == USB_TABLET) {
877 s->ptr.eh_entry = qemu_add_mouse_event_handler(usb_tablet_event, s,
878 1, "QEMU USB Tablet");
879 }
880
881 /* Force poll routine to be run and grab input the first time. */
882 s->changed = 1;
883 return 0;
884 }
885
886 static int usb_tablet_initfn(USBDevice *dev)
887 {
888 return usb_hid_initfn(dev, USB_TABLET);
889 }
890
891 static int usb_mouse_initfn(USBDevice *dev)
892 {
893 return usb_hid_initfn(dev, USB_MOUSE);
894 }
895
896 static int usb_keyboard_initfn(USBDevice *dev)
897 {
898 return usb_hid_initfn(dev, USB_KEYBOARD);
899 }
900
901 void usb_hid_datain_cb(USBDevice *dev, void *opaque, void (*datain)(void *))
902 {
903 USBHIDState *s = (USBHIDState *)dev;
904
905 s->datain_opaque = opaque;
906 s->datain = datain;
907 }
908
909 static struct USBDeviceInfo hid_info[] = {
910 {
911 .product_desc = "QEMU USB Tablet",
912 .qdev.name = "usb-tablet",
913 .usbdevice_name = "tablet",
914 .qdev.size = sizeof(USBHIDState),
915 .init = usb_tablet_initfn,
916 .handle_packet = usb_generic_handle_packet,
917 .handle_reset = usb_mouse_handle_reset,
918 .handle_control = usb_hid_handle_control,
919 .handle_data = usb_hid_handle_data,
920 .handle_destroy = usb_hid_handle_destroy,
921 },{
922 .product_desc = "QEMU USB Mouse",
923 .qdev.name = "usb-mouse",
924 .usbdevice_name = "mouse",
925 .qdev.size = sizeof(USBHIDState),
926 .init = usb_mouse_initfn,
927 .handle_packet = usb_generic_handle_packet,
928 .handle_reset = usb_mouse_handle_reset,
929 .handle_control = usb_hid_handle_control,
930 .handle_data = usb_hid_handle_data,
931 .handle_destroy = usb_hid_handle_destroy,
932 },{
933 .product_desc = "QEMU USB Keyboard",
934 .qdev.name = "usb-kbd",
935 .usbdevice_name = "keyboard",
936 .qdev.size = sizeof(USBHIDState),
937 .init = usb_keyboard_initfn,
938 .handle_packet = usb_generic_handle_packet,
939 .handle_reset = usb_keyboard_handle_reset,
940 .handle_control = usb_hid_handle_control,
941 .handle_data = usb_hid_handle_data,
942 .handle_destroy = usb_hid_handle_destroy,
943 },{
944 /* end of list */
945 }
946 };
947
948 static void usb_hid_register_devices(void)
949 {
950 usb_qdev_register_many(hid_info);
951 }
952 device_init(usb_hid_register_devices)
Random patches