input/fakehid.c - platform/external/bluetooth/bluez - Git at Google

 /*
  *
  *  BlueZ - Bluetooth protocol stack for Linux
  *
  *  Copyright (C) 2004-2010  Marcel Holtmann <marcel@holtmann.org>
  *
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  *
  */

 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif

 #include <stdio.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <unistd.h>
 #include <stdlib.h>
 #include <sys/types.h>

 #include <bluetooth/bluetooth.h>
 #include <bluetooth/hidp.h>
 #include <bluetooth/sdp.h>

 #include <glib.h>
 #include <dbus/dbus.h>

 #include "../src/adapter.h"
 #include "../src/device.h"

 #include "log.h"
 #include "device.h"
 #include "fakehid.h"
 #include "uinput.h"

 #define PS3_FLAGS_MASK 0xFFFFFF00

 enum ps3remote_special_keys {
 	PS3R_BIT_PS = 0,
 	PS3R_BIT_ENTER = 3,
 	PS3R_BIT_L2 = 8,
 	PS3R_BIT_R2 = 9,
 	PS3R_BIT_L1 = 10,
 	PS3R_BIT_R1 = 11,
 	PS3R_BIT_TRIANGLE = 12,
 	PS3R_BIT_CIRCLE = 13,
 	PS3R_BIT_CROSS = 14,
 	PS3R_BIT_SQUARE = 15,
 	PS3R_BIT_SELECT = 16,
 	PS3R_BIT_L3 = 17,
 	PS3R_BIT_R3 = 18,
 	PS3R_BIT_START = 19,
 	PS3R_BIT_UP = 20,
 	PS3R_BIT_RIGHT = 21,
 	PS3R_BIT_DOWN = 22,
 	PS3R_BIT_LEFT = 23,
 };

 static unsigned int ps3remote_bits[] = {
 	[PS3R_BIT_ENTER] = 0x0b,
 	[PS3R_BIT_PS] = 0x43,
 	[PS3R_BIT_SQUARE] = 0x5f,
 	[PS3R_BIT_CROSS] = 0x5e,
 	[PS3R_BIT_CIRCLE] = 0x5d,
 	[PS3R_BIT_TRIANGLE] = 0x5c,
 	[PS3R_BIT_R1] = 0x5b,
 	[PS3R_BIT_L1] = 0x5a,
 	[PS3R_BIT_R2] = 0x59,
 	[PS3R_BIT_L2] = 0x58,
 	[PS3R_BIT_LEFT] = 0x57,
 	[PS3R_BIT_DOWN] = 0x56,
 	[PS3R_BIT_RIGHT] = 0x55,
 	[PS3R_BIT_UP] = 0x54,
 	[PS3R_BIT_START] = 0x53,
 	[PS3R_BIT_R3] = 0x52,
 	[PS3R_BIT_L3] = 0x51,
 	[PS3R_BIT_SELECT] = 0x50,
 };

 static unsigned int ps3remote_keymap[] = {
 	[0x16] = KEY_EJECTCD,
 	[0x64] = KEY_AUDIO,
 	[0x65] = KEY_ANGLE,
 	[0x63] = KEY_SUBTITLE,
 	[0x0f] = KEY_CLEAR,
 	[0x28] = KEY_TIME,
 	[0x00] = KEY_1,
 	[0x01] = KEY_2,
 	[0x02] = KEY_3,
 	[0x03] = KEY_4,
 	[0x04] = KEY_5,
 	[0x05] = KEY_6,
 	[0x06] = KEY_7,
 	[0x07] = KEY_8,
 	[0x08] = KEY_9,
 	[0x09] = KEY_0,
 	[0x81] = KEY_RED,
 	[0x82] = KEY_GREEN,
 	[0x80] = KEY_BLUE,
 	[0x83] = KEY_YELLOW,
 	[0x70] = KEY_INFO,		/* display */
 	[0x1a] = KEY_MENU,		/* top menu */
 	[0x40] = KEY_CONTEXT_MENU,	/* pop up/menu */
 	[0x0e] = KEY_ESC,		/* return */
 	[0x5c] = KEY_OPTION,		/* options/triangle */
 	[0x5d] = KEY_BACK,		/* back/circle */
 	[0x5f] = KEY_SCREEN,		/* view/square */
 	[0x5e] = BTN_0,			/* cross */
 	[0x54] = KEY_UP,
 	[0x56] = KEY_DOWN,
 	[0x57] = KEY_LEFT,
 	[0x55] = KEY_RIGHT,
 	[0x0b] = KEY_ENTER,
 	[0x5a] = BTN_TL,		/* L1 */
 	[0x58] = BTN_TL2,		/* L2 */
 	[0x51] = BTN_THUMBL,		/* L3 */
 	[0x5b] = BTN_TR,		/* R1 */
 	[0x59] = BTN_TR2,		/* R2 */
 	[0x52] = BTN_THUMBR,		/* R3 */
 	[0x43] = KEY_HOMEPAGE,		/* PS button */
 	[0x50] = KEY_SELECT,
 	[0x53] = BTN_START,
 	[0x33] = KEY_REWIND,		/* scan back */
 	[0x32] = KEY_PLAY,
 	[0x34] = KEY_FORWARD,		/* scan forward */
 	[0x30] = KEY_PREVIOUS,
 	[0x38] = KEY_STOP,
 	[0x31] = KEY_NEXT,
 	[0x60] = KEY_FRAMEBACK,		/* slow/step back */
 	[0x39] = KEY_PAUSE,
 	[0x61] = KEY_FRAMEFORWARD,	/* slow/step forward */
 	[0xff] = KEY_MAX,
 };

 static int ps3remote_decode(char *buff, int size, unsigned int *value)
 {
 	static unsigned int lastkey = 0;
 	static unsigned int lastmask = 0;
 	unsigned int i, mask;
 	int retval;
 	guint8 key;

 	if (size < 12) {
 		error("Got a shorter packet! (size %i)\n", size);
 		return KEY_RESERVED;
 	}

 	mask = (buff[2] << 16) + (buff[3] << 8) + buff[4];
 	key = buff[5];

 	/* first, check flags */
 	for (i = 0; i < 24; i++) {
 		if ((lastmask & (1 << i)) == (mask & (1 << i)))
 			continue;
 		if (ps3remote_bits[i] == 0)
 			goto error;
 		retval = ps3remote_keymap[ps3remote_bits[i]];
 		if (mask & (1 << i))
 			/* key pressed */
 			*value = 1;
 		else
 			/* key released */
 			*value = 0;

 		goto out;
 	}

 	*value = buff[11];
 	if (buff[11] == 1) {
 		retval = ps3remote_keymap[key];
 	} else
 		retval = lastkey;

 	if (retval == KEY_RESERVED)
 		goto error;
 	if (retval == KEY_MAX)
 		return retval;

 	lastkey = retval;

 out:
 	fflush(stdout);

 	lastmask = mask;

 	return retval;

 error:
 	error("ps3remote: unrecognized sequence [%#x][%#x][%#x][%#x] [%#x],"
 			"last: [%#x][%#x][%#x][%#x]",
 			buff[2], buff[3], buff[4], buff[5], buff[11],
 				lastmask >> 16, lastmask >> 8 & 0xff,
 						lastmask & 0xff, lastkey);
 	return -1;
 }

 static gboolean ps3remote_event(GIOChannel *chan, GIOCondition cond,
 				gpointer data)
 {
 	struct fake_input *fake = data;
 	struct uinput_event event;
 	unsigned int key, value = 0;
 	ssize_t size;
 	char buff[50];
 	int fd;

 	if (cond & G_IO_NVAL)
 		return FALSE;

 	if (cond & (G_IO_HUP | G_IO_ERR)) {
 		error("Hangup or error on rfcomm server socket");
 		goto failed;
 	}

 	fd = g_io_channel_unix_get_fd(chan);

 	memset(buff, 0, sizeof(buff));
 	size = read(fd, buff, sizeof(buff));
 	if (size < 0) {
 		error("IO Channel read error");
 		goto failed;
 	}

 	key = ps3remote_decode(buff, size, &value);
 	if (key == KEY_RESERVED) {
 		error("Got invalid key from decode");
 		goto failed;
 	} else if (key == KEY_MAX)
 		return TRUE;

 	memset(&event, 0, sizeof(event));
 	gettimeofday(&event.time, NULL);
 	event.type = EV_KEY;
 	event.code = key;
 	event.value = value;
 	if (write(fake->uinput, &event, sizeof(event)) != sizeof(event)) {
 		error("Error writing to uinput device");
 		goto failed;
 	}

 	memset(&event, 0, sizeof(event));
 	gettimeofday(&event.time, NULL);
 	event.type = EV_SYN;
 	event.code = SYN_REPORT;
 	if (write(fake->uinput, &event, sizeof(event)) != sizeof(event)) {
 		error("Error writing to uinput device");
 		goto failed;
 	}

 	return TRUE;

 failed:
 	ioctl(fake->uinput, UI_DEV_DESTROY);
 	close(fake->uinput);
 	fake->uinput = -1;
 	g_io_channel_unref(fake->io);

 	return FALSE;
 }

 static int ps3remote_setup_uinput(struct fake_input *fake,
 						struct fake_hid *fake_hid)
 {
 	struct uinput_dev dev;
 	int i;

 	fake->uinput = open("/dev/input/uinput", O_RDWR);
 	if (fake->uinput < 0) {
 		fake->uinput = open("/dev/uinput", O_RDWR);
 		if (fake->uinput < 0) {
 			fake->uinput = open("/dev/misc/uinput", O_RDWR);
 			if (fake->uinput < 0) {
 				error("Error opening uinput device file");
 				return 1;
 			}
 		}
 	}

 	memset(&dev, 0, sizeof(dev));
 	snprintf(dev.name, sizeof(dev.name), "%s", "PS3 Remote Controller");
 	dev.id.bustype = BUS_BLUETOOTH;
 	dev.id.vendor = fake_hid->vendor;
 	dev.id.product = fake_hid->product;

 	if (write(fake->uinput, &dev, sizeof(dev)) != sizeof(dev)) {
 		error("Error creating uinput device");
 		goto err;
 	}

 	/* enabling key events */
 	if (ioctl(fake->uinput, UI_SET_EVBIT, EV_KEY) < 0) {
 		error("Error enabling uinput device key events");
 		goto err;
 	}

 	/* enabling keys */
 	for (i = 0; i < 256; i++)
 		if (ps3remote_keymap[i] != KEY_RESERVED)
 			if (ioctl(fake->uinput, UI_SET_KEYBIT,
 						ps3remote_keymap[i]) < 0) {
 				error("Error enabling uinput key %i",
 							ps3remote_keymap[i]);
 				goto err;
 			}

 	/* creating the device */
 	if (ioctl(fake->uinput, UI_DEV_CREATE) < 0) {
 		error("Error creating uinput device");
 		goto err;
 	}

 	return 0;

 err:
 	close(fake->uinput);
 	return 1;
 }

 static gboolean fake_hid_common_connect(struct fake_input *fake, GError **err)
 {
 	return TRUE;
 }

 static int fake_hid_common_disconnect(struct fake_input *fake)
 {
 	return 0;
 }

 static struct fake_hid fake_hid_table[] = {
 	/* Sony PS3 remote device */
 	{
 		.vendor		= 0x054c,
 		.product	= 0x0306,
 		.connect	= fake_hid_common_connect,
 		.disconnect	= fake_hid_common_disconnect,
 		.event		= ps3remote_event,
 		.setup_uinput	= ps3remote_setup_uinput,
 		.devices	= NULL,
 	},

 	{ },
 };

 static inline int fake_hid_match_device(uint16_t vendor, uint16_t product,
 							struct fake_hid *fhid)
 {
 	return vendor == fhid->vendor && product == fhid->product;
 }

 struct fake_hid *get_fake_hid(uint16_t vendor, uint16_t product)
 {
 	int i;

 	for (i = 0; fake_hid_table[i].vendor != 0; i++)
 		if (fake_hid_match_device(vendor, product, &fake_hid_table[i]))
 			return &fake_hid_table[i];

 	return NULL;
 }

 struct fake_input *fake_hid_connadd(struct fake_input *fake,
 						GIOChannel *intr_io,
 						struct fake_hid *fake_hid)
 {
 	GList *l;
 	struct fake_input *old = NULL;

 	/* Look for an already setup device */
 	for (l = fake_hid->devices; l != NULL; l = l->next) {
 		old = l->data;
 		if (old->idev == fake->idev) {
 			g_free(fake);
 			fake = old;
 			fake_hid->connect(fake, NULL);
 			break;
 		}
 		old = NULL;
 	}

 	/* New device? Add it to the list of known devices,
 	 * and create the uinput necessary */
 	if (old == NULL) {
 		if (fake_hid->setup_uinput(fake, fake_hid)) {
 			error("Error setting up uinput");
 			g_free(fake);
 			return NULL;
 		}
 		fake_hid->devices = g_list_append(fake_hid->devices, fake);
 	}

 	fake->io = g_io_channel_ref(intr_io);
 	g_io_channel_set_close_on_unref(fake->io, TRUE);
 	g_io_add_watch(fake->io, G_IO_IN | G_IO_ERR | G_IO_HUP | G_IO_NVAL,
 					(GIOFunc) fake_hid->event, fake);

 	return fake;
 }
	/*
	*
	* BlueZ - Bluetooth protocol stack for Linux
	*
	* Copyright (C) 2004-2010 Marcel Holtmann <marcel@holtmann.org>
	*
	*
	* This program is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation; either version 2 of the License, or
	* (at your option) any later version.
	*
	* This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with this program; if not, write to the Free Software
	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	*
	*/

	#ifdef HAVE_CONFIG_H
	#include <config.h>
	#endif

	#include <stdio.h>
	#include <errno.h>
	#include <fcntl.h>
	#include <unistd.h>
	#include <stdlib.h>
	#include <sys/types.h>

	#include <bluetooth/bluetooth.h>
	#include <bluetooth/hidp.h>
	#include <bluetooth/sdp.h>

	#include <glib.h>
	#include <dbus/dbus.h>

	#include "../src/adapter.h"
	#include "../src/device.h"

	#include "log.h"
	#include "device.h"
	#include "fakehid.h"
	#include "uinput.h"

	#define PS3_FLAGS_MASK 0xFFFFFF00

	enum ps3remote_special_keys {
	PS3R_BIT_PS = 0,
	PS3R_BIT_ENTER = 3,
	PS3R_BIT_L2 = 8,
	PS3R_BIT_R2 = 9,
	PS3R_BIT_L1 = 10,
	PS3R_BIT_R1 = 11,
	PS3R_BIT_TRIANGLE = 12,
	PS3R_BIT_CIRCLE = 13,
	PS3R_BIT_CROSS = 14,
	PS3R_BIT_SQUARE = 15,
	PS3R_BIT_SELECT = 16,
	PS3R_BIT_L3 = 17,
	PS3R_BIT_R3 = 18,
	PS3R_BIT_START = 19,
	PS3R_BIT_UP = 20,
	PS3R_BIT_RIGHT = 21,
	PS3R_BIT_DOWN = 22,
	PS3R_BIT_LEFT = 23,
	};

	static unsigned int ps3remote_bits[] = {
	[PS3R_BIT_ENTER] = 0x0b,
	[PS3R_BIT_PS] = 0x43,
	[PS3R_BIT_SQUARE] = 0x5f,
	[PS3R_BIT_CROSS] = 0x5e,
	[PS3R_BIT_CIRCLE] = 0x5d,
	[PS3R_BIT_TRIANGLE] = 0x5c,
	[PS3R_BIT_R1] = 0x5b,
	[PS3R_BIT_L1] = 0x5a,
	[PS3R_BIT_R2] = 0x59,
	[PS3R_BIT_L2] = 0x58,
	[PS3R_BIT_LEFT] = 0x57,
	[PS3R_BIT_DOWN] = 0x56,
	[PS3R_BIT_RIGHT] = 0x55,
	[PS3R_BIT_UP] = 0x54,
	[PS3R_BIT_START] = 0x53,
	[PS3R_BIT_R3] = 0x52,
	[PS3R_BIT_L3] = 0x51,
	[PS3R_BIT_SELECT] = 0x50,
	};

	static unsigned int ps3remote_keymap[] = {
	[0x16] = KEY_EJECTCD,
	[0x64] = KEY_AUDIO,
	[0x65] = KEY_ANGLE,
	[0x63] = KEY_SUBTITLE,
	[0x0f] = KEY_CLEAR,
	[0x28] = KEY_TIME,
	[0x00] = KEY_1,
	[0x01] = KEY_2,
	[0x02] = KEY_3,
	[0x03] = KEY_4,
	[0x04] = KEY_5,
	[0x05] = KEY_6,
	[0x06] = KEY_7,
	[0x07] = KEY_8,
	[0x08] = KEY_9,
	[0x09] = KEY_0,
	[0x81] = KEY_RED,
	[0x82] = KEY_GREEN,
	[0x80] = KEY_BLUE,
	[0x83] = KEY_YELLOW,
	[0x70] = KEY_INFO, /* display */
	[0x1a] = KEY_MENU, /* top menu */
	[0x40] = KEY_CONTEXT_MENU, /* pop up/menu */
	[0x0e] = KEY_ESC, /* return */
	[0x5c] = KEY_OPTION, /* options/triangle */
	[0x5d] = KEY_BACK, /* back/circle */
	[0x5f] = KEY_SCREEN, /* view/square */
	[0x5e] = BTN_0, /* cross */
	[0x54] = KEY_UP,
	[0x56] = KEY_DOWN,
	[0x57] = KEY_LEFT,
	[0x55] = KEY_RIGHT,
	[0x0b] = KEY_ENTER,
	[0x5a] = BTN_TL, /* L1 */
	[0x58] = BTN_TL2, /* L2 */
	[0x51] = BTN_THUMBL, /* L3 */
	[0x5b] = BTN_TR, /* R1 */
	[0x59] = BTN_TR2, /* R2 */
	[0x52] = BTN_THUMBR, /* R3 */
	[0x43] = KEY_HOMEPAGE, /* PS button */
	[0x50] = KEY_SELECT,
	[0x53] = BTN_START,
	[0x33] = KEY_REWIND, /* scan back */
	[0x32] = KEY_PLAY,
	[0x34] = KEY_FORWARD, /* scan forward */
	[0x30] = KEY_PREVIOUS,
	[0x38] = KEY_STOP,
	[0x31] = KEY_NEXT,
	[0x60] = KEY_FRAMEBACK, /* slow/step back */
	[0x39] = KEY_PAUSE,
	[0x61] = KEY_FRAMEFORWARD, /* slow/step forward */
	[0xff] = KEY_MAX,
	};

	static int ps3remote_decode(char buff, int size, unsigned int value)
	{
	static unsigned int lastkey = 0;
	static unsigned int lastmask = 0;
	unsigned int i, mask;
	int retval;
	guint8 key;

	if (size < 12) {
	error("Got a shorter packet! (size %i)\n", size);
	return KEY_RESERVED;
	}

	mask = (buff[2] << 16) + (buff[3] << 8) + buff[4];
	key = buff[5];

	/* first, check flags */
	for (i = 0; i < 24; i++) {
	if ((lastmask & (1 << i)) == (mask & (1 << i)))
	continue;
	if (ps3remote_bits[i] == 0)
	goto error;
	retval = ps3remote_keymap[ps3remote_bits[i]];
	if (mask & (1 << i))
	/* key pressed */
	*value = 1;
	else
	/* key released */
	*value = 0;

	goto out;
	}

	*value = buff[11];
	if (buff[11] == 1) {
	retval = ps3remote_keymap[key];
	} else
	retval = lastkey;

	if (retval == KEY_RESERVED)
	goto error;
	if (retval == KEY_MAX)
	return retval;

	lastkey = retval;

	out:
	fflush(stdout);

	lastmask = mask;

	return retval;

	error:
	error("ps3remote: unrecognized sequence [%#x][%#x][%#x][%#x] [%#x],"
	"last: [%#x][%#x][%#x][%#x]",
	buff[2], buff[3], buff[4], buff[5], buff[11],
	lastmask >> 16, lastmask >> 8 & 0xff,
	lastmask & 0xff, lastkey);
	return -1;
	}

	static gboolean ps3remote_event(GIOChannel *chan, GIOCondition cond,
	gpointer data)
	{
	struct fake_input *fake = data;
	struct uinput_event event;
	unsigned int key, value = 0;
	ssize_t size;
	char buff[50];
	int fd;

	if (cond & G_IO_NVAL)
	return FALSE;

	if (cond & (G_IO_HUP \| G_IO_ERR)) {
	error("Hangup or error on rfcomm server socket");
	goto failed;
	}

	fd = g_io_channel_unix_get_fd(chan);

	memset(buff, 0, sizeof(buff));
	size = read(fd, buff, sizeof(buff));
	if (size < 0) {
	error("IO Channel read error");
	goto failed;
	}

	key = ps3remote_decode(buff, size, &value);
	if (key == KEY_RESERVED) {
	error("Got invalid key from decode");
	goto failed;
	} else if (key == KEY_MAX)
	return TRUE;

	memset(&event, 0, sizeof(event));
	gettimeofday(&event.time, NULL);
	event.type = EV_KEY;
	event.code = key;
	event.value = value;
	if (write(fake->uinput, &event, sizeof(event)) != sizeof(event)) {
	error("Error writing to uinput device");
	goto failed;
	}

	memset(&event, 0, sizeof(event));
	gettimeofday(&event.time, NULL);
	event.type = EV_SYN;
	event.code = SYN_REPORT;
	if (write(fake->uinput, &event, sizeof(event)) != sizeof(event)) {
	error("Error writing to uinput device");
	goto failed;
	}

	return TRUE;

	failed:
	ioctl(fake->uinput, UI_DEV_DESTROY);
	close(fake->uinput);
	fake->uinput = -1;
	g_io_channel_unref(fake->io);

	return FALSE;
	}

	static int ps3remote_setup_uinput(struct fake_input *fake,
	struct fake_hid *fake_hid)
	{
	struct uinput_dev dev;
	int i;

	fake->uinput = open("/dev/input/uinput", O_RDWR);
	if (fake->uinput < 0) {
	fake->uinput = open("/dev/uinput", O_RDWR);
	if (fake->uinput < 0) {
	fake->uinput = open("/dev/misc/uinput", O_RDWR);
	if (fake->uinput < 0) {
	error("Error opening uinput device file");
	return 1;
	}
	}
	}

	memset(&dev, 0, sizeof(dev));
	snprintf(dev.name, sizeof(dev.name), "%s", "PS3 Remote Controller");
	dev.id.bustype = BUS_BLUETOOTH;
	dev.id.vendor = fake_hid->vendor;
	dev.id.product = fake_hid->product;

	if (write(fake->uinput, &dev, sizeof(dev)) != sizeof(dev)) {
	error("Error creating uinput device");
	goto err;
	}

	/* enabling key events */
	if (ioctl(fake->uinput, UI_SET_EVBIT, EV_KEY) < 0) {
	error("Error enabling uinput device key events");
	goto err;
	}

	/* enabling keys */
	for (i = 0; i < 256; i++)
	if (ps3remote_keymap[i] != KEY_RESERVED)
	if (ioctl(fake->uinput, UI_SET_KEYBIT,
	ps3remote_keymap[i]) < 0) {
	error("Error enabling uinput key %i",
	ps3remote_keymap[i]);
	goto err;
	}

	/* creating the device */
	if (ioctl(fake->uinput, UI_DEV_CREATE) < 0) {
	error("Error creating uinput device");
	goto err;
	}

	return 0;

	err:
	close(fake->uinput);
	return 1;
	}

	static gboolean fake_hid_common_connect(struct fake_input fake, GError *err)
	{
	return TRUE;
	}

	static int fake_hid_common_disconnect(struct fake_input *fake)
	{
	return 0;
	}

	static struct fake_hid fake_hid_table[] = {
	/* Sony PS3 remote device */
	{
	.vendor = 0x054c,
	.product = 0x0306,
	.connect = fake_hid_common_connect,
	.disconnect = fake_hid_common_disconnect,
	.event = ps3remote_event,
	.setup_uinput = ps3remote_setup_uinput,
	.devices = NULL,
	},

	{ },
	};

	static inline int fake_hid_match_device(uint16_t vendor, uint16_t product,
	struct fake_hid *fhid)
	{
	return vendor == fhid->vendor && product == fhid->product;
	}

	struct fake_hid *get_fake_hid(uint16_t vendor, uint16_t product)
	{
	int i;

	for (i = 0; fake_hid_table[i].vendor != 0; i++)
	if (fake_hid_match_device(vendor, product, &fake_hid_table[i]))
	return &fake_hid_table[i];

	return NULL;
	}

	struct fake_input fake_hid_connadd(struct fake_input fake,
	GIOChannel *intr_io,
	struct fake_hid *fake_hid)
	{
	GList *l;
	struct fake_input *old = NULL;

	/* Look for an already setup device */
	for (l = fake_hid->devices; l != NULL; l = l->next) {
	old = l->data;
	if (old->idev == fake->idev) {
	g_free(fake);
	fake = old;
	fake_hid->connect(fake, NULL);
	break;
	}
	old = NULL;
	}

	/* New device? Add it to the list of known devices,
	* and create the uinput necessary */
	if (old == NULL) {
	if (fake_hid->setup_uinput(fake, fake_hid)) {
	error("Error setting up uinput");
	g_free(fake);
	return NULL;
	}
	fake_hid->devices = g_list_append(fake_hid->devices, fake);
	}

	fake->io = g_io_channel_ref(intr_io);
	g_io_channel_set_close_on_unref(fake->io, TRUE);
	g_io_add_watch(fake->io, G_IO_IN \| G_IO_ERR \| G_IO_HUP \| G_IO_NVAL,
	(GIOFunc) fake_hid->event, fake);

	return fake;
	}