chardev/msmouse.c

   1 /*
   2  * QEMU Microsoft serial mouse emulation
   3  *
   4  * Copyright (c) 2008 Lubomir Rintel
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  */
  24
  25 #include "qemu/osdep.h"
  26 #include "qemu/module.h"
  27 #include "qemu/fifo8.h"
  28 #include "chardev/char.h"
  29 #include "chardev/char-serial.h"
  30 #include "ui/console.h"
  31 #include "ui/input.h"
  32 #include "qom/object.h"
  33
  34 #define MSMOUSE_LO6(n)  ((n) & 0x3f)
  35 #define MSMOUSE_HI2(n)  (((n) & 0xc0) >> 6)
  36 #define MSMOUSE_PWR(cm) (cm & (CHR_TIOCM_RTS | CHR_TIOCM_DTR))
  37
  38 /* Serial PnP for 6 bit devices/mice sends all ASCII chars - 0x20 */
  39 #define M(c) (c - 0x20)
  40 /* Serial fifo size. */
  41 #define MSMOUSE_BUF_SZ 64
  42
  43 /* Mouse ID: Send "M3" cause we behave like a 3 button logitech mouse. */
  44 const uint8_t mouse_id[] = {'M', '3'};
  45 /*
  46  * PnP start "(", PnP version (1.0), vendor ID, product ID, '\\',
  47  * serial ID (omitted), '\\', MS class name, '\\', driver ID (omitted), '\\',
  48  * product description, checksum, ")"
  49  * Missing parts are inserted later.
  50  */
  51 const uint8_t pnp_data[] = {M('('), 1, '$', M('Q'), M('M'), M('U'),
  52                          M('0'), M('0'), M('0'), M('1'),
  53                          M('\\'), M('\\'),
  54                          M('M'), M('O'), M('U'), M('S'), M('E'),
  55                          M('\\'), M('\\')};
  56
  57 struct MouseChardev {
  58     Chardev parent;
  59
  60     QemuInputHandlerState *hs;
  61     int tiocm;
  62     int axis[INPUT_AXIS__MAX];
  63     bool btns[INPUT_BUTTON__MAX];
  64     bool btnc[INPUT_BUTTON__MAX];
  65     Fifo8 outbuf;
  66 };
  67 typedef struct MouseChardev MouseChardev;
  68
  69 #define TYPE_CHARDEV_MSMOUSE "chardev-msmouse"
  70 DECLARE_INSTANCE_CHECKER(MouseChardev, MOUSE_CHARDEV,
  71                          TYPE_CHARDEV_MSMOUSE)
  72
  73 static void msmouse_chr_accept_input(Chardev *chr)
  74 {
  75     MouseChardev *mouse = MOUSE_CHARDEV(chr);
  76     uint32_t len, avail;
  77
  78     len = qemu_chr_be_can_write(chr);
  79     avail = fifo8_num_used(&mouse->outbuf);
  80     while (len > 0 && avail > 0) {
  81         const uint8_t *buf;
  82         uint32_t size;
  83
  84         buf = fifo8_pop_bufptr(&mouse->outbuf, MIN(len, avail), &size);
  85         qemu_chr_be_write(chr, buf, size);
  86         len = qemu_chr_be_can_write(chr);
  87         avail -= size;
  88     }
  89 }
  90
  91 static void msmouse_queue_event(MouseChardev *mouse)
  92 {
  93     unsigned char bytes[4] = { 0x40, 0x00, 0x00, 0x00 };
  94     int dx, dy, count = 3;
  95
  96     dx = mouse->axis[INPUT_AXIS_X];
  97     mouse->axis[INPUT_AXIS_X] = 0;
  98
  99     dy = mouse->axis[INPUT_AXIS_Y];
 100     mouse->axis[INPUT_AXIS_Y] = 0;
 101
 102     /* Movement deltas */
 103     bytes[0] |= (MSMOUSE_HI2(dy) << 2) | MSMOUSE_HI2(dx);
 104     bytes[1] |= MSMOUSE_LO6(dx);
 105     bytes[2] |= MSMOUSE_LO6(dy);
 106
 107     /* Buttons */
 108     bytes[0] |= (mouse->btns[INPUT_BUTTON_LEFT]   ? 0x20 : 0x00);
 109     bytes[0] |= (mouse->btns[INPUT_BUTTON_RIGHT]  ? 0x10 : 0x00);
 110     if (mouse->btns[INPUT_BUTTON_MIDDLE] ||
 111         mouse->btnc[INPUT_BUTTON_MIDDLE]) {
 112         bytes[3] |= (mouse->btns[INPUT_BUTTON_MIDDLE] ? 0x20 : 0x00);
 113         mouse->btnc[INPUT_BUTTON_MIDDLE] = false;
 114         count++;
 115     }
 116
 117     if (fifo8_num_free(&mouse->outbuf) >= count) {
 118         fifo8_push_all(&mouse->outbuf, bytes, count);
 119     } else {
 120         /* queue full -> drop event */
 121     }
 122 }
 123
 124 static void msmouse_input_event(DeviceState *dev, QemuConsole *src,
 125                                 InputEvent *evt)
 126 {
 127     MouseChardev *mouse = MOUSE_CHARDEV(dev);
 128     InputMoveEvent *move;
 129     InputBtnEvent *btn;
 130
 131     /* Ignore events if serial mouse powered down. */
 132     if (!MSMOUSE_PWR(mouse->tiocm)) {
 133         return;
 134     }
 135
 136     switch (evt->type) {
 137     case INPUT_EVENT_KIND_REL:
 138         move = evt->u.rel.data;
 139         mouse->axis[move->axis] += move->value;
 140         break;
 141
 142     case INPUT_EVENT_KIND_BTN:
 143         btn = evt->u.btn.data;
 144         mouse->btns[btn->button] = btn->down;
 145         mouse->btnc[btn->button] = true;
 146         break;
 147
 148     default:
 149         /* keep gcc happy */
 150         break;
 151     }
 152 }
 153
 154 static void msmouse_input_sync(DeviceState *dev)
 155 {
 156     MouseChardev *mouse = MOUSE_CHARDEV(dev);
 157     Chardev *chr = CHARDEV(dev);
 158
 159     /* Ignore events if serial mouse powered down. */
 160     if (!MSMOUSE_PWR(mouse->tiocm)) {
 161         return;
 162     }
 163
 164     msmouse_queue_event(mouse);
 165     msmouse_chr_accept_input(chr);
 166 }
 167
 168 static int msmouse_chr_write(struct Chardev *s, const uint8_t *buf, int len)
 169 {
 170     /* Ignore writes to mouse port */
 171     return len;
 172 }
 173
 174 static const QemuInputHandler msmouse_handler = {
 175     .name  = "QEMU Microsoft Mouse",
 176     .mask  = INPUT_EVENT_MASK_BTN | INPUT_EVENT_MASK_REL,
 177     .event = msmouse_input_event,
 178     .sync  = msmouse_input_sync,
 179 };
 180
 181 static int msmouse_ioctl(Chardev *chr, int cmd, void *arg)
 182 {
 183     MouseChardev *mouse = MOUSE_CHARDEV(chr);
 184     int c, i, j;
 185     uint8_t bytes[MSMOUSE_BUF_SZ / 2];
 186     int *targ = (int *)arg;
 187     const uint8_t hexchr[16] = {M('0'), M('1'), M('2'), M('3'), M('4'), M('5'),
 188                              M('6'), M('7'), M('8'), M('9'), M('A'), M('B'),
 189                              M('C'), M('D'), M('E'), M('F')};
 190
 191     switch (cmd) {
 192     case CHR_IOCTL_SERIAL_SET_TIOCM:
 193         c = mouse->tiocm;
 194         mouse->tiocm = *(int *)arg;
 195         if (MSMOUSE_PWR(mouse->tiocm)) {
 196             if (!MSMOUSE_PWR(c)) {
 197                 /*
 198                  * Power on after reset: Send ID and PnP data
 199                  * No need to check fifo space as it is empty at this point.
 200                  */
 201                 fifo8_push_all(&mouse->outbuf, mouse_id, sizeof(mouse_id));
 202                 /* Add PnP data: */
 203                 fifo8_push_all(&mouse->outbuf, pnp_data, sizeof(pnp_data));
 204                 /*
 205                  * Add device description from qemu handler name.
 206                  * Make sure this all fits into the queue beforehand!
 207                  */
 208                 c = M(')');
 209                 for (i = 0; msmouse_handler.name[i]; i++) {
 210                     bytes[i] = M(msmouse_handler.name[i]);
 211                     c += bytes[i];
 212                 }
 213                 /* Calc more of checksum */
 214                 for (j = 0; j < sizeof(pnp_data); j++) {
 215                     c += pnp_data[j];
 216                 }
 217                 c &= 0xff;
 218                 bytes[i++] = hexchr[c >> 4];
 219                 bytes[i++] = hexchr[c & 0x0f];
 220                 bytes[i++] = M(')');
 221                 fifo8_push_all(&mouse->outbuf, bytes, i);
 222                 /* Start sending data to serial. */
 223                 msmouse_chr_accept_input(chr);
 224             }
 225             break;
 226         }
 227         /*
 228          * Reset mouse buffers on power down.
 229          * Mouse won't send anything without power.
 230          */
 231         fifo8_reset(&mouse->outbuf);
 232         memset(mouse->axis, 0, sizeof(mouse->axis));
 233         memset(mouse->btns, false, sizeof(mouse->btns));
 234         memset(mouse->btnc, false, sizeof(mouse->btns));
 235         break;
 236     case CHR_IOCTL_SERIAL_GET_TIOCM:
 237         /* Remember line control status. */
 238         *targ = mouse->tiocm;
 239         break;
 240     default:
 241         return -ENOTSUP;
 242     }
 243     return 0;
 244 }
 245
 246 static void char_msmouse_finalize(Object *obj)
 247 {
 248     MouseChardev *mouse = MOUSE_CHARDEV(obj);
 249
 250     if (mouse->hs) {
 251         qemu_input_handler_unregister(mouse->hs);
 252     }
 253     fifo8_destroy(&mouse->outbuf);
 254 }
 255
 256 static void msmouse_chr_open(Chardev *chr,
 257                              ChardevBackend *backend,
 258                              bool *be_opened,
 259                              Error **errp)
 260 {
 261     MouseChardev *mouse = MOUSE_CHARDEV(chr);
 262
 263     *be_opened = false;
 264     mouse->hs = qemu_input_handler_register((DeviceState *)mouse,
 265                                             &msmouse_handler);
 266     mouse->tiocm = 0;
 267     fifo8_create(&mouse->outbuf, MSMOUSE_BUF_SZ);
 268 }
 269
 270 static void char_msmouse_class_init(ObjectClass *oc, void *data)
 271 {
 272     ChardevClass *cc = CHARDEV_CLASS(oc);
 273
 274     cc->open = msmouse_chr_open;
 275     cc->chr_write = msmouse_chr_write;
 276     cc->chr_accept_input = msmouse_chr_accept_input;
 277     cc->chr_ioctl = msmouse_ioctl;
 278 }
 279
 280 static const TypeInfo char_msmouse_type_info = {
 281     .name = TYPE_CHARDEV_MSMOUSE,
 282     .parent = TYPE_CHARDEV,
 283     .instance_size = sizeof(MouseChardev),
 284     .instance_finalize = char_msmouse_finalize,
 285     .class_init = char_msmouse_class_init,
 286 };
 287
 288 static void register_types(void)
 289 {
 290     type_register_static(&char_msmouse_type_info);
 291 }
 292
 293 type_init(register_types);