[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_timer(unsigned long data)
{
	struct IR_i2c *ir = (struct IR_i2c*)data;
	schedule_work(&ir->work);
}

static void ir_work(struct work_struct *work)
{
	struct IR_i2c *ir = container_of(work, struct IR_i2c, 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);
	mod_timer(&ir->timer, jiffies + 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_WORK(&ir->work, ir_work);
	init_timer(&ir->timer);
	ir->timer.function = ir_timer;
	ir->timer.data     = (unsigned long)ir;
	schedule_work(&ir->work);

	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 */
	del_timer_sync(&ir->timer);
	flush_scheduled_work();

	/* unregister devices */
	input_unregister_device(ir->input);
	i2c_detach_client(&ir->c);

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

static int ir_probe(struct i2c_adapter *adap)
{

	/* The external IR receiver is at i2c address 0x34 (0x35 for
	   reads).  Future Hauppauge cards will have an internal
	   receiver at 0x30 (0x31 for reads).  In theory, both can be
	   fitted, and Hauppauge suggest an external overrides an
	   internal.

	   That's why we probe 0x1a (~0x34) first. CB
	*/

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