[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>
 * 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;
	snprintf(ir->c.name, sizeof(ir->c.name), "ir-kbd");

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