[mirror_qemu.git] / hw / ps2.c

/*
 * QEMU PS/2 keyboard/mouse emulation
 *
 * Copyright (c) 2003 Fabrice Bellard
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
#include "hw/hw.h"
#include "hw/input/ps2.h"
#include "ui/console.h"
#include "sysemu/sysemu.h"

/* debug PC keyboard */
//#define DEBUG_KBD

/* debug PC keyboard : only mouse */
//#define DEBUG_MOUSE

/* Keyboard Commands */
#define KBD_CMD_SET_LEDS	0xED	/* Set keyboard leds */
#define KBD_CMD_ECHO     	0xEE
#define KBD_CMD_SCANCODE	0xF0	/* Get/set scancode set */
#define KBD_CMD_GET_ID 	        0xF2	/* get keyboard ID */
#define KBD_CMD_SET_RATE	0xF3	/* Set typematic rate */
#define KBD_CMD_ENABLE		0xF4	/* Enable scanning */
#define KBD_CMD_RESET_DISABLE	0xF5	/* reset and disable scanning */
#define KBD_CMD_RESET_ENABLE   	0xF6    /* reset and enable scanning */
#define KBD_CMD_RESET		0xFF	/* Reset */

/* Keyboard Replies */
#define KBD_REPLY_POR		0xAA	/* Power on reset */
#define KBD_REPLY_ID		0xAB	/* Keyboard ID */
#define KBD_REPLY_ACK		0xFA	/* Command ACK */
#define KBD_REPLY_RESEND	0xFE	/* Command NACK, send the cmd again */

/* Mouse Commands */
#define AUX_SET_SCALE11		0xE6	/* Set 1:1 scaling */
#define AUX_SET_SCALE21		0xE7	/* Set 2:1 scaling */
#define AUX_SET_RES		0xE8	/* Set resolution */
#define AUX_GET_SCALE		0xE9	/* Get scaling factor */
#define AUX_SET_STREAM		0xEA	/* Set stream mode */
#define AUX_POLL		0xEB	/* Poll */
#define AUX_RESET_WRAP		0xEC	/* Reset wrap mode */
#define AUX_SET_WRAP		0xEE	/* Set wrap mode */
#define AUX_SET_REMOTE		0xF0	/* Set remote mode */
#define AUX_GET_TYPE		0xF2	/* Get type */
#define AUX_SET_SAMPLE		0xF3	/* Set sample rate */
#define AUX_ENABLE_DEV		0xF4	/* Enable aux device */
#define AUX_DISABLE_DEV		0xF5	/* Disable aux device */
#define AUX_SET_DEFAULT		0xF6
#define AUX_RESET		0xFF	/* Reset aux device */
#define AUX_ACK			0xFA	/* Command byte ACK. */

#define MOUSE_STATUS_REMOTE     0x40
#define MOUSE_STATUS_ENABLED    0x20
#define MOUSE_STATUS_SCALE21    0x10

#define PS2_QUEUE_SIZE 256

typedef struct {
    uint8_t data[PS2_QUEUE_SIZE];
    int rptr, wptr, count;
} PS2Queue;

typedef struct {
    PS2Queue queue;
    int32_t write_cmd;
    void (*update_irq)(void *, int);
    void *update_arg;
} PS2State;

typedef struct {
    PS2State common;
    int scan_enabled;
    /* QEMU uses translated PC scancodes internally.  To avoid multiple
       conversions we do the translation (if any) in the PS/2 emulation
       not the keyboard controller.  */
    int translate;
    int scancode_set; /* 1=XT, 2=AT, 3=PS/2 */
    int ledstate;
} PS2KbdState;

typedef struct {
    PS2State common;
    uint8_t mouse_status;
    uint8_t mouse_resolution;
    uint8_t mouse_sample_rate;
    uint8_t mouse_wrap;
    uint8_t mouse_type; /* 0 = PS2, 3 = IMPS/2, 4 = IMEX */
    uint8_t mouse_detect_state;
    int mouse_dx; /* current values, needed for 'poll' mode */
    int mouse_dy;
    int mouse_dz;
    uint8_t mouse_buttons;
} PS2MouseState;

/* Table to convert from PC scancodes to raw scancodes.  */
static const unsigned char ps2_raw_keycode[128] = {
  0, 118,  22,  30,  38,  37,  46,  54,  61,  62,  70,  69,  78,  85, 102,  13,
 21,  29,  36,  45,  44,  53,  60,  67,  68,  77,  84,  91,  90,  20,  28,  27,
 35,  43,  52,  51,  59,  66,  75,  76,  82,  14,  18,  93,  26,  34,  33,  42,
 50,  49,  58,  65,  73,  74,  89, 124,  17,  41,  88,   5,   6,   4,  12,   3,
 11,   2,  10,   1,   9, 119, 126, 108, 117, 125, 123, 107, 115, 116, 121, 105,
114, 122, 112, 113, 127,  96,  97, 120,   7,  15,  23,  31,  39,  47,  55,  63,
 71,  79,  86,  94,   8,  16,  24,  32,  40,  48,  56,  64,  72,  80,  87, 111,
 19,  25,  57,  81,  83,  92,  95,  98,  99, 100, 101, 103, 104, 106, 109, 110
};
static const unsigned char ps2_raw_keycode_set3[128] = {
  0,   8,  22,  30,  38,  37,  46,  54,  61,  62,  70,  69,  78,  85, 102,  13,
 21,  29,  36,  45,  44,  53,  60,  67,  68,  77,  84,  91,  90,  17,  28,  27,
 35,  43,  52,  51,  59,  66,  75,  76,  82,  14,  18,  92,  26,  34,  33,  42,
 50,  49,  58,  65,  73,  74,  89, 126,  25,  41,  20,   7,  15,  23,  31,  39,
 47,   2,  63,  71,  79, 118,  95, 108, 117, 125, 132, 107, 115, 116, 124, 105,
114, 122, 112, 113, 127,  96,  97,  86,  94,  15,  23,  31,  39,  47,  55,  63,
 71,  79,  86,  94,   8,  16,  24,  32,  40,  48,  56,  64,  72,  80,  87, 111,
 19,  25,  57,  81,  83,  92,  95,  98,  99, 100, 101, 103, 104, 106, 109, 110
};

void ps2_queue(void *opaque, int b)
{
    PS2State *s = (PS2State *)opaque;
    PS2Queue *q = &s->queue;

    if (q->count >= PS2_QUEUE_SIZE)
        return;
    q->data[q->wptr] = b;
    if (++q->wptr == PS2_QUEUE_SIZE)
        q->wptr = 0;
    q->count++;
    s->update_irq(s->update_arg, 1);
}

/*
   keycode is expressed as follow:
   bit 7    - 0 key pressed, 1 = key released
   bits 6-0 - translated scancode set 2
 */
