[mirror_ubuntu-zesty-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;
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);

	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;
	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);
			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
ff699e6b	53	static int hauppauge;
bf47e4e4 A	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];
34c08029	68	int start, range, toggle, dev, code, ircode;
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;
34c08029 DB	88	/*
	89	* Hauppauge remotes (black/silver) always use
	90	* specific device ids. If we do not filter the
	91	* device ids then messages destined for devices
	92	* such as TVs (id=0) will get through causing
	93	* mis-fired events.
	94	*
	95	* We also filter out invalid key presses which
	96	* produce annoying debug log entries.
	97	*/
	98	ircode= (start << 12) \| (toggle << 11) \| (dev << 6) \| code;
	99	if ((ircode & 0x1fff)==0x1fff)
	100	/* invalid key press */
	101	return 0;
	102
	103	if (dev!=0x1e && dev!=0x1f)
	104	/* not a hauppauge remote */
	105	return 0;
cc7093df DH	106
	107	if (!range)
	108	code += 64;
	109
	110	dprintk(1,"ir hauppauge (rc5): s%d r%d t%d dev=%d code=%d\n",
	111	start, range, toggle, dev, code);
1da177e4 LT	112
	113	/* return key */
	114	*ir_key = code;
34c08029	115	*ir_raw = ircode;
1da177e4 LT	116	return 1;
	117	}
	118
39cf1e81 JF	119	static inline int get_key_haup(struct IR_i2c ir, u32 ir_key, u32 *ir_raw)
	120	{
	121	return get_key_haup_common (ir, ir_key, ir_raw, 3, 0);
	122	}
	123
	124	static inline int get_key_haup_xvr(struct IR_i2c ir, u32 ir_key, u32 *ir_raw)
	125	{
	126	return get_key_haup_common (ir, ir_key, ir_raw, 6, 3);
	127	}
	128
d5e52653	129	static int get_key_pixelview(struct IR_i2c ir, u32 ir_key, u32 *ir_raw)
1da177e4	130	{
4ac97914	131	unsigned char b;
1da177e4 LT	132
	133	/* poll IR chip */
	134	if (1 != i2c_master_recv(&ir->c,&b,1)) {
	135	dprintk(1,"read error\n");
	136	return -EIO;
	137	}
	138	*ir_key = b;
	139	*ir_raw = b;
	140	return 1;
	141	}
	142
d5e52653	143	static int get_key_pv951(struct IR_i2c ir, u32 ir_key, u32 *ir_raw)
1da177e4	144	{
4ac97914	145	unsigned char b;
1da177e4 LT	146
	147	/* poll IR chip */
	148	if (1 != i2c_master_recv(&ir->c,&b,1)) {
	149	dprintk(1,"read error\n");
	150	return -EIO;
	151	}
	152
	153	/* ignore 0xaa */
	154	if (b==0xaa)
	155	return 0;
	156	dprintk(2,"key %02x\n", b);
	157
	158	*ir_key = b;
	159	*ir_raw = b;
	160	return 1;
	161	}
	162
3c44358c	163	static int get_key_fusionhdtv(struct IR_i2c ir, u32 ir_key, u32 *ir_raw)
d54d6980 CZ	164	{
	165	unsigned char buf[4];
	166
	167	/* poll IR chip */
	168	if (4 != i2c_master_recv(&ir->c,buf,4)) {
	169	dprintk(1,"read error\n");
	170	return -EIO;
	171	}
	172
	173	if(buf[0] !=0 \|\| buf[1] !=0 \|\| buf[2] !=0 \|\| buf[3] != 0)
7e28adb2	174	dprintk(2, "%s: 0x%2x 0x%2x 0x%2x 0x%2x\n", __func__,
d54d6980 CZ	175	buf[0], buf[1], buf[2], buf[3]);
	176
	177	/* no key pressed or signal from other ir remote */
	178	if(buf[0] != 0x1 \|\| buf[1] != 0xfe)
	179	return 0;
	180
	181	*ir_key = buf[2];
	182	*ir_raw = (buf[2] << 8) \| buf[3];
	183
	184	return 1;
d54d6980 CZ	185	}
d54d6980 CZ	186
d5e52653	187	static int get_key_knc1(struct IR_i2c ir, u32 ir_key, u32 *ir_raw)
1da177e4 LT	188	{
	189	unsigned char b;
	190
	191	/* poll IR chip */
	192	if (1 != i2c_master_recv(&ir->c,&b,1)) {
	193	dprintk(1,"read error\n");
	194	return -EIO;
	195	}
	196
	197	/* it seems that 0xFE indicates that a button is still hold
4f9c05aa MCC	198	down, while 0xff indicates that no button is hold
4f9c05aa MCC	199	down. 0xfe sequences are sometimes interrupted by 0xFF */
1da177e4 LT	200
	201	dprintk(2,"key %02x\n", b);
	202
4f9c05aa	203	if (b == 0xff)
1da177e4 LT	204	return 0;
1da177e4 LT	205
4f9c05aa	206	if (b == 0xfe)
1da177e4 LT	207	/* keep old data */
	208	return 1;
	209
	210	*ir_key = b;
	211	*ir_raw = b;
	212	return 1;
	213	}
	214
