[mirror_ubuntu-focal-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>
 *
 *  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 = 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:
	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 = 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>
674434c6	43
1da177e4	44	#include <media/ir-common.h>
d5e52653	45	#include <media/ir-kbd-i2c.h>
c365864f	46
1da177e4 LT	47	/* ----------------------------------------------------------------------- */
	48	/* insmod parameters */
	49
	50	static int debug;
	51	module_param(debug, int, 0644); /* debug level (0,1,2) */
	52
bf47e4e4 A	53	static int hauppauge = 0;
	54	module_param(hauppauge, int, 0644); /* Choose Hauppauge remote */
	55	MODULE_PARM_DESC(hauppauge, "Specify Hauppauge remote: 0=black, 1=grey (defaults to 0)");
	56
	57
1da177e4 LT	58	#define DEVNAME "ir-kbd-i2c"
	59	#define dprintk(level, fmt, arg...) if (debug >= level) \
	60	printk(KERN_DEBUG DEVNAME ": " fmt , ## arg)
	61
	62	/* ----------------------------------------------------------------------- */
	63
39cf1e81 JF	64	static int get_key_haup_common(struct IR_i2c ir, u32 ir_key, u32 *ir_raw,
39cf1e81 JF	65	int size, int offset)
1da177e4	66	{
39cf1e81	67	unsigned char buf[6];
cc7093df	68	int start, range, toggle, dev, code;
1da177e4 LT	69
1da177e4 LT	70	/* poll IR chip */
39cf1e81	71	if (size != i2c_master_recv(&ir->c,buf,size))
1da177e4 LT	72	return -EIO;
	73
	74	/* split rc5 data block ... */
39cf1e81 JF	75	start = (buf[offset] >> 7) & 1;
	76	range = (buf[offset] >> 6) & 1;
	77	toggle = (buf[offset] >> 5) & 1;
	78	dev = buf[offset] & 0x1f;
	79	code = (buf[offset+1] >> 2) & 0x3f;
1da177e4	80
cc7093df DH	81	/* rc5 has two start bits
	82	* the first bit must be one
	83	* the second bit defines the command range (1 = 0-63, 0 = 64 - 127)
	84	*/
	85	if (!start)
1da177e4 LT	86	/* no key pressed */
1da177e4 LT	87	return 0;
cc7093df DH	88
	89	if (!range)
	90	code += 64;
	91
	92	dprintk(1,"ir hauppauge (rc5): s%d r%d t%d dev=%d code=%d\n",
	93	start, range, toggle, dev, code);
1da177e4 LT	94
	95	/* return key */
	96	*ir_key = code;
	97	*ir_raw = (start << 12) \| (toggle << 11) \| (dev << 6) \| code;
	98	return 1;
	99	}
	100
39cf1e81 JF	101	static inline int get_key_haup(struct IR_i2c ir, u32 ir_key, u32 *ir_raw)
	102	{
	103	return get_key_haup_common (ir, ir_key, ir_raw, 3, 0);
	104	}
	105
	106	static inline int get_key_haup_xvr(struct IR_i2c ir, u32 ir_key, u32 *ir_raw)
	107	{
	108	return get_key_haup_common (ir, ir_key, ir_raw, 6, 3);
	109	}
	110
d5e52653	111	static int get_key_pixelview(struct IR_i2c ir, u32 ir_key, u32 *ir_raw)
1da177e4	112	{
4ac97914	113	unsigned char b;
1da177e4 LT	114
	115	/* poll IR chip */
	116	if (1 != i2c_master_recv(&ir->c,&b,1)) {
	117	dprintk(1,"read error\n");
	118	return -EIO;
	119	}
	120	*ir_key = b;
	121	*ir_raw = b;
	122	return 1;
	123	}
	124
d5e52653	125	static int get_key_pv951(struct IR_i2c ir, u32 ir_key, u32 *ir_raw)
1da177e4	126	{
4ac97914	127	unsigned char b;
1da177e4 LT	128
	129	/* poll IR chip */
	130	if (1 != i2c_master_recv(&ir->c,&b,1)) {
	131	dprintk(1,"read error\n");
	132	return -EIO;
	133	}
	134
	135	/* ignore 0xaa */
	136	if (b==0xaa)
	137	return 0;
	138	dprintk(2,"key %02x\n", b);
	139
	140	*ir_key = b;
	141	*ir_raw = b;
	142	return 1;
	143	}
	144
3c44358c	145	static int get_key_fusionhdtv(struct IR_i2c ir, u32 ir_key, u32 *ir_raw)
d54d6980 CZ	146	{
	147	unsigned char buf[4];
	148
	149	/* poll IR chip */
	150	if (4 != i2c_master_recv(&ir->c,buf,4)) {
	151	dprintk(1,"read error\n");
	152	return -EIO;
	153	}
	154
	155	if(buf[0] !=0 \|\| buf[1] !=0 \|\| buf[2] !=0 \|\| buf[3] != 0)
3c44358c	156	dprintk(2, "%s: 0x%2x 0x%2x 0x%2x 0x%2x\n", __FUNCTION__,
d54d6980 CZ	157	buf[0], buf[1], buf[2], buf[3]);
	158
	159	/* no key pressed or signal from other ir remote */
	160	if(buf[0] != 0x1 \|\| buf[1] != 0xfe)
	161	return 0;
	162
	163	*ir_key = buf[2];
	164	*ir_raw = (buf[2] << 8) \| buf[3];
	165
	166	return 1;
d54d6980 CZ	167	}
d54d6980 CZ	168
d5e52653	169	static int get_key_knc1(struct IR_i2c ir, u32 ir_key, u32 *ir_raw)
1da177e4 LT	170	{
	171	unsigned char b;
	172
	173	/* poll IR chip */
	174	if (1 != i2c_master_recv(&ir->c,&b,1)) {
	175	dprintk(1,"read error\n");
	176	return -EIO;
	177	}
	178
	179	/* it seems that 0xFE indicates that a button is still hold
4f9c05aa MCC	180	down, while 0xff indicates that no button is hold
4f9c05aa MCC	181	down. 0xfe sequences are sometimes interrupted by 0xFF */
1da177e4 LT	182
	183	dprintk(2,"key %02x\n", b);
	184
4f9c05aa	185	if (b == 0xff)
1da177e4 LT	186	return 0;
1da177e4 LT	187
4f9c05aa	188	if (b == 0xfe)
1da177e4 LT	189	/* keep old data */
	190	return 1;
	191
	192	*ir_key = b;
	193	*ir_raw = b;
	194	return 1;
	195	}
	196
b93eedb6	197	/* Common (grey or coloured) pinnacle PCTV remote handling
8069695c	198	*
8069695c	199	*/
b93eedb6 SP	200	static int get_key_pinnacle(struct IR_i2c ir, u32 ir_key, u32 *ir_raw,
b93eedb6 SP	201	int parity_offset, int marker, int code_modulo)
8069695c RC	202	{
	203	unsigned char b[4];
	204	unsigned int start = 0,parity = 0,code = 0;
	205
	206	/* poll IR chip */
	207	if (4 != i2c_master_recv(&ir->c,b,4)) {
	208	dprintk(2,"read error\n");
	209	return -EIO;
	210	}
	211
53c4e955	212	for (start = 0; start < ARRAY_SIZE(b); start++) {
b93eedb6 SP	213	if (b[start] == marker) {
	214	code=b[(start+parity_offset+1)%4];
	215	parity=b[(start+parity_offset)%4];
8069695c RC	216	}
	217	}
	218
	219	/* Empty Request */
	220	if (parity==0)
	221	return 0;
	222
	223	/* Repeating... */
	224	if (ir->old == parity)
	225	return 0;
	226
8069695c RC	227	ir->old = parity;
8069695c RC	228
b93eedb6 SP	229	/* drop special codes when a key is held down a long time for the grey controller
	230	In this case, the second bit of the code is asserted */
	231	if (marker == 0xfe && (code & 0x40))
	232	return 0;
8069695c	233
b93eedb6	234	code %= code_modulo;
8069695c RC	235
	236	*ir_raw = code;
	237	*ir_key = code;
	238
	239	dprintk(1,"Pinnacle PCTV key %02x\n", code);
	240
	241	return 1;
	242	}
	243
b93eedb6 SP	244	/* The grey pinnacle PCTV remote
	245	*
	246	* There are one issue with this remote:
	247	* - I2c packet does not change when the same key is pressed quickly. The workaround
	248	* is to hold down each key for about half a second, so that another code is generated
	249	* in the i2c packet, and the function can distinguish key presses.
	250	*
	251	* Sylvain Pasche <sylvain.pasche@gmail.com>
	252	*/
	253	int get_key_pinnacle_grey(struct IR_i2c ir, u32 ir_key, u32 *ir_raw)
	254	{
	255
	256	return get_key_pinnacle(ir, ir_key, ir_raw, 1, 0xfe, 0xff);
	257	}
	258
	259	EXPORT_SYMBOL_GPL(get_key_pinnacle_grey);
	260
	261
	262	/* The new pinnacle PCTV remote (with the colored buttons)
	263	*
	264	* Ricardo Cerqueira <v4l@cerqueira.org>
	265	*/
	266	int get_key_pinnacle_color(struct IR_i2c ir, u32 ir_key, u32 *ir_raw)
	267	{
	268	/* code_modulo parameter (0x88) is used to reduce code value to fit inside IR_KEYTAB_SIZE
	269	*
	270	* this is the only value that results in 42 unique
	271	* codes < 128
	272	*/
	273
	274	return get_key_pinnacle(ir, ir_key, ir_raw, 2, 0x80, 0x88);
	275	}
	276
	277	EXPORT_SYMBOL_GPL(get_key_pinnacle_color);
8069695c	278
1da177e4 LT	279	/* ----------------------------------------------------------------------- */
1da177e4 LT	280
d5e52653	281	static void ir_key_poll(struct IR_i2c *ir)
1da177e4 LT	282	{
	283	static u32 ir_key, ir_raw;
	284	int rc;
	285
	286	dprintk(2,"ir_poll_key\n");
	287	rc = ir->get_key(ir, &ir_key, &ir_raw);
	288	if (rc < 0) {
	289	dprintk(2,"error\n");
	290	return;
	291	}
	292
	293	if (0 == rc) {
b7df3910	294	ir_input_nokey(ir->input, &ir->ir);
1da177e4	295	} else {
b7df3910	296	ir_input_keydown(ir->input, &ir->ir, ir_key, ir_raw);
1da177e4 LT	297	}
	298	}
	299
	300	static void ir_timer(unsigned long data)
	301	{
d5e52653	302	struct IR_i2c ir = (struct IR_i2c)data;
1da177e4 LT	303	schedule_work(&ir->work);
	304	}
	305
c4028958	306	static void ir_work(struct work_struct *work)
1da177e4	307	{
c4028958	308	struct IR_i2c *ir = container_of(work, struct IR_i2c, work);
8083c520	309
1da177e4	310	ir_key_poll(ir);
8083c520	311	mod_timer(&ir->timer, jiffies + msecs_to_jiffies(100));
1da177e4 LT	312	}
	313
	314	/* ----------------------------------------------------------------------- */
	315
	316	static int ir_attach(struct i2c_adapter *adap, int addr,
	317	unsigned short flags, int kind);
	318	static int ir_detach(struct i2c_client *client);
	319	static int ir_probe(struct i2c_adapter *adap);
	320
	321	static struct i2c_driver driver = {
604f28e2	322	.driver = {
cab462f7	323	.name = "ir-kbd-i2c",
604f28e2	324	},
dd815408	325	.id = I2C_DRIVERID_INFRARED,
4ac97914 MCC	326	.attach_adapter = ir_probe,
4ac97914 MCC	327	.detach_client = ir_detach,
1da177e4 LT	328	};
	329
	330	static struct i2c_client client_template =
	331	{
4ac97914 MCC	332	.name = "unset",
4ac97914 MCC	333	.driver = &driver
1da177e4 LT	334	};
	335
	336	static int ir_attach(struct i2c_adapter *adap, int addr,
	337	unsigned short flags, int kind)
	338	{
	339	IR_KEYTAB_TYPE *ir_codes = NULL;
	340	char *name;
	341	int ir_type;
afd1a0c9	342	struct IR_i2c *ir;
b7df3910	343	struct input_dev *input_dev;
b07b4783	344	int err;
1da177e4	345
674434c6	346	ir = kzalloc(sizeof(struct IR_i2c),GFP_KERNEL);
b7df3910 DT	347	input_dev = input_allocate_device();
b7df3910 DT	348	if (!ir \|\| !input_dev) {
b07b4783 DT	349	err = -ENOMEM;
b07b4783 DT	350	goto err_out_free;
b7df3910 DT	351	}
b7df3910 DT	352
1da177e4	353	ir->c = client_template;
b7df3910	354	ir->input = input_dev;
1da177e4	355
1da177e4 LT	356	ir->c.adapter = adap;
	357	ir->c.addr = addr;
	358
d21838dd MCC	359	i2c_set_clientdata(&ir->c, ir);
d21838dd MCC	360
1da177e4 LT	361	switch(addr) {
	362	case 0x64:
	363	name = "Pixelview";
	364	ir->get_key = get_key_pixelview;
	365	ir_type = IR_TYPE_OTHER;
	366	ir_codes = ir_codes_empty;
	367	break;
	368	case 0x4b:
	369	name = "PV951";
	370	ir->get_key = get_key_pv951;
	371	ir_type = IR_TYPE_OTHER;
	372	ir_codes = ir_codes_pv951;
	373	break;
	374	case 0x18:
	375	case 0x1a:
	376	name = "Hauppauge";
	377	ir->get_key = get_key_haup;
	378	ir_type = IR_TYPE_RC5;
bf47e4e4	379	if (hauppauge == 1) {
4c0f631e	380	ir_codes = ir_codes_hauppauge_new;
bf47e4e4 A	381	} else {
	382	ir_codes = ir_codes_rc5_tv;
	383	}
1da177e4 LT	384	break;
1da177e4 LT	385	case 0x30:
d5e52653 MCC	386	name = "KNC One";
	387	ir->get_key = get_key_knc1;
	388	ir_type = IR_TYPE_OTHER;
	389	ir_codes = ir_codes_empty;
1da177e4	390	break;
d54d6980	391	case 0x6b:
3c44358c MK	392	name = "FusionHDTV";
3c44358c MK	393	ir->get_key = get_key_fusionhdtv;
d54d6980	394	ir_type = IR_TYPE_RC5;
3c44358c	395	ir_codes = ir_codes_fusionhdtv_mce;
d54d6980	396	break;
1da177e4	397	case 0x7a:
ac9cd976	398	case 0x47:
177aaaf8	399	case 0x71:
e8018c9e	400	case 0x2d:
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};
e8018c9e	507	static const int probe_saa7134[] = { 0x7a, 0x47, 0x71, 0x2d, -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	*/