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 #include "usb-desc.h"
  32
  33 /* Interface requests */
  34 #define WACOM_GET_REPORT        0x2101
  35 #define WACOM_SET_REPORT        0x2109
  36
  37 /* HID interface requests */
  38 #define HID_GET_REPORT          0xa101
  39 #define HID_GET_IDLE            0xa102
  40 #define HID_GET_PROTOCOL        0xa103
  41 #define HID_SET_IDLE            0x210a
  42 #define HID_SET_PROTOCOL        0x210b
  43
  44 typedef struct USBWacomState {
  45     USBDevice dev;
  46     QEMUPutMouseEntry *eh_entry;
  47     int dx, dy, dz, buttons_state;
  48     int x, y;
  49     int mouse_grabbed;
  50     enum {
  51         WACOM_MODE_HID = 1,
  52         WACOM_MODE_WACOM = 2,
  53     } mode;
  54     uint8_t idle;
  55     int changed;
  56 } USBWacomState;
  57
  58 enum {
  59     STR_MANUFACTURER = 1,
  60     STR_PRODUCT,
  61     STR_SERIALNUMBER,
  62 };
  63
  64 static const USBDescStrings desc_strings = {
  65     [STR_MANUFACTURER]     = "QEMU " QEMU_VERSION,
  66     [STR_PRODUCT]          = "Wacom PenPartner",
  67     [STR_SERIALNUMBER]     = "1",
  68 };
  69
  70 static const USBDescIface desc_iface_wacom = {
  71     .bInterfaceNumber              = 0,
  72     .bNumEndpoints                 = 1,
  73     .bInterfaceClass               = USB_CLASS_HID,
  74     .bInterfaceSubClass            = 0x01, /* boot */
  75     .bInterfaceProtocol            = 0x02,
  76     .ndesc                         = 1,
  77     .descs = (USBDescOther[]) {
  78         {
  79             /* HID descriptor */
  80             .data = (uint8_t[]) {
  81                 0x09,          /*  u8  bLength */
  82                 0x21,          /*  u8  bDescriptorType */
  83                 0x01, 0x10,    /*  u16 HID_class */
  84                 0x00,          /*  u8  country_code */
  85                 0x01,          /*  u8  num_descriptors */
  86                 0x22,          /*  u8  type: Report */
  87                 0x6e, 0,       /*  u16 len */
  88             },
  89         },
  90     },
  91     .eps = (USBDescEndpoint[]) {
  92         {
  93             .bEndpointAddress      = USB_DIR_IN | 0x01,
  94             .bmAttributes          = USB_ENDPOINT_XFER_INT,
  95             .wMaxPacketSize        = 8,
  96             .bInterval             = 0x0a,
  97         },
  98     },
  99 };
 100
 101 static const USBDescDevice desc_device_wacom = {
 102     .bcdUSB                        = 0x0110,
 103     .bMaxPacketSize0               = 8,
 104     .bNumConfigurations            = 1,
 105     .confs = (USBDescConfig[]) {
 106         {
 107             .bNumInterfaces        = 1,
 108             .bConfigurationValue   = 1,
 109             .bmAttributes          = 0x80,
 110             .bMaxPower             = 40,
 111             .nif = 1,
 112             .ifs = &desc_iface_wacom,
 113         },
 114     },
 115 };
 116
 117 static const USBDesc desc_wacom = {
 118     .id = {
 119         .idVendor          = 0x056a,
 120         .idProduct         = 0x0000,
 121         .bcdDevice         = 0x4210,
 122         .iManufacturer     = STR_MANUFACTURER,
 123         .iProduct          = STR_PRODUCT,
 124         .iSerialNumber     = STR_SERIALNUMBER,
 125     },
 126     .full = &desc_device_wacom,
 127     .str  = desc_strings,
 128 };
 129
 130 static void usb_mouse_event(void *opaque,
 131                             int dx1, int dy1, int dz1, int buttons_state)
 132 {
 133     USBWacomState *s = opaque;
 134
 135     s->dx += dx1;
 136     s->dy += dy1;
 137     s->dz += dz1;
 138     s->buttons_state = buttons_state;
 139     s->changed = 1;
 140 }
 141
 142 static void usb_wacom_event(void *opaque,
 143                             int x, int y, int dz, int buttons_state)
 144 {
 145     USBWacomState *s = opaque;
 146
 147     /* scale to Penpartner resolution */
 148     s->x = (x * 5040 / 0x7FFF);
 149     s->y = (y * 3780 / 0x7FFF);
 150     s->dz += dz;
 151     s->buttons_state = buttons_state;
 152     s->changed = 1;
 153 }
 154
 155 static inline int int_clamp(int val, int vmin, int vmax)
 156 {
 157     if (val < vmin)
 158         return vmin;
 159     else if (val > vmax)
 160         return vmax;
 161     else
 162         return val;
 163 }
 164
 165 static int usb_mouse_poll(USBWacomState *s, uint8_t *buf, int len)
 166 {
 167     int dx, dy, dz, b, l;
 168
 169     if (!s->mouse_grabbed) {
 170         s->eh_entry = qemu_add_mouse_event_handler(usb_mouse_event, s, 0,
 171                         "QEMU PenPartner tablet");
 172         qemu_activate_mouse_event_handler(s->eh_entry);
 173         s->mouse_grabbed = 1;
 174     }
 175
 176     dx = int_clamp(s->dx, -128, 127);
 177     dy = int_clamp(s->dy, -128, 127);
 178     dz = int_clamp(s->dz, -128, 127);
 179
 180     s->dx -= dx;
 181     s->dy -= dy;
 182     s->dz -= dz;
 183
 184     b = 0;
 185     if (s->buttons_state & MOUSE_EVENT_LBUTTON)
 186         b |= 0x01;
 187     if (s->buttons_state & MOUSE_EVENT_RBUTTON)
 188         b |= 0x02;
 189     if (s->buttons_state & MOUSE_EVENT_MBUTTON)
 190         b |= 0x04;
 191
 192     buf[0] = b;
 193     buf[1] = dx;
 194     buf[2] = dy;
 195     l = 3;
 196     if (len >= 4) {
 197         buf[3] = dz;
 198         l = 4;
 199     }
 200     return l;
 201 }
 202
 203 static int usb_wacom_poll(USBWacomState *s, uint8_t *buf, int len)
 204 {
 205     int b;
 206
 207     if (!s->mouse_grabbed) {
 208         s->eh_entry = qemu_add_mouse_event_handler(usb_wacom_event, s, 1,
 209                         "QEMU PenPartner tablet");
 210         qemu_activate_mouse_event_handler(s->eh_entry);
 211         s->mouse_grabbed = 1;
 212     }
 213
 214     b = 0;
 215     if (s->buttons_state & MOUSE_EVENT_LBUTTON)
 216         b |= 0x01;
 217     if (s->buttons_state & MOUSE_EVENT_RBUTTON)
 218         b |= 0x40;
 219     if (s->buttons_state & MOUSE_EVENT_MBUTTON)
 220         b |= 0x20; /* eraser */
 221
 222     if (len < 7)
 223         return 0;
 224
 225     buf[0] = s->mode;
 226     buf[5] = 0x00 | (b & 0xf0);
 227     buf[1] = s->x & 0xff;
 228     buf[2] = s->x >> 8;
 229     buf[3] = s->y & 0xff;
 230     buf[4] = s->y >> 8;
 231     if (b & 0x3f) {
 232         buf[6] = 0;
 233     } else {
 234         buf[6] = (unsigned char) -127;
 235     }
 236
 237     return 7;
 238 }
 239
 240 static void usb_wacom_handle_reset(USBDevice *dev)
 241 {
 242     USBWacomState *s = (USBWacomState *) dev;
 243
 244     s->dx = 0;
 245     s->dy = 0;
 246     s->dz = 0;
 247     s->x = 0;
 248     s->y = 0;
 249     s->buttons_state = 0;
 250     s->mode = WACOM_MODE_HID;
 251 }
 252
 253 static int usb_wacom_handle_control(USBDevice *dev, USBPacket *p,
 254                int request, int value, int index, int length, uint8_t *data)
 255 {
 256     USBWacomState *s = (USBWacomState *) dev;
 257     int ret;
 258
 259     ret = usb_desc_handle_control(dev, p, request, value, index, length, data);
 260     if (ret >= 0) {
 261         return ret;
 262     }
 263
 264     ret = 0;
 265     switch (request) {
 266     case DeviceRequest | USB_REQ_GET_INTERFACE:
 267         data[0] = 0;
 268         ret = 1;
 269         break;
 270     case DeviceOutRequest | USB_REQ_SET_INTERFACE:
 271         ret = 0;
 272         break;
 273     case WACOM_SET_REPORT:
 274         if (s->mouse_grabbed) {
 275             qemu_remove_mouse_event_handler(s->eh_entry);
 276             s->mouse_grabbed = 0;
 277         }
 278         s->mode = data[0];
 279         ret = 0;
 280         break;
 281     case WACOM_GET_REPORT:
 282         data[0] = 0;
 283         data[1] = s->mode;
 284         ret = 2;
 285         break;
 286     /* USB HID requests */
 287     case HID_GET_REPORT:
 288         if (s->mode == WACOM_MODE_HID)
 289             ret = usb_mouse_poll(s, data, length);
 290         else if (s->mode == WACOM_MODE_WACOM)
 291             ret = usb_wacom_poll(s, data, length);
 292         break;
 293     case HID_GET_IDLE:
 294         ret = 1;
 295         data[0] = s->idle;
 296         break;
 297     case HID_SET_IDLE:
 298         s->idle = (uint8_t) (value >> 8);
 299         ret = 0;
 300         break;
 301     default:
 302         ret = USB_RET_STALL;
 303         break;
 304     }
 305     return ret;
 306 }
 307
 308 static int usb_wacom_handle_data(USBDevice *dev, USBPacket *p)
 309 {
 310     USBWacomState *s = (USBWacomState *) dev;
 311     uint8_t buf[p->iov.size];
 312     int ret = 0;
 313
 314     switch (p->pid) {
 315     case USB_TOKEN_IN:
 316         if (p->devep == 1) {
 317             if (!(s->changed || s->idle))
 318                 return USB_RET_NAK;
 319             s->changed = 0;
 320             if (s->mode == WACOM_MODE_HID)
 321                 ret = usb_mouse_poll(s, buf, p->iov.size);
 322             else if (s->mode == WACOM_MODE_WACOM)
 323                 ret = usb_wacom_poll(s, buf, p->iov.size);
 324             usb_packet_copy(p, buf, ret);
 325             break;
 326         }
 327         /* Fall through.  */
 328     case USB_TOKEN_OUT:
 329     default:
 330         ret = USB_RET_STALL;
 331         break;
 332     }
 333     return ret;
 334 }
 335
 336 static void usb_wacom_handle_destroy(USBDevice *dev)
 337 {
 338     USBWacomState *s = (USBWacomState *) dev;
 339
 340     if (s->mouse_grabbed) {
 341         qemu_remove_mouse_event_handler(s->eh_entry);
 342         s->mouse_grabbed = 0;
 343     }
 344 }
 345
 346 static int usb_wacom_initfn(USBDevice *dev)
 347 {
 348     USBWacomState *s = DO_UPCAST(USBWacomState, dev, dev);
 349     usb_desc_init(dev);
 350     s->changed = 1;
 351     return 0;
 352 }
 353
 354 static const VMStateDescription vmstate_usb_wacom = {
 355     .name = "usb-wacom",
 356     .unmigratable = 1,
 357 };
 358
 359 static struct USBDeviceInfo wacom_info = {
 360     .product_desc   = "QEMU PenPartner Tablet",
 361     .qdev.name      = "usb-wacom-tablet",
 362     .qdev.desc      = "QEMU PenPartner Tablet",
 363     .usbdevice_name = "wacom-tablet",
 364     .usb_desc       = &desc_wacom,
 365     .qdev.size      = sizeof(USBWacomState),
 366     .qdev.vmsd      = &vmstate_usb_wacom,
 367     .init           = usb_wacom_initfn,
 368     .handle_packet  = usb_generic_handle_packet,
 369     .handle_reset   = usb_wacom_handle_reset,
 370     .handle_control = usb_wacom_handle_control,
 371     .handle_data    = usb_wacom_handle_data,
 372     .handle_destroy = usb_wacom_handle_destroy,
 373 };
 374
 375 static void usb_wacom_register_devices(void)
 376 {
 377     usb_qdev_register(&wacom_info);
 378 }
 379 device_init(usb_wacom_register_devices)