[linux-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>
 * modified for DViCO Fusion HDTV 5 RT GOLD by
 *      Chaogui Zhang <czhang1974@gmail.com>
 * modified for MSI TV@nywhere Plus by
 *      Henry Wong <henry@stuffedcow.net>
 *      Mark Schultz <n9xmj@yahoo.com>
 *      Brian Rogers <brian_rogers@comcast.net>
 * modified for AVerMedia Cardbus by
 *      Oldrich Jedlicka <oldium.pro@seznam.cz>
 *
 *  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/init.h>
#include <linux/kernel.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/i2c-id.h>
#include <linux/workqueue.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;
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_common(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw,
			       int size, int offset)
{
	unsigned char buf[6];
	int start, range, toggle, dev, code, ircode;

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

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

	/* rc5 has two start bits
	 * the first bit must be one
	 * the second bit defines the command range (1 = 0-63, 0 = 64 - 127)
	 */
	if (!start)
		/* no key pressed */
		return 0;
	/*
	 * Hauppauge remotes (black/silver) always use
	 * specific device ids. If we do not filter the
	 * device ids then messages destined for devices
	 * such as TVs (id=0) will get through causing
	 * mis-fired events.
	 *
	 * We also filter out invalid key presses which
	 * produce annoying debug log entries.
	 */
	ircode= (start << 12) | (toggle << 11) | (dev << 6) | code;
	if ((ircode & 0x1fff)==0x1fff)
		/* invalid key press */
		return 0;

	if (dev!=0x1e && dev!=0x1f)
		/* not a hauppauge remote */
		return 0;

	if (!range)
		code += 64;

	dprintk(1,"ir hauppauge (rc5): s%d r%d t%d dev=%d code=%d\n",
		start, range, toggle, dev, code);

	/* return key */
	*ir_key = code;
	*ir_raw = ircode;
	return 1;
}

static int get_key_haup(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
{
	return get_key_haup_common (ir, ir_key, ir_raw, 3, 0);
}

static int get_key_haup_xvr(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
{
	return get_key_haup_common (ir, ir_key, ir_raw, 6, 3);
}

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_fusionhdtv(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
{
	unsigned char buf[4];

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

	if(buf[0] !=0 || buf[1] !=0 || buf[2] !=0 || buf[3] != 0)
		dprintk(2, "%s: 0x%2x 0x%2x 0x%2x 0x%2x\n", __func__,
			buf[0], buf[1], buf[2], buf[3]);

	/* no key pressed or signal from other ir remote */
	if(buf[0] != 0x1 ||  buf[1] != 0xfe)
		return 0;

	*ir_key = buf[2];
	*ir_raw = (buf[2] << 8) | buf[3];

	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 int get_key_avermedia_cardbus(struct IR_i2c *ir,
				     u32 *ir_key, u32 *ir_raw)
{
	unsigned char subaddr, key, keygroup;
	struct i2c_msg msg[] = { { .addr = ir->c->addr, .flags = 0,
				   .buf = &subaddr, .len = 1},
				 { .addr = ir->c->addr, .flags = I2C_M_RD,
				  .buf = &key, .len = 1} };
	subaddr = 0x0d;
	if (2 != i2c_transfer(ir->c->adapter, msg, 2)) {
		dprintk(1, "read error\n");
		return -EIO;
	}

	if (key == 0xff)
		return 0;

	subaddr = 0x0b;
	msg[1].buf = &keygroup;
	if (2 != i2c_transfer(ir->c->adapter, msg, 2)) {
		dprintk(1, "read error\n");
		return -EIO;
	}

	if (keygroup == 0xff)
		return 0;

	dprintk(1, "read key 0x%02x/0x%02x\n", key, keygroup);
	if (keygroup < 2 || keygroup > 3) {
		/* Only a warning */
		dprintk(1, "warning: invalid key group 0x%02x for key 0x%02x\n",
								keygroup, key);
	}
	key |= (keygroup & 1) << 6;

	*ir_key = key;
	*ir_raw = key;
	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_work(struct work_struct *work)
{
	struct IR_i2c *ir = container_of(work, struct IR_i2c, work.work);
	int polling_interval = 100;

	/* MSI TV@nywhere Plus requires more frequent polling
	   otherwise it will miss some keypresses */
	if (ir->c->adapter->id == I2C_HW_SAA7134 && ir->c->addr == 0x30)
		polling_interval = 50;

	ir_key_poll(ir);
	schedule_delayed_work(&ir->work, msecs_to_jiffies(polling_interval));
}

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

static int ir_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
	struct ir_scancode_table *ir_codes = NULL;
	const char *name = NULL;
	int ir_type;
	struct IR_i2c *ir;
	struct input_dev *input_dev;
	struct i2c_adapter *adap = client->adapter;
	unsigned short addr = client->addr;
	int err;

	ir = kzalloc(sizeof(struct IR_i2c),GFP_KERNEL);
	input_dev = input_allocate_device();
	if (!ir || !input_dev) {
		err = -ENOMEM;
		goto err_out_free;
	}

	ir->c = client;
	ir->input = input_dev;
	i2c_set_clientdata(client, ir);

	switch(addr) {
	case 0x64:
		name        = "Pixelview";
		ir->get_key = get_key_pixelview;
		ir_type     = IR_TYPE_OTHER;
		ir_codes    = &ir_codes_empty_table;
		break;
	case 0x4b:
		name        = "PV951";
		ir->get_key = get_key_pv951;
		ir_type     = IR_TYPE_OTHER;
		ir_codes    = &ir_codes_pv951_table;
		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_table;
		} else {
			ir_codes    = &ir_codes_rc5_tv_table;
		}
		break;
	case 0x30:
		name        = "KNC One";
		ir->get_key = get_key_knc1;
		ir_type     = IR_TYPE_OTHER;
		ir_codes    = &ir_codes_empty_table;
		break;
	case 0x6b:
		name        = "FusionHDTV";
		ir->get_key = get_key_fusionhdtv;
		ir_type     = IR_TYPE_RC5;
		ir_codes    = &ir_codes_fusionhdtv_mce_table;
		break;
	case 0x7a:
	case 0x47:
	case 0x71:
	case 0x2d:
		if (adap->id == I2C_HW_B_CX2388x ||
		    adap->id == I2C_HW_B_CX2341X) {
			/* Handled by cx88-input */
			name = adap->id == I2C_HW_B_CX2341X ? "CX2341x remote"
							    : "CX2388x remote";
			ir_type     = IR_TYPE_RC5;
			ir->get_key = get_key_haup_xvr;
			if (hauppauge == 1) {
				ir_codes    = &ir_codes_hauppauge_new_table;
			} else {
				ir_codes    = &ir_codes_rc5_tv_table;
			}
		} else {
			/* Handled by saa7134-input */
			name        = "SAA713x remote";
			ir_type     = IR_TYPE_OTHER;
		}
		break;
	case 0x40:
		name        = "AVerMedia Cardbus remote";
		ir->get_key = get_key_avermedia_cardbus;
		ir_type     = IR_TYPE_OTHER;
		ir_codes    = &ir_codes_avermedia_cardbus_table;
		break;
	default:
		dprintk(1, DEVNAME ": Unsupported i2c address 0x%02x\n", addr);
		err = -ENODEV;
		goto err_out_free;
	}

	/* Let the caller override settings */
	if (client->dev.platform_data) {
		const struct IR_i2c_init_data *init_data =
						client->dev.platform_data;

		ir_codes = init_data->ir_codes;
		name = init_data->name;
		if (init_data->type)
			ir_type = init_data->type;

		switch (init_data->internal_get_key_func) {
		case IR_KBD_GET_KEY_CUSTOM:
			/* The bridge driver provided us its own function */
			ir->get_key = init_data->get_key;
			break;
		case IR_KBD_GET_KEY_PIXELVIEW:
			ir->get_key = get_key_pixelview;
			break;
		case IR_KBD_GET_KEY_PV951:
			ir->get_key = get_key_pv951;
			break;
		case IR_KBD_GET_KEY_HAUP:
			ir->get_key = get_key_haup;
			break;
		case IR_KBD_GET_KEY_KNC1:
			ir->get_key = get_key_knc1;
			break;
		case IR_KBD_GET_KEY_FUSIONHDTV:
			ir->get_key = get_key_fusionhdtv;
			break;
		case IR_KBD_GET_KEY_HAUP_XVR:
			ir->get_key = get_key_haup_xvr;
			break;
		case IR_KBD_GET_KEY_AVERMEDIA_CARDBUS:
			ir->get_key = get_key_avermedia_cardbus;
			break;
		}
	}

	/* Make sure we are all setup before going on */
	if (!name || !ir->get_key || !ir_codes) {
		dprintk(1, DEVNAME ": Unsupported device at address 0x%02x\n",
			addr);
		err = -ENODEV;
		goto err_out_free;
	}

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

	snprintf(ir->phys, sizeof(ir->phys), "%s/%s/ir0",
		 dev_name(&adap->dev),
		 dev_name(&client->dev));

	/* 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->name;
	input_dev->phys       = ir->phys;

	err = input_register_device(ir->input);
	if (err)
		goto err_out_free;

	printk(DEVNAME ": %s detected at %s [%s]\n",
	       ir->input->name, ir->input->phys, adap->name);

	/* start polling via eventd */
	INIT_DELAYED_WORK(&ir->work, ir_work);
	schedule_delayed_work(&ir->work, 0);

	return 0;

 err_out_free:
	input_free_device(input_dev);
	kfree(ir);
	return err;
}

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

	/* kill outstanding polls */
	cancel_delayed_work_sync(&ir->work);

	/* unregister device */
	input_unregister_device(ir->input);

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

static const struct i2c_device_id ir_kbd_id[] = {
	/* Generic entry for any IR receiver */
	{ "ir_video", 0 },
	/* IR device specific entries should be added here */
	{ "ir_rx_z8f0811_haup", 0 },
	{ }
};

static struct i2c_driver driver = {
	.driver = {
		.name   = "ir-kbd-i2c",
	},
	.probe          = ir_probe,
	.remove         = ir_remove,
	.id_table       = ir_kbd_id,
};

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

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>
d54d6980 CZ	13	* modified for DViCO Fusion HDTV 5 RT GOLD by
d54d6980 CZ	14	* Chaogui Zhang <czhang1974@gmail.com>
ba340b40 BR	15	* modified for MSI TV@nywhere Plus by
	16	* Henry Wong <henry@stuffedcow.net>
	17	* Mark Schultz <n9xmj@yahoo.com>
	18	* Brian Rogers <brian_rogers@comcast.net>
cb3bf504 OJ	19	* modified for AVerMedia Cardbus by
cb3bf504 OJ	20	* Oldrich Jedlicka <oldium.pro@seznam.cz>
1da177e4 LT	21	*
	22	* This program is free software; you can redistribute it and/or modify
	23	* it under the terms of the GNU General Public License as published by
	24	* the Free Software Foundation; either version 2 of the License, or
	25	* (at your option) any later version.
	26	*
	27	* This program is distributed in the hope that it will be useful,
	28	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	29	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	30	* GNU General Public License for more details.
	31	*
	32	* You should have received a copy of the GNU General Public License
	33	* along with this program; if not, write to the Free Software
	34	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	35	*
	36	*/
	37
	38	#include <linux/module.h>
1da177e4 LT	39	#include <linux/init.h>
1da177e4 LT	40	#include <linux/kernel.h>
1da177e4 LT	41	#include <linux/string.h>
	42	#include <linux/timer.h>
	43	#include <linux/delay.h>
	44	#include <linux/errno.h>
	45	#include <linux/slab.h>
	46	#include <linux/i2c.h>
39cf1e81	47	#include <linux/i2c-id.h>
1da177e4	48	#include <linux/workqueue.h>
674434c6	49
1da177e4	50	#include <media/ir-common.h>
d5e52653	51	#include <media/ir-kbd-i2c.h>
c365864f	52
1da177e4 LT	53	/* ----------------------------------------------------------------------- */
	54	/* insmod parameters */
	55
	56	static int debug;
	57	module_param(debug, int, 0644); /* debug level (0,1,2) */
	58
ff699e6b	59	static int hauppauge;
bf47e4e4 A	60	module_param(hauppauge, int, 0644); /* Choose Hauppauge remote */
	61	MODULE_PARM_DESC(hauppauge, "Specify Hauppauge remote: 0=black, 1=grey (defaults to 0)");
	62
	63
1da177e4 LT	64	#define DEVNAME "ir-kbd-i2c"
	65	#define dprintk(level, fmt, arg...) if (debug >= level) \
	66	printk(KERN_DEBUG DEVNAME ": " fmt , ## arg)
	67
	68	/* ----------------------------------------------------------------------- */
	69
39cf1e81 JF	70	static int get_key_haup_common(struct IR_i2c ir, u32 ir_key, u32 *ir_raw,
39cf1e81 JF	71	int size, int offset)
1da177e4	72	{
39cf1e81	73	unsigned char buf[6];
34c08029	74	int start, range, toggle, dev, code, ircode;
1da177e4 LT	75
1da177e4 LT	76	/* poll IR chip */
c668f32d	77	if (size != i2c_master_recv(ir->c, buf, size))
1da177e4 LT	78	return -EIO;
	79
	80	/* split rc5 data block ... */
39cf1e81 JF	81	start = (buf[offset] >> 7) & 1;
	82	range = (buf[offset] >> 6) & 1;
	83	toggle = (buf[offset] >> 5) & 1;
	84	dev = buf[offset] & 0x1f;
	85	code = (buf[offset+1] >> 2) & 0x3f;
1da177e4	86
cc7093df DH	87	/* rc5 has two start bits
	88	* the first bit must be one
	89	* the second bit defines the command range (1 = 0-63, 0 = 64 - 127)
	90	*/
	91	if (!start)
1da177e4 LT	92	/* no key pressed */
1da177e4 LT	93	return 0;
34c08029 DB	94	/*
	95	* Hauppauge remotes (black/silver) always use
	96	* specific device ids. If we do not filter the
	97	* device ids then messages destined for devices
	98	* such as TVs (id=0) will get through causing
	99	* mis-fired events.
	100	*
	101	* We also filter out invalid key presses which
	102	* produce annoying debug log entries.
	103	*/
	104	ircode= (start << 12) \| (toggle << 11) \| (dev << 6) \| code;
	105	if ((ircode & 0x1fff)==0x1fff)
	106	/* invalid key press */
	107	return 0;
	108
	109	if (dev!=0x1e && dev!=0x1f)
	110	/* not a hauppauge remote */
	111	return 0;
cc7093df DH	112
	113	if (!range)
	114	code += 64;
	115
	116	dprintk(1,"ir hauppauge (rc5): s%d r%d t%d dev=%d code=%d\n",
	117	start, range, toggle, dev, code);
1da177e4 LT	118
	119	/* return key */
	120	*ir_key = code;
34c08029	121	*ir_raw = ircode;
1da177e4 LT	122	return 1;
	123	}
	124
157da276	125	static int get_key_haup(struct IR_i2c ir, u32 ir_key, u32 *ir_raw)
39cf1e81 JF	126	{
	127	return get_key_haup_common (ir, ir_key, ir_raw, 3, 0);
	128	}
	129
157da276	130	static int get_key_haup_xvr(struct IR_i2c ir, u32 ir_key, u32 *ir_raw)
39cf1e81 JF	131	{
	132	return get_key_haup_common (ir, ir_key, ir_raw, 6, 3);
	133	}
	134
d5e52653	135	static int get_key_pixelview(struct IR_i2c ir, u32 ir_key, u32 *ir_raw)
1da177e4	136	{
4ac97914	137	unsigned char b;
1da177e4 LT	138
1da177e4 LT	139	/* poll IR chip */
c668f32d	140	if (1 != i2c_master_recv(ir->c, &b, 1)) {
1da177e4 LT	141	dprintk(1,"read error\n");
	142	return -EIO;
	143	}
	144	*ir_key = b;
	145	*ir_raw = b;
	146	return 1;
	147	}
	148
d5e52653	149	static int get_key_pv951(struct IR_i2c ir, u32 ir_key, u32 *ir_raw)
1da177e4	150	{
4ac97914	151	unsigned char b;
1da177e4 LT	152
1da177e4 LT	153	/* poll IR chip */
c668f32d	154	if (1 != i2c_master_recv(ir->c, &b, 1)) {
1da177e4 LT	155	dprintk(1,"read error\n");
	156	return -EIO;
	157	}
	158
	159	/* ignore 0xaa */
	160	if (b==0xaa)
	161	return 0;
	162	dprintk(2,"key %02x\n", b);
	163
	164	*ir_key = b;
	165	*ir_raw = b;
	166	return 1;
	167	}
	168
3c44358c	169	static int get_key_fusionhdtv(struct IR_i2c ir, u32 ir_key, u32 *ir_raw)
d54d6980 CZ	170	{
	171	unsigned char buf[4];
	172
	173	/* poll IR chip */
c668f32d	174	if (4 != i2c_master_recv(ir->c, buf, 4)) {
d54d6980 CZ	175	dprintk(1,"read error\n");
	176	return -EIO;
	177	}
	178
	179	if(buf[0] !=0 \|\| buf[1] !=0 \|\| buf[2] !=0 \|\| buf[3] != 0)
7e28adb2	180	dprintk(2, "%s: 0x%2x 0x%2x 0x%2x 0x%2x\n", __func__,
d54d6980 CZ	181	buf[0], buf[1], buf[2], buf[3]);
	182
	183	/* no key pressed or signal from other ir remote */
	184	if(buf[0] != 0x1 \|\| buf[1] != 0xfe)
	185	return 0;
	186
	187	*ir_key = buf[2];
	188	*ir_raw = (buf[2] << 8) \| buf[3];
	189
	190	return 1;
d54d6980 CZ	191	}
d54d6980 CZ	192
d5e52653	193	static int get_key_knc1(struct IR_i2c ir, u32 ir_key, u32 *ir_raw)
1da177e4 LT	194	{
	195	unsigned char b;
	196
	197	/* poll IR chip */
c668f32d	198	if (1 != i2c_master_recv(ir->c, &b, 1)) {
1da177e4 LT	199	dprintk(1,"read error\n");
	200	return -EIO;
	201	}
	202
	203	/* it seems that 0xFE indicates that a button is still hold
4f9c05aa MCC	204	down, while 0xff indicates that no button is hold
4f9c05aa MCC	205	down. 0xfe sequences are sometimes interrupted by 0xFF */
1da177e4 LT	206
	207	dprintk(2,"key %02x\n", b);
	208
4f9c05aa	209	if (b == 0xff)
1da177e4 LT	210	return 0;
1da177e4 LT	211
4f9c05aa	212	if (b == 0xfe)
1da177e4 LT	213	/* keep old data */
	214	return 1;
	215
	216	*ir_key = b;
	217	*ir_raw = b;
	218	return 1;
	219	}
	220
cb3bf504 OJ	221	static int get_key_avermedia_cardbus(struct IR_i2c *ir,
	222	u32 ir_key, u32 ir_raw)
	223	{
	224	unsigned char subaddr, key, keygroup;
c668f32d	225	struct i2c_msg msg[] = { { .addr = ir->c->addr, .flags = 0,
cb3bf504	226	.buf = &subaddr, .len = 1},
c668f32d	227	{ .addr = ir->c->addr, .flags = I2C_M_RD,
cb3bf504 OJ	228	.buf = &key, .len = 1} };
cb3bf504 OJ	229	subaddr = 0x0d;
c668f32d	230	if (2 != i2c_transfer(ir->c->adapter, msg, 2)) {
cb3bf504 OJ	231	dprintk(1, "read error\n");
	232	return -EIO;
	233	}
	234
	235	if (key == 0xff)
	236	return 0;
	237
	238	subaddr = 0x0b;
	239	msg[1].buf = &keygroup;
c668f32d	240	if (2 != i2c_transfer(ir->c->adapter, msg, 2)) {
cb3bf504 OJ	241	dprintk(1, "read error\n");
	242	return -EIO;
	243	}
	244
	245	if (keygroup == 0xff)
	246	return 0;
	247
	248	dprintk(1, "read key 0x%02x/0x%02x\n", key, keygroup);
	249	if (keygroup < 2 \|\| keygroup > 3) {
	250	/* Only a warning */
	251	dprintk(1, "warning: invalid key group 0x%02x for key 0x%02x\n",
	252	keygroup, key);
	253	}
	254	key \|= (keygroup & 1) << 6;
	255
	256	*ir_key = key;
	257	*ir_raw = key;
	258	return 1;
	259	}
	260
1da177e4 LT	261	/* ----------------------------------------------------------------------- */
1da177e4 LT	262
d5e52653	263	static void ir_key_poll(struct IR_i2c *ir)
1da177e4 LT	264	{
	265	static u32 ir_key, ir_raw;
	266	int rc;
	267
	268	dprintk(2,"ir_poll_key\n");
	269	rc = ir->get_key(ir, &ir_key, &ir_raw);
	270	if (rc < 0) {
	271	dprintk(2,"error\n");
	272	return;
	273	}
	274
	275	if (0 == rc) {
b7df3910	276	ir_input_nokey(ir->input, &ir->ir);
1da177e4	277	} else {
b7df3910	278	ir_input_keydown(ir->input, &ir->ir, ir_key, ir_raw);
1da177e4 LT	279	}
	280	}
	281
c4028958	282	static void ir_work(struct work_struct *work)
1da177e4	283	{
c1089bdc	284	struct IR_i2c *ir = container_of(work, struct IR_i2c, work.work);
ba340b40 BR	285	int polling_interval = 100;
	286
	287	/* MSI TV@nywhere Plus requires more frequent polling
	288	otherwise it will miss some keypresses */
c668f32d	289	if (ir->c->adapter->id == I2C_HW_SAA7134 && ir->c->addr == 0x30)
ba340b40	290	polling_interval = 50;
8083c520	291
1da177e4	292	ir_key_poll(ir);
c1089bdc	293	schedule_delayed_work(&ir->work, msecs_to_jiffies(polling_interval));
1da177e4 LT	294	}
	295
	296	/* ----------------------------------------------------------------------- */
	297
c668f32d	298	static int ir_probe(struct i2c_client client, const struct i2c_device_id id)
1da177e4	299	{
715a2233	300	struct ir_scancode_table *ir_codes = NULL;
9a4cc5ac	301	const char *name = NULL;
1da177e4	302	int ir_type;
afd1a0c9	303	struct IR_i2c *ir;
b7df3910	304	struct input_dev *input_dev;
c668f32d JD	305	struct i2c_adapter *adap = client->adapter;
c668f32d JD	306	unsigned short addr = client->addr;
b07b4783	307	int err;
1da177e4	308
674434c6	309	ir = kzalloc(sizeof(struct IR_i2c),GFP_KERNEL);
b7df3910 DT	310	input_dev = input_allocate_device();
b7df3910 DT	311	if (!ir \|\| !input_dev) {
b07b4783 DT	312	err = -ENOMEM;
b07b4783 DT	313	goto err_out_free;
b7df3910 DT	314	}
b7df3910 DT	315
c668f32d	316	ir->c = client;
b7df3910	317	ir->input = input_dev;
c668f32d	318	i2c_set_clientdata(client, ir);
d21838dd	319
1da177e4 LT	320	switch(addr) {
	321	case 0x64:
	322	name = "Pixelview";
	323	ir->get_key = get_key_pixelview;
	324	ir_type = IR_TYPE_OTHER;
715a2233	325	ir_codes = &ir_codes_empty_table;
1da177e4 LT	326	break;
	327	case 0x4b:
	328	name = "PV951";
	329	ir->get_key = get_key_pv951;
	330	ir_type = IR_TYPE_OTHER;
715a2233	331	ir_codes = &ir_codes_pv951_table;
1da177e4 LT	332	break;
	333	case 0x18:
	334	case 0x1a:
	335	name = "Hauppauge";
	336	ir->get_key = get_key_haup;
	337	ir_type = IR_TYPE_RC5;
bf47e4e4	338	if (hauppauge == 1) {
715a2233	339	ir_codes = &ir_codes_hauppauge_new_table;
bf47e4e4	340	} else {
715a2233	341	ir_codes = &ir_codes_rc5_tv_table;
bf47e4e4	342	}
1da177e4 LT	343	break;
1da177e4 LT	344	case 0x30:
d5e52653 MCC	345	name = "KNC One";
	346	ir->get_key = get_key_knc1;
	347	ir_type = IR_TYPE_OTHER;
715a2233	348	ir_codes = &ir_codes_empty_table;
1da177e4	349	break;
d54d6980	350	case 0x6b:
3c44358c MK	351	name = "FusionHDTV";
3c44358c MK	352	ir->get_key = get_key_fusionhdtv;
d54d6980	353	ir_type = IR_TYPE_RC5;
715a2233	354	ir_codes = &ir_codes_fusionhdtv_mce_table;
d54d6980	355	break;
1da177e4	356	case 0x7a:
ac9cd976	357	case 0x47:
177aaaf8	358	case 0x71:
e8018c9e	359	case 0x2d:
f5d887ae AW	360	if (adap->id == I2C_HW_B_CX2388x \|\|
f5d887ae AW	361	adap->id == I2C_HW_B_CX2341X) {
39cf1e81	362	/* Handled by cx88-input */
f5d887ae AW	363	name = adap->id == I2C_HW_B_CX2341X ? "CX2341x remote"
f5d887ae AW	364	: "CX2388x remote";
39cf1e81 JF	365	ir_type = IR_TYPE_RC5;
	366	ir->get_key = get_key_haup_xvr;
	367	if (hauppauge == 1) {
715a2233	368	ir_codes = &ir_codes_hauppauge_new_table;
39cf1e81	369	} else {
715a2233	370	ir_codes = &ir_codes_rc5_tv_table;
39cf1e81 JF	371	}
	372	} else {
	373	/* Handled by saa7134-input */
	374	name = "SAA713x remote";
	375	ir_type = IR_TYPE_OTHER;
	376	}
1da177e4	377	break;
cb3bf504 OJ	378	case 0x40:
	379	name = "AVerMedia Cardbus remote";
	380	ir->get_key = get_key_avermedia_cardbus;
	381	ir_type = IR_TYPE_OTHER;
715a2233	382	ir_codes = &ir_codes_avermedia_cardbus_table;
cb3bf504	383	break;
1da177e4	384	default:
9a4cc5ac	385	dprintk(1, DEVNAME ": Unsupported i2c address 0x%02x\n", addr);
b07b4783 DT	386	err = -ENODEV;
b07b4783 DT	387	goto err_out_free;
1da177e4 LT	388	}
1da177e4 LT	389
4d7a2d67 JD	390	/* Let the caller override settings */
	391	if (client->dev.platform_data) {
	392	const struct IR_i2c_init_data *init_data =
	393	client->dev.platform_data;
	394
	395	ir_codes = init_data->ir_codes;
	396	name = init_data->name;
1b6e59e3 AW	397	if (init_data->type)
	398	ir_type = init_data->type;
	399
	400	switch (init_data->internal_get_key_func) {
	401	case IR_KBD_GET_KEY_CUSTOM:
	402	/* The bridge driver provided us its own function */
	403	ir->get_key = init_data->get_key;
	404	break;
	405	case IR_KBD_GET_KEY_PIXELVIEW:
	406	ir->get_key = get_key_pixelview;
	407	break;
	408	case IR_KBD_GET_KEY_PV951:
	409	ir->get_key = get_key_pv951;
	410	break;
	411	case IR_KBD_GET_KEY_HAUP:
	412	ir->get_key = get_key_haup;
	413	break;
	414	case IR_KBD_GET_KEY_KNC1:
	415	ir->get_key = get_key_knc1;
	416	break;
	417	case IR_KBD_GET_KEY_FUSIONHDTV:
	418	ir->get_key = get_key_fusionhdtv;
	419	break;
	420	case IR_KBD_GET_KEY_HAUP_XVR:
	421	ir->get_key = get_key_haup_xvr;
	422	break;
	423	case IR_KBD_GET_KEY_AVERMEDIA_CARDBUS:
	424	ir->get_key = get_key_avermedia_cardbus;
	425	break;
	426	}
4d7a2d67 JD	427	}
4d7a2d67 JD	428
9a4cc5ac JD	429	/* Make sure we are all setup before going on */
	430	if (!name \|\| !ir->get_key \|\| !ir_codes) {
	431	dprintk(1, DEVNAME ": Unsupported device at address 0x%02x\n",
	432	addr);
	433	err = -ENODEV;
	434	goto err_out_free;
	435	}
	436
ac9cd976	437	/* Sets name */
1df8e986	438	snprintf(ir->name, sizeof(ir->name), "i2c IR (%s)", name);
b07b4783	439	ir->ir_codes = ir_codes;
d5e52653	440
ac9cd976	441	snprintf(ir->phys, sizeof(ir->phys), "%s/%s/ir0",
c668f32d JD	442	dev_name(&adap->dev),
c668f32d JD	443	dev_name(&client->dev));
ac9cd976	444
1da177e4	445	/* init + register input device */
b07b4783	446	ir_input_init(input_dev, &ir->ir, ir_type, ir->ir_codes);
d21838dd	447	input_dev->id.bustype = BUS_I2C;
1df8e986	448	input_dev->name = ir->name;
d21838dd	449	input_dev->phys = ir->phys;
b7df3910	450
b07b4783 DT	451	err = input_register_device(ir->input);
b07b4783 DT	452	if (err)
c668f32d	453	goto err_out_free;
b07b4783	454
d21838dd	455	printk(DEVNAME ": %s detected at %s [%s]\n",
b07b4783	456	ir->input->name, ir->input->phys, adap->name);
1da177e4 LT	457
1da177e4 LT	458	/* start polling via eventd */
c1089bdc JD	459	INIT_DELAYED_WORK(&ir->work, ir_work);
c1089bdc JD	460	schedule_delayed_work(&ir->work, 0);
1da177e4 LT	461
1da177e4 LT	462	return 0;
b07b4783	463
b07b4783 DT	464	err_out_free:
	465	input_free_device(input_dev);
	466	kfree(ir);
	467	return err;
1da177e4 LT	468	}
1da177e4 LT	469
c668f32d	470	static int ir_remove(struct i2c_client *client)
1da177e4	471	{
4ac97914	472	struct IR_i2c *ir = i2c_get_clientdata(client);
1da177e4 LT	473
1da177e4 LT	474	/* kill outstanding polls */
c1089bdc	475	cancel_delayed_work_sync(&ir->work);
1da177e4	476
c668f32d	477	/* unregister device */
b7df3910	478	input_unregister_device(ir->input);
1da177e4 LT	479
	480	/* free memory */
	481	kfree(ir);
	482	return 0;
	483	}
	484
c668f32d JD	485	static const struct i2c_device_id ir_kbd_id[] = {
	486	/* Generic entry for any IR receiver */
	487	{ "ir_video", 0 },
f5d887ae AW	488	/* IR device specific entries should be added here */
f5d887ae AW	489	{ "ir_rx_z8f0811_haup", 0 },
c668f32d JD	490	{ }
c668f32d JD	491	};
cb3bf504	492
c668f32d JD	493	static struct i2c_driver driver = {
	494	.driver = {
	495	.name = "ir-kbd-i2c",
	496	},
	497	.probe = ir_probe,
	498	.remove = ir_remove,
	499	.id_table = ir_kbd_id,
	500	};
1da177e4 LT	501
	502	/* ----------------------------------------------------------------------- */
	503
	504	MODULE_AUTHOR("Gerd Knorr, Michal Kochanowicz, Christoph Bartelmus, Ulrich Mueller");
	505	MODULE_DESCRIPTION("input driver for i2c IR remote controls");
	506	MODULE_LICENSE("GPL");
	507
	508	static int __init ir_init(void)
	509	{
	510	return i2c_add_driver(&driver);
	511	}
	512
	513	static void __exit ir_fini(void)
	514	{
	515	i2c_del_driver(&driver);
	516	}
	517
	518	module_init(ir_init);
	519	module_exit(ir_fini);
	520
	521	/*
	522	* Overrides for Emacs so that we follow Linus's tabbing style.
	523	* ---------------------------------------------------------------------------
	524	* Local variables:
	525	* c-basic-offset: 8
	526	* End:
	527	*/