static void ps2_put_keycode(void *opaque, int keycode)
{
    PS2KbdState *s = opaque;

    qemu_system_wakeup_request(QEMU_WAKEUP_REASON_OTHER);
    /* XXX: add support for scancode set 1 */
    if (!s->translate && keycode < 0xe0 && s->scancode_set > 1) {
        if (keycode & 0x80) {
            ps2_queue(&s->common, 0xf0);
        }
        if (s->scancode_set == 2) {
            keycode = ps2_raw_keycode[keycode & 0x7f];
        } else if (s->scancode_set == 3) {
            keycode = ps2_raw_keycode_set3[keycode & 0x7f];
        }
      }
    ps2_queue(&s->common, keycode);
}

uint32_t ps2_read_data(void *opaque)
{
    PS2State *s = (PS2State *)opaque;
    PS2Queue *q;
    int val, index;

    q = &s->queue;
    if (q->count == 0) {
        /* NOTE: if no data left, we return the last keyboard one
           (needed for EMM386) */
        /* XXX: need a timer to do things correctly */
        index = q->rptr - 1;
        if (index < 0)
            index = PS2_QUEUE_SIZE - 1;
        val = q->data[index];
    } else {
        val = q->data[q->rptr];
        if (++q->rptr == PS2_QUEUE_SIZE)
            q->rptr = 0;
        q->count--;
        /* reading deasserts IRQ */
        s->update_irq(s->update_arg, 0);
        /* reassert IRQs if data left */
        s->update_irq(s->update_arg, q->count != 0);
    }
    return val;
}

static void ps2_set_ledstate(PS2KbdState *s, int ledstate)
{
    s->ledstate = ledstate;
    kbd_put_ledstate(ledstate);
}

static void ps2_reset_keyboard(PS2KbdState *s)
{
    s->scan_enabled = 1;
    s->scancode_set = 2;
    ps2_set_ledstate(s, 0);
}

void ps2_write_keyboard(void *opaque, int val)
{
    PS2KbdState *s = (PS2KbdState *)opaque;

    switch(s->common.write_cmd) {
    default:
    case -1:
        switch(val) {
        case 0x00:
            ps2_queue(&s->common, KBD_REPLY_ACK);
            break;
        case 0x05:
            ps2_queue(&s->common, KBD_REPLY_RESEND);
            break;
        case KBD_CMD_GET_ID:
            ps2_queue(&s->common, KBD_REPLY_ACK);
            /* We emulate a MF2 AT keyboard here */
            ps2_queue(&s->common, KBD_REPLY_ID);
            if (s->translate)
                ps2_queue(&s->common, 0x41);
            else
                ps2_queue(&s->common, 0x83);
            break;
        case KBD_CMD_ECHO:
            ps2_queue(&s->common, KBD_CMD_ECHO);
            break;
        case KBD_CMD_ENABLE:
            s->scan_enabled = 1;
            ps2_queue(&s->common, KBD_REPLY_ACK);
            break;
        case KBD_CMD_SCANCODE:
        case KBD_CMD_SET_LEDS:
        case KBD_CMD_SET_RATE:
            s->common.write_cmd = val;
            ps2_queue(&s->common, KBD_REPLY_ACK);
            break;
        case KBD_CMD_RESET_DISABLE:
            ps2_reset_keyboard(s);
            s->scan_enabled = 0;
            ps2_queue(&s->common, KBD_REPLY_ACK);
            break;
        case KBD_CMD_RESET_ENABLE:
            ps2_reset_keyboard(s);
            s->scan_enabled = 1;
            ps2_queue(&s->common, KBD_REPLY_ACK);
            break;
        case KBD_CMD_RESET:
            ps2_reset_keyboard(s);
            ps2_queue(&s->common, KBD_REPLY_ACK);
            ps2_queue(&s->common, KBD_REPLY_POR);
            break;
        default:
            ps2_queue(&s->common, KBD_REPLY_ACK);
            break;
        }
        break;
    case KBD_CMD_SCANCODE:
        if (val == 0) {
            if (s->scancode_set == 1)
                ps2_put_keycode(s, 0x43);
            else if (s->scancode_set == 2)
                ps2_put_keycode(s, 0x41);
            else if (s->scancode_set == 3)
                ps2_put_keycode(s, 0x3f);
        } else {
            if (val >= 1 && val <= 3)
                s->scancode_set = val;
            ps2_queue(&s->common, KBD_REPLY_ACK);
        }
        s->common.write_cmd = -1;
        break;
    case KBD_CMD_SET_LEDS:
        ps2_set_ledstate(s, val);
        ps2_queue(&s->common, KBD_REPLY_ACK);
        s->common.write_cmd = -1;
        break;
    case KBD_CMD_SET_RATE:
        ps2_queue(&s->common, KBD_REPLY_ACK);
        s->common.write_cmd = -1;
        break;
    }
}

/* Set the scancode translation mode.
   0 = raw scancodes.
   1 = translated scancodes (used by qemu internally).  */

void ps2_keyboard_set_translation(void *opaque, int mode)
{
    PS2KbdState *s = (PS2KbdState *)opaque;
    s->translate = mode;
}

static void ps2_mouse_send_packet(PS2MouseState *s)
{
    unsigned int b;
    int dx1, dy1, dz1;

    dx1 = s->mouse_dx;
    dy1 = s->mouse_dy;
    dz1 = s->mouse_dz;
    /* XXX: increase range to 8 bits ? */
    if (dx1 > 127)
        dx1 = 127;
    else if (dx1 < -127)
        dx1 = -127;
    if (dy1 > 127)
        dy1 = 127;
    else if (dy1 < -127)
        dy1 = -127;
    b = 0x08 | ((dx1 < 0) << 4) | ((dy1 < 0) << 5) | (s->mouse_buttons & 0x07);
    ps2_queue(&s->common, b);
    ps2_queue(&s->common, dx1 & 0xff);
    ps2_queue(&s->common, dy1 & 0xff);
    /* extra byte for IMPS/2 or IMEX */
    switch(s->mouse_type) {
    default:
        break;
    case 3:
        if (dz1 > 127)
            dz1 = 127;
        else if (dz1 < -127)
                dz1 = -127;
        ps2_queue(&s->common, dz1 & 0xff);
        break;
    case 4:
        if (dz1 > 7)
            dz1 = 7;
        else if (dz1 < -7)
            dz1 = -7;
        b = (dz1 & 0x0f) | ((s->mouse_buttons & 0x18) << 1);
        ps2_queue(&s->common, b);
        break;
    }

    /* update deltas */
    s->mouse_dx -= dx1;
    s->mouse_dy -= dy1;
    s->mouse_dz -= dz1;
}

