1 /* 2 handle em28xx IR remotes via linux kernel input layer. 3 4 Copyright (C) 2005 Ludovico Cavedon <cavedon@sssup.it> 5 Markus Rechberger <mrechberger@gmail.com> 6 Mauro Carvalho Chehab <mchehab@infradead.org> 7 Sascha Sommer <saschasommer@freenet.de> 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 2 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program; if not, write to the Free Software 21 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 22 */ 23 24 #include <linux/module.h> 25 #include <linux/init.h> 26 #include <linux/delay.h> 27 #include <linux/interrupt.h> 28 #include <linux/usb.h> 29 #include <linux/slab.h> 30 #include <linux/bitrev.h> 31 32 #include "em28xx.h" 33 34 #define EM28XX_SNAPSHOT_KEY KEY_CAMERA 35 #define EM28XX_BUTTONS_DEBOUNCED_QUERY_INTERVAL 500 /* [ms] */ 36 #define EM28XX_BUTTONS_VOLATILE_QUERY_INTERVAL 100 /* [ms] */ 37 38 static unsigned int ir_debug; 39 module_param(ir_debug, int, 0644); 40 MODULE_PARM_DESC(ir_debug, "enable debug messages [IR]"); 41 42 #define MODULE_NAME "em28xx" 43 44 #define dprintk(fmt, arg...) \ 45 if (ir_debug) { \ 46 printk(KERN_DEBUG "%s/ir: " fmt, ir->name , ## arg); \ 47 } 48 49 /********************************************************** 50 Polling structure used by em28xx IR's 51 **********************************************************/ 52 53 struct em28xx_ir_poll_result { 54 unsigned int toggle_bit:1; 55 unsigned int read_count:7; 56 57 enum rc_type protocol; 58 u32 scancode; 59 }; 60 61 struct em28xx_IR { 62 struct em28xx *dev; 63 struct rc_dev *rc; 64 char name[32]; 65 char phys[32]; 66 67 /* poll decoder */ 68 int polling; 69 struct delayed_work work; 70 unsigned int full_code:1; 71 unsigned int last_readcount; 72 u64 rc_type; 73 74 /* i2c slave address of external device (if used) */ 75 u16 i2c_dev_addr; 76 77 int (*get_key_i2c)(struct i2c_client *ir, enum rc_type *protocol, u32 *scancode); 78 int (*get_key)(struct em28xx_IR *, struct em28xx_ir_poll_result *); 79 }; 80 81 /********************************************************** 82 I2C IR based get keycodes - should be used with ir-kbd-i2c 83 **********************************************************/ 84 85 static int em28xx_get_key_terratec(struct i2c_client *i2c_dev, 86 enum rc_type *protocol, u32 *scancode) 87 { 88 unsigned char b; 89 90 /* poll IR chip */ 91 if (1 != i2c_master_recv(i2c_dev, &b, 1)) 92 return -EIO; 93 94 /* it seems that 0xFE indicates that a button is still hold 95 down, while 0xff indicates that no button is hold down. */ 96 97 if (b == 0xff) 98 return 0; 99 100 if (b == 0xfe) 101 /* keep old data */ 102 return 1; 103 104 *protocol = RC_TYPE_UNKNOWN; 105 *scancode = b; 106 return 1; 107 } 108 109 static int em28xx_get_key_em_haup(struct i2c_client *i2c_dev, 110 enum rc_type *protocol, u32 *scancode) 111 { 112 unsigned char buf[2]; 113 int size; 114 115 /* poll IR chip */ 116 size = i2c_master_recv(i2c_dev, buf, sizeof(buf)); 117 118 if (size != 2) 119 return -EIO; 120 121 /* Does eliminate repeated parity code */ 122 if (buf[1] == 0xff) 123 return 0; 124 125 /* 126 * Rearranges bits to the right order. 127 * The bit order were determined experimentally by using 128 * The original Hauppauge Grey IR and another RC5 that uses addr=0x08 129 * The RC5 code has 14 bits, but we've experimentally determined 130 * the meaning for only 11 bits. 131 * So, the code translation is not complete. Yet, it is enough to 132 * work with the provided RC5 IR. 133 */ 134 *protocol = RC_TYPE_RC5; 135 *scancode = (bitrev8(buf[1]) & 0x1f) << 8 | bitrev8(buf[0]) >> 2; 136 return 1; 137 } 138 139 static int em28xx_get_key_pinnacle_usb_grey(struct i2c_client *i2c_dev, 140 enum rc_type *protocol, u32 *scancode) 141 { 142 unsigned char buf[3]; 143 144 /* poll IR chip */ 145 146 if (3 != i2c_master_recv(i2c_dev, buf, 3)) 147 return -EIO; 148 149 if (buf[0] != 0x00) 150 return 0; 151 152 *protocol = RC_TYPE_UNKNOWN; 153 *scancode = buf[2] & 0x3f; 154 return 1; 155 } 156 157 static int em28xx_get_key_winfast_usbii_deluxe(struct i2c_client *i2c_dev, 158 enum rc_type *protocol, u32 *scancode) 159 { 160 unsigned char subaddr, keydetect, key; 161 162 struct i2c_msg msg[] = { { .addr = i2c_dev->addr, .flags = 0, .buf = &subaddr, .len = 1}, 163 { .addr = i2c_dev->addr, .flags = I2C_M_RD, .buf = &keydetect, .len = 1} }; 164 165 subaddr = 0x10; 166 if (2 != i2c_transfer(i2c_dev->adapter, msg, 2)) 167 return -EIO; 168 if (keydetect == 0x00) 169 return 0; 170 171 subaddr = 0x00; 172 msg[1].buf = &key; 173 if (2 != i2c_transfer(i2c_dev->adapter, msg, 2)) 174 return -EIO; 175 if (key == 0x00) 176 return 0; 177 178 *protocol = RC_TYPE_UNKNOWN; 179 *scancode = key; 180 return 1; 181 } 182 183 /********************************************************** 184 Poll based get keycode functions 185 **********************************************************/ 186 187 /* This is for the em2860/em2880 */ 188 static int default_polling_getkey(struct em28xx_IR *ir, 189 struct em28xx_ir_poll_result *poll_result) 190 { 191 struct em28xx *dev = ir->dev; 192 int rc; 193 u8 msg[3] = { 0, 0, 0 }; 194 195 /* Read key toggle, brand, and key code 196 on registers 0x45, 0x46 and 0x47 197 */ 198 rc = dev->em28xx_read_reg_req_len(dev, 0, EM28XX_R45_IR, 199 msg, sizeof(msg)); 200 if (rc < 0) 201 return rc; 202 203 /* Infrared toggle (Reg 0x45[7]) */ 204 poll_result->toggle_bit = (msg[0] >> 7); 205 206 /* Infrared read count (Reg 0x45[6:0] */ 207 poll_result->read_count = (msg[0] & 0x7f); 208 209 /* Remote Control Address/Data (Regs 0x46/0x47) */ 210 switch (ir->rc_type) { 211 case RC_BIT_RC5: 212 poll_result->protocol = RC_TYPE_RC5; 213 poll_result->scancode = RC_SCANCODE_RC5(msg[1], msg[2]); 214 break; 215 216 case RC_BIT_NEC: 217 poll_result->protocol = RC_TYPE_NEC; 218 poll_result->scancode = RC_SCANCODE_NEC(msg[1], msg[2]); 219 break; 220 221 default: 222 poll_result->protocol = RC_TYPE_UNKNOWN; 223 poll_result->scancode = msg[1] << 8 | msg[2]; 224 break; 225 } 226 227 return 0; 228 } 229 230 static int em2874_polling_getkey(struct em28xx_IR *ir, 231 struct em28xx_ir_poll_result *poll_result) 232 { 233 struct em28xx *dev = ir->dev; 234 int rc; 235 u8 msg[5] = { 0, 0, 0, 0, 0 }; 236 237 /* Read key toggle, brand, and key code 238 on registers 0x51-55 239 */ 240 rc = dev->em28xx_read_reg_req_len(dev, 0, EM2874_R51_IR, 241 msg, sizeof(msg)); 242 if (rc < 0) 243 return rc; 244 245 /* Infrared toggle (Reg 0x51[7]) */ 246 poll_result->toggle_bit = (msg[0] >> 7); 247 248 /* Infrared read count (Reg 0x51[6:0] */ 249 poll_result->read_count = (msg[0] & 0x7f); 250 251 /* 252 * Remote Control Address (Reg 0x52) 253 * Remote Control Data (Reg 0x53-0x55) 254 */ 255 switch (ir->rc_type) { 256 case RC_BIT_RC5: 257 poll_result->protocol = RC_TYPE_RC5; 258 poll_result->scancode = RC_SCANCODE_RC5(msg[1], msg[2]); 259 break; 260 261 case RC_BIT_NEC: 262 poll_result->protocol = RC_TYPE_RC5; 263 poll_result->scancode = msg[1] << 8 | msg[2]; 264 if ((msg[3] ^ msg[4]) != 0xff) /* 32 bits NEC */ 265 poll_result->scancode = RC_SCANCODE_NEC32((msg[1] << 24) | 266 (msg[2] << 16) | 267 (msg[3] << 8) | 268 (msg[4])); 269 else if ((msg[1] ^ msg[2]) != 0xff) /* 24 bits NEC */ 270 poll_result->scancode = RC_SCANCODE_NECX(msg[1] << 8 | 271 msg[2], msg[3]); 272 else /* Normal NEC */ 273 poll_result->scancode = RC_SCANCODE_NEC(msg[1], msg[3]); 274 break; 275 276 case RC_BIT_RC6_0: 277 poll_result->protocol = RC_TYPE_RC6_0; 278 poll_result->scancode = RC_SCANCODE_RC6_0(msg[1], msg[2]); 279 break; 280 281 default: 282 poll_result->protocol = RC_TYPE_UNKNOWN; 283 poll_result->scancode = (msg[1] << 24) | (msg[2] << 16) | 284 (msg[3] << 8) | msg[4]; 285 break; 286 } 287 288 return 0; 289 } 290 291 /********************************************************** 292 Polling code for em28xx 293 **********************************************************/ 294 295 static int em28xx_i2c_ir_handle_key(struct em28xx_IR *ir) 296 { 297 struct em28xx *dev = ir->dev; 298 static u32 scancode; 299 enum rc_type protocol; 300 int rc; 301 struct i2c_client client; 302 303 client.adapter = &ir->dev->i2c_adap[dev->def_i2c_bus]; 304 client.addr = ir->i2c_dev_addr; 305 306 rc = ir->get_key_i2c(&client, &protocol, &scancode); 307 if (rc < 0) { 308 dprintk("ir->get_key_i2c() failed: %d\n", rc); 309 return rc; 310 } 311 312 if (rc) { 313 dprintk("%s: proto = 0x%04x, scancode = 0x%04x\n", 314 __func__, protocol, scancode); 315 rc_keydown(ir->rc, protocol, scancode, 0); 316 } 317 return 0; 318 } 319 320 static void em28xx_ir_handle_key(struct em28xx_IR *ir) 321 { 322 int result; 323 struct em28xx_ir_poll_result poll_result; 324 325 /* read the registers containing the IR status */ 326 result = ir->get_key(ir, &poll_result); 327 if (unlikely(result < 0)) { 328 dprintk("ir->get_key() failed: %d\n", result); 329 return; 330 } 331 332 if (unlikely(poll_result.read_count != ir->last_readcount)) { 333 dprintk("%s: toggle: %d, count: %d, key 0x%04x\n", __func__, 334 poll_result.toggle_bit, poll_result.read_count, 335 poll_result.scancode); 336 if (ir->full_code) 337 rc_keydown(ir->rc, 338 poll_result.protocol, 339 poll_result.scancode, 340 poll_result.toggle_bit); 341 else 342 rc_keydown(ir->rc, 343 RC_TYPE_UNKNOWN, 344 poll_result.scancode & 0xff, 345 poll_result.toggle_bit); 346 347 if (ir->dev->chip_id == CHIP_ID_EM2874 || 348 ir->dev->chip_id == CHIP_ID_EM2884) 349 /* The em2874 clears the readcount field every time the 350 register is read. The em2860/2880 datasheet says that it 351 is supposed to clear the readcount, but it doesn't. So with 352 the em2874, we are looking for a non-zero read count as 353 opposed to a readcount that is incrementing */ 354 ir->last_readcount = 0; 355 else 356 ir->last_readcount = poll_result.read_count; 357 } 358 } 359 360 static void em28xx_ir_work(struct work_struct *work) 361 { 362 struct em28xx_IR *ir = container_of(work, struct em28xx_IR, work.work); 363 364 if (ir->i2c_dev_addr) /* external i2c device */ 365 em28xx_i2c_ir_handle_key(ir); 366 else /* internal device */ 367 em28xx_ir_handle_key(ir); 368 schedule_delayed_work(&ir->work, msecs_to_jiffies(ir->polling)); 369 } 370 371 static int em28xx_ir_start(struct rc_dev *rc) 372 { 373 struct em28xx_IR *ir = rc->priv; 374 375 INIT_DELAYED_WORK(&ir->work, em28xx_ir_work); 376 schedule_delayed_work(&ir->work, 0); 377 378 return 0; 379 } 380 381 static void em28xx_ir_stop(struct rc_dev *rc) 382 { 383 struct em28xx_IR *ir = rc->priv; 384 385 cancel_delayed_work_sync(&ir->work); 386 } 387 388 static int em2860_ir_change_protocol(struct rc_dev *rc_dev, u64 *rc_type) 389 { 390 struct em28xx_IR *ir = rc_dev->priv; 391 struct em28xx *dev = ir->dev; 392 393 /* Adjust xclk based on IR table for RC5/NEC tables */ 394 if (*rc_type & RC_BIT_RC5) { 395 dev->board.xclk |= EM28XX_XCLK_IR_RC5_MODE; 396 ir->full_code = 1; 397 *rc_type = RC_BIT_RC5; 398 } else if (*rc_type & RC_BIT_NEC) { 399 dev->board.xclk &= ~EM28XX_XCLK_IR_RC5_MODE; 400 ir->full_code = 1; 401 *rc_type = RC_BIT_NEC; 402 } else if (*rc_type & RC_BIT_UNKNOWN) { 403 *rc_type = RC_BIT_UNKNOWN; 404 } else { 405 *rc_type = ir->rc_type; 406 return -EINVAL; 407 } 408 em28xx_write_reg_bits(dev, EM28XX_R0F_XCLK, dev->board.xclk, 409 EM28XX_XCLK_IR_RC5_MODE); 410 411 ir->rc_type = *rc_type; 412 413 return 0; 414 } 415 416 static int em2874_ir_change_protocol(struct rc_dev *rc_dev, u64 *rc_type) 417 { 418 struct em28xx_IR *ir = rc_dev->priv; 419 struct em28xx *dev = ir->dev; 420 u8 ir_config = EM2874_IR_RC5; 421 422 /* Adjust xclk and set type based on IR table for RC5/NEC/RC6 tables */ 423 if (*rc_type & RC_BIT_RC5) { 424 dev->board.xclk |= EM28XX_XCLK_IR_RC5_MODE; 425 ir->full_code = 1; 426 *rc_type = RC_BIT_RC5; 427 } else if (*rc_type & RC_BIT_NEC) { 428 dev->board.xclk &= ~EM28XX_XCLK_IR_RC5_MODE; 429 ir_config = EM2874_IR_NEC | EM2874_IR_NEC_NO_PARITY; 430 ir->full_code = 1; 431 *rc_type = RC_BIT_NEC; 432 } else if (*rc_type & RC_BIT_RC6_0) { 433 dev->board.xclk |= EM28XX_XCLK_IR_RC5_MODE; 434 ir_config = EM2874_IR_RC6_MODE_0; 435 ir->full_code = 1; 436 *rc_type = RC_BIT_RC6_0; 437 } else if (*rc_type & RC_BIT_UNKNOWN) { 438 *rc_type = RC_BIT_UNKNOWN; 439 } else { 440 *rc_type = ir->rc_type; 441 return -EINVAL; 442 } 443 em28xx_write_regs(dev, EM2874_R50_IR_CONFIG, &ir_config, 1); 444 em28xx_write_reg_bits(dev, EM28XX_R0F_XCLK, dev->board.xclk, 445 EM28XX_XCLK_IR_RC5_MODE); 446 447 ir->rc_type = *rc_type; 448 449 return 0; 450 } 451 static int em28xx_ir_change_protocol(struct rc_dev *rc_dev, u64 *rc_type) 452 { 453 struct em28xx_IR *ir = rc_dev->priv; 454 struct em28xx *dev = ir->dev; 455 456 /* Setup the proper handler based on the chip */ 457 switch (dev->chip_id) { 458 case CHIP_ID_EM2860: 459 case CHIP_ID_EM2883: 460 return em2860_ir_change_protocol(rc_dev, rc_type); 461 case CHIP_ID_EM2884: 462 case CHIP_ID_EM2874: 463 case CHIP_ID_EM28174: 464 case CHIP_ID_EM28178: 465 return em2874_ir_change_protocol(rc_dev, rc_type); 466 default: 467 printk("Unrecognized em28xx chip id 0x%02x: IR not supported\n", 468 dev->chip_id); 469 return -EINVAL; 470 } 471 } 472 473 static int em28xx_probe_i2c_ir(struct em28xx *dev) 474 { 475 int i = 0; 476 /* Leadtek winfast tv USBII deluxe can find a non working IR-device */ 477 /* at address 0x18, so if that address is needed for another board in */ 478 /* the future, please put it after 0x1f. */ 479 const unsigned short addr_list[] = { 480 0x1f, 0x30, 0x47, I2C_CLIENT_END 481 }; 482 483 while (addr_list[i] != I2C_CLIENT_END) { 484 if (i2c_probe_func_quick_read(&dev->i2c_adap[dev->def_i2c_bus], addr_list[i]) == 1) 485 return addr_list[i]; 486 i++; 487 } 488 489 return -ENODEV; 490 } 491 492 /********************************************************** 493 Handle buttons 494 **********************************************************/ 495 496 static void em28xx_query_buttons(struct work_struct *work) 497 { 498 struct em28xx *dev = 499 container_of(work, struct em28xx, buttons_query_work.work); 500 u8 i, j; 501 int regval; 502 bool is_pressed, was_pressed; 503 const struct em28xx_led *led; 504 505 /* Poll and evaluate all addresses */ 506 for (i = 0; i < dev->num_button_polling_addresses; i++) { 507 /* Read value from register */ 508 regval = em28xx_read_reg(dev, dev->button_polling_addresses[i]); 509 if (regval < 0) 510 continue; 511 /* Check states of the buttons and act */ 512 j = 0; 513 while (dev->board.buttons[j].role >= 0 && 514 dev->board.buttons[j].role < EM28XX_NUM_BUTTON_ROLES) { 515 struct em28xx_button *button = &dev->board.buttons[j]; 516 /* Check if button uses the current address */ 517 if (button->reg_r != dev->button_polling_addresses[i]) { 518 j++; 519 continue; 520 } 521 /* Determine if button is and was pressed last time */ 522 is_pressed = regval & button->mask; 523 was_pressed = dev->button_polling_last_values[i] 524 & button->mask; 525 if (button->inverted) { 526 is_pressed = !is_pressed; 527 was_pressed = !was_pressed; 528 } 529 /* Clear button state (if needed) */ 530 if (is_pressed && button->reg_clearing) 531 em28xx_write_reg(dev, button->reg_clearing, 532 (~regval & button->mask) 533 | (regval & ~button->mask)); 534 /* Handle button state */ 535 if (!is_pressed || was_pressed) { 536 j++; 537 continue; 538 } 539 switch (button->role) { 540 case EM28XX_BUTTON_SNAPSHOT: 541 /* Emulate the keypress */ 542 input_report_key(dev->sbutton_input_dev, 543 EM28XX_SNAPSHOT_KEY, 1); 544 /* Unpress the key */ 545 input_report_key(dev->sbutton_input_dev, 546 EM28XX_SNAPSHOT_KEY, 0); 547 break; 548 case EM28XX_BUTTON_ILLUMINATION: 549 led = em28xx_find_led(dev, 550 EM28XX_LED_ILLUMINATION); 551 /* Switch illumination LED on/off */ 552 if (led) 553 em28xx_toggle_reg_bits(dev, 554 led->gpio_reg, 555 led->gpio_mask); 556 break; 557 default: 558 WARN_ONCE(1, "BUG: unhandled button role."); 559 } 560 /* Next button */ 561 j++; 562 } 563 /* Save current value for comparison during the next polling */ 564 dev->button_polling_last_values[i] = regval; 565 } 566 /* Schedule next poll */ 567 schedule_delayed_work(&dev->buttons_query_work, 568 msecs_to_jiffies(dev->button_polling_interval)); 569 } 570 571 static int em28xx_register_snapshot_button(struct em28xx *dev) 572 { 573 struct input_dev *input_dev; 574 int err; 575 576 em28xx_info("Registering snapshot button...\n"); 577 input_dev = input_allocate_device(); 578 if (!input_dev) 579 return -ENOMEM; 580 581 usb_make_path(dev->udev, dev->snapshot_button_path, 582 sizeof(dev->snapshot_button_path)); 583 strlcat(dev->snapshot_button_path, "/sbutton", 584 sizeof(dev->snapshot_button_path)); 585 586 input_dev->name = "em28xx snapshot button"; 587 input_dev->phys = dev->snapshot_button_path; 588 input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP); 589 set_bit(EM28XX_SNAPSHOT_KEY, input_dev->keybit); 590 input_dev->keycodesize = 0; 591 input_dev->keycodemax = 0; 592 input_dev->id.bustype = BUS_USB; 593 input_dev->id.vendor = le16_to_cpu(dev->udev->descriptor.idVendor); 594 input_dev->id.product = le16_to_cpu(dev->udev->descriptor.idProduct); 595 input_dev->id.version = 1; 596 input_dev->dev.parent = &dev->udev->dev; 597 598 err = input_register_device(input_dev); 599 if (err) { 600 em28xx_errdev("input_register_device failed\n"); 601 input_free_device(input_dev); 602 return err; 603 } 604 605 dev->sbutton_input_dev = input_dev; 606 return 0; 607 } 608 609 static void em28xx_init_buttons(struct em28xx *dev) 610 { 611 u8 i = 0, j = 0; 612 bool addr_new = 0; 613 614 dev->button_polling_interval = EM28XX_BUTTONS_DEBOUNCED_QUERY_INTERVAL; 615 while (dev->board.buttons[i].role >= 0 && 616 dev->board.buttons[i].role < EM28XX_NUM_BUTTON_ROLES) { 617 struct em28xx_button *button = &dev->board.buttons[i]; 618 /* Check if polling address is already on the list */ 619 addr_new = 1; 620 for (j = 0; j < dev->num_button_polling_addresses; j++) { 621 if (button->reg_r == dev->button_polling_addresses[j]) { 622 addr_new = 0; 623 break; 624 } 625 } 626 /* Check if max. number of polling addresses is exceeded */ 627 if (addr_new && dev->num_button_polling_addresses 628 >= EM28XX_NUM_BUTTON_ADDRESSES_MAX) { 629 WARN_ONCE(1, "BUG: maximum number of button polling addresses exceeded."); 630 goto next_button; 631 } 632 /* Button role specific checks and actions */ 633 if (button->role == EM28XX_BUTTON_SNAPSHOT) { 634 /* Register input device */ 635 if (em28xx_register_snapshot_button(dev) < 0) 636 goto next_button; 637 } else if (button->role == EM28XX_BUTTON_ILLUMINATION) { 638 /* Check sanity */ 639 if (!em28xx_find_led(dev, EM28XX_LED_ILLUMINATION)) { 640 em28xx_errdev("BUG: illumination button defined, but no illumination LED.\n"); 641 goto next_button; 642 } 643 } 644 /* Add read address to list of polling addresses */ 645 if (addr_new) { 646 unsigned int index = dev->num_button_polling_addresses; 647 dev->button_polling_addresses[index] = button->reg_r; 648 dev->num_button_polling_addresses++; 649 } 650 /* Reduce polling interval if necessary */ 651 if (!button->reg_clearing) 652 dev->button_polling_interval = 653 EM28XX_BUTTONS_VOLATILE_QUERY_INTERVAL; 654 next_button: 655 /* Next button */ 656 i++; 657 } 658 659 /* Start polling */ 660 if (dev->num_button_polling_addresses) { 661 memset(dev->button_polling_last_values, 0, 662 EM28XX_NUM_BUTTON_ADDRESSES_MAX); 663 INIT_DELAYED_WORK(&dev->buttons_query_work, 664 em28xx_query_buttons); 665 schedule_delayed_work(&dev->buttons_query_work, 666 msecs_to_jiffies(dev->button_polling_interval)); 667 } 668 } 669 670 static void em28xx_shutdown_buttons(struct em28xx *dev) 671 { 672 /* Cancel polling */ 673 cancel_delayed_work_sync(&dev->buttons_query_work); 674 /* Clear polling addresses list */ 675 dev->num_button_polling_addresses = 0; 676 /* Deregister input devices */ 677 if (dev->sbutton_input_dev != NULL) { 678 em28xx_info("Deregistering snapshot button\n"); 679 input_unregister_device(dev->sbutton_input_dev); 680 dev->sbutton_input_dev = NULL; 681 } 682 } 683 684 static int em28xx_ir_init(struct em28xx *dev) 685 { 686 struct em28xx_IR *ir; 687 struct rc_dev *rc; 688 int err = -ENOMEM; 689 u64 rc_type; 690 u16 i2c_rc_dev_addr = 0; 691 692 if (dev->is_audio_only) { 693 /* Shouldn't initialize IR for this interface */ 694 return 0; 695 } 696 697 kref_get(&dev->ref); 698 699 if (dev->board.buttons) 700 em28xx_init_buttons(dev); 701 702 if (dev->board.has_ir_i2c) { 703 i2c_rc_dev_addr = em28xx_probe_i2c_ir(dev); 704 if (!i2c_rc_dev_addr) { 705 dev->board.has_ir_i2c = 0; 706 em28xx_warn("No i2c IR remote control device found.\n"); 707 return -ENODEV; 708 } 709 } 710 711 if (dev->board.ir_codes == NULL && !dev->board.has_ir_i2c) { 712 /* No remote control support */ 713 em28xx_warn("Remote control support is not available for " 714 "this card.\n"); 715 return 0; 716 } 717 718 em28xx_info("Registering input extension\n"); 719 720 ir = kzalloc(sizeof(*ir), GFP_KERNEL); 721 rc = rc_allocate_device(); 722 if (!ir || !rc) 723 goto error; 724 725 /* record handles to ourself */ 726 ir->dev = dev; 727 dev->ir = ir; 728 ir->rc = rc; 729 730 rc->priv = ir; 731 rc->open = em28xx_ir_start; 732 rc->close = em28xx_ir_stop; 733 734 if (dev->board.has_ir_i2c) { /* external i2c device */ 735 switch (dev->model) { 736 case EM2800_BOARD_TERRATEC_CINERGY_200: 737 case EM2820_BOARD_TERRATEC_CINERGY_250: 738 rc->map_name = RC_MAP_EM_TERRATEC; 739 ir->get_key_i2c = em28xx_get_key_terratec; 740 break; 741 case EM2820_BOARD_PINNACLE_USB_2: 742 rc->map_name = RC_MAP_PINNACLE_GREY; 743 ir->get_key_i2c = em28xx_get_key_pinnacle_usb_grey; 744 break; 745 case EM2820_BOARD_HAUPPAUGE_WINTV_USB_2: 746 rc->map_name = RC_MAP_HAUPPAUGE; 747 ir->get_key_i2c = em28xx_get_key_em_haup; 748 rc->allowed_protocols = RC_BIT_RC5; 749 break; 750 case EM2820_BOARD_LEADTEK_WINFAST_USBII_DELUXE: 751 rc->map_name = RC_MAP_WINFAST_USBII_DELUXE; 752 ir->get_key_i2c = em28xx_get_key_winfast_usbii_deluxe; 753 break; 754 default: 755 err = -ENODEV; 756 goto error; 757 } 758 759 ir->i2c_dev_addr = i2c_rc_dev_addr; 760 } else { /* internal device */ 761 switch (dev->chip_id) { 762 case CHIP_ID_EM2860: 763 case CHIP_ID_EM2883: 764 rc->allowed_protocols = RC_BIT_RC5 | RC_BIT_NEC; 765 ir->get_key = default_polling_getkey; 766 break; 767 case CHIP_ID_EM2884: 768 case CHIP_ID_EM2874: 769 case CHIP_ID_EM28174: 770 case CHIP_ID_EM28178: 771 ir->get_key = em2874_polling_getkey; 772 rc->allowed_protocols = RC_BIT_RC5 | RC_BIT_NEC | 773 RC_BIT_RC6_0; 774 break; 775 default: 776 err = -ENODEV; 777 goto error; 778 } 779 780 rc->change_protocol = em28xx_ir_change_protocol; 781 rc->map_name = dev->board.ir_codes; 782 783 /* By default, keep protocol field untouched */ 784 rc_type = RC_BIT_UNKNOWN; 785 err = em28xx_ir_change_protocol(rc, &rc_type); 786 if (err) 787 goto error; 788 } 789 790 /* This is how often we ask the chip for IR information */ 791 ir->polling = 100; /* ms */ 792 793 /* init input device */ 794 snprintf(ir->name, sizeof(ir->name), "em28xx IR (%s)", dev->name); 795 796 usb_make_path(dev->udev, ir->phys, sizeof(ir->phys)); 797 strlcat(ir->phys, "/input0", sizeof(ir->phys)); 798 799 rc->input_name = ir->name; 800 rc->input_phys = ir->phys; 801 rc->input_id.bustype = BUS_USB; 802 rc->input_id.version = 1; 803 rc->input_id.vendor = le16_to_cpu(dev->udev->descriptor.idVendor); 804 rc->input_id.product = le16_to_cpu(dev->udev->descriptor.idProduct); 805 rc->dev.parent = &dev->udev->dev; 806 rc->driver_name = MODULE_NAME; 807 808 /* all done */ 809 err = rc_register_device(rc); 810 if (err) 811 goto error; 812 813 em28xx_info("Input extension successfully initalized\n"); 814 815 return 0; 816 817 error: 818 dev->ir = NULL; 819 rc_free_device(rc); 820 kfree(ir); 821 return err; 822 } 823 824 static int em28xx_ir_fini(struct em28xx *dev) 825 { 826 struct em28xx_IR *ir = dev->ir; 827 828 if (dev->is_audio_only) { 829 /* Shouldn't initialize IR for this interface */ 830 return 0; 831 } 832 833 em28xx_info("Closing input extension"); 834 835 em28xx_shutdown_buttons(dev); 836 837 /* skip detach on non attached boards */ 838 if (!ir) 839 goto ref_put; 840 841 if (ir->rc) 842 rc_unregister_device(ir->rc); 843 844 /* done */ 845 kfree(ir); 846 dev->ir = NULL; 847 848 ref_put: 849 kref_put(&dev->ref, em28xx_free_device); 850 851 return 0; 852 } 853 854 static int em28xx_ir_suspend(struct em28xx *dev) 855 { 856 struct em28xx_IR *ir = dev->ir; 857 858 if (dev->is_audio_only) 859 return 0; 860 861 em28xx_info("Suspending input extension"); 862 if (ir) 863 cancel_delayed_work_sync(&ir->work); 864 cancel_delayed_work_sync(&dev->buttons_query_work); 865 /* is canceling delayed work sufficient or does the rc event 866 kthread needs stopping? kthread is stopped in 867 ir_raw_event_unregister() */ 868 return 0; 869 } 870 871 static int em28xx_ir_resume(struct em28xx *dev) 872 { 873 struct em28xx_IR *ir = dev->ir; 874 875 if (dev->is_audio_only) 876 return 0; 877 878 em28xx_info("Resuming input extension"); 879 /* if suspend calls ir_raw_event_unregister(), the should call 880 ir_raw_event_register() */ 881 if (ir) 882 schedule_delayed_work(&ir->work, msecs_to_jiffies(ir->polling)); 883 if (dev->num_button_polling_addresses) 884 schedule_delayed_work(&dev->buttons_query_work, 885 msecs_to_jiffies(dev->button_polling_interval)); 886 return 0; 887 } 888 889 static struct em28xx_ops rc_ops = { 890 .id = EM28XX_RC, 891 .name = "Em28xx Input Extension", 892 .init = em28xx_ir_init, 893 .fini = em28xx_ir_fini, 894 .suspend = em28xx_ir_suspend, 895 .resume = em28xx_ir_resume, 896 }; 897 898 static int __init em28xx_rc_register(void) 899 { 900 return em28xx_register_extension(&rc_ops); 901 } 902 903 static void __exit em28xx_rc_unregister(void) 904 { 905 em28xx_unregister_extension(&rc_ops); 906 } 907 908 MODULE_LICENSE("GPL"); 909 MODULE_AUTHOR("Mauro Carvalho Chehab"); 910 MODULE_DESCRIPTION(DRIVER_DESC " - input interface"); 911 MODULE_VERSION(EM28XX_VERSION); 912 913 module_init(em28xx_rc_register); 914 module_exit(em28xx_rc_unregister); 915