Coverage Report

Created: 2026-10-31 08:12

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/src/qemu/hw/i386/vmmouse.c
Line
Count
Source
1
/*
2
 * QEMU VMMouse emulation
3
 *
4
 * Copyright (C) 2007 Anthony Liguori <anthony@codemonkey.ws>
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 "qapi/error.h"
27
#include "ui/console.h"
28
#include "hw/i386/vmport.h"
29
#include "hw/input/i8042.h"
30
#include "hw/core/qdev-properties.h"
31
#include "migration/vmstate.h"
32
#include "target/i386/cpu.h"
33
#include "qom/object.h"
34
35
#include "trace.h"
36
37
/* debug only vmmouse */
38
//#define DEBUG_VMMOUSE
39
40
0
#define VMMOUSE_READ_ID     0x45414552
41
0
#define VMMOUSE_DISABLE     0x000000f5
42
0
#define VMMOUSE_REQUEST_RELATIVE  0x4c455252
43
0
#define VMMOUSE_REQUEST_ABSOLUTE  0x53424152
44
45
92.8k
#define VMMOUSE_QUEUE_SIZE  1024
46
47
0
#define VMMOUSE_VERSION   0x3442554a
48
49
0
#define VMMOUSE_RELATIVE_PACKET    0x00010000
50
51
0
#define VMMOUSE_LEFT_BUTTON        0x20
52
0
#define VMMOUSE_RIGHT_BUTTON       0x10
53
0
#define VMMOUSE_MIDDLE_BUTTON      0x08
54
55
0
#define VMMOUSE_MIN_X 0
56
0
#define VMMOUSE_MIN_Y 0
57
0
#define VMMOUSE_MAX_X 0xFFFF
58
0
#define VMMOUSE_MAX_Y 0xFFFF
59
60
#define TYPE_VMMOUSE "vmmouse"
61
OBJECT_DECLARE_SIMPLE_TYPE(VMMouseState, VMMOUSE)
62
63
struct VMMouseState {
64
    ISADevice parent_obj;
65
66
    uint32_t queue[VMMOUSE_QUEUE_SIZE];
67
    int32_t queue_size;
68
    uint16_t nb_queue;
69
    uint16_t status;
70
    uint8_t absolute;
71
    QemuInputHandlerState *hs;
72
    int axis[INPUT_AXIS__MAX];
73
    int dz;
74
    bool btns[INPUT_BUTTON__MAX];
75
    ISAKBDState *i8042;
76
};
77
78
static void vmmouse_get_data(uint64_t *data)
79
0
{
80
0
    X86CPU *cpu = X86_CPU(current_cpu);
81
0
    CPUX86State *env = &cpu->env;
82
83
0
    data[0] = env->regs[R_EAX]; data[1] = env->regs[R_EBX];
84
0
    data[2] = env->regs[R_ECX]; data[3] = env->regs[R_EDX];
85
0
    data[4] = env->regs[R_ESI]; data[5] = env->regs[R_EDI];
86
0
}
87
88
static void vmmouse_set_data(const uint64_t *data)
89
0
{
90
0
    X86CPU *cpu = X86_CPU(current_cpu);
91
0
    CPUX86State *env = &cpu->env;
92
93
0
    env->regs[R_EAX] = data[0]; env->regs[R_EBX] = data[1];
94
0
    env->regs[R_ECX] = data[2]; env->regs[R_EDX] = data[3];
95
0
    env->regs[R_ESI] = data[4]; env->regs[R_EDI] = data[5];
96
0
}
97
98
static uint32_t vmmouse_get_status(VMMouseState *s)
99
0
{
100
0
    trace_vmmouse_get_status();
101
102
0
    return (s->status << 16) | s->nb_queue;
103
0
}
104
105
static void vmmouse_input_event(DeviceState *dev, QemuConsole *src,
106
                                QemuInputEvent *evt)
