backends/wctablet.c

   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 "sysemu/char.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);