1da177e4 LT	215	/* ----------------------------------------------------------------------- */
1da177e4 LT	216
d5e52653	217	static void ir_key_poll(struct IR_i2c *ir)
1da177e4 LT	218	{
	219	static u32 ir_key, ir_raw;
	220	int rc;
	221
	222	dprintk(2,"ir_poll_key\n");
	223	rc = ir->get_key(ir, &ir_key, &ir_raw);
	224	if (rc < 0) {
	225	dprintk(2,"error\n");
	226	return;
	227	}
	228
	229	if (0 == rc) {
b7df3910	230	ir_input_nokey(ir->input, &ir->ir);
1da177e4	231	} else {
b7df3910	232	ir_input_keydown(ir->input, &ir->ir, ir_key, ir_raw);
1da177e4 LT	233	}
	234	}
	235
	236	static void ir_timer(unsigned long data)
	237	{
d5e52653	238	struct IR_i2c ir = (struct IR_i2c)data;
1da177e4 LT	239	schedule_work(&ir->work);
	240	}
	241
c4028958	242	static void ir_work(struct work_struct *work)
1da177e4	243	{
c4028958	244	struct IR_i2c *ir = container_of(work, struct IR_i2c, work);
8083c520	245
1da177e4	246	ir_key_poll(ir);
8083c520	247	mod_timer(&ir->timer, jiffies + msecs_to_jiffies(100));
1da177e4 LT	248	}
	249
	250	/* ----------------------------------------------------------------------- */
	251
	252	static int ir_attach(struct i2c_adapter *adap, int addr,
	253	unsigned short flags, int kind);
	254	static int ir_detach(struct i2c_client *client);
	255	static int ir_probe(struct i2c_adapter *adap);
	256
	257	static struct i2c_driver driver = {
604f28e2	258	.driver = {
cab462f7	259	.name = "ir-kbd-i2c",
604f28e2	260	},
dd815408	261	.id = I2C_DRIVERID_INFRARED,
4ac97914 MCC	262	.attach_adapter = ir_probe,
4ac97914 MCC	263	.detach_client = ir_detach,
1da177e4 LT	264	};
	265
	266	static struct i2c_client client_template =
	267	{
4ac97914 MCC	268	.name = "unset",
4ac97914 MCC	269	.driver = &driver
1da177e4 LT	270	};
	271
	272	static int ir_attach(struct i2c_adapter *adap, int addr,
	273	unsigned short flags, int kind)
	274	{
	275	IR_KEYTAB_TYPE *ir_codes = NULL;
	276	char *name;
	277	int ir_type;
afd1a0c9	278	struct IR_i2c *ir;
b7df3910	279	struct input_dev *input_dev;
b07b4783	280	int err;
1da177e4	281
674434c6	282	ir = kzalloc(sizeof(struct IR_i2c),GFP_KERNEL);
b7df3910 DT	283	input_dev = input_allocate_device();
b7df3910 DT	284	if (!ir \|\| !input_dev) {
b07b4783 DT	285	err = -ENOMEM;
b07b4783 DT	286	goto err_out_free;
b7df3910 DT	287	}
b7df3910 DT	288
1da177e4	289	ir->c = client_template;
b7df3910	290	ir->input = input_dev;
1da177e4	291
1da177e4 LT	292	ir->c.adapter = adap;
	293	ir->c.addr = addr;
	294
d21838dd MCC	295	i2c_set_clientdata(&ir->c, ir);
d21838dd MCC	296
1da177e4 LT	297	switch(addr) {
	298	case 0x64:
	299	name = "Pixelview";
	300	ir->get_key = get_key_pixelview;
	301	ir_type = IR_TYPE_OTHER;
	302	ir_codes = ir_codes_empty;
	303	break;
	304	case 0x4b:
	305	name = "PV951";
	306	ir->get_key = get_key_pv951;
	307	ir_type = IR_TYPE_OTHER;
	308	ir_codes = ir_codes_pv951;
	309	break;
	310	case 0x18:
	311	case 0x1a:
	312	name = "Hauppauge";
	313	ir->get_key = get_key_haup;
	314	ir_type = IR_TYPE_RC5;
bf47e4e4	315	if (hauppauge == 1) {
4c0f631e	316	ir_codes = ir_codes_hauppauge_new;
bf47e4e4 A	317	} else {
	318	ir_codes = ir_codes_rc5_tv;
	319	}
1da177e4 LT	320	break;
1da177e4 LT	321	case 0x30:
d5e52653 MCC	322	name = "KNC One";
	323	ir->get_key = get_key_knc1;
	324	ir_type = IR_TYPE_OTHER;
	325	ir_codes = ir_codes_empty;
1da177e4	326	break;
d54d6980	327	case 0x6b:
3c44358c MK	328	name = "FusionHDTV";
3c44358c MK	329	ir->get_key = get_key_fusionhdtv;
d54d6980	330	ir_type = IR_TYPE_RC5;
3c44358c	331	ir_codes = ir_codes_fusionhdtv_mce;
d54d6980	332	break;
1da177e4	333	case 0x7a:
ac9cd976	334	case 0x47:
177aaaf8	335	case 0x71:
e8018c9e	336	case 0x2d:
39cf1e81 JF	337	if (adap->id == I2C_HW_B_CX2388x) {
	338	/* Handled by cx88-input */
	339	name = "CX2388x remote";
	340	ir_type = IR_TYPE_RC5;
	341	ir->get_key = get_key_haup_xvr;
	342	if (hauppauge == 1) {
	343	ir_codes = ir_codes_hauppauge_new;
	344	} else {
	345	ir_codes = ir_codes_rc5_tv;
	346	}
	347	} else {
	348	/* Handled by saa7134-input */
	349	name = "SAA713x remote";
	350	ir_type = IR_TYPE_OTHER;
	351	}
1da177e4 LT	352	break;
	353	default:
	354	/* shouldn't happen */
b07b4783 DT	355	printk(DEVNAME ": Huh? unknown i2c address (0x%02x)?\n", addr);
	356	err = -ENODEV;
	357	goto err_out_free;
1da177e4 LT	358	}
1da177e4 LT	359
ac9cd976	360	/* Sets name */
1da177e4	361	snprintf(ir->c.name, sizeof(ir->c.name), "i2c IR (%s)", name);
b07b4783	362	ir->ir_codes = ir_codes;
d5e52653 MCC	363
	364	/* register i2c device
	365	* At device register, IR codes may be changed to be
	366	* board dependent.
674434c6	367	*/
b07b4783 DT	368	err = i2c_attach_client(&ir->c);
	369	if (err)
	370	goto err_out_free;
1da177e4	371
ac9cd976 RC	372	/* If IR not supported or disabled, unregisters driver */
ac9cd976 RC	373	if (ir->get_key == NULL) {
b07b4783 DT	374	err = -ENODEV;
b07b4783 DT	375	goto err_out_detach;
ac9cd976 RC	376	}
	377
	378	/* Phys addr can only be set after attaching (for ir->c.dev.bus_id) */
	379	snprintf(ir->phys, sizeof(ir->phys), "%s/%s/ir0",
	380	ir->c.adapter->dev.bus_id,
	381	ir->c.dev.bus_id);
	382
1da177e4	383	/* init + register input device */
b07b4783	384	ir_input_init(input_dev, &ir->ir, ir_type, ir->ir_codes);
d21838dd MCC	385	input_dev->id.bustype = BUS_I2C;
	386	input_dev->name = ir->c.name;
	387	input_dev->phys = ir->phys;
b7df3910	388
b07b4783 DT	389	err = input_register_device(ir->input);
	390	if (err)
	391	goto err_out_detach;
	392
d21838dd	393	printk(DEVNAME ": %s detected at %s [%s]\n",
b07b4783	394	ir->input->name, ir->input->phys, adap->name);
1da177e4 LT	395
1da177e4 LT	396	/* start polling via eventd */
c4028958	397	INIT_WORK(&ir->work, ir_work);
1da177e4 LT	398	init_timer(&ir->timer);
	399	ir->timer.function = ir_timer;
	400	ir->timer.data = (unsigned long)ir;
	401	schedule_work(&ir->work);
	402
	403	return 0;
b07b4783 DT	404
	405	err_out_detach:
	406	i2c_detach_client(&ir->c);
	407	err_out_free:
	408	input_free_device(input_dev);
	409	kfree(ir);
	410	return err;
1da177e4 LT	411	}
	412
	413	static int ir_detach(struct i2c_client *client)
	414	{
4ac97914	415	struct IR_i2c *ir = i2c_get_clientdata(client);
1da177e4 LT	416
1da177e4 LT	417	/* kill outstanding polls */
b07b4783	418	del_timer_sync(&ir->timer);
1da177e4 LT	419	flush_scheduled_work();
	420
	421	/* unregister devices */
b7df3910	422	input_unregister_device(ir->input);
1da177e4 LT	423	i2c_detach_client(&ir->c);
	424
	425	/* free memory */
	426	kfree(ir);
	427	return 0;
	428	}
	429
	430	static int ir_probe(struct i2c_adapter *adap)
	431	{
	432
	433	/* The external IR receiver is at i2c address 0x34 (0x35 for
	434	reads). Future Hauppauge cards will have an internal
	435	receiver at 0x30 (0x31 for reads). In theory, both can be
	436	fitted, and Hauppauge suggest an external overrides an
	437	internal.
	438
	439	That's why we probe 0x1a (~0x34) first. CB
	440	*/
	441
	442	static const int probe_bttv[] = { 0x1a, 0x18, 0x4b, 0x64, 0x30, -1};
e8018c9e	443	static const int probe_saa7134[] = { 0x7a, 0x47, 0x71, 0x2d, -1 };
b296fc60	444	static const int probe_em28XX[] = { 0x30, 0x47, -1 };
d54d6980	445	static const int probe_cx88[] = { 0x18, 0x6b, 0x71, -1 };
9bc37caa	446	static const int probe_cx23885[] = { 0x6b, -1 };
d6f34d7a	447	const int *probe;
37c45df7 JD	448	struct i2c_msg msg = {
	449	.flags = I2C_M_RD,
	450	.len = 0,
	451	.buf = NULL,
	452	};
a5885855	453	int i, rc;
1da177e4 LT	454
1da177e4 LT	455	switch (adap->id) {
c7a46533	456	case I2C_HW_B_BT848:
1da177e4 LT	457	probe = probe_bttv;
1da177e4 LT	458	break;
51dab14e	459	case I2C_HW_B_CX2341X:
c097b045	460	probe = probe_bttv;
51dab14e	461	break;
1684a984	462	case I2C_HW_SAA7134:
1da177e4 LT	463	probe = probe_saa7134;
1da177e4 LT	464	break;
b296fc60 MCC	465	case I2C_HW_B_EM28XX:
b296fc60 MCC	466	probe = probe_em28XX;
c365864f	467	break;
39cf1e81 JF	468	case I2C_HW_B_CX2388x:
39cf1e81 JF	469	probe = probe_cx88;
415a1975	470	break;
9bc37caa MK	471	case I2C_HW_B_CX23885:
9bc37caa MK	472	probe = probe_cx23885;
39cf1e81	473	break;
d6f34d7a	474	default:
1da177e4	475	return 0;
d6f34d7a	476	}
1da177e4	477
d5e52653	478	for (i = 0; -1 != probe[i]; i++) {
37c45df7 JD	479	msg.addr = probe[i];
37c45df7 JD	480	rc = i2c_transfer(adap, &msg, 1);
1da177e4 LT	481	dprintk(1,"probe 0x%02x @ %s: %s\n",
1da177e4 LT	482	probe[i], adap->name,
37c45df7 JD	483	(1 == rc) ? "yes" : "no");
37c45df7 JD	484	if (1 == rc) {
a5885855	485	ir_attach(adap, probe[i], 0, 0);
d5e52653	486	break;
1da177e4 LT	487	}
	488	}
	489	return 0;
	490	}
	491
	492	/* ----------------------------------------------------------------------- */
	493
	494	MODULE_AUTHOR("Gerd Knorr, Michal Kochanowicz, Christoph Bartelmus, Ulrich Mueller");
	495	MODULE_DESCRIPTION("input driver for i2c IR remote controls");
	496	MODULE_LICENSE("GPL");
	497
	498	static int __init ir_init(void)
	499	{
	500	return i2c_add_driver(&driver);
	501	}
	502
	503	static void __exit ir_fini(void)
	504	{
	505	i2c_del_driver(&driver);
	506	}
	507
	508	module_init(ir_init);
	509	module_exit(ir_fini);
	510
	511	/*
	512	* Overrides for Emacs so that we follow Linus's tabbing style.
	513	* ---------------------------------------------------------------------------
	514	* Local variables:
	515	* c-basic-offset: 8
	516	* End:
	517	*/