static void ps2_mouse_event(void *opaque,
                            int dx, int dy, int dz, int buttons_state)
{
    PS2MouseState *s = opaque;

    /* check if deltas are recorded when disabled */
    if (!(s->mouse_status & MOUSE_STATUS_ENABLED))
        return;

    s->mouse_dx += dx;
    s->mouse_dy -= dy;
    s->mouse_dz += dz;
    /* XXX: SDL sometimes generates nul events: we delete them */
    if (s->mouse_dx == 0 && s->mouse_dy == 0 && s->mouse_dz == 0 &&
        s->mouse_buttons == buttons_state)
	return;
    s->mouse_buttons = buttons_state;

    if (buttons_state) {
        qemu_system_wakeup_request(QEMU_WAKEUP_REASON_OTHER);
    }

    if (!(s->mouse_status & MOUSE_STATUS_REMOTE) &&
        (s->common.queue.count < (PS2_QUEUE_SIZE - 16))) {
        for(;;) {
            /* if not remote, send event. Multiple events are sent if
               too big deltas */
            ps2_mouse_send_packet(s);
            if (s->mouse_dx == 0 && s->mouse_dy == 0 && s->mouse_dz == 0)
                break;
        }
    }
}

void ps2_mouse_fake_event(void *opaque)
{
    ps2_mouse_event(opaque, 1, 0, 0, 0);
}

void ps2_write_mouse(void *opaque, int val)
{
    PS2MouseState *s = (PS2MouseState *)opaque;
#ifdef DEBUG_MOUSE
    printf("kbd: write mouse 0x%02x\n", val);
#endif
    switch(s->common.write_cmd) {
    default:
    case -1:
        /* mouse command */
        if (s->mouse_wrap) {
            if (val == AUX_RESET_WRAP) {
                s->mouse_wrap = 0;
                ps2_queue(&s->common, AUX_ACK);
                return;
            } else if (val != AUX_RESET) {
                ps2_queue(&s->common, val);
                return;
            }
        }
        switch(val) {
        case AUX_SET_SCALE11:
            s->mouse_status &= ~MOUSE_STATUS_SCALE21;
            ps2_queue(&s->common, AUX_ACK);
            break;
        case AUX_SET_SCALE21:
            s->mouse_status |= MOUSE_STATUS_SCALE21;
            ps2_queue(&s->common, AUX_ACK);
            break;
        case AUX_SET_STREAM:
            s->mouse_status &= ~MOUSE_STATUS_REMOTE;
            ps2_queue(&s->common, AUX_ACK);
            break;
        case AUX_SET_WRAP:
            s->mouse_wrap = 1;
            ps2_queue(&s->common, AUX_ACK);
            break;
        case AUX_SET_REMOTE:
            s->mouse_status |= MOUSE_STATUS_REMOTE;
            ps2_queue(&s->common, AUX_ACK);
            break;
        case AUX_GET_TYPE:
            ps2_queue(&s->common, AUX_ACK);
            ps2_queue(&s->common, s->mouse_type);
            break;
        case AUX_SET_RES:
        case AUX_SET_SAMPLE:
            s->common.write_cmd = val;
            ps2_queue(&s->common, AUX_ACK);
            break;
        case AUX_GET_SCALE:
            ps2_queue(&s->common, AUX_ACK);
            ps2_queue(&s->common, s->mouse_status);
            ps2_queue(&s->common, s->mouse_resolution);
            ps2_queue(&s->common, s->mouse_sample_rate);
            break;
        case AUX_POLL:
            ps2_queue(&s->common, AUX_ACK);
            ps2_mouse_send_packet(s);
            break;
        case AUX_ENABLE_DEV:
            s->mouse_status |= MOUSE_STATUS_ENABLED;
            ps2_queue(&s->common, AUX_ACK);
            break;
        case AUX_DISABLE_DEV:
            s->mouse_status &= ~MOUSE_STATUS_ENABLED;
            ps2_queue(&s->common, AUX_ACK);
            break;
        case AUX_SET_DEFAULT:
            s->mouse_sample_rate = 100;
            s->mouse_resolution = 2;
            s->mouse_status = 0;
            ps2_queue(&s->common, AUX_ACK);
            break;
        case AUX_RESET:
            s->mouse_sample_rate = 100;
            s->mouse_resolution = 2;
            s->mouse_status = 0;
            s->mouse_type = 0;
            ps2_queue(&s->common, AUX_ACK);
            ps2_queue(&s->common, 0xaa);
            ps2_queue(&s->common, s->mouse_type);
            break;
        default:
            break;
        }
        break;
    case AUX_SET_SAMPLE:
        s->mouse_sample_rate = val;
        /* detect IMPS/2 or IMEX */
        switch(s->mouse_detect_state) {
        default:
        case 0:
            if (val == 200)
                s->mouse_detect_state = 1;
            break;
        case 1:
            if (val == 100)
                s->mouse_detect_state = 2;
            else if (val == 200)
                s->mouse_detect_state = 3;
            else
                s->mouse_detect_state = 0;
            break;
        case 2:
            if (val == 80)
                s->mouse_type = 3; /* IMPS/2 */
            s->mouse_detect_state = 0;
            break;
        case 3:
            if (val == 80)
                s->mouse_type = 4; /* IMEX */
            s->mouse_detect_state = 0;
            break;
        }
        ps2_queue(&s->common, AUX_ACK);
        s->common.write_cmd = -1;
        break;
    case AUX_SET_RES:
        s->mouse_resolution = val;
        ps2_queue(&s->common, AUX_ACK);
        s->common.write_cmd = -1;
        break;
    }
}

static void ps2_common_reset(PS2State *s)
{
    PS2Queue *q;
    s->write_cmd = -1;
    q = &s->queue;
    q->rptr = 0;
    q->wptr = 0;
    q->count = 0;
    s->update_irq(s->update_arg, 0);
}

static void ps2_kbd_reset(void *opaque)
{
    PS2KbdState *s = (PS2KbdState *) opaque;

    ps2_common_reset(&s->common);
    s->scan_enabled = 0;
    s->translate = 0;
    s->scancode_set = 0;
}

static void ps2_mouse_reset(void *opaque)
{
    PS2MouseState *s = (PS2MouseState *) opaque;

    ps2_common_reset(&s->common);
    s->mouse_status = 0;
    s->mouse_resolution = 0;
    s->mouse_sample_rate = 0;
    s->mouse_wrap = 0;
    s->mouse_type = 0;
    s->mouse_detect_state = 0;
    s->mouse_dx = 0;
    s->mouse_dy = 0;
    s->mouse_dz = 0;
    s->mouse_buttons = 0;
}

static const VMStateDescription vmstate_ps2_common = {
    .name = "PS2 Common State",
    .version_id = 3,
    .minimum_version_id = 2,
    .minimum_version_id_old = 2,
    .fields      = (VMStateField []) {
        VMSTATE_INT32(write_cmd, PS2State),
        VMSTATE_INT32(queue.rptr, PS2State),
        VMSTATE_INT32(queue.wptr, PS2State),
        VMSTATE_INT32(queue.count, PS2State),
        VMSTATE_BUFFER(queue.data, PS2State),
        VMSTATE_END_OF_LIST()
    }
};

