xref: /openbmc/qemu/chardev/wctablet.c (revision 80adf54e) 
1 /*
2  * QEMU Wacom Penpartner serial tablet emulation
3  *
4  * some protocol details:
5  *   http://linuxwacom.sourceforge.net/wiki/index.php/Serial_Protocol_IV
6  *
7  * Copyright (c) 2016 Anatoli Huseu1
8  * Copyright (c) 2016,17 Gerd Hoffmann
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
12  * deal in the Software without restriction, including without limitation
13  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
14  * and/or sell copies of the Software, and to permit persons to whom the
15  * Software is 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 <stdlib.h>
29 #include <string.h>
30 #include <sys/time.h>
31 #include <time.h>
32 
33 #include "qemu/osdep.h"
34 #include "qemu-common.h"
35 #include "chardev/char-serial.h"
36 #include "ui/console.h"
37 #include "ui/input.h"
38 #include "trace.h"
39 
40 
41 #define WC_OUTPUT_BUF_MAX_LEN 512
42 #define WC_COMMAND_MAX_LEN 60
43 
44 #define WC_L7(n) ((n) & 127)
45 #define WC_M7(n) (((n) >> 7) & 127)
46 #define WC_H2(n) ((n) >> 14)
47 
48 #define WC_L4(n) ((n) & 15)
49 #define WC_H4(n) (((n) >> 4) & 15)
50 
51 /* Model string and config string */
52 #define WC_MODEL_STRING_LENGTH 18
53 uint8_t WC_MODEL_STRING[WC_MODEL_STRING_LENGTH + 1] = "~#CT-0045R,V1.3-5,";
54 
55 #define WC_CONFIG_STRING_LENGTH 8
56 uint8_t WC_CONFIG_STRING[WC_CONFIG_STRING_LENGTH + 1] = "96,N,8,0";
57 
58 #define WC_FULL_CONFIG_STRING_LENGTH 61
59 uint8_t WC_FULL_CONFIG_STRING[WC_FULL_CONFIG_STRING_LENGTH + 1] = {
60     0x5c, 0x39, 0x36, 0x2c, 0x4e, 0x2c, 0x38, 0x2c,
61     0x31, 0x28, 0x01, 0x24, 0x57, 0x41, 0x43, 0x30,
62     0x30, 0x34, 0x35, 0x5c, 0x5c, 0x50, 0x45, 0x4e, 0x5c,
63     0x57, 0x41, 0x43, 0x30, 0x30, 0x30, 0x30, 0x5c,
64     0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x0d, 0x0a,
65     0x43, 0x54, 0x2d, 0x30, 0x30, 0x34, 0x35, 0x52,
66     0x2c, 0x56, 0x31, 0x2e, 0x33, 0x2d, 0x35, 0x0d,
67     0x0a, 0x45, 0x37, 0x29
68 };
69 
70 /* This structure is used to save private info for Wacom Tablet. */
71 typedef struct {
72     Chardev parent;
73     QemuInputHandlerState *hs;
74 
75     /* Query string from serial */
76     uint8_t query[100];
77     int query_index;
78 
79     /* Command to be sent to serial port */
80     uint8_t outbuf[WC_OUTPUT_BUF_MAX_LEN];
81     int outlen;
82 
83     int line_speed;
84     bool send_events;
85     int axis[INPUT_AXIS__MAX];
86     bool btns[INPUT_BUTTON__MAX];
87 
88 } TabletChardev;
89 
90 #define TYPE_CHARDEV_WCTABLET "chardev-wctablet"
91 #define WCTABLET_CHARDEV(obj)                                      \
92     OBJECT_CHECK(TabletChardev, (obj), TYPE_CHARDEV_WCTABLET)
93 
94 
95 static void wctablet_chr_accept_input(Chardev *chr);
96 
97 static void wctablet_shift_input(TabletChardev *tablet, int count)
98 {
99     tablet->query_index -= count;
100     memmove(tablet->query, tablet->query + count, tablet->query_index);
101     tablet->query[tablet->query_index] = 0;
102 }
103 
104 static void wctablet_queue_output(TabletChardev *tablet, uint8_t *buf, int count)
105 {
106     if (tablet->outlen + count > sizeof(tablet->outbuf)) {
107         return;
108     }
109 
110     memcpy(tablet->outbuf + tablet->outlen, buf, count);
111     tablet->outlen += count;
112     wctablet_chr_accept_input(CHARDEV(tablet));
113 }
114 
115 static void wctablet_reset(TabletChardev *tablet)
116 {
117     /* clear buffers */
118     tablet->query_index = 0;
119     tablet->outlen = 0;
120     /* reset state */
121     tablet->send_events = false;
122 }
123 
124 static void wctablet_queue_event(TabletChardev *tablet)
125 {
126     uint8_t codes[8] = { 0xe0, 0, 0, 0, 0, 0, 0 };
127 
128     if (tablet->line_speed != 9600) {
129         return;
130     }
131 
132     int newX = tablet->axis[INPUT_AXIS_X] * 0.1537;
133     int nexY = tablet->axis[INPUT_AXIS_Y] * 0.1152;
134 
135     codes[0] = codes[0] | WC_H2(newX);
136     codes[1] = codes[1] | WC_M7(newX);
137     codes[2] = codes[2] | WC_L7(newX);
138 
139     codes[3] = codes[3] | WC_H2(nexY);
140     codes[4] = codes[4] | WC_M7(nexY);
141     codes[5] = codes[5] | WC_L7(nexY);
142 
143     if (tablet->btns[INPUT_BUTTON_LEFT]) {
144         codes[0] = 0xa0;
145     }
146 
147     wctablet_queue_output(tablet, codes, 7);
148 }
149 
150 static void wctablet_input_event(DeviceState *dev, QemuConsole *src,
151                                 InputEvent *evt)
152 {
153     TabletChardev *tablet = (TabletChardev *)dev;
154     InputMoveEvent *move;
155     InputBtnEvent *btn;
156 
157     switch (evt->type) {
158     case INPUT_EVENT_KIND_ABS:
159         move = evt->u.abs.data;
160         tablet->axis[move->axis] = move->value;
161         break;
162 
163     case INPUT_EVENT_KIND_BTN:
164         btn = evt->u.btn.data;
165         tablet->btns[btn->button] = btn->down;
166         break;
167 
168     default:
169         /* keep gcc happy */
170         break;
171     }
172 }
173 
174 static void wctablet_input_sync(DeviceState *dev)
175 {
176     TabletChardev *tablet = (TabletChardev *)dev;
177 
178     if (tablet->send_events) {
179         wctablet_queue_event(tablet);
180     }
181 }
182 
183 static QemuInputHandler wctablet_handler = {
184     .name  = "QEMU Wacome Pen Tablet",
185     .mask  = INPUT_EVENT_MASK_BTN | INPUT_EVENT_MASK_ABS,
186     .event = wctablet_input_event,
187     .sync  = wctablet_input_sync,
188 };
189 
190 static void wctablet_chr_accept_input(Chardev *chr)
191 {
192     TabletChardev *tablet = WCTABLET_CHARDEV(chr);
193     int len, canWrite;
194 
195     canWrite = qemu_chr_be_can_write(chr);
196     len = canWrite;
197     if (len > tablet->outlen) {
198         len = tablet->outlen;
199     }
200 
201     if (len) {
202         qemu_chr_be_write(chr, tablet->outbuf, len);
203         tablet->outlen -= len;
204         if (tablet->outlen) {
205             memmove(tablet->outbuf, tablet->outbuf + len, tablet->outlen);
206         }
207     }
208 }
209 
210 static int wctablet_chr_write(struct Chardev *chr,
211                               const uint8_t *buf, int len)
212 {
213     TabletChardev *tablet = WCTABLET_CHARDEV(chr);
214     unsigned int i, clen;
215     char *pos;
216 
217     if (tablet->line_speed != 9600) {
218         return len;
219     }
220     for (i = 0; i < len && tablet->query_index < sizeof(tablet->query) - 1; i++) {
221         tablet->query[tablet->query_index++] = buf[i];
222     }
223     tablet->query[tablet->query_index] = 0;
224 
225     while (tablet->query_index > 0 && (tablet->query[0] == '@'  ||
226                                        tablet->query[0] == '\r' ||
227                                        tablet->query[0] == '\n')) {
228         wctablet_shift_input(tablet, 1);
229     }
230     if (!tablet->query_index) {
231         return len;
232     }
233 
234     if (strncmp((char *)tablet->query, "~#", 2) == 0) {
235         /* init / detect sequence */
236         trace_wct_init();
237         wctablet_shift_input(tablet, 2);
238         wctablet_queue_output(tablet, WC_MODEL_STRING,
239                               WC_MODEL_STRING_LENGTH);
240         return len;
241     }
242 
243     /* detect line */
244     pos = strchr((char *)tablet->query, '\r');
245     if (!pos) {
246         pos = strchr((char *)tablet->query, '\n');
247     }
248     if (!pos) {
249         return len;
250     }
251     clen = pos - (char *)tablet->query;
252 
253     /* process commands */
254     if (strncmp((char *)tablet->query, "RE", 2) == 0 &&
255         clen == 2) {
256         trace_wct_cmd_re();
257         wctablet_shift_input(tablet, 3);
258         wctablet_queue_output(tablet, WC_CONFIG_STRING,
259                               WC_CONFIG_STRING_LENGTH);
260 
261     } else if (strncmp((char *)tablet->query, "ST", 2) == 0 &&
262                clen == 2) {
263         trace_wct_cmd_st();
264         wctablet_shift_input(tablet, 3);
265         tablet->send_events = true;
266         wctablet_queue_event(tablet);
267 
268     } else if (strncmp((char *)tablet->query, "SP", 2) == 0 &&
269                clen == 2) {
270         trace_wct_cmd_sp();
271         wctablet_shift_input(tablet, 3);
272         tablet->send_events = false;
273 
274     } else if (strncmp((char *)tablet->query, "TS", 2) == 0 &&
275                clen == 3) {
276         unsigned int input = tablet->query[2];
277         uint8_t codes[7] = {
278             0xa3,
279             ((input & 0x80) == 0) ? 0x7e : 0x7f,
280             (((WC_H4(input) & 0x7) ^ 0x5) << 4) | (WC_L4(input) ^ 0x7),
281             0x03,
282             0x7f,
283             0x7f,
284             0x00,
285         };
286         trace_wct_cmd_ts(input);
287         wctablet_shift_input(tablet, 4);
288         wctablet_queue_output(tablet, codes, 7);
289 
290     } else {
291         tablet->query[clen] = 0; /* terminate line for printing */
292         trace_wct_cmd_other((char *)tablet->query);
293         wctablet_shift_input(tablet, clen + 1);
294 
295     }
296 
297     return len;
298 }
299 
300 static int wctablet_chr_ioctl(Chardev *chr, int cmd, void *arg)
301 {
302     TabletChardev *tablet = WCTABLET_CHARDEV(chr);
303     QEMUSerialSetParams *ssp;
304 
305     switch (cmd) {
306     case CHR_IOCTL_SERIAL_SET_PARAMS:
307         ssp = arg;
308         if (tablet->line_speed != ssp->speed) {
309             trace_wct_speed(ssp->speed);
310             wctablet_reset(tablet);
311             tablet->line_speed = ssp->speed;
312         }
313         break;
314     default:
315         return -ENOTSUP;
316     }
317     return 0;
318 }
319 
320 static void wctablet_chr_finalize(Object *obj)
321 {
322     TabletChardev *tablet = WCTABLET_CHARDEV(obj);
323 
324     qemu_input_handler_unregister(tablet->hs);
325     g_free(tablet);
326 }
327 
328 static void wctablet_chr_open(Chardev *chr,
329                               ChardevBackend *backend,
330                               bool *be_opened,
331                               Error **errp)
332 {
333     TabletChardev *tablet = WCTABLET_CHARDEV(chr);
334 
335     *be_opened = true;
336 
337     /* init state machine */
338     memcpy(tablet->outbuf, WC_FULL_CONFIG_STRING, WC_FULL_CONFIG_STRING_LENGTH);
339     tablet->outlen = WC_FULL_CONFIG_STRING_LENGTH;
340     tablet->query_index = 0;
341 
342     tablet->hs = qemu_input_handler_register((DeviceState *)tablet,
343                                              &wctablet_handler);
344 }
345 
346 static void wctablet_chr_class_init(ObjectClass *oc, void *data)
347 {
348     ChardevClass *cc = CHARDEV_CLASS(oc);
349 
350     cc->open = wctablet_chr_open;
351     cc->chr_write = wctablet_chr_write;
352     cc->chr_ioctl = wctablet_chr_ioctl;
353     cc->chr_accept_input = wctablet_chr_accept_input;
354 }
355 
356 static const TypeInfo wctablet_type_info = {
357     .name = TYPE_CHARDEV_WCTABLET,
358     .parent = TYPE_CHARDEV,
359     .instance_size = sizeof(TabletChardev),
360     .instance_finalize = wctablet_chr_finalize,
361     .class_init = wctablet_chr_class_init,
362 };
363 
364 static void register_types(void)
365 {
366      type_register_static(&wctablet_type_info);
367 }
368 
369 type_init(register_types);
370