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