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