1/* 2 * 3 * Device driver for GPIO attached remote control interfaces 4 * on Conexant 2388x based TV/DVB cards. 5 * 6 * Copyright (c) 2003 Pavel Machek 7 * Copyright (c) 2004 Gerd Knorr 8 * Copyright (c) 2004, 2005 Chris Pascoe 9 * 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. 14 * 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. 19 * 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 23 */ 24 25#include <linux/init.h> 26#include <linux/hrtimer.h> 27#include <linux/input.h> 28#include <linux/pci.h> 29#include <linux/slab.h> 30#include <linux/module.h> 31 32#include "cx88.h" 33#include <media/ir-core.h> 34#include <media/ir-common.h> 35 36#define MODULE_NAME "cx88xx" 37 38/* ---------------------------------------------------------------------- */ 39 40struct cx88_IR { 41 struct cx88_core *core; 42 struct input_dev *input; 43 struct ir_dev_props props; 44 u64 ir_type; 45 46 int users; 47 48 char name[32]; 49 char phys[32]; 50 51 /* sample from gpio pin 16 */ 52 u32 sampling; 53 u32 samples[16]; 54 int scount; 55 56 /* poll external decoder */ 57 int polling; 58 struct hrtimer timer; 59 u32 gpio_addr; 60 u32 last_gpio; 61 u32 mask_keycode; 62 u32 mask_keydown; 63 u32 mask_keyup; 64}; 65 66static int ir_debug; 67module_param(ir_debug, int, 0644); /* debug level [IR] */ 68MODULE_PARM_DESC(ir_debug, "enable debug messages [IR]"); 69 70#define ir_dprintk(fmt, arg...) if (ir_debug) \ 71 printk(KERN_DEBUG "%s IR: " fmt , ir->core->name , ##arg) 72 73/* ---------------------------------------------------------------------- */ 74 75static void cx88_ir_handle_key(struct cx88_IR *ir) 76{ 77 struct cx88_core *core = ir->core; 78 u32 gpio, data, auxgpio; 79 80 /* read gpio value */ 81 gpio = cx_read(ir->gpio_addr); 82 switch (core->boardnr) { 83 case CX88_BOARD_NPGTECH_REALTV_TOP10FM: 84 /* This board apparently uses a combination of 2 GPIO 85 to represent the keys. Additionally, the second GPIO 86 can be used for parity. 87 88 Example: 89 90 for key "5" 91 gpio = 0x758, auxgpio = 0xe5 or 0xf5 92 for key "Power" 93 gpio = 0x758, auxgpio = 0xed or 0xfd 94 */ 95 96 auxgpio = cx_read(MO_GP1_IO); 97 /* Take out the parity part */ 98 gpio=(gpio & 0x7fd) + (auxgpio & 0xef); 99 break; 100 case CX88_BOARD_WINFAST_DTV1000: 101 case CX88_BOARD_WINFAST_DTV1800H: 102 case CX88_BOARD_WINFAST_TV2000_XP_GLOBAL: 103 gpio = (gpio & 0x6ff) | ((cx_read(MO_GP1_IO) << 8) & 0x900); 104 auxgpio = gpio; 105 break; 106 default: 107 auxgpio = gpio; 108 } 109 if (ir->polling) { 110 if (ir->last_gpio == auxgpio) 111 return; 112 ir->last_gpio = auxgpio; 113 } 114 115 /* extract data */ 116 data = ir_extract_bits(gpio, ir->mask_keycode); 117 ir_dprintk("irq gpio=0x%x code=%d | %s%s%s\n", 118 gpio, data, 119 ir->polling ? "poll" : "irq", 120 (gpio & ir->mask_keydown) ? " down" : "", 121 (gpio & ir->mask_keyup) ? " up" : ""); 122 123 if (ir->core->boardnr == CX88_BOARD_NORWOOD_MICRO) { 124 u32 gpio_key = cx_read(MO_GP0_IO); 125 126 data = (data << 4) | ((gpio_key & 0xf0) >> 4); 127 128 ir_keydown(ir->input, data, 0); 129 130 } else if (ir->mask_keydown) { 131 /* bit set on keydown */ 132 if (gpio & ir->mask_keydown) 133 ir_keydown(ir->input, data, 0); 134 135 } else if (ir->mask_keyup) { 136 /* bit cleared on keydown */ 137 if (0 == (gpio & ir->mask_keyup)) 138 ir_keydown(ir->input, data, 0); 139 140 } else { 141 /* can't distinguish keydown/up :-/ */ 142 ir_keydown(ir->input, data, 0); 143 } 144} 145 146static enum hrtimer_restart cx88_ir_work(struct hrtimer *timer) 147{ 148 unsigned long missed; 149 struct cx88_IR *ir = container_of(timer, struct cx88_IR, timer); 150 151 cx88_ir_handle_key(ir); 152 missed = hrtimer_forward_now(&ir->timer, 153 ktime_set(0, ir->polling * 1000000)); 154 if (missed > 1) 155 ir_dprintk("Missed ticks %ld\n", missed - 1); 156 157 return HRTIMER_RESTART; 158} 159 160static int __cx88_ir_start(void *priv) 161{ 162 struct cx88_core *core = priv; 163 struct cx88_IR *ir; 164 165 if (!core || !core->ir) 166 return -EINVAL; 167 168 ir = core->ir; 169 170 if (ir->polling) { 171 hrtimer_init(&ir->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); 172 ir->timer.function = cx88_ir_work; 173 hrtimer_start(&ir->timer, 174 ktime_set(0, ir->polling * 1000000), 175 HRTIMER_MODE_REL); 176 } 177 if (ir->sampling) { 178 core->pci_irqmask |= PCI_INT_IR_SMPINT; 179 cx_write(MO_DDS_IO, 0xa80a80); /* 4 kHz sample rate */ 180 cx_write(MO_DDSCFG_IO, 0x5); /* enable */ 181 } 182 return 0; 183} 184 185static void __cx88_ir_stop(void *priv) 186{ 187 struct cx88_core *core = priv; 188 struct cx88_IR *ir; 189 190 if (!core || !core->ir) 191 return; 192 193 ir = core->ir; 194 if (ir->sampling) { 195 cx_write(MO_DDSCFG_IO, 0x0); 196 core->pci_irqmask &= ~PCI_INT_IR_SMPINT; 197 } 198 199 if (ir->polling) 200 hrtimer_cancel(&ir->timer); 201} 202 203int cx88_ir_start(struct cx88_core *core) 204{ 205 if (core->ir->users) 206 return __cx88_ir_start(core); 207 208 return 0; 209} 210 211void cx88_ir_stop(struct cx88_core *core) 212{ 213 if (core->ir->users) 214 __cx88_ir_stop(core); 215} 216 217static int cx88_ir_open(void *priv) 218{ 219 struct cx88_core *core = priv; 220 221 core->ir->users++; 222 return __cx88_ir_start(core); 223} 224 225static void cx88_ir_close(void *priv) 226{ 227 struct cx88_core *core = priv; 228 229 core->ir->users--; 230 if (!core->ir->users) 231 __cx88_ir_stop(core); 232} 233 234/* ---------------------------------------------------------------------- */ 235 236int cx88_ir_init(struct cx88_core *core, struct pci_dev *pci) 237{ 238 struct cx88_IR *ir; 239 struct input_dev *input_dev; 240 char *ir_codes = NULL; 241 u64 ir_type = IR_TYPE_OTHER; 242 int err = -ENOMEM; 243 u32 hardware_mask = 0; /* For devices with a hardware mask, when 244 * used with a full-code IR table 245 */ 246 247 ir = kzalloc(sizeof(*ir), GFP_KERNEL); 248 input_dev = input_allocate_device(); 249 if (!ir || !input_dev) 250 goto err_out_free; 251 252 ir->input = input_dev; 253 254 /* detect & configure */ 255 switch (core->boardnr) { 256 case CX88_BOARD_DNTV_LIVE_DVB_T: 257 case CX88_BOARD_KWORLD_DVB_T: 258 case CX88_BOARD_KWORLD_DVB_T_CX22702: 259 ir_codes = RC_MAP_DNTV_LIVE_DVB_T; 260 ir->gpio_addr = MO_GP1_IO; 261 ir->mask_keycode = 0x1f; 262 ir->mask_keyup = 0x60; 263 ir->polling = 50; /* ms */ 264 break; 265 case CX88_BOARD_TERRATEC_CINERGY_1400_DVB_T1: 266 ir_codes = RC_MAP_CINERGY_1400; 267 ir_type = IR_TYPE_NEC; 268 ir->sampling = 0xeb04; /* address */ 269 break; 270 case CX88_BOARD_HAUPPAUGE: 271 case CX88_BOARD_HAUPPAUGE_DVB_T1: 272 case CX88_BOARD_HAUPPAUGE_NOVASE2_S1: 273 case CX88_BOARD_HAUPPAUGE_NOVASPLUS_S1: 274 case CX88_BOARD_HAUPPAUGE_HVR1100: 275 case CX88_BOARD_HAUPPAUGE_HVR3000: 276 case CX88_BOARD_HAUPPAUGE_HVR4000: 277 case CX88_BOARD_HAUPPAUGE_HVR4000LITE: 278 case CX88_BOARD_PCHDTV_HD3000: 279 case CX88_BOARD_PCHDTV_HD5500: 280 case CX88_BOARD_HAUPPAUGE_IRONLY: 281 ir_codes = RC_MAP_HAUPPAUGE_NEW; 282 ir_type = IR_TYPE_RC5; 283 ir->sampling = 1; 284 break; 285 case CX88_BOARD_WINFAST_DTV2000H: 286 case CX88_BOARD_WINFAST_DTV2000H_J: 287 case CX88_BOARD_WINFAST_DTV1800H: 288 ir_codes = RC_MAP_WINFAST; 289 ir->gpio_addr = MO_GP0_IO; 290 ir->mask_keycode = 0x8f8; 291 ir->mask_keyup = 0x100; 292 ir->polling = 50; /* ms */ 293 break; 294 case CX88_BOARD_WINFAST2000XP_EXPERT: 295 case CX88_BOARD_WINFAST_DTV1000: 296 case CX88_BOARD_WINFAST_TV2000_XP_GLOBAL: 297 ir_codes = RC_MAP_WINFAST; 298 ir->gpio_addr = MO_GP0_IO; 299 ir->mask_keycode = 0x8f8; 300 ir->mask_keyup = 0x100; 301 ir->polling = 1; /* ms */ 302 break; 303 case CX88_BOARD_IODATA_GVBCTV7E: 304 ir_codes = RC_MAP_IODATA_BCTV7E; 305 ir->gpio_addr = MO_GP0_IO; 306 ir->mask_keycode = 0xfd; 307 ir->mask_keydown = 0x02; 308 ir->polling = 5; /* ms */ 309 break; 310 case CX88_BOARD_PROLINK_PLAYTVPVR: 311 case CX88_BOARD_PIXELVIEW_PLAYTV_ULTRA_PRO: 312 /* 313 * It seems that this hardware is paired with NEC extended 314 * address 0x866b. So, unfortunately, its usage with other 315 * IR's with different address won't work. Still, there are 316 * other IR's from the same manufacturer that works, like the 317 * 002-T mini RC, provided with newer PV hardware 318 */ 319 ir_codes = RC_MAP_PIXELVIEW_MK12; 320 ir->gpio_addr = MO_GP1_IO; 321 ir->mask_keyup = 0x80; 322 ir->polling = 10; /* ms */ 323 hardware_mask = 0x3f; /* Hardware returns only 6 bits from command part */ 324 break; 325 case CX88_BOARD_PROLINK_PV_8000GT: 326 case CX88_BOARD_PROLINK_PV_GLOBAL_XTREME: 327 ir_codes = RC_MAP_PIXELVIEW_NEW; 328 ir->gpio_addr = MO_GP1_IO; 329 ir->mask_keycode = 0x3f; 330 ir->mask_keyup = 0x80; 331 ir->polling = 1; /* ms */ 332 break; 333 case CX88_BOARD_KWORLD_LTV883: 334 ir_codes = RC_MAP_PIXELVIEW; 335 ir->gpio_addr = MO_GP1_IO; 336 ir->mask_keycode = 0x1f; 337 ir->mask_keyup = 0x60; 338 ir->polling = 1; /* ms */ 339 break; 340 case CX88_BOARD_ADSTECH_DVB_T_PCI: 341 ir_codes = RC_MAP_ADSTECH_DVB_T_PCI; 342 ir->gpio_addr = MO_GP1_IO; 343 ir->mask_keycode = 0xbf; 344 ir->mask_keyup = 0x40; 345 ir->polling = 50; /* ms */ 346 break; 347 case CX88_BOARD_MSI_TVANYWHERE_MASTER: 348 ir_codes = RC_MAP_MSI_TVANYWHERE; 349 ir->gpio_addr = MO_GP1_IO; 350 ir->mask_keycode = 0x1f; 351 ir->mask_keyup = 0x40; 352 ir->polling = 1; /* ms */ 353 break; 354 case CX88_BOARD_AVERTV_303: 355 case CX88_BOARD_AVERTV_STUDIO_303: 356 ir_codes = RC_MAP_AVERTV_303; 357 ir->gpio_addr = MO_GP2_IO; 358 ir->mask_keycode = 0xfb; 359 ir->mask_keydown = 0x02; 360 ir->polling = 50; /* ms */ 361 break; 362 case CX88_BOARD_OMICOM_SS4_PCI: 363 case CX88_BOARD_SATTRADE_ST4200: 364 case CX88_BOARD_TBS_8920: 365 case CX88_BOARD_TBS_8910: 366 case CX88_BOARD_PROF_7300: 367 case CX88_BOARD_PROF_7301: 368 case CX88_BOARD_PROF_6200: 369 ir_codes = RC_MAP_TBS_NEC; 370 ir_type = IR_TYPE_NEC; 371 ir->sampling = 0xff00; /* address */ 372 break; 373 case CX88_BOARD_TEVII_S460: 374 case CX88_BOARD_TEVII_S420: 375 ir_codes = RC_MAP_TEVII_NEC; 376 ir_type = IR_TYPE_NEC; 377 ir->sampling = 0xff00; /* address */ 378 break; 379 case CX88_BOARD_DNTV_LIVE_DVB_T_PRO: 380 ir_codes = RC_MAP_DNTV_LIVE_DVBT_PRO; 381 ir_type = IR_TYPE_NEC; 382 ir->sampling = 0xff00; /* address */ 383 break; 384 case CX88_BOARD_NORWOOD_MICRO: 385 ir_codes = RC_MAP_NORWOOD; 386 ir->gpio_addr = MO_GP1_IO; 387 ir->mask_keycode = 0x0e; 388 ir->mask_keyup = 0x80; 389 ir->polling = 50; /* ms */ 390 break; 391 case CX88_BOARD_NPGTECH_REALTV_TOP10FM: 392 ir_codes = RC_MAP_NPGTECH; 393 ir->gpio_addr = MO_GP0_IO; 394 ir->mask_keycode = 0xfa; 395 ir->polling = 50; /* ms */ 396 break; 397 case CX88_BOARD_PINNACLE_PCTV_HD_800i: 398 ir_codes = RC_MAP_PINNACLE_PCTV_HD; 399 ir_type = IR_TYPE_RC5; 400 ir->sampling = 1; 401 break; 402 case CX88_BOARD_POWERCOLOR_REAL_ANGEL: 403 ir_codes = RC_MAP_POWERCOLOR_REAL_ANGEL; 404 ir->gpio_addr = MO_GP2_IO; 405 ir->mask_keycode = 0x7e; 406 ir->polling = 100; /* ms */ 407 break; 408 } 409 410 if (NULL == ir_codes) { 411 err = -ENODEV; 412 goto err_out_free; 413 } 414 415 /* 416 * The usage of mask_keycode were very convenient, due to several 417 * reasons. Among others, the scancode tables were using the scancode 418 * as the index elements. So, the less bits it was used, the smaller 419 * the table were stored. After the input changes, the better is to use 420 * the full scancodes, since it allows replacing the IR remote by 421 * another one. Unfortunately, there are still some hardware, like 422 * Pixelview Ultra Pro, where only part of the scancode is sent via 423 * GPIO. So, there's no way to get the full scancode. Due to that, 424 * hardware_mask were introduced here: it represents those hardware 425 * that has such limits. 426 */ 427 if (hardware_mask && !ir->mask_keycode) 428 ir->mask_keycode = hardware_mask; 429 430 /* init input device */ 431 snprintf(ir->name, sizeof(ir->name), "cx88 IR (%s)", core->board.name); 432 snprintf(ir->phys, sizeof(ir->phys), "pci-%s/ir0", pci_name(pci)); 433 434 ir->ir_type = ir_type; 435 436 input_dev->name = ir->name; 437 input_dev->phys = ir->phys; 438 input_dev->id.bustype = BUS_PCI; 439 input_dev->id.version = 1; 440 if (pci->subsystem_vendor) { 441 input_dev->id.vendor = pci->subsystem_vendor; 442 input_dev->id.product = pci->subsystem_device; 443 } else { 444 input_dev->id.vendor = pci->vendor; 445 input_dev->id.product = pci->device; 446 } 447 input_dev->dev.parent = &pci->dev; 448 /* record handles to ourself */ 449 ir->core = core; 450 core->ir = ir; 451 452 ir->props.priv = core; 453 ir->props.open = cx88_ir_open; 454 ir->props.close = cx88_ir_close; 455 ir->props.scanmask = hardware_mask; 456 457 /* all done */ 458 err = ir_input_register(ir->input, ir_codes, &ir->props, MODULE_NAME); 459 if (err) 460 goto err_out_free; 461 462 return 0; 463 464 err_out_free: 465 core->ir = NULL; 466 kfree(ir); 467 return err; 468} 469 470int cx88_ir_fini(struct cx88_core *core) 471{ 472 struct cx88_IR *ir = core->ir; 473 474 /* skip detach on non attached boards */ 475 if (NULL == ir) 476 return 0; 477 478 cx88_ir_stop(core); 479 ir_input_unregister(ir->input); 480 kfree(ir); 481 482 /* done */ 483 core->ir = NULL; 484 return 0; 485} 486 487/* ---------------------------------------------------------------------- */ 488 489void cx88_ir_irq(struct cx88_core *core) 490{ 491 struct cx88_IR *ir = core->ir; 492 u32 samples, ircode; 493 int i, start, range, toggle, dev, code; 494 495 if (NULL == ir) 496 return; 497 if (!ir->sampling) 498 return; 499 500 samples = cx_read(MO_SAMPLE_IO); 501 if (0 != samples && 0xffffffff != samples) { 502 /* record sample data */ 503 if (ir->scount < ARRAY_SIZE(ir->samples)) 504 ir->samples[ir->scount++] = samples; 505 return; 506 } 507 if (!ir->scount) { 508 /* nothing to sample */ 509 return; 510 } 511 512 /* have a complete sample */ 513 if (ir->scount < ARRAY_SIZE(ir->samples)) 514 ir->samples[ir->scount++] = samples; 515 for (i = 0; i < ir->scount; i++) 516 ir->samples[i] = ~ir->samples[i]; 517 if (ir_debug) 518 ir_dump_samples(ir->samples, ir->scount); 519 520 /* decode it */ 521 switch (core->boardnr) { 522 case CX88_BOARD_TEVII_S460: 523 case CX88_BOARD_TEVII_S420: 524 case CX88_BOARD_TERRATEC_CINERGY_1400_DVB_T1: 525 case CX88_BOARD_DNTV_LIVE_DVB_T_PRO: 526 case CX88_BOARD_OMICOM_SS4_PCI: 527 case CX88_BOARD_SATTRADE_ST4200: 528 case CX88_BOARD_TBS_8920: 529 case CX88_BOARD_TBS_8910: 530 case CX88_BOARD_PROF_7300: 531 case CX88_BOARD_PROF_7301: 532 case CX88_BOARD_PROF_6200: 533 ircode = ir_decode_pulsedistance(ir->samples, ir->scount, 1, 4); 534 535 if (ircode == 0xffffffff) { /* decoding error */ 536 ir_dprintk("pulse distance decoding error\n"); 537 break; 538 } 539 540 ir_dprintk("pulse distance decoded: %x\n", ircode); 541 542 if (ircode == 0) { /* key still pressed */ 543 ir_dprintk("pulse distance decoded repeat code\n"); 544 ir_repeat(ir->input); 545 break; 546 } 547 548 if ((ircode & 0xffff) != (ir->sampling & 0xffff)) { /* wrong address */ 549 ir_dprintk("pulse distance decoded wrong address\n"); 550 break; 551 } 552 553 if (((~ircode >> 24) & 0xff) != ((ircode >> 16) & 0xff)) { /* wrong checksum */ 554 ir_dprintk("pulse distance decoded wrong check sum\n"); 555 break; 556 } 557 558 ir_dprintk("Key Code: %x\n", (ircode >> 16) & 0xff); 559 ir_keydown(ir->input, (ircode >> 16) & 0xff, 0); 560 break; 561 case CX88_BOARD_HAUPPAUGE: 562 case CX88_BOARD_HAUPPAUGE_DVB_T1: 563 case CX88_BOARD_HAUPPAUGE_NOVASE2_S1: 564 case CX88_BOARD_HAUPPAUGE_NOVASPLUS_S1: 565 case CX88_BOARD_HAUPPAUGE_HVR1100: 566 case CX88_BOARD_HAUPPAUGE_HVR3000: 567 case CX88_BOARD_HAUPPAUGE_HVR4000: 568 case CX88_BOARD_HAUPPAUGE_HVR4000LITE: 569 case CX88_BOARD_PCHDTV_HD3000: 570 case CX88_BOARD_PCHDTV_HD5500: 571 case CX88_BOARD_HAUPPAUGE_IRONLY: 572 ircode = ir_decode_biphase(ir->samples, ir->scount, 5, 7); 573 ir_dprintk("biphase decoded: %x\n", ircode); 574 /* 575 * RC5 has an extension bit which adds a new range 576 * of available codes, this is detected here. Also 577 * hauppauge remotes (black/silver) always use 578 * specific device ids. If we do not filter the 579 * device ids then messages destined for devices 580 * such as TVs (id=0) will get through to the 581 * device causing mis-fired events. 582 */ 583 /* split rc5 data block ... */ 584 start = (ircode & 0x2000) >> 13; 585 range = (ircode & 0x1000) >> 12; 586 toggle= (ircode & 0x0800) >> 11; 587 dev = (ircode & 0x07c0) >> 6; 588 code = (ircode & 0x003f) | ((range << 6) ^ 0x0040); 589 if( start != 1) 590 /* no key pressed */ 591 break; 592 if ( dev != 0x1e && dev != 0x1f ) 593 /* not a hauppauge remote */ 594 break; 595 ir_keydown(ir->input, code, toggle); 596 break; 597 case CX88_BOARD_PINNACLE_PCTV_HD_800i: 598 ircode = ir_decode_biphase(ir->samples, ir->scount, 5, 7); 599 ir_dprintk("biphase decoded: %x\n", ircode); 600 if ((ircode & 0xfffff000) != 0x3000) 601 break; 602 /* Note: bit 0x800 being the toggle is assumed, not checked 603 with real hardware */ 604 ir_keydown(ir->input, ircode & 0x3f, ircode & 0x0800 ? 1 : 0); 605 break; 606 } 607 608 ir->scount = 0; 609 return; 610} 611 612/* ---------------------------------------------------------------------- */ 613 614MODULE_AUTHOR("Gerd Knorr, Pavel Machek, Chris Pascoe"); 615MODULE_DESCRIPTION("input driver for cx88 GPIO-based IR remote controls"); 616MODULE_LICENSE("GPL"); 617/* 618 * Local variables: 619 * c-basic-offset: 8 620 * End: 621 */ 622