static bool ps2_keyboard_ledstate_needed(void *opaque)
{
    PS2KbdState *s = opaque;

    return s->ledstate != 0; /* 0 is default state */
}

static int ps2_kbd_ledstate_post_load(void *opaque, int version_id)
{
    PS2KbdState *s = opaque;

    kbd_put_ledstate(s->ledstate);
    return 0;
}

static const VMStateDescription vmstate_ps2_keyboard_ledstate = {
    .name = "ps2kbd/ledstate",
    .version_id = 3,
    .minimum_version_id = 2,
    .minimum_version_id_old = 2,
    .post_load = ps2_kbd_ledstate_post_load,
    .fields      = (VMStateField []) {
        VMSTATE_INT32(ledstate, PS2KbdState),
        VMSTATE_END_OF_LIST()
    }
};

static int ps2_kbd_post_load(void* opaque, int version_id)
{
    PS2KbdState *s = (PS2KbdState*)opaque;

    if (version_id == 2)
        s->scancode_set=2;
    return 0;
}

static const VMStateDescription vmstate_ps2_keyboard = {
    .name = "ps2kbd",
    .version_id = 3,
    .minimum_version_id = 2,
    .minimum_version_id_old = 2,
    .post_load = ps2_kbd_post_load,
    .fields      = (VMStateField []) {
        VMSTATE_STRUCT(common, PS2KbdState, 0, vmstate_ps2_common, PS2State),
        VMSTATE_INT32(scan_enabled, PS2KbdState),
        VMSTATE_INT32(translate, PS2KbdState),
        VMSTATE_INT32_V(scancode_set, PS2KbdState,3),
        VMSTATE_END_OF_LIST()
    },
    .subsections = (VMStateSubsection []) {
        {
            .vmsd = &vmstate_ps2_keyboard_ledstate,
            .needed = ps2_keyboard_ledstate_needed,
        }, {
            /* empty */
        }
    }
};

static const VMStateDescription vmstate_ps2_mouse = {
    .name = "ps2mouse",
    .version_id = 2,
    .minimum_version_id = 2,
    .minimum_version_id_old = 2,
    .fields      = (VMStateField []) {
        VMSTATE_STRUCT(common, PS2MouseState, 0, vmstate_ps2_common, PS2State),
        VMSTATE_UINT8(mouse_status, PS2MouseState),
        VMSTATE_UINT8(mouse_resolution, PS2MouseState),
        VMSTATE_UINT8(mouse_sample_rate, PS2MouseState),
        VMSTATE_UINT8(mouse_wrap, PS2MouseState),
        VMSTATE_UINT8(mouse_type, PS2MouseState),
        VMSTATE_UINT8(mouse_detect_state, PS2MouseState),
        VMSTATE_INT32(mouse_dx, PS2MouseState),
        VMSTATE_INT32(mouse_dy, PS2MouseState),
        VMSTATE_INT32(mouse_dz, PS2MouseState),
        VMSTATE_UINT8(mouse_buttons, PS2MouseState),
        VMSTATE_END_OF_LIST()
    }
};

void *ps2_kbd_init(void (*update_irq)(void *, int), void *update_arg)
{
    PS2KbdState *s = (PS2KbdState *)g_malloc0(sizeof(PS2KbdState));

    s->common.update_irq = update_irq;
    s->common.update_arg = update_arg;
    s->scancode_set = 2;
    vmstate_register(NULL, 0, &vmstate_ps2_keyboard, s);
    qemu_add_kbd_event_handler(ps2_put_keycode, s);
    qemu_register_reset(ps2_kbd_reset, s);
    return s;
}

void *ps2_mouse_init(void (*update_irq)(void *, int), void *update_arg)
{
    PS2MouseState *s = (PS2MouseState *)g_malloc0(sizeof(PS2MouseState));

    s->common.update_irq = update_irq;
    s->common.update_arg = update_arg;
    vmstate_register(NULL, 0, &vmstate_ps2_mouse, s);
    qemu_add_mouse_event_handler(ps2_mouse_event, s, 0, "QEMU PS/2 Mouse");
    qemu_register_reset(ps2_mouse_reset, s);
    return s;
}
Commit	Line	Data
0e43e99c FB	1	/*
0e43e99c FB	2	* QEMU PS/2 keyboard/mouse emulation
5fafdf24	3	*
0e43e99c	4	* Copyright (c) 2003 Fabrice Bellard
5fafdf24	5	*
0e43e99c FB	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	*/
83c9f4ca	24	#include "hw/hw.h"
0d09e41a	25	#include "hw/input/ps2.h"
28ecbaee	26	#include "ui/console.h"
9c17d615	27	#include "sysemu/sysemu.h"
0e43e99c FB	28
	29	/* debug PC keyboard */
	30	//#define DEBUG_KBD
	31
	32	/* debug PC keyboard : only mouse */
	33	//#define DEBUG_MOUSE
	34
	35	/* Keyboard Commands */
	36	#define KBD_CMD_SET_LEDS 0xED /* Set keyboard leds */
	37	#define KBD_CMD_ECHO 0xEE
e7d93956	38	#define KBD_CMD_SCANCODE 0xF0 /* Get/set scancode set */
0e43e99c FB	39	#define KBD_CMD_GET_ID 0xF2 /* get keyboard ID */
	40	#define KBD_CMD_SET_RATE 0xF3 /* Set typematic rate */
	41	#define KBD_CMD_ENABLE 0xF4 /* Enable scanning */
	42	#define KBD_CMD_RESET_DISABLE 0xF5 /* reset and disable scanning */
	43	#define KBD_CMD_RESET_ENABLE 0xF6 /* reset and enable scanning */
	44	#define KBD_CMD_RESET 0xFF /* Reset */
	45
	46	/* Keyboard Replies */
	47	#define KBD_REPLY_POR 0xAA /* Power on reset */
