[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>
 * 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 inline 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 inline 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_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;
	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_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 0x6b:
		name        = "FusionHDTV";
		ir->get_key = get_key_fusionhdtv;
		ir_type     = IR_TYPE_RC5;
		ir_codes    = ir_codes_fusionhdtv_mce;
		break;
	case 0x7a:
	case 0x47:
	case 0x71:
	case 0x2d:
		if (adap->id == I2C_HW_B_CX2388x) {
			/* Handled by cx88-input */
			name        = "CX2388x remote";
			ir_type     = IR_TYPE_RC5;
			ir->get_key = get_key_haup_xvr;
			if (hauppauge == 1) {
				ir_codes    = ir_codes_hauppauge_new;
			} else {
				ir_codes    = ir_codes_rc5_tv;
			}
		} 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;
		break;
	default:
		/* shouldn't happen */
		printk(DEVNAME ": Huh? unknown i2c address (0x%02x)?\n", addr);
		err = -ENODEV;
		goto err_out_free;
	}

	/* 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.
	 */
	err = i2c_attach_client(&ir->c);
	if (err)
		goto err_out_free;

	/* If IR not supported or disabled, unregisters driver */
	if (ir->get_key == NULL) {
		err = -ENODEV;
		goto err_out_detach;
	}

	/* Phys addr can only be set after attaching (for ir->c.dev) */
	snprintf(ir->phys, sizeof(ir->phys), "%s/%s/ir0",
		 dev_name(&ir->c.adapter->dev),
		 dev_name(&ir->c.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->c.name;
	input_dev->phys       = ir->phys;

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

	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_detach:
	i2c_detach_client(&ir->c);
 err_out_free:
	input_free_device(input_dev);
	kfree(ir);
	return err;
}

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

	/* kill outstanding polls */
	cancel_delayed_work_sync(&ir->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, 0x71, 0x2d, -1 };
	static const int probe_em28XX[] = { 0x30, 0x47, -1 };
	static const int probe_cx88[] = { 0x18, 0x6b, 0x71, -1 };
	static const int probe_cx23885[] = { 0x6b, -1 };
	const int *probe;
	struct i2c_msg msg = {
		.flags = I2C_M_RD,
		.len = 0,
		.buf = NULL,
	};
	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;
	case I2C_HW_B_CX2388x:
		probe = probe_cx88;
		break;
	case I2C_HW_B_CX23885:
		probe = probe_cx23885;
		break;
	default:
		return 0;
	}

	for (i = 0; -1 != probe[i]; i++) {
		msg.addr = probe[i];
		rc = i2c_transfer(adap, &msg, 1);
		dprintk(1,"probe 0x%02x @ %s: %s\n",
			probe[i], adap->name,
			(1 == rc) ? "yes" : "no");
		if (1 == rc) {
			ir_attach(adap, probe[i], 0, 0);
			return 0;
		}
	}

	/* Special case for MSI TV@nywhere Plus remote */
	if (adap->id == I2C_HW_SAA7134) {
		u8 temp;

		/* MSI TV@nywhere Plus controller doesn't seem to
		   respond to probes unless we read something from
		   an existing device. Weird... */

		msg.addr = 0x50;
		rc = i2c_transfer(adap, &msg, 1);
			dprintk(1, "probe 0x%02x @ %s: %s\n",
			msg.addr, adap->name,
			(1 == rc) ? "yes" : "no");

		/* Now do the probe. The controller does not respond
		   to 0-byte reads, so we use a 1-byte read instead. */
		msg.addr = 0x30;
		msg.len = 1;
		msg.buf = &temp;
		rc = i2c_transfer(adap, &msg, 1);
		dprintk(1, "probe 0x%02x @ %s: %s\n",
			msg.addr, adap->name,
			(1 == rc) ? "yes" : "no");
		if (1 == rc)
			ir_attach(adap, msg.addr, 0, 0);
	}

	/* Special case for AVerMedia Cardbus remote */
	if (adap->id == I2C_HW_SAA7134) {
		unsigned char subaddr, data;
		struct i2c_msg msg[] = { { .addr = 0x40, .flags = 0,
					   .buf = &subaddr, .len = 1},
					 { .addr = 0x40, .flags = I2C_M_RD,
					   .buf = &data, .len = 1} };
		subaddr = 0x0d;
		rc = i2c_transfer(adap, msg, 2);
		dprintk(1, "probe 0x%02x/0x%02x @ %s: %s\n",
			msg[0].addr, subaddr, adap->name,
			(2 == rc) ? "yes" : "no");
		if (2 == rc)
			ir_attach(adap, msg[0].addr, 0, 0);
	}

	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>
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 */
39cf1e81	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
39cf1e81 JF	125	static inline int get_key_haup(struct IR_i2c ir, u32 ir_key, u32 *ir_raw)
	126	{
	127	return get_key_haup_common (ir, ir_key, ir_raw, 3, 0);
	128	}
	129
	130	static inline int get_key_haup_xvr(struct IR_i2c ir, u32 ir_key, u32 *ir_raw)
	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
	139	/* poll IR chip */
	140	if (1 != i2c_master_recv(&ir->c,&b,1)) {
	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
	153	/* poll IR chip */
	154	if (1 != i2c_master_recv(&ir->c,&b,1)) {
	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 */
	174	if (4 != i2c_master_recv(&ir->c,buf,4)) {
	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 */
	198	if (1 != i2c_master_recv(&ir->c,&b,1)) {
	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;
	225	struct i2c_msg msg[] = { { .addr = ir->c.addr, .flags = 0,
	226	.buf = &subaddr, .len = 1},
	227	{ .addr = ir->c.addr, .flags = I2C_M_RD,
	228	.buf = &key, .len = 1} };
	229	subaddr = 0x0d;
	230	if (2 != i2c_transfer(ir->c.adapter, msg, 2)) {
	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;
	240	if (2 != i2c_transfer(ir->c.adapter, msg, 2)) {
	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 */
	289	if (ir->c.adapter->id == I2C_HW_SAA7134 && ir->c.addr == 0x30)
	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
	298	static int ir_attach(struct i2c_adapter *adap, int addr,
	299	unsigned short flags, int kind);
	300	static int ir_detach(struct i2c_client *client);
	301	static int ir_probe(struct i2c_adapter *adap);
	302
	303	static struct i2c_driver driver = {
604f28e2	304	.driver = {
cab462f7	305	.name = "ir-kbd-i2c",
604f28e2	306	},
dd815408	307	.id = I2C_DRIVERID_INFRARED,
4ac97914 MCC	308	.attach_adapter = ir_probe,
4ac97914 MCC	309	.detach_client = ir_detach,
1da177e4 LT	310	};
	311
	312	static struct i2c_client client_template =
	313	{
4ac97914 MCC	314	.name = "unset",
4ac97914 MCC	315	.driver = &driver
1da177e4 LT	316	};
	317
	318	static int ir_attach(struct i2c_adapter *adap, int addr,
	319	unsigned short flags, int kind)
	320	{
	321	IR_KEYTAB_TYPE *ir_codes = NULL;
	322	char *name;
	323	int ir_type;
afd1a0c9	324	struct IR_i2c *ir;
b7df3910	325	struct input_dev *input_dev;
b07b4783	326	int err;
1da177e4	327
674434c6	328	ir = kzalloc(sizeof(struct IR_i2c),GFP_KERNEL);
b7df3910 DT	329	input_dev = input_allocate_device();
b7df3910 DT	330	if (!ir \|\| !input_dev) {
b07b4783 DT	331	err = -ENOMEM;
b07b4783 DT	332	goto err_out_free;
b7df3910 DT	333	}
b7df3910 DT	334
1da177e4	335	ir->c = client_template;
b7df3910	336	ir->input = input_dev;
1da177e4	337
1da177e4 LT	338	ir->c.adapter = adap;
	339	ir->c.addr = addr;
	340
d21838dd MCC	341	i2c_set_clientdata(&ir->c, ir);
d21838dd MCC	342
1da177e4 LT	343	switch(addr) {
	344	case 0x64:
	345	name = "Pixelview";
	346	ir->get_key = get_key_pixelview;
	347	ir_type = IR_TYPE_OTHER;
	348	ir_codes = ir_codes_empty;
	349	break;
	350	case 0x4b:
	351	name = "PV951";
	352	ir->get_key = get_key_pv951;
	353	ir_type = IR_TYPE_OTHER;
	354	ir_codes = ir_codes_pv951;
	355	break;
	356	case 0x18:
	357	case 0x1a:
	358	name = "Hauppauge";
	359	ir->get_key = get_key_haup;
	360	ir_type = IR_TYPE_RC5;
bf47e4e4	361	if (hauppauge == 1) {
4c0f631e	362	ir_codes = ir_codes_hauppauge_new;
bf47e4e4 A	363	} else {
	364	ir_codes = ir_codes_rc5_tv;
	365	}
1da177e4 LT	366	break;
1da177e4 LT	367	case 0x30:
d5e52653 MCC	368	name = "KNC One";
	369	ir->get_key = get_key_knc1;
	370	ir_type = IR_TYPE_OTHER;
	371	ir_codes = ir_codes_empty;
1da177e4	372	break;
d54d6980	373	case 0x6b:
3c44358c MK	374	name = "FusionHDTV";
3c44358c MK	375	ir->get_key = get_key_fusionhdtv;
d54d6980	376	ir_type = IR_TYPE_RC5;
3c44358c	377	ir_codes = ir_codes_fusionhdtv_mce;
d54d6980	378	break;
1da177e4	379	case 0x7a:
ac9cd976	380	case 0x47:
177aaaf8	381	case 0x71:
e8018c9e	382	case 0x2d:
39cf1e81 JF	383	if (adap->id == I2C_HW_B_CX2388x) {
	384	/* Handled by cx88-input */
	385	name = "CX2388x remote";
	386	ir_type = IR_TYPE_RC5;
	387	ir->get_key = get_key_haup_xvr;
	388	if (hauppauge == 1) {
	389	ir_codes = ir_codes_hauppauge_new;
	390	} else {
	391	ir_codes = ir_codes_rc5_tv;
	392	}
	393	} else {
	394	/* Handled by saa7134-input */
	395	name = "SAA713x remote";
	396	ir_type = IR_TYPE_OTHER;
	397	}
1da177e4	398	break;
cb3bf504 OJ	399	case 0x40:
	400	name = "AVerMedia Cardbus remote";
	401	ir->get_key = get_key_avermedia_cardbus;
	402	ir_type = IR_TYPE_OTHER;
	403	ir_codes = ir_codes_avermedia_cardbus;
	404	break;
1da177e4 LT	405	default:
1da177e4 LT	406	/* shouldn't happen */
b07b4783 DT	407	printk(DEVNAME ": Huh? unknown i2c address (0x%02x)?\n", addr);
	408	err = -ENODEV;
	409	goto err_out_free;
1da177e4 LT	410	}
1da177e4 LT	411
ac9cd976	412	/* Sets name */
1da177e4	413	snprintf(ir->c.name, sizeof(ir->c.name), "i2c IR (%s)", name);
b07b4783	414	ir->ir_codes = ir_codes;
d5e52653 MCC	415
	416	/* register i2c device
	417	* At device register, IR codes may be changed to be
	418	* board dependent.
674434c6	419	*/
b07b4783 DT	420	err = i2c_attach_client(&ir->c);
	421	if (err)
	422	goto err_out_free;
1da177e4	423
ac9cd976 RC	424	/* If IR not supported or disabled, unregisters driver */
ac9cd976 RC	425	if (ir->get_key == NULL) {
b07b4783 DT	426	err = -ENODEV;
b07b4783 DT	427	goto err_out_detach;
ac9cd976 RC	428	}
ac9cd976 RC	429
af128a10	430	/* Phys addr can only be set after attaching (for ir->c.dev) */
ac9cd976	431	snprintf(ir->phys, sizeof(ir->phys), "%s/%s/ir0",
af128a10 KS	432	dev_name(&ir->c.adapter->dev),
af128a10 KS	433	dev_name(&ir->c.dev));
ac9cd976	434
1da177e4	435	/* init + register input device */
b07b4783	436	ir_input_init(input_dev, &ir->ir, ir_type, ir->ir_codes);
d21838dd MCC	437	input_dev->id.bustype = BUS_I2C;
	438	input_dev->name = ir->c.name;
	439	input_dev->phys = ir->phys;
b7df3910	440
b07b4783 DT	441	err = input_register_device(ir->input);
	442	if (err)
	443	goto err_out_detach;
	444
d21838dd	445	printk(DEVNAME ": %s detected at %s [%s]\n",
b07b4783	446	ir->input->name, ir->input->phys, adap->name);
1da177e4 LT	447
1da177e4 LT	448	/* start polling via eventd */
c1089bdc JD	449	INIT_DELAYED_WORK(&ir->work, ir_work);
c1089bdc JD	450	schedule_delayed_work(&ir->work, 0);
1da177e4 LT	451
1da177e4 LT	452	return 0;
b07b4783 DT	453
	454	err_out_detach:
	455	i2c_detach_client(&ir->c);
	456	err_out_free:
	457	input_free_device(input_dev);
	458	kfree(ir);
	459	return err;
1da177e4 LT	460	}
	461
	462	static int ir_detach(struct i2c_client *client)
	463	{
4ac97914	464	struct IR_i2c *ir = i2c_get_clientdata(client);
1da177e4 LT	465
1da177e4 LT	466	/* kill outstanding polls */
c1089bdc	467	cancel_delayed_work_sync(&ir->work);
1da177e4 LT	468
1da177e4 LT	469	/* unregister devices */
b7df3910	470	input_unregister_device(ir->input);
1da177e4 LT	471	i2c_detach_client(&ir->c);
	472
	473	/* free memory */
	474	kfree(ir);
	475	return 0;
	476	}
	477
	478	static int ir_probe(struct i2c_adapter *adap)
	479	{
	480
	481	/* The external IR receiver is at i2c address 0x34 (0x35 for
	482	reads). Future Hauppauge cards will have an internal
	483	receiver at 0x30 (0x31 for reads). In theory, both can be
	484	fitted, and Hauppauge suggest an external overrides an
	485	internal.
	486
	487	That's why we probe 0x1a (~0x34) first. CB
	488	*/
	489
	490	static const int probe_bttv[] = { 0x1a, 0x18, 0x4b, 0x64, 0x30, -1};
e8018c9e	491	static const int probe_saa7134[] = { 0x7a, 0x47, 0x71, 0x2d, -1 };
b296fc60	492	static const int probe_em28XX[] = { 0x30, 0x47, -1 };
d54d6980	493	static const int probe_cx88[] = { 0x18, 0x6b, 0x71, -1 };
9bc37caa	494	static const int probe_cx23885[] = { 0x6b, -1 };
d6f34d7a	495	const int *probe;
37c45df7 JD	496	struct i2c_msg msg = {
	497	.flags = I2C_M_RD,
	498	.len = 0,
	499	.buf = NULL,
	500	};
a5885855	501	int i, rc;
1da177e4 LT	502
1da177e4 LT	503	switch (adap->id) {
c7a46533	504	case I2C_HW_B_BT848:
1da177e4 LT	505	probe = probe_bttv;
1da177e4 LT	506	break;
51dab14e	507	case I2C_HW_B_CX2341X:
c097b045	508	probe = probe_bttv;
51dab14e	509	break;
1684a984	510	case I2C_HW_SAA7134:
1da177e4 LT	511	probe = probe_saa7134;
1da177e4 LT	512	break;
b296fc60 MCC	513	case I2C_HW_B_EM28XX:
b296fc60 MCC	514	probe = probe_em28XX;
c365864f	515	break;
39cf1e81 JF	516	case I2C_HW_B_CX2388x:
39cf1e81 JF	517	probe = probe_cx88;
415a1975	518	break;
9bc37caa MK	519	case I2C_HW_B_CX23885:
9bc37caa MK	520	probe = probe_cx23885;
39cf1e81	521	break;
d6f34d7a	522	default:
1da177e4	523	return 0;
d6f34d7a	524	}
1da177e4	525
d5e52653	526	for (i = 0; -1 != probe[i]; i++) {
37c45df7 JD	527	msg.addr = probe[i];
37c45df7 JD	528	rc = i2c_transfer(adap, &msg, 1);
1da177e4 LT	529	dprintk(1,"probe 0x%02x @ %s: %s\n",
1da177e4 LT	530	probe[i], adap->name,
37c45df7 JD	531	(1 == rc) ? "yes" : "no");
37c45df7 JD	532	if (1 == rc) {
a5885855	533	ir_attach(adap, probe[i], 0, 0);
ba340b40	534	return 0;
1da177e4 LT	535	}
1da177e4 LT	536	}
ba340b40 BR	537
	538	/* Special case for MSI TV@nywhere Plus remote */
	539	if (adap->id == I2C_HW_SAA7134) {
	540	u8 temp;
	541
	542	/* MSI TV@nywhere Plus controller doesn't seem to
	543	respond to probes unless we read something from
	544	an existing device. Weird... */
	545
	546	msg.addr = 0x50;
	547	rc = i2c_transfer(adap, &msg, 1);
	548	dprintk(1, "probe 0x%02x @ %s: %s\n",
	549	msg.addr, adap->name,
	550	(1 == rc) ? "yes" : "no");
	551
	552	/* Now do the probe. The controller does not respond
	553	to 0-byte reads, so we use a 1-byte read instead. */
	554	msg.addr = 0x30;
	555	msg.len = 1;
	556	msg.buf = &temp;
	557	rc = i2c_transfer(adap, &msg, 1);
	558	dprintk(1, "probe 0x%02x @ %s: %s\n",
	559	msg.addr, adap->name,
	560	(1 == rc) ? "yes" : "no");
	561	if (1 == rc)
	562	ir_attach(adap, msg.addr, 0, 0);
	563	}
	564
cb3bf504 OJ	565	/* Special case for AVerMedia Cardbus remote */
	566	if (adap->id == I2C_HW_SAA7134) {
	567	unsigned char subaddr, data;
	568	struct i2c_msg msg[] = { { .addr = 0x40, .flags = 0,
	569	.buf = &subaddr, .len = 1},
	570	{ .addr = 0x40, .flags = I2C_M_RD,
	571	.buf = &data, .len = 1} };
	572	subaddr = 0x0d;
	573	rc = i2c_transfer(adap, msg, 2);
	574	dprintk(1, "probe 0x%02x/0x%02x @ %s: %s\n",
	575	msg[0].addr, subaddr, adap->name,
	576	(2 == rc) ? "yes" : "no");
	577	if (2 == rc)
	578	ir_attach(adap, msg[0].addr, 0, 0);
	579	}
	580
1da177e4 LT	581	return 0;
	582	}
	583
	584	/* ----------------------------------------------------------------------- */
	585
	586	MODULE_AUTHOR("Gerd Knorr, Michal Kochanowicz, Christoph Bartelmus, Ulrich Mueller");
	587	MODULE_DESCRIPTION("input driver for i2c IR remote controls");
	588	MODULE_LICENSE("GPL");
	589
	590	static int __init ir_init(void)
	591	{
	592	return i2c_add_driver(&driver);
	593	}
	594
	595	static void __exit ir_fini(void)
	596	{
	597	i2c_del_driver(&driver);
	598	}
	599
	600	module_init(ir_init);
	601	module_exit(ir_fini);
	602
	603	/*
	604	* Overrides for Emacs so that we follow Linus's tabbing style.
	605	* ---------------------------------------------------------------------------
	606	* Local variables:
	607	* c-basic-offset: 8
	608	* End:
	609	*/