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.
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 #include <linux/init.h>
26 #include <linux/hrtimer.h>
27 #include <linux/pci.h>
28 #include <linux/slab.h>
29 #include <linux/module.h>
32 #include <media/rc-core.h>
34 #define MODULE_NAME "cx88xx"
36 /* ---------------------------------------------------------------------- */
39 struct cx88_core
*core
;
47 /* sample from gpio pin 16 */
50 /* poll external decoder */
60 static unsigned ir_samplerate
= 4;
61 module_param(ir_samplerate
, uint
, 0444);
62 MODULE_PARM_DESC(ir_samplerate
, "IR samplerate in kHz, 1 - 20, default 4");
65 module_param(ir_debug
, int, 0644); /* debug level [IR] */
66 MODULE_PARM_DESC(ir_debug
, "enable debug messages [IR]");
68 #define ir_dprintk(fmt, arg...) if (ir_debug) \
69 printk(KERN_DEBUG "%s IR: " fmt , ir->core->name , ##arg)
71 #define dprintk(fmt, arg...) if (ir_debug) \
72 printk(KERN_DEBUG "cx88 IR: " fmt , ##arg)
74 /* ---------------------------------------------------------------------- */
76 static void cx88_ir_handle_key(struct cx88_IR
*ir
)
78 struct cx88_core
*core
= ir
->core
;
79 u32 gpio
, data
, auxgpio
;
82 gpio
= cx_read(ir
->gpio_addr
);
83 switch (core
->boardnr
) {
84 case CX88_BOARD_NPGTECH_REALTV_TOP10FM
:
85 /* This board apparently uses a combination of 2 GPIO
86 to represent the keys. Additionally, the second GPIO
87 can be used for parity.
92 gpio = 0x758, auxgpio = 0xe5 or 0xf5
94 gpio = 0x758, auxgpio = 0xed or 0xfd
97 auxgpio
= cx_read(MO_GP1_IO
);
98 /* Take out the parity part */
99 gpio
=(gpio
& 0x7fd) + (auxgpio
& 0xef);
101 case CX88_BOARD_WINFAST_DTV1000
:
102 case CX88_BOARD_WINFAST_DTV1800H
:
103 case CX88_BOARD_WINFAST_DTV1800H_XC4000
:
104 case CX88_BOARD_WINFAST_DTV2000H_PLUS
:
105 case CX88_BOARD_WINFAST_TV2000_XP_GLOBAL
:
106 case CX88_BOARD_WINFAST_TV2000_XP_GLOBAL_6F36
:
107 case CX88_BOARD_WINFAST_TV2000_XP_GLOBAL_6F43
:
108 gpio
= (gpio
& 0x6ff) | ((cx_read(MO_GP1_IO
) << 8) & 0x900);
115 if (ir
->last_gpio
== auxgpio
)
117 ir
->last_gpio
= auxgpio
;
121 data
= ir_extract_bits(gpio
, ir
->mask_keycode
);
122 ir_dprintk("irq gpio=0x%x code=%d | %s%s%s\n",
124 ir
->polling
? "poll" : "irq",
125 (gpio
& ir
->mask_keydown
) ? " down" : "",
126 (gpio
& ir
->mask_keyup
) ? " up" : "");
128 if (ir
->core
->boardnr
== CX88_BOARD_NORWOOD_MICRO
) {
129 u32 gpio_key
= cx_read(MO_GP0_IO
);
131 data
= (data
<< 4) | ((gpio_key
& 0xf0) >> 4);
133 rc_keydown(ir
->dev
, data
, 0);
135 } else if (ir
->mask_keydown
) {
136 /* bit set on keydown */
137 if (gpio
& ir
->mask_keydown
)
138 rc_keydown_notimeout(ir
->dev
, data
, 0);
142 } else if (ir
->mask_keyup
) {
143 /* bit cleared on keydown */
144 if (0 == (gpio
& ir
->mask_keyup
))
145 rc_keydown_notimeout(ir
->dev
, data
, 0);
150 /* can't distinguish keydown/up :-/ */
151 rc_keydown_notimeout(ir
->dev
, data
, 0);
156 static enum hrtimer_restart
cx88_ir_work(struct hrtimer
*timer
)
158 unsigned long missed
;
159 struct cx88_IR
*ir
= container_of(timer
, struct cx88_IR
, timer
);
161 cx88_ir_handle_key(ir
);
162 missed
= hrtimer_forward_now(&ir
->timer
,
163 ktime_set(0, ir
->polling
* 1000000));
165 ir_dprintk("Missed ticks %ld\n", missed
- 1);
167 return HRTIMER_RESTART
;
170 static int __cx88_ir_start(void *priv
)
172 struct cx88_core
*core
= priv
;
175 if (!core
|| !core
->ir
)
181 hrtimer_init(&ir
->timer
, CLOCK_MONOTONIC
, HRTIMER_MODE_REL
);
182 ir
->timer
.function
= cx88_ir_work
;
183 hrtimer_start(&ir
->timer
,
184 ktime_set(0, ir
->polling
* 1000000),
188 core
->pci_irqmask
|= PCI_INT_IR_SMPINT
;
189 cx_write(MO_DDS_IO
, 0x33F286 * ir_samplerate
); /* samplerate */
190 cx_write(MO_DDSCFG_IO
, 0x5); /* enable */
195 static void __cx88_ir_stop(void *priv
)
197 struct cx88_core
*core
= priv
;
200 if (!core
|| !core
->ir
)
205 cx_write(MO_DDSCFG_IO
, 0x0);
206 core
->pci_irqmask
&= ~PCI_INT_IR_SMPINT
;
210 hrtimer_cancel(&ir
->timer
);
213 int cx88_ir_start(struct cx88_core
*core
)
216 return __cx88_ir_start(core
);
221 void cx88_ir_stop(struct cx88_core
*core
)
224 __cx88_ir_stop(core
);
227 static int cx88_ir_open(struct rc_dev
*rc
)
229 struct cx88_core
*core
= rc
->priv
;
232 return __cx88_ir_start(core
);
235 static void cx88_ir_close(struct rc_dev
*rc
)
237 struct cx88_core
*core
= rc
->priv
;
240 if (!core
->ir
->users
)
241 __cx88_ir_stop(core
);
244 /* ---------------------------------------------------------------------- */
246 int cx88_ir_init(struct cx88_core
*core
, struct pci_dev
*pci
)
250 char *ir_codes
= NULL
;
251 u64 rc_type
= RC_TYPE_OTHER
;
253 u32 hardware_mask
= 0; /* For devices with a hardware mask, when
254 * used with a full-code IR table
257 ir
= kzalloc(sizeof(*ir
), GFP_KERNEL
);
258 dev
= rc_allocate_device();
264 /* detect & configure */
265 switch (core
->boardnr
) {
266 case CX88_BOARD_DNTV_LIVE_DVB_T
:
267 case CX88_BOARD_KWORLD_DVB_T
:
268 case CX88_BOARD_KWORLD_DVB_T_CX22702
:
269 ir_codes
= RC_MAP_DNTV_LIVE_DVB_T
;
270 ir
->gpio_addr
= MO_GP1_IO
;
271 ir
->mask_keycode
= 0x1f;
272 ir
->mask_keyup
= 0x60;
273 ir
->polling
= 50; /* ms */
275 case CX88_BOARD_TERRATEC_CINERGY_1400_DVB_T1
:
276 ir_codes
= RC_MAP_CINERGY_1400
;
277 ir
->sampling
= 0xeb04; /* address */
279 case CX88_BOARD_HAUPPAUGE
:
280 case CX88_BOARD_HAUPPAUGE_DVB_T1
:
281 case CX88_BOARD_HAUPPAUGE_NOVASE2_S1
:
282 case CX88_BOARD_HAUPPAUGE_NOVASPLUS_S1
:
283 case CX88_BOARD_HAUPPAUGE_HVR1100
:
284 case CX88_BOARD_HAUPPAUGE_HVR3000
:
285 case CX88_BOARD_HAUPPAUGE_HVR4000
:
286 case CX88_BOARD_HAUPPAUGE_HVR4000LITE
:
287 case CX88_BOARD_PCHDTV_HD3000
:
288 case CX88_BOARD_PCHDTV_HD5500
:
289 case CX88_BOARD_HAUPPAUGE_IRONLY
:
290 ir_codes
= RC_MAP_HAUPPAUGE
;
293 case CX88_BOARD_WINFAST_DTV2000H
:
294 case CX88_BOARD_WINFAST_DTV2000H_J
:
295 case CX88_BOARD_WINFAST_DTV1800H
:
296 case CX88_BOARD_WINFAST_DTV1800H_XC4000
:
297 case CX88_BOARD_WINFAST_DTV2000H_PLUS
:
298 ir_codes
= RC_MAP_WINFAST
;
299 ir
->gpio_addr
= MO_GP0_IO
;
300 ir
->mask_keycode
= 0x8f8;
301 ir
->mask_keyup
= 0x100;
302 ir
->polling
= 50; /* ms */
304 case CX88_BOARD_WINFAST2000XP_EXPERT
:
305 case CX88_BOARD_WINFAST_DTV1000
:
306 case CX88_BOARD_WINFAST_TV2000_XP_GLOBAL
:
307 case CX88_BOARD_WINFAST_TV2000_XP_GLOBAL_6F36
:
308 case CX88_BOARD_WINFAST_TV2000_XP_GLOBAL_6F43
:
309 ir_codes
= RC_MAP_WINFAST
;
310 ir
->gpio_addr
= MO_GP0_IO
;
311 ir
->mask_keycode
= 0x8f8;
312 ir
->mask_keyup
= 0x100;
313 ir
->polling
= 1; /* ms */
315 case CX88_BOARD_IODATA_GVBCTV7E
:
316 ir_codes
= RC_MAP_IODATA_BCTV7E
;
317 ir
->gpio_addr
= MO_GP0_IO
;
318 ir
->mask_keycode
= 0xfd;
319 ir
->mask_keydown
= 0x02;
320 ir
->polling
= 5; /* ms */
322 case CX88_BOARD_PROLINK_PLAYTVPVR
:
323 case CX88_BOARD_PIXELVIEW_PLAYTV_ULTRA_PRO
:
325 * It seems that this hardware is paired with NEC extended
326 * address 0x866b. So, unfortunately, its usage with other
327 * IR's with different address won't work. Still, there are
328 * other IR's from the same manufacturer that works, like the
329 * 002-T mini RC, provided with newer PV hardware
331 ir_codes
= RC_MAP_PIXELVIEW_MK12
;
332 ir
->gpio_addr
= MO_GP1_IO
;
333 ir
->mask_keyup
= 0x80;
334 ir
->polling
= 10; /* ms */
335 hardware_mask
= 0x3f; /* Hardware returns only 6 bits from command part */
337 case CX88_BOARD_PROLINK_PV_8000GT
:
338 case CX88_BOARD_PROLINK_PV_GLOBAL_XTREME
:
339 ir_codes
= RC_MAP_PIXELVIEW_NEW
;
340 ir
->gpio_addr
= MO_GP1_IO
;
341 ir
->mask_keycode
= 0x3f;
342 ir
->mask_keyup
= 0x80;
343 ir
->polling
= 1; /* ms */
345 case CX88_BOARD_KWORLD_LTV883
:
346 ir_codes
= RC_MAP_PIXELVIEW
;
347 ir
->gpio_addr
= MO_GP1_IO
;
348 ir
->mask_keycode
= 0x1f;
349 ir
->mask_keyup
= 0x60;
350 ir
->polling
= 1; /* ms */
352 case CX88_BOARD_ADSTECH_DVB_T_PCI
:
353 ir_codes
= RC_MAP_ADSTECH_DVB_T_PCI
;
354 ir
->gpio_addr
= MO_GP1_IO
;
355 ir
->mask_keycode
= 0xbf;
356 ir
->mask_keyup
= 0x40;
357 ir
->polling
= 50; /* ms */
359 case CX88_BOARD_MSI_TVANYWHERE_MASTER
:
360 ir_codes
= RC_MAP_MSI_TVANYWHERE
;
361 ir
->gpio_addr
= MO_GP1_IO
;
362 ir
->mask_keycode
= 0x1f;
363 ir
->mask_keyup
= 0x40;
364 ir
->polling
= 1; /* ms */
366 case CX88_BOARD_AVERTV_303
:
367 case CX88_BOARD_AVERTV_STUDIO_303
:
368 ir_codes
= RC_MAP_AVERTV_303
;
369 ir
->gpio_addr
= MO_GP2_IO
;
370 ir
->mask_keycode
= 0xfb;
371 ir
->mask_keydown
= 0x02;
372 ir
->polling
= 50; /* ms */
374 case CX88_BOARD_OMICOM_SS4_PCI
:
375 case CX88_BOARD_SATTRADE_ST4200
:
376 case CX88_BOARD_TBS_8920
:
377 case CX88_BOARD_TBS_8910
:
378 case CX88_BOARD_PROF_7300
:
379 case CX88_BOARD_PROF_7301
:
380 case CX88_BOARD_PROF_6200
:
381 ir_codes
= RC_MAP_TBS_NEC
;
382 ir
->sampling
= 0xff00; /* address */
384 case CX88_BOARD_TEVII_S464
:
385 case CX88_BOARD_TEVII_S460
:
386 case CX88_BOARD_TEVII_S420
:
387 ir_codes
= RC_MAP_TEVII_NEC
;
388 ir
->sampling
= 0xff00; /* address */
390 case CX88_BOARD_DNTV_LIVE_DVB_T_PRO
:
391 ir_codes
= RC_MAP_DNTV_LIVE_DVBT_PRO
;
392 ir
->sampling
= 0xff00; /* address */
394 case CX88_BOARD_NORWOOD_MICRO
:
395 ir_codes
= RC_MAP_NORWOOD
;
396 ir
->gpio_addr
= MO_GP1_IO
;
397 ir
->mask_keycode
= 0x0e;
398 ir
->mask_keyup
= 0x80;
399 ir
->polling
= 50; /* ms */
401 case CX88_BOARD_NPGTECH_REALTV_TOP10FM
:
402 ir_codes
= RC_MAP_NPGTECH
;
403 ir
->gpio_addr
= MO_GP0_IO
;
404 ir
->mask_keycode
= 0xfa;
405 ir
->polling
= 50; /* ms */
407 case CX88_BOARD_PINNACLE_PCTV_HD_800i
:
408 ir_codes
= RC_MAP_PINNACLE_PCTV_HD
;
411 case CX88_BOARD_POWERCOLOR_REAL_ANGEL
:
412 ir_codes
= RC_MAP_POWERCOLOR_REAL_ANGEL
;
413 ir
->gpio_addr
= MO_GP2_IO
;
414 ir
->mask_keycode
= 0x7e;
415 ir
->polling
= 100; /* ms */
417 case CX88_BOARD_TWINHAN_VP1027_DVBS
:
418 ir_codes
= RC_MAP_TWINHAN_VP1027_DVBS
;
419 rc_type
= RC_TYPE_NEC
;
420 ir
->sampling
= 0xff00; /* address */
430 * The usage of mask_keycode were very convenient, due to several
431 * reasons. Among others, the scancode tables were using the scancode
432 * as the index elements. So, the less bits it was used, the smaller
433 * the table were stored. After the input changes, the better is to use
434 * the full scancodes, since it allows replacing the IR remote by
435 * another one. Unfortunately, there are still some hardware, like
436 * Pixelview Ultra Pro, where only part of the scancode is sent via
437 * GPIO. So, there's no way to get the full scancode. Due to that,
438 * hardware_mask were introduced here: it represents those hardware
439 * that has such limits.
441 if (hardware_mask
&& !ir
->mask_keycode
)
442 ir
->mask_keycode
= hardware_mask
;
444 /* init input device */
445 snprintf(ir
->name
, sizeof(ir
->name
), "cx88 IR (%s)", core
->board
.name
);
446 snprintf(ir
->phys
, sizeof(ir
->phys
), "pci-%s/ir0", pci_name(pci
));
448 dev
->input_name
= ir
->name
;
449 dev
->input_phys
= ir
->phys
;
450 dev
->input_id
.bustype
= BUS_PCI
;
451 dev
->input_id
.version
= 1;
452 if (pci
->subsystem_vendor
) {
453 dev
->input_id
.vendor
= pci
->subsystem_vendor
;
454 dev
->input_id
.product
= pci
->subsystem_device
;
456 dev
->input_id
.vendor
= pci
->vendor
;
457 dev
->input_id
.product
= pci
->device
;
459 dev
->dev
.parent
= &pci
->dev
;
460 dev
->map_name
= ir_codes
;
461 dev
->driver_name
= MODULE_NAME
;
463 dev
->open
= cx88_ir_open
;
464 dev
->close
= cx88_ir_close
;
465 dev
->scanmask
= hardware_mask
;
468 dev
->driver_type
= RC_DRIVER_IR_RAW
;
469 dev
->timeout
= 10 * 1000 * 1000; /* 10 ms */
471 dev
->driver_type
= RC_DRIVER_SCANCODE
;
472 dev
->allowed_protos
= rc_type
;
479 err
= rc_register_device(dev
);
492 int cx88_ir_fini(struct cx88_core
*core
)
494 struct cx88_IR
*ir
= core
->ir
;
496 /* skip detach on non attached boards */
501 rc_unregister_device(ir
->dev
);
509 /* ---------------------------------------------------------------------- */
511 void cx88_ir_irq(struct cx88_core
*core
)
513 struct cx88_IR
*ir
= core
->ir
;
516 struct ir_raw_event ev
;
518 if (!ir
|| !ir
->sampling
)
522 * Samples are stored in a 32 bit register, oldest sample in
523 * the msb. A set bit represents space and an unset bit
524 * represents a pulse.
526 samples
= cx_read(MO_SAMPLE_IO
);
528 if (samples
== 0xff && ir
->dev
->idle
)
531 init_ir_raw_event(&ev
);
532 for (todo
= 32; todo
> 0; todo
-= bits
) {
533 ev
.pulse
= samples
& 0x80000000 ? false : true;
534 bits
= min(todo
, 32U - fls(ev
.pulse
? samples
: ~samples
));
535 ev
.duration
= (bits
* (NSEC_PER_SEC
/ 1000)) / ir_samplerate
;
536 ir_raw_event_store_with_filter(ir
->dev
, &ev
);
539 ir_raw_event_handle(ir
->dev
);
542 static int get_key_pvr2000(struct IR_i2c
*ir
, u32
*ir_key
, u32
*ir_raw
)
547 flags
= i2c_smbus_read_byte_data(ir
->c
, 0x10);
549 dprintk("read error\n");
553 if (0 == (flags
& 0x80))
556 /* read actual key code */
557 code
= i2c_smbus_read_byte_data(ir
->c
, 0x00);
559 dprintk("read error\n");
563 dprintk("IR Key/Flags: (0x%02x/0x%02x)\n",
564 code
& 0xff, flags
& 0xff);
566 *ir_key
= code
& 0xff;
571 void cx88_i2c_init_ir(struct cx88_core
*core
)
573 struct i2c_board_info info
;
574 const unsigned short default_addr_list
[] = {
578 const unsigned short pvr2000_addr_list
[] = {
582 const unsigned short *addr_list
= default_addr_list
;
583 const unsigned short *addrp
;
584 /* Instantiate the IR receiver device, if present */
585 if (0 != core
->i2c_rc
)
588 memset(&info
, 0, sizeof(struct i2c_board_info
));
589 strlcpy(info
.type
, "ir_video", I2C_NAME_SIZE
);
591 switch (core
->boardnr
) {
592 case CX88_BOARD_LEADTEK_PVR2000
:
593 addr_list
= pvr2000_addr_list
;
594 core
->init_data
.name
= "cx88 Leadtek PVR 2000 remote";
595 core
->init_data
.type
= RC_TYPE_UNKNOWN
;
596 core
->init_data
.get_key
= get_key_pvr2000
;
597 core
->init_data
.ir_codes
= RC_MAP_EMPTY
;
602 * We can't call i2c_new_probed_device() because it uses
603 * quick writes for probing and at least some RC receiver
604 * devices only reply to reads.
605 * Also, Hauppauge XVR needs to be specified, as address 0x71
606 * conflicts with another remote type used with saa7134
608 for (addrp
= addr_list
; *addrp
!= I2C_CLIENT_END
; addrp
++) {
609 info
.platform_data
= NULL
;
610 memset(&core
->init_data
, 0, sizeof(core
->init_data
));
612 if (*addrp
== 0x71) {
614 core
->init_data
.name
= "cx88 Hauppauge XVR remote";
615 core
->init_data
.ir_codes
= RC_MAP_HAUPPAUGE
;
616 core
->init_data
.type
= RC_TYPE_RC5
;
617 core
->init_data
.internal_get_key_func
= IR_KBD_GET_KEY_HAUP_XVR
;
619 info
.platform_data
= &core
->init_data
;
621 if (i2c_smbus_xfer(&core
->i2c_adap
, *addrp
, 0,
623 I2C_SMBUS_QUICK
, NULL
) >= 0) {
625 i2c_new_device(&core
->i2c_adap
, &info
);
631 /* ---------------------------------------------------------------------- */
633 MODULE_AUTHOR("Gerd Knorr, Pavel Machek, Chris Pascoe");
634 MODULE_DESCRIPTION("input driver for cx88 GPIO-based IR remote controls");
635 MODULE_LICENSE("GPL");