dev-wacom.c (13751B)
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 29 #include "qemu/osdep.h" 30 #include "ui/console.h" 31 #include "hw/usb.h" 32 #include "hw/usb/hid.h" 33 #include "migration/vmstate.h" 34 #include "qemu/module.h" 35 #include "desc.h" 36 #include "qom/object.h" 37 38 /* Interface requests */ 39 #define WACOM_GET_REPORT 0x2101 40 #define WACOM_SET_REPORT 0x2109 41 42 struct USBWacomState { 43 USBDevice dev; 44 USBEndpoint *intr; 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 }; 56 57 #define TYPE_USB_WACOM "usb-wacom-tablet" 58 OBJECT_DECLARE_SIMPLE_TYPE(USBWacomState, USB_WACOM) 59 60 enum { 61 STR_MANUFACTURER = 1, 62 STR_PRODUCT, 63 STR_SERIALNUMBER, 64 }; 65 66 static const USBDescStrings desc_strings = { 67 [STR_MANUFACTURER] = "QEMU", 68 [STR_PRODUCT] = "Wacom PenPartner", 69 [STR_SERIALNUMBER] = "1", 70 }; 71 72 static const uint8_t qemu_wacom_hid_report_descriptor[] = { 73 0x05, 0x01, /* Usage Page (Desktop) */ 74 0x09, 0x02, /* Usage (Mouse) */ 75 0xa1, 0x01, /* Collection (Application) */ 76 0x85, 0x01, /* Report ID (1) */ 77 0x09, 0x01, /* Usage (Pointer) */ 78 0xa1, 0x00, /* Collection (Physical) */ 79 0x05, 0x09, /* Usage Page (Button) */ 80 0x19, 0x01, /* Usage Minimum (01h) */ 81 0x29, 0x03, /* Usage Maximum (03h) */ 82 0x15, 0x00, /* Logical Minimum (0) */ 83 0x25, 0x01, /* Logical Maximum (1) */ 84 0x95, 0x03, /* Report Count (3) */ 85 0x75, 0x01, /* Report Size (1) */ 86 0x81, 0x02, /* Input (Data, Variable, Absolute) */ 87 0x95, 0x01, /* Report Count (1) */ 88 0x75, 0x05, /* Report Size (5) */ 89 0x81, 0x01, /* Input (Constant) */ 90 0x05, 0x01, /* Usage Page (Desktop) */ 91 0x09, 0x30, /* Usage (X) */ 92 0x09, 0x31, /* Usage (Y) */ 93 0x09, 0x38, /* Usage (Wheel) */ 94 0x15, 0x81, /* Logical Minimum (-127) */ 95 0x25, 0x7f, /* Logical Maximum (127) */ 96 0x75, 0x08, /* Report Size (8) */ 97 0x95, 0x03, /* Report Count (3) */ 98 0x81, 0x06, /* Input (Data, Variable, Relative) */ 99 0x95, 0x03, /* Report Count (3) */ 100 0x81, 0x01, /* Input (Constant) */ 101 0xc0, /* End Collection */ 102 0xc0, /* End Collection */ 103 0x05, 0x0d, /* Usage Page (Digitizer) */ 104 0x09, 0x01, /* Usage (Digitizer) */ 105 0xa1, 0x01, /* Collection (Application) */ 106 0x85, 0x02, /* Report ID (2) */ 107 0xa1, 0x00, /* Collection (Physical) */ 108 0x06, 0x00, 0xff,/* Usage Page (ff00h), vendor-defined */ 109 0x09, 0x01, /* Usage (01h) */ 110 0x15, 0x00, /* Logical Minimum (0) */ 111 0x26, 0xff, 0x00,/* Logical Maximum (255) */ 112 0x75, 0x08, /* Report Size (8) */ 113 0x95, 0x07, /* Report Count (7) */ 114 0x81, 0x02, /* Input (Data, Variable, Absolute) */ 115 0xc0, /* End Collection */ 116 0x09, 0x01, /* Usage (01h) */ 117 0x85, 0x63, /* Report ID (99) */ 118 0x95, 0x07, /* Report Count (7) */ 119 0x81, 0x02, /* Input (Data, Variable, Absolute) */ 120 0x09, 0x01, /* Usage (01h) */ 121 0x85, 0x02, /* Report ID (2) */ 122 0x95, 0x01, /* Report Count (1) */ 123 0xb1, 0x02, /* Feature (Variable) */ 124 0x09, 0x01, /* Usage (01h) */ 125 0x85, 0x03, /* Report ID (3) */ 126 0x95, 0x01, /* Report Count (1) */ 127 0xb1, 0x02, /* Feature (Variable) */ 128 0xc0 /* End Collection */ 129 }; 130 131 static const USBDescIface desc_iface_wacom = { 132 .bInterfaceNumber = 0, 133 .bNumEndpoints = 1, 134 .bInterfaceClass = USB_CLASS_HID, 135 .bInterfaceSubClass = 0x01, /* boot */ 136 .bInterfaceProtocol = 0x02, 137 .ndesc = 1, 138 .descs = (USBDescOther[]) { 139 { 140 /* HID descriptor */ 141 .data = (uint8_t[]) { 142 0x09, /* u8 bLength */ 143 USB_DT_HID, /* u8 bDescriptorType */ 144 0x01, 0x10, /* u16 HID_class */ 145 0x00, /* u8 country_code */ 146 0x01, /* u8 num_descriptors */ 147 USB_DT_REPORT, /* u8 type: Report */ 148 sizeof(qemu_wacom_hid_report_descriptor), 0, /* u16 len */ 149 }, 150 }, 151 }, 152 .eps = (USBDescEndpoint[]) { 153 { 154 .bEndpointAddress = USB_DIR_IN | 0x01, 155 .bmAttributes = USB_ENDPOINT_XFER_INT, 156 .wMaxPacketSize = 8, 157 .bInterval = 0x0a, 158 }, 159 }, 160 }; 161 162 static const USBDescDevice desc_device_wacom = { 163 .bcdUSB = 0x0110, 164 .bMaxPacketSize0 = 8, 165 .bNumConfigurations = 1, 166 .confs = (USBDescConfig[]) { 167 { 168 .bNumInterfaces = 1, 169 .bConfigurationValue = 1, 170 .bmAttributes = USB_CFG_ATT_ONE, 171 .bMaxPower = 40, 172 .nif = 1, 173 .ifs = &desc_iface_wacom, 174 }, 175 }, 176 }; 177 178 static const USBDesc desc_wacom = { 179 .id = { 180 .idVendor = 0x056a, 181 .idProduct = 0x0000, 182 .bcdDevice = 0x4210, 183 .iManufacturer = STR_MANUFACTURER, 184 .iProduct = STR_PRODUCT, 185 .iSerialNumber = STR_SERIALNUMBER, 186 }, 187 .full = &desc_device_wacom, 188 .str = desc_strings, 189 }; 190 191 static void usb_mouse_event(void *opaque, 192 int dx1, int dy1, int dz1, int buttons_state) 193 { 194 USBWacomState *s = opaque; 195 196 s->dx += dx1; 197 s->dy += dy1; 198 s->dz += dz1; 199 s->buttons_state = buttons_state; 200 s->changed = 1; 201 usb_wakeup(s->intr, 0); 202 } 203 204 static void usb_wacom_event(void *opaque, 205 int x, int y, int dz, int buttons_state) 206 { 207 USBWacomState *s = opaque; 208 209 /* scale to Penpartner resolution */ 210 s->x = (x * 5040 / 0x7FFF); 211 s->y = (y * 3780 / 0x7FFF); 212 s->dz += dz; 213 s->buttons_state = buttons_state; 214 s->changed = 1; 215 usb_wakeup(s->intr, 0); 216 } 217 218 static inline int int_clamp(int val, int vmin, int vmax) 219 { 220 if (val < vmin) 221 return vmin; 222 else if (val > vmax) 223 return vmax; 224 else 225 return val; 226 } 227 228 static int usb_mouse_poll(USBWacomState *s, uint8_t *buf, int len) 229 { 230 int dx, dy, dz, b, l; 231 232 if (!s->mouse_grabbed) { 233 s->eh_entry = qemu_add_mouse_event_handler(usb_mouse_event, s, 0, 234 "QEMU PenPartner tablet"); 235 qemu_activate_mouse_event_handler(s->eh_entry); 236 s->mouse_grabbed = 1; 237 } 238 239 dx = int_clamp(s->dx, -128, 127); 240 dy = int_clamp(s->dy, -128, 127); 241 dz = int_clamp(s->dz, -128, 127); 242 243 s->dx -= dx; 244 s->dy -= dy; 245 s->dz -= dz; 246 247 b = 0; 248 if (s->buttons_state & MOUSE_EVENT_LBUTTON) 249 b |= 0x01; 250 if (s->buttons_state & MOUSE_EVENT_RBUTTON) 251 b |= 0x02; 252 if (s->buttons_state & MOUSE_EVENT_MBUTTON) 253 b |= 0x04; 254 255 buf[0] = b; 256 buf[1] = dx; 257 buf[2] = dy; 258 l = 3; 259 if (len >= 4) { 260 buf[3] = dz; 261 l = 4; 262 } 263 return l; 264 } 265 266 static int usb_wacom_poll(USBWacomState *s, uint8_t *buf, int len) 267 { 268 int b; 269 270 if (!s->mouse_grabbed) { 271 s->eh_entry = qemu_add_mouse_event_handler(usb_wacom_event, s, 1, 272 "QEMU PenPartner tablet"); 273 qemu_activate_mouse_event_handler(s->eh_entry); 274 s->mouse_grabbed = 1; 275 } 276 277 b = 0; 278 if (s->buttons_state & MOUSE_EVENT_LBUTTON) 279 b |= 0x01; 280 if (s->buttons_state & MOUSE_EVENT_RBUTTON) 281 b |= 0x40; 282 if (s->buttons_state & MOUSE_EVENT_MBUTTON) 283 b |= 0x20; /* eraser */ 284 285 if (len < 7) 286 return 0; 287 288 buf[0] = s->mode; 289 buf[5] = 0x00 | (b & 0xf0); 290 buf[1] = s->x & 0xff; 291 buf[2] = s->x >> 8; 292 buf[3] = s->y & 0xff; 293 buf[4] = s->y >> 8; 294 if (b & 0x3f) { 295 buf[6] = 0; 296 } else { 297 buf[6] = (unsigned char) -127; 298 } 299 300 return 7; 301 } 302 303 static void usb_wacom_handle_reset(USBDevice *dev) 304 { 305 USBWacomState *s = (USBWacomState *) dev; 306 307 s->dx = 0; 308 s->dy = 0; 309 s->dz = 0; 310 s->x = 0; 311 s->y = 0; 312 s->buttons_state = 0; 313 s->mode = WACOM_MODE_HID; 314 } 315 316 static void usb_wacom_handle_control(USBDevice *dev, USBPacket *p, 317 int request, int value, int index, int length, uint8_t *data) 318 { 319 USBWacomState *s = (USBWacomState *) dev; 320 int ret; 321 322 ret = usb_desc_handle_control(dev, p, request, value, index, length, data); 323 if (ret >= 0) { 324 return; 325 } 326 327 switch (request) { 328 case InterfaceRequest | USB_REQ_GET_DESCRIPTOR: 329 switch (value >> 8) { 330 case 0x22: 331 memcpy(data, qemu_wacom_hid_report_descriptor, 332 sizeof(qemu_wacom_hid_report_descriptor)); 333 p->actual_length = sizeof(qemu_wacom_hid_report_descriptor); 334 break; 335 default: 336 return; 337 } 338 break; 339 case WACOM_SET_REPORT: 340 if (s->mouse_grabbed) { 341 qemu_remove_mouse_event_handler(s->eh_entry); 342 s->mouse_grabbed = 0; 343 } 344 s->mode = data[0]; 345 break; 346 case WACOM_GET_REPORT: 347 data[0] = 0; 348 data[1] = s->mode; 349 p->actual_length = 2; 350 break; 351 /* USB HID requests */ 352 case HID_GET_REPORT: 353 if (s->mode == WACOM_MODE_HID) 354 p->actual_length = usb_mouse_poll(s, data, length); 355 else if (s->mode == WACOM_MODE_WACOM) 356 p->actual_length = usb_wacom_poll(s, data, length); 357 break; 358 case HID_GET_IDLE: 359 data[0] = s->idle; 360 p->actual_length = 1; 361 break; 362 case HID_SET_IDLE: 363 s->idle = (uint8_t) (value >> 8); 364 break; 365 default: 366 p->status = USB_RET_STALL; 367 break; 368 } 369 } 370 371 static void usb_wacom_handle_data(USBDevice *dev, USBPacket *p) 372 { 373 USBWacomState *s = (USBWacomState *) dev; 374 g_autofree uint8_t *buf = g_malloc(p->iov.size); 375 int len = 0; 376 377 switch (p->pid) { 378 case USB_TOKEN_IN: 379 if (p->ep->nr == 1) { 380 if (!(s->changed || s->idle)) { 381 p->status = USB_RET_NAK; 382 return; 383 } 384 s->changed = 0; 385 if (s->mode == WACOM_MODE_HID) 386 len = usb_mouse_poll(s, buf, p->iov.size); 387 else if (s->mode == WACOM_MODE_WACOM) 388 len = usb_wacom_poll(s, buf, p->iov.size); 389 usb_packet_copy(p, buf, len); 390 break; 391 } 392 /* Fall through. */ 393 case USB_TOKEN_OUT: 394 default: 395 p->status = USB_RET_STALL; 396 } 397 } 398 399 static void usb_wacom_unrealize(USBDevice *dev) 400 { 401 USBWacomState *s = (USBWacomState *) dev; 402 403 if (s->mouse_grabbed) { 404 qemu_remove_mouse_event_handler(s->eh_entry); 405 s->mouse_grabbed = 0; 406 } 407 } 408 409 static void usb_wacom_realize(USBDevice *dev, Error **errp) 410 { 411 USBWacomState *s = USB_WACOM(dev); 412 usb_desc_create_serial(dev); 413 usb_desc_init(dev); 414 s->intr = usb_ep_get(dev, USB_TOKEN_IN, 1); 415 s->changed = 1; 416 } 417 418 static const VMStateDescription vmstate_usb_wacom = { 419 .name = "usb-wacom", 420 .unmigratable = 1, 421 }; 422 423 static void usb_wacom_class_init(ObjectClass *klass, void *data) 424 { 425 DeviceClass *dc = DEVICE_CLASS(klass); 426 USBDeviceClass *uc = USB_DEVICE_CLASS(klass); 427 428 uc->product_desc = "QEMU PenPartner Tablet"; 429 uc->usb_desc = &desc_wacom; 430 uc->realize = usb_wacom_realize; 431 uc->handle_reset = usb_wacom_handle_reset; 432 uc->handle_control = usb_wacom_handle_control; 433 uc->handle_data = usb_wacom_handle_data; 434 uc->unrealize = usb_wacom_unrealize; 435 set_bit(DEVICE_CATEGORY_INPUT, dc->categories); 436 dc->desc = "QEMU PenPartner Tablet"; 437 dc->vmsd = &vmstate_usb_wacom; 438 } 439 440 static const TypeInfo wacom_info = { 441 .name = TYPE_USB_WACOM, 442 .parent = TYPE_USB_DEVICE, 443 .instance_size = sizeof(USBWacomState), 444 .class_init = usb_wacom_class_init, 445 }; 446 447 static void usb_wacom_register_types(void) 448 { 449 type_register_static(&wacom_info); 450 usb_legacy_register(TYPE_USB_WACOM, "wacom-tablet", NULL); 451 } 452 453 type_init(usb_wacom_register_types)