projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'for-linus' of git://git.kernel.dk/linux-block
[deliverable/linux.git] / drivers / media / video / saa7134 / saa7134-input.c
1 /*
2 *
3 * handle saa7134 IR remotes via linux kernel input layer.
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 *
19 */
20
21 #include <linux/module.h>
22 #include <linux/init.h>
23 #include <linux/delay.h>
24 #include <linux/interrupt.h>
25 #include <linux/slab.h>
26
27 #include "saa7134-reg.h"
28 #include "saa7134.h"
29
30 #define MODULE_NAME "saa7134"
31
32 static unsigned int disable_ir;
33 module_param(disable_ir, int, 0444);
34 MODULE_PARM_DESC(disable_ir,"disable infrared remote support");
35
36 static unsigned int ir_debug;
37 module_param(ir_debug, int, 0644);
38 MODULE_PARM_DESC(ir_debug,"enable debug messages [IR]");
39
40 static int pinnacle_remote;
41 module_param(pinnacle_remote, int, 0644); /* Choose Pinnacle PCTV remote */
42 MODULE_PARM_DESC(pinnacle_remote, "Specify Pinnacle PCTV remote: 0=coloured, 1=grey (defaults to 0)");
43
44 #define dprintk(fmt, arg...) if (ir_debug) \
45 printk(KERN_DEBUG "%s/ir: " fmt, dev->name , ## arg)
46 #define i2cdprintk(fmt, arg...) if (ir_debug) \
47 printk(KERN_DEBUG "%s/ir: " fmt, ir->name , ## arg)
48
49 /* Helper function for raw decoding at GPIO16 or GPIO18 */
50 static int saa7134_raw_decode_irq(struct saa7134_dev *dev);
51
52 /* -------------------- GPIO generic keycode builder -------------------- */
53
54 static int build_key(struct saa7134_dev *dev)
55 {
56 struct saa7134_card_ir *ir = dev->remote;
57 u32 gpio, data;
58
59 /* here comes the additional handshake steps for some cards */
60 switch (dev->board) {
61 case SAA7134_BOARD_GOTVIEW_7135:
62 saa_setb(SAA7134_GPIO_GPSTATUS1, 0x80);
63 saa_clearb(SAA7134_GPIO_GPSTATUS1, 0x80);
64 break;
65 }
66 /* rising SAA7134_GPIO_GPRESCAN reads the status */
67 saa_clearb(SAA7134_GPIO_GPMODE3,SAA7134_GPIO_GPRESCAN);
68 saa_setb(SAA7134_GPIO_GPMODE3,SAA7134_GPIO_GPRESCAN);
69
70 gpio = saa_readl(SAA7134_GPIO_GPSTATUS0 >> 2);
71 if (ir->polling) {
72 if (ir->last_gpio == gpio)
73 return 0;
74 ir->last_gpio = gpio;
75 }
76
77 data = ir_extract_bits(gpio, ir->mask_keycode);
78 dprintk("build_key gpio=0x%x mask=0x%x data=%d\n",
79 gpio, ir->mask_keycode, data);
80
81 switch (dev->board) {
82 case SAA7134_BOARD_KWORLD_PLUS_TV_ANALOG:
83 if (data == ir->mask_keycode)
84 rc_keyup(ir->dev);
85 else
86 rc_keydown_notimeout(ir->dev, data, 0);
87 return 0;
88 }
89
90 if (ir->polling) {
91 if ((ir->mask_keydown && (0 != (gpio & ir->mask_keydown))) ||
92 (ir->mask_keyup && (0 == (gpio & ir->mask_keyup)))) {
93 rc_keydown_notimeout(ir->dev, data, 0);
94 } else {
95 rc_keyup(ir->dev);
96 }
97 }
98 else { /* IRQ driven mode - handle key press and release in one go */
99 if ((ir->mask_keydown && (0 != (gpio & ir->mask_keydown))) ||
100 (ir->mask_keyup && (0 == (gpio & ir->mask_keyup)))) {
101 rc_keydown_notimeout(ir->dev, data, 0);
102 rc_keyup(ir->dev);
103 }
104 }
105
106 return 0;
107 }
108
109 /* --------------------- Chip specific I2C key builders ----------------- */
110
111 static int get_key_flydvb_trio(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
112 {
113 int gpio;
114 int attempt = 0;
115 unsigned char b;
116
117 /* We need this to access GPI Used by the saa_readl macro. */
118 struct saa7134_dev *dev = ir->c->adapter->algo_data;
119
120 if (dev == NULL) {
121 i2cdprintk("get_key_flydvb_trio: "
122 "ir->c->adapter->algo_data is NULL!\n");
123 return -EIO;
124 }
125
126 /* rising SAA7134_GPIGPRESCAN reads the status */
127 saa_clearb(SAA7134_GPIO_GPMODE3, SAA7134_GPIO_GPRESCAN);
128 saa_setb(SAA7134_GPIO_GPMODE3, SAA7134_GPIO_GPRESCAN);
129
130 gpio = saa_readl(SAA7134_GPIO_GPSTATUS0 >> 2);
131
132 if (0x40000 & ~gpio)
133 return 0; /* No button press */
134
135 /* No button press - only before first key pressed */
136 if (b == 0xFF)
137 return 0;
138
139 /* poll IR chip */
140 /* weak up the IR chip */
141 b = 0;
142
143 while (1 != i2c_master_send(ir->c, &b, 1)) {
144 if ((attempt++) < 10) {
145 /*
146 * wait a bit for next attempt -
147 * I don't know how make it better
148 */
149 msleep(10);
150 continue;
151 }
152 i2cdprintk("send wake up byte to pic16C505 (IR chip)"
153 "failed %dx\n", attempt);
154 return -EIO;
155 }
156 if (1 != i2c_master_recv(ir->c, &b, 1)) {
157 i2cdprintk("read error\n");
158 return -EIO;
159 }
160
161 *ir_key = b;
162 *ir_raw = b;
163 return 1;
164 }
165
166 static int get_key_msi_tvanywhere_plus(struct IR_i2c *ir, u32 *ir_key,
167 u32 *ir_raw)
168 {
169 unsigned char b;
170 int gpio;
171
172 /* <dev> is needed to access GPIO. Used by the saa_readl macro. */
173 struct saa7134_dev *dev = ir->c->adapter->algo_data;
174 if (dev == NULL) {
175 i2cdprintk("get_key_msi_tvanywhere_plus: "
176 "ir->c->adapter->algo_data is NULL!\n");
177 return -EIO;
178 }
179
180 /* rising SAA7134_GPIO_GPRESCAN reads the status */
181
182 saa_clearb(SAA7134_GPIO_GPMODE3, SAA7134_GPIO_GPRESCAN);
183 saa_setb(SAA7134_GPIO_GPMODE3, SAA7134_GPIO_GPRESCAN);
184
185 gpio = saa_readl(SAA7134_GPIO_GPSTATUS0 >> 2);
186
187 /* GPIO&0x40 is pulsed low when a button is pressed. Don't do
188 I2C receive if gpio&0x40 is not low. */
189
190 if (gpio & 0x40)
191 return 0; /* No button press */
192
193 /* GPIO says there is a button press. Get it. */
194
195 if (1 != i2c_master_recv(ir->c, &b, 1)) {
196 i2cdprintk("read error\n");
197 return -EIO;
198 }
199
200 /* No button press */
201
202 if (b == 0xff)
203 return 0;
204
205 /* Button pressed */
206
207 dprintk("get_key_msi_tvanywhere_plus: Key = 0x%02X\n", b);
208 *ir_key = b;
209 *ir_raw = b;
210 return 1;
211 }
212
213 static int get_key_purpletv(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
214 {
215 unsigned char b;
216
217 /* poll IR chip */
218 if (1 != i2c_master_recv(ir->c, &b, 1)) {
219 i2cdprintk("read error\n");
220 return -EIO;
221 }
222
223 /* no button press */
224 if (b==0)
225 return 0;
226
227 /* repeating */
228 if (b & 0x80)
229 return 1;
230
231 *ir_key = b;
232 *ir_raw = b;
233 return 1;
234 }
235
236 static int get_key_hvr1110(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
237 {
238 unsigned char buf[5];
239
240 /* poll IR chip */
241 if (5 != i2c_master_recv(ir->c, buf, 5))
242 return -EIO;
243
244 /* Check if some key were pressed */
245 if (!(buf[0] & 0x80))
246 return 0;
247
248 /*
249 * buf[3] & 0x80 is always high.
250 * buf[3] & 0x40 is a parity bit. A repeat event is marked
251 * by preserving it into two separate readings
252 * buf[4] bits 0 and 1, and buf[1] and buf[2] are always
253 * zero.
254 */
255 *ir_key = 0x1fff & ((buf[3] << 8) | (buf[4] >> 2));
256 *ir_raw = *ir_key;
257 return 1;
258 }
259
260
261 static int get_key_beholdm6xx(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
262 {
263 unsigned char data[12];
264 u32 gpio;
265
266 struct saa7134_dev *dev = ir->c->adapter->algo_data;
267
268 /* rising SAA7134_GPIO_GPRESCAN reads the status */
269 saa_clearb(SAA7134_GPIO_GPMODE3, SAA7134_GPIO_GPRESCAN);
270 saa_setb(SAA7134_GPIO_GPMODE3, SAA7134_GPIO_GPRESCAN);
271
272 gpio = saa_readl(SAA7134_GPIO_GPSTATUS0 >> 2);
273
274 if (0x400000 & ~gpio)
275 return 0; /* No button press */
276
277 ir->c->addr = 0x5a >> 1;
278
279 if (12 != i2c_master_recv(ir->c, data, 12)) {
280 i2cdprintk("read error\n");
281 return -EIO;
282 }
283
284 if (data[9] != (unsigned char)(~data[8]))
285 return 0;
286
287 *ir_raw = ((data[10] << 16) | (data[11] << 8) | (data[9] << 0));
288 *ir_key = *ir_raw;
289
290 return 1;
291 }
292
293 /* Common (grey or coloured) pinnacle PCTV remote handling
294 *
295 */
296 static int get_key_pinnacle(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw,
297 int parity_offset, int marker, int code_modulo)
298 {
299 unsigned char b[4];
300 unsigned int start = 0,parity = 0,code = 0;
301
302 /* poll IR chip */
303 if (4 != i2c_master_recv(ir->c, b, 4)) {
304 i2cdprintk("read error\n");
305 return -EIO;
306 }
307
308 for (start = 0; start < ARRAY_SIZE(b); start++) {
309 if (b[start] == marker) {
310 code=b[(start+parity_offset + 1) % 4];
311 parity=b[(start+parity_offset) % 4];
312 }
313 }
314
315 /* Empty Request */
316 if (parity == 0)
317 return 0;
318
319 /* Repeating... */
320 if (ir->old == parity)
321 return 0;
322
323 ir->old = parity;
324
325 /* drop special codes when a key is held down a long time for the grey controller
326 In this case, the second bit of the code is asserted */
327 if (marker == 0xfe && (code & 0x40))
328 return 0;
329
330 code %= code_modulo;
331
332 *ir_raw = code;
333 *ir_key = code;
334
335 i2cdprintk("Pinnacle PCTV key %02x\n", code);
336
337 return 1;
338 }
339
340 /* The grey pinnacle PCTV remote
341 *
342 * There are one issue with this remote:
343 * - I2c packet does not change when the same key is pressed quickly. The workaround
344 * is to hold down each key for about half a second, so that another code is generated
345 * in the i2c packet, and the function can distinguish key presses.
346 *
347 * Sylvain Pasche <sylvain.pasche@gmail.com>
348 */
349 static int get_key_pinnacle_grey(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
350 {
351
352 return get_key_pinnacle(ir, ir_key, ir_raw, 1, 0xfe, 0xff);
353 }
354
355
356 /* The new pinnacle PCTV remote (with the colored buttons)
357 *
358 * Ricardo Cerqueira <v4l@cerqueira.org>
359 */
360 static int get_key_pinnacle_color(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
361 {
362 /* code_modulo parameter (0x88) is used to reduce code value to fit inside IR_KEYTAB_SIZE
363 *
364 * this is the only value that results in 42 unique
365 * codes < 128
366 */
367
368 return get_key_pinnacle(ir, ir_key, ir_raw, 2, 0x80, 0x88);
369 }
370
371 void saa7134_input_irq(struct saa7134_dev *dev)
372 {
373 struct saa7134_card_ir *ir;
374
375 if (!dev || !dev->remote)
376 return;
377
378 ir = dev->remote;
379 if (!ir->running)
380 return;
381
382 if (!ir->polling && !ir->raw_decode) {
383 build_key(dev);
384 } else if (ir->raw_decode) {
385 saa7134_raw_decode_irq(dev);
386 }
387 }
388
389 static void saa7134_input_timer(unsigned long data)
390 {
391 struct saa7134_dev *dev = (struct saa7134_dev *)data;
392 struct saa7134_card_ir *ir = dev->remote;
393
394 build_key(dev);
395 mod_timer(&ir->timer, jiffies + msecs_to_jiffies(ir->polling));
396 }
397
398 static void ir_raw_decode_timer_end(unsigned long data)
399 {
400 struct saa7134_dev *dev = (struct saa7134_dev *)data;
401 struct saa7134_card_ir *ir = dev->remote;
402
403 ir_raw_event_handle(dev->remote->dev);
404
405 ir->active = false;
406 }
407
408 static int __saa7134_ir_start(void *priv)
409 {
410 struct saa7134_dev *dev = priv;
411 struct saa7134_card_ir *ir;
412
413 if (!dev || !dev->remote)
414 return -EINVAL;
415
416 ir = dev->remote;
417 if (ir->running)
418 return 0;
419
420 /* Moved here from saa7134_input_init1() because the latter
421 * is not called on device resume */
422 switch (dev->board) {
423 case SAA7134_BOARD_MD2819:
424 case SAA7134_BOARD_KWORLD_VSTREAM_XPERT:
425 case SAA7134_BOARD_AVERMEDIA_305:
426 case SAA7134_BOARD_AVERMEDIA_307:
427 case SAA7134_BOARD_AVERMEDIA_STUDIO_305:
428 case SAA7134_BOARD_AVERMEDIA_STUDIO_505:
429 case SAA7134_BOARD_AVERMEDIA_STUDIO_307:
430 case SAA7134_BOARD_AVERMEDIA_STUDIO_507:
431 case SAA7134_BOARD_AVERMEDIA_STUDIO_507UA:
432 case SAA7134_BOARD_AVERMEDIA_GO_007_FM:
433 case SAA7134_BOARD_AVERMEDIA_M102:
434 case SAA7134_BOARD_AVERMEDIA_GO_007_FM_PLUS:
435 /* Without this we won't receive key up events */
436 saa_setb(SAA7134_GPIO_GPMODE0, 0x4);
437 saa_setb(SAA7134_GPIO_GPSTATUS0, 0x4);
438 break;
439 case SAA7134_BOARD_AVERMEDIA_777:
440 case SAA7134_BOARD_AVERMEDIA_A16AR:
441 /* Without this we won't receive key up events */
442 saa_setb(SAA7134_GPIO_GPMODE1, 0x1);
443 saa_setb(SAA7134_GPIO_GPSTATUS1, 0x1);
444 break;
445 case SAA7134_BOARD_AVERMEDIA_A16D:
446 /* Without this we won't receive key up events */
447 saa_setb(SAA7134_GPIO_GPMODE1, 0x1);
448 saa_setb(SAA7134_GPIO_GPSTATUS1, 0x1);
449 break;
450 case SAA7134_BOARD_GOTVIEW_7135:
451 saa_setb(SAA7134_GPIO_GPMODE1, 0x80);
452 break;
453 }
454
455 ir->running = true;
456 ir->active = false;
457
458 if (ir->polling) {
459 setup_timer(&ir->timer, saa7134_input_timer,
460 (unsigned long)dev);
461 ir->timer.expires = jiffies + HZ;
462 add_timer(&ir->timer);
463 } else if (ir->raw_decode) {
464 /* set timer_end for code completion */
465 setup_timer(&ir->timer, ir_raw_decode_timer_end,
466 (unsigned long)dev);
467 }
468
469 return 0;
470 }
471
472 static void __saa7134_ir_stop(void *priv)
473 {
474 struct saa7134_dev *dev = priv;
475 struct saa7134_card_ir *ir;
476
477 if (!dev || !dev->remote)
478 return;
479
480 ir = dev->remote;
481 if (!ir->running)
482 return;
483
484 if (ir->polling || ir->raw_decode)
485 del_timer_sync(&ir->timer);
486
487 ir->active = false;
488 ir->running = false;
489
490 return;
491 }
492
493 int saa7134_ir_start(struct saa7134_dev *dev)
494 {
495 if (dev->remote->users)
496 return __saa7134_ir_start(dev);
497
498 return 0;
499 }
500
501 void saa7134_ir_stop(struct saa7134_dev *dev)
502 {
503 if (dev->remote->users)
504 __saa7134_ir_stop(dev);
505 }
506
507 static int saa7134_ir_open(struct rc_dev *rc)
508 {
509 struct saa7134_dev *dev = rc->priv;
510
511 dev->remote->users++;
512 return __saa7134_ir_start(dev);
513 }
514
515 static void saa7134_ir_close(struct rc_dev *rc)
516 {
517 struct saa7134_dev *dev = rc->priv;
518
519 dev->remote->users--;
520 if (!dev->remote->users)
521 __saa7134_ir_stop(dev);
522 }
523
524 int saa7134_input_init1(struct saa7134_dev *dev)
525 {
526 struct saa7134_card_ir *ir;
527 struct rc_dev *rc;
528 char *ir_codes = NULL;
529 u32 mask_keycode = 0;
530 u32 mask_keydown = 0;
531 u32 mask_keyup = 0;
532 unsigned polling = 0;
533 bool raw_decode = false;
534 int err;
535
536 if (dev->has_remote != SAA7134_REMOTE_GPIO)
537 return -ENODEV;
538 if (disable_ir)
539 return -ENODEV;
540
541 /* detect & configure */
542 switch (dev->board) {
543 case SAA7134_BOARD_FLYVIDEO2000:
544 case SAA7134_BOARD_FLYVIDEO3000:
545 case SAA7134_BOARD_FLYTVPLATINUM_FM:
546 case SAA7134_BOARD_FLYTVPLATINUM_MINI2:
547 case SAA7134_BOARD_ROVERMEDIA_LINK_PRO_FM:
548 ir_codes = RC_MAP_FLYVIDEO;
549 mask_keycode = 0xEC00000;
550 mask_keydown = 0x0040000;
551 break;
552 case SAA7134_BOARD_CINERGY400:
553 case SAA7134_BOARD_CINERGY600:
554 case SAA7134_BOARD_CINERGY600_MK3:
555 ir_codes = RC_MAP_CINERGY;
556 mask_keycode = 0x00003f;
557 mask_keyup = 0x040000;
558 break;
559 case SAA7134_BOARD_ECS_TVP3XP:
560 case SAA7134_BOARD_ECS_TVP3XP_4CB5:
561 ir_codes = RC_MAP_EZTV;
562 mask_keycode = 0x00017c;
563 mask_keyup = 0x000002;
564 polling = 50; // ms
565 break;
566 case SAA7134_BOARD_KWORLD_XPERT:
567 case SAA7134_BOARD_AVACSSMARTTV:
568 ir_codes = RC_MAP_PIXELVIEW;
569 mask_keycode = 0x00001F;
570 mask_keyup = 0x000020;
571 polling = 50; // ms
572 break;
573 case SAA7134_BOARD_MD2819:
574 case SAA7134_BOARD_KWORLD_VSTREAM_XPERT:
575 case SAA7134_BOARD_AVERMEDIA_305:
576 case SAA7134_BOARD_AVERMEDIA_307:
577 case SAA7134_BOARD_AVERMEDIA_STUDIO_305:
578 case SAA7134_BOARD_AVERMEDIA_STUDIO_505:
579 case SAA7134_BOARD_AVERMEDIA_STUDIO_307:
580 case SAA7134_BOARD_AVERMEDIA_STUDIO_507:
581 case SAA7134_BOARD_AVERMEDIA_STUDIO_507UA:
582 case SAA7134_BOARD_AVERMEDIA_GO_007_FM:
583 case SAA7134_BOARD_AVERMEDIA_M102:
584 case SAA7134_BOARD_AVERMEDIA_GO_007_FM_PLUS:
585 ir_codes = RC_MAP_AVERMEDIA;
586 mask_keycode = 0x0007C8;
587 mask_keydown = 0x000010;
588 polling = 50; // ms
589 /* GPIO stuff moved to __saa7134_ir_start() */
590 break;
591 case SAA7134_BOARD_AVERMEDIA_M135A:
592 ir_codes = RC_MAP_AVERMEDIA_M135A;
593 mask_keydown = 0x0040000; /* Enable GPIO18 line on both edges */
594 mask_keyup = 0x0040000;
595 mask_keycode = 0xffff;
596 raw_decode = true;
597 break;
598 case SAA7134_BOARD_AVERMEDIA_M733A:
599 ir_codes = RC_MAP_AVERMEDIA_M733A_RM_K6;
600 mask_keydown = 0x0040000;
601 mask_keyup = 0x0040000;
602 mask_keycode = 0xffff;
603 raw_decode = true;
604 break;
605 case SAA7134_BOARD_AVERMEDIA_777:
606 case SAA7134_BOARD_AVERMEDIA_A16AR:
607 ir_codes = RC_MAP_AVERMEDIA;
608 mask_keycode = 0x02F200;
609 mask_keydown = 0x000400;
610 polling = 50; // ms
611 /* GPIO stuff moved to __saa7134_ir_start() */
612 break;
613 case SAA7134_BOARD_AVERMEDIA_A16D:
614 ir_codes = RC_MAP_AVERMEDIA_A16D;
615 mask_keycode = 0x02F200;
616 mask_keydown = 0x000400;
617 polling = 50; /* ms */
618 /* GPIO stuff moved to __saa7134_ir_start() */
619 break;
620 case SAA7134_BOARD_KWORLD_TERMINATOR:
621 ir_codes = RC_MAP_PIXELVIEW;
622 mask_keycode = 0x00001f;
623 mask_keyup = 0x000060;
624 polling = 50; // ms
625 break;
626 case SAA7134_BOARD_MANLI_MTV001:
627 case SAA7134_BOARD_MANLI_MTV002:
628 ir_codes = RC_MAP_MANLI;
629 mask_keycode = 0x001f00;
630 mask_keyup = 0x004000;
631 polling = 50; /* ms */
632 break;
633 case SAA7134_BOARD_BEHOLD_409FM:
634 case SAA7134_BOARD_BEHOLD_401:
635 case SAA7134_BOARD_BEHOLD_403:
636 case SAA7134_BOARD_BEHOLD_403FM:
637 case SAA7134_BOARD_BEHOLD_405:
638 case SAA7134_BOARD_BEHOLD_405FM:
639 case SAA7134_BOARD_BEHOLD_407:
640 case SAA7134_BOARD_BEHOLD_407FM:
641 case SAA7134_BOARD_BEHOLD_409:
642 case SAA7134_BOARD_BEHOLD_505FM:
643 case SAA7134_BOARD_BEHOLD_505RDS_MK5:
644 case SAA7134_BOARD_BEHOLD_505RDS_MK3:
645 case SAA7134_BOARD_BEHOLD_507_9FM:
646 case SAA7134_BOARD_BEHOLD_507RDS_MK3:
647 case SAA7134_BOARD_BEHOLD_507RDS_MK5:
648 ir_codes = RC_MAP_MANLI;
649 mask_keycode = 0x003f00;
650 mask_keyup = 0x004000;
651 polling = 50; /* ms */
652 break;
653 case SAA7134_BOARD_BEHOLD_COLUMBUS_TVFM:
654 ir_codes = RC_MAP_BEHOLD_COLUMBUS;
655 mask_keycode = 0x003f00;
656 mask_keyup = 0x004000;
657 polling = 50; // ms
658 break;
659 case SAA7134_BOARD_SEDNA_PC_TV_CARDBUS:
660 ir_codes = RC_MAP_PCTV_SEDNA;
661 mask_keycode = 0x001f00;
662 mask_keyup = 0x004000;
663 polling = 50; // ms
664 break;
665 case SAA7134_BOARD_GOTVIEW_7135:
666 ir_codes = RC_MAP_GOTVIEW7135;
667 mask_keycode = 0x0003CC;
668 mask_keydown = 0x000010;
669 polling = 5; /* ms */
670 /* GPIO stuff moved to __saa7134_ir_start() */
671 break;
672 case SAA7134_BOARD_VIDEOMATE_TV_PVR:
673 case SAA7134_BOARD_VIDEOMATE_GOLD_PLUS:
674 case SAA7134_BOARD_VIDEOMATE_TV_GOLD_PLUSII:
675 ir_codes = RC_MAP_VIDEOMATE_TV_PVR;
676 mask_keycode = 0x00003F;
677 mask_keyup = 0x400000;
678 polling = 50; // ms
679 break;
680 case SAA7134_BOARD_PROTEUS_2309:
681 ir_codes = RC_MAP_PROTEUS_2309;
682 mask_keycode = 0x00007F;
683 mask_keyup = 0x000080;
684 polling = 50; // ms
685 break;
686 case SAA7134_BOARD_VIDEOMATE_DVBT_300:
687 case SAA7134_BOARD_VIDEOMATE_DVBT_200:
688 ir_codes = RC_MAP_VIDEOMATE_TV_PVR;
689 mask_keycode = 0x003F00;
690 mask_keyup = 0x040000;
691 break;
692 case SAA7134_BOARD_FLYDVBS_LR300:
693 case SAA7134_BOARD_FLYDVBT_LR301:
694 case SAA7134_BOARD_FLYDVBTDUO:
695 ir_codes = RC_MAP_FLYDVB;
696 mask_keycode = 0x0001F00;
697 mask_keydown = 0x0040000;
698 break;
699 case SAA7134_BOARD_ASUSTeK_P7131_DUAL:
700 case SAA7134_BOARD_ASUSTeK_P7131_HYBRID_LNA:
701 case SAA7134_BOARD_ASUSTeK_P7131_ANALOG:
702 ir_codes = RC_MAP_ASUS_PC39;
703 mask_keydown = 0x0040000; /* Enable GPIO18 line on both edges */
704 mask_keyup = 0x0040000;
705 mask_keycode = 0xffff;
706 raw_decode = true;
707 break;
708 case SAA7134_BOARD_ENCORE_ENLTV:
709 case SAA7134_BOARD_ENCORE_ENLTV_FM:
710 ir_codes = RC_MAP_ENCORE_ENLTV;
711 mask_keycode = 0x00007f;
712 mask_keyup = 0x040000;
713 polling = 50; // ms
714 break;
715 case SAA7134_BOARD_ENCORE_ENLTV_FM53:
716 case SAA7134_BOARD_ENCORE_ENLTV_FM3:
717 ir_codes = RC_MAP_ENCORE_ENLTV_FM53;
718 mask_keydown = 0x0040000; /* Enable GPIO18 line on both edges */
719 mask_keyup = 0x0040000;
720 mask_keycode = 0xffff;
721 raw_decode = true;
722 break;
723 case SAA7134_BOARD_10MOONSTVMASTER3:
724 ir_codes = RC_MAP_ENCORE_ENLTV;
725 mask_keycode = 0x5f80000;
726 mask_keyup = 0x8000000;
727 polling = 50; //ms
728 break;
729 case SAA7134_BOARD_GENIUS_TVGO_A11MCE:
730 ir_codes = RC_MAP_GENIUS_TVGO_A11MCE;
731 mask_keycode = 0xff;
732 mask_keydown = 0xf00000;
733 polling = 50; /* ms */
734 break;
735 case SAA7134_BOARD_REAL_ANGEL_220:
736 ir_codes = RC_MAP_REAL_AUDIO_220_32_KEYS;
737 mask_keycode = 0x3f00;
738 mask_keyup = 0x4000;
739 polling = 50; /* ms */
740 break;
741 case SAA7134_BOARD_KWORLD_PLUS_TV_ANALOG:
742 ir_codes = RC_MAP_KWORLD_PLUS_TV_ANALOG;
743 mask_keycode = 0x7f;
744 polling = 40; /* ms */
745 break;
746 case SAA7134_BOARD_VIDEOMATE_S350:
747 ir_codes = RC_MAP_VIDEOMATE_S350;
748 mask_keycode = 0x003f00;
749 mask_keydown = 0x040000;
750 break;
751 case SAA7134_BOARD_LEADTEK_WINFAST_DTV1000S:
752 ir_codes = RC_MAP_WINFAST;
753 mask_keycode = 0x5f00;
754 mask_keyup = 0x020000;
755 polling = 50; /* ms */
756 break;
757 case SAA7134_BOARD_VIDEOMATE_M1F:
758 ir_codes = RC_MAP_VIDEOMATE_K100;
759 mask_keycode = 0x0ff00;
760 mask_keyup = 0x040000;
761 break;
762 case SAA7134_BOARD_HAUPPAUGE_HVR1150:
763 case SAA7134_BOARD_HAUPPAUGE_HVR1120:
764 ir_codes = RC_MAP_HAUPPAUGE;
765 mask_keydown = 0x0040000; /* Enable GPIO18 line on both edges */
766 mask_keyup = 0x0040000;
767 mask_keycode = 0xffff;
768 raw_decode = true;
769 break;
770 }
771 if (NULL == ir_codes) {
772 printk("%s: Oops: IR config error [card=%d]\n",
773 dev->name, dev->board);
774 return -ENODEV;
775 }
776
777 ir = kzalloc(sizeof(*ir), GFP_KERNEL);
778 rc = rc_allocate_device();
779 if (!ir || !rc) {
780 err = -ENOMEM;
781 goto err_out_free;
782 }
783
784 ir->dev = rc;
785 dev->remote = ir;
786
787 /* init hardware-specific stuff */
788 ir->mask_keycode = mask_keycode;
789 ir->mask_keydown = mask_keydown;
790 ir->mask_keyup = mask_keyup;
791 ir->polling = polling;
792 ir->raw_decode = raw_decode;
793
794 /* init input device */
795 snprintf(ir->name, sizeof(ir->name), "saa7134 IR (%s)",
796 saa7134_boards[dev->board].name);
797 snprintf(ir->phys, sizeof(ir->phys), "pci-%s/ir0",
798 pci_name(dev->pci));
799
800 rc->priv = dev;
801 rc->open = saa7134_ir_open;
802 rc->close = saa7134_ir_close;
803 if (raw_decode)
804 rc->driver_type = RC_DRIVER_IR_RAW;
805
806 rc->input_name = ir->name;
807 rc->input_phys = ir->phys;
808 rc->input_id.bustype = BUS_PCI;
809 rc->input_id.version = 1;
810 if (dev->pci->subsystem_vendor) {
811 rc->input_id.vendor = dev->pci->subsystem_vendor;
812 rc->input_id.product = dev->pci->subsystem_device;
813 } else {
814 rc->input_id.vendor = dev->pci->vendor;
815 rc->input_id.product = dev->pci->device;
816 }
817 rc->dev.parent = &dev->pci->dev;
818 rc->map_name = ir_codes;
819 rc->driver_name = MODULE_NAME;
820
821 err = rc_register_device(rc);
822 if (err)
823 goto err_out_free;
824
825 return 0;
826
827 err_out_free:
828 rc_free_device(rc);
829 dev->remote = NULL;
830 kfree(ir);
831 return err;
832 }
833
834 void saa7134_input_fini(struct saa7134_dev *dev)
835 {
836 if (NULL == dev->remote)
837 return;
838
839 saa7134_ir_stop(dev);
840 rc_unregister_device(dev->remote->dev);
841 kfree(dev->remote);
842 dev->remote = NULL;
843 }
844
845 void saa7134_probe_i2c_ir(struct saa7134_dev *dev)
846 {
847 struct i2c_board_info info;
848 struct i2c_msg msg_msi = {
849 .addr = 0x50,
850 .flags = I2C_M_RD,
851 .len = 0,
852 .buf = NULL,
853 };
854 int rc;
855
856 if (disable_ir) {
857 dprintk("IR has been disabled, not probing for i2c remote\n");
858 return;
859 }
860
861 memset(&info, 0, sizeof(struct i2c_board_info));
862 memset(&dev->init_data, 0, sizeof(dev->init_data));
863 strlcpy(info.type, "ir_video", I2C_NAME_SIZE);
864
865 switch (dev->board) {
866 case SAA7134_BOARD_PINNACLE_PCTV_110i:
867 case SAA7134_BOARD_PINNACLE_PCTV_310i:
868 dev->init_data.name = "Pinnacle PCTV";
869 if (pinnacle_remote == 0) {
870 dev->init_data.get_key = get_key_pinnacle_color;
871 dev->init_data.ir_codes = RC_MAP_PINNACLE_COLOR;
872 info.addr = 0x47;
873 } else {
874 dev->init_data.get_key = get_key_pinnacle_grey;
875 dev->init_data.ir_codes = RC_MAP_PINNACLE_GREY;
876 info.addr = 0x47;
877 }
878 break;
879 case SAA7134_BOARD_UPMOST_PURPLE_TV:
880 dev->init_data.name = "Purple TV";
881 dev->init_data.get_key = get_key_purpletv;
882 dev->init_data.ir_codes = RC_MAP_PURPLETV;
883 info.addr = 0x7a;
884 break;
885 case SAA7134_BOARD_MSI_TVATANYWHERE_PLUS:
886 dev->init_data.name = "MSI TV@nywhere Plus";
887 dev->init_data.get_key = get_key_msi_tvanywhere_plus;
888 dev->init_data.ir_codes = RC_MAP_MSI_TVANYWHERE_PLUS;
889 /*
890 * MSI TV@nyware Plus requires more frequent polling
891 * otherwise it will miss some keypresses
892 */
893 dev->init_data.polling_interval = 50;
894 info.addr = 0x30;
895 /* MSI TV@nywhere Plus controller doesn't seem to
896 respond to probes unless we read something from
897 an existing device. Weird...
898 REVISIT: might no longer be needed */
899 rc = i2c_transfer(&dev->i2c_adap, &msg_msi, 1);
900 dprintk("probe 0x%02x @ %s: %s\n",
901 msg_msi.addr, dev->i2c_adap.name,
902 (1 == rc) ? "yes" : "no");
903 break;
904 case SAA7134_BOARD_HAUPPAUGE_HVR1110:
905 dev->init_data.name = "HVR 1110";
906 dev->init_data.get_key = get_key_hvr1110;
907 dev->init_data.ir_codes = RC_MAP_HAUPPAUGE;
908 info.addr = 0x71;
909 break;
910 case SAA7134_BOARD_BEHOLD_607FM_MK3:
911 case SAA7134_BOARD_BEHOLD_607FM_MK5:
912 case SAA7134_BOARD_BEHOLD_609FM_MK3:
913 case SAA7134_BOARD_BEHOLD_609FM_MK5:
914 case SAA7134_BOARD_BEHOLD_607RDS_MK3:
915 case SAA7134_BOARD_BEHOLD_607RDS_MK5:
916 case SAA7134_BOARD_BEHOLD_609RDS_MK3:
917 case SAA7134_BOARD_BEHOLD_609RDS_MK5:
918 case SAA7134_BOARD_BEHOLD_M6:
919 case SAA7134_BOARD_BEHOLD_M63:
920 case SAA7134_BOARD_BEHOLD_M6_EXTRA:
921 case SAA7134_BOARD_BEHOLD_H6:
922 case SAA7134_BOARD_BEHOLD_X7:
923 case SAA7134_BOARD_BEHOLD_H7:
924 case SAA7134_BOARD_BEHOLD_A7:
925 dev->init_data.name = "BeholdTV";
926 dev->init_data.get_key = get_key_beholdm6xx;
927 dev->init_data.ir_codes = RC_MAP_BEHOLD;
928 dev->init_data.type = RC_TYPE_NEC;
929 info.addr = 0x2d;
930 break;
931 case SAA7134_BOARD_AVERMEDIA_CARDBUS_501:
932 case SAA7134_BOARD_AVERMEDIA_CARDBUS_506:
933 info.addr = 0x40;
934 break;
935 case SAA7134_BOARD_FLYDVB_TRIO:
936 dev->init_data.name = "FlyDVB Trio";
937 dev->init_data.get_key = get_key_flydvb_trio;
938 dev->init_data.ir_codes = RC_MAP_FLYDVB;
939 info.addr = 0x0b;
940 break;
941 default:
942 dprintk("No I2C IR support for board %x\n", dev->board);
943 return;
944 }
945
946 if (dev->init_data.name)
947 info.platform_data = &dev->init_data;
948 i2c_new_device(&dev->i2c_adap, &info);
949 }
950
951 static int saa7134_raw_decode_irq(struct saa7134_dev *dev)
952 {
953 struct saa7134_card_ir *ir = dev->remote;
954 unsigned long timeout;
955 int space;
956
957 /* Generate initial event */
958 saa_clearb(SAA7134_GPIO_GPMODE3, SAA7134_GPIO_GPRESCAN);
959 saa_setb(SAA7134_GPIO_GPMODE3, SAA7134_GPIO_GPRESCAN);
960 space = saa_readl(SAA7134_GPIO_GPSTATUS0 >> 2) & ir->mask_keydown;
961 ir_raw_event_store_edge(dev->remote->dev, space ? IR_SPACE : IR_PULSE);
962
963 /*
964 * Wait 15 ms from the start of the first IR event before processing
965 * the event. This time is enough for NEC protocol. May need adjustments
966 * to work with other protocols.
967 */
968 if (!ir->active) {
969 timeout = jiffies + msecs_to_jiffies(15);
970 mod_timer(&ir->timer, timeout);
971 ir->active = true;
972 }
973
974 return 1;
975 }
Linux kernel - Deliverables
This page took 0.068998 seconds and 5 git commands to generate.