[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>
 *
 *  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 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;
	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.bus_id) */
	snprintf(ir->phys, sizeof(ir->phys), "%s/%s/ir0",
		 ir->c.adapter->dev.bus_id,
		 ir->c.dev.bus_id);

	/* init + register input device */
	ir_input_init(input_dev, &ir->ir, ir_type, ir->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);
	}

	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>
1da177e4 LT	19	*
	20	* This program is free software; you can redistribute it and/or modify
	21	* it under the terms of the GNU General Public License as published by
	22	* the Free Software Foundation; either version 2 of the License, or
	23	* (at your option) any later version.
	24	*
	25	* This program is distributed in the hope that it will be useful,
	26	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	27	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	28	* GNU General Public License for more details.
	29	*
	30	* You should have received a copy of the GNU General Public License
	31	* along with this program; if not, write to the Free Software
	32	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	33	*
	34	*/
	35
	36	#include <linux/module.h>
1da177e4 LT	37	#include <linux/init.h>
1da177e4 LT	38	#include <linux/kernel.h>
1da177e4 LT	39	#include <linux/string.h>
	40	#include <linux/timer.h>
	41	#include <linux/delay.h>
	42	#include <linux/errno.h>
	43	#include <linux/slab.h>
	44	#include <linux/i2c.h>
39cf1e81	45	#include <linux/i2c-id.h>
1da177e4	46	#include <linux/workqueue.h>
674434c6	47
1da177e4	48	#include <media/ir-common.h>
d5e52653	49	#include <media/ir-kbd-i2c.h>
c365864f	50
1da177e4 LT	51	/* ----------------------------------------------------------------------- */
	52	/* insmod parameters */
	53
	54	static int debug;
	55	module_param(debug, int, 0644); /* debug level (0,1,2) */
	56
ff699e6b	57	static int hauppauge;
bf47e4e4 A	58	module_param(hauppauge, int, 0644); /* Choose Hauppauge remote */
	59	MODULE_PARM_DESC(hauppauge, "Specify Hauppauge remote: 0=black, 1=grey (defaults to 0)");
	60
	61