35c4d671	48	#define KBD_REPLY_ID 0xAB /* Keyboard ID */
0e43e99c FB	49	#define KBD_REPLY_ACK 0xFA /* Command ACK */
	50	#define KBD_REPLY_RESEND 0xFE /* Command NACK, send the cmd again */
	51
	52	/* Mouse Commands */
	53	#define AUX_SET_SCALE11 0xE6 /* Set 1:1 scaling */
	54	#define AUX_SET_SCALE21 0xE7 /* Set 2:1 scaling */
	55	#define AUX_SET_RES 0xE8 /* Set resolution */
	56	#define AUX_GET_SCALE 0xE9 /* Get scaling factor */
	57	#define AUX_SET_STREAM 0xEA /* Set stream mode */
	58	#define AUX_POLL 0xEB /* Poll */
	59	#define AUX_RESET_WRAP 0xEC /* Reset wrap mode */
	60	#define AUX_SET_WRAP 0xEE /* Set wrap mode */
	61	#define AUX_SET_REMOTE 0xF0 /* Set remote mode */
	62	#define AUX_GET_TYPE 0xF2 /* Get type */
	63	#define AUX_SET_SAMPLE 0xF3 /* Set sample rate */
	64	#define AUX_ENABLE_DEV 0xF4 /* Enable aux device */
	65	#define AUX_DISABLE_DEV 0xF5 /* Disable aux device */
	66	#define AUX_SET_DEFAULT 0xF6
	67	#define AUX_RESET 0xFF /* Reset aux device */
	68	#define AUX_ACK 0xFA /* Command byte ACK. */
	69
	70	#define MOUSE_STATUS_REMOTE 0x40
	71	#define MOUSE_STATUS_ENABLED 0x20
	72	#define MOUSE_STATUS_SCALE21 0x10
	73
	74	#define PS2_QUEUE_SIZE 256
	75
	76	typedef struct {
	77	uint8_t data[PS2_QUEUE_SIZE];
	78	int rptr, wptr, count;
	79	} PS2Queue;
	80
	81	typedef struct {
	82	PS2Queue queue;
	83	int32_t write_cmd;
	84	void (update_irq)(void , int);
	85	void *update_arg;
	86	} PS2State;
	87
	88	typedef struct {
	89	PS2State common;
	90	int scan_enabled;
5cbdb3a3	91	/* QEMU uses translated PC scancodes internally. To avoid multiple
f94f5d71 PB	92	conversions we do the translation (if any) in the PS/2 emulation
	93	not the keyboard controller. */
	94	int translate;
e7d93956	95	int scancode_set; /* 1=XT, 2=AT, 3=PS/2 */
7f540ab5	96	int ledstate;
0e43e99c FB	97	} PS2KbdState;
	98
	99	typedef struct {
	100	PS2State common;
	101	uint8_t mouse_status;
	102	uint8_t mouse_resolution;
	103	uint8_t mouse_sample_rate;
	104	uint8_t mouse_wrap;
	105	uint8_t mouse_type; /* 0 = PS2, 3 = IMPS/2, 4 = IMEX */
	106	uint8_t mouse_detect_state;
	107	int mouse_dx; /* current values, needed for 'poll' mode */
	108	int mouse_dy;
	109	int mouse_dz;
	110	uint8_t mouse_buttons;
	111	} PS2MouseState;
	112
f94f5d71 PB	113	/* Table to convert from PC scancodes to raw scancodes. */
f94f5d71 PB	114	static const unsigned char ps2_raw_keycode[128] = {
7096a96d RT	115	0, 118, 22, 30, 38, 37, 46, 54, 61, 62, 70, 69, 78, 85, 102, 13,
	116	21, 29, 36, 45, 44, 53, 60, 67, 68, 77, 84, 91, 90, 20, 28, 27,
	117	35, 43, 52, 51, 59, 66, 75, 76, 82, 14, 18, 93, 26, 34, 33, 42,
	118	50, 49, 58, 65, 73, 74, 89, 124, 17, 41, 88, 5, 6, 4, 12, 3,
	119	11, 2, 10, 1, 9, 119, 126, 108, 117, 125, 123, 107, 115, 116, 121, 105,
	120	114, 122, 112, 113, 127, 96, 97, 120, 7, 15, 23, 31, 39, 47, 55, 63,
	121	71, 79, 86, 94, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 87, 111,
	122	19, 25, 57, 81, 83, 92, 95, 98, 99, 100, 101, 103, 104, 106, 109, 110
	123	};
	124	static const unsigned char ps2_raw_keycode_set3[128] = {
	125	0, 8, 22, 30, 38, 37, 46, 54, 61, 62, 70, 69, 78, 85, 102, 13,
	126	21, 29, 36, 45, 44, 53, 60, 67, 68, 77, 84, 91, 90, 17, 28, 27,
	127	35, 43, 52, 51, 59, 66, 75, 76, 82, 14, 18, 92, 26, 34, 33, 42,
	128	50, 49, 58, 65, 73, 74, 89, 126, 25, 41, 20, 7, 15, 23, 31, 39,
	129	47, 2, 63, 71, 79, 118, 95, 108, 117, 125, 132, 107, 115, 116, 124, 105,
	130	114, 122, 112, 113, 127, 96, 97, 86, 94, 15, 23, 31, 39, 47, 55, 63,
	131	71, 79, 86, 94, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 87, 111,
	132	19, 25, 57, 81, 83, 92, 95, 98, 99, 100, 101, 103, 104, 106, 109, 110
f94f5d71 PB	133	};
f94f5d71 PB	134
0e43e99c FB	135	void ps2_queue(void *opaque, int b)
	136	{
	137	PS2State s = (PS2State )opaque;
	138	PS2Queue *q = &s->queue;
	139
	140	if (q->count >= PS2_QUEUE_SIZE)
	141	return;
	142	q->data[q->wptr] = b;
	143	if (++q->wptr == PS2_QUEUE_SIZE)
	144	q->wptr = 0;
	145	q->count++;
	146	s->update_irq(s->update_arg, 1);
	147	}
	148
35c4d671 AJ	149	/*
	150	keycode is expressed as follow:
	151	bit 7 - 0 key pressed, 1 = key released
	152	bits 6-0 - translated scancode set 2
	153	*/
0e43e99c FB	154	static void ps2_put_keycode(void *opaque, int keycode)
0e43e99c FB	155	{
f94f5d71	156	PS2KbdState *s = opaque;
e7d93956	157
fd214d18	158	qemu_system_wakeup_request(QEMU_WAKEUP_REASON_OTHER);
7096a96d RT	159	/* XXX: add support for scancode set 1 */
	160	if (!s->translate && keycode < 0xe0 && s->scancode_set > 1) {
	161	if (keycode & 0x80) {
f94f5d71	162	ps2_queue(&s->common, 0xf0);
7096a96d RT	163	}
	164	if (s->scancode_set == 2) {
	165	keycode = ps2_raw_keycode[keycode & 0x7f];
	166	} else if (s->scancode_set == 3) {
	167	keycode = ps2_raw_keycode_set3[keycode & 0x7f];
	168	}
f94f5d71	169	}
0e43e99c FB	170	ps2_queue(&s->common, keycode);
	171	}
	172
	173	uint32_t ps2_read_data(void *opaque)
	174	{
	175	PS2State s = (PS2State )opaque;
	176	PS2Queue *q;
	177	int val, index;
3b46e624	178
0e43e99c FB	179	q = &s->queue;
	180	if (q->count == 0) {
	181	/* NOTE: if no data left, we return the last keyboard one
	182	(needed for EMM386) */
	183	/* XXX: need a timer to do things correctly */
	184	index = q->rptr - 1;
	185	if (index < 0)
	186	index = PS2_QUEUE_SIZE - 1;
	187	val = q->data[index];
	188	} else {
	189	val = q->data[q->rptr];
	190	if (++q->rptr == PS2_QUEUE_SIZE)
	191	q->rptr = 0;
	192	q->count--;
	193	/* reading deasserts IRQ */
	194	s->update_irq(s->update_arg, 0);
	195	/* reassert IRQs if data left */
	196	s->update_irq(s->update_arg, q->count != 0);
	197	}
	198	return val;
	199	}
	200
