hw/usb-wacom.c

   1 /*
   2  * Wacom PenPartner USB tablet emulation.
   3  *
   4  * Copyright (c) 2006 Openedhand Ltd.
   5  * Author: Andrzej Zaborowski <balrog@zabor.org>
   6  *
   7  * Based on hw/usb-hid.c:
   8  * Copyright (c) 2005 Fabrice Bellard
   9  *
  10  * Permission is hereby granted, free of charge, to any person obtaining a copy
  11  * of this software and associated documentation files (the "Software"), to deal
  12  * in the Software without restriction, including without limitation the rights
  13  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  14  * copies of the Software, and to permit persons to whom the Software is
  15  * furnished to do so, subject to the following conditions:
  16  *
  17  * The above copyright notice and this permission notice shall be included in
  18  * all copies or substantial portions of the Software.
  19  *
  20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  21  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  23  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  24  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  25  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  26  * THE SOFTWARE.
  27  */
  28 #include "hw.h"
  29 #include "console.h"
  30 #include "usb.h"
  31
  32 /* Interface requests */
  33 #define WACOM_GET_REPORT        0x2101
  34 #define WACOM_SET_REPORT        0x2109
  35
  36 /* HID interface requests */
  37 #define HID_GET_REPORT          0xa101
  38 #define HID_GET_IDLE            0xa102
  39 #define HID_GET_PROTOCOL        0xa103
  40 #define HID_SET_IDLE            0x210a
  41 #define HID_SET_PROTOCOL        0x210b
  42
  43 typedef struct USBWacomState {
  44     USBDevice dev;
  45     QEMUPutMouseEntry *eh_entry;
  46     int dx, dy, dz, buttons_state;
  47     int x, y;
  48     int mouse_grabbed;
  49     enum {
  50         WACOM_MODE_HID = 1,
  51         WACOM_MODE_WACOM = 2,
  52     } mode;
  53     uint8_t idle;
  54     int changed;
  55 } USBWacomState;
  56
  57 static const uint8_t qemu_wacom_dev_descriptor[] = {
  58     0x12,       /*  u8 bLength; */
  59     0x01,       /*  u8 bDescriptorType; Device */
  60     0x10, 0x10, /*  u16 bcdUSB; v1.10 */
  61
  62     0x00,       /*  u8  bDeviceClass; */
  63     0x00,       /*  u8  bDeviceSubClass; */
  64     0x00,       /*  u8  bDeviceProtocol; [ low/full speeds only ] */
  65     0x08,       /*  u8  bMaxPacketSize0; 8 Bytes */
  66
  67     0x6a, 0x05, /*  u16 idVendor; */
  68     0x00, 0x00, /*  u16 idProduct; */
  69     0x10, 0x42, /*  u16 bcdDevice */
  70
  71     0x01,       /*  u8  iManufacturer; */
  72     0x02,       /*  u8  iProduct; */
  73     0x00,       /*  u8  iSerialNumber; */
  74     0x01,       /*  u8  bNumConfigurations; */
  75 };
  76
  77 static const uint8_t qemu_wacom_config_descriptor[] = {
  78     /* one configuration */
  79     0x09,       /*  u8  bLength; */
  80     0x02,       /*  u8  bDescriptorType; Configuration */
  81     0x22, 0x00, /*  u16 wTotalLength; */
  82     0x01,       /*  u8  bNumInterfaces; (1) */
  83     0x01,       /*  u8  bConfigurationValue; */
  84     0x00,       /*  u8  iConfiguration; */
  85     0x80,       /*  u8  bmAttributes;
  86                                  Bit 7: must be set,
  87                                      6: Self-powered,
  88                                      5: Remote wakeup,
  89                                      4..0: resvd */
  90     40,         /*  u8  MaxPower; */
  91
  92     /* one interface */
  93     0x09,       /*  u8  if_bLength; */
  94     0x04,       /*  u8  if_bDescriptorType; Interface */
  95     0x00,       /*  u8  if_bInterfaceNumber; */
  96     0x00,       /*  u8  if_bAlternateSetting; */
  97     0x01,       /*  u8  if_bNumEndpoints; */
  98     0x03,       /*  u8  if_bInterfaceClass; HID */
  99     0x01,       /*  u8  if_bInterfaceSubClass; Boot */
 100     0x02,       /*  u8  if_bInterfaceProtocol; [usb1.1 or single tt] */
 101     0x00,       /*  u8  if_iInterface; */
 102
 103     /* HID descriptor */
 104     0x09,       /*  u8  bLength; */
 105     0x21,       /*  u8  bDescriptorType; */
 106     0x01, 0x10, /*  u16 HID_class */
 107     0x00,       /*  u8  country_code */
 108     0x01,       /*  u8  num_descriptors */
 109     0x22,       /*  u8  type; Report */
 110     0x6e, 0x00, /*  u16 len */
 111
 112     /* one endpoint (status change endpoint) */
 113     0x07,       /*  u8  ep_bLength; */
 114     0x05,       /*  u8  ep_bDescriptorType; Endpoint */
 115     0x81,       /*  u8  ep_bEndpointAddress; IN Endpoint 1 */
 116     0x03,       /*  u8  ep_bmAttributes; Interrupt */
 117     0x08, 0x00, /*  u16 ep_wMaxPacketSize; */
 118     0x0a,       /*  u8  ep_bInterval; */
 119 };
 120
 121 static void usb_mouse_event(void *opaque,
 122                             int dx1, int dy1, int dz1, int buttons_state)
 123 {
 124     USBWacomState *s = opaque;
 125
 126     s->dx += dx1;
 127     s->dy += dy1;
 128     s->dz += dz1;
 129     s->buttons_state = buttons_state;
 130     s->changed = 1;
 131 }
 132
 133 static void usb_wacom_event(void *opaque,
 134                             int x, int y, int dz, int buttons_state)
 135 {
 136     USBWacomState *s = opaque;
 137
 138     /* scale to Penpartner resolution */
 139     s->x = (x * 5040 / 0x7FFF);
 140     s->y = (y * 3780 / 0x7FFF);
 141     s->dz += dz;
 142     s->buttons_state = buttons_state;
 143     s->changed = 1;
 144 }
 145
 146 static inline int int_clamp(int val, int vmin, int vmax)
 147 {
 148     if (val < vmin)
 149         return vmin;
 150     else if (val > vmax)
 151         return vmax;
 152     else
 153         return val;
 154 }
 155
 156 static int usb_mouse_poll(USBWacomState *s, uint8_t *buf, int len)
 157 {
 158     int dx, dy, dz, b, l;
 159
 160     if (!s->mouse_grabbed) {
 161         s->eh_entry = qemu_add_mouse_event_handler(usb_mouse_event, s, 0,
 162                         "QEMU PenPartner tablet");
 163         s->mouse_grabbed = 1;
 164     }
 165
 166     dx = int_clamp(s->dx, -128, 127);
 167     dy = int_clamp(s->dy, -128, 127);
 168     dz = int_clamp(s->dz, -128, 127);
 169
 170     s->dx -= dx;
 171     s->dy -= dy;
 172     s->dz -= dz;
 173
 174     b = 0;
 175     if (s->buttons_state & MOUSE_EVENT_LBUTTON)
 176         b |= 0x01;
 177     if (s->buttons_state & MOUSE_EVENT_RBUTTON)
 178         b |= 0x02;
 179     if (s->buttons_state & MOUSE_EVENT_MBUTTON)
 180         b |= 0x04;
 181
 182     buf[0] = b;
 183     buf[1] = dx;
 184     buf[2] = dy;
 185     l = 3;
 186     if (len >= 4) {
 187         buf[3] = dz;
 188         l = 4;
 189     }
 190     return l;
 191 }
 192
 193 static int usb_wacom_poll(USBWacomState *s, uint8_t *buf, int len)
 194 {
 195     int b;
 196
 197     if (!s->mouse_grabbed) {
 198         s->eh_entry = qemu_add_mouse_event_handler(usb_wacom_event, s, 1,
 199                         "QEMU PenPartner tablet");
 200         s->mouse_grabbed = 1;
 201     }
 202
 203     b = 0;
 204     if (s->buttons_state & MOUSE_EVENT_LBUTTON)
 205         b |= 0x01;
 206     if (s->buttons_state & MOUSE_EVENT_RBUTTON)
 207         b |= 0x40;
 208     if (s->buttons_state & MOUSE_EVENT_MBUTTON)
 209         b |= 0x20; /* eraser */
 210
 211     if (len < 7)
 212         return 0;
 213
 214     buf[0] = s->mode;
 215     buf[5] = 0x00 | (b & 0xf0);
 216     buf[1] = s->x & 0xff;
 217     buf[2] = s->x >> 8;
 218     buf[3] = s->y & 0xff;
 219     buf[4] = s->y >> 8;
 220     if (b & 0x3f) {
 221         buf[6] = 0;
 222     } else {
 223         buf[6] = (unsigned char) -127;
 224     }
 225
 226     return 7;
 227 }
 228
 229 static void usb_wacom_handle_reset(USBDevice *dev)
 230 {
 231     USBWacomState *s = (USBWacomState *) dev;
 232
 233     s->dx = 0;
 234     s->dy = 0;
 235     s->dz = 0;
 236     s->x = 0;
 237     s->y = 0;
 238     s->buttons_state = 0;
 239     s->mode = WACOM_MODE_HID;
 240 }
 241
 242 static int usb_wacom_handle_control(USBDevice *dev, int request, int value,
 243                                     int index, int length, uint8_t *data)
 244 {
 245     USBWacomState *s = (USBWacomState *) dev;
 246     int ret = 0;
 247
 248     switch (request) {
 249     case DeviceRequest | USB_REQ_GET_STATUS:
 250         data[0] = (1 << USB_DEVICE_SELF_POWERED) |
 251             (dev->remote_wakeup << USB_DEVICE_REMOTE_WAKEUP);
 252         data[1] = 0x00;
 253         ret = 2;
 254         break;
 255     case DeviceOutRequest | USB_REQ_CLEAR_FEATURE:
 256         if (value == USB_DEVICE_REMOTE_WAKEUP) {
 257             dev->remote_wakeup = 0;
 258         } else {
 259             goto fail;
 260         }
 261         ret = 0;
 262         break;
 263     case DeviceOutRequest | USB_REQ_SET_FEATURE:
 264         if (value == USB_DEVICE_REMOTE_WAKEUP) {
 265             dev->remote_wakeup = 1;
 266         } else {
 267             goto fail;
 268         }
 269         ret = 0;
 270         break;
 271     case DeviceOutRequest | USB_REQ_SET_ADDRESS:
 272         dev->addr = value;
 273         ret = 0;
 274         break;
 275     case DeviceRequest | USB_REQ_GET_DESCRIPTOR:
 276         switch (value >> 8) {
 277         case USB_DT_DEVICE:
 278             memcpy(data, qemu_wacom_dev_descriptor,
 279                    sizeof(qemu_wacom_dev_descriptor));
 280             ret = sizeof(qemu_wacom_dev_descriptor);
 281             break;
 282         case USB_DT_CONFIG:
 283             memcpy(data, qemu_wacom_config_descriptor,
 284                    sizeof(qemu_wacom_config_descriptor));
 285             ret = sizeof(qemu_wacom_config_descriptor);
 286             break;
 287         case USB_DT_STRING:
 288             switch (value & 0xff) {
 289             case 0:
 290                 /* language ids */
 291                 data[0] = 4;
 292                 data[1] = 3;
 293                 data[2] = 0x09;
 294                 data[3] = 0x04;
 295                 ret = 4;
 296                 break;
 297             case 1:
 298                 /* serial number */
 299                 ret = set_usb_string(data, "1");
 300                 break;
 301             case 2:
 302                 ret = set_usb_string(data, "Wacom PenPartner");
 303                 break;
 304             case 3:
 305                 /* vendor description */
 306                 ret = set_usb_string(data, "QEMU " QEMU_VERSION);
 307                 break;
 308             case 4:
 309                 ret = set_usb_string(data, "Wacom Tablet");
 310                 break;
 311             case 5:
 312                 ret = set_usb_string(data, "Endpoint1 Interrupt Pipe");
 313                 break;
 314             default:
 315                 goto fail;
 316             }
 317             break;
 318         default:
 319             goto fail;
 320         }
 321         break;
 322     case DeviceRequest | USB_REQ_GET_CONFIGURATION:
 323         data[0] = 1;
 324         ret = 1;
 325         break;
 326     case DeviceOutRequest | USB_REQ_SET_CONFIGURATION:
 327         ret = 0;
 328         break;
 329     case DeviceRequest | USB_REQ_GET_INTERFACE:
 330         data[0] = 0;
 331         ret = 1;
 332         break;
 333     case DeviceOutRequest | USB_REQ_SET_INTERFACE:
 334         ret = 0;
 335         break;
 336     case WACOM_SET_REPORT:
 337         qemu_remove_mouse_event_handler(s->eh_entry);
 338         s->mouse_grabbed = 0;
 339         s->mode = data[0];
 340         ret = 0;
 341         break;
 342     case WACOM_GET_REPORT:
 343         data[0] = 0;
 344         data[1] = s->mode;
 345         ret = 2;
 346         break;
 347     /* USB HID requests */
 348     case HID_GET_REPORT:
 349         if (s->mode == WACOM_MODE_HID)
 350             ret = usb_mouse_poll(s, data, length);
 351         else if (s->mode == WACOM_MODE_WACOM)
 352             ret = usb_wacom_poll(s, data, length);
 353         break;
 354     case HID_GET_IDLE:
 355         ret = 1;
 356         data[0] = s->idle;
 357         break;
 358     case HID_SET_IDLE:
 359         s->idle = (uint8_t) (value >> 8);
 360         ret = 0;
 361         break;
 362     default:
 363     fail:
 364         ret = USB_RET_STALL;
 365         break;
 366     }
 367     return ret;
 368 }
 369
 370 static int usb_wacom_handle_data(USBDevice *dev, USBPacket *p)
 371 {
 372     USBWacomState *s = (USBWacomState *) dev;
 373     int ret = 0;
 374
 375     switch (p->pid) {
 376     case USB_TOKEN_IN:
 377         if (p->devep == 1) {
 378             if (!(s->changed || s->idle))
 379                 return USB_RET_NAK;
 380             s->changed = 0;
 381             if (s->mode == WACOM_MODE_HID)
 382                 ret = usb_mouse_poll(s, p->data, p->len);
 383             else if (s->mode == WACOM_MODE_WACOM)
 384                 ret = usb_wacom_poll(s, p->data, p->len);
 385             break;
 386         }
 387         /* Fall through.  */
 388     case USB_TOKEN_OUT:
 389     default:
 390         ret = USB_RET_STALL;
 391         break;
 392     }
 393     return ret;
 394 }
 395
 396 static void usb_wacom_handle_destroy(USBDevice *dev)
 397 {
 398     USBWacomState *s = (USBWacomState *) dev;
 399
 400     qemu_remove_mouse_event_handler(s->eh_entry);
 401 }
 402
 403 static int usb_wacom_initfn(USBDevice *dev)
 404 {
 405     USBWacomState *s = DO_UPCAST(USBWacomState, dev, dev);
 406     s->dev.speed = USB_SPEED_FULL;
 407     s->changed = 1;
 408     return 0;
 409 }
 410
 411 static struct USBDeviceInfo wacom_info = {
 412     .qdev.name      = "QEMU PenPartner Tablet",
 413     .qdev.alias     = "wacom-tablet",
 414     .usbdevice_name = "wacom-tablet",
 415     .qdev.size      = sizeof(USBWacomState),
 416     .init           = usb_wacom_initfn,
 417     .handle_packet  = usb_generic_handle_packet,
 418     .handle_reset   = usb_wacom_handle_reset,
 419     .handle_control = usb_wacom_handle_control,
 420     .handle_data    = usb_wacom_handle_data,
 421     .handle_destroy = usb_wacom_handle_destroy,
 422 };
 423
 424 static void usb_wacom_register_devices(void)
 425 {
 426     usb_qdev_register(&wacom_info);
 427 }
 428 device_init(usb_wacom_register_devices)