1da177e4 LT	62	#define DEVNAME "ir-kbd-i2c"
	63	#define dprintk(level, fmt, arg...) if (debug >= level) \
	64	printk(KERN_DEBUG DEVNAME ": " fmt , ## arg)
	65
	66	/* ----------------------------------------------------------------------- */
	67
39cf1e81 JF	68	static int get_key_haup_common(struct IR_i2c ir, u32 ir_key, u32 *ir_raw,
39cf1e81 JF	69	int size, int offset)
1da177e4	70	{
39cf1e81	71	unsigned char buf[6];
34c08029	72	int start, range, toggle, dev, code, ircode;
1da177e4 LT	73
1da177e4 LT	74	/* poll IR chip */
39cf1e81	75	if (size != i2c_master_recv(&ir->c,buf,size))
1da177e4 LT	76	return -EIO;
	77
	78	/* split rc5 data block ... */
39cf1e81 JF	79	start = (buf[offset] >> 7) & 1;
	80	range = (buf[offset] >> 6) & 1;
	81	toggle = (buf[offset] >> 5) & 1;
	82	dev = buf[offset] & 0x1f;
	83	code = (buf[offset+1] >> 2) & 0x3f;
1da177e4	84
cc7093df DH	85	/* rc5 has two start bits
	86	* the first bit must be one
	87	* the second bit defines the command range (1 = 0-63, 0 = 64 - 127)
	88	*/
	89	if (!start)
1da177e4 LT	90	/* no key pressed */
1da177e4 LT	91	return 0;
34c08029 DB	92	/*
	93	* Hauppauge remotes (black/silver) always use
	94	* specific device ids. If we do not filter the
	95	* device ids then messages destined for devices
	96	* such as TVs (id=0) will get through causing
	97	* mis-fired events.
	98	*
	99	* We also filter out invalid key presses which
	100	* produce annoying debug log entries.
	101	*/
	102	ircode= (start << 12) \| (toggle << 11) \| (dev << 6) \| code;
	103	if ((ircode & 0x1fff)==0x1fff)
	104	/* invalid key press */
	105	return 0;
	106
	107	if (dev!=0x1e && dev!=0x1f)
	108	/* not a hauppauge remote */
	109	return 0;
cc7093df DH	110
	111	if (!range)
	112	code += 64;
	113
	114	dprintk(1,"ir hauppauge (rc5): s%d r%d t%d dev=%d code=%d\n",
	115	start, range, toggle, dev, code);
1da177e4 LT	116
	117	/* return key */
	118	*ir_key = code;
34c08029	119	*ir_raw = ircode;
1da177e4 LT	120	return 1;
	121	}
	122
39cf1e81 JF	123	static inline int get_key_haup(struct IR_i2c ir, u32 ir_key, u32 *ir_raw)
	124	{
	125	return get_key_haup_common (ir, ir_key, ir_raw, 3, 0);
	126	}
	127
	128	static inline int get_key_haup_xvr(struct IR_i2c ir, u32 ir_key, u32 *ir_raw)
	129	{
	130	return get_key_haup_common (ir, ir_key, ir_raw, 6, 3);
	131	}
	132
d5e52653	133	static int get_key_pixelview(struct IR_i2c ir, u32 ir_key, u32 *ir_raw)
1da177e4	134	{
4ac97914	135	unsigned char b;
1da177e4 LT	136
	137	/* poll IR chip */
	138	if (1 != i2c_master_recv(&ir->c,&b,1)) {
	139	dprintk(1,"read error\n");
	140	return -EIO;
	141	}
	142	*ir_key = b;
	143	*ir_raw = b;
	144	return 1;
	145	}
	146
d5e52653	147	static int get_key_pv951(struct IR_i2c ir, u32 ir_key, u32 *ir_raw)
1da177e4	148	{
4ac97914	149	unsigned char b;
1da177e4 LT	150
	151	/* poll IR chip */
	152	if (1 != i2c_master_recv(&ir->c,&b,1)) {
	153	dprintk(1,"read error\n");
	154	return -EIO;
	155	}
	156
	157	/* ignore 0xaa */
	158	if (b==0xaa)
	159	return 0;
	160	dprintk(2,"key %02x\n", b);
	161
	162	*ir_key = b;
	163	*ir_raw = b;
	164	return 1;
	165	}
	166
3c44358c	167	static int get_key_fusionhdtv(struct IR_i2c ir, u32 ir_key, u32 *ir_raw)
d54d6980 CZ	168	{
	169	unsigned char buf[4];
	170
	171	/* poll IR chip */
	172	if (4 != i2c_master_recv(&ir->c,buf,4)) {
	173	dprintk(1,"read error\n");
	174	return -EIO;
	175	}
	176
	177	if(buf[0] !=0 \|\| buf[1] !=0 \|\| buf[2] !=0 \|\| buf[3] != 0)
7e28adb2	178	dprintk(2, "%s: 0x%2x 0x%2x 0x%2x 0x%2x\n", __func__,
d54d6980 CZ	179	buf[0], buf[1], buf[2], buf[3]);
	180
	181	/* no key pressed or signal from other ir remote */
	182	if(buf[0] != 0x1 \|\| buf[1] != 0xfe)
	183	return 0;
	184
	185	*ir_key = buf[2];
	186	*ir_raw = (buf[2] << 8) \| buf[3];
	187
	188	return 1;
d54d6980 CZ	189	}
d54d6980 CZ	190
d5e52653	191	static int get_key_knc1(struct IR_i2c ir, u32 ir_key, u32 *ir_raw)
1da177e4 LT	192	{
	193	unsigned char b;
	194
	195	/* poll IR chip */
	196	if (1 != i2c_master_recv(&ir->c,&b,1)) {
	197	dprintk(1,"read error\n");
	198	return -EIO;
	199	}
	200
	201	/* it seems that 0xFE indicates that a button is still hold
4f9c05aa MCC	202	down, while 0xff indicates that no button is hold
4f9c05aa MCC	203	down. 0xfe sequences are sometimes interrupted by 0xFF */
1da177e4 LT	204
	205	dprintk(2,"key %02x\n", b);
	206
4f9c05aa	207	if (b == 0xff)
1da177e4 LT	208	return 0;
1da177e4 LT	209
4f9c05aa	210	if (b == 0xfe)
1da177e4 LT	211	/* keep old data */
	212	return 1;
	213
	214	*ir_key = b;
	215	*ir_raw = b;
	216	return 1;
	217	}
	218
1da177e4 LT	219	/* ----------------------------------------------------------------------- */
1da177e4 LT	220
d5e52653	221	static void ir_key_poll(struct IR_i2c *ir)
1da177e4 LT	222	{
	223	static u32 ir_key, ir_raw;
	224	int rc;
	225
	226	dprintk(2,"ir_poll_key\n");
	227	rc = ir->get_key(ir, &ir_key, &ir_raw);
	228	if (rc < 0) {
	229	dprintk(2,"error\n");
	230	return;
	231	}
	232
	233	if (0 == rc) {
b7df3910	234	ir_input_nokey(ir->input, &ir->ir);
1da177e4	235	} else {
b7df3910	236	ir_input_keydown(ir->input, &ir->ir, ir_key, ir_raw);
1da177e4 LT	237	}
	238	}
	239
	240	static void ir_timer(unsigned long data)
	241	{
d5e52653	242	struct IR_i2c ir = (struct IR_i2c)data;
1da177e4 LT	243	schedule_work(&ir->work);
	244	}
	245
c4028958	246	static void ir_work(struct work_struct *work)
1da177e4	247	{
c4028958	248	struct IR_i2c *ir = container_of(work, struct IR_i2c, work);
ba340b40 BR	249	int polling_interval = 100;
	250
	251	/* MSI TV@nywhere Plus requires more frequent polling
	252	otherwise it will miss some keypresses */
	253	if (ir->c.adapter->id == I2C_HW_SAA7134 && ir->c.addr == 0x30)
	254	polling_interval = 50;
8083c520	255
1da177e4	256	ir_key_poll(ir);
ba340b40	257	mod_timer(&ir->timer, jiffies + msecs_to_jiffies(polling_interval));
1da177e4 LT	258	}
	259
	260	/* ----------------------------------------------------------------------- */
	261
	262	static int ir_attach(struct i2c_adapter *adap, int addr,
	263	unsigned short flags, int kind);
	264	static int ir_detach(struct i2c_client *client);
	265	static int ir_probe(struct i2c_adapter *adap);
	266
	267	static struct i2c_driver driver = {
604f28e2	268	.driver = {
cab462f7	269	.name = "ir-kbd-i2c",
604f28e2	270	},
dd815408	271	.id = I2C_DRIVERID_INFRARED,
4ac97914 MCC	272	.attach_adapter = ir_probe,
4ac97914 MCC	273	.detach_client = ir_detach,
1da177e4 LT	274	};
	275
	276	static struct i2c_client client_template =
	277	{
4ac97914 MCC	278	.name = "unset",
4ac97914 MCC	279	.driver = &driver
1da177e4 LT	280	};
	281
	282	static int ir_attach(struct i2c_adapter *adap, int addr,
	283	unsigned short flags, int kind)
	284	{
	285	IR_KEYTAB_TYPE *ir_codes = NULL;
	286	char *name;
	287	int ir_type;
afd1a0c9	288	struct IR_i2c *ir;
b7df3910	289	struct input_dev *input_dev;
b07b4783	290	int err;
1da177e4	291
674434c6	292	ir = kzalloc(sizeof(struct IR_i2c),GFP_KERNEL);
b7df3910 DT	293	input_dev = input_allocate_device();
b7df3910 DT	294	if (!ir \|\| !input_dev) {
b07b4783 DT	295	err = -ENOMEM;
b07b4783 DT	296	goto err_out_free;
b7df3910 DT	297	}
b7df3910 DT	298
1da177e4	299	ir->c = client_template;
b7df3910	300	ir->input = input_dev;
1da177e4	301
1da177e4 LT	302	ir->c.adapter = adap;
	303	ir->c.addr = addr;
	304
d21838dd MCC	305	i2c_set_clientdata(&ir->c, ir);
d21838dd MCC	306
1da177e4 LT	307	switch(addr) {
	308	case 0x64:
	309	name = "Pixelview";
	310	ir->get_key = get_key_pixelview;
	311	ir_type = IR_TYPE_OTHER;
	312	ir_codes = ir_codes_empty;
	313	break;
	314	case 0x4b:
	315	name = "PV951";
	316	ir->get_key = get_key_pv951;
	317	ir_type = IR_TYPE_OTHER;
	318	ir_codes = ir_codes_pv951;
	319	break;
	320	case 0x18:
	321	case 0x1a:
	322	name = "Hauppauge";
	323	ir->get_key = get_key_haup;
	324	ir_type = IR_TYPE_RC5;
bf47e4e4	325	if (hauppauge == 1) {
4c0f631e	326	ir_codes = ir_codes_hauppauge_new;
bf47e4e4 A	327	} else {
	328	ir_codes = ir_codes_rc5_tv;
	329	}
1da177e4 LT	330	break;
1da177e4 LT	331	case 0x30:
d5e52653 MCC	332	name = "KNC One";
	333	ir->get_key = get_key_knc1;
	334	ir_type = IR_TYPE_OTHER;
	335	ir_codes = ir_codes_empty;
1da177e4	336	break;
d54d6980	337	case 0x6b:
3c44358c MK	338	name = "FusionHDTV";
3c44358c MK	339	ir->get_key = get_key_fusionhdtv;
d54d6980	340	ir_type = IR_TYPE_RC5;
3c44358c	341	ir_codes = ir_codes_fusionhdtv_mce;
d54d6980	342	break;
1da177e4	343	case 0x7a:
ac9cd976	344	case 0x47:
177aaaf8	345	case 0x71:
e8018c9e	346	case 0x2d:
39cf1e81 JF	347	if (adap->id == I2C_HW_B_CX2388x) {
	348	/* Handled by cx88-input */
	349	name = "CX2388x remote";
	350	ir_type = IR_TYPE_RC5;
	351	ir->get_key = get_key_haup_xvr;
	352	if (hauppauge == 1) {
	353	ir_codes = ir_codes_hauppauge_new;
	354	} else {
	355	ir_codes = ir_codes_rc5_tv;
	356	}
	357	} else {
	358	/* Handled by saa7134-input */
	359	name = "SAA713x remote";
	360	ir_type = IR_TYPE_OTHER;
	361	}
1da177e4 LT	362	break;
	363	default:
	364	/* shouldn't happen */
b07b4783 DT	365	printk(DEVNAME ": Huh? unknown i2c address (0x%02x)?\n", addr);
	366	err = -ENODEV;
	367	goto err_out_free;
1da177e4 LT	368	}
1da177e4 LT	369
ac9cd976	370	/* Sets name */
1da177e4	371	snprintf(ir->c.name, sizeof(ir->c.name), "i2c IR (%s)", name);
b07b4783	372	ir->ir_codes = ir_codes;
d5e52653 MCC	373
	374	/* register i2c device
	375	* At device register, IR codes may be changed to be
	376	* board dependent.
674434c6	377	*/
b07b4783 DT	378	err = i2c_attach_client(&ir->c);
	379	if (err)
	380	goto err_out_free;
1da177e4	381
ac9cd976 RC	382	/* If IR not supported or disabled, unregisters driver */
ac9cd976 RC	383	if (ir->get_key == NULL) {
b07b4783 DT	384	err = -ENODEV;
b07b4783 DT	385	goto err_out_detach;
ac9cd976 RC	386	}
	387
	388	/* Phys addr can only be set after attaching (for ir->c.dev.bus_id) */
	389	snprintf(ir->phys, sizeof(ir->phys), "%s/%s/ir0",
	390	ir->c.adapter->dev.bus_id,
	391	ir->c.dev.bus_id);
	392
1da177e4	393	/* init + register input device */
b07b4783	394	ir_input_init(input_dev, &ir->ir, ir_type, ir->ir_codes);
d21838dd MCC	395	input_dev->id.bustype = BUS_I2C;
	396	input_dev->name = ir->c.name;
	397	input_dev->phys = ir->phys;
b7df3910	398
b07b4783 DT	399	err = input_register_device(ir->input);
	400	if (err)
	401	goto err_out_detach;
	402
d21838dd	403	printk(DEVNAME ": %s detected at %s [%s]\n",
b07b4783	404	ir->input->name, ir->input->phys, adap->name);
1da177e4 LT	405
1da177e4 LT	406	/* start polling via eventd */
c4028958	407	INIT_WORK(&ir->work, ir_work);
1da177e4 LT	408	init_timer(&ir->timer);
	409	ir->timer.function = ir_timer;
	410	ir->timer.data = (unsigned long)ir;
	411	schedule_work(&ir->work);
	412
	413	return 0;
b07b4783 DT	414
	415	err_out_detach:
	416	i2c_detach_client(&ir->c);
	417	err_out_free:
	418	input_free_device(input_dev);
	419	kfree(ir);
	420	return err;
1da177e4 LT	421	}
	422
	423	static int ir_detach(struct i2c_client *client)
	424	{
4ac97914	425	struct IR_i2c *ir = i2c_get_clientdata(client);
1da177e4 LT	426
1da177e4 LT	427	/* kill outstanding polls */
b07b4783	428	del_timer_sync(&ir->timer);
1da177e4 LT	429	flush_scheduled_work();
	430
	431	/* unregister devices */
b7df3910	432	input_unregister_device(ir->input);
1da177e4 LT	433	i2c_detach_client(&ir->c);
	434
	435	/* free memory */
	436	kfree(ir);
	437	return 0;
	438	}
	439
	440	static int ir_probe(struct i2c_adapter *adap)
	441	{
	442
	443	/* The external IR receiver is at i2c address 0x34 (0x35 for
	444	reads). Future Hauppauge cards will have an internal
	445	receiver at 0x30 (0x31 for reads). In theory, both can be
	446	fitted, and Hauppauge suggest an external overrides an
	447	internal.
	448
	449	That's why we probe 0x1a (~0x34) first. CB
	450	*/
	451
	452	static const int probe_bttv[] = { 0x1a, 0x18, 0x4b, 0x64, 0x30, -1};
e8018c9e	453	static const int probe_saa7134[] = { 0x7a, 0x47, 0x71, 0x2d, -1 };
b296fc60	454	static const int probe_em28XX[] = { 0x30, 0x47, -1 };
d54d6980	455	static const int probe_cx88[] = { 0x18, 0x6b, 0x71, -1 };
9bc37caa	456	static const int probe_cx23885[] = { 0x6b, -1 };
d6f34d7a	457	const int *probe;
37c45df7 JD	458	struct i2c_msg msg = {
	459	.flags = I2C_M_RD,
	460	.len = 0,
	461	.buf = NULL,
	462	};
a5885855	463	int i, rc;
1da177e4 LT	464
1da177e4 LT	465	switch (adap->id) {
c7a46533	466	case I2C_HW_B_BT848:
1da177e4 LT	467	probe = probe_bttv;
1da177e4 LT	468	break;
51dab14e	469	case I2C_HW_B_CX2341X:
c097b045	470	probe = probe_bttv;
51dab14e	471	break;
1684a984	472	case I2C_HW_SAA7134:
1da177e4 LT	473	probe = probe_saa7134;
1da177e4 LT	474	break;
b296fc60 MCC	475	case I2C_HW_B_EM28XX:
b296fc60 MCC	476	probe = probe_em28XX;
c365864f	477	break;
39cf1e81 JF	478	case I2C_HW_B_CX2388x:
39cf1e81 JF	479	probe = probe_cx88;
415a1975	480	break;
9bc37caa MK	481	case I2C_HW_B_CX23885:
9bc37caa MK	482	probe = probe_cx23885;
39cf1e81	483	break;
d6f34d7a	484	default:
1da177e4	485	return 0;
d6f34d7a	486	}
1da177e4	487
d5e52653	488	for (i = 0; -1 != probe[i]; i++) {
37c45df7 JD	489	msg.addr = probe[i];
37c45df7 JD	490	rc = i2c_transfer(adap, &msg, 1);
1da177e4 LT	491	dprintk(1,"probe 0x%02x @ %s: %s\n",
1da177e4 LT	492	probe[i], adap->name,
37c45df7 JD	493	(1 == rc) ? "yes" : "no");
37c45df7 JD	494	if (1 == rc) {
a5885855	495	ir_attach(adap, probe[i], 0, 0);
ba340b40	496	return 0;
1da177e4 LT	497	}
1da177e4 LT	498	}
ba340b40 BR	499
	500	/* Special case for MSI TV@nywhere Plus remote */
	501	if (adap->id == I2C_HW_SAA7134) {
	502	u8 temp;
	503
	504	/* MSI TV@nywhere Plus controller doesn't seem to
	505	respond to probes unless we read something from
	506	an existing device. Weird... */
	507
	508	msg.addr = 0x50;
	509	rc = i2c_transfer(adap, &msg, 1);
	510	dprintk(1, "probe 0x%02x @ %s: %s\n",
	511	msg.addr, adap->name,
	512	(1 == rc) ? "yes" : "no");
	513
	514	/* Now do the probe. The controller does not respond
	515	to 0-byte reads, so we use a 1-byte read instead. */
	516	msg.addr = 0x30;
	517	msg.len = 1;
	518	msg.buf = &temp;
	519	rc = i2c_transfer(adap, &msg, 1);
	520	dprintk(1, "probe 0x%02x @ %s: %s\n",
	521	msg.addr, adap->name,
	522	(1 == rc) ? "yes" : "no");
	523	if (1 == rc)
	524	ir_attach(adap, msg.addr, 0, 0);
	525	}
	526
1da177e4 LT	527	return 0;
	528	}
	529
	530	/* ----------------------------------------------------------------------- */
	531
	532	MODULE_AUTHOR("Gerd Knorr, Michal Kochanowicz, Christoph Bartelmus, Ulrich Mueller");
	533	MODULE_DESCRIPTION("input driver for i2c IR remote controls");
	534	MODULE_LICENSE("GPL");
	535
	536	static int __init ir_init(void)
	537	{
	538	return i2c_add_driver(&driver);
	539	}
	540
	541	static void __exit ir_fini(void)
	542	{
	543	i2c_del_driver(&driver);
	544	}
	545
	546	module_init(ir_init);
	547	module_exit(ir_fini);
	548
	549	/*
	550	* Overrides for Emacs so that we follow Linus's tabbing style.
	551	* ---------------------------------------------------------------------------
	552	* Local variables:
	553	* c-basic-offset: 8
	554	* End:
	555	*/