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 26 #include "qemu/osdep.h" 27 #include "ui/console.h" 28 #include "hw/usb.h" 29 #include "migration/vmstate.h" 30 #include "desc.h" 31 #include "qapi/error.h" 32 #include "qemu/module.h" 33 #include "qemu/timer.h" 34 #include "hw/input/hid.h" 35 #include "hw/usb/hid.h" 36 #include "hw/qdev-properties.h" 37 38 typedef struct USBHIDState { 39 USBDevice dev; 40 USBEndpoint *intr; 41 HIDState hid; 42 uint32_t usb_version; 43 char *display; 44 uint32_t head; 45 } USBHIDState; 46 47 #define TYPE_USB_HID "usb-hid" 48 #define USB_HID(obj) OBJECT_CHECK(USBHIDState, (obj), TYPE_USB_HID) 49 50 enum { 51 STR_MANUFACTURER = 1, 52 STR_PRODUCT_MOUSE, 53 STR_PRODUCT_TABLET, 54 STR_PRODUCT_KEYBOARD, 55 STR_SERIAL_COMPAT, 56 STR_CONFIG_MOUSE, 57 STR_CONFIG_TABLET, 58 STR_CONFIG_KEYBOARD, 59 STR_SERIAL_MOUSE, 60 STR_SERIAL_TABLET, 61 STR_SERIAL_KEYBOARD, 62 }; 63 64 static const USBDescStrings desc_strings = { 65 [STR_MANUFACTURER] = "QEMU", 66 [STR_PRODUCT_MOUSE] = "QEMU USB Mouse", 67 [STR_PRODUCT_TABLET] = "QEMU USB Tablet", 68 [STR_PRODUCT_KEYBOARD] = "QEMU USB Keyboard", 69 [STR_SERIAL_COMPAT] = "42", 70 [STR_CONFIG_MOUSE] = "HID Mouse", 71 [STR_CONFIG_TABLET] = "HID Tablet", 72 [STR_CONFIG_KEYBOARD] = "HID Keyboard", 73 [STR_SERIAL_MOUSE] = "89126", 74 [STR_SERIAL_TABLET] = "28754", 75 [STR_SERIAL_KEYBOARD] = "68284", 76 }; 77 78 static const USBDescIface desc_iface_mouse = { 79 .bInterfaceNumber = 0, 80 .bNumEndpoints = 1, 81 .bInterfaceClass = USB_CLASS_HID, 82 .bInterfaceSubClass = 0x01, /* boot */ 83 .bInterfaceProtocol = 0x02, 84 .ndesc = 1, 85 .descs = (USBDescOther[]) { 86 { 87 /* HID descriptor */ 88 .data = (uint8_t[]) { 89 0x09, /* u8 bLength */ 90 USB_DT_HID, /* u8 bDescriptorType */ 91 0x01, 0x00, /* u16 HID_class */ 92 0x00, /* u8 country_code */ 93 0x01, /* u8 num_descriptors */ 94 USB_DT_REPORT, /* u8 type: Report */ 95 52, 0, /* u16 len */ 96 }, 97 }, 98 }, 99 .eps = (USBDescEndpoint[]) { 100 { 101 .bEndpointAddress = USB_DIR_IN | 0x01, 102 .bmAttributes = USB_ENDPOINT_XFER_INT, 103 .wMaxPacketSize = 4, 104 .bInterval = 0x0a, 105 }, 106 }, 107 }; 108 109 static const USBDescIface desc_iface_mouse2 = { 110 .bInterfaceNumber = 0, 111 .bNumEndpoints = 1, 112 .bInterfaceClass = USB_CLASS_HID, 113 .bInterfaceSubClass = 0x01, /* boot */ 114 .bInterfaceProtocol = 0x02, 115 .ndesc = 1, 116 .descs = (USBDescOther[]) { 117 { 118 /* HID descriptor */ 119 .data = (uint8_t[]) { 120 0x09, /* u8 bLength */ 121 USB_DT_HID, /* u8 bDescriptorType */ 122 0x01, 0x00, /* u16 HID_class */ 123 0x00, /* u8 country_code */ 124 0x01, /* u8 num_descriptors */ 125 USB_DT_REPORT, /* u8 type: Report */ 126 52, 0, /* u16 len */ 127 }, 128 }, 129 }, 130 .eps = (USBDescEndpoint[]) { 131 { 132 .bEndpointAddress = USB_DIR_IN | 0x01, 133 .bmAttributes = USB_ENDPOINT_XFER_INT, 134 .wMaxPacketSize = 4, 135 .bInterval = 7, /* 2 ^ (8-1) * 125 usecs = 8 ms */ 136 }, 137 }, 138 }; 139 140 static const USBDescIface desc_iface_tablet = { 141 .bInterfaceNumber = 0, 142 .bNumEndpoints = 1, 143 .bInterfaceClass = USB_CLASS_HID, 144 .bInterfaceProtocol = 0x00, 145 .ndesc = 1, 146 .descs = (USBDescOther[]) { 147 { 148 /* HID descriptor */ 149 .data = (uint8_t[]) { 150 0x09, /* u8 bLength */ 151 USB_DT_HID, /* u8 bDescriptorType */ 152 0x01, 0x00, /* u16 HID_class */ 153 0x00, /* u8 country_code */ 154 0x01, /* u8 num_descriptors */ 155 USB_DT_REPORT, /* u8 type: Report */ 156 74, 0, /* u16 len */ 157 }, 158 }, 159 }, 160 .eps = (USBDescEndpoint[]) { 161 { 162 .bEndpointAddress = USB_DIR_IN | 0x01, 163 .bmAttributes = USB_ENDPOINT_XFER_INT, 164 .wMaxPacketSize = 8, 165 .bInterval = 0x0a, 166 }, 167 }, 168 }; 169 170 static const USBDescIface desc_iface_tablet2 = { 171 .bInterfaceNumber = 0, 172 .bNumEndpoints = 1, 173 .bInterfaceClass = USB_CLASS_HID, 174 .bInterfaceProtocol = 0x00, 175 .ndesc = 1, 176 .descs = (USBDescOther[]) { 177 { 178 /* HID descriptor */ 179 .data = (uint8_t[]) { 180 0x09, /* u8 bLength */ 181 USB_DT_HID, /* u8 bDescriptorType */ 182 0x01, 0x00, /* u16 HID_class */ 183 0x00, /* u8 country_code */ 184 0x01, /* u8 num_descriptors */ 185 USB_DT_REPORT, /* u8 type: Report */ 186 74, 0, /* u16 len */ 187 }, 188 }, 189 }, 190 .eps = (USBDescEndpoint[]) { 191 { 192 .bEndpointAddress = USB_DIR_IN | 0x01, 193 .bmAttributes = USB_ENDPOINT_XFER_INT, 194 .wMaxPacketSize = 8, 195 .bInterval = 4, /* 2 ^ (4-1) * 125 usecs = 1 ms */ 196 }, 197 }, 198 }; 199 200 static const USBDescIface desc_iface_keyboard = { 201 .bInterfaceNumber = 0, 202 .bNumEndpoints = 1, 203 .bInterfaceClass = USB_CLASS_HID, 204 .bInterfaceSubClass = 0x01, /* boot */ 205 .bInterfaceProtocol = 0x01, /* keyboard */ 206 .ndesc = 1, 207 .descs = (USBDescOther[]) { 208 { 209 /* HID descriptor */ 210 .data = (uint8_t[]) { 211 0x09, /* u8 bLength */ 212 USB_DT_HID, /* u8 bDescriptorType */ 213 0x11, 0x01, /* u16 HID_class */ 214 0x00, /* u8 country_code */ 215 0x01, /* u8 num_descriptors */ 216 USB_DT_REPORT, /* u8 type: Report */ 217 0x3f, 0, /* u16 len */ 218 }, 219 }, 220 }, 221 .eps = (USBDescEndpoint[]) { 222 { 223 .bEndpointAddress = USB_DIR_IN | 0x01, 224 .bmAttributes = USB_ENDPOINT_XFER_INT, 225 .wMaxPacketSize = 8, 226 .bInterval = 0x0a, 227 }, 228 }, 229 }; 230 231 static const USBDescIface desc_iface_keyboard2 = { 232 .bInterfaceNumber = 0, 233 .bNumEndpoints = 1, 234 .bInterfaceClass = USB_CLASS_HID, 235 .bInterfaceSubClass = 0x01, /* boot */ 236 .bInterfaceProtocol = 0x01, /* keyboard */ 237 .ndesc = 1, 238 .descs = (USBDescOther[]) { 239 { 240 /* HID descriptor */ 241 .data = (uint8_t[]) { 242 0x09, /* u8 bLength */ 243 USB_DT_HID, /* u8 bDescriptorType */ 244 0x11, 0x01, /* u16 HID_class */ 245 0x00, /* u8 country_code */ 246 0x01, /* u8 num_descriptors */ 247 USB_DT_REPORT, /* u8 type: Report */ 248 0x3f, 0, /* u16 len */ 249 }, 250 }, 251 }, 252 .eps = (USBDescEndpoint[]) { 253 { 254 .bEndpointAddress = USB_DIR_IN | 0x01, 255 .bmAttributes = USB_ENDPOINT_XFER_INT, 256 .wMaxPacketSize = 8, 257 .bInterval = 7, /* 2 ^ (8-1) * 125 usecs = 8 ms */ 258 }, 259 }, 260 }; 261 262 static const USBDescDevice desc_device_mouse = { 263 .bcdUSB = 0x0100, 264 .bMaxPacketSize0 = 8, 265 .bNumConfigurations = 1, 266 .confs = (USBDescConfig[]) { 267 { 268 .bNumInterfaces = 1, 269 .bConfigurationValue = 1, 270 .iConfiguration = STR_CONFIG_MOUSE, 271 .bmAttributes = USB_CFG_ATT_ONE | USB_CFG_ATT_WAKEUP, 272 .bMaxPower = 50, 273 .nif = 1, 274 .ifs = &desc_iface_mouse, 275 }, 276 }, 277 }; 278 279 static const USBDescDevice desc_device_mouse2 = { 280 .bcdUSB = 0x0200, 281 .bMaxPacketSize0 = 64, 282 .bNumConfigurations = 1, 283 .confs = (USBDescConfig[]) { 284 { 285 .bNumInterfaces = 1, 286 .bConfigurationValue = 1, 287 .iConfiguration = STR_CONFIG_MOUSE, 288 .bmAttributes = USB_CFG_ATT_ONE | USB_CFG_ATT_WAKEUP, 289 .bMaxPower = 50, 290 .nif = 1, 291 .ifs = &desc_iface_mouse2, 292 }, 293 }, 294 }; 295 296 static const USBDescDevice desc_device_tablet = { 297 .bcdUSB = 0x0100, 298 .bMaxPacketSize0 = 8, 299 .bNumConfigurations = 1, 300 .confs = (USBDescConfig[]) { 301 { 302 .bNumInterfaces = 1, 303 .bConfigurationValue = 1, 304 .iConfiguration = STR_CONFIG_TABLET, 305 .bmAttributes = USB_CFG_ATT_ONE | USB_CFG_ATT_WAKEUP, 306 .bMaxPower = 50, 307 .nif = 1, 308 .ifs = &desc_iface_tablet, 309 }, 310 }, 311 }; 312 313 static const USBDescDevice desc_device_tablet2 = { 314 .bcdUSB = 0x0200, 315 .bMaxPacketSize0 = 64, 316 .bNumConfigurations = 1, 317 .confs = (USBDescConfig[]) { 318 { 319 .bNumInterfaces = 1, 320 .bConfigurationValue = 1, 321 .iConfiguration = STR_CONFIG_TABLET, 322 .bmAttributes = USB_CFG_ATT_ONE | USB_CFG_ATT_WAKEUP, 323 .bMaxPower = 50, 324 .nif = 1, 325 .ifs = &desc_iface_tablet2, 326 }, 327 }, 328 }; 329 330 static const USBDescDevice desc_device_keyboard = { 331 .bcdUSB = 0x0100, 332 .bMaxPacketSize0 = 8, 333 .bNumConfigurations = 1, 334 .confs = (USBDescConfig[]) { 335 { 336 .bNumInterfaces = 1, 337 .bConfigurationValue = 1, 338 .iConfiguration = STR_CONFIG_KEYBOARD, 339 .bmAttributes = USB_CFG_ATT_ONE | USB_CFG_ATT_WAKEUP, 340 .bMaxPower = 50, 341 .nif = 1, 342 .ifs = &desc_iface_keyboard, 343 }, 344 }, 345 }; 346 347 static const USBDescDevice desc_device_keyboard2 = { 348 .bcdUSB = 0x0200, 349 .bMaxPacketSize0 = 64, 350 .bNumConfigurations = 1, 351 .confs = (USBDescConfig[]) { 352 { 353 .bNumInterfaces = 1, 354 .bConfigurationValue = 1, 355 .iConfiguration = STR_CONFIG_KEYBOARD, 356 .bmAttributes = USB_CFG_ATT_ONE | USB_CFG_ATT_WAKEUP, 357 .bMaxPower = 50, 358 .nif = 1, 359 .ifs = &desc_iface_keyboard2, 360 }, 361 }, 362 }; 363 364 static const USBDescMSOS desc_msos_suspend = { 365 .SelectiveSuspendEnabled = true, 366 }; 367 368 static const USBDesc desc_mouse = { 369 .id = { 370 .idVendor = 0x0627, 371 .idProduct = 0x0001, 372 .bcdDevice = 0, 373 .iManufacturer = STR_MANUFACTURER, 374 .iProduct = STR_PRODUCT_MOUSE, 375 .iSerialNumber = STR_SERIAL_MOUSE, 376 }, 377 .full = &desc_device_mouse, 378 .str = desc_strings, 379 .msos = &desc_msos_suspend, 380 }; 381 382 static const USBDesc desc_mouse2 = { 383 .id = { 384 .idVendor = 0x0627, 385 .idProduct = 0x0001, 386 .bcdDevice = 0, 387 .iManufacturer = STR_MANUFACTURER, 388 .iProduct = STR_PRODUCT_MOUSE, 389 .iSerialNumber = STR_SERIAL_MOUSE, 390 }, 391 .full = &desc_device_mouse, 392 .high = &desc_device_mouse2, 393 .str = desc_strings, 394 .msos = &desc_msos_suspend, 395 }; 396 397 static const USBDesc desc_tablet = { 398 .id = { 399 .idVendor = 0x0627, 400 .idProduct = 0x0001, 401 .bcdDevice = 0, 402 .iManufacturer = STR_MANUFACTURER, 403 .iProduct = STR_PRODUCT_TABLET, 404 .iSerialNumber = STR_SERIAL_TABLET, 405 }, 406 .full = &desc_device_tablet, 407 .str = desc_strings, 408 .msos = &desc_msos_suspend, 409 }; 410 411 static const USBDesc desc_tablet2 = { 412 .id = { 413 .idVendor = 0x0627, 414 .idProduct = 0x0001, 415 .bcdDevice = 0, 416 .iManufacturer = STR_MANUFACTURER, 417 .iProduct = STR_PRODUCT_TABLET, 418 .iSerialNumber = STR_SERIAL_TABLET, 419 }, 420 .full = &desc_device_tablet, 421 .high = &desc_device_tablet2, 422 .str = desc_strings, 423 .msos = &desc_msos_suspend, 424 }; 425 426 static const USBDesc desc_keyboard = { 427 .id = { 428 .idVendor = 0x0627, 429 .idProduct = 0x0001, 430 .bcdDevice = 0, 431 .iManufacturer = STR_MANUFACTURER, 432 .iProduct = STR_PRODUCT_KEYBOARD, 433 .iSerialNumber = STR_SERIAL_KEYBOARD, 434 }, 435 .full = &desc_device_keyboard, 436 .str = desc_strings, 437 .msos = &desc_msos_suspend, 438 }; 439 440 static const USBDesc desc_keyboard2 = { 441 .id = { 442 .idVendor = 0x0627, 443 .idProduct = 0x0001, 444 .bcdDevice = 0, 445 .iManufacturer = STR_MANUFACTURER, 446 .iProduct = STR_PRODUCT_KEYBOARD, 447 .iSerialNumber = STR_SERIAL_KEYBOARD, 448 }, 449 .full = &desc_device_keyboard, 450 .high = &desc_device_keyboard2, 451 .str = desc_strings, 452 .msos = &desc_msos_suspend, 453 }; 454 455 static const uint8_t qemu_mouse_hid_report_descriptor[] = { 456 0x05, 0x01, /* Usage Page (Generic Desktop) */ 457 0x09, 0x02, /* Usage (Mouse) */ 458 0xa1, 0x01, /* Collection (Application) */ 459 0x09, 0x01, /* Usage (Pointer) */ 460 0xa1, 0x00, /* Collection (Physical) */ 461 0x05, 0x09, /* Usage Page (Button) */ 462 0x19, 0x01, /* Usage Minimum (1) */ 463 0x29, 0x03, /* Usage Maximum (3) */ 464 0x15, 0x00, /* Logical Minimum (0) */ 465 0x25, 0x01, /* Logical Maximum (1) */ 466 0x95, 0x03, /* Report Count (3) */ 467 0x75, 0x01, /* Report Size (1) */ 468 0x81, 0x02, /* Input (Data, Variable, Absolute) */ 469 0x95, 0x01, /* Report Count (1) */ 470 0x75, 0x05, /* Report Size (5) */ 471 0x81, 0x01, /* Input (Constant) */ 472 0x05, 0x01, /* Usage Page (Generic Desktop) */ 473 0x09, 0x30, /* Usage (X) */ 474 0x09, 0x31, /* Usage (Y) */ 475 0x09, 0x38, /* Usage (Wheel) */ 476 0x15, 0x81, /* Logical Minimum (-0x7f) */ 477 0x25, 0x7f, /* Logical Maximum (0x7f) */ 478 0x75, 0x08, /* Report Size (8) */ 479 0x95, 0x03, /* Report Count (3) */ 480 0x81, 0x06, /* Input (Data, Variable, Relative) */ 481 0xc0, /* End Collection */ 482 0xc0, /* End Collection */ 483 }; 484 485 static const uint8_t qemu_tablet_hid_report_descriptor[] = { 486 0x05, 0x01, /* Usage Page (Generic Desktop) */ 487 0x09, 0x02, /* Usage (Mouse) */ 488 0xa1, 0x01, /* Collection (Application) */ 489 0x09, 0x01, /* Usage (Pointer) */ 490 0xa1, 0x00, /* Collection (Physical) */ 491 0x05, 0x09, /* Usage Page (Button) */ 492 0x19, 0x01, /* Usage Minimum (1) */ 493 0x29, 0x03, /* Usage Maximum (3) */ 494 0x15, 0x00, /* Logical Minimum (0) */ 495 0x25, 0x01, /* Logical Maximum (1) */ 496 0x95, 0x03, /* Report Count (3) */ 497 0x75, 0x01, /* Report Size (1) */ 498 0x81, 0x02, /* Input (Data, Variable, Absolute) */ 499 0x95, 0x01, /* Report Count (1) */ 500 0x75, 0x05, /* Report Size (5) */ 501 0x81, 0x01, /* Input (Constant) */ 502 0x05, 0x01, /* Usage Page (Generic Desktop) */ 503 0x09, 0x30, /* Usage (X) */ 504 0x09, 0x31, /* Usage (Y) */ 505 0x15, 0x00, /* Logical Minimum (0) */ 506 0x26, 0xff, 0x7f, /* Logical Maximum (0x7fff) */ 507 0x35, 0x00, /* Physical Minimum (0) */ 508 0x46, 0xff, 0x7f, /* Physical Maximum (0x7fff) */ 509 0x75, 0x10, /* Report Size (16) */ 510 0x95, 0x02, /* Report Count (2) */ 511 0x81, 0x02, /* Input (Data, Variable, Absolute) */ 512 0x05, 0x01, /* Usage Page (Generic Desktop) */ 513 0x09, 0x38, /* Usage (Wheel) */ 514 0x15, 0x81, /* Logical Minimum (-0x7f) */ 515 0x25, 0x7f, /* Logical Maximum (0x7f) */ 516 0x35, 0x00, /* Physical Minimum (same as logical) */ 517 0x45, 0x00, /* Physical Maximum (same as logical) */ 518 0x75, 0x08, /* Report Size (8) */ 519 0x95, 0x01, /* Report Count (1) */ 520 0x81, 0x06, /* Input (Data, Variable, Relative) */ 521 0xc0, /* End Collection */ 522 0xc0, /* End Collection */ 523 }; 524 525 static const uint8_t qemu_keyboard_hid_report_descriptor[] = { 526 0x05, 0x01, /* Usage Page (Generic Desktop) */ 527 0x09, 0x06, /* Usage (Keyboard) */ 528 0xa1, 0x01, /* Collection (Application) */ 529 0x75, 0x01, /* Report Size (1) */ 530 0x95, 0x08, /* Report Count (8) */ 531 0x05, 0x07, /* Usage Page (Key Codes) */ 532 0x19, 0xe0, /* Usage Minimum (224) */ 533 0x29, 0xe7, /* Usage Maximum (231) */ 534 0x15, 0x00, /* Logical Minimum (0) */ 535 0x25, 0x01, /* Logical Maximum (1) */ 536 0x81, 0x02, /* Input (Data, Variable, Absolute) */ 537 0x95, 0x01, /* Report Count (1) */ 538 0x75, 0x08, /* Report Size (8) */ 539 0x81, 0x01, /* Input (Constant) */ 540 0x95, 0x05, /* Report Count (5) */ 541 0x75, 0x01, /* Report Size (1) */ 542 0x05, 0x08, /* Usage Page (LEDs) */ 543 0x19, 0x01, /* Usage Minimum (1) */ 544 0x29, 0x05, /* Usage Maximum (5) */ 545 0x91, 0x02, /* Output (Data, Variable, Absolute) */ 546 0x95, 0x01, /* Report Count (1) */ 547 0x75, 0x03, /* Report Size (3) */ 548 0x91, 0x01, /* Output (Constant) */ 549 0x95, 0x06, /* Report Count (6) */ 550 0x75, 0x08, /* Report Size (8) */ 551 0x15, 0x00, /* Logical Minimum (0) */ 552 0x25, 0xff, /* Logical Maximum (255) */ 553 0x05, 0x07, /* Usage Page (Key Codes) */ 554 0x19, 0x00, /* Usage Minimum (0) */ 555 0x29, 0xff, /* Usage Maximum (255) */ 556 0x81, 0x00, /* Input (Data, Array) */ 557 0xc0, /* End Collection */ 558 }; 559 560 static void usb_hid_changed(HIDState *hs) 561 { 562 USBHIDState *us = container_of(hs, USBHIDState, hid); 563 564 usb_wakeup(us->intr, 0); 565 } 566 567 static void usb_hid_handle_reset(USBDevice *dev) 568 { 569 USBHIDState *us = USB_HID(dev); 570 571 hid_reset(&us->hid); 572 } 573 574 static void usb_hid_handle_control(USBDevice *dev, USBPacket *p, 575 int request, int value, int index, int length, uint8_t *data) 576 { 577 USBHIDState *us = USB_HID(dev); 578 HIDState *hs = &us->hid; 579 int ret; 580 581 ret = usb_desc_handle_control(dev, p, request, value, index, length, data); 582 if (ret >= 0) { 583 return; 584 } 585 586 switch (request) { 587 /* hid specific requests */ 588 case InterfaceRequest | USB_REQ_GET_DESCRIPTOR: 589 switch (value >> 8) { 590 case 0x22: 591 if (hs->kind == HID_MOUSE) { 592 memcpy(data, qemu_mouse_hid_report_descriptor, 593 sizeof(qemu_mouse_hid_report_descriptor)); 594 p->actual_length = sizeof(qemu_mouse_hid_report_descriptor); 595 } else if (hs->kind == HID_TABLET) { 596 memcpy(data, qemu_tablet_hid_report_descriptor, 597 sizeof(qemu_tablet_hid_report_descriptor)); 598 p->actual_length = sizeof(qemu_tablet_hid_report_descriptor); 599 } else if (hs->kind == HID_KEYBOARD) { 600 memcpy(data, qemu_keyboard_hid_report_descriptor, 601 sizeof(qemu_keyboard_hid_report_descriptor)); 602 p->actual_length = sizeof(qemu_keyboard_hid_report_descriptor); 603 } 604 break; 605 default: 606 goto fail; 607 } 608 break; 609 case HID_GET_REPORT: 610 if (hs->kind == HID_MOUSE || hs->kind == HID_TABLET) { 611 p->actual_length = hid_pointer_poll(hs, data, length); 612 } else if (hs->kind == HID_KEYBOARD) { 613 p->actual_length = hid_keyboard_poll(hs, data, length); 614 } 615 break; 616 case HID_SET_REPORT: 617 if (hs->kind == HID_KEYBOARD) { 618 p->actual_length = hid_keyboard_write(hs, data, length); 619 } else { 620 goto fail; 621 } 622 break; 623 case HID_GET_PROTOCOL: 624 if (hs->kind != HID_KEYBOARD && hs->kind != HID_MOUSE) { 625 goto fail; 626 } 627 data[0] = hs->protocol; 628 p->actual_length = 1; 629 break; 630 case HID_SET_PROTOCOL: 631 if (hs->kind != HID_KEYBOARD && hs->kind != HID_MOUSE) { 632 goto fail; 633 } 634 hs->protocol = value; 635 break; 636 case HID_GET_IDLE: 637 data[0] = hs->idle; 638 p->actual_length = 1; 639 break; 640 case HID_SET_IDLE: 641 hs->idle = (uint8_t) (value >> 8); 642 hid_set_next_idle(hs); 643 if (hs->kind == HID_MOUSE || hs->kind == HID_TABLET) { 644 hid_pointer_activate(hs); 645 } 646 break; 647 default: 648 fail: 649 p->status = USB_RET_STALL; 650 break; 651 } 652 } 653 654 static void usb_hid_handle_data(USBDevice *dev, USBPacket *p) 655 { 656 USBHIDState *us = USB_HID(dev); 657 HIDState *hs = &us->hid; 658 uint8_t buf[p->iov.size]; 659 int len = 0; 660 661 switch (p->pid) { 662 case USB_TOKEN_IN: 663 if (p->ep->nr == 1) { 664 if (hs->kind == HID_MOUSE || hs->kind == HID_TABLET) { 665 hid_pointer_activate(hs); 666 } 667 if (!hid_has_events(hs)) { 668 p->status = USB_RET_NAK; 669 return; 670 } 671 hid_set_next_idle(hs); 672 if (hs->kind == HID_MOUSE || hs->kind == HID_TABLET) { 673 len = hid_pointer_poll(hs, buf, p->iov.size); 674 } else if (hs->kind == HID_KEYBOARD) { 675 len = hid_keyboard_poll(hs, buf, p->iov.size); 676 } 677 usb_packet_copy(p, buf, len); 678 } else { 679 goto fail; 680 } 681 break; 682 case USB_TOKEN_OUT: 683 default: 684 fail: 685 p->status = USB_RET_STALL; 686 break; 687 } 688 } 689 690 static void usb_hid_unrealize(USBDevice *dev) 691 { 692 USBHIDState *us = USB_HID(dev); 693 694 hid_free(&us->hid); 695 } 696 697 static void usb_hid_initfn(USBDevice *dev, int kind, 698 const USBDesc *usb1, const USBDesc *usb2, 699 Error **errp) 700 { 701 USBHIDState *us = USB_HID(dev); 702 switch (us->usb_version) { 703 case 1: 704 dev->usb_desc = usb1; 705 break; 706 case 2: 707 dev->usb_desc = usb2; 708 break; 709 default: 710 dev->usb_desc = NULL; 711 } 712 if (!dev->usb_desc) { 713 error_setg(errp, "Invalid usb version %d for usb hid device", 714 us->usb_version); 715 return; 716 } 717 718 usb_desc_create_serial(dev); 719 usb_desc_init(dev); 720 us->intr = usb_ep_get(dev, USB_TOKEN_IN, 1); 721 hid_init(&us->hid, kind, usb_hid_changed); 722 if (us->display && us->hid.s) { 723 qemu_input_handler_bind(us->hid.s, us->display, us->head, NULL); 724 } 725 } 726 727 static void usb_tablet_realize(USBDevice *dev, Error **errp) 728 { 729 730 usb_hid_initfn(dev, HID_TABLET, &desc_tablet, &desc_tablet2, errp); 731 } 732 733 static void usb_mouse_realize(USBDevice *dev, Error **errp) 734 { 735 usb_hid_initfn(dev, HID_MOUSE, &desc_mouse, &desc_mouse2, errp); 736 } 737 738 static void usb_keyboard_realize(USBDevice *dev, Error **errp) 739 { 740 usb_hid_initfn(dev, HID_KEYBOARD, &desc_keyboard, &desc_keyboard2, errp); 741 } 742 743 static int usb_ptr_post_load(void *opaque, int version_id) 744 { 745 USBHIDState *s = opaque; 746 747 if (s->dev.remote_wakeup) { 748 hid_pointer_activate(&s->hid); 749 } 750 return 0; 751 } 752 753 static const VMStateDescription vmstate_usb_ptr = { 754 .name = "usb-ptr", 755 .version_id = 1, 756 .minimum_version_id = 1, 757 .post_load = usb_ptr_post_load, 758 .fields = (VMStateField[]) { 759 VMSTATE_USB_DEVICE(dev, USBHIDState), 760 VMSTATE_HID_POINTER_DEVICE(hid, USBHIDState), 761 VMSTATE_END_OF_LIST() 762 } 763 }; 764 765 static const VMStateDescription vmstate_usb_kbd = { 766 .name = "usb-kbd", 767 .version_id = 1, 768 .minimum_version_id = 1, 769 .fields = (VMStateField[]) { 770 VMSTATE_USB_DEVICE(dev, USBHIDState), 771 VMSTATE_HID_KEYBOARD_DEVICE(hid, USBHIDState), 772 VMSTATE_END_OF_LIST() 773 } 774 }; 775 776 static void usb_hid_class_initfn(ObjectClass *klass, void *data) 777 { 778 USBDeviceClass *uc = USB_DEVICE_CLASS(klass); 779 780 uc->handle_reset = usb_hid_handle_reset; 781 uc->handle_control = usb_hid_handle_control; 782 uc->handle_data = usb_hid_handle_data; 783 uc->unrealize = usb_hid_unrealize; 784 uc->handle_attach = usb_desc_attach; 785 } 786 787 static const TypeInfo usb_hid_type_info = { 788 .name = TYPE_USB_HID, 789 .parent = TYPE_USB_DEVICE, 790 .instance_size = sizeof(USBHIDState), 791 .abstract = true, 792 .class_init = usb_hid_class_initfn, 793 }; 794 795 static Property usb_tablet_properties[] = { 796 DEFINE_PROP_UINT32("usb_version", USBHIDState, usb_version, 2), 797 DEFINE_PROP_STRING("display", USBHIDState, display), 798 DEFINE_PROP_UINT32("head", USBHIDState, head, 0), 799 DEFINE_PROP_END_OF_LIST(), 800 }; 801 802 static void usb_tablet_class_initfn(ObjectClass *klass, void *data) 803 { 804 DeviceClass *dc = DEVICE_CLASS(klass); 805 USBDeviceClass *uc = USB_DEVICE_CLASS(klass); 806 807 uc->realize = usb_tablet_realize; 808 uc->product_desc = "QEMU USB Tablet"; 809 dc->vmsd = &vmstate_usb_ptr; 810 device_class_set_props(dc, usb_tablet_properties); 811 set_bit(DEVICE_CATEGORY_INPUT, dc->categories); 812 } 813 814 static const TypeInfo usb_tablet_info = { 815 .name = "usb-tablet", 816 .parent = TYPE_USB_HID, 817 .class_init = usb_tablet_class_initfn, 818 }; 819 820 static Property usb_mouse_properties[] = { 821 DEFINE_PROP_UINT32("usb_version", USBHIDState, usb_version, 2), 822 DEFINE_PROP_END_OF_LIST(), 823 }; 824 825 static void usb_mouse_class_initfn(ObjectClass *klass, void *data) 826 { 827 DeviceClass *dc = DEVICE_CLASS(klass); 828 USBDeviceClass *uc = USB_DEVICE_CLASS(klass); 829 830 uc->realize = usb_mouse_realize; 831 uc->product_desc = "QEMU USB Mouse"; 832 dc->vmsd = &vmstate_usb_ptr; 833 device_class_set_props(dc, usb_mouse_properties); 834 set_bit(DEVICE_CATEGORY_INPUT, dc->categories); 835 } 836 837 static const TypeInfo usb_mouse_info = { 838 .name = "usb-mouse", 839 .parent = TYPE_USB_HID, 840 .class_init = usb_mouse_class_initfn, 841 }; 842 843 static Property usb_keyboard_properties[] = { 844 DEFINE_PROP_UINT32("usb_version", USBHIDState, usb_version, 2), 845 DEFINE_PROP_STRING("display", USBHIDState, display), 846 DEFINE_PROP_END_OF_LIST(), 847 }; 848 849 static void usb_keyboard_class_initfn(ObjectClass *klass, void *data) 850 { 851 DeviceClass *dc = DEVICE_CLASS(klass); 852 USBDeviceClass *uc = USB_DEVICE_CLASS(klass); 853 854 uc->realize = usb_keyboard_realize; 855 uc->product_desc = "QEMU USB Keyboard"; 856 dc->vmsd = &vmstate_usb_kbd; 857 device_class_set_props(dc, usb_keyboard_properties); 858 set_bit(DEVICE_CATEGORY_INPUT, dc->categories); 859 } 860 861 static const TypeInfo usb_keyboard_info = { 862 .name = "usb-kbd", 863 .parent = TYPE_USB_HID, 864 .class_init = usb_keyboard_class_initfn, 865 }; 866 867 static void usb_hid_register_types(void) 868 { 869 type_register_static(&usb_hid_type_info); 870 type_register_static(&usb_tablet_info); 871 usb_legacy_register("usb-tablet", "tablet", NULL); 872 type_register_static(&usb_mouse_info); 873 usb_legacy_register("usb-mouse", "mouse", NULL); 874 type_register_static(&usb_keyboard_info); 875 usb_legacy_register("usb-kbd", "keyboard", NULL); 876 } 877 878 type_init(usb_hid_register_types) 879