3 * Device driver for GPIO attached remote control interfaces
4 * on Conexant 2388x based TV/DVB cards.
6 * Copyright (c) 2003 Pavel Machek
7 * Copyright (c) 2004 Gerd Knorr
8 * Copyright (c) 2004, 2005 Chris Pascoe
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
23 #include <linux/init.h>
24 #include <linux/hrtimer.h>
25 #include <linux/pci.h>
26 #include <linux/slab.h>
27 #include <linux/module.h>
29 #include <media/rc-core.h>
31 #define MODULE_NAME "cx88xx"
33 /* ---------------------------------------------------------------------- */
36 struct cx88_core
*core
;
44 /* sample from gpio pin 16 */
47 /* poll external decoder */
57 static unsigned int ir_samplerate
= 4;
58 module_param(ir_samplerate
, uint
, 0444);
59 MODULE_PARM_DESC(ir_samplerate
, "IR samplerate in kHz, 1 - 20, default 4");
62 module_param(ir_debug
, int, 0644); /* debug level [IR] */
63 MODULE_PARM_DESC(ir_debug
, "enable debug messages [IR]");
65 #define ir_dprintk(fmt, arg...) do { \
67 printk(KERN_DEBUG "%s IR: " fmt, ir->core->name, ##arg);\
70 #define dprintk(fmt, arg...) do { \
72 printk(KERN_DEBUG "cx88 IR: " fmt, ##arg); \
75 /* ---------------------------------------------------------------------- */
77 static void cx88_ir_handle_key(struct cx88_IR
*ir
)
79 struct cx88_core
*core
= ir
->core
;
80 u32 gpio
, data
, auxgpio
;
83 gpio
= cx_read(ir
->gpio_addr
);
84 switch (core
->boardnr
) {
85 case CX88_BOARD_NPGTECH_REALTV_TOP10FM
:
87 * This board apparently uses a combination of 2 GPIO
88 * to represent the keys. Additionally, the second GPIO
89 * can be used for parity.
94 * gpio = 0x758, auxgpio = 0xe5 or 0xf5
96 * gpio = 0x758, auxgpio = 0xed or 0xfd
99 auxgpio
= cx_read(MO_GP1_IO
);
100 /* Take out the parity part */
101 gpio
= (gpio
& 0x7fd) + (auxgpio
& 0xef);
103 case CX88_BOARD_WINFAST_DTV1000
:
104 case CX88_BOARD_WINFAST_DTV1800H
:
105 case CX88_BOARD_WINFAST_DTV1800H_XC4000
:
106 case CX88_BOARD_WINFAST_DTV2000H_PLUS
:
107 case CX88_BOARD_WINFAST_TV2000_XP_GLOBAL
:
108 case CX88_BOARD_WINFAST_TV2000_XP_GLOBAL_6F36
:
109 case CX88_BOARD_WINFAST_TV2000_XP_GLOBAL_6F43
:
110 gpio
= (gpio
& 0x6ff) | ((cx_read(MO_GP1_IO
) << 8) & 0x900);
117 if (ir
->last_gpio
== auxgpio
)
119 ir
->last_gpio
= auxgpio
;
123 data
= ir_extract_bits(gpio
, ir
->mask_keycode
);
124 ir_dprintk("irq gpio=0x%x code=%d | %s%s%s\n",
126 ir
->polling
? "poll" : "irq",
127 (gpio
& ir
->mask_keydown
) ? " down" : "",
128 (gpio
& ir
->mask_keyup
) ? " up" : "");
130 if (ir
->core
->boardnr
== CX88_BOARD_NORWOOD_MICRO
) {
131 u32 gpio_key
= cx_read(MO_GP0_IO
);
133 data
= (data
<< 4) | ((gpio_key
& 0xf0) >> 4);
135 rc_keydown(ir
->dev
, RC_TYPE_UNKNOWN
, data
, 0);
137 } else if (ir
->core
->boardnr
== CX88_BOARD_PROLINK_PLAYTVPVR
||
138 ir
->core
->boardnr
== CX88_BOARD_PIXELVIEW_PLAYTV_ULTRA_PRO
) {
139 /* bit cleared on keydown, NEC scancode, 0xAAAACC, A = 0x866b */
144 addr
= (data
>> 8) & 0xffff;
145 cmd
= (data
>> 0) & 0x00ff;
146 scancode
= RC_SCANCODE_NECX(addr
, cmd
);
148 if (0 == (gpio
& ir
->mask_keyup
))
149 rc_keydown_notimeout(ir
->dev
, RC_TYPE_NECX
, scancode
,
154 } else if (ir
->mask_keydown
) {
155 /* bit set on keydown */
156 if (gpio
& ir
->mask_keydown
)
157 rc_keydown_notimeout(ir
->dev
, RC_TYPE_UNKNOWN
, data
, 0);
161 } else if (ir
->mask_keyup
) {
162 /* bit cleared on keydown */
163 if (0 == (gpio
& ir
->mask_keyup
))
164 rc_keydown_notimeout(ir
->dev
, RC_TYPE_UNKNOWN
, data
, 0);
169 /* can't distinguish keydown/up :-/ */
170 rc_keydown_notimeout(ir
->dev
, RC_TYPE_UNKNOWN
, data
, 0);
175 static enum hrtimer_restart
cx88_ir_work(struct hrtimer
*timer
)
177 unsigned long missed
;
178 struct cx88_IR
*ir
= container_of(timer
, struct cx88_IR
, timer
);
180 cx88_ir_handle_key(ir
);
181 missed
= hrtimer_forward_now(&ir
->timer
,
182 ktime_set(0, ir
->polling
* 1000000));
184 ir_dprintk("Missed ticks %ld\n", missed
- 1);
186 return HRTIMER_RESTART
;
189 static int __cx88_ir_start(void *priv
)
191 struct cx88_core
*core
= priv
;
194 if (!core
|| !core
->ir
)
200 hrtimer_init(&ir
->timer
, CLOCK_MONOTONIC
, HRTIMER_MODE_REL
);
201 ir
->timer
.function
= cx88_ir_work
;
202 hrtimer_start(&ir
->timer
,
203 ktime_set(0, ir
->polling
* 1000000),
207 core
->pci_irqmask
|= PCI_INT_IR_SMPINT
;
208 cx_write(MO_DDS_IO
, 0x33F286 * ir_samplerate
); /* samplerate */
209 cx_write(MO_DDSCFG_IO
, 0x5); /* enable */
214 static void __cx88_ir_stop(void *priv
)
216 struct cx88_core
*core
= priv
;
219 if (!core
|| !core
->ir
)
224 cx_write(MO_DDSCFG_IO
, 0x0);
225 core
->pci_irqmask
&= ~PCI_INT_IR_SMPINT
;
229 hrtimer_cancel(&ir
->timer
);
232 int cx88_ir_start(struct cx88_core
*core
)
235 return __cx88_ir_start(core
);
239 EXPORT_SYMBOL(cx88_ir_start
);
241 void cx88_ir_stop(struct cx88_core
*core
)
244 __cx88_ir_stop(core
);
246 EXPORT_SYMBOL(cx88_ir_stop
);
248 static int cx88_ir_open(struct rc_dev
*rc
)
250 struct cx88_core
*core
= rc
->priv
;
253 return __cx88_ir_start(core
);
256 static void cx88_ir_close(struct rc_dev
*rc
)
258 struct cx88_core
*core
= rc
->priv
;
261 if (!core
->ir
->users
)
262 __cx88_ir_stop(core
);
265 /* ---------------------------------------------------------------------- */
267 int cx88_ir_init(struct cx88_core
*core
, struct pci_dev
*pci
)
271 char *ir_codes
= NULL
;
272 u64 rc_type
= RC_BIT_OTHER
;
274 u32 hardware_mask
= 0; /* For devices with a hardware mask, when
275 * used with a full-code IR table
278 ir
= kzalloc(sizeof(*ir
), GFP_KERNEL
);
279 dev
= rc_allocate_device();
285 /* detect & configure */
286 switch (core
->boardnr
) {
287 case CX88_BOARD_DNTV_LIVE_DVB_T
:
288 case CX88_BOARD_KWORLD_DVB_T
:
289 case CX88_BOARD_KWORLD_DVB_T_CX22702
:
290 ir_codes
= RC_MAP_DNTV_LIVE_DVB_T
;
291 ir
->gpio_addr
= MO_GP1_IO
;
292 ir
->mask_keycode
= 0x1f;
293 ir
->mask_keyup
= 0x60;
294 ir
->polling
= 50; /* ms */
296 case CX88_BOARD_TERRATEC_CINERGY_1400_DVB_T1
:
297 ir_codes
= RC_MAP_CINERGY_1400
;
298 ir
->sampling
= 0xeb04; /* address */
300 case CX88_BOARD_HAUPPAUGE
:
301 case CX88_BOARD_HAUPPAUGE_DVB_T1
:
302 case CX88_BOARD_HAUPPAUGE_NOVASE2_S1
:
303 case CX88_BOARD_HAUPPAUGE_NOVASPLUS_S1
:
304 case CX88_BOARD_HAUPPAUGE_HVR1100
:
305 case CX88_BOARD_HAUPPAUGE_HVR3000
:
306 case CX88_BOARD_HAUPPAUGE_HVR4000
:
307 case CX88_BOARD_HAUPPAUGE_HVR4000LITE
:
308 case CX88_BOARD_PCHDTV_HD3000
:
309 case CX88_BOARD_PCHDTV_HD5500
:
310 case CX88_BOARD_HAUPPAUGE_IRONLY
:
311 ir_codes
= RC_MAP_HAUPPAUGE
;
314 case CX88_BOARD_WINFAST_DTV2000H
:
315 case CX88_BOARD_WINFAST_DTV2000H_J
:
316 case CX88_BOARD_WINFAST_DTV1800H
:
317 case CX88_BOARD_WINFAST_DTV1800H_XC4000
:
318 case CX88_BOARD_WINFAST_DTV2000H_PLUS
:
319 ir_codes
= RC_MAP_WINFAST
;
320 ir
->gpio_addr
= MO_GP0_IO
;
321 ir
->mask_keycode
= 0x8f8;
322 ir
->mask_keyup
= 0x100;
323 ir
->polling
= 50; /* ms */
325 case CX88_BOARD_WINFAST2000XP_EXPERT
:
326 case CX88_BOARD_WINFAST_DTV1000
:
327 case CX88_BOARD_WINFAST_TV2000_XP_GLOBAL
:
328 case CX88_BOARD_WINFAST_TV2000_XP_GLOBAL_6F36
:
329 case CX88_BOARD_WINFAST_TV2000_XP_GLOBAL_6F43
:
330 ir_codes
= RC_MAP_WINFAST
;
331 ir
->gpio_addr
= MO_GP0_IO
;
332 ir
->mask_keycode
= 0x8f8;
333 ir
->mask_keyup
= 0x100;
334 ir
->polling
= 1; /* ms */
336 case CX88_BOARD_IODATA_GVBCTV7E
:
337 ir_codes
= RC_MAP_IODATA_BCTV7E
;
338 ir
->gpio_addr
= MO_GP0_IO
;
339 ir
->mask_keycode
= 0xfd;
340 ir
->mask_keydown
= 0x02;
341 ir
->polling
= 5; /* ms */
343 case CX88_BOARD_PROLINK_PLAYTVPVR
:
344 case CX88_BOARD_PIXELVIEW_PLAYTV_ULTRA_PRO
:
346 * It seems that this hardware is paired with NEC extended
347 * address 0x866b. So, unfortunately, its usage with other
348 * IR's with different address won't work. Still, there are
349 * other IR's from the same manufacturer that works, like the
350 * 002-T mini RC, provided with newer PV hardware
352 ir_codes
= RC_MAP_PIXELVIEW_MK12
;
353 rc_type
= RC_BIT_NECX
;
354 ir
->gpio_addr
= MO_GP1_IO
;
355 ir
->mask_keyup
= 0x80;
356 ir
->polling
= 10; /* ms */
357 hardware_mask
= 0x3f; /* Hardware returns only 6 bits from command part */
359 case CX88_BOARD_PROLINK_PV_8000GT
:
360 case CX88_BOARD_PROLINK_PV_GLOBAL_XTREME
:
361 ir_codes
= RC_MAP_PIXELVIEW_NEW
;
362 ir
->gpio_addr
= MO_GP1_IO
;
363 ir
->mask_keycode
= 0x3f;
364 ir
->mask_keyup
= 0x80;
365 ir
->polling
= 1; /* ms */
367 case CX88_BOARD_KWORLD_LTV883
:
368 ir_codes
= RC_MAP_PIXELVIEW
;
369 ir
->gpio_addr
= MO_GP1_IO
;
370 ir
->mask_keycode
= 0x1f;
371 ir
->mask_keyup
= 0x60;
372 ir
->polling
= 1; /* ms */
374 case CX88_BOARD_ADSTECH_DVB_T_PCI
:
375 ir_codes
= RC_MAP_ADSTECH_DVB_T_PCI
;
376 ir
->gpio_addr
= MO_GP1_IO
;
377 ir
->mask_keycode
= 0xbf;
378 ir
->mask_keyup
= 0x40;
379 ir
->polling
= 50; /* ms */
381 case CX88_BOARD_MSI_TVANYWHERE_MASTER
:
382 ir_codes
= RC_MAP_MSI_TVANYWHERE
;
383 ir
->gpio_addr
= MO_GP1_IO
;
384 ir
->mask_keycode
= 0x1f;
385 ir
->mask_keyup
= 0x40;
386 ir
->polling
= 1; /* ms */
388 case CX88_BOARD_AVERTV_303
:
389 case CX88_BOARD_AVERTV_STUDIO_303
:
390 ir_codes
= RC_MAP_AVERTV_303
;
391 ir
->gpio_addr
= MO_GP2_IO
;
392 ir
->mask_keycode
= 0xfb;
393 ir
->mask_keydown
= 0x02;
394 ir
->polling
= 50; /* ms */
396 case CX88_BOARD_OMICOM_SS4_PCI
:
397 case CX88_BOARD_SATTRADE_ST4200
:
398 case CX88_BOARD_TBS_8920
:
399 case CX88_BOARD_TBS_8910
:
400 case CX88_BOARD_PROF_7300
:
401 case CX88_BOARD_PROF_7301
:
402 case CX88_BOARD_PROF_6200
:
403 ir_codes
= RC_MAP_TBS_NEC
;
404 ir
->sampling
= 0xff00; /* address */
406 case CX88_BOARD_TEVII_S464
:
407 case CX88_BOARD_TEVII_S460
:
408 case CX88_BOARD_TEVII_S420
:
409 ir_codes
= RC_MAP_TEVII_NEC
;
410 ir
->sampling
= 0xff00; /* address */
412 case CX88_BOARD_DNTV_LIVE_DVB_T_PRO
:
413 ir_codes
= RC_MAP_DNTV_LIVE_DVBT_PRO
;
414 ir
->sampling
= 0xff00; /* address */
416 case CX88_BOARD_NORWOOD_MICRO
:
417 ir_codes
= RC_MAP_NORWOOD
;
418 ir
->gpio_addr
= MO_GP1_IO
;
419 ir
->mask_keycode
= 0x0e;
420 ir
->mask_keyup
= 0x80;
421 ir
->polling
= 50; /* ms */
423 case CX88_BOARD_NPGTECH_REALTV_TOP10FM
:
424 ir_codes
= RC_MAP_NPGTECH
;
425 ir
->gpio_addr
= MO_GP0_IO
;
426 ir
->mask_keycode
= 0xfa;
427 ir
->polling
= 50; /* ms */
429 case CX88_BOARD_PINNACLE_PCTV_HD_800i
:
430 ir_codes
= RC_MAP_PINNACLE_PCTV_HD
;
433 case CX88_BOARD_POWERCOLOR_REAL_ANGEL
:
434 ir_codes
= RC_MAP_POWERCOLOR_REAL_ANGEL
;
435 ir
->gpio_addr
= MO_GP2_IO
;
436 ir
->mask_keycode
= 0x7e;
437 ir
->polling
= 100; /* ms */
439 case CX88_BOARD_TWINHAN_VP1027_DVBS
:
440 ir_codes
= RC_MAP_TWINHAN_VP1027_DVBS
;
441 ir
->sampling
= 0xff00; /* address */
451 * The usage of mask_keycode were very convenient, due to several
452 * reasons. Among others, the scancode tables were using the scancode
453 * as the index elements. So, the less bits it was used, the smaller
454 * the table were stored. After the input changes, the better is to use
455 * the full scancodes, since it allows replacing the IR remote by
456 * another one. Unfortunately, there are still some hardware, like
457 * Pixelview Ultra Pro, where only part of the scancode is sent via
458 * GPIO. So, there's no way to get the full scancode. Due to that,
459 * hardware_mask were introduced here: it represents those hardware
460 * that has such limits.
462 if (hardware_mask
&& !ir
->mask_keycode
)
463 ir
->mask_keycode
= hardware_mask
;
465 /* init input device */
466 snprintf(ir
->name
, sizeof(ir
->name
), "cx88 IR (%s)", core
->board
.name
);
467 snprintf(ir
->phys
, sizeof(ir
->phys
), "pci-%s/ir0", pci_name(pci
));
469 dev
->input_name
= ir
->name
;
470 dev
->input_phys
= ir
->phys
;
471 dev
->input_id
.bustype
= BUS_PCI
;
472 dev
->input_id
.version
= 1;
473 if (pci
->subsystem_vendor
) {
474 dev
->input_id
.vendor
= pci
->subsystem_vendor
;
475 dev
->input_id
.product
= pci
->subsystem_device
;
477 dev
->input_id
.vendor
= pci
->vendor
;
478 dev
->input_id
.product
= pci
->device
;
480 dev
->dev
.parent
= &pci
->dev
;
481 dev
->map_name
= ir_codes
;
482 dev
->driver_name
= MODULE_NAME
;
484 dev
->open
= cx88_ir_open
;
485 dev
->close
= cx88_ir_close
;
486 dev
->scancode_mask
= hardware_mask
;
489 dev
->driver_type
= RC_DRIVER_IR_RAW
;
490 dev
->timeout
= 10 * 1000 * 1000; /* 10 ms */
492 dev
->driver_type
= RC_DRIVER_SCANCODE
;
493 dev
->allowed_protocols
= rc_type
;
500 err
= rc_register_device(dev
);
513 int cx88_ir_fini(struct cx88_core
*core
)
515 struct cx88_IR
*ir
= core
->ir
;
517 /* skip detach on non attached boards */
522 rc_unregister_device(ir
->dev
);
530 /* ---------------------------------------------------------------------- */
532 void cx88_ir_irq(struct cx88_core
*core
)
534 struct cx88_IR
*ir
= core
->ir
;
536 unsigned int todo
, bits
;
537 struct ir_raw_event ev
;
539 if (!ir
|| !ir
->sampling
)
543 * Samples are stored in a 32 bit register, oldest sample in
544 * the msb. A set bit represents space and an unset bit
545 * represents a pulse.
547 samples
= cx_read(MO_SAMPLE_IO
);
549 if (samples
== 0xff && ir
->dev
->idle
)
552 init_ir_raw_event(&ev
);
553 for (todo
= 32; todo
> 0; todo
-= bits
) {
554 ev
.pulse
= samples
& 0x80000000 ? false : true;
555 bits
= min(todo
, 32U - fls(ev
.pulse
? samples
: ~samples
));
556 ev
.duration
= (bits
* (NSEC_PER_SEC
/ 1000)) / ir_samplerate
;
557 ir_raw_event_store_with_filter(ir
->dev
, &ev
);
560 ir_raw_event_handle(ir
->dev
);
563 static int get_key_pvr2000(struct IR_i2c
*ir
, enum rc_type
*protocol
,
564 u32
*scancode
, u8
*toggle
)
569 flags
= i2c_smbus_read_byte_data(ir
->c
, 0x10);
571 dprintk("read error\n");
575 if (0 == (flags
& 0x80))
578 /* read actual key code */
579 code
= i2c_smbus_read_byte_data(ir
->c
, 0x00);
581 dprintk("read error\n");
585 dprintk("IR Key/Flags: (0x%02x/0x%02x)\n",
586 code
& 0xff, flags
& 0xff);
588 *protocol
= RC_TYPE_UNKNOWN
;
589 *scancode
= code
& 0xff;
594 void cx88_i2c_init_ir(struct cx88_core
*core
)
596 struct i2c_board_info info
;
597 const unsigned short default_addr_list
[] = {
601 const unsigned short pvr2000_addr_list
[] = {
605 const unsigned short *addr_list
= default_addr_list
;
606 const unsigned short *addrp
;
607 /* Instantiate the IR receiver device, if present */
608 if (core
->i2c_rc
!= 0)
611 memset(&info
, 0, sizeof(struct i2c_board_info
));
612 strlcpy(info
.type
, "ir_video", I2C_NAME_SIZE
);
614 switch (core
->boardnr
) {
615 case CX88_BOARD_LEADTEK_PVR2000
:
616 addr_list
= pvr2000_addr_list
;
617 core
->init_data
.name
= "cx88 Leadtek PVR 2000 remote";
618 core
->init_data
.type
= RC_BIT_UNKNOWN
;
619 core
->init_data
.get_key
= get_key_pvr2000
;
620 core
->init_data
.ir_codes
= RC_MAP_EMPTY
;
625 * We can't call i2c_new_probed_device() because it uses
626 * quick writes for probing and at least some RC receiver
627 * devices only reply to reads.
628 * Also, Hauppauge XVR needs to be specified, as address 0x71
629 * conflicts with another remote type used with saa7134
631 for (addrp
= addr_list
; *addrp
!= I2C_CLIENT_END
; addrp
++) {
632 info
.platform_data
= NULL
;
633 memset(&core
->init_data
, 0, sizeof(core
->init_data
));
635 if (*addrp
== 0x71) {
637 core
->init_data
.name
= "cx88 Hauppauge XVR remote";
638 core
->init_data
.ir_codes
= RC_MAP_HAUPPAUGE
;
639 core
->init_data
.type
= RC_BIT_RC5
| RC_BIT_RC6_MCE
|
641 core
->init_data
.internal_get_key_func
= IR_KBD_GET_KEY_HAUP_XVR
;
643 info
.platform_data
= &core
->init_data
;
645 if (i2c_smbus_xfer(&core
->i2c_adap
, *addrp
, 0,
647 I2C_SMBUS_QUICK
, NULL
) >= 0) {
649 i2c_new_device(&core
->i2c_adap
, &info
);
655 /* ---------------------------------------------------------------------- */
657 MODULE_AUTHOR("Gerd Knorr, Pavel Machek, Chris Pascoe");
658 MODULE_DESCRIPTION("input driver for cx88 GPIO-based IR remote controls");
659 MODULE_LICENSE("GPL");