[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>

/* ----------------------------------------------------------------------- */
/* 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;
}

/* Common (grey or coloured) pinnacle PCTV remote handling
 *
 */
static int get_key_pinnacle(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw,
			    int parity_offset, int marker, int code_modulo)
{
	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] == marker) {
			code=b[(start+parity_offset+1)%4];
			parity=b[(start+parity_offset)%4];
		}
	}

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

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

	ir->old = parity;

	/* drop special codes when a key is held down a long time for the grey controller
	   In this case, the second bit of the code is asserted */
	if (marker == 0xfe && (code & 0x40))
		return 0;

	code %= code_modulo;

	*ir_raw = code;
	*ir_key = code;

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

	return 1;
}

/* The grey pinnacle PCTV remote
 *
 *  There are one issue with this remote:
 *   - I2c packet does not change when the same key is pressed quickly. The workaround
 *     is to hold down each key for about half a second, so that another code is generated
 *     in the i2c packet, and the function can distinguish key presses.
 *
 * Sylvain Pasche <sylvain.pasche@gmail.com>
 */
int get_key_pinnacle_grey(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
{

	return get_key_pinnacle(ir, ir_key, ir_raw, 1, 0xfe, 0xff);
}

EXPORT_SYMBOL_GPL(get_key_pinnacle_grey);


/* The new pinnacle PCTV remote (with the colored buttons)
 *
 * Ricardo Cerqueira <v4l@cerqueira.org>
 */
int get_key_pinnacle_color(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
{
	/* code_modulo parameter (0x88) is used to reduce code value to fit inside IR_KEYTAB_SIZE
	 *
	 * this is the only value that results in 42 unique
	 * codes < 128
	 */

	return get_key_pinnacle(ir, ir_key, ir_raw, 2, 0x80, 0x88);
}

EXPORT_SYMBOL_GPL(get_key_pinnacle_color);

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

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_B_CX2341X:
		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
b93eedb6	153	/* Common (grey or coloured) pinnacle PCTV remote handling
8069695c	154	*
8069695c	155	*/
b93eedb6 SP	156	static int get_key_pinnacle(struct IR_i2c ir, u32 ir_key, u32 *ir_raw,
b93eedb6 SP	157	int parity_offset, int marker, int code_modulo)
8069695c RC	158	{
	159	unsigned char b[4];
	160	unsigned int start = 0,parity = 0,code = 0;
	161
	162	/* poll IR chip */
	163	if (4 != i2c_master_recv(&ir->c,b,4)) {
	164	dprintk(2,"read error\n");
	165	return -EIO;
	166	}
	167
	168	for (start = 0; start<4; start++) {
b93eedb6 SP	169	if (b[start] == marker) {
	170	code=b[(start+parity_offset+1)%4];
	171	parity=b[(start+parity_offset)%4];
8069695c RC	172	}
	173	}
	174
	175	/* Empty Request */
	176	if (parity==0)
	177	return 0;
	178
	179	/* Repeating... */
	180	if (ir->old == parity)
	181	return 0;
	182
8069695c RC	183	ir->old = parity;
8069695c RC	184
b93eedb6 SP	185	/* drop special codes when a key is held down a long time for the grey controller
	186	In this case, the second bit of the code is asserted */
	187	if (marker == 0xfe && (code & 0x40))
	188	return 0;
8069695c	189
b93eedb6	190	code %= code_modulo;
8069695c RC	191
	192	*ir_raw = code;
	193	*ir_key = code;
	194
	195	dprintk(1,"Pinnacle PCTV key %02x\n", code);
	196
	197	return 1;
	198	}
	199
b93eedb6 SP	200	/* The grey pinnacle PCTV remote
	201	*
	202	* There are one issue with this remote:
	203	* - I2c packet does not change when the same key is pressed quickly. The workaround
	204	* is to hold down each key for about half a second, so that another code is generated
	205	* in the i2c packet, and the function can distinguish key presses.
	206	*
	207	* Sylvain Pasche <sylvain.pasche@gmail.com>
	208	*/
	209	int get_key_pinnacle_grey(struct IR_i2c ir, u32 ir_key, u32 *ir_raw)
	210	{
	211
	212	return get_key_pinnacle(ir, ir_key, ir_raw, 1, 0xfe, 0xff);
	213	}
	214
	215	EXPORT_SYMBOL_GPL(get_key_pinnacle_grey);
	216
	217
	218	/* The new pinnacle PCTV remote (with the colored buttons)
	219	*
	220	* Ricardo Cerqueira <v4l@cerqueira.org>
	221	*/
	222	int get_key_pinnacle_color(struct IR_i2c ir, u32 ir_key, u32 *ir_raw)
	223	{
	224	/* code_modulo parameter (0x88) is used to reduce code value to fit inside IR_KEYTAB_SIZE
	225	*
	226	* this is the only value that results in 42 unique
	227	* codes < 128
	228	*/
	229
	230	return get_key_pinnacle(ir, ir_key, ir_raw, 2, 0x80, 0x88);
	231	}
	232
	233	EXPORT_SYMBOL_GPL(get_key_pinnacle_color);
8069695c	234
1da177e4 LT	235	/* ----------------------------------------------------------------------- */
1da177e4 LT	236
d5e52653	237	static void ir_key_poll(struct IR_i2c *ir)
1da177e4 LT	238	{
	239	static u32 ir_key, ir_raw;
	240	int rc;
	241
	242	dprintk(2,"ir_poll_key\n");
	243	rc = ir->get_key(ir, &ir_key, &ir_raw);
	244	if (rc < 0) {
	245	dprintk(2,"error\n");
	246	return;
	247	}
	248
	249	if (0 == rc) {
b7df3910	250	ir_input_nokey(ir->input, &ir->ir);
1da177e4	251	} else {
b7df3910	252	ir_input_keydown(ir->input, &ir->ir, ir_key, ir_raw);
1da177e4 LT	253	}
	254	}
	255
	256	static void ir_timer(unsigned long data)
	257	{
d5e52653	258	struct IR_i2c ir = (struct IR_i2c)data;
1da177e4 LT	259	schedule_work(&ir->work);
	260	}
	261
	262	static void ir_work(void *data)
	263	{
d5e52653	264	struct IR_i2c *ir = data;
1da177e4 LT	265	ir_key_poll(ir);
	266	mod_timer(&ir->timer, jiffies+HZ/10);
	267	}
	268
	269	/* ----------------------------------------------------------------------- */
	270
	271	static int ir_attach(struct i2c_adapter *adap, int addr,
	272	unsigned short flags, int kind);
	273	static int ir_detach(struct i2c_client *client);
	274	static int ir_probe(struct i2c_adapter *adap);
	275
	276	static struct i2c_driver driver = {
604f28e2	277	.driver = {
cab462f7	278	.name = "ir-kbd-i2c",
604f28e2	279	},
dd815408	280	.id = I2C_DRIVERID_INFRARED,
4ac97914 MCC	281	.attach_adapter = ir_probe,
4ac97914 MCC	282	.detach_client = ir_detach,
1da177e4 LT	283	};
	284
	285	static struct i2c_client client_template =
	286	{
4ac97914 MCC	287	.name = "unset",
4ac97914 MCC	288	.driver = &driver
1da177e4 LT	289	};
	290
	291	static int ir_attach(struct i2c_adapter *adap, int addr,
	292	unsigned short flags, int kind)
	293	{
	294	IR_KEYTAB_TYPE *ir_codes = NULL;
	295	char *name;
	296	int ir_type;
afd1a0c9	297	struct IR_i2c *ir;
b7df3910	298	struct input_dev *input_dev;
1da177e4	299
674434c6	300	ir = kzalloc(sizeof(struct IR_i2c),GFP_KERNEL);
b7df3910 DT	301	input_dev = input_allocate_device();
b7df3910 DT	302	if (!ir \|\| !input_dev) {
b7df3910	303	input_free_device(input_dev);
d21838dd	304	kfree(ir);
afd1a0c9	305	return -ENOMEM;
b7df3910	306	}
d21838dd	307	memset(ir,0,sizeof(*ir));
b7df3910	308
1da177e4	309	ir->c = client_template;
b7df3910	310	ir->input = input_dev;
1da177e4	311
1da177e4 LT	312	ir->c.adapter = adap;
	313	ir->c.addr = addr;
	314
d21838dd MCC	315	i2c_set_clientdata(&ir->c, ir);
d21838dd MCC	316
1da177e4 LT	317	switch(addr) {
	318	case 0x64:
	319	name = "Pixelview";
	320	ir->get_key = get_key_pixelview;
	321	ir_type = IR_TYPE_OTHER;
	322	ir_codes = ir_codes_empty;
	323	break;
	324	case 0x4b:
	325	name = "PV951";
	326	ir->get_key = get_key_pv951;
	327	ir_type = IR_TYPE_OTHER;
	328	ir_codes = ir_codes_pv951;
	329	break;
	330	case 0x18:
	331	case 0x1a:
	332	name = "Hauppauge";
	333	ir->get_key = get_key_haup;
	334	ir_type = IR_TYPE_RC5;
bf47e4e4	335	if (hauppauge == 1) {
4c0f631e	336	ir_codes = ir_codes_hauppauge_new;
bf47e4e4 A	337	} else {
	338	ir_codes = ir_codes_rc5_tv;
	339	}
1da177e4 LT	340	break;
1da177e4 LT	341	case 0x30:
d5e52653 MCC	342	name = "KNC One";
	343	ir->get_key = get_key_knc1;
	344	ir_type = IR_TYPE_OTHER;
	345	ir_codes = ir_codes_empty;
1da177e4 LT	346	break;
1da177e4 LT	347	case 0x7a:
ac9cd976 RC	348	case 0x47:
	349	/* Handled by saa7134-input */
	350	name = "SAA713x remote";
d5e52653	351	ir_type = IR_TYPE_OTHER;
1da177e4 LT	352	break;
	353	default:
	354	/* shouldn't happen */
	355	printk(DEVNAME ": Huh? unknown i2c address (0x%02x)?\n",addr);
	356	kfree(ir);
	357	return -1;
	358	}
	359
ac9cd976	360	/* Sets name */
1da177e4	361	snprintf(ir->c.name, sizeof(ir->c.name), "i2c IR (%s)", name);
d5e52653 MCC	362	ir->ir_codes=ir_codes;
	363
	364	/* register i2c device
	365	* At device register, IR codes may be changed to be
	366	* board dependent.
674434c6	367	*/
d5e52653	368	i2c_attach_client(&ir->c);
1da177e4	369
ac9cd976 RC	370	/* If IR not supported or disabled, unregisters driver */
	371	if (ir->get_key == NULL) {
	372	i2c_detach_client(&ir->c);
	373	kfree(ir);
	374	return -1;
	375	}
	376
	377	/* Phys addr can only be set after attaching (for ir->c.dev.bus_id) */
	378	snprintf(ir->phys, sizeof(ir->phys), "%s/%s/ir0",
	379	ir->c.adapter->dev.bus_id,
	380	ir->c.dev.bus_id);
	381
1da177e4	382	/* init + register input device */
d21838dd MCC	383	ir_input_init(input_dev,&ir->ir,ir_type,ir->ir_codes);
	384	input_dev->id.bustype = BUS_I2C;
	385	input_dev->name = ir->c.name;
	386	input_dev->phys = ir->phys;
b7df3910	387
d5e52653	388	/* register event device */
b7df3910	389	input_register_device(ir->input);
d21838dd MCC	390	printk(DEVNAME ": %s detected at %s [%s]\n",
d21838dd MCC	391	ir->input->name,ir->input->phys,adap->name);
1da177e4 LT	392
	393	/* start polling via eventd */
	394	INIT_WORK(&ir->work, ir_work, ir);
	395	init_timer(&ir->timer);
	396	ir->timer.function = ir_timer;
	397	ir->timer.data = (unsigned long)ir;
	398	schedule_work(&ir->work);
	399
	400	return 0;
	401	}
	402
	403	static int ir_detach(struct i2c_client *client)
	404	{
4ac97914	405	struct IR_i2c *ir = i2c_get_clientdata(client);
1da177e4 LT	406
	407	/* kill outstanding polls */
	408	del_timer(&ir->timer);
	409	flush_scheduled_work();
	410
	411	/* unregister devices */
b7df3910	412	input_unregister_device(ir->input);
1da177e4 LT	413	i2c_detach_client(&ir->c);
	414
	415	/* free memory */
	416	kfree(ir);
	417	return 0;
	418	}
	419
	420	static int ir_probe(struct i2c_adapter *adap)
	421	{
	422
	423	/* The external IR receiver is at i2c address 0x34 (0x35 for
	424	reads). Future Hauppauge cards will have an internal
	425	receiver at 0x30 (0x31 for reads). In theory, both can be
	426	fitted, and Hauppauge suggest an external overrides an
	427	internal.
	428
	429	That's why we probe 0x1a (~0x34) first. CB
	430	*/
	431
	432	static const int probe_bttv[] = { 0x1a, 0x18, 0x4b, 0x64, 0x30, -1};
c2f6f9d8	433	static const int probe_saa7134[] = { 0x7a, 0x47, -1 };
b296fc60	434	static const int probe_em28XX[] = { 0x30, 0x47, -1 };
1da177e4	435	const int *probe = NULL;
4f9c05aa MCC	436	struct i2c_client c;
	437	unsigned char buf;
	438	int i,rc;
1da177e4 LT	439
1da177e4 LT	440	switch (adap->id) {
c7a46533	441	case I2C_HW_B_BT848:
1da177e4 LT	442	probe = probe_bttv;
1da177e4 LT	443	break;
51dab14e	444	case I2C_HW_B_CX2341X:
c097b045	445	probe = probe_bttv;
51dab14e	446	break;
1684a984	447	case I2C_HW_SAA7134:
1da177e4 LT	448	probe = probe_saa7134;
1da177e4 LT	449	break;
b296fc60 MCC	450	case I2C_HW_B_EM28XX:
b296fc60 MCC	451	probe = probe_em28XX;
c365864f	452	break;
1da177e4 LT	453	}
	454	if (NULL == probe)
	455	return 0;
	456
	457	memset(&c,0,sizeof(c));
	458	c.adapter = adap;
d5e52653	459	for (i = 0; -1 != probe[i]; i++) {
1da177e4	460	c.addr = probe[i];
d5e52653	461	rc = i2c_master_recv(&c,&buf,0);
1da177e4 LT	462	dprintk(1,"probe 0x%02x @ %s: %s\n",
1da177e4 LT	463	probe[i], adap->name,
d5e52653 MCC	464	(0 == rc) ? "yes" : "no");
	465	if (0 == rc) {
	466	ir_attach(adap,probe[i],0,0);
	467	break;
1da177e4 LT	468	}
	469	}
	470	return 0;
	471	}
	472
	473	/* ----------------------------------------------------------------------- */
	474
	475	MODULE_AUTHOR("Gerd Knorr, Michal Kochanowicz, Christoph Bartelmus, Ulrich Mueller");
	476	MODULE_DESCRIPTION("input driver for i2c IR remote controls");
	477	MODULE_LICENSE("GPL");
	478
	479	static int __init ir_init(void)
	480	{
	481	return i2c_add_driver(&driver);
	482	}
	483
	484	static void __exit ir_fini(void)
	485	{
	486	i2c_del_driver(&driver);
	487	}
	488
	489	module_init(ir_init);
	490	module_exit(ir_fini);
	491
	492	/*
	493	* Overrides for Emacs so that we follow Linus's tabbing style.
	494	* ---------------------------------------------------------------------------
	495	* Local variables:
	496	* c-basic-offset: 8
	497	* End:
	498	*/