[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>
 *
 *  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 <asm/semaphore.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 = 0;
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;

	/* 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;

	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 = (start << 12) | (toggle << 11) | (dev << 6) | code;
	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", __FUNCTION__,
			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;
}

/* Common (grey or coloured) pinnacle PCTV remote handling
 *
 */
static int get_key_pinnacle(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw,
			    int parity_offset, int marker, int code_modulo)
{
	unsigned char b[4];
	unsigned int start = 0,parity = 0,code = 0;

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

	for (start = 0; start < ARRAY_SIZE(b); start++) {
		if (b[start] == marker) {
			code=b[(start+parity_offset+1)%4];
			parity=b[(start+parity_offset)%4];
		}
	}

	/* Empty Request */
	if (parity==0)
		return 0;

	/* Repeating... */
	if (ir->old == parity)
		return 0;

	ir->old = parity;

	/* drop special codes when a key is held down a long time for the grey controller
	   In this case, the second bit of the code is asserted */
	if (marker == 0xfe && (code & 0x40))
		return 0;

	code %= code_modulo;

	*ir_raw = code;
	*ir_key = code;

	dprintk(1,"Pinnacle PCTV key %02x\n", code);

	return 1;
}

/* The grey pinnacle PCTV remote
 *
 *  There are one issue with this remote:
 *   - I2c packet does not change when the same key is pressed quickly. The workaround
 *     is to hold down each key for about half a second, so that another code is generated
 *     in the i2c packet, and the function can distinguish key presses.
 *
 * Sylvain Pasche <sylvain.pasche@gmail.com>
 */
int get_key_pinnacle_grey(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
{

	return get_key_pinnacle(ir, ir_key, ir_raw, 1, 0xfe, 0xff);
}

EXPORT_SYMBOL_GPL(get_key_pinnacle_grey);


/* The new pinnacle PCTV remote (with the colored buttons)
 *
 * Ricardo Cerqueira <v4l@cerqueira.org>
 */
int get_key_pinnacle_color(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
{
	/* code_modulo parameter (0x88) is used to reduce code value to fit inside IR_KEYTAB_SIZE
	 *
	 * this is the only value that results in 42 unique
	 * codes < 128
	 */

	return get_key_pinnacle(ir, ir_key, ir_raw, 2, 0x80, 0x88);
}

EXPORT_SYMBOL_GPL(get_key_pinnacle_color);

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

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);

	ir_key_poll(ir);
	mod_timer(&ir->timer, jiffies + msecs_to_jiffies(100));
}

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

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:
		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, -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 = NULL;
	struct i2c_client c;
	unsigned char buf;
	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;
	}
	if (NULL == probe)
		return 0;

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