qemu

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);
294