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 "em28xx.h" 25 26 #include <linux/module.h> 27 #include <linux/init.h> 28 #include <linux/delay.h> 29 #include <linux/interrupt.h> 30 #include <linux/usb.h> 31 #include <linux/slab.h> 32 #include <linux/bitrev.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...) do { \ 45 if (ir_debug) \ 46 dev_printk(KERN_DEBUG, &ir->dev->intf->dev, \ 47 "input: %s: " fmt, __func__, ## arg); \ 48 } while (0) 49 50 /********************************************************** 51 Polling structure used by em28xx IR's 52 **********************************************************/ 53 54 struct em28xx_ir_poll_result { 55 unsigned int toggle_bit:1; 56 unsigned int read_count:7; 57 58 enum rc_type protocol; 59 u32 scancode; 60 }; 61 62 struct em28xx_IR { 63 struct em28xx *dev; 64 struct rc_dev *rc; 65 char name[32]; 66 char phys[32]; 67 68 /* poll decoder */ 69 int polling; 70 struct delayed_work work; 71 unsigned int full_code:1; 72 unsigned int last_readcount; 73 u64 rc_type; 74 75 struct i2c_client *i2c_client; 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 static u32 scancode; 298 enum rc_type protocol; 299 int rc; 300 301 rc = ir->get_key_i2c(ir->i2c_client, &protocol, &scancode); 302 if (rc < 0) { 303 dprintk("ir->get_key_i2c() failed: %d\n", rc); 304 return rc; 305 } 306 307 if (rc) { 308 dprintk("%s: proto = 0x%04x, scancode = 0x%04x\n", 309 __func__, protocol, scancode); 310 rc_keydown(ir->rc, protocol, scancode, 0); 311 } 312 return 0; 313 } 314 315 static void em28xx_ir_handle_key(struct em28xx_IR *ir) 316 { 317 int result; 318 struct em28xx_ir_poll_result poll_result; 319 320 /* read the registers containing the IR status */ 321 result = ir->get_key(ir, &poll_result); 322 if (unlikely(result < 0)) { 323 dprintk("ir->get_key() failed: %d\n", result); 324 return; 325 } 326 327 if (unlikely(poll_result.read_count != ir->last_readcount)) { 328 dprintk("%s: toggle: %d, count: %d, key 0x%04x\n", __func__, 329 poll_result.toggle_bit, poll_result.read_count, 330 poll_result.scancode); 331 if (ir->full_code) 332 rc_keydown(ir->rc, 333 poll_result.protocol, 334 poll_result.scancode, 335 poll_result.toggle_bit); 336 else 337 rc_keydown(ir->rc, 338 RC_TYPE_UNKNOWN, 339 poll_result.scancode & 0xff, 340 poll_result.toggle_bit); 341 342 if (ir->dev->chip_id == CHIP_ID_EM2874 || 343 ir->dev->chip_id == CHIP_ID_EM2884) 344 /* The em2874 clears the readcount field every time the 345 register is read. The em2860/2880 datasheet says that it 346 is supposed to clear the readcount, but it doesn't. So with 347 the em2874, we are looking for a non-zero read count as 348 opposed to a readcount that is incrementing */ 349 ir->last_readcount = 0; 350 else 351 ir->last_readcount = poll_result.read_count; 352 } 353 } 354 355 static void em28xx_ir_work(struct work_struct *work) 356 { 357 struct em28xx_IR *ir = container_of(work, struct em28xx_IR, work.work); 358 359 if (ir->i2c_client) /* external i2c device */ 360 em28xx_i2c_ir_handle_key(ir); 361 else /* internal device */ 362 em28xx_ir_handle_key(ir); 363 schedule_delayed_work(&ir->work, msecs_to_jiffies(ir->polling)); 364 } 365 366 static int em28xx_ir_start(struct rc_dev *rc) 367 { 368 struct em28xx_IR *ir = rc->priv; 369 370 INIT_DELAYED_WORK(&ir->work, em28xx_ir_work); 371 schedule_delayed_work(&ir->work, 0); 372 373 return 0; 374 } 375 376 static void em28xx_ir_stop(struct rc_dev *rc) 377 { 378 struct em28xx_IR *ir = rc->priv; 379 380 cancel_delayed_work_sync(&ir->work); 381 } 382 383 static int em2860_ir_change_protocol(struct rc_dev *rc_dev, u64 *rc_type) 384 { 385 struct em28xx_IR *ir = rc_dev->priv; 386 struct em28xx *dev = ir->dev; 387 388 /* Adjust xclk based on IR table for RC5/NEC tables */ 389 if (*rc_type & RC_BIT_RC5) { 390 dev->board.xclk |= EM28XX_XCLK_IR_RC5_MODE; 391 ir->full_code = 1; 392 *rc_type = RC_BIT_RC5; 393 } else if (*rc_type & RC_BIT_NEC) { 394 dev->board.xclk &= ~EM28XX_XCLK_IR_RC5_MODE; 395 ir->full_code = 1; 396 *rc_type = RC_BIT_NEC; 397 } else if (*rc_type & RC_BIT_UNKNOWN) { 398 *rc_type = RC_BIT_UNKNOWN; 399 } else { 400 *rc_type = ir->rc_type; 401 return -EINVAL; 402 } 403 em28xx_write_reg_bits(dev, EM28XX_R0F_XCLK, dev->board.xclk, 404 EM28XX_XCLK_IR_RC5_MODE); 405 406 ir->rc_type = *rc_type; 407 408 return 0; 409 } 410 411 static int em2874_ir_change_protocol(struct rc_dev *rc_dev, u64 *rc_type) 412 { 413 struct em28xx_IR *ir = rc_dev->priv; 414 struct em28xx *dev = ir->dev; 415 u8 ir_config = EM2874_IR_RC5; 416 417 /* Adjust xclk and set type based on IR table for RC5/NEC/RC6 tables */ 418 if (*rc_type & RC_BIT_RC5) { 419 dev->board.xclk |= EM28XX_XCLK_IR_RC5_MODE; 420 ir->full_code = 1; 421 *rc_type = RC_BIT_RC5; 422 } else if (*rc_type & RC_BIT_NEC) { 423 dev->board.xclk &= ~EM28XX_XCLK_IR_RC5_MODE; 424 ir_config = EM2874_IR_NEC | EM2874_IR_NEC_NO_PARITY; 425 ir->full_code = 1; 426 *rc_type = RC_BIT_NEC; 427 } else if (*rc_type & RC_BIT_RC6_0) { 428 dev->board.xclk |= EM28XX_XCLK_IR_RC5_MODE; 429 ir_config = EM2874_IR_RC6_MODE_0; 430 ir->full_code = 1; 431 *rc_type = RC_BIT_RC6_0; 432 } else if (*rc_type & RC_BIT_UNKNOWN) { 433 *rc_type = RC_BIT_UNKNOWN; 434 } else { 435 *rc_type = ir->rc_type; 436 return -EINVAL; 437 } 438 em28xx_write_regs(dev, EM2874_R50_IR_CONFIG, &ir_config, 1); 439 em28xx_write_reg_bits(dev, EM28XX_R0F_XCLK, dev->board.xclk, 440 EM28XX_XCLK_IR_RC5_MODE); 441 442 ir->rc_type = *rc_type; 443 444 return 0; 445 } 446 static int em28xx_ir_change_protocol(struct rc_dev *rc_dev, u64 *rc_type) 447 { 448 struct em28xx_IR *ir = rc_dev->priv; 449 struct em28xx *dev = ir->dev; 450 451 /* Setup the proper handler based on the chip */ 452 switch (dev->chip_id) { 453 case CHIP_ID_EM2860: 454 case CHIP_ID_EM2883: 455 return em2860_ir_change_protocol(rc_dev, rc_type); 456 case CHIP_ID_EM2884: 457 case CHIP_ID_EM2874: 458 case CHIP_ID_EM28174: 459 case CHIP_ID_EM28178: 460 return em2874_ir_change_protocol(rc_dev, rc_type); 461 default: 462 dev_err(&ir->dev->intf->dev, 463 "Unrecognized em28xx chip id 0x%02x: IR not supported\n", 464 dev->chip_id); 465 return -EINVAL; 466 } 467 } 468 469 static int em28xx_probe_i2c_ir(struct em28xx *dev) 470 { 471 int i = 0; 472 /* Leadtek winfast tv USBII deluxe can find a non working IR-device */ 473 /* at address 0x18, so if that address is needed for another board in */ 474 /* the future, please put it after 0x1f. */ 475 const unsigned short addr_list[] = { 476 0x1f, 0x30, 0x47, I2C_CLIENT_END 477 }; 478 479 while (addr_list[i] != I2C_CLIENT_END) { 480 if (i2c_probe_func_quick_read(&dev->i2c_adap[dev->def_i2c_bus], addr_list[i]) == 1) 481 return addr_list[i]; 482 i++; 483 } 484 485 return -ENODEV; 486 } 487 488 /********************************************************** 489 Handle buttons 490 **********************************************************/ 491 492 static void em28xx_query_buttons(struct work_struct *work) 493 { 494 struct em28xx *dev = 495 container_of(work, struct em28xx, buttons_query_work.work); 496 u8 i, j; 497 int regval; 498 bool is_pressed, was_pressed; 499 const struct em28xx_led *led; 500 501 /* Poll and evaluate all addresses */ 502 for (i = 0; i < dev->num_button_polling_addresses; i++) { 503 /* Read value from register */ 504 regval = em28xx_read_reg(dev, dev->button_polling_addresses[i]); 505 if (regval < 0) 506 continue; 507 /* Check states of the buttons and act */ 508 j = 0; 509 while (dev->board.buttons[j].role >= 0 && 510 dev->board.buttons[j].role < EM28XX_NUM_BUTTON_ROLES) { 511 struct em28xx_button *button = &dev->board.buttons[j]; 512 /* Check if button uses the current address */ 513 if (button->reg_r != dev->button_polling_addresses[i]) { 514 j++; 515 continue; 516 } 517 /* Determine if button is and was pressed last time */ 518 is_pressed = regval & button->mask; 519 was_pressed = dev->button_polling_last_values[i] 520 & button->mask; 521 if (button->inverted) { 522 is_pressed = !is_pressed; 523 was_pressed = !was_pressed; 524 } 525 /* Clear button state (if needed) */ 526 if (is_pressed && button->reg_clearing) 527 em28xx_write_reg(dev, button->reg_clearing, 528 (~regval & button->mask) 529 | (regval & ~button->mask)); 530 /* Handle button state */ 531 if (!is_pressed || was_pressed) { 532 j++; 533 continue; 534 } 535 switch (button->role) { 536 case EM28XX_BUTTON_SNAPSHOT: 537 /* Emulate the keypress */ 538 input_report_key(dev->sbutton_input_dev, 539 EM28XX_SNAPSHOT_KEY, 1); 540 /* Unpress the key */ 541 input_report_key(dev->sbutton_input_dev, 542 EM28XX_SNAPSHOT_KEY, 0); 543 break; 544 case EM28XX_BUTTON_ILLUMINATION: 545 led = em28xx_find_led(dev, 546 EM28XX_LED_ILLUMINATION); 547 /* Switch illumination LED on/off */ 548 if (led) 549 em28xx_toggle_reg_bits(dev, 550 led->gpio_reg, 551 led->gpio_mask); 552 break; 553 default: 554 WARN_ONCE(1, "BUG: unhandled button role."); 555 } 556 /* Next button */ 557 j++; 558 } 559 /* Save current value for comparison during the next polling */ 560 dev->button_polling_last_values[i] = regval; 561 } 562 /* Schedule next poll */ 563 schedule_delayed_work(&dev->buttons_query_work, 564 msecs_to_jiffies(dev->button_polling_interval)); 565 } 566 567 static int em28xx_register_snapshot_button(struct em28xx *dev) 568 { 569 struct usb_device *udev = interface_to_usbdev(dev->intf); 570 struct input_dev *input_dev; 571 int err; 572 573 dev_info(&dev->intf->dev, "Registering snapshot button...\n"); 574 input_dev = input_allocate_device(); 575 if (!input_dev) 576 return -ENOMEM; 577 578 usb_make_path(udev, dev->snapshot_button_path, 579 sizeof(dev->snapshot_button_path)); 580 strlcat(dev->snapshot_button_path, "/sbutton", 581 sizeof(dev->snapshot_button_path)); 582 583 input_dev->name = "em28xx snapshot button"; 584 input_dev->phys = dev->snapshot_button_path; 585 input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP); 586 set_bit(EM28XX_SNAPSHOT_KEY, input_dev->keybit); 587 input_dev->keycodesize = 0; 588 input_dev->keycodemax = 0; 589 input_dev->id.bustype = BUS_USB; 590 input_dev->id.vendor = le16_to_cpu(udev->descriptor.idVendor); 591 input_dev->id.product = le16_to_cpu(udev->descriptor.idProduct); 592 input_dev->id.version = 1; 593 input_dev->dev.parent = &dev->intf->dev; 594 595 err = input_register_device(input_dev); 596 if (err) { 597 dev_err(&dev->intf->dev, "input_register_device failed\n"); 598 input_free_device(input_dev); 599 return err; 600 } 601 602 dev->sbutton_input_dev = input_dev; 603 return 0; 604 } 605 606 static void em28xx_init_buttons(struct em28xx *dev) 607 { 608 u8 i = 0, j = 0; 609 bool addr_new = false; 610 611 dev->button_polling_interval = EM28XX_BUTTONS_DEBOUNCED_QUERY_INTERVAL; 612 while (dev->board.buttons[i].role >= 0 && 613 dev->board.buttons[i].role < EM28XX_NUM_BUTTON_ROLES) { 614 struct em28xx_button *button = &dev->board.buttons[i]; 615 /* Check if polling address is already on the list */ 616 addr_new = true; 617 for (j = 0; j < dev->num_button_polling_addresses; j++) { 618 if (button->reg_r == dev->button_polling_addresses[j]) { 619 addr_new = false; 620 break; 621 } 622 } 623 /* Check if max. number of polling addresses is exceeded */ 624 if (addr_new && dev->num_button_polling_addresses 625 >= EM28XX_NUM_BUTTON_ADDRESSES_MAX) { 626 WARN_ONCE(1, "BUG: maximum number of button polling addresses exceeded."); 627 goto next_button; 628 } 629 /* Button role specific checks and actions */ 630 if (button->role == EM28XX_BUTTON_SNAPSHOT) { 631 /* Register input device */ 632 if (em28xx_register_snapshot_button(dev) < 0) 633 goto next_button; 634 } else if (button->role == EM28XX_BUTTON_ILLUMINATION) { 635 /* Check sanity */ 636 if (!em28xx_find_led(dev, EM28XX_LED_ILLUMINATION)) { 637 dev_err(&dev->intf->dev, 638 "BUG: illumination button defined, but no illumination LED.\n"); 639 goto next_button; 640 } 641 } 642 /* Add read address to list of polling addresses */ 643 if (addr_new) { 644 unsigned int index = dev->num_button_polling_addresses; 645 dev->button_polling_addresses[index] = button->reg_r; 646 dev->num_button_polling_addresses++; 647 } 648 /* Reduce polling interval if necessary */ 649 if (!button->reg_clearing) 650 dev->button_polling_interval = 651 EM28XX_BUTTONS_VOLATILE_QUERY_INTERVAL; 652 next_button: 653 /* Next button */ 654 i++; 655 } 656 657 /* Start polling */ 658 if (dev->num_button_polling_addresses) { 659 memset(dev->button_polling_last_values, 0, 660 EM28XX_NUM_BUTTON_ADDRESSES_MAX); 661 schedule_delayed_work(&dev->buttons_query_work, 662 msecs_to_jiffies(dev->button_polling_interval)); 663 } 664 } 665 666 static void em28xx_shutdown_buttons(struct em28xx *dev) 667 { 668 /* Cancel polling */ 669 cancel_delayed_work_sync(&dev->buttons_query_work); 670 /* Clear polling addresses list */ 671 dev->num_button_polling_addresses = 0; 672 /* Deregister input devices */ 673 if (dev->sbutton_input_dev != NULL) { 674 dev_info(&dev->intf->dev, "Deregistering snapshot button\n"); 675 input_unregister_device(dev->sbutton_input_dev); 676 dev->sbutton_input_dev = NULL; 677 } 678 } 679 680 static int em28xx_ir_init(struct em28xx *dev) 681 { 682 struct usb_device *udev = interface_to_usbdev(dev->intf); 683 struct em28xx_IR *ir; 684 struct rc_dev *rc; 685 int err = -ENOMEM; 686 u64 rc_type; 687 u16 i2c_rc_dev_addr = 0; 688 689 if (dev->is_audio_only) { 690 /* Shouldn't initialize IR for this interface */ 691 return 0; 692 } 693 694 kref_get(&dev->ref); 695 INIT_DELAYED_WORK(&dev->buttons_query_work, em28xx_query_buttons); 696 697 if (dev->board.buttons) 698 em28xx_init_buttons(dev); 699 700 if (dev->board.has_ir_i2c) { 701 i2c_rc_dev_addr = em28xx_probe_i2c_ir(dev); 702 if (!i2c_rc_dev_addr) { 703 dev->board.has_ir_i2c = 0; 704 dev_warn(&dev->intf->dev, 705 "No i2c IR remote control device found.\n"); 706 return -ENODEV; 707 } 708 } 709 710 if (dev->board.ir_codes == NULL && !dev->board.has_ir_i2c) { 711 /* No remote control support */ 712 dev_warn(&dev->intf->dev, 713 "Remote control support is not available for this card.\n"); 714 return 0; 715 } 716 717 dev_info(&dev->intf->dev, "Registering input extension\n"); 718 719 ir = kzalloc(sizeof(*ir), GFP_KERNEL); 720 if (!ir) 721 return -ENOMEM; 722 rc = rc_allocate_device(); 723 if (!rc) 724 goto error; 725 726 /* record handles to ourself */ 727 ir->dev = dev; 728 dev->ir = ir; 729 ir->rc = rc; 730 731 rc->priv = ir; 732 rc->open = em28xx_ir_start; 733 rc->close = em28xx_ir_stop; 734 735 if (dev->board.has_ir_i2c) { /* external i2c device */ 736 switch (dev->model) { 737 case EM2800_BOARD_TERRATEC_CINERGY_200: 738 case EM2820_BOARD_TERRATEC_CINERGY_250: 739 rc->map_name = RC_MAP_EM_TERRATEC; 740 ir->get_key_i2c = em28xx_get_key_terratec; 741 break; 742 case EM2820_BOARD_PINNACLE_USB_2: 743 rc->map_name = RC_MAP_PINNACLE_GREY; 744 ir->get_key_i2c = em28xx_get_key_pinnacle_usb_grey; 745 break; 746 case EM2820_BOARD_HAUPPAUGE_WINTV_USB_2: 747 rc->map_name = RC_MAP_HAUPPAUGE; 748 ir->get_key_i2c = em28xx_get_key_em_haup; 749 rc->allowed_protocols = RC_BIT_RC5; 750 break; 751 case EM2820_BOARD_LEADTEK_WINFAST_USBII_DELUXE: 752 rc->map_name = RC_MAP_WINFAST_USBII_DELUXE; 753 ir->get_key_i2c = em28xx_get_key_winfast_usbii_deluxe; 754 break; 755 default: 756 err = -ENODEV; 757 goto error; 758 } 759 760 ir->i2c_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL); 761 if (!ir->i2c_client) 762 goto error; 763 ir->i2c_client->adapter = &ir->dev->i2c_adap[dev->def_i2c_bus]; 764 ir->i2c_client->addr = i2c_rc_dev_addr; 765 ir->i2c_client->flags = 0; 766 /* NOTE: all other fields of i2c_client are unused */ 767 } else { /* internal device */ 768 switch (dev->chip_id) { 769 case CHIP_ID_EM2860: 770 case CHIP_ID_EM2883: 771 rc->allowed_protocols = RC_BIT_RC5 | RC_BIT_NEC; 772 ir->get_key = default_polling_getkey; 773 break; 774 case CHIP_ID_EM2884: 775 case CHIP_ID_EM2874: 776 case CHIP_ID_EM28174: 777 case CHIP_ID_EM28178: 778 ir->get_key = em2874_polling_getkey; 779 rc->allowed_protocols = RC_BIT_RC5 | RC_BIT_NEC | 780 RC_BIT_RC6_0; 781 break; 782 default: 783 err = -ENODEV; 784 goto error; 785 } 786 787 rc->change_protocol = em28xx_ir_change_protocol; 788 rc->map_name = dev->board.ir_codes; 789 790 /* By default, keep protocol field untouched */ 791 rc_type = RC_BIT_UNKNOWN; 792 err = em28xx_ir_change_protocol(rc, &rc_type); 793 if (err) 794 goto error; 795 } 796 797 /* This is how often we ask the chip for IR information */ 798 ir->polling = 100; /* ms */ 799 800 /* init input device */ 801 snprintf(ir->name, sizeof(ir->name), "%s IR", 802 dev_name(&dev->intf->dev)); 803 804 usb_make_path(udev, ir->phys, sizeof(ir->phys)); 805 strlcat(ir->phys, "/input0", sizeof(ir->phys)); 806 807 rc->input_name = ir->name; 808 rc->input_phys = ir->phys; 809 rc->input_id.bustype = BUS_USB; 810 rc->input_id.version = 1; 811 rc->input_id.vendor = le16_to_cpu(udev->descriptor.idVendor); 812 rc->input_id.product = le16_to_cpu(udev->descriptor.idProduct); 813 rc->dev.parent = &dev->intf->dev; 814 rc->driver_name = MODULE_NAME; 815 816 /* all done */ 817 err = rc_register_device(rc); 818 if (err) 819 goto error; 820 821 dev_info(&dev->intf->dev, "Input extension successfully initalized\n"); 822 823 return 0; 824 825 error: 826 kfree(ir->i2c_client); 827 dev->ir = NULL; 828 rc_free_device(rc); 829 kfree(ir); 830 return err; 831 } 832 833 static int em28xx_ir_fini(struct em28xx *dev) 834 { 835 struct em28xx_IR *ir = dev->ir; 836 837 if (dev->is_audio_only) { 838 /* Shouldn't initialize IR for this interface */ 839 return 0; 840 } 841 842 dev_info(&dev->intf->dev, "Closing input extension\n"); 843 844 em28xx_shutdown_buttons(dev); 845 846 /* skip detach on non attached boards */ 847 if (!ir) 848 goto ref_put; 849 850 rc_unregister_device(ir->rc); 851 852 kfree(ir->i2c_client); 853 854 /* done */ 855 kfree(ir); 856 dev->ir = NULL; 857 858 ref_put: 859 kref_put(&dev->ref, em28xx_free_device); 860 861 return 0; 862 } 863 864 static int em28xx_ir_suspend(struct em28xx *dev) 865 { 866 struct em28xx_IR *ir = dev->ir; 867 868 if (dev->is_audio_only) 869 return 0; 870 871 dev_info(&dev->intf->dev, "Suspending input extension\n"); 872 if (ir) 873 cancel_delayed_work_sync(&ir->work); 874 cancel_delayed_work_sync(&dev->buttons_query_work); 875 /* is canceling delayed work sufficient or does the rc event 876 kthread needs stopping? kthread is stopped in 877 ir_raw_event_unregister() */ 878 return 0; 879 } 880 881 static int em28xx_ir_resume(struct em28xx *dev) 882 { 883 struct em28xx_IR *ir = dev->ir; 884 885 if (dev->is_audio_only) 886 return 0; 887 888 dev_info(&dev->intf->dev, "Resuming input extension\n"); 889 /* if suspend calls ir_raw_event_unregister(), the should call 890 ir_raw_event_register() */ 891 if (ir) 892 schedule_delayed_work(&ir->work, msecs_to_jiffies(ir->polling)); 893 if (dev->num_button_polling_addresses) 894 schedule_delayed_work(&dev->buttons_query_work, 895 msecs_to_jiffies(dev->button_polling_interval)); 896 return 0; 897 } 898 899 static struct em28xx_ops rc_ops = { 900 .id = EM28XX_RC, 901 .name = "Em28xx Input Extension", 902 .init = em28xx_ir_init, 903 .fini = em28xx_ir_fini, 904 .suspend = em28xx_ir_suspend, 905 .resume = em28xx_ir_resume, 906 }; 907 908 static int __init em28xx_rc_register(void) 909 { 910 return em28xx_register_extension(&rc_ops); 911 } 912 913 static void __exit em28xx_rc_unregister(void) 914 { 915 em28xx_unregister_extension(&rc_ops); 916 } 917 918 MODULE_LICENSE("GPL"); 919 MODULE_AUTHOR("Mauro Carvalho Chehab"); 920 MODULE_DESCRIPTION(DRIVER_DESC " - input interface"); 921 MODULE_VERSION(EM28XX_VERSION); 922 923 module_init(em28xx_rc_register); 924 module_exit(em28xx_rc_unregister); 925