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 31 #include "em28xx.h" 32 33 #define EM28XX_SNAPSHOT_KEY KEY_CAMERA 34 #define EM28XX_SBUTTON_QUERY_INTERVAL 500 35 #define EM28XX_R0C_USBSUSP_SNAPSHOT 0x20 36 37 static unsigned int ir_debug; 38 module_param(ir_debug, int, 0644); 39 MODULE_PARM_DESC(ir_debug, "enable debug messages [IR]"); 40 41 #define MODULE_NAME "em28xx" 42 43 #define i2cdprintk(fmt, arg...) \ 44 if (ir_debug) { \ 45 printk(KERN_DEBUG "%s/ir: " fmt, ir->name , ## arg); \ 46 } 47 48 #define dprintk(fmt, arg...) \ 49 if (ir_debug) { \ 50 printk(KERN_DEBUG "%s/ir: " fmt, ir->name , ## arg); \ 51 } 52 53 /********************************************************** 54 Polling structure used by em28xx IR's 55 **********************************************************/ 56 57 struct em28xx_ir_poll_result { 58 unsigned int toggle_bit:1; 59 unsigned int read_count:7; 60 u8 rc_address; 61 u8 rc_data[4]; /* 1 byte on em2860/2880, 4 on em2874 */ 62 }; 63 64 struct em28xx_IR { 65 struct em28xx *dev; 66 struct rc_dev *rc; 67 char name[32]; 68 char phys[32]; 69 70 /* poll external decoder */ 71 int polling; 72 struct delayed_work work; 73 unsigned int full_code:1; 74 unsigned int last_readcount; 75 76 int (*get_key)(struct em28xx_IR *, struct em28xx_ir_poll_result *); 77 }; 78 79 /********************************************************** 80 I2C IR based get keycodes - should be used with ir-kbd-i2c 81 **********************************************************/ 82 83 static int em28xx_get_key_terratec(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw) 84 { 85 unsigned char b; 86 87 /* poll IR chip */ 88 if (1 != i2c_master_recv(ir->c, &b, 1)) { 89 i2cdprintk("read error\n"); 90 return -EIO; 91 } 92 93 /* it seems that 0xFE indicates that a button is still hold 94 down, while 0xff indicates that no button is hold 95 down. 0xfe sequences are sometimes interrupted by 0xFF */ 96 97 i2cdprintk("key %02x\n", b); 98 99 if (b == 0xff) 100 return 0; 101 102 if (b == 0xfe) 103 /* keep old data */ 104 return 1; 105 106 *ir_key = b; 107 *ir_raw = b; 108 return 1; 109 } 110 111 static int em28xx_get_key_em_haup(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw) 112 { 113 unsigned char buf[2]; 114 u16 code; 115 int size; 116 117 /* poll IR chip */ 118 size = i2c_master_recv(ir->c, buf, sizeof(buf)); 119 120 if (size != 2) 121 return -EIO; 122 123 /* Does eliminate repeated parity code */ 124 if (buf[1] == 0xff) 125 return 0; 126 127 ir->old = buf[1]; 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 code = 139 ((buf[0] & 0x01) ? 0x0020 : 0) | /* 0010 0000 */ 140 ((buf[0] & 0x02) ? 0x0010 : 0) | /* 0001 0000 */ 141 ((buf[0] & 0x04) ? 0x0008 : 0) | /* 0000 1000 */ 142 ((buf[0] & 0x08) ? 0x0004 : 0) | /* 0000 0100 */ 143 ((buf[0] & 0x10) ? 0x0002 : 0) | /* 0000 0010 */ 144 ((buf[0] & 0x20) ? 0x0001 : 0) | /* 0000 0001 */ 145 ((buf[1] & 0x08) ? 0x1000 : 0) | /* 0001 0000 */ 146 ((buf[1] & 0x10) ? 0x0800 : 0) | /* 0000 1000 */ 147 ((buf[1] & 0x20) ? 0x0400 : 0) | /* 0000 0100 */ 148 ((buf[1] & 0x40) ? 0x0200 : 0) | /* 0000 0010 */ 149 ((buf[1] & 0x80) ? 0x0100 : 0); /* 0000 0001 */ 150 151 i2cdprintk("ir hauppauge (em2840): code=0x%02x (rcv=0x%02x%02x)\n", 152 code, buf[1], buf[0]); 153 154 /* return key */ 155 *ir_key = code; 156 *ir_raw = code; 157 return 1; 158 } 159 160 static int em28xx_get_key_pinnacle_usb_grey(struct IR_i2c *ir, u32 *ir_key, 161 u32 *ir_raw) 162 { 163 unsigned char buf[3]; 164 165 /* poll IR chip */ 166 167 if (3 != i2c_master_recv(ir->c, buf, 3)) { 168 i2cdprintk("read error\n"); 169 return -EIO; 170 } 171 172 i2cdprintk("key %02x\n", buf[2]&0x3f); 173 if (buf[0] != 0x00) 174 return 0; 175 176 *ir_key = buf[2]&0x3f; 177 *ir_raw = buf[2]&0x3f; 178 179 return 1; 180 } 181 182 static int em28xx_get_key_winfast_usbii_deluxe(struct IR_i2c *ir, u32 *ir_key, 183 u32 *ir_raw) 184 { 185 unsigned char subaddr, keydetect, key; 186 187 struct i2c_msg msg[] = { { .addr = ir->c->addr, .flags = 0, .buf = &subaddr, .len = 1}, 188 189 { .addr = ir->c->addr, .flags = I2C_M_RD, .buf = &keydetect, .len = 1} }; 190 191 subaddr = 0x10; 192 if (2 != i2c_transfer(ir->c->adapter, msg, 2)) { 193 i2cdprintk("read error\n"); 194 return -EIO; 195 } 196 if (keydetect == 0x00) 197 return 0; 198 199 subaddr = 0x00; 200 msg[1].buf = &key; 201 if (2 != i2c_transfer(ir->c->adapter, msg, 2)) { 202 i2cdprintk("read error\n"); 203 return -EIO; 204 } 205 if (key == 0x00) 206 return 0; 207 208 *ir_key = key; 209 *ir_raw = key; 210 return 1; 211 } 212 213 /********************************************************** 214 Poll based get keycode functions 215 **********************************************************/ 216 217 /* This is for the em2860/em2880 */ 218 static int default_polling_getkey(struct em28xx_IR *ir, 219 struct em28xx_ir_poll_result *poll_result) 220 { 221 struct em28xx *dev = ir->dev; 222 int rc; 223 u8 msg[3] = { 0, 0, 0 }; 224 225 /* Read key toggle, brand, and key code 226 on registers 0x45, 0x46 and 0x47 227 */ 228 rc = dev->em28xx_read_reg_req_len(dev, 0, EM28XX_R45_IR, 229 msg, sizeof(msg)); 230 if (rc < 0) 231 return rc; 232 233 /* Infrared toggle (Reg 0x45[7]) */ 234 poll_result->toggle_bit = (msg[0] >> 7); 235 236 /* Infrared read count (Reg 0x45[6:0] */ 237 poll_result->read_count = (msg[0] & 0x7f); 238 239 /* Remote Control Address (Reg 0x46) */ 240 poll_result->rc_address = msg[1]; 241 242 /* Remote Control Data (Reg 0x47) */ 243 poll_result->rc_data[0] = msg[2]; 244 245 return 0; 246 } 247 248 static int em2874_polling_getkey(struct em28xx_IR *ir, 249 struct em28xx_ir_poll_result *poll_result) 250 { 251 struct em28xx *dev = ir->dev; 252 int rc; 253 u8 msg[5] = { 0, 0, 0, 0, 0 }; 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 /* Remote Control Address (Reg 0x52) */ 270 poll_result->rc_address = msg[1]; 271 272 /* Remote Control Data (Reg 0x53-55) */ 273 poll_result->rc_data[0] = msg[2]; 274 poll_result->rc_data[1] = msg[3]; 275 poll_result->rc_data[2] = msg[4]; 276 277 return 0; 278 } 279 280 /********************************************************** 281 Polling code for em28xx 282 **********************************************************/ 283 284 static void em28xx_ir_handle_key(struct em28xx_IR *ir) 285 { 286 int result; 287 struct em28xx_ir_poll_result poll_result; 288 289 /* read the registers containing the IR status */ 290 result = ir->get_key(ir, &poll_result); 291 if (unlikely(result < 0)) { 292 dprintk("ir->get_key() failed %d\n", result); 293 return; 294 } 295 296 if (unlikely(poll_result.read_count != ir->last_readcount)) { 297 dprintk("%s: toggle: %d, count: %d, key 0x%02x%02x\n", __func__, 298 poll_result.toggle_bit, poll_result.read_count, 299 poll_result.rc_address, poll_result.rc_data[0]); 300 if (ir->full_code) 301 rc_keydown(ir->rc, 302 poll_result.rc_address << 8 | 303 poll_result.rc_data[0], 304 poll_result.toggle_bit); 305 else 306 rc_keydown(ir->rc, 307 poll_result.rc_data[0], 308 poll_result.toggle_bit); 309 310 if (ir->dev->chip_id == CHIP_ID_EM2874 || 311 ir->dev->chip_id == CHIP_ID_EM2884) 312 /* The em2874 clears the readcount field every time the 313 register is read. The em2860/2880 datasheet says that it 314 is supposed to clear the readcount, but it doesn't. So with 315 the em2874, we are looking for a non-zero read count as 316 opposed to a readcount that is incrementing */ 317 ir->last_readcount = 0; 318 else 319 ir->last_readcount = poll_result.read_count; 320 } 321 } 322 323 static void em28xx_ir_work(struct work_struct *work) 324 { 325 struct em28xx_IR *ir = container_of(work, struct em28xx_IR, work.work); 326 327 em28xx_ir_handle_key(ir); 328 schedule_delayed_work(&ir->work, msecs_to_jiffies(ir->polling)); 329 } 330 331 static int em28xx_ir_start(struct rc_dev *rc) 332 { 333 struct em28xx_IR *ir = rc->priv; 334 335 INIT_DELAYED_WORK(&ir->work, em28xx_ir_work); 336 schedule_delayed_work(&ir->work, 0); 337 338 return 0; 339 } 340 341 static void em28xx_ir_stop(struct rc_dev *rc) 342 { 343 struct em28xx_IR *ir = rc->priv; 344 345 cancel_delayed_work_sync(&ir->work); 346 } 347 348 static int em28xx_ir_change_protocol(struct rc_dev *rc_dev, u64 *rc_type) 349 { 350 int rc = 0; 351 struct em28xx_IR *ir = rc_dev->priv; 352 struct em28xx *dev = ir->dev; 353 u8 ir_config = EM2874_IR_RC5; 354 355 /* Adjust xclk based o IR table for RC5/NEC tables */ 356 357 if (*rc_type & RC_BIT_RC5) { 358 dev->board.xclk |= EM28XX_XCLK_IR_RC5_MODE; 359 ir->full_code = 1; 360 *rc_type = RC_BIT_RC5; 361 } else if (*rc_type & RC_BIT_NEC) { 362 dev->board.xclk &= ~EM28XX_XCLK_IR_RC5_MODE; 363 ir_config = EM2874_IR_NEC; 364 ir->full_code = 1; 365 *rc_type = RC_BIT_NEC; 366 } else if (*rc_type != RC_BIT_UNKNOWN) 367 rc = -EINVAL; 368 369 em28xx_write_reg_bits(dev, EM28XX_R0F_XCLK, dev->board.xclk, 370 EM28XX_XCLK_IR_RC5_MODE); 371 372 /* Setup the proper handler based on the chip */ 373 switch (dev->chip_id) { 374 case CHIP_ID_EM2860: 375 case CHIP_ID_EM2883: 376 ir->get_key = default_polling_getkey; 377 break; 378 case CHIP_ID_EM2884: 379 case CHIP_ID_EM2874: 380 case CHIP_ID_EM28174: 381 ir->get_key = em2874_polling_getkey; 382 em28xx_write_regs(dev, EM2874_R50_IR_CONFIG, &ir_config, 1); 383 break; 384 default: 385 printk("Unrecognized em28xx chip id 0x%02x: IR not supported\n", 386 dev->chip_id); 387 rc = -EINVAL; 388 } 389 390 return rc; 391 } 392 393 static void em28xx_register_i2c_ir(struct em28xx *dev) 394 { 395 /* Leadtek winfast tv USBII deluxe can find a non working IR-device */ 396 /* at address 0x18, so if that address is needed for another board in */ 397 /* the future, please put it after 0x1f. */ 398 struct i2c_board_info info; 399 const unsigned short addr_list[] = { 400 0x1f, 0x30, 0x47, I2C_CLIENT_END 401 }; 402 403 memset(&info, 0, sizeof(struct i2c_board_info)); 404 memset(&dev->init_data, 0, sizeof(dev->init_data)); 405 strlcpy(info.type, "ir_video", I2C_NAME_SIZE); 406 407 /* detect & configure */ 408 switch (dev->model) { 409 case EM2800_BOARD_TERRATEC_CINERGY_200: 410 case EM2820_BOARD_TERRATEC_CINERGY_250: 411 dev->init_data.ir_codes = RC_MAP_EM_TERRATEC; 412 dev->init_data.get_key = em28xx_get_key_terratec; 413 dev->init_data.name = "i2c IR (EM28XX Terratec)"; 414 break; 415 case EM2820_BOARD_PINNACLE_USB_2: 416 dev->init_data.ir_codes = RC_MAP_PINNACLE_GREY; 417 dev->init_data.get_key = em28xx_get_key_pinnacle_usb_grey; 418 dev->init_data.name = "i2c IR (EM28XX Pinnacle PCTV)"; 419 break; 420 case EM2820_BOARD_HAUPPAUGE_WINTV_USB_2: 421 dev->init_data.ir_codes = RC_MAP_HAUPPAUGE; 422 dev->init_data.get_key = em28xx_get_key_em_haup; 423 dev->init_data.name = "i2c IR (EM2840 Hauppauge)"; 424 break; 425 case EM2820_BOARD_LEADTEK_WINFAST_USBII_DELUXE: 426 dev->init_data.ir_codes = RC_MAP_WINFAST_USBII_DELUXE; 427 dev->init_data.get_key = em28xx_get_key_winfast_usbii_deluxe; 428 dev->init_data.name = "i2c IR (EM2820 Winfast TV USBII Deluxe)"; 429 break; 430 } 431 432 if (dev->init_data.name) 433 info.platform_data = &dev->init_data; 434 i2c_new_probed_device(&dev->i2c_adap, &info, addr_list, NULL); 435 } 436 437 /********************************************************** 438 Handle Webcam snapshot button 439 **********************************************************/ 440 441 static void em28xx_query_sbutton(struct work_struct *work) 442 { 443 /* Poll the register and see if the button is depressed */ 444 struct em28xx *dev = 445 container_of(work, struct em28xx, sbutton_query_work.work); 446 int ret; 447 448 ret = em28xx_read_reg(dev, EM28XX_R0C_USBSUSP); 449 450 if (ret & EM28XX_R0C_USBSUSP_SNAPSHOT) { 451 u8 cleared; 452 /* Button is depressed, clear the register */ 453 cleared = ((u8) ret) & ~EM28XX_R0C_USBSUSP_SNAPSHOT; 454 em28xx_write_regs(dev, EM28XX_R0C_USBSUSP, &cleared, 1); 455 456 /* Not emulate the keypress */ 457 input_report_key(dev->sbutton_input_dev, EM28XX_SNAPSHOT_KEY, 458 1); 459 /* Now unpress the key */ 460 input_report_key(dev->sbutton_input_dev, EM28XX_SNAPSHOT_KEY, 461 0); 462 } 463 464 /* Schedule next poll */ 465 schedule_delayed_work(&dev->sbutton_query_work, 466 msecs_to_jiffies(EM28XX_SBUTTON_QUERY_INTERVAL)); 467 } 468 469 static void em28xx_register_snapshot_button(struct em28xx *dev) 470 { 471 struct input_dev *input_dev; 472 int err; 473 474 em28xx_info("Registering snapshot button...\n"); 475 input_dev = input_allocate_device(); 476 if (!input_dev) { 477 em28xx_errdev("input_allocate_device failed\n"); 478 return; 479 } 480 481 usb_make_path(dev->udev, dev->snapshot_button_path, 482 sizeof(dev->snapshot_button_path)); 483 strlcat(dev->snapshot_button_path, "/sbutton", 484 sizeof(dev->snapshot_button_path)); 485 INIT_DELAYED_WORK(&dev->sbutton_query_work, em28xx_query_sbutton); 486 487 input_dev->name = "em28xx snapshot button"; 488 input_dev->phys = dev->snapshot_button_path; 489 input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP); 490 set_bit(EM28XX_SNAPSHOT_KEY, input_dev->keybit); 491 input_dev->keycodesize = 0; 492 input_dev->keycodemax = 0; 493 input_dev->id.bustype = BUS_USB; 494 input_dev->id.vendor = le16_to_cpu(dev->udev->descriptor.idVendor); 495 input_dev->id.product = le16_to_cpu(dev->udev->descriptor.idProduct); 496 input_dev->id.version = 1; 497 input_dev->dev.parent = &dev->udev->dev; 498 499 err = input_register_device(input_dev); 500 if (err) { 501 em28xx_errdev("input_register_device failed\n"); 502 input_free_device(input_dev); 503 return; 504 } 505 506 dev->sbutton_input_dev = input_dev; 507 schedule_delayed_work(&dev->sbutton_query_work, 508 msecs_to_jiffies(EM28XX_SBUTTON_QUERY_INTERVAL)); 509 return; 510 511 } 512 513 static void em28xx_deregister_snapshot_button(struct em28xx *dev) 514 { 515 if (dev->sbutton_input_dev != NULL) { 516 em28xx_info("Deregistering snapshot button\n"); 517 cancel_delayed_work_sync(&dev->sbutton_query_work); 518 input_unregister_device(dev->sbutton_input_dev); 519 dev->sbutton_input_dev = NULL; 520 } 521 return; 522 } 523 524 static int em28xx_ir_init(struct em28xx *dev) 525 { 526 struct em28xx_IR *ir; 527 struct rc_dev *rc; 528 int err = -ENOMEM; 529 u64 rc_type; 530 531 if (dev->board.ir_codes == NULL) { 532 /* No remote control support */ 533 em28xx_warn("Remote control support is not available for " 534 "this card.\n"); 535 return 0; 536 } 537 538 ir = kzalloc(sizeof(*ir), GFP_KERNEL); 539 rc = rc_allocate_device(); 540 if (!ir || !rc) 541 goto err_out_free; 542 543 /* record handles to ourself */ 544 ir->dev = dev; 545 dev->ir = ir; 546 ir->rc = rc; 547 548 /* 549 * em2874 supports more protocols. For now, let's just announce 550 * the two protocols that were already tested 551 */ 552 rc->allowed_protos = RC_BIT_RC5 | RC_BIT_NEC; 553 rc->priv = ir; 554 rc->change_protocol = em28xx_ir_change_protocol; 555 rc->open = em28xx_ir_start; 556 rc->close = em28xx_ir_stop; 557 558 /* By default, keep protocol field untouched */ 559 rc_type = RC_BIT_UNKNOWN; 560 err = em28xx_ir_change_protocol(rc, &rc_type); 561 if (err) 562 goto err_out_free; 563 564 /* This is how often we ask the chip for IR information */ 565 ir->polling = 100; /* ms */ 566 567 /* init input device */ 568 snprintf(ir->name, sizeof(ir->name), "em28xx IR (%s)", 569 dev->name); 570 571 usb_make_path(dev->udev, ir->phys, sizeof(ir->phys)); 572 strlcat(ir->phys, "/input0", sizeof(ir->phys)); 573 574 rc->input_name = ir->name; 575 rc->input_phys = ir->phys; 576 rc->input_id.bustype = BUS_USB; 577 rc->input_id.version = 1; 578 rc->input_id.vendor = le16_to_cpu(dev->udev->descriptor.idVendor); 579 rc->input_id.product = le16_to_cpu(dev->udev->descriptor.idProduct); 580 rc->dev.parent = &dev->udev->dev; 581 rc->map_name = dev->board.ir_codes; 582 rc->driver_name = MODULE_NAME; 583 584 /* all done */ 585 err = rc_register_device(rc); 586 if (err) 587 goto err_out_stop; 588 589 em28xx_register_i2c_ir(dev); 590 591 #if defined(CONFIG_MODULES) && defined(MODULE) 592 if (dev->board.has_ir_i2c) 593 request_module("ir-kbd-i2c"); 594 #endif 595 if (dev->board.has_snapshot_button) 596 em28xx_register_snapshot_button(dev); 597 598 return 0; 599 600 err_out_stop: 601 dev->ir = NULL; 602 err_out_free: 603 rc_free_device(rc); 604 kfree(ir); 605 return err; 606 } 607 608 static int em28xx_ir_fini(struct em28xx *dev) 609 { 610 struct em28xx_IR *ir = dev->ir; 611 612 em28xx_deregister_snapshot_button(dev); 613 614 /* skip detach on non attached boards */ 615 if (!ir) 616 return 0; 617 618 if (ir->rc) 619 rc_unregister_device(ir->rc); 620 621 /* done */ 622 kfree(ir); 623 dev->ir = NULL; 624 return 0; 625 } 626 627 static struct em28xx_ops rc_ops = { 628 .id = EM28XX_RC, 629 .name = "Em28xx Input Extension", 630 .init = em28xx_ir_init, 631 .fini = em28xx_ir_fini, 632 }; 633 634 static int __init em28xx_rc_register(void) 635 { 636 return em28xx_register_extension(&rc_ops); 637 } 638 639 static void __exit em28xx_rc_unregister(void) 640 { 641 em28xx_unregister_extension(&rc_ops); 642 } 643 644 MODULE_LICENSE("GPL"); 645 MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@redhat.com>"); 646 MODULE_DESCRIPTION("Em28xx Input driver"); 647 648 module_init(em28xx_rc_register); 649 module_exit(em28xx_rc_unregister); 650