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