← Back to branch summary

~vcs-imports/qemu/git

« back to all changes in this revision

Viewing changes to hw/vmmouse.c

  • Committer: ths
  • Date: 2007-06-17 15:32:30 UTC
  • Revision ID: git-v1:ffb04fcf089865952592f1f8855c2848d4514a89
Allow relative paths for the interpreter prefix in linux-user emulation.


git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@2984 c046a42c-6fe2-441c-8c8c-71466251a162

Show diffs side-by-side

added added

removed removed

Lines of Context:
hw/vmmouse.c
1
1
/*
2
2
 * QEMU VMMouse emulation
3
 
 *
 
3
 * 
4
4
 * Copyright (C) 2007 Anthony Liguori <anthony@codemonkey.ws>
5
 
 *
 
5
 * 
6
6
 * Permission is hereby granted, free of charge, to any person obtaining a copy
7
7
 * of this software and associated documentation files (the "Software"), to deal
8
8
 * in the Software without restriction, including without limitation the rights
21
21
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22
22
 * THE SOFTWARE.
23
23
 */
24
 
#include "hw.h"
25
 
#include "console.h"
26
 
#include "ps2.h"
27
 
#include "pc.h"
 
24
#include "vl.h"
28
25
 
29
26
/* debug only vmmouse */
30
27
//#define DEBUG_VMMOUSE
42
39
 
43
40
#define VMMOUSE_QUEUE_SIZE      1024
44
41
 
 
42
#define VMMOUSE_MAGIC           0x564D5868
45
43
#define VMMOUSE_VERSION         0x3442554a
46
44
 
47
45
#ifdef DEBUG_VMMOUSE
60
58
    void *ps2_mouse;
61
59
} VMMouseState;
62
60
 
 
61
static uint32_t vmmouse_get_version(VMMouseState *s, uint32_t *magic)
 
62
{
 
63
    DPRINTF("vmmouse_get_version(%x)\n", *magic);
 
64
    *magic = VMMOUSE_MAGIC;
 
65
    return VMMOUSE_VERSION;
 
66
}
 
67
 
63
68
static uint32_t vmmouse_get_status(VMMouseState *s)
64
69
{
65
70
    DPRINTF("vmmouse_get_status()\n");
72
77
    int buttons = 0;
73
78
 
74
79
    if (s->nb_queue > (VMMOUSE_QUEUE_SIZE - 4))
75
 
        return;
 
80
        return;
76
81
 
77
82
    DPRINTF("vmmouse_mouse_event(%d, %d, %d, %d)\n",
78
 
            x, y, dz, buttons_state);
 
83
            x, y, dz, buttons_state);
79
84
 
80
85
    if ((buttons_state & MOUSE_EVENT_LBUTTON))
81
 
        buttons |= 0x20;
 
86
        buttons |= 0x20;
82
87
    if ((buttons_state & MOUSE_EVENT_RBUTTON))
83
 
        buttons |= 0x10;
 
88
        buttons |= 0x10;
84
89
    if ((buttons_state & MOUSE_EVENT_MBUTTON))
85
 
        buttons |= 0x08;
 
90
        buttons |= 0x08;
86
91
 
87
92
    if (s->absolute) {
88
 
        x <<= 1;
89
 
        y <<= 1;
 
93
        x <<= 1;
 
94
        y <<= 1;
90
95
    }
91
96
 
92
97
    s->queue[s->nb_queue++] = buttons;
102
107
static void vmmouse_update_handler(VMMouseState *s)
103
108
{
104
109
    if (s->entry) {
105
 
        qemu_remove_mouse_event_handler(s->entry);
106
 
        s->entry = NULL;
 
110
        qemu_remove_mouse_event_handler(s->entry);
 
111
        s->entry = NULL;
107
112
    }
108
113
    if (s->status == 0)
109
 
        s->entry = qemu_add_mouse_event_handler(vmmouse_mouse_event,
110
 
                                                s, s->absolute,
111
 
                                                "vmmouse");
 
114
        s->entry = qemu_add_mouse_event_handler(vmmouse_mouse_event,
 
115
                                                s, s->absolute,
 
116
                                                "vmmouse");
112
117
}
113
118
 
114
119
static void vmmouse_read_id(VMMouseState *s)
116
121
    DPRINTF("vmmouse_read_id()\n");
117
122
 
118
123
    if (s->nb_queue == VMMOUSE_QUEUE_SIZE)
119
 
        return;
 
124
        return;
120
125
 
121
126
    s->queue[s->nb_queue++] = VMMOUSE_VERSION;
122
127
    s->status = 0;
151
156
    DPRINTF("vmmouse_data(%d)\n", size);
152
157
 
153
158
    if (size == 0 || size > 6 || size > s->nb_queue) {
154
 
        printf("vmmouse: driver requested too much data %d\n", size);
155
 
        s->status = 0xffff;
156
 
        vmmouse_update_handler(s);
157
 
        return;
 
159
        printf("vmmouse: driver requested too much data %d\n", size);
 
160
        s->status = 0xffff;
 
161
        vmmouse_update_handler(s);
 
162
        return;
158
163
    }
159
164
 
160
165
    for (i = 0; i < size; i++)
161
 
        data[i] = s->queue[i];
 
166
        data[i] = s->queue[i];
162
167
 
163
168
    s->nb_queue -= size;
164
169
    if (s->nb_queue)
165
 
        memmove(s->queue, &s->queue[size], sizeof(s->queue[0]) * s->nb_queue);
 
170
        memmove(s->queue, &s->queue[size], sizeof(s->queue[0]) * s->nb_queue);
166
171
}
167
172
 
