hw/usb-hid.c

   1 /*
   2  * QEMU USB HID devices
   3  *
   4  * Copyright (c) 2005 Fabrice Bellard
   5  * Copyright (c) 2007 OpenMoko, Inc.  ([email protected])
   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 "usb-desc.h"
  29 #include "sysemu.h"
  30
  31 /* HID interface requests */
  32 #define GET_REPORT   0xa101
  33 #define GET_IDLE     0xa102
  34 #define GET_PROTOCOL 0xa103
  35 #define SET_REPORT   0x2109
  36 #define SET_IDLE     0x210a
  37 #define SET_PROTOCOL 0x210b
  38
  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
  47
  48 typedef struct USBMouseState {
  49     int dx, dy, dz, buttons_state;
  50     int x, y;
  51     int mouse_grabbed;
  52     QEMUPutMouseEntry *eh_entry;
  53 } USBMouseState;
  54
  55 typedef struct USBKeyboardState {
  56     uint16_t modifiers;
  57     uint8_t leds;
  58     uint8_t key[16];
  59     int keys;
  60 } USBKeyboardState;
  61
  62 typedef struct USBHIDState {
  63     USBDevice dev;
  64     union {
  65         USBMouseState ptr;
  66         USBKeyboardState kbd;
  67     };
  68     int kind;
  69     int protocol;
  70     uint8_t idle;
  71     int64_t next_idle_clock;
  72     int changed;
  73     void *datain_opaque;
  74     void (*datain)(void *);
  75 } USBHIDState;
  76
  77 enum {
  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,
  86 };
  87
  88 static 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]     = "42", /* == remote wakeup works */
  94     [STR_CONFIG_MOUSE]     = "HID Mouse",
  95     [STR_CONFIG_TABLET]    = "HID Tablet",
  96     [STR_CONFIG_KEYBOARD]  = "HID Keyboard",
  97 };
  98
  99 static 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     },
 128 };
 129
 130 static 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
 161 static 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
 192 static 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
 208 static 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
 224 static 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
 240 static 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
 253 static 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
 266 static 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,
 277 };
 278
 279 static const uint8_t qemu_mouse_hid_report_descriptor[] = {
 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 */
 307 };
 308
 309 static const uint8_t qemu_tablet_hid_report_descriptor[] = {
 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) */
 330     0x26, 0xff, 0x7f,   /*     Logical Maximum (0x7fff) */
 331     0x35, 0x00,         /*     Physical Minimum (0) */
 332     0x46, 0xff, 0x7f,   /*     Physical Maximum (0x7fff) */
 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 */
 347 };
 348
 349 static 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.  */
 390 static 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, 0xe3, 0xe7, 0x65, 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
 426 static void usb_hid_changed(USBHIDState *hs)
 427 {
 428     hs->changed = 1;
 429
 430     if (hs->datain)
 431         hs->datain(hs->datain_opaque);
 432
 433     usb_wakeup(&hs->dev);
 434 }
 435
 436 static void usb_mouse_event(void *opaque,
 437                             int dx1, int dy1, int dz1, int buttons_state)
 438 {
 439     USBHIDState *hs = opaque;
 440     USBMouseState *s = &hs->ptr;
 441
 442     s->dx += dx1;
 443     s->dy += dy1;
 444     s->dz += dz1;
 445     s->buttons_state = buttons_state;
 446
 447     usb_hid_changed(hs);
 448 }
 449
 450 static void usb_tablet_event(void *opaque,
 451                              int x, int y, int dz, int buttons_state)
 452 {
 453     USBHIDState *hs = opaque;
 454     USBMouseState *s = &hs->ptr;
 455
 456     s->x = x;
 457     s->y = y;
 458     s->dz += dz;
 459     s->buttons_state = buttons_state;
 460
 461     usb_hid_changed(hs);
 462 }
 463
 464 static void usb_keyboard_event(void *opaque, int keycode)
 465 {
 466     USBHIDState *hs = opaque;
 467     USBKeyboardState *s = &hs->kbd;
 468     uint8_t hid_code, key;
 469     int i;
 470
 471     key = keycode & 0x7f;
 472     hid_code = usb_hid_usage_keys[key | ((s->modifiers >> 1) & (1 << 7))];
 473     s->modifiers &= ~(1 << 8);
 474
 475     switch (hid_code) {
 476     case 0x00:
 477         return;
 478
 479     case 0xe0:
 480         if (s->modifiers & (1 << 9)) {
 481             s->modifiers ^= 3 << 8;
 482             usb_hid_changed(hs);
 483             return;
 484         }
 485     case 0xe1 ... 0xe7:
 486         if (keycode & (1 << 7)) {
 487             s->modifiers &= ~(1 << (hid_code & 0x0f));
 488             usb_hid_changed(hs);
 489             return;
 490         }
 491     case 0xe8 ... 0xef:
 492         s->modifiers |= 1 << (hid_code & 0x0f);
 493         usb_hid_changed(hs);
 494         return;
 495     }
 496
 497     if (keycode & (1 << 7)) {
 498         for (i = s->keys - 1; i >= 0; i --)
 499             if (s->key[i] == hid_code) {
 500                 s->key[i] = s->key[-- s->keys];
 501                 s->key[s->keys] = 0x00;
 502                 usb_hid_changed(hs);
 503                 break;
 504             }
 505         if (i < 0)
 506             return;
 507     } else {
 508         for (i = s->keys - 1; i >= 0; i --)
 509             if (s->key[i] == hid_code)
 510                 break;
 511         if (i < 0) {
 512             if (s->keys < sizeof(s->key))
 513                 s->key[s->keys ++] = hid_code;
 514         } else
 515             return;
 516     }
 517
 518     usb_hid_changed(hs);
 519 }
 520
 521 static inline int int_clamp(int val, int vmin, int vmax)
 522 {
 523     if (val < vmin)
 524         return vmin;
 525     else if (val > vmax)
 526         return vmax;
 527     else
 528         return val;
 529 }
 530
 531 static int usb_mouse_poll(USBHIDState *hs, uint8_t *buf, int len)
 532 {
 533     int dx, dy, dz, b, l;
 534     USBMouseState *s = &hs->ptr;
 535
 536     if (!s->mouse_grabbed) {
 537         qemu_activate_mouse_event_handler(s->eh_entry);
 538         s->mouse_grabbed = 1;
 539     }
 540
 541     dx = int_clamp(s->dx, -127, 127);
 542     dy = int_clamp(s->dy, -127, 127);
 543     dz = int_clamp(s->dz, -127, 127);
 544
 545     s->dx -= dx;
 546     s->dy -= dy;
 547     s->dz -= dz;
 548
 549     /* Appears we have to invert the wheel direction */
 550     dz = 0 - dz;
 551
 552     b = 0;
 553     if (s->buttons_state & MOUSE_EVENT_LBUTTON)
 554         b |= 0x01;
 555     if (s->buttons_state & MOUSE_EVENT_RBUTTON)
 556         b |= 0x02;
 557     if (s->buttons_state & MOUSE_EVENT_MBUTTON)
 558         b |= 0x04;
 559
 560     l = 0;
 561     if (len > l)
 562         buf[l ++] = b;
 563     if (len > l)
 564         buf[l ++] = dx;
 565     if (len > l)
 566         buf[l ++] = dy;
 567     if (len > l)
 568         buf[l ++] = dz;
 569     return l;
 570 }
 571
 572 static int usb_tablet_poll(USBHIDState *hs, uint8_t *buf, int len)
 573 {
 574     int dz, b, l;
 575     USBMouseState *s = &hs->ptr;
 576
 577     if (!s->mouse_grabbed) {
 578         qemu_activate_mouse_event_handler(s->eh_entry);
 579         s->mouse_grabbed = 1;
 580     }
 581
 582     dz = int_clamp(s->dz, -127, 127);
 583     s->dz -= dz;
 584
 585     /* Appears we have to invert the wheel direction */
 586     dz = 0 - dz;
 587     b = 0;
 588     if (s->buttons_state & MOUSE_EVENT_LBUTTON)
 589         b |= 0x01;
 590     if (s->buttons_state & MOUSE_EVENT_RBUTTON)
 591         b |= 0x02;
 592     if (s->buttons_state & MOUSE_EVENT_MBUTTON)
 593         b |= 0x04;
 594
 595     buf[0] = b;
 596     buf[1] = s->x & 0xff;
 597     buf[2] = s->x >> 8;
 598     buf[3] = s->y & 0xff;
 599     buf[4] = s->y >> 8;
 600     buf[5] = dz;
 601     l = 6;
 602
 603     return l;
 604 }
 605
 606 static int usb_keyboard_poll(USBKeyboardState *s, uint8_t *buf, int len)
 607 {
 608     if (len < 2)
 609         return 0;
 610
 611     buf[0] = s->modifiers & 0xff;
 612     buf[1] = 0;
 613     if (s->keys > 6)
 614         memset(buf + 2, USB_HID_USAGE_ERROR_ROLLOVER, MIN(8, len) - 2);
 615     else
 616         memcpy(buf + 2, s->key, MIN(8, len) - 2);
 617
 618     return MIN(8, len);
 619 }
 620
 621 static int usb_keyboard_write(USBKeyboardState *s, uint8_t *buf, int len)
 622 {
 623     if (len > 0) {
 624         int ledstate = 0;
 625         /* 0x01: Num Lock LED
 626          * 0x02: Caps Lock LED
 627          * 0x04: Scroll Lock LED
 628          * 0x08: Compose LED
 629          * 0x10: Kana LED */
 630         s->leds = buf[0];
 631         if (s->leds & 0x04)
 632             ledstate |= QEMU_SCROLL_LOCK_LED;
 633         if (s->leds & 0x01)
 634             ledstate |= QEMU_NUM_LOCK_LED;
 635         if (s->leds & 0x02)
 636             ledstate |= QEMU_CAPS_LOCK_LED;
 637         kbd_put_ledstate(ledstate);
 638     }
 639     return 0;
 640 }
 641
 642 static void usb_mouse_handle_reset(USBDevice *dev)
 643 {
 644     USBHIDState *s = (USBHIDState *)dev;
 645
 646     s->ptr.dx = 0;
 647     s->ptr.dy = 0;
 648     s->ptr.dz = 0;
 649     s->ptr.x = 0;
 650     s->ptr.y = 0;
 651     s->ptr.buttons_state = 0;
 652     s->protocol = 1;
 653 }
 654
 655 static void usb_keyboard_handle_reset(USBDevice *dev)
 656 {
 657     USBHIDState *s = (USBHIDState *)dev;
 658
 659     qemu_add_kbd_event_handler(usb_keyboard_event, s);
 660     s->protocol = 1;
 661 }
 662
 663 static void usb_hid_set_next_idle(USBHIDState *s, int64_t curtime)
 664 {
 665     s->next_idle_clock = curtime + (get_ticks_per_sec() * s->idle * 4) / 1000;
 666 }
 667
 668 static int usb_hid_handle_control(USBDevice *dev, int request, int value,
 669                                   int index, int length, uint8_t *data)
 670 {
 671     USBHIDState *s = (USBHIDState *)dev;
 672     int ret;
 673
 674     ret = usb_desc_handle_control(dev, request, value, index, length, data);
 675     if (ret >= 0) {
 676         return ret;
 677     }
 678
 679     ret = 0;
 680     switch(request) {
 681     case DeviceRequest | USB_REQ_GET_INTERFACE:
 682         data[0] = 0;
 683         ret = 1;
 684         break;
 685     case DeviceOutRequest | USB_REQ_SET_INTERFACE:
 686         ret = 0;
 687         break;
 688         /* hid specific requests */
 689     case InterfaceRequest | USB_REQ_GET_DESCRIPTOR:
 690         switch(value >> 8) {
 691         case 0x22:
 692             if (s->kind == USB_MOUSE) {
 693                 memcpy(data, qemu_mouse_hid_report_descriptor,
 694                        sizeof(qemu_mouse_hid_report_descriptor));
 695                 ret = sizeof(qemu_mouse_hid_report_descriptor);
 696             } else if (s->kind == USB_TABLET) {
 697                 memcpy(data, qemu_tablet_hid_report_descriptor,
 698                        sizeof(qemu_tablet_hid_report_descriptor));
 699                 ret = sizeof(qemu_tablet_hid_report_descriptor);
 700             } else if (s->kind == USB_KEYBOARD) {
 701                 memcpy(data, qemu_keyboard_hid_report_descriptor,
 702                        sizeof(qemu_keyboard_hid_report_descriptor));
 703                 ret = sizeof(qemu_keyboard_hid_report_descriptor);
 704             }
 705             break;
 706         default:
 707             goto fail;
 708         }
 709         break;
 710     case GET_REPORT:
 711         if (s->kind == USB_MOUSE)
 712             ret = usb_mouse_poll(s, data, length);
 713         else if (s->kind == USB_TABLET)
 714             ret = usb_tablet_poll(s, data, length);
 715         else if (s->kind == USB_KEYBOARD)
 716             ret = usb_keyboard_poll(&s->kbd, data, length);
 717         break;
 718     case SET_REPORT:
 719         if (s->kind == USB_KEYBOARD)
 720             ret = usb_keyboard_write(&s->kbd, data, length);
 721         else
 722             goto fail;
 723         break;
 724     case GET_PROTOCOL:
 725         if (s->kind != USB_KEYBOARD)
 726             goto fail;
 727         ret = 1;
 728         data[0] = s->protocol;
 729         break;
 730     case SET_PROTOCOL:
 731         if (s->kind != USB_KEYBOARD)
 732             goto fail;
 733         ret = 0;
 734         s->protocol = value;
 735         break;
 736     case GET_IDLE:
 737         ret = 1;
 738         data[0] = s->idle;
 739         break;
 740     case SET_IDLE:
 741         s->idle = (uint8_t) (value >> 8);
 742         usb_hid_set_next_idle(s, qemu_get_clock(vm_clock));
 743         ret = 0;
 744         break;
 745     default:
 746     fail:
 747         ret = USB_RET_STALL;
 748         break;
 749     }
 750     return ret;
 751 }
 752
 753 static int usb_hid_handle_data(USBDevice *dev, USBPacket *p)
 754 {
 755     USBHIDState *s = (USBHIDState *)dev;
 756     int ret = 0;
 757
 758     switch(p->pid) {
 759     case USB_TOKEN_IN:
 760         if (p->devep == 1) {
 761             int64_t curtime = qemu_get_clock(vm_clock);
 762             if (!s->changed && (!s->idle || s->next_idle_clock - curtime > 0))
 763                 return USB_RET_NAK;
 764             usb_hid_set_next_idle(s, curtime);
 765             s->changed = 0;
 766             if (s->kind == USB_MOUSE)
 767                 ret = usb_mouse_poll(s, p->data, p->len);
 768             else if (s->kind == USB_TABLET)
 769                 ret = usb_tablet_poll(s, p->data, p->len);
 770             else if (s->kind == USB_KEYBOARD)
 771                 ret = usb_keyboard_poll(&s->kbd, p->data, p->len);
 772         } else {
 773             goto fail;
 774         }
 775         break;
 776     case USB_TOKEN_OUT:
 777     default:
 778     fail:
 779         ret = USB_RET_STALL;
 780         break;
 781     }
 782     return ret;
 783 }
 784
 785 static void usb_hid_handle_destroy(USBDevice *dev)
 786 {
 787     USBHIDState *s = (USBHIDState *)dev;
 788
 789     switch(s->kind) {
 790     case USB_KEYBOARD:
 791         qemu_remove_kbd_event_handler();
 792         break;
 793     default:
 794         qemu_remove_mouse_event_handler(s->ptr.eh_entry);
 795     }
 796 }
 797
 798 static int usb_hid_initfn(USBDevice *dev, int kind)
 799 {
 800     USBHIDState *s = DO_UPCAST(USBHIDState, dev, dev);
 801
 802     usb_desc_init(dev);
 803     s->kind = kind;
 804
 805     if (s->kind == USB_MOUSE) {
 806         s->ptr.eh_entry = qemu_add_mouse_event_handler(usb_mouse_event, s,
 807                                                        0, "QEMU USB Mouse");
 808     } else if (s->kind == USB_TABLET) {
 809         s->ptr.eh_entry = qemu_add_mouse_event_handler(usb_tablet_event, s,
 810                                                        1, "QEMU USB Tablet");
 811     }
 812
 813     /* Force poll routine to be run and grab input the first time.  */
 814     s->changed = 1;
 815     return 0;
 816 }
 817
 818 static int usb_tablet_initfn(USBDevice *dev)
 819 {
 820     return usb_hid_initfn(dev, USB_TABLET);
 821 }
 822
 823 static int usb_mouse_initfn(USBDevice *dev)
 824 {
 825     return usb_hid_initfn(dev, USB_MOUSE);
 826 }
 827
 828 static int usb_keyboard_initfn(USBDevice *dev)
 829 {
 830     return usb_hid_initfn(dev, USB_KEYBOARD);
 831 }
 832
 833 void usb_hid_datain_cb(USBDevice *dev, void *opaque, void (*datain)(void *))
 834 {
 835     USBHIDState *s = (USBHIDState *)dev;
 836
 837     s->datain_opaque = opaque;
 838     s->datain = datain;
 839 }
 840
 841 static struct USBDeviceInfo hid_info[] = {
 842     {
 843         .product_desc   = "QEMU USB Tablet",
 844         .qdev.name      = "usb-tablet",
 845         .usbdevice_name = "tablet",
 846         .qdev.size      = sizeof(USBHIDState),
 847         .usb_desc       = &desc_tablet,
 848         .init           = usb_tablet_initfn,
 849         .handle_packet  = usb_generic_handle_packet,
 850         .handle_reset   = usb_mouse_handle_reset,
 851         .handle_control = usb_hid_handle_control,
 852         .handle_data    = usb_hid_handle_data,
 853         .handle_destroy = usb_hid_handle_destroy,
 854     },{
 855         .product_desc   = "QEMU USB Mouse",
 856         .qdev.name      = "usb-mouse",
 857         .usbdevice_name = "mouse",
 858         .qdev.size      = sizeof(USBHIDState),
 859         .usb_desc       = &desc_mouse,
 860         .init           = usb_mouse_initfn,
 861         .handle_packet  = usb_generic_handle_packet,
 862         .handle_reset   = usb_mouse_handle_reset,
 863         .handle_control = usb_hid_handle_control,
 864         .handle_data    = usb_hid_handle_data,
 865         .handle_destroy = usb_hid_handle_destroy,
 866     },{
 867         .product_desc   = "QEMU USB Keyboard",
 868         .qdev.name      = "usb-kbd",
 869         .usbdevice_name = "keyboard",
 870         .qdev.size      = sizeof(USBHIDState),
 871         .usb_desc       = &desc_keyboard,
 872         .init           = usb_keyboard_initfn,
 873         .handle_packet  = usb_generic_handle_packet,
 874         .handle_reset   = usb_keyboard_handle_reset,
 875         .handle_control = usb_hid_handle_control,
 876         .handle_data    = usb_hid_handle_data,
 877         .handle_destroy = usb_hid_handle_destroy,
 878     },{
 879         /* end of list */
 880     }
 881 };
 882
 883 static void usb_hid_register_devices(void)
 884 {
 885     usb_qdev_register_many(hid_info);
 886 }
 887 device_init(usb_hid_register_devices)