[linux-2.6-block.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;
}

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

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 = {
	.name           = "ir remote kbd driver",
	.id             = I2C_DRIVERID_EXP3, /* FIXME */
	.flags          = I2C_DF_NOTIFY,
	.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_em2820[] = { 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_EM2820:
		probe = probe_em2820;
		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>
1da177e4	43	#include <media/ir-common.h>
d5e52653	44	#include <media/ir-kbd-i2c.h>
c365864f	45
1da177e4 LT	46	/* Mark Phalan <phalanm@o2.ie> */
1da177e4 LT	47	static IR_KEYTAB_TYPE ir_codes_pv951[IR_KEYTAB_SIZE] = {
d5e52653 MCC	48	[ 0 ] = KEY_KP0,
	49	[ 1 ] = KEY_KP1,
	50	[ 2 ] = KEY_KP2,
	51	[ 3 ] = KEY_KP3,
	52	[ 4 ] = KEY_KP4,
	53	[ 5 ] = KEY_KP5,
	54	[ 6 ] = KEY_KP6,
	55	[ 7 ] = KEY_KP7,
	56	[ 8 ] = KEY_KP8,
	57	[ 9 ] = KEY_KP9,
	58
	59	[ 18 ] = KEY_POWER,
	60	[ 16 ] = KEY_MUTE,
	61	[ 31 ] = KEY_VOLUMEDOWN,
	62	[ 27 ] = KEY_VOLUMEUP,
	63	[ 26 ] = KEY_CHANNELUP,
	64	[ 30 ] = KEY_CHANNELDOWN,
	65	[ 14 ] = KEY_PAGEUP,
	66	[ 29 ] = KEY_PAGEDOWN,
	67	[ 19 ] = KEY_SOUND,
	68
	69	[ 24 ] = KEY_KPPLUSMINUS, /* CH +/- */
	70	[ 22 ] = KEY_SUBTITLE, /* CC */
	71	[ 13 ] = KEY_TEXT, /* TTX */
	72	[ 11 ] = KEY_TV, /* AIR/CBL */
	73	[ 17 ] = KEY_PC, /* PC/TV */
	74	[ 23 ] = KEY_OK, /* CH RTN */
	75	[ 25 ] = KEY_MODE, /* FUNC */
	76	[ 12 ] = KEY_SEARCH, /* AUTOSCAN */
1da177e4 LT	77
1da177e4 LT	78	/* Not sure what to do with these ones! */
d5e52653 MCC	79	[ 15 ] = KEY_SELECT, /* SOURCE */
	80	[ 10 ] = KEY_KPPLUS, /* +100 */
	81	[ 20 ] = KEY_KPEQUAL, /* SYNC */
	82	[ 28 ] = KEY_MEDIA, /* PC/TV */
1da177e4 LT	83	};
1da177e4 LT	84
1da177e4 LT	85	/* ----------------------------------------------------------------------- */
	86	/* insmod parameters */
	87
	88	static int debug;
	89	module_param(debug, int, 0644); /* debug level (0,1,2) */
	90
	91	#define DEVNAME "ir-kbd-i2c"
	92	#define dprintk(level, fmt, arg...) if (debug >= level) \
	93	printk(KERN_DEBUG DEVNAME ": " fmt , ## arg)
	94
	95	/* ----------------------------------------------------------------------- */
	96
d5e52653	97	static int get_key_haup(struct IR_i2c ir, u32 ir_key, u32 *ir_raw)
1da177e4 LT	98	{
	99	unsigned char buf[3];
	100	int start, toggle, dev, code;
	101
	102	/* poll IR chip */
	103	if (3 != i2c_master_recv(&ir->c,buf,3))
	104	return -EIO;
	105
	106	/* split rc5 data block ... */
	107	start = (buf[0] >> 6) & 3;
	108	toggle = (buf[0] >> 5) & 1;
	109	dev = buf[0] & 0x1f;
	110	code = (buf[1] >> 2) & 0x3f;
	111
	112	if (3 != start)
	113	/* no key pressed */
	114	return 0;
	115	dprintk(1,"ir hauppauge (rc5): s%d t%d dev=%d code=%d\n",
	116	start, toggle, dev, code);
	117
	118	/* return key */
	119	*ir_key = code;
	120	*ir_raw = (start << 12) \| (toggle << 11) \| (dev << 6) \| code;
	121	return 1;
	122	}
	123
d5e52653	124	static int get_key_pixelview(struct IR_i2c ir, u32 ir_key, u32 *ir_raw)
1da177e4	125	{
4ac97914	126	unsigned char b;
1da177e4 LT	127
	128	/* poll IR chip */
	129	if (1 != i2c_master_recv(&ir->c,&b,1)) {
	130	dprintk(1,"read error\n");
	131	return -EIO;
	132	}
	133	*ir_key = b;
	134	*ir_raw = b;
	135	return 1;
	136	}
	137
d5e52653	138	static int get_key_pv951(struct IR_i2c ir, u32 ir_key, u32 *ir_raw)
1da177e4	139	{
4ac97914	140	unsigned char b;
1da177e4 LT	141
	142	/* poll IR chip */
	143	if (1 != i2c_master_recv(&ir->c,&b,1)) {
	144	dprintk(1,"read error\n");
	145	return -EIO;
	146	}
	147
	148	/* ignore 0xaa */
	149	if (b==0xaa)
	150	return 0;
	151	dprintk(2,"key %02x\n", b);
	152
	153	*ir_key = b;
	154	*ir_raw = b;
	155	return 1;
	156	}
	157
d5e52653	158	static int get_key_knc1(struct IR_i2c ir, u32 ir_key, u32 *ir_raw)
1da177e4 LT	159	{
	160	unsigned char b;
	161
	162	/* poll IR chip */
	163	if (1 != i2c_master_recv(&ir->c,&b,1)) {
	164	dprintk(1,"read error\n");
	165	return -EIO;
	166	}
	167
	168	/* it seems that 0xFE indicates that a button is still hold
4f9c05aa MCC	169	down, while 0xff indicates that no button is hold
4f9c05aa MCC	170	down. 0xfe sequences are sometimes interrupted by 0xFF */
1da177e4 LT	171
	172	dprintk(2,"key %02x\n", b);
	173
4f9c05aa	174	if (b == 0xff)
1da177e4 LT	175	return 0;
1da177e4 LT	176
4f9c05aa	177	if (b == 0xfe)
1da177e4 LT	178	/* keep old data */
	179	return 1;
	180
	181	*ir_key = b;
	182	*ir_raw = b;
	183	return 1;
	184	}
	185
1da177e4 LT	186	/* ----------------------------------------------------------------------- */
1da177e4 LT	187
d5e52653	188	static void ir_key_poll(struct IR_i2c *ir)
1da177e4 LT	189	{
	190	static u32 ir_key, ir_raw;
	191	int rc;
	192
	193	dprintk(2,"ir_poll_key\n");
	194	rc = ir->get_key(ir, &ir_key, &ir_raw);
	195	if (rc < 0) {
	196	dprintk(2,"error\n");
	197	return;
	198	}
	199
	200	if (0 == rc) {
b7df3910	201	ir_input_nokey(ir->input, &ir->ir);
1da177e4	202	} else {
b7df3910	203	ir_input_keydown(ir->input, &ir->ir, ir_key, ir_raw);
1da177e4 LT	204	}
	205	}
	206
	207	static void ir_timer(unsigned long data)
	208	{
d5e52653	209	struct IR_i2c ir = (struct IR_i2c)data;
1da177e4 LT	210	schedule_work(&ir->work);
	211	}
	212
	213	static void ir_work(void *data)
	214	{
d5e52653	215	struct IR_i2c *ir = data;
1da177e4 LT	216	ir_key_poll(ir);
	217	mod_timer(&ir->timer, jiffies+HZ/10);
	218	}
	219
	220	/* ----------------------------------------------------------------------- */
	221
	222	static int ir_attach(struct i2c_adapter *adap, int addr,
	223	unsigned short flags, int kind);
	224	static int ir_detach(struct i2c_client *client);
	225	static int ir_probe(struct i2c_adapter *adap);
	226
	227	static struct i2c_driver driver = {
4ac97914 MCC	228	.name = "ir remote kbd driver",
	229	.id = I2C_DRIVERID_EXP3, /* FIXME */
	230	.flags = I2C_DF_NOTIFY,
	231	.attach_adapter = ir_probe,
	232	.detach_client = ir_detach,
1da177e4 LT	233	};
	234
	235	static struct i2c_client client_template =
	236	{
4ac97914 MCC	237	.name = "unset",
4ac97914 MCC	238	.driver = &driver
1da177e4 LT	239	};
	240
	241	static int ir_attach(struct i2c_adapter *adap, int addr,
	242	unsigned short flags, int kind)
	243	{
	244	IR_KEYTAB_TYPE *ir_codes = NULL;
	245	char *name;
	246	int ir_type;
d5e52653	247	struct IR_i2c *ir;
b7df3910	248	struct input_dev *input_dev;
1da177e4	249
d5e52653	250	ir = kzalloc(sizeof(struct IR_i2c), GFP_KERNEL);
b7df3910 DT	251	input_dev = input_allocate_device();
	252	if (!ir \|\| !input_dev) {
	253	kfree(ir);
	254	input_free_device(input_dev);
1da177e4	255	return -ENOMEM;
b7df3910 DT	256	}
b7df3910 DT	257
1da177e4	258	ir->c = client_template;
b7df3910	259	ir->input = input_dev;
1da177e4 LT	260
	261	i2c_set_clientdata(&ir->c, ir);
	262	ir->c.adapter = adap;
	263	ir->c.addr = addr;
	264
	265	switch(addr) {
	266	case 0x64:
	267	name = "Pixelview";
	268	ir->get_key = get_key_pixelview;
	269	ir_type = IR_TYPE_OTHER;
	270	ir_codes = ir_codes_empty;
	271	break;
	272	case 0x4b:
	273	name = "PV951";
	274	ir->get_key = get_key_pv951;
	275	ir_type = IR_TYPE_OTHER;
	276	ir_codes = ir_codes_pv951;
	277	break;
	278	case 0x18:
	279	case 0x1a:
	280	name = "Hauppauge";
	281	ir->get_key = get_key_haup;
	282	ir_type = IR_TYPE_RC5;
	283	ir_codes = ir_codes_rc5_tv;
	284	break;
	285	case 0x30:
d5e52653 MCC	286	name = "KNC One";
	287	ir->get_key = get_key_knc1;
	288	ir_type = IR_TYPE_OTHER;
	289	ir_codes = ir_codes_empty;
1da177e4 LT	290	break;
1da177e4 LT	291	case 0x7a:
ac9cd976 RC	292	case 0x47:
	293	/* Handled by saa7134-input */
	294	name = "SAA713x remote";
d5e52653	295	ir_type = IR_TYPE_OTHER;
1da177e4 LT	296	break;
	297	default:
	298	/* shouldn't happen */
	299	printk(DEVNAME ": Huh? unknown i2c address (0x%02x)?\n",addr);
	300	kfree(ir);
	301	return -1;
	302	}
	303
ac9cd976	304	/* Sets name */
1da177e4	305	snprintf(ir->c.name, sizeof(ir->c.name), "i2c IR (%s)", name);
d5e52653 MCC	306	ir->ir_codes=ir_codes;
	307
	308	/* register i2c device
	309	* At device register, IR codes may be changed to be
	310	* board dependent.
	311	*/
	312	i2c_attach_client(&ir->c);
1da177e4	313
ac9cd976 RC	314	/* If IR not supported or disabled, unregisters driver */
	315	if (ir->get_key == NULL) {
	316	i2c_detach_client(&ir->c);
	317	kfree(ir);
	318	return -1;
	319	}
	320
	321	/* Phys addr can only be set after attaching (for ir->c.dev.bus_id) */
	322	snprintf(ir->phys, sizeof(ir->phys), "%s/%s/ir0",
	323	ir->c.adapter->dev.bus_id,
	324	ir->c.dev.bus_id);
	325
1da177e4	326	/* init + register input device */
b7df3910 DT	327	ir_input_init(input_dev, &ir->ir, ir_type, ir_codes);
	328	input_dev->id.bustype = BUS_I2C;
	329	input_dev->name = ir->c.name;
	330	input_dev->phys = ir->phys;
	331
d5e52653	332	/* register event device */
b7df3910	333	input_register_device(ir->input);
1da177e4 LT	334
	335	/* start polling via eventd */
	336	INIT_WORK(&ir->work, ir_work, ir);
	337	init_timer(&ir->timer);
	338	ir->timer.function = ir_timer;
	339	ir->timer.data = (unsigned long)ir;
	340	schedule_work(&ir->work);
	341
	342	return 0;
	343	}
	344
	345	static int ir_detach(struct i2c_client *client)
	346	{
4ac97914	347	struct IR_i2c *ir = i2c_get_clientdata(client);
1da177e4 LT	348
	349	/* kill outstanding polls */
	350	del_timer(&ir->timer);
	351	flush_scheduled_work();
	352
	353	/* unregister devices */
b7df3910	354	input_unregister_device(ir->input);
1da177e4 LT	355	i2c_detach_client(&ir->c);
	356
	357	/* free memory */
	358	kfree(ir);
	359	return 0;
	360	}
	361
	362	static int ir_probe(struct i2c_adapter *adap)
	363	{
	364
	365	/* The external IR receiver is at i2c address 0x34 (0x35 for
	366	reads). Future Hauppauge cards will have an internal
	367	receiver at 0x30 (0x31 for reads). In theory, both can be
	368	fitted, and Hauppauge suggest an external overrides an
	369	internal.
	370
	371	That's why we probe 0x1a (~0x34) first. CB
	372	*/
	373
	374	static const int probe_bttv[] = { 0x1a, 0x18, 0x4b, 0x64, 0x30, -1};
c2f6f9d8	375	static const int probe_saa7134[] = { 0x7a, 0x47, -1 };
d5e52653	376	static const int probe_em2820[] = { 0x30, 0x47, -1 };
1da177e4	377	const int *probe = NULL;
4f9c05aa MCC	378	struct i2c_client c;
	379	unsigned char buf;
	380	int i,rc;
1da177e4 LT	381
1da177e4 LT	382	switch (adap->id) {
c7a46533	383	case I2C_HW_B_BT848:
1da177e4 LT	384	probe = probe_bttv;
1da177e4 LT	385	break;
1684a984	386	case I2C_HW_SAA7134:
1da177e4 LT	387	probe = probe_saa7134;
1da177e4 LT	388	break;
c365864f MR	389	case I2C_HW_B_EM2820:
	390	probe = probe_em2820;
	391	break;
1da177e4 LT	392	}
	393	if (NULL == probe)
	394	return 0;
	395
	396	memset(&c,0,sizeof(c));
	397	c.adapter = adap;
d5e52653	398	for (i = 0; -1 != probe[i]; i++) {
1da177e4	399	c.addr = probe[i];
d5e52653	400	rc = i2c_master_recv(&c,&buf,0);
1da177e4 LT	401	dprintk(1,"probe 0x%02x @ %s: %s\n",
1da177e4 LT	402	probe[i], adap->name,
d5e52653 MCC	403	(0 == rc) ? "yes" : "no");
	404	if (0 == rc) {
	405	ir_attach(adap,probe[i],0,0);
	406	break;
1da177e4 LT	407	}
	408	}
	409	return 0;
	410	}
	411
	412	/* ----------------------------------------------------------------------- */
	413
	414	MODULE_AUTHOR("Gerd Knorr, Michal Kochanowicz, Christoph Bartelmus, Ulrich Mueller");
	415	MODULE_DESCRIPTION("input driver for i2c IR remote controls");
	416	MODULE_LICENSE("GPL");
	417
	418	static int __init ir_init(void)
	419	{
	420	return i2c_add_driver(&driver);
	421	}
	422
	423	static void __exit ir_fini(void)
	424	{
	425	i2c_del_driver(&driver);
	426	}
	427
	428	module_init(ir_init);
	429	module_exit(ir_fini);
	430
	431	/*
	432	* Overrides for Emacs so that we follow Linus's tabbing style.
	433	* ---------------------------------------------------------------------------
	434	* Local variables:
	435	* c-basic-offset: 8
	436	* End:
	437	*/