Merge remote-tracking branch 'remotes/legoater/tags/pull-ppc-20220118' into staging
[qemu.git] / hw / usb / dev-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
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)