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