![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to usb-wacom.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / hw|
Return to usb-wacom.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / hw |
1.1 root 1: /*
2: * Wacom PenPartner USB tablet emulation.
3: *
4: * Copyright (c) 2006 Openedhand Ltd.
5: * Author: Andrzej Zaborowski <[email protected]>
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: } USBWacomState;
54:
55: static const uint8_t qemu_wacom_dev_descriptor[] = {
56: 0x12, /* u8 bLength; */
57: 0x01, /* u8 bDescriptorType; Device */
58: 0x10, 0x10, /* u16 bcdUSB; v1.10 */
59:
60: 0x00, /* u8 bDeviceClass; */
61: 0x00, /* u8 bDeviceSubClass; */
62: 0x00, /* u8 bDeviceProtocol; [ low/full speeds only ] */
63: 0x08, /* u8 bMaxPacketSize0; 8 Bytes */
64:
65: 0x6a, 0x05, /* u16 idVendor; */
66: 0x00, 0x00, /* u16 idProduct; */
67: 0x10, 0x42, /* u16 bcdDevice */
68:
69: 0x01, /* u8 iManufacturer; */
70: 0x02, /* u8 iProduct; */
71: 0x00, /* u8 iSerialNumber; */
72: 0x01, /* u8 bNumConfigurations; */
73: };
74:
75: static const uint8_t qemu_wacom_config_descriptor[] = {
76: /* one configuration */
77: 0x09, /* u8 bLength; */
78: 0x02, /* u8 bDescriptorType; Configuration */
79: 0x22, 0x00, /* u16 wTotalLength; */
80: 0x01, /* u8 bNumInterfaces; (1) */
81: 0x01, /* u8 bConfigurationValue; */
82: 0x00, /* u8 iConfiguration; */
83: 0x80, /* u8 bmAttributes;
84: Bit 7: must be set,
85: 6: Self-powered,
86: 5: Remote wakeup,
87: 4..0: resvd */
88: 40, /* u8 MaxPower; */
89:
90: /* one interface */
91: 0x09, /* u8 if_bLength; */
92: 0x04, /* u8 if_bDescriptorType; Interface */
93: 0x00, /* u8 if_bInterfaceNumber; */
94: 0x00, /* u8 if_bAlternateSetting; */
95: 0x01, /* u8 if_bNumEndpoints; */
96: 0x03, /* u8 if_bInterfaceClass; HID */
97: 0x01, /* u8 if_bInterfaceSubClass; Boot */
98: 0x02, /* u8 if_bInterfaceProtocol; [usb1.1 or single tt] */
99: 0x00, /* u8 if_iInterface; */
100:
101: /* HID descriptor */
102: 0x09, /* u8 bLength; */
103: 0x21, /* u8 bDescriptorType; */
104: 0x01, 0x10, /* u16 HID_class */
105: 0x00, /* u8 country_code */
106: 0x01, /* u8 num_descriptors */
107: 0x22, /* u8 type; Report */
108: 0x6e, 0x00, /* u16 len */
109:
110: /* one endpoint (status change endpoint) */
111: 0x07, /* u8 ep_bLength; */
112: 0x05, /* u8 ep_bDescriptorType; Endpoint */
113: 0x81, /* u8 ep_bEndpointAddress; IN Endpoint 1 */
114: 0x03, /* u8 ep_bmAttributes; Interrupt */
115: 0x08, 0x00, /* u16 ep_wMaxPacketSize; */
116: 0x0a, /* u8 ep_bInterval; */
117: };
118:
119: static void usb_mouse_event(void *opaque,
120: int dx1, int dy1, int dz1, int buttons_state)
121: {
122: USBWacomState *s = opaque;
123:
124: s->dx += dx1;
125: s->dy += dy1;
126: s->dz += dz1;
127: s->buttons_state = buttons_state;
128: }
129:
130: static void usb_wacom_event(void *opaque,
131: int x, int y, int dz, int buttons_state)
132: {
133: USBWacomState *s = opaque;
134:
135: s->x = x;
136: s->y = y;
137: s->dz += dz;
138: s->buttons_state = buttons_state;
139: }
140:
141: static inline int int_clamp(int val, int vmin, int vmax)
142: {
143: if (val < vmin)
144: return vmin;
145: else if (val > vmax)
146: return vmax;
147: else
148: return val;
149: }
150:
151: static int usb_mouse_poll(USBWacomState *s, uint8_t *buf, int len)
152: {
153: int dx, dy, dz, b, l;
154:
155: if (!s->mouse_grabbed) {
156: s->eh_entry = qemu_add_mouse_event_handler(usb_mouse_event, s, 0,
157: "QEMU PenPartner tablet");
158: s->mouse_grabbed = 1;
159: }
160:
161: dx = int_clamp(s->dx, -128, 127);
162: dy = int_clamp(s->dy, -128, 127);
163: dz = int_clamp(s->dz, -128, 127);
164:
165: s->dx -= dx;
166: s->dy -= dy;
167: s->dz -= dz;
168:
169: b = 0;
170: if (s->buttons_state & MOUSE_EVENT_LBUTTON)
171: b |= 0x01;
172: if (s->buttons_state & MOUSE_EVENT_RBUTTON)
173: b |= 0x02;
174: if (s->buttons_state & MOUSE_EVENT_MBUTTON)
175: b |= 0x04;
176:
177: buf[0] = b;
178: buf[1] = dx;
179: buf[2] = dy;
180: l = 3;
181: if (len >= 4) {
182: buf[3] = dz;
183: l = 4;
184: }
185: return l;
186: }
187:
188: static int usb_wacom_poll(USBWacomState *s, uint8_t *buf, int len)
189: {
190: int b;
191:
192: if (!s->mouse_grabbed) {
193: s->eh_entry = qemu_add_mouse_event_handler(usb_wacom_event, s, 1,
194: "QEMU PenPartner tablet");
195: s->mouse_grabbed = 1;
196: }
197:
198: b = 0;
199: if (s->buttons_state & MOUSE_EVENT_LBUTTON)
200: b |= 0x01;
201: if (s->buttons_state & MOUSE_EVENT_RBUTTON)
202: b |= 0x02;
203: if (s->buttons_state & MOUSE_EVENT_MBUTTON)
204: b |= 0x04;
205:
206: if (len < 7)
207: return 0;
208:
209: buf[0] = s->mode;
210: buf[5] = 0x00;
211: if (b) {
212: buf[1] = s->x & 0xff;
213: buf[2] = s->x >> 8;
214: buf[3] = s->y & 0xff;
215: buf[4] = s->y >> 8;
216: buf[6] = 0;
217: } else {
218: buf[1] = 0;
219: buf[2] = 0;
220: buf[3] = 0;
221: buf[4] = 0;
222: buf[6] = (unsigned char) -127;
223: }
224:
225: return 7;
226: }
227:
228: static void usb_wacom_handle_reset(USBDevice *dev)
229: {
230: USBWacomState *s = (USBWacomState *) dev;
231:
232: s->dx = 0;
233: s->dy = 0;
234: s->dz = 0;
235: s->x = 0;
236: s->y = 0;
237: s->buttons_state = 0;
238: s->mode = WACOM_MODE_HID;
239: }
240:
241: static int usb_wacom_handle_control(USBDevice *dev, int request, int value,
242: int index, int length, uint8_t *data)
243: {
244: USBWacomState *s = (USBWacomState *) dev;
245: int ret = 0;
246:
247: switch (request) {
248: case DeviceRequest | USB_REQ_GET_STATUS:
249: data[0] = (1 << USB_DEVICE_SELF_POWERED) |
250: (dev->remote_wakeup << USB_DEVICE_REMOTE_WAKEUP);
251: data[1] = 0x00;
252: ret = 2;
253: break;
254: case DeviceOutRequest | USB_REQ_CLEAR_FEATURE:
255: if (value == USB_DEVICE_REMOTE_WAKEUP) {
256: dev->remote_wakeup = 0;
257: } else {
258: goto fail;
259: }
260: ret = 0;
261: break;
262: case DeviceOutRequest | USB_REQ_SET_FEATURE:
263: if (value == USB_DEVICE_REMOTE_WAKEUP) {
264: dev->remote_wakeup = 1;
265: } else {
266: goto fail;
267: }
268: ret = 0;
269: break;
270: case DeviceOutRequest | USB_REQ_SET_ADDRESS:
271: dev->addr = value;
272: ret = 0;
273: break;
274: case DeviceRequest | USB_REQ_GET_DESCRIPTOR:
275: switch (value >> 8) {
276: case USB_DT_DEVICE:
277: memcpy(data, qemu_wacom_dev_descriptor,
278: sizeof(qemu_wacom_dev_descriptor));
279: ret = sizeof(qemu_wacom_dev_descriptor);
280: break;
281: case USB_DT_CONFIG:
282: memcpy(data, qemu_wacom_config_descriptor,
283: sizeof(qemu_wacom_config_descriptor));
284: ret = sizeof(qemu_wacom_config_descriptor);
285: break;
286: case USB_DT_STRING:
287: switch (value & 0xff) {
288: case 0:
289: /* language ids */
290: data[0] = 4;
291: data[1] = 3;
292: data[2] = 0x09;
293: data[3] = 0x04;
294: ret = 4;
295: break;
296: case 1:
297: /* serial number */
298: ret = set_usb_string(data, "1");
299: break;
300: case 2:
301: ret = set_usb_string(data, "Wacom PenPartner");
302: break;
303: case 3:
304: /* vendor description */
305: ret = set_usb_string(data, "QEMU " QEMU_VERSION);
306: break;
307: case 4:
308: ret = set_usb_string(data, "Wacom Tablet");
309: break;
310: case 5:
311: ret = set_usb_string(data, "Endpoint1 Interrupt Pipe");
312: break;
313: default:
314: goto fail;
315: }
316: break;
317: default:
318: goto fail;
319: }
320: break;
321: case DeviceRequest | USB_REQ_GET_CONFIGURATION:
322: data[0] = 1;
323: ret = 1;
324: break;
325: case DeviceOutRequest | USB_REQ_SET_CONFIGURATION:
326: ret = 0;
327: break;
328: case DeviceRequest | USB_REQ_GET_INTERFACE:
329: data[0] = 0;
330: ret = 1;
331: break;
332: case DeviceOutRequest | USB_REQ_SET_INTERFACE:
333: ret = 0;
334: break;
335: case WACOM_SET_REPORT:
336: qemu_remove_mouse_event_handler(s->eh_entry);
337: s->mouse_grabbed = 0;
338: s->mode = data[0];
339: ret = 0;
340: break;
341: case WACOM_GET_REPORT:
342: data[0] = 0;
343: data[1] = s->mode;
344: ret = 2;
345: break;
346: /* USB HID requests */
347: case HID_GET_REPORT:
348: if (s->mode == WACOM_MODE_HID)
349: ret = usb_mouse_poll(s, data, length);
350: else if (s->mode == WACOM_MODE_WACOM)
351: ret = usb_wacom_poll(s, data, length);
352: break;
353: case HID_SET_IDLE:
354: ret = 0;
355: break;
356: default:
357: fail:
358: ret = USB_RET_STALL;
359: break;
360: }
361: return ret;
362: }
363:
364: static int usb_wacom_handle_data(USBDevice *dev, USBPacket *p)
365: {
366: USBWacomState *s = (USBWacomState *) dev;
367: int ret = 0;
368:
369: switch (p->pid) {
370: case USB_TOKEN_IN:
371: if (p->devep == 1) {
372: if (s->mode == WACOM_MODE_HID)
373: ret = usb_mouse_poll(s, p->data, p->len);
374: else if (s->mode == WACOM_MODE_WACOM)
375: ret = usb_wacom_poll(s, p->data, p->len);
376: break;
377: }
378: /* Fall through. */
379: case USB_TOKEN_OUT:
380: default:
381: ret = USB_RET_STALL;
382: break;
383: }
384: return ret;
385: }
386:
387: static void usb_wacom_handle_destroy(USBDevice *dev)
388: {
389: USBWacomState *s = (USBWacomState *) dev;
390:
391: qemu_remove_mouse_event_handler(s->eh_entry);
392: qemu_free(s);
393: }
394:
395: USBDevice *usb_wacom_init(void)
396: {
397: USBWacomState *s;
398:
399: s = qemu_mallocz(sizeof(USBWacomState));
400: if (!s)
401: return NULL;
402: s->dev.speed = USB_SPEED_FULL;
403: s->dev.handle_packet = usb_generic_handle_packet;
404:
405: s->dev.handle_reset = usb_wacom_handle_reset;
406: s->dev.handle_control = usb_wacom_handle_control;
407: s->dev.handle_data = usb_wacom_handle_data;
408: s->dev.handle_destroy = usb_wacom_handle_destroy;
409:
410: pstrcpy(s->dev.devname, sizeof(s->dev.devname),
411: "QEMU PenPartner Tablet");
412:
413: return (USBDevice *) s;
414: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.