[mirror_ubuntu-artful-kernel.git] / drivers / media / video / ir-kbd-i2c.c

/*
 *
 * keyboard input driver for i2c IR remote controls
 *
 * Copyright (c) 2000-2003 Gerd Knorr <kraxel@bytesex.org>
 * modified for PixelView (BT878P+W/FM) by
 *      Michal Kochanowicz <mkochano@pld.org.pl>
 *      Christoph Bartelmus <lirc@bartelmus.de>
 * modified for KNC ONE TV Station/Anubis Typhoon TView Tuner by
 *      Ulrich Mueller <ulrich.mueller42@web.de>
 * modified for em2820 based USB TV tuners by
 *      Markus Rechberger <mrechberger@gmail.com>
 *
 *  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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/string.h>
#include <linux/timer.h>
#include <linux/delay.h>
#include <linux/errno.h>
#include <linux/slab.h>
#include <linux/i2c.h>
#include <linux/workqueue.h>
#include <asm/semaphore.h>

#include <media/ir-common.h>
#include <media/ir-kbd-i2c.h>

/* Mark Phalan <phalanm@o2.ie> */
static IR_KEYTAB_TYPE ir_codes_pv951[IR_KEYTAB_SIZE] = {
	[  0 ] = KEY_KP0,
	[  1 ] = KEY_KP1,
	[  2 ] = KEY_KP2,
	[  3 ] = KEY_KP3,
	[  4 ] = KEY_KP4,
	[  5 ] = KEY_KP5,
	[  6 ] = KEY_KP6,
	[  7 ] = KEY_KP7,
	[  8 ] = KEY_KP8,
	[  9 ] = KEY_KP9,

	[ 18 ] = KEY_POWER,
	[ 16 ] = KEY_MUTE,
	[ 31 ] = KEY_VOLUMEDOWN,
	[ 27 ] = KEY_VOLUMEUP,
	[ 26 ] = KEY_CHANNELUP,
	[ 30 ] = KEY_CHANNELDOWN,
	[ 14 ] = KEY_PAGEUP,
	[ 29 ] = KEY_PAGEDOWN,
	[ 19 ] = KEY_SOUND,

	[ 24 ] = KEY_KPPLUSMINUS,	/* CH +/- */
	[ 22 ] = KEY_SUBTITLE,		/* CC */
	[ 13 ] = KEY_TEXT,		/* TTX */
	[ 11 ] = KEY_TV,		/* AIR/CBL */
	[ 17 ] = KEY_PC,		/* PC/TV */
	[ 23 ] = KEY_OK,		/* CH RTN */
	[ 25 ] = KEY_MODE, 		/* FUNC */
	[ 12 ] = KEY_SEARCH, 		/* AUTOSCAN */

	/* Not sure what to do with these ones! */
	[ 15 ] = KEY_SELECT, 		/* SOURCE */
	[ 10 ] = KEY_KPPLUS,		/* +100 */
	[ 20 ] = KEY_KPEQUAL,		/* SYNC */
	[ 28 ] = KEY_MEDIA,             /* PC/TV */
};

/* ----------------------------------------------------------------------- */
/* insmod parameters                                                       */

static int debug;
module_param(debug, int, 0644);    /* debug level (0,1,2) */