168
173
static void vmmouse_get_data(uint32_t *data)
174
179
    data[4] = env->regs[R_ESI]; data[5] = env->regs[R_EDI];
175
180
 
176
181
    DPRINTF("get_data = {%x, %x, %x, %x, %x, %x}\n",
177
 
            data[0], data[1], data[2], data[3], data[4], data[5]);
 
182
            data[0], data[1], data[2], data[3], data[4], data[5]);
178
183
}
179
184
 
180
185
static void vmmouse_set_data(const uint32_t *data)
182
187
    CPUState *env = cpu_single_env;
183
188
 
184
189
    DPRINTF("set_data = {%x, %x, %x, %x, %x, %x}\n",
185
 
            data[0], data[1], data[2], data[3], data[4], data[5]);
 
190
            data[0], data[1], data[2], data[3], data[4], data[5]);
186
191
 
187
192
    env->regs[R_EAX] = data[0]; env->regs[R_EBX] = data[1];
188
193
    env->regs[R_ECX] = data[2]; env->regs[R_EDX] = data[3];
196
201
    uint16_t command;
197
202
 
198
203
    vmmouse_get_data(data);
 
204
    if (data[0] != VMMOUSE_MAGIC)
 
205
        goto error;
199
206
 
200
207
    command = data[2] & 0xFFFF;
201
208
 
202
209
    switch (command) {
 
210
    case VMMOUSE_GETVERSION:
 
211
        data[0] = vmmouse_get_version(s, &data[1]);
 
212
        break;
203
213
    case VMMOUSE_STATUS:
204
 
        data[0] = vmmouse_get_status(s);
205
 
        break;
 
214
        data[0] = vmmouse_get_status(s);
 
215
        break;
206
216
    case VMMOUSE_COMMAND:
207
 
        switch (data[1]) {
208
 
        case VMMOUSE_DISABLE:
209
 
            vmmouse_disable(s);
210
 
            break;
211
 
        case VMMOUSE_READ_ID:
212
 
            vmmouse_read_id(s);
213
 
            break;
214
 
        case VMMOUSE_REQUEST_RELATIVE:
215
 
            vmmouse_request_relative(s);
216
 
            break;
217
 
        case VMMOUSE_REQUEST_ABSOLUTE:
218
 
            vmmouse_request_absolute(s);
219
 
            break;
220
 
        default:
221
 
            printf("vmmouse: unknown command %x\n", data[1]);
222
 
            break;
223
 
        }
224
 
        break;
 
217
        switch (data[1]) {
 
218
        case VMMOUSE_DISABLE:
 
219
            vmmouse_disable(s);
 
220
            break;
 
221
        case VMMOUSE_READ_ID:
 
222
            vmmouse_read_id(s);
 
223
            break;
 
224
        case VMMOUSE_REQUEST_RELATIVE:
 
225
            vmmouse_request_relative(s);
 
226
            break;
 
227
        case VMMOUSE_REQUEST_ABSOLUTE:
 
228
            vmmouse_request_absolute(s);
 
229
            break;
 
230
        default:
 
231
            printf("vmmouse: unknown command %x\n", data[1]);
 
232
            break;
 
233
        }
 
234
        break;
225
235
    case VMMOUSE_DATA:
226
 
        vmmouse_data(s, data, data[1]);
227
 
        break;
 
236
        vmmouse_data(s, data, data[1]);
 
237
        break;
228
238
    default:
229
 
        printf("vmmouse: unknown command %x\n", command);
230
 
        break;
 
239
        printf("vmmouse: unknown command %x\n", command);
 
240
        break;
231
241
    }
232
242
 
 
243
error:
233
244
    vmmouse_set_data(data);
234
245
    return data[0];
235
246
}
241
252
 
242
253
    qemu_put_be32(f, VMMOUSE_QUEUE_SIZE);
243
254
    for (i = 0; i < VMMOUSE_QUEUE_SIZE; i++)
244
 
        qemu_put_be32s(f, &s->queue[i]);
 
255
        qemu_put_be32s(f, &s->queue[i]);
245
256
    qemu_put_be16s(f, &s->nb_queue);
246
257
    qemu_put_be16s(f, &s->status);
247
258
    qemu_put_8s(f, &s->absolute);
256
267
        return -EINVAL;
257
268
 
258
269
    if (qemu_get_be32(f) != VMMOUSE_QUEUE_SIZE)
259
 
        return -EINVAL;
 
270
        return -EINVAL;
260
271
    for (i = 0; i < VMMOUSE_QUEUE_SIZE; i++)
261
 
        qemu_get_be32s(f, &s->queue[i]);
 
272
        qemu_get_be32s(f, &s->queue[i]);
262
273
    qemu_get_be16s(f, &s->nb_queue);
263
274
    qemu_get_be16s(f, &s->status);
264
275
    qemu_get_8s(f, &s->absolute);
276
287
 
277
288
    s = qemu_mallocz(sizeof(VMMouseState));
278
289
    if (!s)
279
 
        return NULL;
 
290
        return NULL;
280
291
 
281
292
    s->status = 0xffff;
282
293
    s->ps2_mouse = m;
283
294
 
284
 
    vmport_register(VMMOUSE_STATUS, vmmouse_ioport_read, s);
285
 
    vmport_register(VMMOUSE_COMMAND, vmmouse_ioport_read, s);
286
 
    vmport_register(VMMOUSE_DATA, vmmouse_ioport_read, s);
 
295
    register_ioport_read(0x5658, 1, 4, vmmouse_ioport_read, s);
287
296
    register_savevm("vmmouse", 0, 0, vmmouse_save, vmmouse_load, s);
288
297
 
289
298
    return s;