107
0
{
108
0
    VMMouseState *s = VMMOUSE(dev);
109
110
0
    switch (evt->type) {
111
0
    case INPUT_EVENT_KIND_BTN:
112
0
        if (evt->btn.down) {
113
0
            if (evt->btn.button == INPUT_BUTTON_WHEEL_UP) {
114
0
                s->dz--;
115
0
            } else if (evt->btn.button == INPUT_BUTTON_WHEEL_DOWN) {
116
0
                s->dz++;
117
0
            }
118
0
        }
119
0
        s->btns[evt->btn.button] = evt->btn.down;
120
0
        break;
121
0
    case INPUT_EVENT_KIND_ABS:
122
0
        if (evt->abs.axis == INPUT_AXIS_X) {
123
0
            s->axis[INPUT_AXIS_X] =
124
0
                qemu_input_scale_axis(evt->abs.value,
125
0
                                      INPUT_EVENT_ABS_MIN, INPUT_EVENT_ABS_MAX,
126
0
                                      VMMOUSE_MIN_X, VMMOUSE_MAX_X);
127
0
        } else if (evt->abs.axis == INPUT_AXIS_Y) {
128
0
            s->axis[INPUT_AXIS_Y] =
129
0
                qemu_input_scale_axis(evt->abs.value,
130
0
                                      INPUT_EVENT_ABS_MIN, INPUT_EVENT_ABS_MAX,
131
0
                                      VMMOUSE_MIN_Y, VMMOUSE_MAX_Y);
132
0
        }
133
0
        break;
134
0
    case INPUT_EVENT_KIND_REL:
135
0
        s->axis[evt->rel.axis] += evt->rel.value;
136
0
        break;
137
0
    default:
138
0
        break;
139
0
    }
140
0
}
141
142
static void vmmouse_input_sync(DeviceState *dev)
143
0
{
144
0
    VMMouseState *s = VMMOUSE(dev);
145
0
    int buttons = 0;
146
147
0
    if (s->nb_queue > (VMMOUSE_QUEUE_SIZE - 4)) {
148
0
        return;
149
0
    }
150
151
0
    if (s->btns[INPUT_BUTTON_LEFT]) {
152
0
        buttons |= VMMOUSE_LEFT_BUTTON;
153
0
    }
154
0
    if (s->btns[INPUT_BUTTON_RIGHT]) {
155
0
        buttons |= VMMOUSE_RIGHT_BUTTON;
156
0
    }
157
0
    if (s->btns[INPUT_BUTTON_MIDDLE]) {
158
0
        buttons |= VMMOUSE_MIDDLE_BUTTON;
159
0
    }
160
0
    if (!s->absolute) {
161
0
        buttons |= VMMOUSE_RELATIVE_PACKET;
162
0
    }
163
164
0
    trace_vmmouse_queue_event(s->axis[INPUT_AXIS_X], s->axis[INPUT_AXIS_Y],
165
0
                              s->dz, buttons);
166
167
0
    s->queue[s->nb_queue++] = buttons;
168
0
    s->queue[s->nb_queue++] = s->axis[INPUT_AXIS_X];
169
0
    s->queue[s->nb_queue++] = s->axis[INPUT_AXIS_Y];
170
0
    s->queue[s->nb_queue++] = s->dz;
171
0
    s->dz = 0;
172
173
0
    if (!s->absolute) {
174
0
        s->axis[INPUT_AXIS_X] = 0;
175
0
        s->axis[INPUT_AXIS_Y] = 0;
176
0
    }
177
178
    /* need to still generate PS2 events to notify driver to
179
       read from queue */
180
0
    i8042_isa_mouse_fake_event(s->i8042);
181
0
}
182
183
static void vmmouse_remove_handler(VMMouseState *s)
184
92.8k
{
185
92.8k
    g_clear_pointer(&s->hs, qemu_input_handler_unregister);
186
92.8k
}
187
188
static void vmmouse_update_handler(VMMouseState *s, int absolute)
189
0
{
190
0
    static const QemuInputHandler vmmouse_abs_handler = {
191
0
        .name  = "vmmouse",
192
0
        .mask  = INPUT_EVENT_MASK_BTN | INPUT_EVENT_MASK_ABS,
193
0
        .event = vmmouse_input_event,
194
0
        .sync  = vmmouse_input_sync,
195
0
    };
196
197
0
    static const QemuInputHandler vmmouse_rel_handler = {
198
0
        .name  = "vmmouse",
199
0
        .mask  = INPUT_EVENT_MASK_BTN | INPUT_EVENT_MASK_REL,
200
0
        .event = vmmouse_input_event,
201
0
        .sync  = vmmouse_input_sync,
202
0
    };
203
204
0
    if (s->status != 0) {
205
0
        return;
206
0
    }
207
0
    if (s->absolute != absolute) {
208
0
        s->absolute = absolute;
209
0
        vmmouse_remove_handler(s);
210
0
    }
211
0
    if (s->hs == NULL) {
212
0
        const QemuInputHandler *h = s->absolute ?
213
0
            &vmmouse_abs_handler : &vmmouse_rel_handler;
214
0
        s->hs = qemu_input_handler_register(DEVICE(s), h);
215
0
        qemu_input_handler_activate(s->hs);
216
0
    }
217
0
}
218
219
static void vmmouse_read_id(VMMouseState *s)
220
0
{
221
0
    trace_vmmouse_read_id();
222
223
0
    if (s->nb_queue == VMMOUSE_QUEUE_SIZE)
224
0
        return;
225
226
0
    s->queue[s->nb_queue++] = VMMOUSE_VERSION;
227
0
    s->status = 0;
228
0
    vmmouse_update_handler(s, s->absolute);
229
0
}
230
231
static void vmmouse_request_relative(VMMouseState *s)
232
0
{
233
0
    trace_vmmouse_request_relative();
234
235
0
    vmmouse_update_handler(s, 0);
236
0
}
237
238
static void vmmouse_request_absolute(VMMouseState *s)
239
0
{
240
0
    trace_vmmouse_request_absolute();
241
242
0
    vmmouse_update_handler(s, 1);
243
0
}
244
245
static void vmmouse_disable(VMMouseState *s)
246
92.8k
{
247
92.8k
    trace_vmmouse_disable();
248
249
92.8k
    s->status = 0xffff;
250
92.8k
    vmmouse_remove_handler(s);
251
92.8k
}
252
253
static void vmmouse_data(VMMouseState *s, uint64_t *data, uint32_t size)
254
0
{
255
0
    int i;
256
257
0
    trace_vmmouse_data(size);
258
259
0
    if (size == 0 || size > 6 || size > s->nb_queue) {
260
0
        printf("vmmouse: driver requested too much data %d\n", size);
261
0
        s->status = 0xffff;
262
0
        vmmouse_remove_handler(s);
263
0
        return;
264
0
    }
265
266
0
    for (i = 0; i < size; i++)
267
0
        data[i] = s->queue[i];
268
269
0
    s->nb_queue -= size;
270
0
    if (s->nb_queue)
271
0
        memmove(s->queue, &s->queue[size], sizeof(s->queue[0]) * s->nb_queue);
272
0
}
273
274
static uint32_t vmmouse_ioport_read(void *opaque, uint32_t addr)
275
0
{
276
0
    VMMouseState *s = opaque;
277
0
    uint64_t data[6];
278
0
    uint16_t command;
279
280
0
    vmmouse_get_data(data);
281
282
0
    command = data[2] & 0xFFFF;
283
284
0
    switch (command) {
285
0
    case VMPORT_CMD_VMMOUSE_STATUS:
286
0
        data[0] = vmmouse_get_status(s);
287
0
        break;
288
0
    case VMPORT_CMD_VMMOUSE_COMMAND:
289
0
        switch (data[1]) {
290
0
        case VMMOUSE_DISABLE:
291
0
            vmmouse_disable(s);
292
0
            break;
293
0
        case VMMOUSE_READ_ID:
294
0
            vmmouse_read_id(s);
295
0
            break;
296
0
        case VMMOUSE_REQUEST_RELATIVE:
297
0
            vmmouse_request_relative(s);
298
0
            break;
299
0
        case VMMOUSE_REQUEST_ABSOLUTE:
300
0
            vmmouse_request_absolute(s);
301
0
            break;
302
0
        default:
303
0
            printf("vmmouse: unknown command %" PRIx64 "\n", data[1]);
304
0
            break;
305
0
        }
306
0
        break;
307
0
    case VMPORT_CMD_VMMOUSE_DATA:
308
0
        vmmouse_data(s, data, data[1]);
309
0
        break;
310
0
    default:
311
0
        printf("vmmouse: unknown command %x\n", command);
312
0
        break;
313
0
    }
314
315
0
    vmmouse_set_data(data);
316
0
    return data[0];
317
0
}
318
319
static int vmmouse_post_load(void *opaque, int version_id)
320
0
{
321
0
    VMMouseState *s = opaque;
322
323
0
    vmmouse_remove_handler(s);
324
0
    vmmouse_update_handler(s, s->absolute);
325
0
    return 0;
326
0
}
327
328
static const VMStateDescription vmstate_vmmouse = {
329
    .name = "vmmouse",
330
    .version_id = 0,
331
    .minimum_version_id = 0,
332
    .post_load = vmmouse_post_load,
333
    .fields = (const VMStateField[]) {
334
        VMSTATE_INT32_EQUAL(queue_size, VMMouseState),
335
        VMSTATE_UINT32_ARRAY(queue, VMMouseState, VMMOUSE_QUEUE_SIZE),
336
        VMSTATE_UINT16(nb_queue, VMMouseState),
337
        VMSTATE_UINT16(status, VMMouseState),
338
        VMSTATE_UINT8(absolute, VMMouseState),
339
        VMSTATE_END_OF_LIST()
340
    }
341
};
342
343
static void vmmouse_reset(DeviceState *d)
344
92.8k
{
345
92.8k
    VMMouseState *s = VMMOUSE(d);
346
347
92.8k
    s->queue_size = VMMOUSE_QUEUE_SIZE;
348
92.8k
    s->nb_queue = 0;
349
350
92.8k
    vmmouse_disable(s);
351
92.8k
}
352
353
static void vmmouse_realizefn(DeviceState *dev, Error **errp)
354
61
{
355
61
    VMMouseState *s = VMMOUSE(dev);
356
357
61
    trace_vmmouse_init();
358
359
61
    if (!s->i8042) {
360
0
        error_setg(errp, "'i8042' link is not set");
361
0
        return;
362
0
    }
363
61
    if (!object_resolve_path_type("", TYPE_VMPORT, NULL)) {
364
0
        error_setg(errp, "vmmouse needs a machine with vmport");
365
0
        return;
366
0
    }
367
368
61
    vmport_register(VMPORT_CMD_VMMOUSE_STATUS, vmmouse_ioport_read, s);
369
61
    vmport_register(VMPORT_CMD_VMMOUSE_COMMAND, vmmouse_ioport_read, s);
370
61
    vmport_register(VMPORT_CMD_VMMOUSE_DATA, vmmouse_ioport_read, s);
371
61
}
372
373
static const Property vmmouse_properties[] = {
374
    DEFINE_PROP_LINK("i8042", VMMouseState, i8042, TYPE_I8042, ISAKBDState *),
375
};
376
377
static void vmmouse_class_initfn(ObjectClass *klass, const void *data)
378
61
{
379
61
    DeviceClass *dc = DEVICE_CLASS(klass);
380
381
61
    dc->realize = vmmouse_realizefn;
382
61
    device_class_set_legacy_reset(dc, vmmouse_reset);
383
61
    dc->vmsd = &vmstate_vmmouse;
384
61
    device_class_set_props(dc, vmmouse_properties);
385
61
    set_bit(DEVICE_CATEGORY_INPUT, dc->categories);
386
61
}
387
388
static const TypeInfo vmmouse_info = {
389
    .name          = TYPE_VMMOUSE,
390
    .parent        = TYPE_ISA_DEVICE,
391
    .instance_size = sizeof(VMMouseState),
392
    .class_init    = vmmouse_class_initfn,
393
};
394
395
static void vmmouse_register_types(void)
396
61
{
397
61
    type_register_static(&vmmouse_info);
398
61
}
399
400
type_init(vmmouse_register_types)