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