[qemu.git] / hw / adb.c

/*
 * QEMU ADB support
 *
 * Copyright (c) 2004 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 "ppc_mac.h"
#include "console.h"

/* debug ADB */
//#define DEBUG_ADB

#ifdef DEBUG_ADB
#define ADB_DPRINTF(fmt, ...) \
do { printf("ADB: " fmt , ## __VA_ARGS__); } while (0)
#else
#define ADB_DPRINTF(fmt, ...)
#endif

/* ADB commands */
#define ADB_BUSRESET		0x00
#define ADB_FLUSH               0x01
#define ADB_WRITEREG		0x08
#define ADB_READREG		0x0c

/* ADB device commands */
#define ADB_CMD_SELF_TEST		0xff
#define ADB_CMD_CHANGE_ID		0xfe
#define ADB_CMD_CHANGE_ID_AND_ACT	0xfd
#define ADB_CMD_CHANGE_ID_AND_ENABLE	0x00

/* ADB default device IDs (upper 4 bits of ADB command byte) */
#define ADB_DONGLE	1
#define ADB_KEYBOARD	2
#define ADB_MOUSE	3
#define ADB_TABLET	4
#define ADB_MODEM	5
#define ADB_MISC	7

/* error codes */
#define ADB_RET_NOTPRESENT (-2)

int adb_request(ADBBusState *s, uint8_t *obuf, const uint8_t *buf, int len)
{
    ADBDevice *d;
    int devaddr, cmd, i;

    cmd = buf[0] & 0xf;
    if (cmd == ADB_BUSRESET) {
        for(i = 0; i < s->nb_devices; i++) {
            d = &s->devices[i];
            if (d->devreset) {
                d->devreset(d);
            }
        }
        return 0;
    }
    devaddr = buf[0] >> 4;
    for(i = 0; i < s->nb_devices; i++) {
        d = &s->devices[i];
        if (d->devaddr == devaddr) {
            return d->devreq(d, obuf, buf, len);
        }
    }
    return ADB_RET_NOTPRESENT;
}

/* XXX: move that to cuda ? */
int adb_poll(ADBBusState *s, uint8_t *obuf)
{
    ADBDevice *d;
    int olen, i;
    uint8_t buf[1];

    olen = 0;
    for(i = 0; i < s->nb_devices; i++) {
        if (s->poll_index >= s->nb_devices)
            s->poll_index = 0;
        d = &s->devices[s->poll_index];
        buf[0] = ADB_READREG | (d->devaddr << 4);
        olen = adb_request(s, obuf + 1, buf, 1);
        /* if there is data, we poll again the same device */
        if (olen > 0) {
            obuf[0] = buf[0];
            olen++;
            break;
        }
        s->poll_index++;
    }
    return olen;
}

ADBDevice *adb_register_device(ADBBusState *s, int devaddr,
                               ADBDeviceRequest *devreq,
                               ADBDeviceReset *devreset,
                               void *opaque)
{
    ADBDevice *d;
    if (s->nb_devices >= MAX_ADB_DEVICES)
        return NULL;
    d = &s->devices[s->nb_devices++];
    d->bus = s;
    d->devaddr = devaddr;
    d->devreq = devreq;
    d->devreset = devreset;
    d->opaque = opaque;
    qemu_register_reset((QEMUResetHandler *)devreset, d);
    return d;
}

/***************************************************************/
/* Keyboard ADB device */

typedef struct KBDState {
    uint8_t data[128];
    int rptr, wptr, count;
} KBDState;

static const uint8_t pc_to_adb_keycode[256] = {
  0, 53, 18, 19, 20, 21, 23, 22, 26, 28, 25, 29, 27, 24, 51, 48,
 12, 13, 14, 15, 17, 16, 32, 34, 31, 35, 33, 30, 36, 54,  0,  1,
  2,  3,  5,  4, 38, 40, 37, 41, 39, 50, 56, 42,  6,  7,  8,  9,
 11, 45, 46, 43, 47, 44,123, 67, 58, 49, 57,122,120, 99,118, 96,
 97, 98,100,101,109, 71,107, 89, 91, 92, 78, 86, 87, 88, 69, 83,
 84, 85, 82, 65,  0,  0, 10,103,111,  0,  0,110, 81,  0,  0,  0,
  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
  0,  0,  0, 94,  0, 93,  0,  0,  0,  0,  0,  0,104,102,  0,  0,
  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 76,125,  0,  0,
  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,105,  0,  0,  0,  0,  0,
  0,  0,  0,  0,  0, 75,  0,  0,124,  0,  0,  0,  0,  0,  0,  0,
  0,  0,  0,  0,  0,  0,  0,115, 62,116,  0, 59,  0, 60,  0,119,
 61,121,114,117,  0,  0,  0,  0,  0,  0,  0, 55,126,  0,127,  0,
  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
  0,  0,  0,  0,  0, 95,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
};

static void adb_kbd_put_keycode(void *opaque, int keycode)
{
    ADBDevice *d = opaque;
    KBDState *s = d->opaque;

    if (s->count < sizeof(s->data)) {
        s->data[s->wptr] = keycode;
        if (++s->wptr == sizeof(s->data))
            s->wptr = 0;
        s->count++;
    }
}

static int adb_kbd_poll(ADBDevice *d, uint8_t *obuf)
{
    static int ext_keycode;
    KBDState *s = d->opaque;
    int adb_keycode, keycode;
    int olen;

    olen = 0;
    for(;;) {
        if (s->count == 0)
            break;
        keycode = s->data[s->rptr];
        if (++s->rptr == sizeof(s->data))
            s->rptr = 0;
        s->count--;

        if (keycode == 0xe0) {
            ext_keycode = 1;
        } else {
            if (ext_keycode)
                adb_keycode =  pc_to_adb_keycode[keycode | 0x80];
            else
                adb_keycode =  pc_to_adb_keycode[keycode & 0x7f];
            obuf[0] = adb_keycode | (keycode & 0x80);
            /* NOTE: could put a second keycode if needed */
            obuf[1] = 0xff;
            olen = 2;
            ext_keycode = 0;
            break;
        }
    }
    return olen;
}

static int adb_kbd_request(ADBDevice *d, uint8_t *obuf,
                           const uint8_t *buf, int len)
{
    KBDState *s = d->opaque;
    int cmd, reg, olen;

    if ((buf[0] & 0x0f) == ADB_FLUSH) {
        /* flush keyboard fifo */
        s->wptr = s->rptr = s->count = 0;
        return 0;
    }

    cmd = buf[0] & 0xc;
    reg = buf[0] & 0x3;
    olen = 0;
    switch(cmd) {
    case ADB_WRITEREG:
        switch(reg) {
        case 2:
            /* LED status */
            break;
        case 3:
            switch(buf[2]) {
            case ADB_CMD_SELF_TEST:
                break;
            case ADB_CMD_CHANGE_ID:
            case ADB_CMD_CHANGE_ID_AND_ACT:
            case ADB_CMD_CHANGE_ID_AND_ENABLE:
                d->devaddr = buf[1] & 0xf;
                break;
            default:
                /* XXX: check this */
                d->devaddr = buf[1] & 0xf;
                d->handler = buf[2];
                break;
            }
        }
        break;
    case ADB_READREG:
        switch(reg) {
        case 0:
            olen = adb_kbd_poll(d, obuf);
            break;
        case 1:
            break;
        case 2:
            obuf[0] = 0x00; /* XXX: check this */
            obuf[1] = 0x07; /* led status */
            olen = 2;
            break;
        case 3:
            obuf[0] = d->handler;
            obuf[1] = d->devaddr;
            olen = 2;
            break;
        }
        break;
    }
    return olen;
}

static void adb_kbd_save(QEMUFile *f, void *opaque)
{
    KBDState *s = (KBDState *)opaque;

    qemu_put_buffer(f, s->data, sizeof(s->data));
    qemu_put_sbe32s(f, &s->rptr);
    qemu_put_sbe32s(f, &s->wptr);
    qemu_put_sbe32s(f, &s->count);
}

static int adb_kbd_load(QEMUFile *f, void *opaque, int version_id)
{
    KBDState *s = (KBDState *)opaque;

    if (version_id != 1)
        return -EINVAL;

    qemu_get_buffer(f, s->data, sizeof(s->data));
    qemu_get_sbe32s(f, &s->rptr);
    qemu_get_sbe32s(f, &s->wptr);
    qemu_get_sbe32s(f, &s->count);

    return 0;
}

static int adb_kbd_reset(ADBDevice *d)
{
    KBDState *s = d->opaque;

    d->handler = 1;
    d->devaddr = ADB_KEYBOARD;
    memset(s, 0, sizeof(KBDState));

    return 0;
}

void adb_kbd_init(ADBBusState *bus)
{
    ADBDevice *d;
    KBDState *s;
    s = qemu_mallocz(sizeof(KBDState));
    d = adb_register_device(bus, ADB_KEYBOARD, adb_kbd_request,
                            adb_kbd_reset, s);
    qemu_add_kbd_event_handler(adb_kbd_put_keycode, d);
    register_savevm("adb_kbd", -1, 1, adb_kbd_save,
                    adb_kbd_load, s);
}

/***************************************************************/
/* Mouse ADB device */

typedef struct MouseState {
    int buttons_state, last_buttons_state;
    int dx, dy, dz;
} MouseState;

static void adb_mouse_event(void *opaque,
                            int dx1, int dy1, int dz1, int buttons_state)
{
    ADBDevice *d = opaque;
    MouseState *s = d->opaque;

    s->dx += dx1;
    s->dy += dy1;
    s->dz += dz1;
    s->buttons_state = buttons_state;
}


static int adb_mouse_poll(ADBDevice *d, uint8_t *obuf)
{
    MouseState *s = d->opaque;
    int dx, dy;

    if (s->last_buttons_state == s->buttons_state &&
        s->dx == 0 && s->dy == 0)
        return 0;

    dx = s->dx;
    if (dx < -63)
        dx = -63;
    else if (dx > 63)
        dx = 63;

    dy = s->dy;
    if (dy < -63)
        dy = -63;
    else if (dy > 63)
        dy = 63;

    s->dx -= dx;
    s->dy -= dy;
    s->last_buttons_state = s->buttons_state;

    dx &= 0x7f;
    dy &= 0x7f;

    if (!(s->buttons_state & MOUSE_EVENT_LBUTTON))
        dy |= 0x80;
    if (!(s->buttons_state & MOUSE_EVENT_RBUTTON))
        dx |= 0x80;

    obuf[0] = dy;
    obuf[1] = dx;
    return 2;
}

static int adb_mouse_request(ADBDevice *d, uint8_t *obuf,
                             const uint8_t *buf, int len)
{
    MouseState *s = d->opaque;
    int cmd, reg, olen;

    if ((buf[0] & 0x0f) == ADB_FLUSH) {
        /* flush mouse fifo */
        s->buttons_state = s->last_buttons_state;
        s->dx = 0;
        s->dy = 0;
        s->dz = 0;
        return 0;
    }

    cmd = buf[0] & 0xc;
    reg = buf[0] & 0x3;
    olen = 0;
    switch(cmd) {
    case ADB_WRITEREG:
        ADB_DPRINTF("write reg %d val 0x%2.2x\n", reg, buf[1]);
        switch(reg) {
        case 2:
            break;
        case 3:
            switch(buf[2]) {
            case ADB_CMD_SELF_TEST:
                break;
            case ADB_CMD_CHANGE_ID:
            case ADB_CMD_CHANGE_ID_AND_ACT:
            case ADB_CMD_CHANGE_ID_AND_ENABLE:
                d->devaddr = buf[1] & 0xf;
                break;
            default:
                /* XXX: check this */
                d->devaddr = buf[1] & 0xf;
                break;
            }
        }
        break;
    case ADB_READREG:
        switch(reg) {
        case 0:
            olen = adb_mouse_poll(d, obuf);
            break;
        case 1:
            break;
        case 3:
            obuf[0] = d->handler;
            obuf[1] = d->devaddr;
            olen = 2;
            break;
        }
        ADB_DPRINTF("read reg %d obuf[0] 0x%2.2x obuf[1] 0x%2.2x\n", reg,
                    obuf[0], obuf[1]);
        break;
    }
    return olen;
}

static int adb_mouse_reset(ADBDevice *d)
{
    MouseState *s = d->opaque;

    d->handler = 2;
    d->devaddr = ADB_MOUSE;
    memset(s, 0, sizeof(MouseState));

    return 0;
}

static void adb_mouse_save(QEMUFile *f, void *opaque)
{
    MouseState *s = (MouseState *)opaque;

    qemu_put_sbe32s(f, &s->buttons_state);
    qemu_put_sbe32s(f, &s->last_buttons_state);
    qemu_put_sbe32s(f, &s->dx);
    qemu_put_sbe32s(f, &s->dy);
    qemu_put_sbe32s(f, &s->dz);
}

static int adb_mouse_load(QEMUFile *f, void *opaque, int version_id)
{
    MouseState *s = (MouseState *)opaque;

    if (version_id != 1)
        return -EINVAL;

    qemu_get_sbe32s(f, &s->buttons_state);
    qemu_get_sbe32s(f, &s->last_buttons_state);
    qemu_get_sbe32s(f, &s->dx);
    qemu_get_sbe32s(f, &s->dy);
    qemu_get_sbe32s(f, &s->dz);

    return 0;
}

void adb_mouse_init(ADBBusState *bus)
{
    ADBDevice *d;
    MouseState *s;

    s = qemu_mallocz(sizeof(MouseState));
    d = adb_register_device(bus, ADB_MOUSE, adb_mouse_request,
                            adb_mouse_reset, s);
    qemu_add_mouse_event_handler(adb_mouse_event, d, 0, "QEMU ADB Mouse");
    register_savevm("adb_mouse", -1, 1, adb_mouse_save,
                    adb_mouse_load, s);
}
Commit	Line	Data
	1	/*
	2	* QEMU ADB support
	3	*
	4	* Copyright (c) 2004 Fabrice Bellard
	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	#include "hw.h"
	25	#include "ppc_mac.h"
	26	#include "console.h"
	27
	28	/* debug ADB */
	29	//#define DEBUG_ADB
	30
	31	#ifdef DEBUG_ADB
	32	#define ADB_DPRINTF(fmt, ...) \
	33	do { printf("ADB: " fmt , ## __VA_ARGS__); } while (0)
	34	#else
	35	#define ADB_DPRINTF(fmt, ...)
	36	#endif
	37
	38	/* ADB commands */
	39	#define ADB_BUSRESET 0x00
	40	#define ADB_FLUSH 0x01
	41	#define ADB_WRITEREG 0x08
	42	#define ADB_READREG 0x0c
	43
	44	/* ADB device commands */
	45	#define ADB_CMD_SELF_TEST 0xff
	46	#define ADB_CMD_CHANGE_ID 0xfe
	47	#define ADB_CMD_CHANGE_ID_AND_ACT 0xfd
	48	#define ADB_CMD_CHANGE_ID_AND_ENABLE 0x00
	49
	50	/* ADB default device IDs (upper 4 bits of ADB command byte) */
	51	#define ADB_DONGLE 1
	52	#define ADB_KEYBOARD 2
	53	#define ADB_MOUSE 3
	54	#define ADB_TABLET 4
	55	#define ADB_MODEM 5
	56	#define ADB_MISC 7
	57
	58	/* error codes */
	59	#define ADB_RET_NOTPRESENT (-2)
	60
	61	int adb_request(ADBBusState s, uint8_t obuf, const uint8_t *buf, int len)
	62	{
	63	ADBDevice *d;
	64	int devaddr, cmd, i;
	65
	66	cmd = buf[0] & 0xf;
	67	if (cmd == ADB_BUSRESET) {
	68	for(i = 0; i < s->nb_devices; i++) {
	69	d = &s->devices[i];
	70	if (d->devreset) {
	71	d->devreset(d);
	72	}
	73	}
	74	return 0;
	75	}
	76	devaddr = buf[0] >> 4;
	77	for(i = 0; i < s->nb_devices; i++) {
	78	d = &s->devices[i];
	79	if (d->devaddr == devaddr) {
	80	return d->devreq(d, obuf, buf, len);
	81	}
	82	}
	83	return ADB_RET_NOTPRESENT;
	84	}
	85
	86	/* XXX: move that to cuda ? */
	87	int adb_poll(ADBBusState s, uint8_t obuf)
	88	{
	89	ADBDevice *d;
	90	int olen, i;
	91	uint8_t buf[1];
	92
	93	olen = 0;
	94	for(i = 0; i < s->nb_devices; i++) {
	95	if (s->poll_index >= s->nb_devices)
	96	s->poll_index = 0;
	97	d = &s->devices[s->poll_index];
	98	buf[0] = ADB_READREG \| (d->devaddr << 4);
	99	olen = adb_request(s, obuf + 1, buf, 1);
	100	/* if there is data, we poll again the same device */
	101	if (olen > 0) {
	102	obuf[0] = buf[0];
	103	olen++;
	104	break;
	105	}
	106	s->poll_index++;
	107	}
	108	return olen;
	109	}
	110
	111	ADBDevice adb_register_device(ADBBusState s, int devaddr,
	112	ADBDeviceRequest *devreq,
	113	ADBDeviceReset *devreset,
	114	void *opaque)
	115	{
	116	ADBDevice *d;
	117	if (s->nb_devices >= MAX_ADB_DEVICES)
	118	return NULL;
	119	d = &s->devices[s->nb_devices++];
	120	d->bus = s;
	121	d->devaddr = devaddr;
	122	d->devreq = devreq;
	123	d->devreset = devreset;
	124	d->opaque = opaque;
	125	qemu_register_reset((QEMUResetHandler *)devreset, d);
	126	return d;
	127	}
	128
	129	/***************************************************************/
	130	/* Keyboard ADB device */
	131
	132	typedef struct KBDState {
	133	uint8_t data[128];
	134	int rptr, wptr, count;
	135	} KBDState;
	136
	137	static const uint8_t pc_to_adb_keycode[256] = {
	138	0, 53, 18, 19, 20, 21, 23, 22, 26, 28, 25, 29, 27, 24, 51, 48,
	139	12, 13, 14, 15, 17, 16, 32, 34, 31, 35, 33, 30, 36, 54, 0, 1,
	140	2, 3, 5, 4, 38, 40, 37, 41, 39, 50, 56, 42, 6, 7, 8, 9,
	141	11, 45, 46, 43, 47, 44,123, 67, 58, 49, 57,122,120, 99,118, 96,
	142	97, 98,100,101,109, 71,107, 89, 91, 92, 78, 86, 87, 88, 69, 83,
	143	84, 85, 82, 65, 0, 0, 10,103,111, 0, 0,110, 81, 0, 0, 0,
	144	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	145	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	146	0, 0, 0, 94, 0, 93, 0, 0, 0, 0, 0, 0,104,102, 0, 0,
	147	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 76,125, 0, 0,
	148	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,105, 0, 0, 0, 0, 0,
	149	0, 0, 0, 0, 0, 75, 0, 0,124, 0, 0, 0, 0, 0, 0, 0,
	150	0, 0, 0, 0, 0, 0, 0,115, 62,116, 0, 59, 0, 60, 0,119,
	151	61,121,114,117, 0, 0, 0, 0, 0, 0, 0, 55,126, 0,127, 0,
	152	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	153	0, 0, 0, 0, 0, 95, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	154	};
	155
	156	static void adb_kbd_put_keycode(void *opaque, int keycode)
	157	{
	158	ADBDevice *d = opaque;
	159	KBDState *s = d->opaque;
	160
	161	if (s->count < sizeof(s->data)) {
	162	s->data[s->wptr] = keycode;
	163	if (++s->wptr == sizeof(s->data))
	164	s->wptr = 0;
	165	s->count++;
	166	}
	167	}
	168
	169	static int adb_kbd_poll(ADBDevice d, uint8_t obuf)
	170	{
	171	static int ext_keycode;
	172	KBDState *s = d->opaque;
	173	int adb_keycode, keycode;
	174	int olen;
	175
	176	olen = 0;
	177	for(;;) {
	178	if (s->count == 0)
	179	break;
	180	keycode = s->data[s->rptr];
	181	if (++s->rptr == sizeof(s->data))
	182	s->rptr = 0;
	183	s->count--;
	184
	185	if (keycode == 0xe0) {
	186	ext_keycode = 1;
	187	} else {
	188	if (ext_keycode)
	189	adb_keycode = pc_to_adb_keycode[keycode \| 0x80];
	190	else
	191	adb_keycode = pc_to_adb_keycode[keycode & 0x7f];
	192	obuf[0] = adb_keycode \| (keycode & 0x80);
	193	/* NOTE: could put a second keycode if needed */
	194	obuf[1] = 0xff;
	195	olen = 2;
	196	ext_keycode = 0;
	197	break;
	198	}
	199	}
	200	return olen;
	201	}
	202
	203	static int adb_kbd_request(ADBDevice d, uint8_t obuf,
	204	const uint8_t *buf, int len)
	205	{
	206	KBDState *s = d->opaque;
	207	int cmd, reg, olen;
	208
	209	if ((buf[0] & 0x0f) == ADB_FLUSH) {
	210	/* flush keyboard fifo */
	211	s->wptr = s->rptr = s->count = 0;
	212	return 0;
	213	}
	214
	215	cmd = buf[0] & 0xc;
	216	reg = buf[0] & 0x3;
	217	olen = 0;
	218	switch(cmd) {
	219	case ADB_WRITEREG:
	220	switch(reg) {
	221	case 2:
	222	/* LED status */
	223	break;
	224	case 3:
	225	switch(buf[2]) {
	226	case ADB_CMD_SELF_TEST:
	227	break;
	228	case ADB_CMD_CHANGE_ID:
	229	case ADB_CMD_CHANGE_ID_AND_ACT:
	230	case ADB_CMD_CHANGE_ID_AND_ENABLE:
	231	d->devaddr = buf[1] & 0xf;
	232	break;
	233	default:
	234	/* XXX: check this */
	235	d->devaddr = buf[1] & 0xf;
	236	d->handler = buf[2];
	237	break;
	238	}
	239	}
	240	break;
	241	case ADB_READREG:
	242	switch(reg) {
	243	case 0:
	244	olen = adb_kbd_poll(d, obuf);
	245	break;
	246	case 1:
	247	break;
	248	case 2:
	249	obuf[0] = 0x00; /* XXX: check this */
	250	obuf[1] = 0x07; /* led status */
	251	olen = 2;
	252	break;
	253	case 3:
	254	obuf[0] = d->handler;
	255	obuf[1] = d->devaddr;
	256	olen = 2;
	257	break;
	258	}
	259	break;
	260	}
	261	return olen;
	262	}
	263
	264	static void adb_kbd_save(QEMUFile f, void opaque)
	265	{
	266	KBDState s = (KBDState )opaque;
	267
	268	qemu_put_buffer(f, s->data, sizeof(s->data));
	269	qemu_put_sbe32s(f, &s->rptr);
	270	qemu_put_sbe32s(f, &s->wptr);
	271	qemu_put_sbe32s(f, &s->count);
	272	}
	273
	274	static int adb_kbd_load(QEMUFile f, void opaque, int version_id)
	275	{
	276	KBDState s = (KBDState )opaque;
	277
	278	if (version_id != 1)
	279	return -EINVAL;
	280
	281	qemu_get_buffer(f, s->data, sizeof(s->data));
	282	qemu_get_sbe32s(f, &s->rptr);
	283	qemu_get_sbe32s(f, &s->wptr);
	284	qemu_get_sbe32s(f, &s->count);
	285
	286	return 0;
	287	}
	288
	289	static int adb_kbd_reset(ADBDevice *d)
	290	{
	291	KBDState *s = d->opaque;
	292
	293	d->handler = 1;
	294	d->devaddr = ADB_KEYBOARD;
	295	memset(s, 0, sizeof(KBDState));
	296
	297	return 0;
	298	}
	299
	300	void adb_kbd_init(ADBBusState *bus)
	301	{
	302	ADBDevice *d;
	303	KBDState *s;
	304	s = qemu_mallocz(sizeof(KBDState));
	305	d = adb_register_device(bus, ADB_KEYBOARD, adb_kbd_request,
	306	adb_kbd_reset, s);
	307	qemu_add_kbd_event_handler(adb_kbd_put_keycode, d);
	308	register_savevm("adb_kbd", -1, 1, adb_kbd_save,
	309	adb_kbd_load, s);
	310	}
	311
	312	/***************************************************************/
	313	/* Mouse ADB device */
	314
	315	typedef struct MouseState {
	316	int buttons_state, last_buttons_state;
	317	int dx, dy, dz;
	318	} MouseState;
	319
	320	static void adb_mouse_event(void *opaque,
	321	int dx1, int dy1, int dz1, int buttons_state)
	322	{
	323	ADBDevice *d = opaque;
	324	MouseState *s = d->opaque;
	325
	326	s->dx += dx1;
	327	s->dy += dy1;
	328	s->dz += dz1;
	329	s->buttons_state = buttons_state;
	330	}
	331
	332
	333	static int adb_mouse_poll(ADBDevice d, uint8_t obuf)
	334	{
	335	MouseState *s = d->opaque;
	336	int dx, dy;
	337
	338	if (s->last_buttons_state == s->buttons_state &&
	339	s->dx == 0 && s->dy == 0)
	340	return 0;
	341
	342	dx = s->dx;
	343	if (dx < -63)
	344	dx = -63;
	345	else if (dx > 63)
	346	dx = 63;
	347
	348	dy = s->dy;
	349	if (dy < -63)
	350	dy = -63;
	351	else if (dy > 63)
	352	dy = 63;
	353
	354	s->dx -= dx;
	355	s->dy -= dy;
	356	s->last_buttons_state = s->buttons_state;
	357
	358	dx &= 0x7f;
	359	dy &= 0x7f;
	360
	361	if (!(s->buttons_state & MOUSE_EVENT_LBUTTON))
	362	dy \|= 0x80;
	363	if (!(s->buttons_state & MOUSE_EVENT_RBUTTON))
	364	dx \|= 0x80;
	365
	366	obuf[0] = dy;
	367	obuf[1] = dx;
	368	return 2;
	369	}
	370
	371	static int adb_mouse_request(ADBDevice d, uint8_t obuf,
	372	const uint8_t *buf, int len)
	373	{
	374	MouseState *s = d->opaque;
	375	int cmd, reg, olen;
	376
	377	if ((buf[0] & 0x0f) == ADB_FLUSH) {
	378	/* flush mouse fifo */
	379	s->buttons_state = s->last_buttons_state;
	380	s->dx = 0;
	381	s->dy = 0;
	382	s->dz = 0;
	383	return 0;
	384	}
	385
	386	cmd = buf[0] & 0xc;
	387	reg = buf[0] & 0x3;
	388	olen = 0;
	389	switch(cmd) {
	390	case ADB_WRITEREG:
	391	ADB_DPRINTF("write reg %d val 0x%2.2x\n", reg, buf[1]);
	392	switch(reg) {
	393	case 2:
	394	break;
	395	case 3:
	396	switch(buf[2]) {
	397	case ADB_CMD_SELF_TEST:
	398	break;
	399	case ADB_CMD_CHANGE_ID:
	400	case ADB_CMD_CHANGE_ID_AND_ACT:
	401	case ADB_CMD_CHANGE_ID_AND_ENABLE:
	402	d->devaddr = buf[1] & 0xf;
	403	break;
	404	default:
	405	/* XXX: check this */
	406	d->devaddr = buf[1] & 0xf;
	407	break;
	408	}
	409	}
	410	break;
	411	case ADB_READREG:
	412	switch(reg) {
	413	case 0:
	414	olen = adb_mouse_poll(d, obuf);
	415	break;
	416	case 1:
	417	break;
	418	case 3:
	419	obuf[0] = d->handler;
	420	obuf[1] = d->devaddr;
	421	olen = 2;
	422	break;
	423	}
	424	ADB_DPRINTF("read reg %d obuf[0] 0x%2.2x obuf[1] 0x%2.2x\n", reg,
	425	obuf[0], obuf[1]);
	426	break;
	427	}
	428	return olen;
	429	}
	430
	431	static int adb_mouse_reset(ADBDevice *d)
	432	{
	433	MouseState *s = d->opaque;
	434
	435	d->handler = 2;
	436	d->devaddr = ADB_MOUSE;
	437	memset(s, 0, sizeof(MouseState));
	438
	439	return 0;
	440	}
	441
	442	static void adb_mouse_save(QEMUFile f, void opaque)
	443	{
	444	MouseState s = (MouseState )opaque;
	445
	446	qemu_put_sbe32s(f, &s->buttons_state);
	447	qemu_put_sbe32s(f, &s->last_buttons_state);
	448	qemu_put_sbe32s(f, &s->dx);
	449	qemu_put_sbe32s(f, &s->dy);
	450	qemu_put_sbe32s(f, &s->dz);
	451	}
	452
	453	static int adb_mouse_load(QEMUFile f, void opaque, int version_id)
	454	{
	455	MouseState s = (MouseState )opaque;
	456
	457	if (version_id != 1)
	458	return -EINVAL;
	459
	460	qemu_get_sbe32s(f, &s->buttons_state);
	461	qemu_get_sbe32s(f, &s->last_buttons_state);
	462	qemu_get_sbe32s(f, &s->dx);
	463	qemu_get_sbe32s(f, &s->dy);
	464	qemu_get_sbe32s(f, &s->dz);
	465
	466	return 0;
	467	}
	468
	469	void adb_mouse_init(ADBBusState *bus)
	470	{
	471	ADBDevice *d;
	472	MouseState *s;
	473
	474	s = qemu_mallocz(sizeof(MouseState));
	475	d = adb_register_device(bus, ADB_MOUSE, adb_mouse_request,
	476	adb_mouse_reset, s);
	477	qemu_add_mouse_event_handler(adb_mouse_event, d, 0, "QEMU ADB Mouse");
	478	register_savevm("adb_mouse", -1, 1, adb_mouse_save,
	479	adb_mouse_load, s);
	480	}