[mirror_ubuntu-artful-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>
 *
 *  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>

/* Mark Phalan <phalanm@o2.ie> */
static IR_KEYTAB_TYPE ir_codes_pv951[IR_KEYTAB_SIZE] = {
	[  0 ] = KEY_KP0,
	[  1 ] = KEY_KP1,
	[  2 ] = KEY_KP2,
	[  3 ] = KEY_KP3,
	[  4 ] = KEY_KP4,
	[  5 ] = KEY_KP5,
	[  6 ] = KEY_KP6,
	[  7 ] = KEY_KP7,
	[  8 ] = KEY_KP8,
	[  9 ] = KEY_KP9,

	[ 18 ] = KEY_POWER,
	[ 16 ] = KEY_MUTE,
	[ 31 ] = KEY_VOLUMEDOWN,
	[ 27 ] = KEY_VOLUMEUP,
	[ 26 ] = KEY_CHANNELUP,
	[ 30 ] = KEY_CHANNELDOWN,
	[ 14 ] = KEY_PAGEUP,
	[ 29 ] = KEY_PAGEDOWN,
	[ 19 ] = KEY_SOUND,

	[ 24 ] = KEY_KPPLUSMINUS,	/* CH +/- */
	[ 22 ] = KEY_SUBTITLE,		/* CC */
	[ 13 ] = KEY_TEXT,		/* TTX */
	[ 11 ] = KEY_TV,		/* AIR/CBL */
	[ 17 ] = KEY_PC,		/* PC/TV */
	[ 23 ] = KEY_OK,		/* CH RTN */
	[ 25 ] = KEY_MODE, 		/* FUNC */
	[ 12 ] = KEY_SEARCH, 		/* AUTOSCAN */

	/* Not sure what to do with these ones! */
	[ 15 ] = KEY_SELECT, 		/* SOURCE */
	[ 10 ] = KEY_KPPLUS,		/* +100 */
	[ 20 ] = KEY_KPEQUAL,		/* SYNC */
	[ 28 ] = KEY_MEDIA,             /* PC/TV */
};

static IR_KEYTAB_TYPE ir_codes_purpletv[IR_KEYTAB_SIZE] = {
	[ 0x3  ] = KEY_POWER,
	[ 0x6f ] = KEY_MUTE,
	[ 0x10 ] = KEY_BACKSPACE,	/* Recall */

	[ 0x11 ] = KEY_KP0,
	[ 0x4  ] = KEY_KP1,
	[ 0x5  ] = KEY_KP2,
	[ 0x6  ] = KEY_KP3,
	[ 0x8  ] = KEY_KP4,
	[ 0x9  ] = KEY_KP5,
	[ 0xa  ] = KEY_KP6,
	[ 0xc  ] = KEY_KP7,
	[ 0xd  ] = KEY_KP8,
	[ 0xe  ] = KEY_KP9,
	[ 0x12 ] = KEY_KPDOT,		/* 100+ */

	[ 0x7  ] = KEY_VOLUMEUP,
	[ 0xb  ] = KEY_VOLUMEDOWN,
	[ 0x1a ] = KEY_KPPLUS,
	[ 0x18 ] = KEY_KPMINUS,
	[ 0x15 ] = KEY_UP,
	[ 0x1d ] = KEY_DOWN,
	[ 0xf  ] = KEY_CHANNELUP,
	[ 0x13 ] = KEY_CHANNELDOWN,
	[ 0x48 ] = KEY_ZOOM,

	[ 0x1b ] = KEY_VIDEO,		/* Video source */
	[ 0x49 ] = KEY_LANGUAGE,	/* MTS Select */
	[ 0x19 ] = KEY_SEARCH,		/* Auto Scan */

	[ 0x4b ] = KEY_RECORD,
	[ 0x46 ] = KEY_PLAY,
	[ 0x45 ] = KEY_PAUSE,   	/* Pause */
	[ 0x44 ] = KEY_STOP,
	[ 0x40 ] = KEY_FORWARD,   	/* Forward ? */
	[ 0x42 ] = KEY_REWIND,   	/* Backward ? */

};

/* ----------------------------------------------------------------------- */
/* insmod parameters                                                       */

static int debug;
module_param(debug, int, 0644);    /* debug level (0,1,2) */

#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, toggle, dev, code;

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

	/* split rc5 data block ... */
	start  = (buf[0] >> 6) &    3;
	toggle = (buf[0] >> 5) &    1;
	dev    =  buf[0]       & 0x1f;
	code   = (buf[1] >> 2) & 0x3f;

	if (3 != start)
		/* no key pressed */
		return 0;
	dprintk(1,"ir hauppauge (rc5): s%d t%d dev=%d code=%d\n",
		start, 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;
}

static int get_key_purpletv(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;
	}

	/* no button press */
	if (b==0)
		return 0;

	/* repeating */
	if (b & 0x80)
		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(void *data)
{
	struct IR_i2c *ir = data;
	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 = {
        .name           = "ir remote kbd driver",
        .id             = I2C_DRIVERID_EXP3, /* FIXME */
        .flags          = I2C_DF_NOTIFY,
        .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) {
		kfree(ir);
		input_free_device(input_dev);
                return -ENOMEM;
	}

	ir->c = client_template;
	ir->input = input_dev;

	i2c_set_clientdata(&ir->c, ir);
	ir->c.adapter = adap;
	ir->c.addr    = addr;

	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;
		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:
		name        = "Purple TV";
		ir->get_key = get_key_purpletv;
		ir_type     = IR_TYPE_OTHER;
		ir_codes    = ir_codes_purpletv;
		break;

	default:
		/* shouldn't happen */
		printk(DEVNAME ": Huh? unknown i2c address (0x%02x)?\n",addr);
		kfree(ir);
		return -1;
	}

	/* Sets name and its physical addr */
	snprintf(ir->c.name, sizeof(ir->c.name), "i2c IR (%s)", name);
	snprintf(ir->phys, sizeof(ir->phys), "%s/%s/ir0",
		 ir->c.adapter->dev.bus_id,
		 ir->c.dev.bus_id);
	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);

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

	/* start polling via eventd */
	INIT_WORK(&ir->work, ir_work, ir);
	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, -1 };
	static const int probe_em2820[] = { 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_SAA7134:
		probe = probe_saa7134;
		break;
	case I2C_HW_B_EM2820:
		probe = probe_em2820;
		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>
1da177e4	43	#include <media/ir-common.h>
d5e52653	44	#include <media/ir-kbd-i2c.h>
c365864f	45
1da177e4 LT	46	/* Mark Phalan <phalanm@o2.ie> */
1da177e4 LT	47	static IR_KEYTAB_TYPE ir_codes_pv951[IR_KEYTAB_SIZE] = {
d5e52653 MCC	48	[ 0 ] = KEY_KP0,
	49	[ 1 ] = KEY_KP1,
	50	[ 2 ] = KEY_KP2,
	51	[ 3 ] = KEY_KP3,
	52	[ 4 ] = KEY_KP4,
	53	[ 5 ] = KEY_KP5,
	54	[ 6 ] = KEY_KP6,
	55	[ 7 ] = KEY_KP7,
	56	[ 8 ] = KEY_KP8,
	57	[ 9 ] = KEY_KP9,
	58
	59	[ 18 ] = KEY_POWER,
	60	[ 16 ] = KEY_MUTE,
	61	[ 31 ] = KEY_VOLUMEDOWN,
	62	[ 27 ] = KEY_VOLUMEUP,
	63	[ 26 ] = KEY_CHANNELUP,
	64	[ 30 ] = KEY_CHANNELDOWN,
	65	[ 14 ] = KEY_PAGEUP,
	66	[ 29 ] = KEY_PAGEDOWN,
	67	[ 19 ] = KEY_SOUND,
	68
	69	[ 24 ] = KEY_KPPLUSMINUS, /* CH +/- */
	70	[ 22 ] = KEY_SUBTITLE, /* CC */
	71	[ 13 ] = KEY_TEXT, /* TTX */
	72	[ 11 ] = KEY_TV, /* AIR/CBL */
	73	[ 17 ] = KEY_PC, /* PC/TV */
	74	[ 23 ] = KEY_OK, /* CH RTN */
	75	[ 25 ] = KEY_MODE, /* FUNC */
	76	[ 12 ] = KEY_SEARCH, /* AUTOSCAN */
1da177e4 LT	77
1da177e4 LT	78	/* Not sure what to do with these ones! */
d5e52653 MCC	79	[ 15 ] = KEY_SELECT, /* SOURCE */
	80	[ 10 ] = KEY_KPPLUS, /* +100 */
	81	[ 20 ] = KEY_KPEQUAL, /* SYNC */
	82	[ 28 ] = KEY_MEDIA, /* PC/TV */
1da177e4 LT	83	};
	84
	85	static IR_KEYTAB_TYPE ir_codes_purpletv[IR_KEYTAB_SIZE] = {
d5e52653	86	[ 0x3 ] = KEY_POWER,
1da177e4	87	[ 0x6f ] = KEY_MUTE,
de9c6342	88	[ 0x10 ] = KEY_BACKSPACE, /* Recall */
1da177e4 LT	89
1da177e4 LT	90	[ 0x11 ] = KEY_KP0,
d5e52653 MCC	91	[ 0x4 ] = KEY_KP1,
	92	[ 0x5 ] = KEY_KP2,
	93	[ 0x6 ] = KEY_KP3,
	94	[ 0x8 ] = KEY_KP4,
	95	[ 0x9 ] = KEY_KP5,
	96	[ 0xa ] = KEY_KP6,
	97	[ 0xc ] = KEY_KP7,
	98	[ 0xd ] = KEY_KP8,
	99	[ 0xe ] = KEY_KP9,
de9c6342	100	[ 0x12 ] = KEY_KPDOT, /* 100+ */
1da177e4	101
d5e52653 MCC	102	[ 0x7 ] = KEY_VOLUMEUP,
d5e52653 MCC	103	[ 0xb ] = KEY_VOLUMEDOWN,
1da177e4 LT	104	[ 0x1a ] = KEY_KPPLUS,
	105	[ 0x18 ] = KEY_KPMINUS,
	106	[ 0x15 ] = KEY_UP,
	107	[ 0x1d ] = KEY_DOWN,
d5e52653	108	[ 0xf ] = KEY_CHANNELUP,
1da177e4 LT	109	[ 0x13 ] = KEY_CHANNELDOWN,
	110	[ 0x48 ] = KEY_ZOOM,
	111
de9c6342 MCC	112	[ 0x1b ] = KEY_VIDEO, /* Video source */
	113	[ 0x49 ] = KEY_LANGUAGE, /* MTS Select */
	114	[ 0x19 ] = KEY_SEARCH, /* Auto Scan */
1da177e4 LT	115
	116	[ 0x4b ] = KEY_RECORD,
	117	[ 0x46 ] = KEY_PLAY,
de9c6342	118	[ 0x45 ] = KEY_PAUSE, /* Pause */
1da177e4	119	[ 0x44 ] = KEY_STOP,
de9c6342 MCC	120	[ 0x40 ] = KEY_FORWARD, /* Forward ? */
de9c6342 MCC	121	[ 0x42 ] = KEY_REWIND, /* Backward ? */
1da177e4 LT	122
	123	};
	124
1da177e4 LT	125	/* ----------------------------------------------------------------------- */
	126	/* insmod parameters */
	127
	128	static int debug;
	129	module_param(debug, int, 0644); /* debug level (0,1,2) */
	130
	131	#define DEVNAME "ir-kbd-i2c"
	132	#define dprintk(level, fmt, arg...) if (debug >= level) \
	133	printk(KERN_DEBUG DEVNAME ": " fmt , ## arg)
	134
	135	/* ----------------------------------------------------------------------- */
	136
d5e52653	137	static int get_key_haup(struct IR_i2c ir, u32 ir_key, u32 *ir_raw)
1da177e4 LT	138	{
	139	unsigned char buf[3];
	140	int start, toggle, dev, code;
	141
	142	/* poll IR chip */
	143	if (3 != i2c_master_recv(&ir->c,buf,3))
	144	return -EIO;
	145
	146	/* split rc5 data block ... */
	147	start = (buf[0] >> 6) & 3;
	148	toggle = (buf[0] >> 5) & 1;
	149	dev = buf[0] & 0x1f;
	150	code = (buf[1] >> 2) & 0x3f;
	151
	152	if (3 != start)
	153	/* no key pressed */
	154	return 0;
	155	dprintk(1,"ir hauppauge (rc5): s%d t%d dev=%d code=%d\n",
	156	start, toggle, dev, code);
	157
	158	/* return key */
	159	*ir_key = code;
	160	*ir_raw = (start << 12) \| (toggle << 11) \| (dev << 6) \| code;
	161	return 1;
	162	}
	163
d5e52653	164	static int get_key_pixelview(struct IR_i2c ir, u32 ir_key, u32 *ir_raw)
1da177e4 LT	165	{
	166	unsigned char b;
	167
	168	/* poll IR chip */
	169	if (1 != i2c_master_recv(&ir->c,&b,1)) {
	170	dprintk(1,"read error\n");
	171	return -EIO;
	172	}
	173	*ir_key = b;
	174	*ir_raw = b;
	175	return 1;
	176	}
	177
d5e52653	178	static int get_key_pv951(struct IR_i2c ir, u32 ir_key, u32 *ir_raw)
1da177e4 LT	179	{
	180	unsigned char b;
	181
	182	/* poll IR chip */
	183	if (1 != i2c_master_recv(&ir->c,&b,1)) {
	184	dprintk(1,"read error\n");
	185	return -EIO;
	186	}
	187
	188	/* ignore 0xaa */
	189	if (b==0xaa)
	190	return 0;
	191	dprintk(2,"key %02x\n", b);
	192
	193	*ir_key = b;
	194	*ir_raw = b;
	195	return 1;
	196	}
	197
d5e52653	198	static int get_key_knc1(struct IR_i2c ir, u32 ir_key, u32 *ir_raw)
1da177e4 LT	199	{
	200	unsigned char b;
	201
	202	/* poll IR chip */
	203	if (1 != i2c_master_recv(&ir->c,&b,1)) {
	204	dprintk(1,"read error\n");
	205	return -EIO;
	206	}
	207
	208	/* it seems that 0xFE indicates that a button is still hold
	209	down, while 0xFF indicates that no button is hold
	210	down. 0xFE sequences are sometimes interrupted by 0xFF */
	211
	212	dprintk(2,"key %02x\n", b);
	213
	214	if (b == 0xFF)
	215	return 0;
	216
	217	if (b == 0xFE)
	218	/* keep old data */
	219	return 1;
	220
	221	*ir_key = b;
	222	*ir_raw = b;
	223	return 1;
	224	}
	225
d5e52653	226	static int get_key_purpletv(struct IR_i2c ir, u32 ir_key, u32 *ir_raw)
1da177e4 LT	227	{
	228	unsigned char b;
	229
	230	/* poll IR chip */
	231	if (1 != i2c_master_recv(&ir->c,&b,1)) {
	232	dprintk(1,"read error\n");
	233	return -EIO;
	234	}
	235
	236	/* no button press */
	237	if (b==0)
	238	return 0;
	239
	240	/* repeating */
	241	if (b & 0x80)
	242	return 1;
	243
	244	*ir_key = b;
	245	*ir_raw = b;
	246	return 1;
	247	}
	248	/* ----------------------------------------------------------------------- */
	249
d5e52653	250	static void ir_key_poll(struct IR_i2c *ir)
1da177e4 LT	251	{
	252	static u32 ir_key, ir_raw;
	253	int rc;
	254
	255	dprintk(2,"ir_poll_key\n");
	256	rc = ir->get_key(ir, &ir_key, &ir_raw);
	257	if (rc < 0) {
	258	dprintk(2,"error\n");
	259	return;
	260	}
	261
	262	if (0 == rc) {
b7df3910	263	ir_input_nokey(ir->input, &ir->ir);
1da177e4	264	} else {
b7df3910	265	ir_input_keydown(ir->input, &ir->ir, ir_key, ir_raw);
1da177e4 LT	266	}
	267	}
	268
	269	static void ir_timer(unsigned long data)
	270	{
d5e52653	271	struct IR_i2c ir = (struct IR_i2c)data;
1da177e4 LT	272	schedule_work(&ir->work);
	273	}
	274
	275	static void ir_work(void *data)
	276	{
d5e52653	277	struct IR_i2c *ir = data;
1da177e4 LT	278	ir_key_poll(ir);
	279	mod_timer(&ir->timer, jiffies+HZ/10);
	280	}
	281
	282	/* ----------------------------------------------------------------------- */
	283
	284	static int ir_attach(struct i2c_adapter *adap, int addr,
	285	unsigned short flags, int kind);
	286	static int ir_detach(struct i2c_client *client);
	287	static int ir_probe(struct i2c_adapter *adap);
	288
	289	static struct i2c_driver driver = {
	290	.name = "ir remote kbd driver",
	291	.id = I2C_DRIVERID_EXP3, /* FIXME */
	292	.flags = I2C_DF_NOTIFY,
	293	.attach_adapter = ir_probe,
	294	.detach_client = ir_detach,
	295	};
	296
	297	static struct i2c_client client_template =
	298	{
fae91e72	299	.name = "unset",
1da177e4 LT	300	.driver = &driver
	301	};
	302
	303	static int ir_attach(struct i2c_adapter *adap, int addr,
	304	unsigned short flags, int kind)
	305	{
	306	IR_KEYTAB_TYPE *ir_codes = NULL;
	307	char *name;
	308	int ir_type;
d5e52653	309	struct IR_i2c *ir;
b7df3910	310	struct input_dev *input_dev;
1da177e4	311
d5e52653	312	ir = kzalloc(sizeof(struct IR_i2c), GFP_KERNEL);
b7df3910 DT	313	input_dev = input_allocate_device();
	314	if (!ir \|\| !input_dev) {
	315	kfree(ir);
	316	input_free_device(input_dev);
1da177e4	317	return -ENOMEM;
b7df3910 DT	318	}
b7df3910 DT	319
1da177e4	320	ir->c = client_template;
b7df3910	321	ir->input = input_dev;
1da177e4 LT	322
	323	i2c_set_clientdata(&ir->c, ir);
	324	ir->c.adapter = adap;
	325	ir->c.addr = addr;
	326
	327	switch(addr) {
	328	case 0x64:
	329	name = "Pixelview";
	330	ir->get_key = get_key_pixelview;
	331	ir_type = IR_TYPE_OTHER;
	332	ir_codes = ir_codes_empty;
	333	break;
	334	case 0x4b:
	335	name = "PV951";
	336	ir->get_key = get_key_pv951;
	337	ir_type = IR_TYPE_OTHER;
	338	ir_codes = ir_codes_pv951;
	339	break;
	340	case 0x18:
	341	case 0x1a:
	342	name = "Hauppauge";
	343	ir->get_key = get_key_haup;
	344	ir_type = IR_TYPE_RC5;
	345	ir_codes = ir_codes_rc5_tv;
	346	break;
	347	case 0x30:
d5e52653 MCC	348	name = "KNC One";
	349	ir->get_key = get_key_knc1;
	350	ir_type = IR_TYPE_OTHER;
	351	ir_codes = ir_codes_empty;
1da177e4 LT	352	break;
1da177e4 LT	353	case 0x7a:
d5e52653 MCC	354	name = "Purple TV";
	355	ir->get_key = get_key_purpletv;
	356	ir_type = IR_TYPE_OTHER;
	357	ir_codes = ir_codes_purpletv;
1da177e4	358	break;
d5e52653	359
1da177e4 LT	360	default:
	361	/* shouldn't happen */
	362	printk(DEVNAME ": Huh? unknown i2c address (0x%02x)?\n",addr);
	363	kfree(ir);
	364	return -1;
	365	}
	366
d5e52653	367	/* Sets name and its physical addr */
1da177e4 LT	368	snprintf(ir->c.name, sizeof(ir->c.name), "i2c IR (%s)", name);
	369	snprintf(ir->phys, sizeof(ir->phys), "%s/%s/ir0",
	370	ir->c.adapter->dev.bus_id,
	371	ir->c.dev.bus_id);
d5e52653 MCC	372	ir->ir_codes=ir_codes;
	373
	374	/* register i2c device
	375	* At device register, IR codes may be changed to be
	376	* board dependent.
	377	*/
	378	i2c_attach_client(&ir->c);
1da177e4 LT	379
1da177e4 LT	380	/* init + register input device */
b7df3910 DT	381	ir_input_init(input_dev, &ir->ir, ir_type, ir_codes);
	382	input_dev->id.bustype = BUS_I2C;
	383	input_dev->name = ir->c.name;
	384	input_dev->phys = ir->phys;
	385
d5e52653	386	/* register event device */
b7df3910	387	input_register_device(ir->input);
1da177e4 LT	388
	389	/* start polling via eventd */
	390	INIT_WORK(&ir->work, ir_work, ir);
	391	init_timer(&ir->timer);
	392	ir->timer.function = ir_timer;
	393	ir->timer.data = (unsigned long)ir;
	394	schedule_work(&ir->work);
	395
	396	return 0;
	397	}
	398
	399	static int ir_detach(struct i2c_client *client)
	400	{
d5e52653	401	struct IR_i2c *ir = i2c_get_clientdata(client);
1da177e4 LT	402
	403	/* kill outstanding polls */
	404	del_timer(&ir->timer);
	405	flush_scheduled_work();
	406
	407	/* unregister devices */
b7df3910	408	input_unregister_device(ir->input);
1da177e4 LT	409	i2c_detach_client(&ir->c);
	410
	411	/* free memory */
	412	kfree(ir);
	413	return 0;
	414	}
	415
	416	static int ir_probe(struct i2c_adapter *adap)
	417	{
	418
	419	/* The external IR receiver is at i2c address 0x34 (0x35 for
	420	reads). Future Hauppauge cards will have an internal
	421	receiver at 0x30 (0x31 for reads). In theory, both can be
	422	fitted, and Hauppauge suggest an external overrides an
	423	internal.
	424
	425	That's why we probe 0x1a (~0x34) first. CB
	426	*/
	427
	428	static const int probe_bttv[] = { 0x1a, 0x18, 0x4b, 0x64, 0x30, -1};
	429	static const int probe_saa7134[] = { 0x7a, -1 };
d5e52653	430	static const int probe_em2820[] = { 0x30, 0x47, -1 };
1da177e4	431	const int *probe = NULL;
e43f14af	432	struct i2c_client c; unsigned char buf; int i,rc;
1da177e4 LT	433
1da177e4 LT	434	switch (adap->id) {
c7a46533	435	case I2C_HW_B_BT848:
1da177e4 LT	436	probe = probe_bttv;
1da177e4 LT	437	break;
1684a984	438	case I2C_HW_SAA7134:
1da177e4 LT	439	probe = probe_saa7134;
1da177e4 LT	440	break;
c365864f MR	441	case I2C_HW_B_EM2820:
	442	probe = probe_em2820;
	443	break;
1da177e4 LT	444	}
	445	if (NULL == probe)
	446	return 0;
	447
	448	memset(&c,0,sizeof(c));
	449	c.adapter = adap;
d5e52653	450	for (i = 0; -1 != probe[i]; i++) {
1da177e4	451	c.addr = probe[i];
d5e52653	452	rc = i2c_master_recv(&c,&buf,0);
1da177e4 LT	453	dprintk(1,"probe 0x%02x @ %s: %s\n",
1da177e4 LT	454	probe[i], adap->name,
d5e52653 MCC	455	(0 == rc) ? "yes" : "no");
	456	if (0 == rc) {
	457	ir_attach(adap,probe[i],0,0);
	458	break;
1da177e4 LT	459	}
	460	}
	461	return 0;
	462	}
	463
	464	/* ----------------------------------------------------------------------- */
	465
	466	MODULE_AUTHOR("Gerd Knorr, Michal Kochanowicz, Christoph Bartelmus, Ulrich Mueller");
	467	MODULE_DESCRIPTION("input driver for i2c IR remote controls");
	468	MODULE_LICENSE("GPL");
	469
	470	static int __init ir_init(void)
	471	{
	472	return i2c_add_driver(&driver);
	473	}
	474
	475	static void __exit ir_fini(void)
	476	{
	477	i2c_del_driver(&driver);
	478	}
	479
	480	module_init(ir_init);
	481	module_exit(ir_fini);
	482
	483	/*
	484	* Overrides for Emacs so that we follow Linus's tabbing style.
	485	* ---------------------------------------------------------------------------
	486	* Local variables:
	487	* c-basic-offset: 8
	488	* End:
	489	*/