7f540ab5 CF	201	static void ps2_set_ledstate(PS2KbdState *s, int ledstate)
	202	{
	203	s->ledstate = ledstate;
	204	kbd_put_ledstate(ledstate);
	205	}
	206
0e43e99c FB	207	static void ps2_reset_keyboard(PS2KbdState *s)
	208	{
	209	s->scan_enabled = 1;
e7d93956	210	s->scancode_set = 2;
7f540ab5	211	ps2_set_ledstate(s, 0);
0e43e99c FB	212	}
	213
	214	void ps2_write_keyboard(void *opaque, int val)
	215	{
	216	PS2KbdState s = (PS2KbdState )opaque;
	217
	218	switch(s->common.write_cmd) {
	219	default:
	220	case -1:
	221	switch(val) {
	222	case 0x00:
	223	ps2_queue(&s->common, KBD_REPLY_ACK);
	224	break;
	225	case 0x05:
	226	ps2_queue(&s->common, KBD_REPLY_RESEND);
	227	break;
	228	case KBD_CMD_GET_ID:
	229	ps2_queue(&s->common, KBD_REPLY_ACK);
e7d93956	230	/* We emulate a MF2 AT keyboard here */
35c4d671 AJ	231	ps2_queue(&s->common, KBD_REPLY_ID);
	232	if (s->translate)
	233	ps2_queue(&s->common, 0x41);
	234	else
	235	ps2_queue(&s->common, 0x83);
0e43e99c FB	236	break;
	237	case KBD_CMD_ECHO:
	238	ps2_queue(&s->common, KBD_CMD_ECHO);
	239	break;
	240	case KBD_CMD_ENABLE:
	241	s->scan_enabled = 1;
	242	ps2_queue(&s->common, KBD_REPLY_ACK);
	243	break;
e7d93956	244	case KBD_CMD_SCANCODE:
0e43e99c FB	245	case KBD_CMD_SET_LEDS:
	246	case KBD_CMD_SET_RATE:
	247	s->common.write_cmd = val;
	248	ps2_queue(&s->common, KBD_REPLY_ACK);
	249	break;
	250	case KBD_CMD_RESET_DISABLE:
	251	ps2_reset_keyboard(s);
	252	s->scan_enabled = 0;
	253	ps2_queue(&s->common, KBD_REPLY_ACK);
	254	break;
	255	case KBD_CMD_RESET_ENABLE:
	256	ps2_reset_keyboard(s);
	257	s->scan_enabled = 1;
	258	ps2_queue(&s->common, KBD_REPLY_ACK);
	259	break;
	260	case KBD_CMD_RESET:
	261	ps2_reset_keyboard(s);
	262	ps2_queue(&s->common, KBD_REPLY_ACK);
	263	ps2_queue(&s->common, KBD_REPLY_POR);
	264	break;
	265	default:
	266	ps2_queue(&s->common, KBD_REPLY_ACK);
	267	break;
	268	}
	269	break;
e7d93956 AJ	270	case KBD_CMD_SCANCODE:
	271	if (val == 0) {
	272	if (s->scancode_set == 1)
	273	ps2_put_keycode(s, 0x43);
	274	else if (s->scancode_set == 2)
	275	ps2_put_keycode(s, 0x41);
	276	else if (s->scancode_set == 3)
	277	ps2_put_keycode(s, 0x3f);
	278	} else {
	279	if (val >= 1 && val <= 3)
	280	s->scancode_set = val;
	281	ps2_queue(&s->common, KBD_REPLY_ACK);
	282	}
	283	s->common.write_cmd = -1;
	284	break;
0e43e99c	285	case KBD_CMD_SET_LEDS:
7f540ab5	286	ps2_set_ledstate(s, val);
0e43e99c FB	287	ps2_queue(&s->common, KBD_REPLY_ACK);
	288	s->common.write_cmd = -1;
	289	break;
	290	case KBD_CMD_SET_RATE:
	291	ps2_queue(&s->common, KBD_REPLY_ACK);
	292	s->common.write_cmd = -1;
	293	break;
	294	}
	295	}
	296
f94f5d71 PB	297	/* Set the scancode translation mode.
	298	0 = raw scancodes.
	299	1 = translated scancodes (used by qemu internally). */
	300
	301	void ps2_keyboard_set_translation(void *opaque, int mode)
	302	{
	303	PS2KbdState s = (PS2KbdState )opaque;
	304	s->translate = mode;
	305	}
	306
0e43e99c FB	307	static void ps2_mouse_send_packet(PS2MouseState *s)
	308	{
	309	unsigned int b;
	310	int dx1, dy1, dz1;
	311
	312	dx1 = s->mouse_dx;
	313	dy1 = s->mouse_dy;
	314	dz1 = s->mouse_dz;
	315	/* XXX: increase range to 8 bits ? */
	316	if (dx1 > 127)
	317	dx1 = 127;
	318	else if (dx1 < -127)
	319	dx1 = -127;
	320	if (dy1 > 127)
	321	dy1 = 127;
	322	else if (dy1 < -127)
	323	dy1 = -127;
	324	b = 0x08 \| ((dx1 < 0) << 4) \| ((dy1 < 0) << 5) \| (s->mouse_buttons & 0x07);
	325	ps2_queue(&s->common, b);
	326	ps2_queue(&s->common, dx1 & 0xff);
	327	ps2_queue(&s->common, dy1 & 0xff);
	328	/* extra byte for IMPS/2 or IMEX */
	329	switch(s->mouse_type) {
	330	default:
	331	break;
	332	case 3:
	333	if (dz1 > 127)
	334	dz1 = 127;
	335	else if (dz1 < -127)
	336	dz1 = -127;
	337	ps2_queue(&s->common, dz1 & 0xff);
	338	break;
	339	case 4:
	340	if (dz1 > 7)
	341	dz1 = 7;
	342	else if (dz1 < -7)
	343	dz1 = -7;
	344	b = (dz1 & 0x0f) \| ((s->mouse_buttons & 0x18) << 1);
	345	ps2_queue(&s->common, b);
	346	break;
	347	}
	348
	349	/* update deltas */
	350	s->mouse_dx -= dx1;
	351	s->mouse_dy -= dy1;
	352	s->mouse_dz -= dz1;
	353	}
	354
