ir-kbd-i2c.c revision 769e24382dd47434dfda681f360868c4acd8b6e2 
1/*
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>
11 * modified for em2820 based USB TV tuners by
12 *      Markus Rechberger <mrechberger@gmail.com>
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>
42#include <asm/semaphore.h>
43#include <media/ir-common.h>
44#include <media/ir-kbd-i2c.h>
45
46/* Mark Phalan <phalanm@o2.ie> */
47static IR_KEYTAB_TYPE ir_codes_pv951[IR_KEYTAB_SIZE] = {
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 */
77
78	/* Not sure what to do with these ones! */
79	[ 15 ] = KEY_SELECT, 		/* SOURCE */
80	[ 10 ] = KEY_KPPLUS,		/* +100 */
81	[ 20 ] = KEY_KPEQUAL,		/* SYNC */
82	[ 28 ] = KEY_MEDIA,             /* PC/TV */
83};
84
85/* ----------------------------------------------------------------------- */
86/* insmod parameters                                                       */
87
88static int debug;
89module_param(debug, int, 0644);    /* debug level (0,1,2) */
90
91#define DEVNAME "ir-kbd-i2c"
92#define dprintk(level, fmt, arg...)	if (debug >= level) \
93	printk(KERN_DEBUG DEVNAME ": " fmt , ## arg)
94
95/* ----------------------------------------------------------------------- */
96
97static int get_key_haup(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
98{
99	unsigned char buf[3];
100	int start, toggle, dev, code;
101
102	/* poll IR chip */
103	if (3 != i2c_master_recv(&ir->c,buf,3))
104		return -EIO;
105
106	/* split rc5 data block ... */
107	start  = (buf[0] >> 6) &    3;
108	toggle = (buf[0] >> 5) &    1;
109	dev    =  buf[0]       & 0x1f;
110	code   = (buf[1] >> 2) & 0x3f;
111
112	if (3 != start)
113		/* no key pressed */
114		return 0;
115	dprintk(1,"ir hauppauge (rc5): s%d t%d dev=%d code=%d\n",
116		start, toggle, dev, code);
117
118	/* return key */
119	*ir_key = code;
120	*ir_raw = (start << 12) | (toggle << 11) | (dev << 6) | code;
121	return 1;
122}
123
124static int get_key_pixelview(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
125{
126	unsigned char b;
127
128	/* poll IR chip */
129	if (1 != i2c_master_recv(&ir->c,&b,1)) {
130		dprintk(1,"read error\n");
131		return -EIO;
132	}
133	*ir_key = b;
134	*ir_raw = b;
135	return 1;
136}
137
138static int get_key_pv951(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
139{
140	unsigned char b;
141
142	/* poll IR chip */
143	if (1 != i2c_master_recv(&ir->c,&b,1)) {
144		dprintk(1,"read error\n");
145		return -EIO;
146	}
147
148	/* ignore 0xaa */
149	if (b==0xaa)
150		return 0;
151	dprintk(2,"key %02x\n", b);
152
153	*ir_key = b;
154	*ir_raw = b;
155	return 1;
156}
157
158static int get_key_knc1(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
159{
160	unsigned char b;
161
162	/* poll IR chip */
163	if (1 != i2c_master_recv(&ir->c,&b,1)) {
164		dprintk(1,"read error\n");
165		return -EIO;
166	}
167
168	/* it seems that 0xFE indicates that a button is still hold
169	   down, while 0xff indicates that no button is hold
170	   down. 0xfe sequences are sometimes interrupted by 0xFF */
171
172	dprintk(2,"key %02x\n", b);
173
174	if (b == 0xff)
175		return 0;
176
177	if (b == 0xfe)
178		/* keep old data */
179		return 1;
180
181	*ir_key = b;
182	*ir_raw = b;
183	return 1;
184}
185
186/* The new pinnacle PCTV remote (with the colored buttons)
187 *
188 * Ricardo Cerqueira <v4l@cerqueira.org>
189 */
190
191int get_key_pinnacle(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
192{
193	unsigned char b[4];
194	unsigned int start = 0,parity = 0,code = 0;
195
196	/* poll IR chip */
197	if (4 != i2c_master_recv(&ir->c,b,4)) {
198		dprintk(2,"read error\n");
199		return -EIO;
200	}
201
202	for (start = 0; start<4; start++) {
203		if (b[start] == 0x80) {
204			code=b[(start+3)%4];
205			parity=b[(start+2)%4];
206		}
207	}
208
209	/* Empty Request */
210	if (parity==0)
211		return 0;
212
213	/* Repeating... */
214	if (ir->old == parity)
215		return 0;
216
217
218	ir->old = parity;
219
220	/* Reduce code value to fit inside IR_KEYTAB_SIZE
221	 *
222	 * this is the only value that results in 42 unique
223	 * codes < 128
224	 */
225
226	code %= 0x88;
227
228	*ir_raw = code;
229	*ir_key = code;
230
231	dprintk(1,"Pinnacle PCTV key %02x\n", code);
232
233	return 1;
234}
235
236EXPORT_SYMBOL_GPL(get_key_pinnacle);
237
238/* ----------------------------------------------------------------------- */
239
240static void ir_key_poll(struct IR_i2c *ir)
241{
242	static u32 ir_key, ir_raw;
243	int rc;
244
245	dprintk(2,"ir_poll_key\n");
246	rc = ir->get_key(ir, &ir_key, &ir_raw);
247	if (rc < 0) {
248		dprintk(2,"error\n");
249		return;
250	}
251
252	if (0 == rc) {
253		ir_input_nokey(ir->input, &ir->ir);
254	} else {
255		ir_input_keydown(ir->input, &ir->ir, ir_key, ir_raw);
256	}
257}
258
259static void ir_timer(unsigned long data)
260{
261	struct IR_i2c *ir = (struct IR_i2c*)data;
262	schedule_work(&ir->work);
263}
264
265static void ir_work(void *data)
266{
267	struct IR_i2c *ir = data;
268	ir_key_poll(ir);
269	mod_timer(&ir->timer, jiffies+HZ/10);
270}
271
272/* ----------------------------------------------------------------------- */
273
274static int ir_attach(struct i2c_adapter *adap, int addr,
275		      unsigned short flags, int kind);
276static int ir_detach(struct i2c_client *client);
277static int ir_probe(struct i2c_adapter *adap);
278
279static struct i2c_driver driver = {
280	.name           = "ir remote kbd driver",
281	.id             = I2C_DRIVERID_I2C_IR,
282	.flags          = I2C_DF_NOTIFY,
283	.attach_adapter = ir_probe,
284	.detach_client  = ir_detach,
285};
286
287static struct i2c_client client_template =
288{
289	.name = "unset",
290	.driver = &driver
291};
292
293static int ir_attach(struct i2c_adapter *adap, int addr,
294		     unsigned short flags, int kind)
295{
296	IR_KEYTAB_TYPE *ir_codes = NULL;
297	char *name;
298	int ir_type;
299        struct IR_i2c *ir;
300	struct input_dev *input_dev;
301
302	ir = kzalloc(sizeof(struct IR_i2c), GFP_KERNEL);
303	input_dev = input_allocate_device();
304	if (!ir || !input_dev) {
305		kfree(ir);
306		input_free_device(input_dev);
307                return -ENOMEM;
308	}
309
310	ir->c = client_template;
311	ir->input = input_dev;
312
313	i2c_set_clientdata(&ir->c, ir);
314	ir->c.adapter = adap;
315	ir->c.addr    = addr;
316
317	switch(addr) {
318	case 0x64:
319		name        = "Pixelview";
320		ir->get_key = get_key_pixelview;
321		ir_type     = IR_TYPE_OTHER;
322		ir_codes    = ir_codes_empty;
323		break;
324	case 0x4b:
325		name        = "PV951";
326		ir->get_key = get_key_pv951;
327		ir_type     = IR_TYPE_OTHER;
328		ir_codes    = ir_codes_pv951;
329		break;
330	case 0x18:
331	case 0x1a:
332		name        = "Hauppauge";
333		ir->get_key = get_key_haup;
334		ir_type     = IR_TYPE_RC5;
335		ir_codes    = ir_codes_rc5_tv;
336		break;
337	case 0x30:
338		name        = "KNC One";
339		ir->get_key = get_key_knc1;
340		ir_type     = IR_TYPE_OTHER;
341		ir_codes    = ir_codes_empty;
342		break;
343	case 0x7a:
344	case 0x47:
345		/* Handled by saa7134-input */
346		name        = "SAA713x remote";
347		ir_type     = IR_TYPE_OTHER;
348		break;
349	default:
350		/* shouldn't happen */
351		printk(DEVNAME ": Huh? unknown i2c address (0x%02x)?\n",addr);
352		kfree(ir);
353		return -1;
354	}
355
356	/* Sets name */
357	snprintf(ir->c.name, sizeof(ir->c.name), "i2c IR (%s)", name);
358	ir->ir_codes=ir_codes;
359
360	/* register i2c device
361	 * At device register, IR codes may be changed to be
362	 * board dependent.
363	*/
364	i2c_attach_client(&ir->c);
365
366	/* If IR not supported or disabled, unregisters driver */
367	if (ir->get_key == NULL) {
368		i2c_detach_client(&ir->c);
369		kfree(ir);
370		return -1;
371	}
372
373	/* Phys addr can only be set after attaching (for ir->c.dev.bus_id) */
374	snprintf(ir->phys, sizeof(ir->phys), "%s/%s/ir0",
375		 ir->c.adapter->dev.bus_id,
376		 ir->c.dev.bus_id);
377
378	/* init + register input device */
379	ir_input_init(input_dev, &ir->ir, ir_type, ir_codes);
380	input_dev->id.bustype	= BUS_I2C;
381	input_dev->name		= ir->c.name;
382	input_dev->phys		= ir->phys;
383
384	/* register event device */
385	input_register_device(ir->input);
386
387	/* start polling via eventd */
388	INIT_WORK(&ir->work, ir_work, ir);
389	init_timer(&ir->timer);
390	ir->timer.function = ir_timer;
391	ir->timer.data     = (unsigned long)ir;
392	schedule_work(&ir->work);
393
394	return 0;
395}
396
397static int ir_detach(struct i2c_client *client)
398{
399	struct IR_i2c *ir = i2c_get_clientdata(client);
400
401	/* kill outstanding polls */
402	del_timer(&ir->timer);
403	flush_scheduled_work();
404
405	/* unregister devices */
406	input_unregister_device(ir->input);
407	i2c_detach_client(&ir->c);
408
409	/* free memory */
410	kfree(ir);
411	return 0;
412}
413
414static int ir_probe(struct i2c_adapter *adap)
415{
416
417	/* The external IR receiver is at i2c address 0x34 (0x35 for
418	   reads).  Future Hauppauge cards will have an internal
419	   receiver at 0x30 (0x31 for reads).  In theory, both can be
420	   fitted, and Hauppauge suggest an external overrides an
421	   internal.
422
423	   That's why we probe 0x1a (~0x34) first. CB
424	*/
425
426	static const int probe_bttv[] = { 0x1a, 0x18, 0x4b, 0x64, 0x30, -1};
427	static const int probe_saa7134[] = { 0x7a, 0x47, -1 };
428	static const int probe_em28XX[] = { 0x30, 0x47, -1 };
429	const int *probe = NULL;
430	struct i2c_client c;
431	unsigned char buf;
432	int i,rc;
433
434	switch (adap->id) {
435	case I2C_HW_B_BT848:
436		probe = probe_bttv;
437		break;
438	case I2C_HW_SAA7134:
439		probe = probe_saa7134;
440		break;
441	case I2C_HW_B_EM28XX:
442		probe = probe_em28XX;
443		break;
444	}
445	if (NULL == probe)
446		return 0;
447
448	memset(&c,0,sizeof(c));
449	c.adapter = adap;
450	for (i = 0; -1 != probe[i]; i++) {
451		c.addr = probe[i];
452		rc = i2c_master_recv(&c,&buf,0);
453		dprintk(1,"probe 0x%02x @ %s: %s\n",
454			probe[i], adap->name,
455			(0 == rc) ? "yes" : "no");
456		if (0 == rc) {
457			ir_attach(adap,probe[i],0,0);
458			break;
459		}
460	}
461	return 0;
462}
463
464/* ----------------------------------------------------------------------- */
465
466MODULE_AUTHOR("Gerd Knorr, Michal Kochanowicz, Christoph Bartelmus, Ulrich Mueller");
467MODULE_DESCRIPTION("input driver for i2c IR remote controls");
468MODULE_LICENSE("GPL");
469
470static int __init ir_init(void)
471{
472	return i2c_add_driver(&driver);
473}
474
475static void __exit ir_fini(void)
476{
477	i2c_del_driver(&driver);
478}
479
480module_init(ir_init);
481module_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 */
490