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