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 * modified for DViCO Fusion HDTV 5 RT GOLD by
14 * Chaogui Zhang <czhang1974@gmail.com>
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>
33 #include <linux/init.h>
34 #include <linux/kernel.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/i2c-id.h>
42 #include <linux/workqueue.h>
43 #include <asm/semaphore.h>
44
45 #include <media/ir-common.h>
46 #include <media/ir-kbd-i2c.h>
47
48 /* ----------------------------------------------------------------------- */
49 /* insmod parameters */
50
51 static int debug;
52 module_param(debug, int, 0644); /* debug level (0,1,2) */
53
54 static int hauppauge = 0;
55 module_param(hauppauge, int, 0644); /* Choose Hauppauge remote */
56 MODULE_PARM_DESC(hauppauge, "Specify Hauppauge remote: 0=black, 1=grey (defaults to 0)");
57
58
59 #define DEVNAME "ir-kbd-i2c"
60 #define dprintk(level, fmt, arg...) if (debug >= level) \
61 printk(KERN_DEBUG DEVNAME ": " fmt , ## arg)
62
63 /* ----------------------------------------------------------------------- */
64
65 static int get_key_haup_common(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw,
66 int size, int offset)
67 {
68 unsigned char buf[6];
69 int start, range, toggle, dev, code;
70
71 /* poll IR chip */
72 if (size != i2c_master_recv(&ir->c,buf,size))
73 return -EIO;
74
75 /* split rc5 data block ... */
76 start = (buf[offset] >> 7) & 1;
77 range = (buf[offset] >> 6) & 1;
78 toggle = (buf[offset] >> 5) & 1;
79 dev = buf[offset] & 0x1f;
80 code = (buf[offset+1] >> 2) & 0x3f;
81
82 /* rc5 has two start bits
83 * the first bit must be one
84 * the second bit defines the command range (1 = 0-63, 0 = 64 - 127)
85 */
86 if (!start)
87 /* no key pressed */
88 return 0;
89
90 if (!range)
91 code += 64;
92
93 dprintk(1,"ir hauppauge (rc5): s%d r%d t%d dev=%d code=%d\n",
94 start, range, toggle, dev, code);
95
96 /* return key */
97 *ir_key = code;
98 *ir_raw = (start << 12) | (toggle << 11) | (dev << 6) | code;
99 return 1;
100 }
101
102 static inline int get_key_haup(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
103 {
104 return get_key_haup_common (ir, ir_key, ir_raw, 3, 0);
105 }
106
107 static inline int get_key_haup_xvr(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
108 {
109 return get_key_haup_common (ir, ir_key, ir_raw, 6, 3);
110 }
111
112 static int get_key_pixelview(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
113 {
114 unsigned char b;
115
116 /* poll IR chip */
117 if (1 != i2c_master_recv(&ir->c,&b,1)) {
118 dprintk(1,"read error\n");
119 return -EIO;
120 }
121 *ir_key = b;
122 *ir_raw = b;
123 return 1;
124 }
125
126 static int get_key_pv951(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
127 {
128 unsigned char b;
129
130 /* poll IR chip */
131 if (1 != i2c_master_recv(&ir->c,&b,1)) {
132 dprintk(1,"read error\n");
133 return -EIO;
134 }
135
136 /* ignore 0xaa */
137 if (b==0xaa)
138 return 0;
139 dprintk(2,"key %02x\n", b);
140
141 *ir_key = b;
142 *ir_raw = b;
143 return 1;
144 }
145
146 static int get_key_fusionhdtv(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
147 {
148 unsigned char buf[4];
149
150 /* poll IR chip */
151 if (4 != i2c_master_recv(&ir->c,buf,4)) {
152 dprintk(1,"read error\n");
153 return -EIO;
154 }
155
156 if(buf[0] !=0 || buf[1] !=0 || buf[2] !=0 || buf[3] != 0)
157 dprintk(2, "%s: 0x%2x 0x%2x 0x%2x 0x%2x\n", __FUNCTION__,
158 buf[0], buf[1], buf[2], buf[3]);
159
160 /* no key pressed or signal from other ir remote */
161 if(buf[0] != 0x1 || buf[1] != 0xfe)
162 return 0;
163
164 *ir_key = buf[2];
165 *ir_raw = (buf[2] << 8) | buf[3];
166
167 return 1;
168 }
169
170 static int get_key_knc1(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
171 {
172 unsigned char b;
173
174 /* poll IR chip */
175 if (1 != i2c_master_recv(&ir->c,&b,1)) {
176 dprintk(1,"read error\n");
177 return -EIO;
178 }
179
180 /* it seems that 0xFE indicates that a button is still hold
181 down, while 0xff indicates that no button is hold
182 down. 0xfe sequences are sometimes interrupted by 0xFF */
183
184 dprintk(2,"key %02x\n", b);
185
186 if (b == 0xff)
187 return 0;
188
189 if (b == 0xfe)
190 /* keep old data */
191 return 1;
192
193 *ir_key = b;
194 *ir_raw = b;
195 return 1;
196 }
197
198 /* Common (grey or coloured) pinnacle PCTV remote handling
199 *
200 */
201 static int get_key_pinnacle(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw,
202 int parity_offset, int marker, int code_modulo)
203 {
204 unsigned char b[4];
205 unsigned int start = 0,parity = 0,code = 0;
206
207 /* poll IR chip */
208 if (4 != i2c_master_recv(&ir->c,b,4)) {
209 dprintk(2,"read error\n");
210 return -EIO;
211 }
212
213 for (start = 0; start < ARRAY_SIZE(b); start++) {
214 if (b[start] == marker) {
215 code=b[(start+parity_offset+1)%4];
216 parity=b[(start+parity_offset)%4];
217 }
218 }
219
220 /* Empty Request */
221 if (parity==0)
222 return 0;
223
224 /* Repeating... */
225 if (ir->old == parity)
226 return 0;
227
228 ir->old = parity;
229
230 /* drop special codes when a key is held down a long time for the grey controller
231 In this case, the second bit of the code is asserted */
232 if (marker == 0xfe && (code & 0x40))
233 return 0;
234
235 code %= code_modulo;
236
237 *ir_raw = code;
238 *ir_key = code;
239
240 dprintk(1,"Pinnacle PCTV key %02x\n", code);
241
242 return 1;
243 }
244
245 /* The grey pinnacle PCTV remote
246 *
247 * There are one issue with this remote:
248 * - I2c packet does not change when the same key is pressed quickly. The workaround
249 * is to hold down each key for about half a second, so that another code is generated
250 * in the i2c packet, and the function can distinguish key presses.
251 *
252 * Sylvain Pasche <sylvain.pasche@gmail.com>
253 */
254 int get_key_pinnacle_grey(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
255 {
256
257 return get_key_pinnacle(ir, ir_key, ir_raw, 1, 0xfe, 0xff);
258 }
259
260 EXPORT_SYMBOL_GPL(get_key_pinnacle_grey);
261
262
263 /* The new pinnacle PCTV remote (with the colored buttons)
264 *
265 * Ricardo Cerqueira <v4l@cerqueira.org>
266 */
267 int get_key_pinnacle_color(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
268 {
269 /* code_modulo parameter (0x88) is used to reduce code value to fit inside IR_KEYTAB_SIZE
270 *
271 * this is the only value that results in 42 unique
272 * codes < 128
273 */
274
275 return get_key_pinnacle(ir, ir_key, ir_raw, 2, 0x80, 0x88);
276 }
277
278 EXPORT_SYMBOL_GPL(get_key_pinnacle_color);
279
280 /* ----------------------------------------------------------------------- */
281
282 static void ir_key_poll(struct IR_i2c *ir)
283 {
284 static u32 ir_key, ir_raw;
285 int rc;
286
287 dprintk(2,"ir_poll_key\n");
288 rc = ir->get_key(ir, &ir_key, &ir_raw);
289 if (rc < 0) {
290 dprintk(2,"error\n");
291 return;
292 }
293
294 if (0 == rc) {
295 ir_input_nokey(ir->input, &ir->ir);
296 } else {
297 ir_input_keydown(ir->input, &ir->ir, ir_key, ir_raw);
298 }
299 }
300
301 static void ir_timer(unsigned long data)
302 {
303 struct IR_i2c *ir = (struct IR_i2c*)data;
304 schedule_work(&ir->work);
305 }
306
307 static void ir_work(struct work_struct *work)
308 {
309 struct IR_i2c *ir = container_of(work, struct IR_i2c, work);
310
311 ir_key_poll(ir);
312 mod_timer(&ir->timer, jiffies + msecs_to_jiffies(100));
313 }
314
315 /* ----------------------------------------------------------------------- */
316
317 static int ir_attach(struct i2c_adapter *adap, int addr,
318 unsigned short flags, int kind);
319 static int ir_detach(struct i2c_client *client);
320 static int ir_probe(struct i2c_adapter *adap);
321
322 static struct i2c_driver driver = {
323 .driver = {
324 .name = "ir-kbd-i2c",
325 },
326 .id = I2C_DRIVERID_INFRARED,
327 .attach_adapter = ir_probe,
328 .detach_client = ir_detach,
329 };
330
331 static struct i2c_client client_template =
332 {
333 .name = "unset",
334 .driver = &driver
335 };
336
337 static int ir_attach(struct i2c_adapter *adap, int addr,
338 unsigned short flags, int kind)
339 {
340 IR_KEYTAB_TYPE *ir_codes = NULL;
341 char *name;
342 int ir_type;
343 struct IR_i2c *ir;
344 struct input_dev *input_dev;
345 int err;
346
347 ir = kzalloc(sizeof(struct IR_i2c),GFP_KERNEL);
348 input_dev = input_allocate_device();
349 if (!ir || !input_dev) {
350 err = -ENOMEM;
351 goto err_out_free;
352 }
353
354 ir->c = client_template;
355 ir->input = input_dev;
356
357 ir->c.adapter = adap;
358 ir->c.addr = addr;
359
360 i2c_set_clientdata(&ir->c, ir);
361
362 switch(addr) {
363 case 0x64:
364 name = "Pixelview";
365 ir->get_key = get_key_pixelview;
366 ir_type = IR_TYPE_OTHER;
367 ir_codes = ir_codes_empty;
368 break;
369 case 0x4b:
370 name = "PV951";
371 ir->get_key = get_key_pv951;
372 ir_type = IR_TYPE_OTHER;
373 ir_codes = ir_codes_pv951;
374 break;
375 case 0x18:
376 case 0x1a:
377 name = "Hauppauge";
378 ir->get_key = get_key_haup;
379 ir_type = IR_TYPE_RC5;
380 if (hauppauge == 1) {
381 ir_codes = ir_codes_hauppauge_new;
382 } else {
383 ir_codes = ir_codes_rc5_tv;
384 }
385 break;
386 case 0x30:
387 name = "KNC One";
388 ir->get_key = get_key_knc1;
389 ir_type = IR_TYPE_OTHER;
390 ir_codes = ir_codes_empty;
391 break;
392 case 0x6b:
393 name = "FusionHDTV";
394 ir->get_key = get_key_fusionhdtv;
395 ir_type = IR_TYPE_RC5;
396 ir_codes = ir_codes_fusionhdtv_mce;
397 break;
398 case 0x7a:
399 case 0x47:
400 case 0x71:
401 case 0x2d:
402 if (adap->id == I2C_HW_B_CX2388x) {
403 /* Handled by cx88-input */
404 name = "CX2388x remote";
405 ir_type = IR_TYPE_RC5;
406 ir->get_key = get_key_haup_xvr;
407 if (hauppauge == 1) {
408 ir_codes = ir_codes_hauppauge_new;
409 } else {
410 ir_codes = ir_codes_rc5_tv;
411 }
412 } else {
413 /* Handled by saa7134-input */
414 name = "SAA713x remote";
415 ir_type = IR_TYPE_OTHER;
416 }
417 break;
418 default:
419 /* shouldn't happen */
420 printk(DEVNAME ": Huh? unknown i2c address (0x%02x)?\n", addr);
421 err = -ENODEV;
422 goto err_out_free;
423 }
424
425 /* Sets name */
426 snprintf(ir->c.name, sizeof(ir->c.name), "i2c IR (%s)", name);
427 ir->ir_codes = ir_codes;
428
429 /* register i2c device
430 * At device register, IR codes may be changed to be
431 * board dependent.
432 */
433 err = i2c_attach_client(&ir->c);
434 if (err)
435 goto err_out_free;
436
437 /* If IR not supported or disabled, unregisters driver */
438 if (ir->get_key == NULL) {
439 err = -ENODEV;
440 goto err_out_detach;
441 }
442
443 /* Phys addr can only be set after attaching (for ir->c.dev.bus_id) */
444 snprintf(ir->phys, sizeof(ir->phys), "%s/%s/ir0",
445 ir->c.adapter->dev.bus_id,
446 ir->c.dev.bus_id);
447
448 /* init + register input device */
449 ir_input_init(input_dev, &ir->ir, ir_type, ir->ir_codes);
450 input_dev->id.bustype = BUS_I2C;
451 input_dev->name = ir->c.name;
452 input_dev->phys = ir->phys;
453
454 err = input_register_device(ir->input);
455 if (err)
456 goto err_out_detach;
457
458 printk(DEVNAME ": %s detected at %s [%s]\n",
459 ir->input->name, ir->input->phys, adap->name);
460
461 /* start polling via eventd */
462 INIT_WORK(&ir->work, ir_work);
463 init_timer(&ir->timer);
464 ir->timer.function = ir_timer;
465 ir->timer.data = (unsigned long)ir;
466 schedule_work(&ir->work);
467
468 return 0;
469
470 err_out_detach:
471 i2c_detach_client(&ir->c);
472 err_out_free:
473 input_free_device(input_dev);
474 kfree(ir);
475 return err;
476 }
477
478 static int ir_detach(struct i2c_client *client)
479 {
480 struct IR_i2c *ir = i2c_get_clientdata(client);
481
482 /* kill outstanding polls */
483 del_timer_sync(&ir->timer);
484 flush_scheduled_work();
485
486 /* unregister devices */
487 input_unregister_device(ir->input);
488 i2c_detach_client(&ir->c);
489
490 /* free memory */
491 kfree(ir);
492 return 0;
493 }
494
495 static int ir_probe(struct i2c_adapter *adap)
496 {
497
498 /* The external IR receiver is at i2c address 0x34 (0x35 for
499 reads). Future Hauppauge cards will have an internal
500 receiver at 0x30 (0x31 for reads). In theory, both can be
501 fitted, and Hauppauge suggest an external overrides an
502 internal.
503
504 That's why we probe 0x1a (~0x34) first. CB
505 */
506
507 static const int probe_bttv[] = { 0x1a, 0x18, 0x4b, 0x64, 0x30, -1};
508 static const int probe_saa7134[] = { 0x7a, 0x47, 0x71, 0x2d, -1 };
509 static const int probe_em28XX[] = { 0x30, 0x47, -1 };
510 static const int probe_cx88[] = { 0x18, 0x6b, 0x71, -1 };
511 static const int probe_cx23885[] = { 0x6b, -1 };
512 const int *probe = NULL;
513 struct i2c_client c;
514 unsigned char buf;
515 int i,rc;
516
517 switch (adap->id) {
518 case I2C_HW_B_BT848:
519 probe = probe_bttv;
520 break;
521 case I2C_HW_B_CX2341X:
522 probe = probe_bttv;
523 break;
524 case I2C_HW_SAA7134:
525 probe = probe_saa7134;
526 break;
527 case I2C_HW_B_EM28XX:
528 probe = probe_em28XX;
529 break;
530 case I2C_HW_B_CX2388x:
531 probe = probe_cx88;
532 break;
533 case I2C_HW_B_CX23885:
534 probe = probe_cx23885;
535 break;
536 }
537 if (NULL == probe)
538 return 0;
539
540 memset(&c,0,sizeof(c));
541 c.adapter = adap;
542 for (i = 0; -1 != probe[i]; i++) {
543 c.addr = probe[i];
544 rc = i2c_master_recv(&c,&buf,0);
545 dprintk(1,"probe 0x%02x @ %s: %s\n",
546 probe[i], adap->name,
547 (0 == rc) ? "yes" : "no");
548 if (0 == rc) {
549 ir_attach(adap,probe[i],0,0);
550 break;
551 }
552 }
553 return 0;
554 }
555
556 /* ----------------------------------------------------------------------- */
557
558 MODULE_AUTHOR("Gerd Knorr, Michal Kochanowicz, Christoph Bartelmus, Ulrich Mueller");
559 MODULE_DESCRIPTION("input driver for i2c IR remote controls");
560 MODULE_LICENSE("GPL");
561
562 static int __init ir_init(void)
563 {
564 return i2c_add_driver(&driver);
565 }
566
567 static void __exit ir_fini(void)
568 {
569 i2c_del_driver(&driver);
570 }
571
572 module_init(ir_init);
573 module_exit(ir_fini);
574
575 /*
576 * Overrides for Emacs so that we follow Linus's tabbing style.
577 * ---------------------------------------------------------------------------
578 * Local variables:
579 * c-basic-offset: 8
580 * End:
581 */
582
|
This page was automatically generated by the
LXR engine.
|