[deliverable/linux.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>

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

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

static int hauppauge = 0;
module_param(hauppauge, int, 0644);    /* Choose Hauppauge remote */
MODULE_PARM_DESC(hauppauge, "Specify Hauppauge remote: 0=black, 1=grey (defaults to 0)");


#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-kbd-i2c",
	},
	.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) {
		input_free_device(input_dev);
		kfree(ir);
		return -ENOMEM;
	}
	memset(ir,0,sizeof(*ir));

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

	ir->c.adapter = adap;
	ir->c.addr    = addr;

	i2c_set_clientdata(&ir->c, ir);

	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;
		if (hauppauge == 1) {
			ir_codes    = ir_codes_hauppauge_new;
		} else {
			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->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);
	printk(DEVNAME ": %s detected at %s [%s]\n",
	       ir->input->name,ir->input->phys,adap->name);

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