/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) |