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 /* copied and modified from get_key_msi_tvanywhere_plus() */ 214 static int get_key_kworld_pc150u(struct IR_i2c *ir, u32 *ir_key, 215 u32 *ir_raw) 216 { 217 unsigned char b; 218 unsigned int gpio; 219 220 /* <dev> is needed to access GPIO. Used by the saa_readl macro. */ 221 struct saa7134_dev *dev = ir->c->adapter->algo_data; 222 if (dev == NULL) { 223 i2cdprintk("get_key_kworld_pc150u: " 224 "ir->c->adapter->algo_data is NULL!\n"); 225 return -EIO; 226 } 227 228 /* rising SAA7134_GPIO_GPRESCAN reads the status */ 229 230 saa_clearb(SAA7134_GPIO_GPMODE3, SAA7134_GPIO_GPRESCAN); 231 saa_setb(SAA7134_GPIO_GPMODE3, SAA7134_GPIO_GPRESCAN); 232 233 gpio = saa_readl(SAA7134_GPIO_GPSTATUS0 >> 2); 234 235 /* GPIO&0x100 is pulsed low when a button is pressed. Don't do 236 I2C receive if gpio&0x100 is not low. */ 237 238 if (gpio & 0x100) 239 return 0; /* No button press */ 240 241 /* GPIO says there is a button press. Get it. */ 242 243 if (1 != i2c_master_recv(ir->c, &b, 1)) { 244 i2cdprintk("read error\n"); 245 return -EIO; 246 } 247 248 /* No button press */ 249 250 if (b == 0xff) 251 return 0; 252 253 /* Button pressed */ 254 255 dprintk("get_key_kworld_pc150u: Key = 0x%02X\n", b); 256 *ir_key = b; 257 *ir_raw = b; 258 return 1; 259 } 260 261 static int get_key_purpletv(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw) 262 { 263 unsigned char b; 264 265 /* poll IR chip */ 266 if (1 != i2c_master_recv(ir->c, &b, 1)) { 267 i2cdprintk("read error\n"); 268 return -EIO; 269 } 270 271 /* no button press */ 272 if (b==0) 273 return 0; 274 275 /* repeating */ 276 if (b & 0x80) 277 return 1; 278 279 *ir_key = b; 280 *ir_raw = b; 281 return 1; 282 } 283 284 static int get_key_hvr1110(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw) 285 { 286 unsigned char buf[5]; 287 288 /* poll IR chip */ 289 if (5 != i2c_master_recv(ir->c, buf, 5)) 290 return -EIO; 291 292 /* Check if some key were pressed */ 293 if (!(buf[0] & 0x80)) 294 return 0; 295 296 /* 297 * buf[3] & 0x80 is always high. 298 * buf[3] & 0x40 is a parity bit. A repeat event is marked 299 * by preserving it into two separate readings 300 * buf[4] bits 0 and 1, and buf[1] and buf[2] are always 301 * zero. 302 */ 303 *ir_key = 0x1fff & ((buf[3] << 8) | (buf[4] >> 2)); 304 *ir_raw = *ir_key; 305 return 1; 306 } 307 308 309 static int get_key_beholdm6xx(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw) 310 { 311 unsigned char data[12]; 312 u32 gpio; 313 314 struct saa7134_dev *dev = ir->c->adapter->algo_data; 315 316 /* rising SAA7134_GPIO_GPRESCAN reads the status */ 317 saa_clearb(SAA7134_GPIO_GPMODE3, SAA7134_GPIO_GPRESCAN); 318 saa_setb(SAA7134_GPIO_GPMODE3, SAA7134_GPIO_GPRESCAN); 319 320 gpio = saa_readl(SAA7134_GPIO_GPSTATUS0 >> 2); 321 322 if (0x400000 & ~gpio) 323 return 0; /* No button press */ 324 325 ir->c->addr = 0x5a >> 1; 326 327 if (12 != i2c_master_recv(ir->c, data, 12)) { 328 i2cdprintk("read error\n"); 329 return -EIO; 330 } 331 332 if (data[9] != (unsigned char)(~data[8])) 333 return 0; 334 335 *ir_raw = ((data[10] << 16) | (data[11] << 8) | (data[9] << 0)); 336 *ir_key = *ir_raw; 337 338 return 1; 339 } 340 341 /* Common (grey or coloured) pinnacle PCTV remote handling 342 * 343 */ 344 static int get_key_pinnacle(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw, 345 int parity_offset, int marker, int code_modulo) 346 { 347 unsigned char b[4]; 348 unsigned int start = 0,parity = 0,code = 0; 349 350 /* poll IR chip */ 351 if (4 != i2c_master_recv(ir->c, b, 4)) { 352 i2cdprintk("read error\n"); 353 return -EIO; 354 } 355 356 for (start = 0; start < ARRAY_SIZE(b); start++) { 357 if (b[start] == marker) { 358 code=b[(start+parity_offset + 1) % 4]; 359 parity=b[(start+parity_offset) % 4]; 360 } 361 } 362 363 /* Empty Request */ 364 if (parity == 0) 365 return 0; 366 367 /* Repeating... */ 368 if (ir->old == parity) 369 return 0; 370 371 ir->old = parity; 372 373 /* drop special codes when a key is held down a long time for the grey controller 374 In this case, the second bit of the code is asserted */ 375 if (marker == 0xfe && (code & 0x40)) 376 return 0; 377 378 code %= code_modulo; 379 380 *ir_raw = code; 381 *ir_key = code; 382 383 i2cdprintk("Pinnacle PCTV key %02x\n", code); 384 385 return 1; 386 } 387 388 /* The grey pinnacle PCTV remote 389 * 390 * There are one issue with this remote: 391 * - I2c packet does not change when the same key is pressed quickly. The workaround 392 * is to hold down each key for about half a second, so that another code is generated 393 * in the i2c packet, and the function can distinguish key presses. 394 * 395 * Sylvain Pasche <sylvain.pasche@gmail.com> 396 */ 397 static int get_key_pinnacle_grey(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw) 398 { 399 400 return get_key_pinnacle(ir, ir_key, ir_raw, 1, 0xfe, 0xff); 401 } 402 403 404 /* The new pinnacle PCTV remote (with the colored buttons) 405 * 406 * Ricardo Cerqueira <v4l@cerqueira.org> 407 */ 408 static int get_key_pinnacle_color(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw) 409 { 410 /* code_modulo parameter (0x88) is used to reduce code value to fit inside IR_KEYTAB_SIZE 411 * 412 * this is the only value that results in 42 unique 413 * codes < 128 414 */ 415 416 return get_key_pinnacle(ir, ir_key, ir_raw, 2, 0x80, 0x88); 417 } 418 419 void saa7134_input_irq(struct saa7134_dev *dev) 420 { 421 struct saa7134_card_ir *ir; 422 423 if (!dev || !dev->remote) 424 return; 425 426 ir = dev->remote; 427 if (!ir->running) 428 return; 429 430 if (!ir->polling && !ir->raw_decode) { 431 build_key(dev); 432 } else if (ir->raw_decode) { 433 saa7134_raw_decode_irq(dev); 434 } 435 } 436 437 static void saa7134_input_timer(unsigned long data) 438 { 439 struct saa7134_dev *dev = (struct saa7134_dev *)data; 440 struct saa7134_card_ir *ir = dev->remote; 441 442 build_key(dev); 443 mod_timer(&ir->timer, jiffies + msecs_to_jiffies(ir->polling)); 444 } 445 446 static void ir_raw_decode_timer_end(unsigned long data) 447 { 448 struct saa7134_dev *dev = (struct saa7134_dev *)data; 449 450 ir_raw_event_handle(dev->remote->dev); 451 } 452 453 static int __saa7134_ir_start(void *priv) 454 { 455 struct saa7134_dev *dev = priv; 456 struct saa7134_card_ir *ir; 457 458 if (!dev || !dev->remote) 459 return -EINVAL; 460 461 ir = dev->remote; 462 if (ir->running) 463 return 0; 464 465 /* Moved here from saa7134_input_init1() because the latter 466 * is not called on device resume */ 467 switch (dev->board) { 468 case SAA7134_BOARD_MD2819: 469 case SAA7134_BOARD_KWORLD_VSTREAM_XPERT: 470 case SAA7134_BOARD_AVERMEDIA_305: 471 case SAA7134_BOARD_AVERMEDIA_307: 472 case SAA7134_BOARD_AVERMEDIA_STUDIO_305: 473 case SAA7134_BOARD_AVERMEDIA_STUDIO_505: 474 case SAA7134_BOARD_AVERMEDIA_STUDIO_307: 475 case SAA7134_BOARD_AVERMEDIA_STUDIO_507: 476 case SAA7134_BOARD_AVERMEDIA_STUDIO_507UA: 477 case SAA7134_BOARD_AVERMEDIA_GO_007_FM: 478 case SAA7134_BOARD_AVERMEDIA_M102: 479 case SAA7134_BOARD_AVERMEDIA_GO_007_FM_PLUS: 480 /* Without this we won't receive key up events */ 481 saa_setb(SAA7134_GPIO_GPMODE0, 0x4); 482 saa_setb(SAA7134_GPIO_GPSTATUS0, 0x4); 483 break; 484 case SAA7134_BOARD_AVERMEDIA_777: 485 case SAA7134_BOARD_AVERMEDIA_A16AR: 486 /* Without this we won't receive key up events */ 487 saa_setb(SAA7134_GPIO_GPMODE1, 0x1); 488 saa_setb(SAA7134_GPIO_GPSTATUS1, 0x1); 489 break; 490 case SAA7134_BOARD_AVERMEDIA_A16D: 491 /* Without this we won't receive key up events */ 492 saa_setb(SAA7134_GPIO_GPMODE1, 0x1); 493 saa_setb(SAA7134_GPIO_GPSTATUS1, 0x1); 494 break; 495 case SAA7134_BOARD_GOTVIEW_7135: 496 saa_setb(SAA7134_GPIO_GPMODE1, 0x80); 497 break; 498 } 499 500 ir->running = true; 501 502 if (ir->polling) { 503 setup_timer(&ir->timer, saa7134_input_timer, 504 (unsigned long)dev); 505 ir->timer.expires = jiffies + HZ; 506 add_timer(&ir->timer); 507 } else if (ir->raw_decode) { 508 /* set timer_end for code completion */ 509 setup_timer(&ir->timer, ir_raw_decode_timer_end, 510 (unsigned long)dev); 511 } 512 513 return 0; 514 } 515 516 static void __saa7134_ir_stop(void *priv) 517 { 518 struct saa7134_dev *dev = priv; 519 struct saa7134_card_ir *ir; 520 521 if (!dev || !dev->remote) 522 return; 523 524 ir = dev->remote; 525 if (!ir->running) 526 return; 527 528 if (ir->polling || ir->raw_decode) 529 del_timer_sync(&ir->timer); 530 531 ir->running = false; 532 533 return; 534 } 535 536 int saa7134_ir_start(struct saa7134_dev *dev) 537 { 538 if (dev->remote->users) 539 return __saa7134_ir_start(dev); 540 541 return 0; 542 } 543 544 void saa7134_ir_stop(struct saa7134_dev *dev) 545 { 546 if (dev->remote->users) 547 __saa7134_ir_stop(dev); 548 } 549 550 static int saa7134_ir_open(struct rc_dev *rc) 551 { 552 struct saa7134_dev *dev = rc->priv; 553 554 dev->remote->users++; 555 return __saa7134_ir_start(dev); 556 } 557 558 static void saa7134_ir_close(struct rc_dev *rc) 559 { 560 struct saa7134_dev *dev = rc->priv; 561 562 dev->remote->users--; 563 if (!dev->remote->users) 564 __saa7134_ir_stop(dev); 565 } 566 567 int saa7134_input_init1(struct saa7134_dev *dev) 568 { 569 struct saa7134_card_ir *ir; 570 struct rc_dev *rc; 571 char *ir_codes = NULL; 572 u32 mask_keycode = 0; 573 u32 mask_keydown = 0; 574 u32 mask_keyup = 0; 575 unsigned polling = 0; 576 bool raw_decode = false; 577 int err; 578 579 if (dev->has_remote != SAA7134_REMOTE_GPIO) 580 return -ENODEV; 581 if (disable_ir) 582 return -ENODEV; 583 584 /* detect & configure */ 585 switch (dev->board) { 586 case SAA7134_BOARD_FLYVIDEO2000: 587 case SAA7134_BOARD_FLYVIDEO3000: 588 case SAA7134_BOARD_FLYTVPLATINUM_FM: 589 case SAA7134_BOARD_FLYTVPLATINUM_MINI2: 590 case SAA7134_BOARD_ROVERMEDIA_LINK_PRO_FM: 591 ir_codes = RC_MAP_FLYVIDEO; 592 mask_keycode = 0xEC00000; 593 mask_keydown = 0x0040000; 594 break; 595 case SAA7134_BOARD_CINERGY400: 596 case SAA7134_BOARD_CINERGY600: 597 case SAA7134_BOARD_CINERGY600_MK3: 598 ir_codes = RC_MAP_CINERGY; 599 mask_keycode = 0x00003f; 600 mask_keyup = 0x040000; 601 break; 602 case SAA7134_BOARD_ECS_TVP3XP: 603 case SAA7134_BOARD_ECS_TVP3XP_4CB5: 604 ir_codes = RC_MAP_EZTV; 605 mask_keycode = 0x00017c; 606 mask_keyup = 0x000002; 607 polling = 50; // ms 608 break; 609 case SAA7134_BOARD_KWORLD_XPERT: 610 case SAA7134_BOARD_AVACSSMARTTV: 611 ir_codes = RC_MAP_PIXELVIEW; 612 mask_keycode = 0x00001F; 613 mask_keyup = 0x000020; 614 polling = 50; // ms 615 break; 616 case SAA7134_BOARD_MD2819: 617 case SAA7134_BOARD_KWORLD_VSTREAM_XPERT: 618 case SAA7134_BOARD_AVERMEDIA_305: 619 case SAA7134_BOARD_AVERMEDIA_307: 620 case SAA7134_BOARD_AVERMEDIA_STUDIO_305: 621 case SAA7134_BOARD_AVERMEDIA_STUDIO_505: 622 case SAA7134_BOARD_AVERMEDIA_STUDIO_307: 623 case SAA7134_BOARD_AVERMEDIA_STUDIO_507: 624 case SAA7134_BOARD_AVERMEDIA_STUDIO_507UA: 625 case SAA7134_BOARD_AVERMEDIA_GO_007_FM: 626 case SAA7134_BOARD_AVERMEDIA_M102: 627 case SAA7134_BOARD_AVERMEDIA_GO_007_FM_PLUS: 628 ir_codes = RC_MAP_AVERMEDIA; 629 mask_keycode = 0x0007C8; 630 mask_keydown = 0x000010; 631 polling = 50; // ms 632 /* GPIO stuff moved to __saa7134_ir_start() */ 633 break; 634 case SAA7134_BOARD_AVERMEDIA_M135A: 635 ir_codes = RC_MAP_AVERMEDIA_M135A; 636 mask_keydown = 0x0040000; /* Enable GPIO18 line on both edges */ 637 mask_keyup = 0x0040000; 638 mask_keycode = 0xffff; 639 raw_decode = true; 640 break; 641 case SAA7134_BOARD_AVERMEDIA_M733A: 642 ir_codes = RC_MAP_AVERMEDIA_M733A_RM_K6; 643 mask_keydown = 0x0040000; 644 mask_keyup = 0x0040000; 645 mask_keycode = 0xffff; 646 raw_decode = true; 647 break; 648 case SAA7134_BOARD_AVERMEDIA_777: 649 case SAA7134_BOARD_AVERMEDIA_A16AR: 650 ir_codes = RC_MAP_AVERMEDIA; 651 mask_keycode = 0x02F200; 652 mask_keydown = 0x000400; 653 polling = 50; // ms 654 /* GPIO stuff moved to __saa7134_ir_start() */ 655 break; 656 case SAA7134_BOARD_AVERMEDIA_A16D: 657 ir_codes = RC_MAP_AVERMEDIA_A16D; 658 mask_keycode = 0x02F200; 659 mask_keydown = 0x000400; 660 polling = 50; /* ms */ 661 /* GPIO stuff moved to __saa7134_ir_start() */ 662 break; 663 case SAA7134_BOARD_KWORLD_TERMINATOR: 664 ir_codes = RC_MAP_PIXELVIEW; 665 mask_keycode = 0x00001f; 666 mask_keyup = 0x000060; 667 polling = 50; // ms 668 break; 669 case SAA7134_BOARD_MANLI_MTV001: 670 case SAA7134_BOARD_MANLI_MTV002: 671 ir_codes = RC_MAP_MANLI; 672 mask_keycode = 0x001f00; 673 mask_keyup = 0x004000; 674 polling = 50; /* ms */ 675 break; 676 case SAA7134_BOARD_BEHOLD_409FM: 677 case SAA7134_BOARD_BEHOLD_401: 678 case SAA7134_BOARD_BEHOLD_403: 679 case SAA7134_BOARD_BEHOLD_403FM: 680 case SAA7134_BOARD_BEHOLD_405: 681 case SAA7134_BOARD_BEHOLD_405FM: 682 case SAA7134_BOARD_BEHOLD_407: 683 case SAA7134_BOARD_BEHOLD_407FM: 684 case SAA7134_BOARD_BEHOLD_409: 685 case SAA7134_BOARD_BEHOLD_505FM: 686 case SAA7134_BOARD_BEHOLD_505RDS_MK5: 687 case SAA7134_BOARD_BEHOLD_505RDS_MK3: 688 case SAA7134_BOARD_BEHOLD_507_9FM: 689 case SAA7134_BOARD_BEHOLD_507RDS_MK3: 690 case SAA7134_BOARD_BEHOLD_507RDS_MK5: 691 ir_codes = RC_MAP_MANLI; 692 mask_keycode = 0x003f00; 693 mask_keyup = 0x004000; 694 polling = 50; /* ms */ 695 break; 696 case SAA7134_BOARD_BEHOLD_COLUMBUS_TVFM: 697 ir_codes = RC_MAP_BEHOLD_COLUMBUS; 698 mask_keycode = 0x003f00; 699 mask_keyup = 0x004000; 700 polling = 50; // ms 701 break; 702 case SAA7134_BOARD_SEDNA_PC_TV_CARDBUS: 703 ir_codes = RC_MAP_PCTV_SEDNA; 704 mask_keycode = 0x001f00; 705 mask_keyup = 0x004000; 706 polling = 50; // ms 707 break; 708 case SAA7134_BOARD_GOTVIEW_7135: 709 ir_codes = RC_MAP_GOTVIEW7135; 710 mask_keycode = 0x0003CC; 711 mask_keydown = 0x000010; 712 polling = 5; /* ms */ 713 /* GPIO stuff moved to __saa7134_ir_start() */ 714 break; 715 case SAA7134_BOARD_VIDEOMATE_TV_PVR: 716 case SAA7134_BOARD_VIDEOMATE_GOLD_PLUS: 717 case SAA7134_BOARD_VIDEOMATE_TV_GOLD_PLUSII: 718 ir_codes = RC_MAP_VIDEOMATE_TV_PVR; 719 mask_keycode = 0x00003F; 720 mask_keyup = 0x400000; 721 polling = 50; // ms 722 break; 723 case SAA7134_BOARD_PROTEUS_2309: 724 ir_codes = RC_MAP_PROTEUS_2309; 725 mask_keycode = 0x00007F; 726 mask_keyup = 0x000080; 727 polling = 50; // ms 728 break; 729 case SAA7134_BOARD_VIDEOMATE_DVBT_300: 730 case SAA7134_BOARD_VIDEOMATE_DVBT_200: 731 ir_codes = RC_MAP_VIDEOMATE_TV_PVR; 732 mask_keycode = 0x003F00; 733 mask_keyup = 0x040000; 734 break; 735 case SAA7134_BOARD_FLYDVBS_LR300: 736 case SAA7134_BOARD_FLYDVBT_LR301: 737 case SAA7134_BOARD_FLYDVBTDUO: 738 ir_codes = RC_MAP_FLYDVB; 739 mask_keycode = 0x0001F00; 740 mask_keydown = 0x0040000; 741 break; 742 case SAA7134_BOARD_ASUSTeK_P7131_DUAL: 743 case SAA7134_BOARD_ASUSTeK_P7131_HYBRID_LNA: 744 case SAA7134_BOARD_ASUSTeK_P7131_ANALOG: 745 ir_codes = RC_MAP_ASUS_PC39; 746 mask_keydown = 0x0040000; /* Enable GPIO18 line on both edges */ 747 mask_keyup = 0x0040000; 748 mask_keycode = 0xffff; 749 raw_decode = true; 750 break; 751 case SAA7134_BOARD_ASUSTeK_PS3_100: 752 ir_codes = RC_MAP_ASUS_PS3_100; 753 mask_keydown = 0x0040000; 754 mask_keyup = 0x0040000; 755 mask_keycode = 0xffff; 756 raw_decode = true; 757 break; 758 case SAA7134_BOARD_ENCORE_ENLTV: 759 case SAA7134_BOARD_ENCORE_ENLTV_FM: 760 ir_codes = RC_MAP_ENCORE_ENLTV; 761 mask_keycode = 0x00007f; 762 mask_keyup = 0x040000; 763 polling = 50; // ms 764 break; 765 case SAA7134_BOARD_ENCORE_ENLTV_FM53: 766 case SAA7134_BOARD_ENCORE_ENLTV_FM3: 767 ir_codes = RC_MAP_ENCORE_ENLTV_FM53; 768 mask_keydown = 0x0040000; /* Enable GPIO18 line on both edges */ 769 mask_keyup = 0x0040000; 770 mask_keycode = 0xffff; 771 raw_decode = true; 772 break; 773 case SAA7134_BOARD_10MOONSTVMASTER3: 774 ir_codes = RC_MAP_ENCORE_ENLTV; 775 mask_keycode = 0x5f80000; 776 mask_keyup = 0x8000000; 777 polling = 50; //ms 778 break; 779 case SAA7134_BOARD_GENIUS_TVGO_A11MCE: 780 ir_codes = RC_MAP_GENIUS_TVGO_A11MCE; 781 mask_keycode = 0xff; 782 mask_keydown = 0xf00000; 783 polling = 50; /* ms */ 784 break; 785 case SAA7134_BOARD_REAL_ANGEL_220: 786 ir_codes = RC_MAP_REAL_AUDIO_220_32_KEYS; 787 mask_keycode = 0x3f00; 788 mask_keyup = 0x4000; 789 polling = 50; /* ms */ 790 break; 791 case SAA7134_BOARD_KWORLD_PLUS_TV_ANALOG: 792 ir_codes = RC_MAP_KWORLD_PLUS_TV_ANALOG; 793 mask_keycode = 0x7f; 794 polling = 40; /* ms */ 795 break; 796 case SAA7134_BOARD_VIDEOMATE_S350: 797 ir_codes = RC_MAP_VIDEOMATE_S350; 798 mask_keycode = 0x003f00; 799 mask_keydown = 0x040000; 800 break; 801 case SAA7134_BOARD_LEADTEK_WINFAST_DTV1000S: 802 ir_codes = RC_MAP_WINFAST; 803 mask_keycode = 0x5f00; 804 mask_keyup = 0x020000; 805 polling = 50; /* ms */ 806 break; 807 case SAA7134_BOARD_VIDEOMATE_M1F: 808 ir_codes = RC_MAP_VIDEOMATE_K100; 809 mask_keycode = 0x0ff00; 810 mask_keyup = 0x040000; 811 break; 812 case SAA7134_BOARD_HAUPPAUGE_HVR1150: 813 case SAA7134_BOARD_HAUPPAUGE_HVR1120: 814 ir_codes = RC_MAP_HAUPPAUGE; 815 mask_keydown = 0x0040000; /* Enable GPIO18 line on both edges */ 816 mask_keyup = 0x0040000; 817 mask_keycode = 0xffff; 818 raw_decode = true; 819 break; 820 } 821 if (NULL == ir_codes) { 822 printk("%s: Oops: IR config error [card=%d]\n", 823 dev->name, dev->board); 824 return -ENODEV; 825 } 826 827 ir = kzalloc(sizeof(*ir), GFP_KERNEL); 828 rc = rc_allocate_device(); 829 if (!ir || !rc) { 830 err = -ENOMEM; 831 goto err_out_free; 832 } 833 834 ir->dev = rc; 835 dev->remote = ir; 836 837 /* init hardware-specific stuff */ 838 ir->mask_keycode = mask_keycode; 839 ir->mask_keydown = mask_keydown; 840 ir->mask_keyup = mask_keyup; 841 ir->polling = polling; 842 ir->raw_decode = raw_decode; 843 844 /* init input device */ 845 snprintf(ir->name, sizeof(ir->name), "saa7134 IR (%s)", 846 saa7134_boards[dev->board].name); 847 snprintf(ir->phys, sizeof(ir->phys), "pci-%s/ir0", 848 pci_name(dev->pci)); 849 850 rc->priv = dev; 851 rc->open = saa7134_ir_open; 852 rc->close = saa7134_ir_close; 853 if (raw_decode) 854 rc->driver_type = RC_DRIVER_IR_RAW; 855 856 rc->input_name = ir->name; 857 rc->input_phys = ir->phys; 858 rc->input_id.bustype = BUS_PCI; 859 rc->input_id.version = 1; 860 if (dev->pci->subsystem_vendor) { 861 rc->input_id.vendor = dev->pci->subsystem_vendor; 862 rc->input_id.product = dev->pci->subsystem_device; 863 } else { 864 rc->input_id.vendor = dev->pci->vendor; 865 rc->input_id.product = dev->pci->device; 866 } 867 rc->dev.parent = &dev->pci->dev; 868 rc->map_name = ir_codes; 869 rc->driver_name = MODULE_NAME; 870 871 err = rc_register_device(rc); 872 if (err) 873 goto err_out_free; 874 875 return 0; 876 877 err_out_free: 878 rc_free_device(rc); 879 dev->remote = NULL; 880 kfree(ir); 881 return err; 882 } 883 884 void saa7134_input_fini(struct saa7134_dev *dev) 885 { 886 if (NULL == dev->remote) 887 return; 888 889 saa7134_ir_stop(dev); 890 rc_unregister_device(dev->remote->dev); 891 kfree(dev->remote); 892 dev->remote = NULL; 893 } 894 895 void saa7134_probe_i2c_ir(struct saa7134_dev *dev) 896 { 897 struct i2c_board_info info; 898 struct i2c_msg msg_msi = { 899 .addr = 0x50, 900 .flags = I2C_M_RD, 901 .len = 0, 902 .buf = NULL, 903 }; 904 int rc; 905 906 if (disable_ir) { 907 dprintk("IR has been disabled, not probing for i2c remote\n"); 908 return; 909 } 910 911 memset(&info, 0, sizeof(struct i2c_board_info)); 912 memset(&dev->init_data, 0, sizeof(dev->init_data)); 913 strlcpy(info.type, "ir_video", I2C_NAME_SIZE); 914 915 switch (dev->board) { 916 case SAA7134_BOARD_PINNACLE_PCTV_110i: 917 case SAA7134_BOARD_PINNACLE_PCTV_310i: 918 dev->init_data.name = "Pinnacle PCTV"; 919 if (pinnacle_remote == 0) { 920 dev->init_data.get_key = get_key_pinnacle_color; 921 dev->init_data.ir_codes = RC_MAP_PINNACLE_COLOR; 922 info.addr = 0x47; 923 } else { 924 dev->init_data.get_key = get_key_pinnacle_grey; 925 dev->init_data.ir_codes = RC_MAP_PINNACLE_GREY; 926 info.addr = 0x47; 927 } 928 break; 929 case SAA7134_BOARD_UPMOST_PURPLE_TV: 930 dev->init_data.name = "Purple TV"; 931 dev->init_data.get_key = get_key_purpletv; 932 dev->init_data.ir_codes = RC_MAP_PURPLETV; 933 info.addr = 0x7a; 934 break; 935 case SAA7134_BOARD_MSI_TVATANYWHERE_PLUS: 936 dev->init_data.name = "MSI TV@nywhere Plus"; 937 dev->init_data.get_key = get_key_msi_tvanywhere_plus; 938 dev->init_data.ir_codes = RC_MAP_MSI_TVANYWHERE_PLUS; 939 /* 940 * MSI TV@nyware Plus requires more frequent polling 941 * otherwise it will miss some keypresses 942 */ 943 dev->init_data.polling_interval = 50; 944 info.addr = 0x30; 945 /* MSI TV@nywhere Plus controller doesn't seem to 946 respond to probes unless we read something from 947 an existing device. Weird... 948 REVISIT: might no longer be needed */ 949 rc = i2c_transfer(&dev->i2c_adap, &msg_msi, 1); 950 dprintk("probe 0x%02x @ %s: %s\n", 951 msg_msi.addr, dev->i2c_adap.name, 952 (1 == rc) ? "yes" : "no"); 953 break; 954 case SAA7134_BOARD_KWORLD_PC150U: 955 /* copied and modified from MSI TV@nywhere Plus */ 956 dev->init_data.name = "Kworld PC150-U"; 957 dev->init_data.get_key = get_key_kworld_pc150u; 958 dev->init_data.ir_codes = RC_MAP_KWORLD_PC150U; 959 info.addr = 0x30; 960 /* MSI TV@nywhere Plus controller doesn't seem to 961 respond to probes unless we read something from 962 an existing device. Weird... 963 REVISIT: might no longer be needed */ 964 rc = i2c_transfer(&dev->i2c_adap, &msg_msi, 1); 965 dprintk("probe 0x%02x @ %s: %s\n", 966 msg_msi.addr, dev->i2c_adap.name, 967 (1 == rc) ? "yes" : "no"); 968 break; 969 case SAA7134_BOARD_HAUPPAUGE_HVR1110: 970 dev->init_data.name = "HVR 1110"; 971 dev->init_data.get_key = get_key_hvr1110; 972 dev->init_data.ir_codes = RC_MAP_HAUPPAUGE; 973 info.addr = 0x71; 974 break; 975 case SAA7134_BOARD_BEHOLD_607FM_MK3: 976 case SAA7134_BOARD_BEHOLD_607FM_MK5: 977 case SAA7134_BOARD_BEHOLD_609FM_MK3: 978 case SAA7134_BOARD_BEHOLD_609FM_MK5: 979 case SAA7134_BOARD_BEHOLD_607RDS_MK3: 980 case SAA7134_BOARD_BEHOLD_607RDS_MK5: 981 case SAA7134_BOARD_BEHOLD_609RDS_MK3: 982 case SAA7134_BOARD_BEHOLD_609RDS_MK5: 983 case SAA7134_BOARD_BEHOLD_M6: 984 case SAA7134_BOARD_BEHOLD_M63: 985 case SAA7134_BOARD_BEHOLD_M6_EXTRA: 986 case SAA7134_BOARD_BEHOLD_H6: 987 case SAA7134_BOARD_BEHOLD_X7: 988 case SAA7134_BOARD_BEHOLD_H7: 989 case SAA7134_BOARD_BEHOLD_A7: 990 dev->init_data.name = "BeholdTV"; 991 dev->init_data.get_key = get_key_beholdm6xx; 992 dev->init_data.ir_codes = RC_MAP_BEHOLD; 993 dev->init_data.type = RC_BIT_NEC; 994 info.addr = 0x2d; 995 break; 996 case SAA7134_BOARD_AVERMEDIA_CARDBUS_501: 997 case SAA7134_BOARD_AVERMEDIA_CARDBUS_506: 998 info.addr = 0x40; 999 break; 1000 case SAA7134_BOARD_AVERMEDIA_A706: 1001 info.addr = 0x41; 1002 break; 1003 case SAA7134_BOARD_FLYDVB_TRIO: 1004 dev->init_data.name = "FlyDVB Trio"; 1005 dev->init_data.get_key = get_key_flydvb_trio; 1006 dev->init_data.ir_codes = RC_MAP_FLYDVB; 1007 info.addr = 0x0b; 1008 break; 1009 default: 1010 dprintk("No I2C IR support for board %x\n", dev->board); 1011 return; 1012 } 1013 1014 if (dev->init_data.name) 1015 info.platform_data = &dev->init_data; 1016 i2c_new_device(&dev->i2c_adap, &info); 1017 } 1018 1019 static int saa7134_raw_decode_irq(struct saa7134_dev *dev) 1020 { 1021 struct saa7134_card_ir *ir = dev->remote; 1022 unsigned long timeout; 1023 int space; 1024 1025 /* Generate initial event */ 1026 saa_clearb(SAA7134_GPIO_GPMODE3, SAA7134_GPIO_GPRESCAN); 1027 saa_setb(SAA7134_GPIO_GPMODE3, SAA7134_GPIO_GPRESCAN); 1028 space = saa_readl(SAA7134_GPIO_GPSTATUS0 >> 2) & ir->mask_keydown; 1029 ir_raw_event_store_edge(dev->remote->dev, space ? IR_SPACE : IR_PULSE); 1030 1031 /* 1032 * Wait 15 ms from the start of the first IR event before processing 1033 * the event. This time is enough for NEC protocol. May need adjustments 1034 * to work with other protocols. 1035 */ 1036 smp_mb(); 1037 1038 if (!timer_pending(&ir->timer)) { 1039 timeout = jiffies + msecs_to_jiffies(15); 1040 mod_timer(&ir->timer, timeout); 1041 } 1042 1043 return 1; 1044 } 1045