[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.h"
#include "ps2.h"
#include "console.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_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 */
} 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
};

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 in scancode set 2 */
static void ps2_put_keycode(void *opaque, int keycode)
{
    PS2KbdState *s = opaque;

    /* XXX: add support for scancode sets 1 and 3 */
    if (!s->translate && keycode < 0xe0 && s->scancode_set == 2)
      {
        if (keycode & 0x80)
            ps2_queue(&s->common, 0xf0);
        keycode = ps2_raw_keycode[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_reset_keyboard(PS2KbdState *s)
{
    s->scan_enabled = 1;
    s->scancode_set = 2;
}

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_put_keycode(s, 0xab);
            ps2_put_keycode(s, 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_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 (!(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_reset(void *opaque)
{
    PS2State *s = (PS2State *)opaque;
    PS2Queue *q;
    s->write_cmd = -1;
    q = &s->queue;
    q->rptr = 0;
    q->wptr = 0;
    q->count = 0;
}

static void ps2_common_save (QEMUFile *f, PS2State *s)
{
    qemu_put_be32 (f, s->write_cmd);
    qemu_put_be32 (f, s->queue.rptr);
    qemu_put_be32 (f, s->queue.wptr);
    qemu_put_be32 (f, s->queue.count);
    qemu_put_buffer (f, s->queue.data, sizeof (s->queue.data));
}

static void ps2_common_load (QEMUFile *f, PS2State *s)
{
    s->write_cmd=qemu_get_be32 (f);
    s->queue.rptr=qemu_get_be32 (f);
    s->queue.wptr=qemu_get_be32 (f);
    s->queue.count=qemu_get_be32 (f);
    qemu_get_buffer (f, s->queue.data, sizeof (s->queue.data));
}

static void ps2_kbd_save(QEMUFile* f, void* opaque)
{
    PS2KbdState *s = (PS2KbdState*)opaque;

    ps2_common_save (f, &s->common);
    qemu_put_be32(f, s->scan_enabled);
    qemu_put_be32(f, s->translate);
    qemu_put_be32(f, s->scancode_set);
}

static void ps2_mouse_save(QEMUFile* f, void* opaque)
{
    PS2MouseState *s = (PS2MouseState*)opaque;

    ps2_common_save (f, &s->common);
    qemu_put_8s(f, &s->mouse_status);
    qemu_put_8s(f, &s->mouse_resolution);
    qemu_put_8s(f, &s->mouse_sample_rate);
    qemu_put_8s(f, &s->mouse_wrap);
    qemu_put_8s(f, &s->mouse_type);
    qemu_put_8s(f, &s->mouse_detect_state);
    qemu_put_be32(f, s->mouse_dx);
    qemu_put_be32(f, s->mouse_dy);
    qemu_put_be32(f, s->mouse_dz);
    qemu_put_8s(f, &s->mouse_buttons);
}

static int ps2_kbd_load(QEMUFile* f, void* opaque, int version_id)
{
    PS2KbdState *s = (PS2KbdState*)opaque;

    if (version_id != 2 && version_id != 3)
        return -EINVAL;

    ps2_common_load (f, &s->common);
    s->scan_enabled=qemu_get_be32(f);
    s->translate=qemu_get_be32(f);
    if (version_id == 3)
        s->scancode_set=qemu_get_be32(f);
    else
        s->scancode_set=2;
    return 0;
}

static int ps2_mouse_load(QEMUFile* f, void* opaque, int version_id)
{
    PS2MouseState *s = (PS2MouseState*)opaque;

    if (version_id != 2)
        return -EINVAL;

    ps2_common_load (f, &s->common);
    qemu_get_8s(f, &s->mouse_status);
    qemu_get_8s(f, &s->mouse_resolution);
    qemu_get_8s(f, &s->mouse_sample_rate);
    qemu_get_8s(f, &s->mouse_wrap);
    qemu_get_8s(f, &s->mouse_type);
    qemu_get_8s(f, &s->mouse_detect_state);
    s->mouse_dx=qemu_get_be32(f);
    s->mouse_dy=qemu_get_be32(f);
    s->mouse_dz=qemu_get_be32(f);
    qemu_get_8s(f, &s->mouse_buttons);
    return 0;
}

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

    s->common.update_irq = update_irq;
    s->common.update_arg = update_arg;
    s->scancode_set = 2;
    ps2_reset(&s->common);
    register_savevm("ps2kbd", 0, 3, ps2_kbd_save, ps2_kbd_load, s);
    qemu_add_kbd_event_handler(ps2_put_keycode, s);
    qemu_register_reset(ps2_reset, &s->common);
    return s;
}

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

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