5fafdf24	355	static void ps2_mouse_event(void *opaque,
0e43e99c FB	356	int dx, int dy, int dz, int buttons_state)
	357	{
	358	PS2MouseState *s = opaque;
	359
	360	/* check if deltas are recorded when disabled */
	361	if (!(s->mouse_status & MOUSE_STATUS_ENABLED))
	362	return;
	363
	364	s->mouse_dx += dx;
	365	s->mouse_dy -= dy;
	366	s->mouse_dz += dz;
	367	/* XXX: SDL sometimes generates nul events: we delete them */
	368	if (s->mouse_dx == 0 && s->mouse_dy == 0 && s->mouse_dz == 0 &&
	369	s->mouse_buttons == buttons_state)
	370	return;
	371	s->mouse_buttons = buttons_state;
3b46e624	372
fd214d18 GH	373	if (buttons_state) {
	374	qemu_system_wakeup_request(QEMU_WAKEUP_REASON_OTHER);
	375	}
	376
0e43e99c FB	377	if (!(s->mouse_status & MOUSE_STATUS_REMOTE) &&
	378	(s->common.queue.count < (PS2_QUEUE_SIZE - 16))) {
	379	for(;;) {
	380	/* if not remote, send event. Multiple events are sent if
	381	too big deltas */
	382	ps2_mouse_send_packet(s);
	383	if (s->mouse_dx == 0 && s->mouse_dy == 0 && s->mouse_dz == 0)
	384	break;
	385	}
	386	}
	387	}
	388
548df2ac TS	389	void ps2_mouse_fake_event(void *opaque)
	390	{
	391	ps2_mouse_event(opaque, 1, 0, 0, 0);
	392	}
	393
0e43e99c FB	394	void ps2_write_mouse(void *opaque, int val)
	395	{
	396	PS2MouseState s = (PS2MouseState )opaque;
	397	#ifdef DEBUG_MOUSE
	398	printf("kbd: write mouse 0x%02x\n", val);
	399	#endif
	400	switch(s->common.write_cmd) {
	401	default:
	402	case -1:
	403	/* mouse command */
	404	if (s->mouse_wrap) {
	405	if (val == AUX_RESET_WRAP) {
	406	s->mouse_wrap = 0;
	407	ps2_queue(&s->common, AUX_ACK);
	408	return;
	409	} else if (val != AUX_RESET) {
	410	ps2_queue(&s->common, val);
	411	return;
	412	}
	413	}
	414	switch(val) {
	415	case AUX_SET_SCALE11:
	416	s->mouse_status &= ~MOUSE_STATUS_SCALE21;
	417	ps2_queue(&s->common, AUX_ACK);
	418	break;
	419	case AUX_SET_SCALE21:
	420	s->mouse_status \|= MOUSE_STATUS_SCALE21;
	421	ps2_queue(&s->common, AUX_ACK);
	422	break;
	423	case AUX_SET_STREAM:
	424	s->mouse_status &= ~MOUSE_STATUS_REMOTE;
	425	ps2_queue(&s->common, AUX_ACK);
	426	break;
	427	case AUX_SET_WRAP:
	428	s->mouse_wrap = 1;
	429	ps2_queue(&s->common, AUX_ACK);
	430	break;
	431	case AUX_SET_REMOTE:
	432	s->mouse_status \|= MOUSE_STATUS_REMOTE;
	433	ps2_queue(&s->common, AUX_ACK);
	434	break;
	435	case AUX_GET_TYPE:
	436	ps2_queue(&s->common, AUX_ACK);
	437	ps2_queue(&s->common, s->mouse_type);
	438	break;
	439	case AUX_SET_RES:
	440	case AUX_SET_SAMPLE:
	441	s->common.write_cmd = val;
	442	ps2_queue(&s->common, AUX_ACK);
	443	break;
	444	case AUX_GET_SCALE:
	445	ps2_queue(&s->common, AUX_ACK);
	446	ps2_queue(&s->common, s->mouse_status);
	447	ps2_queue(&s->common, s->mouse_resolution);
	448	ps2_queue(&s->common, s->mouse_sample_rate);
	449	break;
	450	case AUX_POLL:
	451	ps2_queue(&s->common, AUX_ACK);
	452	ps2_mouse_send_packet(s);
	453	break;
	454	case AUX_ENABLE_DEV:
	455	s->mouse_status \|= MOUSE_STATUS_ENABLED;
	456	ps2_queue(&s->common, AUX_ACK);
	457	break;
458	case AUX_DISABLE_DEV:
459	s->mouse_status &= ~MOUSE_STATUS_ENABLED;
460	ps2_queue(&s->common, AUX_ACK);
461	break;
462	case AUX_SET_DEFAULT:
463	s->mouse_sample_rate = 100;
464	s->mouse_resolution = 2;
465	s->mouse_status = 0;
466	ps2_queue(&s->common, AUX_ACK);
467	break;
468	case AUX_RESET:
469	s->mouse_sample_rate = 100;
470	s->mouse_resolution = 2;
471	s->mouse_status = 0;
472	s->mouse_type = 0;
473	ps2_queue(&s->common, AUX_ACK);
474	ps2_queue(&s->common, 0xaa);
475	ps2_queue(&s->common, s->mouse_type);
476	break;
477	default:
478	break;
479	}
480	break;
481	case AUX_SET_SAMPLE:
482	s->mouse_sample_rate = val;
483	/* detect IMPS/2 or IMEX */
484	switch(s->mouse_detect_state) {
485	default:
486	case 0:
487	if (val == 200)
488	s->mouse_detect_state = 1;
489	break;
490	case 1:
491	if (val == 100)
492	s->mouse_detect_state = 2;
493	else if (val == 200)
494	s->mouse_detect_state = 3;
495	else
496	s->mouse_detect_state = 0;
497	break;
498	case 2:
5fafdf24	499	if (val == 80)
0e43e99c FB	500	s->mouse_type = 3; /* IMPS/2 */
	501	s->mouse_detect_state = 0;
	502	break;
	503	case 3:
5fafdf24	504	if (val == 80)
0e43e99c FB	505	s->mouse_type = 4; /* IMEX */
	506	s->mouse_detect_state = 0;
	507	break;
	508	}
	509	ps2_queue(&s->common, AUX_ACK);
	510	s->common.write_cmd = -1;
	511	break;
	512	case AUX_SET_RES:
	513	s->mouse_resolution = val;
	514	ps2_queue(&s->common, AUX_ACK);
	515	s->common.write_cmd = -1;
	516	break;
	517	}
	518	}
	519
