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