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