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/ir-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 /* ---------------------------------------------------------------------- */
73 static void cx88_ir_handle_key(struct cx88_IR
*ir
)
75 struct cx88_core
*core
= ir
->core
;
76 u32 gpio
, data
, auxgpio
;
79 gpio
= cx_read(ir
->gpio_addr
);
80 switch (core
->boardnr
) {
81 case CX88_BOARD_NPGTECH_REALTV_TOP10FM
:
82 /* This board apparently uses a combination of 2 GPIO
83 to represent the keys. Additionally, the second GPIO
84 can be used for parity.
89 gpio = 0x758, auxgpio = 0xe5 or 0xf5
91 gpio = 0x758, auxgpio = 0xed or 0xfd
94 auxgpio
= cx_read(MO_GP1_IO
);
95 /* Take out the parity part */
96 gpio
=(gpio
& 0x7fd) + (auxgpio
& 0xef);
98 case CX88_BOARD_WINFAST_DTV1000
:
99 case CX88_BOARD_WINFAST_DTV1800H
:
100 case CX88_BOARD_WINFAST_TV2000_XP_GLOBAL
:
101 gpio
= (gpio
& 0x6ff) | ((cx_read(MO_GP1_IO
) << 8) & 0x900);
108 if (ir
->last_gpio
== auxgpio
)
110 ir
->last_gpio
= auxgpio
;
114 data
= ir_extract_bits(gpio
, ir
->mask_keycode
);
115 ir_dprintk("irq gpio=0x%x code=%d | %s%s%s\n",
117 ir
->polling
? "poll" : "irq",
118 (gpio
& ir
->mask_keydown
) ? " down" : "",
119 (gpio
& ir
->mask_keyup
) ? " up" : "");
121 if (ir
->core
->boardnr
== CX88_BOARD_NORWOOD_MICRO
) {
122 u32 gpio_key
= cx_read(MO_GP0_IO
);
124 data
= (data
<< 4) | ((gpio_key
& 0xf0) >> 4);
126 ir_keydown(ir
->dev
, data
, 0);
128 } else if (ir
->mask_keydown
) {
129 /* bit set on keydown */
130 if (gpio
& ir
->mask_keydown
)
131 ir_keydown_notimeout(ir
->dev
, data
, 0);
135 } else if (ir
->mask_keyup
) {
136 /* bit cleared on keydown */
137 if (0 == (gpio
& ir
->mask_keyup
))
138 ir_keydown_notimeout(ir
->dev
, data
, 0);
143 /* can't distinguish keydown/up :-/ */
144 ir_keydown_notimeout(ir
->dev
, data
, 0);
149 static enum hrtimer_restart
cx88_ir_work(struct hrtimer
*timer
)
151 unsigned long missed
;
152 struct cx88_IR
*ir
= container_of(timer
, struct cx88_IR
, timer
);
154 cx88_ir_handle_key(ir
);
155 missed
= hrtimer_forward_now(&ir
->timer
,
156 ktime_set(0, ir
->polling
* 1000000));
158 ir_dprintk("Missed ticks %ld\n", missed
- 1);
160 return HRTIMER_RESTART
;
163 static int __cx88_ir_start(void *priv
)
165 struct cx88_core
*core
= priv
;
168 if (!core
|| !core
->ir
)
174 hrtimer_init(&ir
->timer
, CLOCK_MONOTONIC
, HRTIMER_MODE_REL
);
175 ir
->timer
.function
= cx88_ir_work
;
176 hrtimer_start(&ir
->timer
,
177 ktime_set(0, ir
->polling
* 1000000),
181 core
->pci_irqmask
|= PCI_INT_IR_SMPINT
;
182 cx_write(MO_DDS_IO
, 0x33F286 * ir_samplerate
); /* samplerate */
183 cx_write(MO_DDSCFG_IO
, 0x5); /* enable */
188 static void __cx88_ir_stop(void *priv
)
190 struct cx88_core
*core
= priv
;
193 if (!core
|| !core
->ir
)
198 cx_write(MO_DDSCFG_IO
, 0x0);
199 core
->pci_irqmask
&= ~PCI_INT_IR_SMPINT
;
203 hrtimer_cancel(&ir
->timer
);
206 int cx88_ir_start(struct cx88_core
*core
)
209 return __cx88_ir_start(core
);
214 void cx88_ir_stop(struct cx88_core
*core
)
217 __cx88_ir_stop(core
);
220 static int cx88_ir_open(struct rc_dev
*rc
)
222 struct cx88_core
*core
= rc
->priv
;
225 return __cx88_ir_start(core
);
228 static void cx88_ir_close(struct rc_dev
*rc
)
230 struct cx88_core
*core
= rc
->priv
;
233 if (!core
->ir
->users
)
234 __cx88_ir_stop(core
);
237 /* ---------------------------------------------------------------------- */
239 int cx88_ir_init(struct cx88_core
*core
, struct pci_dev
*pci
)
243 char *ir_codes
= NULL
;
244 u64 ir_type
= IR_TYPE_OTHER
;
246 u32 hardware_mask
= 0; /* For devices with a hardware mask, when
247 * used with a full-code IR table
250 ir
= kzalloc(sizeof(*ir
), GFP_KERNEL
);
251 dev
= rc_allocate_device();
257 /* detect & configure */
258 switch (core
->boardnr
) {
259 case CX88_BOARD_DNTV_LIVE_DVB_T
:
260 case CX88_BOARD_KWORLD_DVB_T
:
261 case CX88_BOARD_KWORLD_DVB_T_CX22702
:
262 ir_codes
= RC_MAP_DNTV_LIVE_DVB_T
;
263 ir
->gpio_addr
= MO_GP1_IO
;
264 ir
->mask_keycode
= 0x1f;
265 ir
->mask_keyup
= 0x60;
266 ir
->polling
= 50; /* ms */
268 case CX88_BOARD_TERRATEC_CINERGY_1400_DVB_T1
:
269 ir_codes
= RC_MAP_CINERGY_1400
;
270 ir
->sampling
= 0xeb04; /* address */
272 case CX88_BOARD_HAUPPAUGE
:
273 case CX88_BOARD_HAUPPAUGE_DVB_T1
:
274 case CX88_BOARD_HAUPPAUGE_NOVASE2_S1
:
275 case CX88_BOARD_HAUPPAUGE_NOVASPLUS_S1
:
276 case CX88_BOARD_HAUPPAUGE_HVR1100
:
277 case CX88_BOARD_HAUPPAUGE_HVR3000
:
278 case CX88_BOARD_HAUPPAUGE_HVR4000
:
279 case CX88_BOARD_HAUPPAUGE_HVR4000LITE
:
280 case CX88_BOARD_PCHDTV_HD3000
:
281 case CX88_BOARD_PCHDTV_HD5500
:
282 case CX88_BOARD_HAUPPAUGE_IRONLY
:
283 ir_codes
= RC_MAP_HAUPPAUGE_NEW
;
286 case CX88_BOARD_WINFAST_DTV2000H
:
287 case CX88_BOARD_WINFAST_DTV2000H_J
:
288 case CX88_BOARD_WINFAST_DTV1800H
:
289 ir_codes
= RC_MAP_WINFAST
;
290 ir
->gpio_addr
= MO_GP0_IO
;
291 ir
->mask_keycode
= 0x8f8;
292 ir
->mask_keyup
= 0x100;
293 ir
->polling
= 50; /* ms */
295 case CX88_BOARD_WINFAST2000XP_EXPERT
:
296 case CX88_BOARD_WINFAST_DTV1000
:
297 case CX88_BOARD_WINFAST_TV2000_XP_GLOBAL
:
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
= 1; /* ms */
304 case CX88_BOARD_IODATA_GVBCTV7E
:
305 ir_codes
= RC_MAP_IODATA_BCTV7E
;
306 ir
->gpio_addr
= MO_GP0_IO
;
307 ir
->mask_keycode
= 0xfd;
308 ir
->mask_keydown
= 0x02;
309 ir
->polling
= 5; /* ms */
311 case CX88_BOARD_PROLINK_PLAYTVPVR
:
312 case CX88_BOARD_PIXELVIEW_PLAYTV_ULTRA_PRO
:
314 * It seems that this hardware is paired with NEC extended
315 * address 0x866b. So, unfortunately, its usage with other
316 * IR's with different address won't work. Still, there are
317 * other IR's from the same manufacturer that works, like the
318 * 002-T mini RC, provided with newer PV hardware
320 ir_codes
= RC_MAP_PIXELVIEW_MK12
;
321 ir
->gpio_addr
= MO_GP1_IO
;
322 ir
->mask_keyup
= 0x80;
323 ir
->polling
= 10; /* ms */
324 hardware_mask
= 0x3f; /* Hardware returns only 6 bits from command part */
326 case CX88_BOARD_PROLINK_PV_8000GT
:
327 case CX88_BOARD_PROLINK_PV_GLOBAL_XTREME
:
328 ir_codes
= RC_MAP_PIXELVIEW_NEW
;
329 ir
->gpio_addr
= MO_GP1_IO
;
330 ir
->mask_keycode
= 0x3f;
331 ir
->mask_keyup
= 0x80;
332 ir
->polling
= 1; /* ms */
334 case CX88_BOARD_KWORLD_LTV883
:
335 ir_codes
= RC_MAP_PIXELVIEW
;
336 ir
->gpio_addr
= MO_GP1_IO
;
337 ir
->mask_keycode
= 0x1f;
338 ir
->mask_keyup
= 0x60;
339 ir
->polling
= 1; /* ms */
341 case CX88_BOARD_ADSTECH_DVB_T_PCI
:
342 ir_codes
= RC_MAP_ADSTECH_DVB_T_PCI
;
343 ir
->gpio_addr
= MO_GP1_IO
;
344 ir
->mask_keycode
= 0xbf;
345 ir
->mask_keyup
= 0x40;
346 ir
->polling
= 50; /* ms */
348 case CX88_BOARD_MSI_TVANYWHERE_MASTER
:
349 ir_codes
= RC_MAP_MSI_TVANYWHERE
;
350 ir
->gpio_addr
= MO_GP1_IO
;
351 ir
->mask_keycode
= 0x1f;
352 ir
->mask_keyup
= 0x40;
353 ir
->polling
= 1; /* ms */
355 case CX88_BOARD_AVERTV_303
:
356 case CX88_BOARD_AVERTV_STUDIO_303
:
357 ir_codes
= RC_MAP_AVERTV_303
;
358 ir
->gpio_addr
= MO_GP2_IO
;
359 ir
->mask_keycode
= 0xfb;
360 ir
->mask_keydown
= 0x02;
361 ir
->polling
= 50; /* ms */
363 case CX88_BOARD_OMICOM_SS4_PCI
:
364 case CX88_BOARD_SATTRADE_ST4200
:
365 case CX88_BOARD_TBS_8920
:
366 case CX88_BOARD_TBS_8910
:
367 case CX88_BOARD_PROF_7300
:
368 case CX88_BOARD_PROF_7301
:
369 case CX88_BOARD_PROF_6200
:
370 ir_codes
= RC_MAP_TBS_NEC
;
371 ir
->sampling
= 0xff00; /* address */
373 case CX88_BOARD_TEVII_S460
:
374 case CX88_BOARD_TEVII_S420
:
375 ir_codes
= RC_MAP_TEVII_NEC
;
376 ir
->sampling
= 0xff00; /* address */
378 case CX88_BOARD_DNTV_LIVE_DVB_T_PRO
:
379 ir_codes
= RC_MAP_DNTV_LIVE_DVBT_PRO
;
380 ir
->sampling
= 0xff00; /* address */
382 case CX88_BOARD_NORWOOD_MICRO
:
383 ir_codes
= RC_MAP_NORWOOD
;
384 ir
->gpio_addr
= MO_GP1_IO
;
385 ir
->mask_keycode
= 0x0e;
386 ir
->mask_keyup
= 0x80;
387 ir
->polling
= 50; /* ms */
389 case CX88_BOARD_NPGTECH_REALTV_TOP10FM
:
390 ir_codes
= RC_MAP_NPGTECH
;
391 ir
->gpio_addr
= MO_GP0_IO
;
392 ir
->mask_keycode
= 0xfa;
393 ir
->polling
= 50; /* ms */
395 case CX88_BOARD_PINNACLE_PCTV_HD_800i
:
396 ir_codes
= RC_MAP_PINNACLE_PCTV_HD
;
399 case CX88_BOARD_POWERCOLOR_REAL_ANGEL
:
400 ir_codes
= RC_MAP_POWERCOLOR_REAL_ANGEL
;
401 ir
->gpio_addr
= MO_GP2_IO
;
402 ir
->mask_keycode
= 0x7e;
403 ir
->polling
= 100; /* ms */
405 case CX88_BOARD_TWINHAN_VP1027_DVBS
:
406 ir_codes
= RC_MAP_TWINHAN_VP1027_DVBS
;
407 ir_type
= IR_TYPE_NEC
;
408 ir
->sampling
= 0xff00; /* address */
418 * The usage of mask_keycode were very convenient, due to several
419 * reasons. Among others, the scancode tables were using the scancode
420 * as the index elements. So, the less bits it was used, the smaller
421 * the table were stored. After the input changes, the better is to use
422 * the full scancodes, since it allows replacing the IR remote by
423 * another one. Unfortunately, there are still some hardware, like
424 * Pixelview Ultra Pro, where only part of the scancode is sent via
425 * GPIO. So, there's no way to get the full scancode. Due to that,
426 * hardware_mask were introduced here: it represents those hardware
427 * that has such limits.
429 if (hardware_mask
&& !ir
->mask_keycode
)
430 ir
->mask_keycode
= hardware_mask
;
432 /* init input device */
433 snprintf(ir
->name
, sizeof(ir
->name
), "cx88 IR (%s)", core
->board
.name
);
434 snprintf(ir
->phys
, sizeof(ir
->phys
), "pci-%s/ir0", pci_name(pci
));
436 dev
->input_name
= ir
->name
;
437 dev
->input_phys
= ir
->phys
;
438 dev
->input_id
.bustype
= BUS_PCI
;
439 dev
->input_id
.version
= 1;
440 if (pci
->subsystem_vendor
) {
441 dev
->input_id
.vendor
= pci
->subsystem_vendor
;
442 dev
->input_id
.product
= pci
->subsystem_device
;
444 dev
->input_id
.vendor
= pci
->vendor
;
445 dev
->input_id
.product
= pci
->device
;
447 dev
->dev
.parent
= &pci
->dev
;
448 dev
->map_name
= ir_codes
;
449 dev
->driver_name
= MODULE_NAME
;
451 dev
->open
= cx88_ir_open
;
452 dev
->close
= cx88_ir_close
;
453 dev
->scanmask
= hardware_mask
;
456 dev
->driver_type
= RC_DRIVER_IR_RAW
;
457 dev
->timeout
= 10 * 1000 * 1000; /* 10 ms */
459 dev
->driver_type
= RC_DRIVER_SCANCODE
;
460 dev
->allowed_protos
= ir_type
;
467 err
= rc_register_device(dev
);
480 int cx88_ir_fini(struct cx88_core
*core
)
482 struct cx88_IR
*ir
= core
->ir
;
484 /* skip detach on non attached boards */
489 rc_unregister_device(ir
->dev
);
497 /* ---------------------------------------------------------------------- */
499 void cx88_ir_irq(struct cx88_core
*core
)
501 struct cx88_IR
*ir
= core
->ir
;
504 struct ir_raw_event ev
;
506 if (!ir
|| !ir
->sampling
)
510 * Samples are stored in a 32 bit register, oldest sample in
511 * the msb. A set bit represents space and an unset bit
512 * represents a pulse.
514 samples
= cx_read(MO_SAMPLE_IO
);
516 if (samples
== 0xff && ir
->dev
->idle
)
519 init_ir_raw_event(&ev
);
520 for (todo
= 32; todo
> 0; todo
-= bits
) {
521 ev
.pulse
= samples
& 0x80000000 ? false : true;
522 bits
= min(todo
, 32U - fls(ev
.pulse
? samples
: ~samples
));
523 ev
.duration
= (bits
* NSEC_PER_SEC
) / (1000 * ir_samplerate
);
524 ir_raw_event_store_with_filter(ir
->dev
, &ev
);
527 ir_raw_event_handle(ir
->dev
);
530 void cx88_i2c_init_ir(struct cx88_core
*core
)
532 struct i2c_board_info info
;
533 const unsigned short addr_list
[] = {
537 const unsigned short *addrp
;
538 /* Instantiate the IR receiver device, if present */
539 if (0 != core
->i2c_rc
)
542 memset(&info
, 0, sizeof(struct i2c_board_info
));
543 strlcpy(info
.type
, "ir_video", I2C_NAME_SIZE
);
546 * We can't call i2c_new_probed_device() because it uses
547 * quick writes for probing and at least some RC receiver
548 * devices only reply to reads.
549 * Also, Hauppauge XVR needs to be specified, as address 0x71
550 * conflicts with another remote type used with saa7134
552 for (addrp
= addr_list
; *addrp
!= I2C_CLIENT_END
; addrp
++) {
553 info
.platform_data
= NULL
;
554 memset(&core
->init_data
, 0, sizeof(core
->init_data
));
556 if (*addrp
== 0x71) {
558 core
->init_data
.name
= "cx88 Hauppauge XVR remote";
559 core
->init_data
.ir_codes
= RC_MAP_HAUPPAUGE_NEW
;
560 core
->init_data
.type
= IR_TYPE_RC5
;
561 core
->init_data
.internal_get_key_func
= IR_KBD_GET_KEY_HAUP_XVR
;
563 info
.platform_data
= &core
->init_data
;
565 if (i2c_smbus_xfer(&core
->i2c_adap
, *addrp
, 0,
567 I2C_SMBUS_QUICK
, NULL
) >= 0) {
569 i2c_new_device(&core
->i2c_adap
, &info
);
575 /* ---------------------------------------------------------------------- */
577 MODULE_AUTHOR("Gerd Knorr, Pavel Machek, Chris Pascoe");
578 MODULE_DESCRIPTION("input driver for cx88 GPIO-based IR remote controls");
579 MODULE_LICENSE("GPL");