#define DEVNAME "ir-kbd-i2c"
#define dprintk(level, fmt, arg...)	if (debug >= level) \
	printk(KERN_DEBUG DEVNAME ": " fmt , ## arg)

/* ----------------------------------------------------------------------- */

static int get_key_haup(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
{
	unsigned char buf[3];
	int start, toggle, dev, code;

	/* poll IR chip */
	if (3 != i2c_master_recv(&ir->c,buf,3))
		return -EIO;

	/* split rc5 data block ... */
	start  = (buf[0] >> 6) &    3;
	toggle = (buf[0] >> 5) &    1;
	dev    =  buf[0]       & 0x1f;
	code   = (buf[1] >> 2) & 0x3f;

	if (3 != start)
		/* no key pressed */
		return 0;
	dprintk(1,"ir hauppauge (rc5): s%d t%d dev=%d code=%d\n",
		start, toggle, dev, code);

	/* return key */
	*ir_key = code;
	*ir_raw = (start << 12) | (toggle << 11) | (dev << 6) | code;
	return 1;
}

static int get_key_pixelview(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
{
	unsigned char b;

	/* poll IR chip */
	if (1 != i2c_master_recv(&ir->c,&b,1)) {
		dprintk(1,"read error\n");
		return -EIO;
	}
	*ir_key = b;
	*ir_raw = b;
	return 1;
}

static int get_key_pv951(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
{
	unsigned char b;

	/* poll IR chip */
	if (1 != i2c_master_recv(&ir->c,&b,1)) {
		dprintk(1,"read error\n");
		return -EIO;
	}

	/* ignore 0xaa */
	if (b==0xaa)
		return 0;
	dprintk(2,"key %02x\n", b);

	*ir_key = b;
	*ir_raw = b;
	return 1;
}

static int get_key_knc1(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
{
	unsigned char b;

	/* poll IR chip */
	if (1 != i2c_master_recv(&ir->c,&b,1)) {
		dprintk(1,"read error\n");
		return -EIO;
	}

	/* it seems that 0xFE indicates that a button is still hold
	   down, while 0xff indicates that no button is hold
	   down. 0xfe sequences are sometimes interrupted by 0xFF */

	dprintk(2,"key %02x\n", b);

	if (b == 0xff)
		return 0;

	if (b == 0xfe)
		/* keep old data */
		return 1;

	*ir_key = b;
	*ir_raw = b;
	return 1;
}

/* The new pinnacle PCTV remote (with the colored buttons)
 *
 * Ricardo Cerqueira <v4l@cerqueira.org>
 */

int get_key_pinnacle(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
{
	unsigned char b[4];
	unsigned int start = 0,parity = 0,code = 0;

	/* poll IR chip */
	if (4 != i2c_master_recv(&ir->c,b,4)) {
		dprintk(2,"read error\n");
		return -EIO;
	}

	for (start = 0; start<4; start++) {
		if (b[start] == 0x80) {
			code=b[(start+3)%4];
			parity=b[(start+2)%4];
		}
	}

	/* Empty Request */
	if (parity==0)
		return 0;

	/* Repeating... */
	if (ir->old == parity)
		return 0;


	ir->old = parity;

	/* Reduce code value to fit inside IR_KEYTAB_SIZE
	 *
	 * this is the only value that results in 42 unique
	 * codes < 128
	 */

	code %= 0x88;

	*ir_raw = code;
	*ir_key = code;

	dprintk(1,"Pinnacle PCTV key %02x\n", code);

	return 1;
}

EXPORT_SYMBOL_GPL(get_key_pinnacle);

/* ----------------------------------------------------------------------- */

static void ir_key_poll(struct IR_i2c *ir)
{
	static u32 ir_key, ir_raw;
	int rc;

	dprintk(2,"ir_poll_key\n");
	rc = ir->get_key(ir, &ir_key, &ir_raw);
	if (rc < 0) {
		dprintk(2,"error\n");
		return;
	}

	if (0 == rc) {
		ir_input_nokey(ir->input, &ir->ir);
	} else {
		ir_input_keydown(ir->input, &ir->ir, ir_key, ir_raw);
	}
}

static void ir_timer(unsigned long data)
{
	struct IR_i2c *ir = (struct IR_i2c*)data;
	schedule_work(&ir->work);
}

static void ir_work(void *data)
{
	struct IR_i2c *ir = data;
	ir_key_poll(ir);
	mod_timer(&ir->timer, jiffies+HZ/10);
}

/* ----------------------------------------------------------------------- */

static int ir_attach(struct i2c_adapter *adap, int addr,
		      unsigned short flags, int kind);
static int ir_detach(struct i2c_client *client);
static int ir_probe(struct i2c_adapter *adap);

static struct i2c_driver driver = {
	.driver = {
		.name   = "ir remote kbd driver",
	},
	.id             = I2C_DRIVERID_INFRARED,
	.attach_adapter = ir_probe,
	.detach_client  = ir_detach,
};

static struct i2c_client client_template =
{
	.name = "unset",
	.driver = &driver
};

static int ir_attach(struct i2c_adapter *adap, int addr,
		     unsigned short flags, int kind)
{
	IR_KEYTAB_TYPE *ir_codes = NULL;
	char *name;
	int ir_type;
	struct IR_i2c *ir;
	struct input_dev *input_dev;

	ir = kzalloc(sizeof(struct IR_i2c),GFP_KERNEL);
	input_dev = input_allocate_device();
	if (!ir || !input_dev) {
		kfree(ir);
		input_free_device(input_dev);
		return -ENOMEM;
	}

	ir->c = client_template;
	ir->input = input_dev;

	i2c_set_clientdata(&ir->c, ir);
	ir->c.adapter = adap;
	ir->c.addr    = addr;

	switch(addr) {
	case 0x64:
		name        = "Pixelview";
		ir->get_key = get_key_pixelview;
		ir_type     = IR_TYPE_OTHER;
		ir_codes    = ir_codes_empty;
		break;
	case 0x4b:
		name        = "PV951";
		ir->get_key = get_key_pv951;
		ir_type     = IR_TYPE_OTHER;
		ir_codes    = ir_codes_pv951;
		break;
	case 0x18:
	case 0x1a:
		name        = "Hauppauge";
		ir->get_key = get_key_haup;
		ir_type     = IR_TYPE_RC5;
		ir_codes    = ir_codes_rc5_tv;
		break;
	case 0x30:
		name        = "KNC One";
		ir->get_key = get_key_knc1;
		ir_type     = IR_TYPE_OTHER;
		ir_codes    = ir_codes_empty;
		break;
	case 0x7a:
	case 0x47:
		/* Handled by saa7134-input */
		name        = "SAA713x remote";
		ir_type     = IR_TYPE_OTHER;
		break;
	default:
		/* shouldn't happen */
		printk(DEVNAME ": Huh? unknown i2c address (0x%02x)?\n",addr);
		kfree(ir);
		return -1;
	}

	/* Sets name */
	snprintf(ir->c.name, sizeof(ir->c.name), "i2c IR (%s)", name);
	ir->ir_codes=ir_codes;

	/* register i2c device
	 * At device register, IR codes may be changed to be
	 * board dependent.
	 */
	i2c_attach_client(&ir->c);

	/* If IR not supported or disabled, unregisters driver */
	if (ir->get_key == NULL) {
		i2c_detach_client(&ir->c);
		kfree(ir);
		return -1;
	}

	/* Phys addr can only be set after attaching (for ir->c.dev.bus_id) */
	snprintf(ir->phys, sizeof(ir->phys), "%s/%s/ir0",
		 ir->c.adapter->dev.bus_id,
		 ir->c.dev.bus_id);

	/* init + register input device */
	ir_input_init(input_dev, &ir->ir, ir_type, ir_codes);
	input_dev->id.bustype	= BUS_I2C;
	input_dev->name		= ir->c.name;
	input_dev->phys		= ir->phys;

	/* register event device */
	input_register_device(ir->input);

	/* start polling via eventd */
	INIT_WORK(&ir->work, ir_work, ir);
	init_timer(&ir->timer);
	ir->timer.function = ir_timer;
	ir->timer.data     = (unsigned long)ir;
	schedule_work(&ir->work);

	return 0;
}

static int ir_detach(struct i2c_client *client)
{
	struct IR_i2c *ir = i2c_get_clientdata(client);

	/* kill outstanding polls */
	del_timer(&ir->timer);
	flush_scheduled_work();

	/* unregister devices */
	input_unregister_device(ir->input);
	i2c_detach_client(&ir->c);

	/* free memory */
	kfree(ir);
	return 0;
}

static int ir_probe(struct i2c_adapter *adap)
{

	/* The external IR receiver is at i2c address 0x34 (0x35 for
	   reads).  Future Hauppauge cards will have an internal
	   receiver at 0x30 (0x31 for reads).  In theory, both can be
	   fitted, and Hauppauge suggest an external overrides an
	   internal.

	   That's why we probe 0x1a (~0x34) first. CB
	*/

	static const int probe_bttv[] = { 0x1a, 0x18, 0x4b, 0x64, 0x30, -1};
	static const int probe_saa7134[] = { 0x7a, 0x47, -1 };
	static const int probe_em28XX[] = { 0x30, 0x47, -1 };
	const int *probe = NULL;
	struct i2c_client c;
	unsigned char buf;
	int i,rc;

	switch (adap->id) {
	case I2C_HW_B_BT848:
		probe = probe_bttv;
		break;
	case I2C_HW_SAA7134:
		probe = probe_saa7134;
		break;
	case I2C_HW_B_EM28XX:
		probe = probe_em28XX;
		break;
	}
	if (NULL == probe)
		return 0;

	memset(&c,0,sizeof(c));
	c.adapter = adap;
	for (i = 0; -1 != probe[i]; i++) {
		c.addr = probe[i];
		rc = i2c_master_recv(&c,&buf,0);
		dprintk(1,"probe 0x%02x @ %s: %s\n",
			probe[i], adap->name,
			(0 == rc) ? "yes" : "no");
		if (0 == rc) {
			ir_attach(adap,probe[i],0,0);
			break;
		}
	}
	return 0;
}

/* ----------------------------------------------------------------------- */

MODULE_AUTHOR("Gerd Knorr, Michal Kochanowicz, Christoph Bartelmus, Ulrich Mueller");
MODULE_DESCRIPTION("input driver for i2c IR remote controls");
MODULE_LICENSE("GPL");

static int __init ir_init(void)
{
	return i2c_add_driver(&driver);
}

static void __exit ir_fini(void)
{
	i2c_del_driver(&driver);
}

module_init(ir_init);
module_exit(ir_fini);

/*
 * Overrides for Emacs so that we follow Linus's tabbing style.
 * ---------------------------------------------------------------------------
 * Local variables:
 * c-basic-offset: 8
 * End:
 */
Commit	Line	Data
1da177e4	1	/*
1da177e4 LT	2	*
	3	* keyboard input driver for i2c IR remote controls
	4	*
	5	* Copyright (c) 2000-2003 Gerd Knorr <kraxel@bytesex.org>
	6	* modified for PixelView (BT878P+W/FM) by
	7	* Michal Kochanowicz <mkochano@pld.org.pl>
	8	* Christoph Bartelmus <lirc@bartelmus.de>
	9	* modified for KNC ONE TV Station/Anubis Typhoon TView Tuner by
	10	* Ulrich Mueller <ulrich.mueller42@web.de>
c365864f MR	11	* modified for em2820 based USB TV tuners by
c365864f MR	12	* Markus Rechberger <mrechberger@gmail.com>
1da177e4 LT	13	*
	14	* This program is free software; you can redistribute it and/or modify
	15	* it under the terms of the GNU General Public License as published by
	16	* the Free Software Foundation; either version 2 of the License, or
	17	* (at your option) any later version.
	18	*
	19	* This program is distributed in the hope that it will be useful,
	20	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	21	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	22	* GNU General Public License for more details.
	23	*
	24	* You should have received a copy of the GNU General Public License
	25	* along with this program; if not, write to the Free Software
	26	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	27	*
	28	*/
	29
	30	#include <linux/module.h>
	31	#include <linux/moduleparam.h>
	32	#include <linux/init.h>
	33	#include <linux/kernel.h>
	34	#include <linux/sched.h>
	35	#include <linux/string.h>
	36	#include <linux/timer.h>
	37	#include <linux/delay.h>
	38	#include <linux/errno.h>
	39	#include <linux/slab.h>
	40	#include <linux/i2c.h>
	41	#include <linux/workqueue.h>
1da177e4	42	#include <asm/semaphore.h>
674434c6	43
1da177e4	44	#include <media/ir-common.h>
d5e52653	45	#include <media/ir-kbd-i2c.h>
c365864f	46
1da177e4 LT	47	/* Mark Phalan <phalanm@o2.ie> */
1da177e4 LT	48	static IR_KEYTAB_TYPE ir_codes_pv951[IR_KEYTAB_SIZE] = {
d5e52653 MCC	49	[ 0 ] = KEY_KP0,
	50	[ 1 ] = KEY_KP1,
	51	[ 2 ] = KEY_KP2,
	52	[ 3 ] = KEY_KP3,
	53	[ 4 ] = KEY_KP4,
	54	[ 5 ] = KEY_KP5,
	55	[ 6 ] = KEY_KP6,
	56	[ 7 ] = KEY_KP7,
	57	[ 8 ] = KEY_KP8,
	58	[ 9 ] = KEY_KP9,
	59
	60	[ 18 ] = KEY_POWER,
	61	[ 16 ] = KEY_MUTE,
	62	[ 31 ] = KEY_VOLUMEDOWN,
	63	[ 27 ] = KEY_VOLUMEUP,
	64	[ 26 ] = KEY_CHANNELUP,
	65	[ 30 ] = KEY_CHANNELDOWN,
	66	[ 14 ] = KEY_PAGEUP,
	67	[ 29 ] = KEY_PAGEDOWN,
	68	[ 19 ] = KEY_SOUND,
	69
	70	[ 24 ] = KEY_KPPLUSMINUS, /* CH +/- */
	71	[ 22 ] = KEY_SUBTITLE, /* CC */
	72	[ 13 ] = KEY_TEXT, /* TTX */
	73	[ 11 ] = KEY_TV, /* AIR/CBL */
	74	[ 17 ] = KEY_PC, /* PC/TV */
	75	[ 23 ] = KEY_OK, /* CH RTN */
	76	[ 25 ] = KEY_MODE, /* FUNC */
	77	[ 12 ] = KEY_SEARCH, /* AUTOSCAN */
1da177e4 LT	78
1da177e4 LT	79	/* Not sure what to do with these ones! */
d5e52653 MCC	80	[ 15 ] = KEY_SELECT, /* SOURCE */
	81	[ 10 ] = KEY_KPPLUS, /* +100 */
	82	[ 20 ] = KEY_KPEQUAL, /* SYNC */
	83	[ 28 ] = KEY_MEDIA, /* PC/TV */
1da177e4 LT	84	};
1da177e4 LT	85
1da177e4 LT	86	/* ----------------------------------------------------------------------- */
	87	/* insmod parameters */
	88
	89	static int debug;
	90	module_param(debug, int, 0644); /* debug level (0,1,2) */
	91
	92	#define DEVNAME "ir-kbd-i2c"
	93	#define dprintk(level, fmt, arg...) if (debug >= level) \
	94	printk(KERN_DEBUG DEVNAME ": " fmt , ## arg)
	95
	96	/* ----------------------------------------------------------------------- */
	97
d5e52653	98	static int get_key_haup(struct IR_i2c ir, u32 ir_key, u32 *ir_raw)
1da177e4 LT	99	{
	100	unsigned char buf[3];
	101	int start, toggle, dev, code;
	102
	103	/* poll IR chip */
	104	if (3 != i2c_master_recv(&ir->c,buf,3))
	105	return -EIO;
	106
	107	/* split rc5 data block ... */
	108	start = (buf[0] >> 6) & 3;
	109	toggle = (buf[0] >> 5) & 1;
	110	dev = buf[0] & 0x1f;
	111	code = (buf[1] >> 2) & 0x3f;
	112
	113	if (3 != start)
	114	/* no key pressed */
	115	return 0;
	116	dprintk(1,"ir hauppauge (rc5): s%d t%d dev=%d code=%d\n",
	117	start, toggle, dev, code);
	118
	119	/* return key */
	120	*ir_key = code;
	121	*ir_raw = (start << 12) \| (toggle << 11) \| (dev << 6) \| code;
	122	return 1;
	123	}
	124
d5e52653	125	static int get_key_pixelview(struct IR_i2c ir, u32 ir_key, u32 *ir_raw)
1da177e4	126	{
4ac97914	127	unsigned char b;
1da177e4 LT	128
	129	/* poll IR chip */
	130	if (1 != i2c_master_recv(&ir->c,&b,1)) {
	131	dprintk(1,"read error\n");
	132	return -EIO;
	133	}
	134	*ir_key = b;
	135	*ir_raw = b;
	136	return 1;
	137	}
	138
d5e52653	139	static int get_key_pv951(struct IR_i2c ir, u32 ir_key, u32 *ir_raw)
1da177e4	140	{
4ac97914	141	unsigned char b;
1da177e4 LT	142
	143	/* poll IR chip */
	144	if (1 != i2c_master_recv(&ir->c,&b,1)) {
	145	dprintk(1,"read error\n");
	146	return -EIO;
	147	}
	148
	149	/* ignore 0xaa */
	150	if (b==0xaa)
	151	return 0;
	152	dprintk(2,"key %02x\n", b);
	153
	154	*ir_key = b;
	155	*ir_raw = b;
	156	return 1;
	157	}
	158
d5e52653	159	static int get_key_knc1(struct IR_i2c ir, u32 ir_key, u32 *ir_raw)
1da177e4 LT	160	{
	161	unsigned char b;
	162
	163	/* poll IR chip */
	164	if (1 != i2c_master_recv(&ir->c,&b,1)) {
	165	dprintk(1,"read error\n");
	166	return -EIO;
	167	}
	168
	169	/* it seems that 0xFE indicates that a button is still hold
4f9c05aa MCC	170	down, while 0xff indicates that no button is hold
4f9c05aa MCC	171	down. 0xfe sequences are sometimes interrupted by 0xFF */
1da177e4 LT	172
	173	dprintk(2,"key %02x\n", b);
	174
4f9c05aa	175	if (b == 0xff)
1da177e4 LT	176	return 0;
1da177e4 LT	177
4f9c05aa	178	if (b == 0xfe)
1da177e4 LT	179	/* keep old data */
	180	return 1;
	181
	182	*ir_key = b;
	183	*ir_raw = b;
	184	return 1;
	185	}
	186
8069695c RC	187	/* The new pinnacle PCTV remote (with the colored buttons)
	188	*
	189	* Ricardo Cerqueira <v4l@cerqueira.org>
	190	*/
	191
	192	int get_key_pinnacle(struct IR_i2c ir, u32 ir_key, u32 *ir_raw)
	193	{
	194	unsigned char b[4];
	195	unsigned int start = 0,parity = 0,code = 0;
	196
	197	/* poll IR chip */
	198	if (4 != i2c_master_recv(&ir->c,b,4)) {
	199	dprintk(2,"read error\n");
	200	return -EIO;
	201	}
	202
	203	for (start = 0; start<4; start++) {
	204	if (b[start] == 0x80) {
	205	code=b[(start+3)%4];
	206	parity=b[(start+2)%4];
	207	}
	208	}
	209
	210	/* Empty Request */
	211	if (parity==0)
	212	return 0;
	213
	214	/* Repeating... */
	215	if (ir->old == parity)
	216	return 0;
	217
	218
	219	ir->old = parity;
	220
	221	/* Reduce code value to fit inside IR_KEYTAB_SIZE
	222	*
	223	* this is the only value that results in 42 unique
	224	* codes < 128
	225	*/
	226
	227	code %= 0x88;
	228
	229	*ir_raw = code;
	230	*ir_key = code;
	231
	232	dprintk(1,"Pinnacle PCTV key %02x\n", code);
	233
	234	return 1;
	235	}
	236
	237	EXPORT_SYMBOL_GPL(get_key_pinnacle);
	238
1da177e4 LT	239	/* ----------------------------------------------------------------------- */
1da177e4 LT	240
d5e52653	241	static void ir_key_poll(struct IR_i2c *ir)
1da177e4 LT	242	{
	243	static u32 ir_key, ir_raw;
	244	int rc;
	245
	246	dprintk(2,"ir_poll_key\n");
	247	rc = ir->get_key(ir, &ir_key, &ir_raw);
	248	if (rc < 0) {
	249	dprintk(2,"error\n");
	250	return;
	251	}
	252
	253	if (0 == rc) {
b7df3910	254	ir_input_nokey(ir->input, &ir->ir);
1da177e4	255	} else {
b7df3910	256	ir_input_keydown(ir->input, &ir->ir, ir_key, ir_raw);
1da177e4 LT	257	}
	258	}
	259
	260	static void ir_timer(unsigned long data)
	261	{
d5e52653	262	struct IR_i2c ir = (struct IR_i2c)data;
1da177e4 LT	263	schedule_work(&ir->work);
	264	}
	265
	266	static void ir_work(void *data)
	267	{
d5e52653	268	struct IR_i2c *ir = data;
1da177e4 LT	269	ir_key_poll(ir);
	270	mod_timer(&ir->timer, jiffies+HZ/10);
	271	}
	272
	273	/* ----------------------------------------------------------------------- */
	274
	275	static int ir_attach(struct i2c_adapter *adap, int addr,
	276	unsigned short flags, int kind);
	277	static int ir_detach(struct i2c_client *client);
	278	static int ir_probe(struct i2c_adapter *adap);
	279
	280	static struct i2c_driver driver = {
604f28e2	281	.driver = {
604f28e2 LR	282	.name = "ir remote kbd driver",
604f28e2 LR	283	},
dd815408	284	.id = I2C_DRIVERID_INFRARED,
4ac97914 MCC	285	.attach_adapter = ir_probe,
4ac97914 MCC	286	.detach_client = ir_detach,
1da177e4 LT	287	};
	288
	289	static struct i2c_client client_template =
	290	{
4ac97914 MCC	291	.name = "unset",
4ac97914 MCC	292	.driver = &driver
1da177e4 LT	293	};
	294
	295	static int ir_attach(struct i2c_adapter *adap, int addr,
	296	unsigned short flags, int kind)
	297	{
	298	IR_KEYTAB_TYPE *ir_codes = NULL;
	299	char *name;
	300	int ir_type;
afd1a0c9	301	struct IR_i2c *ir;
b7df3910	302	struct input_dev *input_dev;
1da177e4	303
674434c6	304	ir = kzalloc(sizeof(struct IR_i2c),GFP_KERNEL);
b7df3910 DT	305	input_dev = input_allocate_device();
	306	if (!ir \|\| !input_dev) {
	307	kfree(ir);
	308	input_free_device(input_dev);
afd1a0c9	309	return -ENOMEM;
b7df3910 DT	310	}
b7df3910 DT	311
1da177e4	312	ir->c = client_template;
b7df3910	313	ir->input = input_dev;
1da177e4 LT	314
	315	i2c_set_clientdata(&ir->c, ir);
	316	ir->c.adapter = adap;
	317	ir->c.addr = addr;
	318
	319	switch(addr) {
	320	case 0x64:
	321	name = "Pixelview";
	322	ir->get_key = get_key_pixelview;
	323	ir_type = IR_TYPE_OTHER;
	324	ir_codes = ir_codes_empty;
	325	break;
	326	case 0x4b:
	327	name = "PV951";
	328	ir->get_key = get_key_pv951;
	329	ir_type = IR_TYPE_OTHER;
	330	ir_codes = ir_codes_pv951;
	331	break;
	332	case 0x18:
	333	case 0x1a:
	334	name = "Hauppauge";
	335	ir->get_key = get_key_haup;
	336	ir_type = IR_TYPE_RC5;
	337	ir_codes = ir_codes_rc5_tv;
	338	break;
	339	case 0x30:
d5e52653 MCC	340	name = "KNC One";
	341	ir->get_key = get_key_knc1;
	342	ir_type = IR_TYPE_OTHER;
	343	ir_codes = ir_codes_empty;
1da177e4 LT	344	break;
1da177e4 LT	345	case 0x7a:
ac9cd976 RC	346	case 0x47:
	347	/* Handled by saa7134-input */
	348	name = "SAA713x remote";
d5e52653	349	ir_type = IR_TYPE_OTHER;
1da177e4 LT	350	break;
	351	default:
	352	/* shouldn't happen */
	353	printk(DEVNAME ": Huh? unknown i2c address (0x%02x)?\n",addr);
	354	kfree(ir);
	355	return -1;
	356	}
	357
ac9cd976	358	/* Sets name */
1da177e4	359	snprintf(ir->c.name, sizeof(ir->c.name), "i2c IR (%s)", name);
d5e52653 MCC	360	ir->ir_codes=ir_codes;
	361
	362	/* register i2c device
	363	* At device register, IR codes may be changed to be
	364	* board dependent.
674434c6	365	*/
d5e52653	366	i2c_attach_client(&ir->c);
1da177e4	367
ac9cd976 RC	368	/* If IR not supported or disabled, unregisters driver */
	369	if (ir->get_key == NULL) {
	370	i2c_detach_client(&ir->c);
	371	kfree(ir);
	372	return -1;
	373	}
	374
	375	/* Phys addr can only be set after attaching (for ir->c.dev.bus_id) */
	376	snprintf(ir->phys, sizeof(ir->phys), "%s/%s/ir0",
	377	ir->c.adapter->dev.bus_id,
	378	ir->c.dev.bus_id);
	379
1da177e4	380	/* init + register input device */
b7df3910 DT	381	ir_input_init(input_dev, &ir->ir, ir_type, ir_codes);
	382	input_dev->id.bustype = BUS_I2C;
	383	input_dev->name = ir->c.name;
	384	input_dev->phys = ir->phys;
	385
d5e52653	386	/* register event device */
b7df3910	387	input_register_device(ir->input);
1da177e4 LT	388
	389	/* start polling via eventd */
	390	INIT_WORK(&ir->work, ir_work, ir);
	391	init_timer(&ir->timer);
	392	ir->timer.function = ir_timer;
	393	ir->timer.data = (unsigned long)ir;
	394	schedule_work(&ir->work);
	395
	396	return 0;
	397	}
	398
	399	static int ir_detach(struct i2c_client *client)
	400	{
4ac97914	401	struct IR_i2c *ir = i2c_get_clientdata(client);
1da177e4 LT	402
	403	/* kill outstanding polls */
	404	del_timer(&ir->timer);
	405	flush_scheduled_work();
	406
	407	/* unregister devices */
b7df3910	408	input_unregister_device(ir->input);
1da177e4 LT	409	i2c_detach_client(&ir->c);
	410
	411	/* free memory */
	412	kfree(ir);
	413	return 0;
	414	}
	415
	416	static int ir_probe(struct i2c_adapter *adap)
	417	{
	418
	419	/* The external IR receiver is at i2c address 0x34 (0x35 for
	420	reads). Future Hauppauge cards will have an internal
	421	receiver at 0x30 (0x31 for reads). In theory, both can be
	422	fitted, and Hauppauge suggest an external overrides an
	423	internal.
	424
	425	That's why we probe 0x1a (~0x34) first. CB
	426	*/
	427
	428	static const int probe_bttv[] = { 0x1a, 0x18, 0x4b, 0x64, 0x30, -1};
c2f6f9d8	429	static const int probe_saa7134[] = { 0x7a, 0x47, -1 };
b296fc60	430	static const int probe_em28XX[] = { 0x30, 0x47, -1 };
1da177e4	431	const int *probe = NULL;
4f9c05aa MCC	432	struct i2c_client c;
	433	unsigned char buf;
	434	int i,rc;
1da177e4 LT	435
1da177e4 LT	436	switch (adap->id) {
c7a46533	437	case I2C_HW_B_BT848:
1da177e4 LT	438	probe = probe_bttv;
1da177e4 LT	439	break;
1684a984	440	case I2C_HW_SAA7134:
1da177e4 LT	441	probe = probe_saa7134;
1da177e4 LT	442	break;
b296fc60 MCC	443	case I2C_HW_B_EM28XX:
b296fc60 MCC	444	probe = probe_em28XX;
c365864f	445	break;
1da177e4 LT	446	}
	447	if (NULL == probe)
	448	return 0;
	449
	450	memset(&c,0,sizeof(c));
	451	c.adapter = adap;
d5e52653	452	for (i = 0; -1 != probe[i]; i++) {
1da177e4	453	c.addr = probe[i];
d5e52653	454	rc = i2c_master_recv(&c,&buf,0);
1da177e4 LT	455	dprintk(1,"probe 0x%02x @ %s: %s\n",
1da177e4 LT	456	probe[i], adap->name,
d5e52653 MCC	457	(0 == rc) ? "yes" : "no");
	458	if (0 == rc) {
	459	ir_attach(adap,probe[i],0,0);
	460	break;
1da177e4 LT	461	}
	462	}
	463	return 0;
	464	}
	465
	466	/* ----------------------------------------------------------------------- */
	467
	468	MODULE_AUTHOR("Gerd Knorr, Michal Kochanowicz, Christoph Bartelmus, Ulrich Mueller");
	469	MODULE_DESCRIPTION("input driver for i2c IR remote controls");
	470	MODULE_LICENSE("GPL");
	471
	472	static int __init ir_init(void)
	473	{
	474	return i2c_add_driver(&driver);
	475	}
	476
	477	static void __exit ir_fini(void)
	478	{
	479	i2c_del_driver(&driver);
	480	}
	481
	482	module_init(ir_init);
	483	module_exit(ir_fini);
	484
	485	/*
	486	* Overrides for Emacs so that we follow Linus's tabbing style.
	487	* ---------------------------------------------------------------------------
	488	* Local variables:
	489	* c-basic-offset: 8
	490	* End:
	491	*/