ef74679a	520	static void ps2_common_reset(PS2State *s)
0e43e99c	521	{
0e43e99c FB	522	PS2Queue *q;
	523	s->write_cmd = -1;
	524	q = &s->queue;
	525	q->rptr = 0;
	526	q->wptr = 0;
	527	q->count = 0;
deeccef3	528	s->update_irq(s->update_arg, 0);
0e43e99c FB	529	}
0e43e99c FB	530
ef74679a DS	531	static void ps2_kbd_reset(void *opaque)
	532	{
	533	PS2KbdState s = (PS2KbdState ) opaque;
	534
	535	ps2_common_reset(&s->common);
	536	s->scan_enabled = 0;
	537	s->translate = 0;
	538	s->scancode_set = 0;
	539	}
	540
	541	static void ps2_mouse_reset(void *opaque)
	542	{
	543	PS2MouseState s = (PS2MouseState ) opaque;
	544
	545	ps2_common_reset(&s->common);
	546	s->mouse_status = 0;
	547	s->mouse_resolution = 0;
	548	s->mouse_sample_rate = 0;
	549	s->mouse_wrap = 0;
	550	s->mouse_type = 0;
	551	s->mouse_detect_state = 0;
	552	s->mouse_dx = 0;
	553	s->mouse_dy = 0;
	554	s->mouse_dz = 0;
	555	s->mouse_buttons = 0;
	556	}
	557
b31442c3 JQ	558	static const VMStateDescription vmstate_ps2_common = {
	559	.name = "PS2 Common State",
	560	.version_id = 3,
	561	.minimum_version_id = 2,
	562	.minimum_version_id_old = 2,
	563	.fields = (VMStateField []) {
	564	VMSTATE_INT32(write_cmd, PS2State),
	565	VMSTATE_INT32(queue.rptr, PS2State),
	566	VMSTATE_INT32(queue.wptr, PS2State),
	567	VMSTATE_INT32(queue.count, PS2State),
	568	VMSTATE_BUFFER(queue.data, PS2State),
	569	VMSTATE_END_OF_LIST()
	570	}
	571	};
0e43e99c	572
7f540ab5 CF	573	static bool ps2_keyboard_ledstate_needed(void *opaque)
	574	{
	575	PS2KbdState *s = opaque;
	576
	577	return s->ledstate != 0; /* 0 is default state */
	578	}
	579
	580	static int ps2_kbd_ledstate_post_load(void *opaque, int version_id)
	581	{
	582	PS2KbdState *s = opaque;
	583
	584	kbd_put_ledstate(s->ledstate);
	585	return 0;
	586	}
	587
	588	static const VMStateDescription vmstate_ps2_keyboard_ledstate = {
	589	.name = "ps2kbd/ledstate",
	590	.version_id = 3,
	591	.minimum_version_id = 2,
	592	.minimum_version_id_old = 2,
	593	.post_load = ps2_kbd_ledstate_post_load,
	594	.fields = (VMStateField []) {
	595	VMSTATE_INT32(ledstate, PS2KbdState),
	596	VMSTATE_END_OF_LIST()
	597	}
	598	};
	599
db596c53	600	static int ps2_kbd_post_load(void* opaque, int version_id)
0e43e99c FB	601	{
0e43e99c FB	602	PS2KbdState s = (PS2KbdState)opaque;
7783e9f0	603
db596c53	604	if (version_id == 2)
e7d93956	605	s->scancode_set=2;
0e43e99c FB	606	return 0;
	607	}
	608
b31442c3 JQ	609	static const VMStateDescription vmstate_ps2_keyboard = {
	610	.name = "ps2kbd",
	611	.version_id = 3,
db596c53	612	.minimum_version_id = 2,
b31442c3	613	.minimum_version_id_old = 2,
db596c53	614	.post_load = ps2_kbd_post_load,
b31442c3 JQ	615	.fields = (VMStateField []) {
	616	VMSTATE_STRUCT(common, PS2KbdState, 0, vmstate_ps2_common, PS2State),
	617	VMSTATE_INT32(scan_enabled, PS2KbdState),
	618	VMSTATE_INT32(translate, PS2KbdState),
	619	VMSTATE_INT32_V(scancode_set, PS2KbdState,3),
	620	VMSTATE_END_OF_LIST()
7f540ab5 CF	621	},
	622	.subsections = (VMStateSubsection []) {
	623	{
	624	.vmsd = &vmstate_ps2_keyboard_ledstate,
	625	.needed = ps2_keyboard_ledstate_needed,
	626	}, {
	627	/* empty */
	628	}
b31442c3 JQ	629	}
b31442c3 JQ	630	};
7783e9f0	631
b31442c3 JQ	632	static const VMStateDescription vmstate_ps2_mouse = {
	633	.name = "ps2mouse",
	634	.version_id = 2,
	635	.minimum_version_id = 2,
	636	.minimum_version_id_old = 2,
	637	.fields = (VMStateField []) {
	638	VMSTATE_STRUCT(common, PS2MouseState, 0, vmstate_ps2_common, PS2State),
	639	VMSTATE_UINT8(mouse_status, PS2MouseState),
	640	VMSTATE_UINT8(mouse_resolution, PS2MouseState),
	641	VMSTATE_UINT8(mouse_sample_rate, PS2MouseState),
	642	VMSTATE_UINT8(mouse_wrap, PS2MouseState),
	643	VMSTATE_UINT8(mouse_type, PS2MouseState),
	644	VMSTATE_UINT8(mouse_detect_state, PS2MouseState),
	645	VMSTATE_INT32(mouse_dx, PS2MouseState),
	646	VMSTATE_INT32(mouse_dy, PS2MouseState),
	647	VMSTATE_INT32(mouse_dz, PS2MouseState),
	648	VMSTATE_UINT8(mouse_buttons, PS2MouseState),
	649	VMSTATE_END_OF_LIST()
	650	}
	651	};
0e43e99c FB	652
	653	void ps2_kbd_init(void (update_irq)(void , int), void update_arg)
	654	{
7267c094	655	PS2KbdState s = (PS2KbdState )g_malloc0(sizeof(PS2KbdState));
0e43e99c FB	656
	657	s->common.update_irq = update_irq;
	658	s->common.update_arg = update_arg;
e7d93956	659	s->scancode_set = 2;
0be71e32	660	vmstate_register(NULL, 0, &vmstate_ps2_keyboard, s);
0e43e99c	661	qemu_add_kbd_event_handler(ps2_put_keycode, s);
ef74679a	662	qemu_register_reset(ps2_kbd_reset, s);
0e43e99c FB	663	return s;
	664	}
	665
	666	void ps2_mouse_init(void (update_irq)(void , int), void update_arg)
	667	{
7267c094	668	PS2MouseState s = (PS2MouseState )g_malloc0(sizeof(PS2MouseState));
0e43e99c FB	669
	670	s->common.update_irq = update_irq;
	671	s->common.update_arg = update_arg;
0be71e32	672	vmstate_register(NULL, 0, &vmstate_ps2_mouse, s);
455204eb	673	qemu_add_mouse_event_handler(ps2_mouse_event, s, 0, "QEMU PS/2 Mouse");
ef74679a	674	qemu_register_reset(ps2_mouse_reset, s);
0e43e99c FB	675	return s;
0e43e99c FB	676	}