[net-next-2.6.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>
 *
 *  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/moduleparam.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/sched.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/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(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
{
	unsigned char buf[3];
	int start, range, toggle, dev, code;

	/* poll IR chip */
	if (3 != i2c_master_recv(&ir->c,buf,3))
		return -EIO;

	/* split rc5 data block ... */
	start  = (buf[0] >> 7) &    1;
	range  = (buf[0] >> 6) &    1;
	toggle = (buf[0] >> 5) &    1;
	dev    =  buf[0]       & 0x1f;
	code   = (buf[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 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_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<4; 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+HZ/10);
}

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

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;

	ir = kzalloc(sizeof(struct IR_i2c),GFP_KERNEL);
	input_dev = input_allocate_device();
	if (!ir || !input_dev) {
		input_free_device(input_dev);
		kfree(ir);
		return -ENOMEM;
	}
	memset(ir,0,sizeof(*ir));

	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 0x7a:
	case 0x47:
		/* 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);
		kfree(ir);
		return -1;
	}

	/* 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.
	 */
	i2c_attach_client(&ir->c);

	/* If IR not supported or disabled, unregisters driver */
	if (ir->get_key == NULL) {
		i2c_detach_client(&ir->c);
		kfree(ir);
		return -1;
	}

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

	/* register event device */
	input_register_device(ir->input);
	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;
}

static int ir_detach(struct i2c_client *client)
{
	struct IR_i2c *ir = i2c_get_clientdata(client);

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