]> 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/hid: add hid_pointer_activate, use it
[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"
d8dfad9c 29#include "qemu-timer.h"
dcfda673 30#include "hid.h"
59ae540c
FB		 31
32/* HID interface requests */
33#define GET_REPORT 0xa101
34#define GET_IDLE 0xa102
35#define GET_PROTOCOL 0xa103
47b2d338 36#define SET_REPORT 0x2109
59ae540c
FB		 37#define SET_IDLE 0x210a
38#define SET_PROTOCOL 0x210b
39
47b2d338
AZ		 40/* HID descriptor types */
41#define USB_DT_HID 0x21
42#define USB_DT_REPORT 0x22
43#define USB_DT_PHY 0x23
44
0d878eec
GH		 45typedef struct USBHIDState {
46 USBDevice dev;
47 HIDState hid;
47e699dc
AZ		 48 void *datain_opaque;
49 void (*datain)(void *);
47b2d338
AZ		 50} USBHIDState;
51
0e4e9695
GH		 52enum {
53 STR_MANUFACTURER = 1,
54 STR_PRODUCT_MOUSE,
55 STR_PRODUCT_TABLET,
56 STR_PRODUCT_KEYBOARD,
57 STR_SERIALNUMBER,
58 STR_CONFIG_MOUSE,
59 STR_CONFIG_TABLET,
60 STR_CONFIG_KEYBOARD,
59ae540c
FB		 61};
62
0e4e9695
GH		 63static const USBDescStrings desc_strings = {
64 [STR_MANUFACTURER] = "QEMU " QEMU_VERSION,
65 [STR_PRODUCT_MOUSE] = "QEMU USB Mouse",
66 [STR_PRODUCT_TABLET] = "QEMU USB Tablet",
67 [STR_PRODUCT_KEYBOARD] = "QEMU USB Keyboard",
7b074a22 68 [STR_SERIALNUMBER] = "42", /* == remote wakeup works */
0e4e9695
GH		 69 [STR_CONFIG_MOUSE] = "HID Mouse",
70 [STR_CONFIG_TABLET] = "HID Tablet",
71 [STR_CONFIG_KEYBOARD] = "HID Keyboard",
09b26c5e
FB		 72};
73
0e4e9695
GH		 74static const USBDescIface desc_iface_mouse = {
75 .bInterfaceNumber = 0,
76 .bNumEndpoints = 1,
77 .bInterfaceClass = USB_CLASS_HID,
78 .bInterfaceSubClass = 0x01, /* boot */
79 .bInterfaceProtocol = 0x02,
80 .ndesc = 1,
81 .descs = (USBDescOther[]) {
82 {
83 /* HID descriptor */
84 .data = (uint8_t[]) {
85 0x09, /* u8 bLength */
86 USB_DT_HID, /* u8 bDescriptorType */
87 0x01, 0x00, /* u16 HID_class */
88 0x00, /* u8 country_code */
89 0x01, /* u8 num_descriptors */
90 USB_DT_REPORT, /* u8 type: Report */
91 52, 0, /* u16 len */
92 },
93 },
94 },
95 .eps = (USBDescEndpoint[]) {
96 {
97 .bEndpointAddress = USB_DIR_IN | 0x01,
98 .bmAttributes = USB_ENDPOINT_XFER_INT,
99 .wMaxPacketSize = 4,
100 .bInterval = 0x0a,
101 },
102 },
59ae540c
FB		 103};
104
0e4e9695
GH		 105static const USBDescIface desc_iface_tablet = {
106 .bInterfaceNumber = 0,
107 .bNumEndpoints = 1,
108 .bInterfaceClass = USB_CLASS_HID,
0e4e9695
GH		 109 .bInterfaceProtocol = 0x02,
110 .ndesc = 1,
111 .descs = (USBDescOther[]) {
112 {
113 /* HID descriptor */
114 .data = (uint8_t[]) {
115 0x09, /* u8 bLength */
116 USB_DT_HID, /* u8 bDescriptorType */
117 0x01, 0x00, /* u16 HID_class */
118 0x00, /* u8 country_code */
119 0x01, /* u8 num_descriptors */
120 USB_DT_REPORT, /* u8 type: Report */
121 74, 0, /* u16 len */
122 },
123 },
124 },
125 .eps = (USBDescEndpoint[]) {
126 {
127 .bEndpointAddress = USB_DIR_IN | 0x01,
128 .bmAttributes = USB_ENDPOINT_XFER_INT,
129 .wMaxPacketSize = 8,
130 .bInterval = 0x0a,
131 },
132 },
133};
134
135static const USBDescIface desc_iface_keyboard = {
136 .bInterfaceNumber = 0,
137 .bNumEndpoints = 1,
138 .bInterfaceClass = USB_CLASS_HID,
139 .bInterfaceSubClass = 0x01, /* boot */
140 .bInterfaceProtocol = 0x01, /* keyboard */
141 .ndesc = 1,
142 .descs = (USBDescOther[]) {
143 {
144 /* HID descriptor */
145 .data = (uint8_t[]) {
146 0x09, /* u8 bLength */
147 USB_DT_HID, /* u8 bDescriptorType */
148 0x11, 0x01, /* u16 HID_class */
149 0x00, /* u8 country_code */
150 0x01, /* u8 num_descriptors */
151 USB_DT_REPORT, /* u8 type: Report */
152 0x3f, 0, /* u16 len */
153 },
154 },
155 },
156 .eps = (USBDescEndpoint[]) {
157 {
158 .bEndpointAddress = USB_DIR_IN | 0x01,
159 .bmAttributes = USB_ENDPOINT_XFER_INT,
160 .wMaxPacketSize = 8,
161 .bInterval = 0x0a,
162 },
163 },
164};
165
166static const USBDescDevice desc_device_mouse = {
167 .bcdUSB = 0x0100,
168 .bMaxPacketSize0 = 8,
169 .bNumConfigurations = 1,
170 .confs = (USBDescConfig[]) {
171 {
172 .bNumInterfaces = 1,
173 .bConfigurationValue = 1,
174 .iConfiguration = STR_CONFIG_MOUSE,
175 .bmAttributes = 0xa0,
176 .bMaxPower = 50,
add75088 177 .nif = 1,
0e4e9695
GH		 178 .ifs = &desc_iface_mouse,
179 },
180 },
181};
182
183static const USBDescDevice desc_device_tablet = {
184 .bcdUSB = 0x0100,
185 .bMaxPacketSize0 = 8,
186 .bNumConfigurations = 1,
187 .confs = (USBDescConfig[]) {
188 {
189 .bNumInterfaces = 1,
190 .bConfigurationValue = 1,
191 .iConfiguration = STR_CONFIG_TABLET,
192 .bmAttributes = 0xa0,
193 .bMaxPower = 50,
add75088 194 .nif = 1,
0e4e9695
GH		 195 .ifs = &desc_iface_tablet,
196 },
197 },
198};
199
200static const USBDescDevice desc_device_keyboard = {
201 .bcdUSB = 0x0100,
202 .bMaxPacketSize0 = 8,
203 .bNumConfigurations = 1,
204 .confs = (USBDescConfig[]) {
205 {
206 .bNumInterfaces = 1,
207 .bConfigurationValue = 1,
208 .iConfiguration = STR_CONFIG_KEYBOARD,
209 .bmAttributes = 0xa0,
210 .bMaxPower = 50,
add75088 211 .nif = 1,
0e4e9695
GH		 212 .ifs = &desc_iface_keyboard,
213 },
214 },
215};
216
217static const USBDesc desc_mouse = {
218 .id = {
219 .idVendor = 0x0627,
220 .idProduct = 0x0001,
221 .bcdDevice = 0,
222 .iManufacturer = STR_MANUFACTURER,
223 .iProduct = STR_PRODUCT_MOUSE,
224 .iSerialNumber = STR_SERIALNUMBER,
225 },
226 .full = &desc_device_mouse,
227 .str = desc_strings,
228};
229
230static const USBDesc desc_tablet = {
231 .id = {
232 .idVendor = 0x0627,
233 .idProduct = 0x0001,
234 .bcdDevice = 0,
235 .iManufacturer = STR_MANUFACTURER,
236 .iProduct = STR_PRODUCT_TABLET,
237 .iSerialNumber = STR_SERIALNUMBER,
238 },
239 .full = &desc_device_tablet,
240 .str = desc_strings,
241};
242
243static const USBDesc desc_keyboard = {
244 .id = {
245 .idVendor = 0x0627,
246 .idProduct = 0x0001,
247 .bcdDevice = 0,
248 .iManufacturer = STR_MANUFACTURER,
249 .iProduct = STR_PRODUCT_KEYBOARD,
250 .iSerialNumber = STR_SERIALNUMBER,
251 },
252 .full = &desc_device_keyboard,
253 .str = desc_strings,
47b2d338
AZ		 254};
255
59ae540c 256static const uint8_t qemu_mouse_hid_report_descriptor[] = {
976f8eef
AZ		 257 0x05, 0x01, /* Usage Page (Generic Desktop) */
258 0x09, 0x02, /* Usage (Mouse) */
259 0xa1, 0x01, /* Collection (Application) */
260 0x09, 0x01, /* Usage (Pointer) */
261 0xa1, 0x00, /* Collection (Physical) */
262 0x05, 0x09, /* Usage Page (Button) */
263 0x19, 0x01, /* Usage Minimum (1) */
264 0x29, 0x03, /* Usage Maximum (3) */
265 0x15, 0x00, /* Logical Minimum (0) */
266 0x25, 0x01, /* Logical Maximum (1) */
267 0x95, 0x03, /* Report Count (3) */
268 0x75, 0x01, /* Report Size (1) */
269 0x81, 0x02, /* Input (Data, Variable, Absolute) */
270 0x95, 0x01, /* Report Count (1) */
271 0x75, 0x05, /* Report Size (5) */
272 0x81, 0x01, /* Input (Constant) */
273 0x05, 0x01, /* Usage Page (Generic Desktop) */
274 0x09, 0x30, /* Usage (X) */
275 0x09, 0x31, /* Usage (Y) */
276 0x09, 0x38, /* Usage (Wheel) */
277 0x15, 0x81, /* Logical Minimum (-0x7f) */
278 0x25, 0x7f, /* Logical Maximum (0x7f) */
279 0x75, 0x08, /* Report Size (8) */
280 0x95, 0x03, /* Report Count (3) */
281 0x81, 0x06, /* Input (Data, Variable, Relative) */
282 0xc0, /* End Collection */
283 0xc0, /* End Collection */
59ae540c
FB		 284};
285
09b26c5e 286static const uint8_t qemu_tablet_hid_report_descriptor[] = {
976f8eef
AZ		 287 0x05, 0x01, /* Usage Page (Generic Desktop) */
288 0x09, 0x01, /* Usage (Pointer) */
289 0xa1, 0x01, /* Collection (Application) */
290 0x09, 0x01, /* Usage (Pointer) */
291 0xa1, 0x00, /* Collection (Physical) */
292 0x05, 0x09, /* Usage Page (Button) */
293 0x19, 0x01, /* Usage Minimum (1) */
294 0x29, 0x03, /* Usage Maximum (3) */
295 0x15, 0x00, /* Logical Minimum (0) */
296 0x25, 0x01, /* Logical Maximum (1) */
297 0x95, 0x03, /* Report Count (3) */
298 0x75, 0x01, /* Report Size (1) */
299 0x81, 0x02, /* Input (Data, Variable, Absolute) */
300 0x95, 0x01, /* Report Count (1) */
301 0x75, 0x05, /* Report Size (5) */
302 0x81, 0x01, /* Input (Constant) */
303 0x05, 0x01, /* Usage Page (Generic Desktop) */
304 0x09, 0x30, /* Usage (X) */
305 0x09, 0x31, /* Usage (Y) */
306 0x15, 0x00, /* Logical Minimum (0) */
de5c2d0a 307 0x26, 0xff, 0x7f, /* Logical Maximum (0x7fff) */
976f8eef 308 0x35, 0x00, /* Physical Minimum (0) */
de5c2d0a 309 0x46, 0xff, 0x7f, /* Physical Maximum (0x7fff) */
976f8eef
AZ		 310 0x75, 0x10, /* Report Size (16) */
311 0x95, 0x02, /* Report Count (2) */
312 0x81, 0x02, /* Input (Data, Variable, Absolute) */
313 0x05, 0x01, /* Usage Page (Generic Desktop) */
314 0x09, 0x38, /* Usage (Wheel) */
315 0x15, 0x81, /* Logical Minimum (-0x7f) */
316 0x25, 0x7f, /* Logical Maximum (0x7f) */
317 0x35, 0x00, /* Physical Minimum (same as logical) */
318 0x45, 0x00, /* Physical Maximum (same as logical) */
319 0x75, 0x08, /* Report Size (8) */
320 0x95, 0x01, /* Report Count (1) */
321 0x81, 0x06, /* Input (Data, Variable, Relative) */
322 0xc0, /* End Collection */
323 0xc0, /* End Collection */
09b26c5e
FB		 324};
325
47b2d338
AZ		 326static const uint8_t qemu_keyboard_hid_report_descriptor[] = {
327 0x05, 0x01, /* Usage Page (Generic Desktop) */
328 0x09, 0x06, /* Usage (Keyboard) */
329 0xa1, 0x01, /* Collection (Application) */
330 0x75, 0x01, /* Report Size (1) */
331 0x95, 0x08, /* Report Count (8) */
332 0x05, 0x07, /* Usage Page (Key Codes) */
333 0x19, 0xe0, /* Usage Minimum (224) */
334 0x29, 0xe7, /* Usage Maximum (231) */
335 0x15, 0x00, /* Logical Minimum (0) */
336 0x25, 0x01, /* Logical Maximum (1) */
337 0x81, 0x02, /* Input (Data, Variable, Absolute) */
338 0x95, 0x01, /* Report Count (1) */
339 0x75, 0x08, /* Report Size (8) */
340 0x81, 0x01, /* Input (Constant) */
341 0x95, 0x05, /* Report Count (5) */
342 0x75, 0x01, /* Report Size (1) */
343 0x05, 0x08, /* Usage Page (LEDs) */
344 0x19, 0x01, /* Usage Minimum (1) */
345 0x29, 0x05, /* Usage Maximum (5) */
346 0x91, 0x02, /* Output (Data, Variable, Absolute) */
347 0x95, 0x01, /* Report Count (1) */
348 0x75, 0x03, /* Report Size (3) */
349 0x91, 0x01, /* Output (Constant) */
350 0x95, 0x06, /* Report Count (6) */
351 0x75, 0x08, /* Report Size (8) */
352 0x15, 0x00, /* Logical Minimum (0) */
353 0x25, 0xff, /* Logical Maximum (255) */
354 0x05, 0x07, /* Usage Page (Key Codes) */
355 0x19, 0x00, /* Usage Minimum (0) */
356 0x29, 0xff, /* Usage Maximum (255) */
357 0x81, 0x00, /* Input (Data, Array) */
358 0xc0, /* End Collection */
359};
360
8bde6805 361static void usb_hid_changed(HIDState *hs)
47e699dc 362{
8bde6805 363 USBHIDState *us = container_of(hs, USBHIDState, hid);
47e699dc 364
8bde6805
GH		 365 if (us->datain) {
366 us->datain(us->datain_opaque);
367 }
ac57bbb6 368
8bde6805 369 usb_wakeup(&us->dev);
47e699dc
AZ		 370}
371
8bde6805 372static void usb_hid_handle_reset(USBDevice *dev)
47b2d338 373{
0d878eec
GH		 374 USBHIDState *us = DO_UPCAST(USBHIDState, dev, dev);
375
dcfda673 376 hid_reset(&us->hid);
68735b6c
KC		 377}
378
007fd62f
HG		 379static int usb_hid_handle_control(USBDevice *dev, USBPacket *p,
380 int request, int value, int index, int length, uint8_t *data)
59ae540c 381{
0d878eec
GH		 382 USBHIDState *us = DO_UPCAST(USBHIDState, dev, dev);
383 HIDState *hs = &us->hid;
0e4e9695 384 int ret;
59ae540c 385
007fd62f 386 ret = usb_desc_handle_control(dev, p, request, value, index, length, data);
0e4e9695
GH		 387 if (ret >= 0) {
388 return ret;
389 }
59ae540c 390
0e4e9695 391 ret = 0;
0d878eec 392 switch (request) {
59ae540c
FB		 393 case DeviceRequest | USB_REQ_GET_INTERFACE:
394 data[0] = 0;
395 ret = 1;
396 break;
397 case DeviceOutRequest | USB_REQ_SET_INTERFACE:
398 ret = 0;
399 break;
400 /* hid specific requests */
401 case InterfaceRequest | USB_REQ_GET_DESCRIPTOR:
0d878eec 402 switch (value >> 8) {
59ae540c 403 case 0x22:
0d878eec 404 if (hs->kind == HID_MOUSE) {
5fafdf24 405 memcpy(data, qemu_mouse_hid_report_descriptor,
09b26c5e
FB		 406 sizeof(qemu_mouse_hid_report_descriptor));
407 ret = sizeof(qemu_mouse_hid_report_descriptor);
0d878eec
GH		 408 } else if (hs->kind == HID_TABLET) {
409 memcpy(data, qemu_tablet_hid_report_descriptor,
09b26c5e
FB		 410 sizeof(qemu_tablet_hid_report_descriptor));
411 ret = sizeof(qemu_tablet_hid_report_descriptor);
0d878eec 412 } else if (hs->kind == HID_KEYBOARD) {
5fafdf24 413 memcpy(data, qemu_keyboard_hid_report_descriptor,
47b2d338
AZ		 414 sizeof(qemu_keyboard_hid_report_descriptor));
415 ret = sizeof(qemu_keyboard_hid_report_descriptor);
416 }
417 break;
59ae540c
FB		 418 default:
419 goto fail;
420 }
421 break;
422 case GET_REPORT:
0d878eec
GH		 423 if (hs->kind == HID_MOUSE || hs->kind == HID_TABLET) {
424 ret = hid_pointer_poll(hs, data, length);
425 } else if (hs->kind == HID_KEYBOARD) {
426 ret = hid_keyboard_poll(hs, data, length);
e7e73892 427 }
47b2d338
AZ		 428 break;
429 case SET_REPORT:
0d878eec
GH		 430 if (hs->kind == HID_KEYBOARD) {
431 ret = hid_keyboard_write(hs, data, length);
432 } else {
47b2d338 433 goto fail;
0d878eec 434 }
47b2d338
AZ		 435 break;
436 case GET_PROTOCOL:
0d878eec 437 if (hs->kind != HID_KEYBOARD && hs->kind != HID_MOUSE) {
47b2d338 438 goto fail;
0d878eec 439 }
47b2d338 440 ret = 1;
b069d348 441 data[0] = hs->protocol;
47b2d338
AZ		 442 break;
443 case SET_PROTOCOL:
0d878eec 444 if (hs->kind != HID_KEYBOARD && hs->kind != HID_MOUSE) {
47b2d338 445 goto fail;
0d878eec 446 }
47b2d338 447 ret = 0;
b069d348 448 hs->protocol = value;
47b2d338
AZ		 449 break;
450 case GET_IDLE:
451 ret = 1;
b069d348 452 data[0] = hs->idle;
59ae540c
FB		 453 break;
454 case SET_IDLE:
b069d348
GH		 455 hs->idle = (uint8_t) (value >> 8);
456 hid_set_next_idle(hs, qemu_get_clock_ns(vm_clock));
21635e12
GH		 457 if (hs->kind == HID_MOUSE || hs->kind == HID_TABLET) {
458 hid_pointer_activate(hs);
459 }
59ae540c
FB		 460 ret = 0;
461 break;
462 default:
463 fail:
464 ret = USB_RET_STALL;
465 break;
466 }
467 return ret;
468}
469
47b2d338 470static int usb_hid_handle_data(USBDevice *dev, USBPacket *p)
59ae540c 471{
0d878eec
GH		 472 USBHIDState *us = DO_UPCAST(USBHIDState, dev, dev);
473 HIDState *hs = &us->hid;
4f4321c1 474 uint8_t buf[p->iov.size];
09b26c5e 475 int ret = 0;
59ae540c 476
0d878eec 477 switch (p->pid) {
59ae540c 478 case USB_TOKEN_IN:
4d611c9a 479 if (p->devep == 1) {
74475455 480 int64_t curtime = qemu_get_clock_ns(vm_clock);
38931fa8 481 if (!hid_has_events(hs) &&
b069d348 482 (!hs->idle || hs->next_idle_clock - curtime > 0)) {
117b3ae6 483 return USB_RET_NAK;
13f8b97a 484 }
b069d348 485 hid_set_next_idle(hs, curtime);
0d878eec
GH		 486 if (hs->kind == HID_MOUSE || hs->kind == HID_TABLET) {
487 ret = hid_pointer_poll(hs, buf, p->iov.size);
488 } else if (hs->kind == HID_KEYBOARD) {
489 ret = hid_keyboard_poll(hs, buf, p->iov.size);
13f8b97a 490 }
4f4321c1 491 usb_packet_copy(p, buf, ret);
59ae540c
FB		 492 } else {
493 goto fail;
494 }
495 break;
496 case USB_TOKEN_OUT:
497 default:
498 fail:
499 ret = USB_RET_STALL;
500 break;
501 }
502 return ret;
503}
504
8bde6805 505static void usb_hid_handle_destroy(USBDevice *dev)
09b26c5e 506{
0d878eec 507 USBHIDState *us = DO_UPCAST(USBHIDState, dev, dev);
a980a065 508
8bde6805
GH		 509 hid_free(&us->hid);
510}
511
8bde6805
GH		 512static int usb_hid_initfn(USBDevice *dev, int kind)
513{
514 USBHIDState *us = DO_UPCAST(USBHIDState, dev, dev);
515
516 usb_desc_init(dev);
517 hid_init(&us->hid, kind, usb_hid_changed);
806b6024 518 return 0;
09b26c5e
FB		 519}
520
806b6024 521static int usb_tablet_initfn(USBDevice *dev)
59ae540c 522{
0d878eec 523 return usb_hid_initfn(dev, HID_TABLET);
806b6024 524}
59ae540c 525
806b6024
GH		 526static int usb_mouse_initfn(USBDevice *dev)
527{
0d878eec 528 return usb_hid_initfn(dev, HID_MOUSE);
806b6024 529}
59ae540c 530
806b6024
GH		 531static int usb_keyboard_initfn(USBDevice *dev)
532{
0d878eec 533 return usb_hid_initfn(dev, HID_KEYBOARD);
806b6024 534}
59ae540c 535
47e699dc
AZ		 536void usb_hid_datain_cb(USBDevice *dev, void *opaque, void (*datain)(void *))
537{
538 USBHIDState *s = (USBHIDState *)dev;
539
540 s->datain_opaque = opaque;
541 s->datain = datain;
542}
806b6024 543
ee59e6b3
GH		 544static int usb_hid_post_load(void *opaque, int version_id)
545{
546 USBHIDState *s = opaque;
547
b069d348
GH		 548 if (s->hid.idle) {
549 hid_set_next_idle(&s->hid, qemu_get_clock_ns(vm_clock));
ee59e6b3
GH		 550 }
551 return 0;
552}
553
554static const VMStateDescription vmstate_usb_ptr_queue = {
555 .name = "usb-ptr-queue",
556 .version_id = 1,
557 .minimum_version_id = 1,
558 .fields = (VMStateField []) {
0d878eec
GH		 559 VMSTATE_INT32(xdx, HIDPointerEvent),
560 VMSTATE_INT32(ydy, HIDPointerEvent),
561 VMSTATE_INT32(dz, HIDPointerEvent),
562 VMSTATE_INT32(buttons_state, HIDPointerEvent),
ee59e6b3
GH		 563 VMSTATE_END_OF_LIST()
564 }
565};
566static const VMStateDescription vmstate_usb_ptr = {
567 .name = "usb-ptr",
568 .version_id = 1,
569 .minimum_version_id = 1,
570 .post_load = usb_hid_post_load,
571 .fields = (VMStateField []) {
572 VMSTATE_USB_DEVICE(dev, USBHIDState),
0d878eec
GH		 573 VMSTATE_STRUCT_ARRAY(hid.ptr.queue, USBHIDState, QUEUE_LENGTH, 0,
574 vmstate_usb_ptr_queue, HIDPointerEvent),
575 VMSTATE_UINT32(hid.head, USBHIDState),
576 VMSTATE_UINT32(hid.n, USBHIDState),
b069d348
GH		 577 VMSTATE_INT32(hid.protocol, USBHIDState),
578 VMSTATE_UINT8(hid.idle, USBHIDState),
ee59e6b3
GH		 579 VMSTATE_END_OF_LIST()
580 }
581};
582
583static const VMStateDescription vmstate_usb_kbd = {
584 .name = "usb-kbd",
585 .version_id = 1,
586 .minimum_version_id = 1,
587 .post_load = usb_hid_post_load,
588 .fields = (VMStateField []) {
589 VMSTATE_USB_DEVICE(dev, USBHIDState),
0d878eec
GH		 590 VMSTATE_UINT32_ARRAY(hid.kbd.keycodes, USBHIDState, QUEUE_LENGTH),
591 VMSTATE_UINT32(hid.head, USBHIDState),
592 VMSTATE_UINT32(hid.n, USBHIDState),
593 VMSTATE_UINT16(hid.kbd.modifiers, USBHIDState),
594 VMSTATE_UINT8(hid.kbd.leds, USBHIDState),
595 VMSTATE_UINT8_ARRAY(hid.kbd.key, USBHIDState, 16),
596 VMSTATE_INT32(hid.kbd.keys, USBHIDState),
b069d348
GH		 597 VMSTATE_INT32(hid.protocol, USBHIDState),
598 VMSTATE_UINT8(hid.idle, USBHIDState),
ee59e6b3
GH		 599 VMSTATE_END_OF_LIST()
600 }
601};
602
806b6024
GH		 603static struct USBDeviceInfo hid_info[] = {
604 {
06384698 605 .product_desc = "QEMU USB Tablet",
556cd098 606 .qdev.name = "usb-tablet",
fa7c70c3 607 .usbdevice_name = "tablet",
806b6024 608 .qdev.size = sizeof(USBHIDState),
ee59e6b3 609 .qdev.vmsd = &vmstate_usb_ptr,
0e4e9695 610 .usb_desc = &desc_tablet,
806b6024
GH		 611 .init = usb_tablet_initfn,
612 .handle_packet = usb_generic_handle_packet,
8bde6805 613 .handle_reset = usb_hid_handle_reset,
806b6024
GH		 614 .handle_control = usb_hid_handle_control,
615 .handle_data = usb_hid_handle_data,
616 .handle_destroy = usb_hid_handle_destroy,
617 },{
06384698 618 .product_desc = "QEMU USB Mouse",
556cd098 619 .qdev.name = "usb-mouse",
fa7c70c3 620 .usbdevice_name = "mouse",
806b6024 621 .qdev.size = sizeof(USBHIDState),
ee59e6b3 622 .qdev.vmsd = &vmstate_usb_ptr,
0e4e9695 623 .usb_desc = &desc_mouse,
806b6024
GH		 624 .init = usb_mouse_initfn,
625 .handle_packet = usb_generic_handle_packet,
8bde6805 626 .handle_reset = usb_hid_handle_reset,
806b6024
GH		 627 .handle_control = usb_hid_handle_control,
628 .handle_data = usb_hid_handle_data,
629 .handle_destroy = usb_hid_handle_destroy,
630 },{
06384698 631 .product_desc = "QEMU USB Keyboard",
556cd098 632 .qdev.name = "usb-kbd",
fa7c70c3 633 .usbdevice_name = "keyboard",
806b6024 634 .qdev.size = sizeof(USBHIDState),
ee59e6b3 635 .qdev.vmsd = &vmstate_usb_kbd,
0e4e9695 636 .usb_desc = &desc_keyboard,
806b6024
GH		 637 .init = usb_keyboard_initfn,
638 .handle_packet = usb_generic_handle_packet,
8bde6805 639 .handle_reset = usb_hid_handle_reset,
806b6024
GH		 640 .handle_control = usb_hid_handle_control,
641 .handle_data = usb_hid_handle_data,
642 .handle_destroy = usb_hid_handle_destroy,
643 },{
644 /* end of list */
645 }
646};
647
648static void usb_hid_register_devices(void)
649{
650 usb_qdev_register_many(hid_info);
651}
652device_init(usb_hid_register_devices)
Empty description
This page took 0.701223 seconds and 4 git commands to generate.