1/* rc-main.c - Remote Controller core module 2 * 3 * Copyright (C) 2009-2010 by Mauro Carvalho Chehab 4 * 5 * This program is free software; you can redistribute it and/or modify 6 * it under the terms of the GNU General Public License as published by 7 * the Free Software Foundation version 2 of the License. 8 * 9 * This program is distributed in the hope that it will be useful, 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 * GNU General Public License for more details. 13 */ 14 15#include <media/rc-core.h> 16#include <linux/spinlock.h> 17#include <linux/delay.h> 18#include <linux/input.h> 19#include <linux/leds.h> 20#include <linux/slab.h> 21#include <linux/idr.h> 22#include <linux/device.h> 23#include <linux/module.h> 24#include "rc-core-priv.h" 25 26/* Sizes are in bytes, 256 bytes allows for 32 entries on x64 */ 27#define IR_TAB_MIN_SIZE 256 28#define IR_TAB_MAX_SIZE 8192 29#define RC_DEV_MAX 256 30 31/* FIXME: IR_KEYPRESS_TIMEOUT should be protocol specific */ 32#define IR_KEYPRESS_TIMEOUT 250 33 34/* Used to keep track of known keymaps */ 35static LIST_HEAD(rc_map_list); 36static DEFINE_SPINLOCK(rc_map_lock); 37static struct led_trigger *led_feedback; 38 39/* Used to keep track of rc devices */ 40static DEFINE_IDA(rc_ida); 41 42static struct rc_map_list *seek_rc_map(const char *name) 43{ 44 struct rc_map_list *map = NULL; 45 46 spin_lock(&rc_map_lock); 47 list_for_each_entry(map, &rc_map_list, list) { 48 if (!strcmp(name, map->map.name)) { 49 spin_unlock(&rc_map_lock); 50 return map; 51 } 52 } 53 spin_unlock(&rc_map_lock); 54 55 return NULL; 56} 57 58struct rc_map *rc_map_get(const char *name) 59{ 60 61 struct rc_map_list *map; 62 63 map = seek_rc_map(name); 64#ifdef MODULE 65 if (!map) { 66 int rc = request_module("%s", name); 67 if (rc < 0) { 68 printk(KERN_ERR "Couldn't load IR keymap %s\n", name); 69 return NULL; 70 } 71 msleep(20); /* Give some time for IR to register */ 72 73 map = seek_rc_map(name); 74 } 75#endif 76 if (!map) { 77 printk(KERN_ERR "IR keymap %s not found\n", name); 78 return NULL; 79 } 80 81 printk(KERN_INFO "Registered IR keymap %s\n", map->map.name); 82 83 return &map->map; 84} 85EXPORT_SYMBOL_GPL(rc_map_get); 86 87int rc_map_register(struct rc_map_list *map) 88{ 89 spin_lock(&rc_map_lock); 90 list_add_tail(&map->list, &rc_map_list); 91 spin_unlock(&rc_map_lock); 92 return 0; 93} 94EXPORT_SYMBOL_GPL(rc_map_register); 95 96void rc_map_unregister(struct rc_map_list *map) 97{ 98 spin_lock(&rc_map_lock); 99 list_del(&map->list); 100 spin_unlock(&rc_map_lock); 101} 102EXPORT_SYMBOL_GPL(rc_map_unregister); 103 104 105static struct rc_map_table empty[] = { 106 { 0x2a, KEY_COFFEE }, 107}; 108 109static struct rc_map_list empty_map = { 110 .map = { 111 .scan = empty, 112 .size = ARRAY_SIZE(empty), 113 .rc_type = RC_TYPE_UNKNOWN, /* Legacy IR type */ 114 .name = RC_MAP_EMPTY, 115 } 116}; 117 118/** 119 * ir_create_table() - initializes a scancode table 120 * @rc_map: the rc_map to initialize 121 * @name: name to assign to the table 122 * @rc_type: ir type to assign to the new table 123 * @size: initial size of the table 124 * @return: zero on success or a negative error code 125 * 126 * This routine will initialize the rc_map and will allocate 127 * memory to hold at least the specified number of elements. 128 */ 129static int ir_create_table(struct rc_map *rc_map, 130 const char *name, u64 rc_type, size_t size) 131{ 132 rc_map->name = name; 133 rc_map->rc_type = rc_type; 134 rc_map->alloc = roundup_pow_of_two(size * sizeof(struct rc_map_table)); 135 rc_map->size = rc_map->alloc / sizeof(struct rc_map_table); 136 rc_map->scan = kmalloc(rc_map->alloc, GFP_KERNEL); 137 if (!rc_map->scan) 138 return -ENOMEM; 139 140 IR_dprintk(1, "Allocated space for %u keycode entries (%u bytes)\n", 141 rc_map->size, rc_map->alloc); 142 return 0; 143} 144 145/** 146 * ir_free_table() - frees memory allocated by a scancode table 147 * @rc_map: the table whose mappings need to be freed 148 * 149 * This routine will free memory alloctaed for key mappings used by given 150 * scancode table. 151 */ 152static void ir_free_table(struct rc_map *rc_map) 153{ 154 rc_map->size = 0; 155 kfree(rc_map->scan); 156 rc_map->scan = NULL; 157} 158 159/** 160 * ir_resize_table() - resizes a scancode table if necessary 161 * @rc_map: the rc_map to resize 162 * @gfp_flags: gfp flags to use when allocating memory 163 * @return: zero on success or a negative error code 164 * 165 * This routine will shrink the rc_map if it has lots of 166 * unused entries and grow it if it is full. 167 */ 168static int ir_resize_table(struct rc_map *rc_map, gfp_t gfp_flags) 169{ 170 unsigned int oldalloc = rc_map->alloc; 171 unsigned int newalloc = oldalloc; 172 struct rc_map_table *oldscan = rc_map->scan; 173 struct rc_map_table *newscan; 174 175 if (rc_map->size == rc_map->len) { 176 /* All entries in use -> grow keytable */ 177 if (rc_map->alloc >= IR_TAB_MAX_SIZE) 178 return -ENOMEM; 179 180 newalloc *= 2; 181 IR_dprintk(1, "Growing table to %u bytes\n", newalloc); 182 } 183 184 if ((rc_map->len * 3 < rc_map->size) && (oldalloc > IR_TAB_MIN_SIZE)) { 185 /* Less than 1/3 of entries in use -> shrink keytable */ 186 newalloc /= 2; 187 IR_dprintk(1, "Shrinking table to %u bytes\n", newalloc); 188 } 189 190 if (newalloc == oldalloc) 191 return 0; 192 193 newscan = kmalloc(newalloc, gfp_flags); 194 if (!newscan) { 195 IR_dprintk(1, "Failed to kmalloc %u bytes\n", newalloc); 196 return -ENOMEM; 197 } 198 199 memcpy(newscan, rc_map->scan, rc_map->len * sizeof(struct rc_map_table)); 200 rc_map->scan = newscan; 201 rc_map->alloc = newalloc; 202 rc_map->size = rc_map->alloc / sizeof(struct rc_map_table); 203 kfree(oldscan); 204 return 0; 205} 206 207/** 208 * ir_update_mapping() - set a keycode in the scancode->keycode table 209 * @dev: the struct rc_dev device descriptor 210 * @rc_map: scancode table to be adjusted 211 * @index: index of the mapping that needs to be updated 212 * @keycode: the desired keycode 213 * @return: previous keycode assigned to the mapping 214 * 215 * This routine is used to update scancode->keycode mapping at given 216 * position. 217 */ 218static unsigned int ir_update_mapping(struct rc_dev *dev, 219 struct rc_map *rc_map, 220 unsigned int index, 221 unsigned int new_keycode) 222{ 223 int old_keycode = rc_map->scan[index].keycode; 224 int i; 225 226 /* Did the user wish to remove the mapping? */ 227 if (new_keycode == KEY_RESERVED || new_keycode == KEY_UNKNOWN) { 228 IR_dprintk(1, "#%d: Deleting scan 0x%04x\n", 229 index, rc_map->scan[index].scancode); 230 rc_map->len--; 231 memmove(&rc_map->scan[index], &rc_map->scan[index+ 1], 232 (rc_map->len - index) * sizeof(struct rc_map_table)); 233 } else { 234 IR_dprintk(1, "#%d: %s scan 0x%04x with key 0x%04x\n", 235 index, 236 old_keycode == KEY_RESERVED ? "New" : "Replacing", 237 rc_map->scan[index].scancode, new_keycode); 238 rc_map->scan[index].keycode = new_keycode; 239 __set_bit(new_keycode, dev->input_dev->keybit); 240 } 241 242 if (old_keycode != KEY_RESERVED) { 243 /* A previous mapping was updated... */ 244 __clear_bit(old_keycode, dev->input_dev->keybit); 245 /* ... but another scancode might use the same keycode */ 246 for (i = 0; i < rc_map->len; i++) { 247 if (rc_map->scan[i].keycode == old_keycode) { 248 __set_bit(old_keycode, dev->input_dev->keybit); 249 break; 250 } 251 } 252 253 /* Possibly shrink the keytable, failure is not a problem */ 254 ir_resize_table(rc_map, GFP_ATOMIC); 255 } 256 257 return old_keycode; 258} 259 260/** 261 * ir_establish_scancode() - set a keycode in the scancode->keycode table 262 * @dev: the struct rc_dev device descriptor 263 * @rc_map: scancode table to be searched 264 * @scancode: the desired scancode 265 * @resize: controls whether we allowed to resize the table to 266 * accommodate not yet present scancodes 267 * @return: index of the mapping containing scancode in question 268 * or -1U in case of failure. 269 * 270 * This routine is used to locate given scancode in rc_map. 271 * If scancode is not yet present the routine will allocate a new slot 272 * for it. 273 */ 274static unsigned int ir_establish_scancode(struct rc_dev *dev, 275 struct rc_map *rc_map, 276 unsigned int scancode, 277 bool resize) 278{ 279 unsigned int i; 280 281 /* 282 * Unfortunately, some hardware-based IR decoders don't provide 283 * all bits for the complete IR code. In general, they provide only 284 * the command part of the IR code. Yet, as it is possible to replace 285 * the provided IR with another one, it is needed to allow loading 286 * IR tables from other remotes. So, we support specifying a mask to 287 * indicate the valid bits of the scancodes. 288 */ 289 if (dev->scancode_mask) 290 scancode &= dev->scancode_mask; 291 292 /* First check if we already have a mapping for this ir command */ 293 for (i = 0; i < rc_map->len; i++) { 294 if (rc_map->scan[i].scancode == scancode) 295 return i; 296 297 /* Keytable is sorted from lowest to highest scancode */ 298 if (rc_map->scan[i].scancode >= scancode) 299 break; 300 } 301 302 /* No previous mapping found, we might need to grow the table */ 303 if (rc_map->size == rc_map->len) { 304 if (!resize || ir_resize_table(rc_map, GFP_ATOMIC)) 305 return -1U; 306 } 307 308 /* i is the proper index to insert our new keycode */ 309 if (i < rc_map->len) 310 memmove(&rc_map->scan[i + 1], &rc_map->scan[i], 311 (rc_map->len - i) * sizeof(struct rc_map_table)); 312 rc_map->scan[i].scancode = scancode; 313 rc_map->scan[i].keycode = KEY_RESERVED; 314 rc_map->len++; 315 316 return i; 317} 318 319/** 320 * ir_setkeycode() - set a keycode in the scancode->keycode table 321 * @idev: the struct input_dev device descriptor 322 * @scancode: the desired scancode 323 * @keycode: result 324 * @return: -EINVAL if the keycode could not be inserted, otherwise zero. 325 * 326 * This routine is used to handle evdev EVIOCSKEY ioctl. 327 */ 328static int ir_setkeycode(struct input_dev *idev, 329 const struct input_keymap_entry *ke, 330 unsigned int *old_keycode) 331{ 332 struct rc_dev *rdev = input_get_drvdata(idev); 333 struct rc_map *rc_map = &rdev->rc_map; 334 unsigned int index; 335 unsigned int scancode; 336 int retval = 0; 337 unsigned long flags; 338 339 spin_lock_irqsave(&rc_map->lock, flags); 340 341 if (ke->flags & INPUT_KEYMAP_BY_INDEX) { 342 index = ke->index; 343 if (index >= rc_map->len) { 344 retval = -EINVAL; 345 goto out; 346 } 347 } else { 348 retval = input_scancode_to_scalar(ke, &scancode); 349 if (retval) 350 goto out; 351 352 index = ir_establish_scancode(rdev, rc_map, scancode, true); 353 if (index >= rc_map->len) { 354 retval = -ENOMEM; 355 goto out; 356 } 357 } 358 359 *old_keycode = ir_update_mapping(rdev, rc_map, index, ke->keycode); 360 361out: 362 spin_unlock_irqrestore(&rc_map->lock, flags); 363 return retval; 364} 365 366/** 367 * ir_setkeytable() - sets several entries in the scancode->keycode table 368 * @dev: the struct rc_dev device descriptor 369 * @to: the struct rc_map to copy entries to 370 * @from: the struct rc_map to copy entries from 371 * @return: -ENOMEM if all keycodes could not be inserted, otherwise zero. 372 * 373 * This routine is used to handle table initialization. 374 */ 375static int ir_setkeytable(struct rc_dev *dev, 376 const struct rc_map *from) 377{ 378 struct rc_map *rc_map = &dev->rc_map; 379 unsigned int i, index; 380 int rc; 381 382 rc = ir_create_table(rc_map, from->name, 383 from->rc_type, from->size); 384 if (rc) 385 return rc; 386 387 IR_dprintk(1, "Allocated space for %u keycode entries (%u bytes)\n", 388 rc_map->size, rc_map->alloc); 389 390 for (i = 0; i < from->size; i++) { 391 index = ir_establish_scancode(dev, rc_map, 392 from->scan[i].scancode, false); 393 if (index >= rc_map->len) { 394 rc = -ENOMEM; 395 break; 396 } 397 398 ir_update_mapping(dev, rc_map, index, 399 from->scan[i].keycode); 400 } 401 402 if (rc) 403 ir_free_table(rc_map); 404 405 return rc; 406} 407 408/** 409 * ir_lookup_by_scancode() - locate mapping by scancode 410 * @rc_map: the struct rc_map to search 411 * @scancode: scancode to look for in the table 412 * @return: index in the table, -1U if not found 413 * 414 * This routine performs binary search in RC keykeymap table for 415 * given scancode. 416 */ 417static unsigned int ir_lookup_by_scancode(const struct rc_map *rc_map, 418 unsigned int scancode) 419{ 420 int start = 0; 421 int end = rc_map->len - 1; 422 int mid; 423 424 while (start <= end) { 425 mid = (start + end) / 2; 426 if (rc_map->scan[mid].scancode < scancode) 427 start = mid + 1; 428 else if (rc_map->scan[mid].scancode > scancode) 429 end = mid - 1; 430 else 431 return mid; 432 } 433 434 return -1U; 435} 436 437/** 438 * ir_getkeycode() - get a keycode from the scancode->keycode table 439 * @idev: the struct input_dev device descriptor 440 * @scancode: the desired scancode 441 * @keycode: used to return the keycode, if found, or KEY_RESERVED 442 * @return: always returns zero. 443 * 444 * This routine is used to handle evdev EVIOCGKEY ioctl. 445 */ 446static int ir_getkeycode(struct input_dev *idev, 447 struct input_keymap_entry *ke) 448{ 449 struct rc_dev *rdev = input_get_drvdata(idev); 450 struct rc_map *rc_map = &rdev->rc_map; 451 struct rc_map_table *entry; 452 unsigned long flags; 453 unsigned int index; 454 unsigned int scancode; 455 int retval; 456 457 spin_lock_irqsave(&rc_map->lock, flags); 458 459 if (ke->flags & INPUT_KEYMAP_BY_INDEX) { 460 index = ke->index; 461 } else { 462 retval = input_scancode_to_scalar(ke, &scancode); 463 if (retval) 464 goto out; 465 466 index = ir_lookup_by_scancode(rc_map, scancode); 467 } 468 469 if (index < rc_map->len) { 470 entry = &rc_map->scan[index]; 471 472 ke->index = index; 473 ke->keycode = entry->keycode; 474 ke->len = sizeof(entry->scancode); 475 memcpy(ke->scancode, &entry->scancode, sizeof(entry->scancode)); 476 477 } else if (!(ke->flags & INPUT_KEYMAP_BY_INDEX)) { 478 /* 479 * We do not really know the valid range of scancodes 480 * so let's respond with KEY_RESERVED to anything we 481 * do not have mapping for [yet]. 482 */ 483 ke->index = index; 484 ke->keycode = KEY_RESERVED; 485 } else { 486 retval = -EINVAL; 487 goto out; 488 } 489 490 retval = 0; 491 492out: 493 spin_unlock_irqrestore(&rc_map->lock, flags); 494 return retval; 495} 496 497/** 498 * rc_g_keycode_from_table() - gets the keycode that corresponds to a scancode 499 * @dev: the struct rc_dev descriptor of the device 500 * @scancode: the scancode to look for 501 * @return: the corresponding keycode, or KEY_RESERVED 502 * 503 * This routine is used by drivers which need to convert a scancode to a 504 * keycode. Normally it should not be used since drivers should have no 505 * interest in keycodes. 506 */ 507u32 rc_g_keycode_from_table(struct rc_dev *dev, u32 scancode) 508{ 509 struct rc_map *rc_map = &dev->rc_map; 510 unsigned int keycode; 511 unsigned int index; 512 unsigned long flags; 513 514 spin_lock_irqsave(&rc_map->lock, flags); 515 516 index = ir_lookup_by_scancode(rc_map, scancode); 517 keycode = index < rc_map->len ? 518 rc_map->scan[index].keycode : KEY_RESERVED; 519 520 spin_unlock_irqrestore(&rc_map->lock, flags); 521 522 if (keycode != KEY_RESERVED) 523 IR_dprintk(1, "%s: scancode 0x%04x keycode 0x%02x\n", 524 dev->input_name, scancode, keycode); 525 526 return keycode; 527} 528EXPORT_SYMBOL_GPL(rc_g_keycode_from_table); 529 530/** 531 * ir_do_keyup() - internal function to signal the release of a keypress 532 * @dev: the struct rc_dev descriptor of the device 533 * @sync: whether or not to call input_sync 534 * 535 * This function is used internally to release a keypress, it must be 536 * called with keylock held. 537 */ 538static void ir_do_keyup(struct rc_dev *dev, bool sync) 539{ 540 if (!dev->keypressed) 541 return; 542 543 IR_dprintk(1, "keyup key 0x%04x\n", dev->last_keycode); 544 input_report_key(dev->input_dev, dev->last_keycode, 0); 545 led_trigger_event(led_feedback, LED_OFF); 546 if (sync) 547 input_sync(dev->input_dev); 548 dev->keypressed = false; 549} 550 551/** 552 * rc_keyup() - signals the release of a keypress 553 * @dev: the struct rc_dev descriptor of the device 554 * 555 * This routine is used to signal that a key has been released on the 556 * remote control. 557 */ 558void rc_keyup(struct rc_dev *dev) 559{ 560 unsigned long flags; 561 562 spin_lock_irqsave(&dev->keylock, flags); 563 ir_do_keyup(dev, true); 564 spin_unlock_irqrestore(&dev->keylock, flags); 565} 566EXPORT_SYMBOL_GPL(rc_keyup); 567 568/** 569 * ir_timer_keyup() - generates a keyup event after a timeout 570 * @cookie: a pointer to the struct rc_dev for the device 571 * 572 * This routine will generate a keyup event some time after a keydown event 573 * is generated when no further activity has been detected. 574 */ 575static void ir_timer_keyup(unsigned long cookie) 576{ 577 struct rc_dev *dev = (struct rc_dev *)cookie; 578 unsigned long flags; 579 580 /* 581 * ir->keyup_jiffies is used to prevent a race condition if a 582 * hardware interrupt occurs at this point and the keyup timer 583 * event is moved further into the future as a result. 584 * 585 * The timer will then be reactivated and this function called 586 * again in the future. We need to exit gracefully in that case 587 * to allow the input subsystem to do its auto-repeat magic or 588 * a keyup event might follow immediately after the keydown. 589 */ 590 spin_lock_irqsave(&dev->keylock, flags); 591 if (time_is_before_eq_jiffies(dev->keyup_jiffies)) 592 ir_do_keyup(dev, true); 593 spin_unlock_irqrestore(&dev->keylock, flags); 594} 595 596/** 597 * rc_repeat() - signals that a key is still pressed 598 * @dev: the struct rc_dev descriptor of the device 599 * 600 * This routine is used by IR decoders when a repeat message which does 601 * not include the necessary bits to reproduce the scancode has been 602 * received. 603 */ 604void rc_repeat(struct rc_dev *dev) 605{ 606 unsigned long flags; 607 608 spin_lock_irqsave(&dev->keylock, flags); 609 610 input_event(dev->input_dev, EV_MSC, MSC_SCAN, dev->last_scancode); 611 input_sync(dev->input_dev); 612 613 if (!dev->keypressed) 614 goto out; 615 616 dev->keyup_jiffies = jiffies + msecs_to_jiffies(IR_KEYPRESS_TIMEOUT); 617 mod_timer(&dev->timer_keyup, dev->keyup_jiffies); 618 619out: 620 spin_unlock_irqrestore(&dev->keylock, flags); 621} 622EXPORT_SYMBOL_GPL(rc_repeat); 623 624/** 625 * ir_do_keydown() - internal function to process a keypress 626 * @dev: the struct rc_dev descriptor of the device 627 * @protocol: the protocol of the keypress 628 * @scancode: the scancode of the keypress 629 * @keycode: the keycode of the keypress 630 * @toggle: the toggle value of the keypress 631 * 632 * This function is used internally to register a keypress, it must be 633 * called with keylock held. 634 */ 635static void ir_do_keydown(struct rc_dev *dev, enum rc_type protocol, 636 u32 scancode, u32 keycode, u8 toggle) 637{ 638 bool new_event = (!dev->keypressed || 639 dev->last_protocol != protocol || 640 dev->last_scancode != scancode || 641 dev->last_toggle != toggle); 642 643 if (new_event && dev->keypressed) 644 ir_do_keyup(dev, false); 645 646 input_event(dev->input_dev, EV_MSC, MSC_SCAN, scancode); 647 648 if (new_event && keycode != KEY_RESERVED) { 649 /* Register a keypress */ 650 dev->keypressed = true; 651 dev->last_protocol = protocol; 652 dev->last_scancode = scancode; 653 dev->last_toggle = toggle; 654 dev->last_keycode = keycode; 655 656 IR_dprintk(1, "%s: key down event, " 657 "key 0x%04x, protocol 0x%04x, scancode 0x%08x\n", 658 dev->input_name, keycode, protocol, scancode); 659 input_report_key(dev->input_dev, keycode, 1); 660 661 led_trigger_event(led_feedback, LED_FULL); 662 } 663 664 input_sync(dev->input_dev); 665} 666 667/** 668 * rc_keydown() - generates input event for a key press 669 * @dev: the struct rc_dev descriptor of the device 670 * @protocol: the protocol for the keypress 671 * @scancode: the scancode for the keypress 672 * @toggle: the toggle value (protocol dependent, if the protocol doesn't 673 * support toggle values, this should be set to zero) 674 * 675 * This routine is used to signal that a key has been pressed on the 676 * remote control. 677 */ 678void rc_keydown(struct rc_dev *dev, enum rc_type protocol, u32 scancode, u8 toggle) 679{ 680 unsigned long flags; 681 u32 keycode = rc_g_keycode_from_table(dev, scancode); 682 683 spin_lock_irqsave(&dev->keylock, flags); 684 ir_do_keydown(dev, protocol, scancode, keycode, toggle); 685 686 if (dev->keypressed) { 687 dev->keyup_jiffies = jiffies + msecs_to_jiffies(IR_KEYPRESS_TIMEOUT); 688 mod_timer(&dev->timer_keyup, dev->keyup_jiffies); 689 } 690 spin_unlock_irqrestore(&dev->keylock, flags); 691} 692EXPORT_SYMBOL_GPL(rc_keydown); 693 694/** 695 * rc_keydown_notimeout() - generates input event for a key press without 696 * an automatic keyup event at a later time 697 * @dev: the struct rc_dev descriptor of the device 698 * @protocol: the protocol for the keypress 699 * @scancode: the scancode for the keypress 700 * @toggle: the toggle value (protocol dependent, if the protocol doesn't 701 * support toggle values, this should be set to zero) 702 * 703 * This routine is used to signal that a key has been pressed on the 704 * remote control. The driver must manually call rc_keyup() at a later stage. 705 */ 706void rc_keydown_notimeout(struct rc_dev *dev, enum rc_type protocol, 707 u32 scancode, u8 toggle) 708{ 709 unsigned long flags; 710 u32 keycode = rc_g_keycode_from_table(dev, scancode); 711 712 spin_lock_irqsave(&dev->keylock, flags); 713 ir_do_keydown(dev, protocol, scancode, keycode, toggle); 714 spin_unlock_irqrestore(&dev->keylock, flags); 715} 716EXPORT_SYMBOL_GPL(rc_keydown_notimeout); 717 718int rc_open(struct rc_dev *rdev) 719{ 720 int rval = 0; 721 722 if (!rdev) 723 return -EINVAL; 724 725 mutex_lock(&rdev->lock); 726 if (!rdev->users++ && rdev->open != NULL) 727 rval = rdev->open(rdev); 728 729 if (rval) 730 rdev->users--; 731 732 mutex_unlock(&rdev->lock); 733 734 return rval; 735} 736EXPORT_SYMBOL_GPL(rc_open); 737 738static int ir_open(struct input_dev *idev) 739{ 740 struct rc_dev *rdev = input_get_drvdata(idev); 741 742 return rc_open(rdev); 743} 744 745void rc_close(struct rc_dev *rdev) 746{ 747 if (rdev) { 748 mutex_lock(&rdev->lock); 749 750 if (!--rdev->users && rdev->close != NULL) 751 rdev->close(rdev); 752 753 mutex_unlock(&rdev->lock); 754 } 755} 756EXPORT_SYMBOL_GPL(rc_close); 757 758static void ir_close(struct input_dev *idev) 759{ 760 struct rc_dev *rdev = input_get_drvdata(idev); 761 rc_close(rdev); 762} 763 764/* class for /sys/class/rc */ 765static char *rc_devnode(struct device *dev, umode_t *mode) 766{ 767 return kasprintf(GFP_KERNEL, "rc/%s", dev_name(dev)); 768} 769 770static struct class rc_class = { 771 .name = "rc", 772 .devnode = rc_devnode, 773}; 774 775/* 776 * These are the protocol textual descriptions that are 777 * used by the sysfs protocols file. Note that the order 778 * of the entries is relevant. 779 */ 780static struct { 781 u64 type; 782 char *name; 783} proto_names[] = { 784 { RC_BIT_NONE, "none" }, 785 { RC_BIT_OTHER, "other" }, 786 { RC_BIT_UNKNOWN, "unknown" }, 787 { RC_BIT_RC5 | 788 RC_BIT_RC5X, "rc-5" }, 789 { RC_BIT_NEC, "nec" }, 790 { RC_BIT_RC6_0 | 791 RC_BIT_RC6_6A_20 | 792 RC_BIT_RC6_6A_24 | 793 RC_BIT_RC6_6A_32 | 794 RC_BIT_RC6_MCE, "rc-6" }, 795 { RC_BIT_JVC, "jvc" }, 796 { RC_BIT_SONY12 | 797 RC_BIT_SONY15 | 798 RC_BIT_SONY20, "sony" }, 799 { RC_BIT_RC5_SZ, "rc-5-sz" }, 800 { RC_BIT_SANYO, "sanyo" }, 801 { RC_BIT_SHARP, "sharp" }, 802 { RC_BIT_MCE_KBD, "mce_kbd" }, 803 { RC_BIT_XMP, "xmp" }, 804}; 805 806/** 807 * struct rc_filter_attribute - Device attribute relating to a filter type. 808 * @attr: Device attribute. 809 * @type: Filter type. 810 * @mask: false for filter value, true for filter mask. 811 */ 812struct rc_filter_attribute { 813 struct device_attribute attr; 814 enum rc_filter_type type; 815 bool mask; 816}; 817#define to_rc_filter_attr(a) container_of(a, struct rc_filter_attribute, attr) 818 819#define RC_PROTO_ATTR(_name, _mode, _show, _store, _type) \ 820 struct rc_filter_attribute dev_attr_##_name = { \ 821 .attr = __ATTR(_name, _mode, _show, _store), \ 822 .type = (_type), \ 823 } 824#define RC_FILTER_ATTR(_name, _mode, _show, _store, _type, _mask) \ 825 struct rc_filter_attribute dev_attr_##_name = { \ 826 .attr = __ATTR(_name, _mode, _show, _store), \ 827 .type = (_type), \ 828 .mask = (_mask), \ 829 } 830 831static bool lirc_is_present(void) 832{ 833#if defined(CONFIG_LIRC_MODULE) 834 struct module *lirc; 835 836 mutex_lock(&module_mutex); 837 lirc = find_module("lirc_dev"); 838 mutex_unlock(&module_mutex); 839 840 return lirc ? true : false; 841#elif defined(CONFIG_LIRC) 842 return true; 843#else 844 return false; 845#endif 846} 847 848/** 849 * show_protocols() - shows the current/wakeup IR protocol(s) 850 * @device: the device descriptor 851 * @mattr: the device attribute struct 852 * @buf: a pointer to the output buffer 853 * 854 * This routine is a callback routine for input read the IR protocol type(s). 855 * it is trigged by reading /sys/class/rc/rc?/[wakeup_]protocols. 856 * It returns the protocol names of supported protocols. 857 * Enabled protocols are printed in brackets. 858 * 859 * dev->lock is taken to guard against races between device 860 * registration, store_protocols and show_protocols. 861 */ 862static ssize_t show_protocols(struct device *device, 863 struct device_attribute *mattr, char *buf) 864{ 865 struct rc_dev *dev = to_rc_dev(device); 866 struct rc_filter_attribute *fattr = to_rc_filter_attr(mattr); 867 u64 allowed, enabled; 868 char *tmp = buf; 869 int i; 870 871 /* Device is being removed */ 872 if (!dev) 873 return -EINVAL; 874 875 mutex_lock(&dev->lock); 876 877 if (fattr->type == RC_FILTER_NORMAL) { 878 enabled = dev->enabled_protocols; 879 allowed = dev->allowed_protocols; 880 if (dev->raw && !allowed) 881 allowed = ir_raw_get_allowed_protocols(); 882 } else { 883 enabled = dev->enabled_wakeup_protocols; 884 allowed = dev->allowed_wakeup_protocols; 885 } 886 887 mutex_unlock(&dev->lock); 888 889 IR_dprintk(1, "%s: allowed - 0x%llx, enabled - 0x%llx\n", 890 __func__, (long long)allowed, (long long)enabled); 891 892 for (i = 0; i < ARRAY_SIZE(proto_names); i++) { 893 if (allowed & enabled & proto_names[i].type) 894 tmp += sprintf(tmp, "[%s] ", proto_names[i].name); 895 else if (allowed & proto_names[i].type) 896 tmp += sprintf(tmp, "%s ", proto_names[i].name); 897 898 if (allowed & proto_names[i].type) 899 allowed &= ~proto_names[i].type; 900 } 901 902 if (dev->driver_type == RC_DRIVER_IR_RAW && lirc_is_present()) 903 tmp += sprintf(tmp, "[lirc] "); 904 905 if (tmp != buf) 906 tmp--; 907 *tmp = '\n'; 908 909 return tmp + 1 - buf; 910} 911 912/** 913 * parse_protocol_change() - parses a protocol change request 914 * @protocols: pointer to the bitmask of current protocols 915 * @buf: pointer to the buffer with a list of changes 916 * 917 * Writing "+proto" will add a protocol to the protocol mask. 918 * Writing "-proto" will remove a protocol from protocol mask. 919 * Writing "proto" will enable only "proto". 920 * Writing "none" will disable all protocols. 921 * Returns the number of changes performed or a negative error code. 922 */ 923static int parse_protocol_change(u64 *protocols, const char *buf) 924{ 925 const char *tmp; 926 unsigned count = 0; 927 bool enable, disable; 928 u64 mask; 929 int i; 930 931 while ((tmp = strsep((char **)&buf, " \n")) != NULL) { 932 if (!*tmp) 933 break; 934 935 if (*tmp == '+') { 936 enable = true; 937 disable = false; 938 tmp++; 939 } else if (*tmp == '-') { 940 enable = false; 941 disable = true; 942 tmp++; 943 } else { 944 enable = false; 945 disable = false; 946 } 947 948 for (i = 0; i < ARRAY_SIZE(proto_names); i++) { 949 if (!strcasecmp(tmp, proto_names[i].name)) { 950 mask = proto_names[i].type; 951 break; 952 } 953 } 954 955 if (i == ARRAY_SIZE(proto_names)) { 956 if (!strcasecmp(tmp, "lirc")) 957 mask = 0; 958 else { 959 IR_dprintk(1, "Unknown protocol: '%s'\n", tmp); 960 return -EINVAL; 961 } 962 } 963 964 count++; 965 966 if (enable) 967 *protocols |= mask; 968 else if (disable) 969 *protocols &= ~mask; 970 else 971 *protocols = mask; 972 } 973 974 if (!count) { 975 IR_dprintk(1, "Protocol not specified\n"); 976 return -EINVAL; 977 } 978 979 return count; 980} 981 982/** 983 * store_protocols() - changes the current/wakeup IR protocol(s) 984 * @device: the device descriptor 985 * @mattr: the device attribute struct 986 * @buf: a pointer to the input buffer 987 * @len: length of the input buffer 988 * 989 * This routine is for changing the IR protocol type. 990 * It is trigged by writing to /sys/class/rc/rc?/[wakeup_]protocols. 991 * See parse_protocol_change() for the valid commands. 992 * Returns @len on success or a negative error code. 993 * 994 * dev->lock is taken to guard against races between device 995 * registration, store_protocols and show_protocols. 996 */ 997static ssize_t store_protocols(struct device *device, 998 struct device_attribute *mattr, 999 const char *buf, size_t len) 1000{ 1001 struct rc_dev *dev = to_rc_dev(device); 1002 struct rc_filter_attribute *fattr = to_rc_filter_attr(mattr); 1003 u64 *current_protocols; 1004 int (*change_protocol)(struct rc_dev *dev, u64 *rc_type); 1005 struct rc_scancode_filter *filter; 1006 int (*set_filter)(struct rc_dev *dev, struct rc_scancode_filter *filter); 1007 u64 old_protocols, new_protocols; 1008 ssize_t rc; 1009 1010 /* Device is being removed */ 1011 if (!dev) 1012 return -EINVAL; 1013 1014 if (fattr->type == RC_FILTER_NORMAL) { 1015 IR_dprintk(1, "Normal protocol change requested\n"); 1016 current_protocols = &dev->enabled_protocols; 1017 change_protocol = dev->change_protocol; 1018 filter = &dev->scancode_filter; 1019 set_filter = dev->s_filter; 1020 } else { 1021 IR_dprintk(1, "Wakeup protocol change requested\n"); 1022 current_protocols = &dev->enabled_wakeup_protocols; 1023 change_protocol = dev->change_wakeup_protocol; 1024 filter = &dev->scancode_wakeup_filter; 1025 set_filter = dev->s_wakeup_filter; 1026 } 1027 1028 if (!change_protocol) { 1029 IR_dprintk(1, "Protocol switching not supported\n"); 1030 return -EINVAL; 1031 } 1032 1033 mutex_lock(&dev->lock); 1034 1035 old_protocols = *current_protocols; 1036 new_protocols = old_protocols; 1037 rc = parse_protocol_change(&new_protocols, buf); 1038 if (rc < 0) 1039 goto out; 1040 1041 rc = change_protocol(dev, &new_protocols); 1042 if (rc < 0) { 1043 IR_dprintk(1, "Error setting protocols to 0x%llx\n", 1044 (long long)new_protocols); 1045 goto out; 1046 } 1047 1048 if (new_protocols != old_protocols) { 1049 *current_protocols = new_protocols; 1050 IR_dprintk(1, "Protocols changed to 0x%llx\n", 1051 (long long)new_protocols); 1052 } 1053 1054 /* 1055 * If a protocol change was attempted the filter may need updating, even 1056 * if the actual protocol mask hasn't changed (since the driver may have 1057 * cleared the filter). 1058 * Try setting the same filter with the new protocol (if any). 1059 * Fall back to clearing the filter. 1060 */ 1061 if (set_filter && filter->mask) { 1062 if (new_protocols) 1063 rc = set_filter(dev, filter); 1064 else 1065 rc = -1; 1066 1067 if (rc < 0) { 1068 filter->data = 0; 1069 filter->mask = 0; 1070 set_filter(dev, filter); 1071 } 1072 } 1073 1074 rc = len; 1075 1076out: 1077 mutex_unlock(&dev->lock); 1078 return rc; 1079} 1080 1081/** 1082 * show_filter() - shows the current scancode filter value or mask 1083 * @device: the device descriptor 1084 * @attr: the device attribute struct 1085 * @buf: a pointer to the output buffer 1086 * 1087 * This routine is a callback routine to read a scancode filter value or mask. 1088 * It is trigged by reading /sys/class/rc/rc?/[wakeup_]filter[_mask]. 1089 * It prints the current scancode filter value or mask of the appropriate filter 1090 * type in hexadecimal into @buf and returns the size of the buffer. 1091 * 1092 * Bits of the filter value corresponding to set bits in the filter mask are 1093 * compared against input scancodes and non-matching scancodes are discarded. 1094 * 1095 * dev->lock is taken to guard against races between device registration, 1096 * store_filter and show_filter. 1097 */ 1098static ssize_t show_filter(struct device *device, 1099 struct device_attribute *attr, 1100 char *buf) 1101{ 1102 struct rc_dev *dev = to_rc_dev(device); 1103 struct rc_filter_attribute *fattr = to_rc_filter_attr(attr); 1104 struct rc_scancode_filter *filter; 1105 u32 val; 1106 1107 /* Device is being removed */ 1108 if (!dev) 1109 return -EINVAL; 1110 1111 if (fattr->type == RC_FILTER_NORMAL) 1112 filter = &dev->scancode_filter; 1113 else 1114 filter = &dev->scancode_wakeup_filter; 1115 1116 mutex_lock(&dev->lock); 1117 if (fattr->mask) 1118 val = filter->mask; 1119 else 1120 val = filter->data; 1121 mutex_unlock(&dev->lock); 1122 1123 return sprintf(buf, "%#x\n", val); 1124} 1125 1126/** 1127 * store_filter() - changes the scancode filter value 1128 * @device: the device descriptor 1129 * @attr: the device attribute struct 1130 * @buf: a pointer to the input buffer 1131 * @len: length of the input buffer 1132 * 1133 * This routine is for changing a scancode filter value or mask. 1134 * It is trigged by writing to /sys/class/rc/rc?/[wakeup_]filter[_mask]. 1135 * Returns -EINVAL if an invalid filter value for the current protocol was 1136 * specified or if scancode filtering is not supported by the driver, otherwise 1137 * returns @len. 1138 * 1139 * Bits of the filter value corresponding to set bits in the filter mask are 1140 * compared against input scancodes and non-matching scancodes are discarded. 1141 * 1142 * dev->lock is taken to guard against races between device registration, 1143 * store_filter and show_filter. 1144 */ 1145static ssize_t store_filter(struct device *device, 1146 struct device_attribute *attr, 1147 const char *buf, size_t len) 1148{ 1149 struct rc_dev *dev = to_rc_dev(device); 1150 struct rc_filter_attribute *fattr = to_rc_filter_attr(attr); 1151 struct rc_scancode_filter new_filter, *filter; 1152 int ret; 1153 unsigned long val; 1154 int (*set_filter)(struct rc_dev *dev, struct rc_scancode_filter *filter); 1155 u64 *enabled_protocols; 1156 1157 /* Device is being removed */ 1158 if (!dev) 1159 return -EINVAL; 1160 1161 ret = kstrtoul(buf, 0, &val); 1162 if (ret < 0) 1163 return ret; 1164 1165 if (fattr->type == RC_FILTER_NORMAL) { 1166 set_filter = dev->s_filter; 1167 enabled_protocols = &dev->enabled_protocols; 1168 filter = &dev->scancode_filter; 1169 } else { 1170 set_filter = dev->s_wakeup_filter; 1171 enabled_protocols = &dev->enabled_wakeup_protocols; 1172 filter = &dev->scancode_wakeup_filter; 1173 } 1174 1175 if (!set_filter) 1176 return -EINVAL; 1177 1178 mutex_lock(&dev->lock); 1179 1180 new_filter = *filter; 1181 if (fattr->mask) 1182 new_filter.mask = val; 1183 else 1184 new_filter.data = val; 1185 1186 if (!*enabled_protocols && val) { 1187 /* refuse to set a filter unless a protocol is enabled */ 1188 ret = -EINVAL; 1189 goto unlock; 1190 } 1191 1192 ret = set_filter(dev, &new_filter); 1193 if (ret < 0) 1194 goto unlock; 1195 1196 *filter = new_filter; 1197 1198unlock: 1199 mutex_unlock(&dev->lock); 1200 return (ret < 0) ? ret : len; 1201} 1202 1203static void rc_dev_release(struct device *device) 1204{ 1205} 1206 1207#define ADD_HOTPLUG_VAR(fmt, val...) \ 1208 do { \ 1209 int err = add_uevent_var(env, fmt, val); \ 1210 if (err) \ 1211 return err; \ 1212 } while (0) 1213 1214static int rc_dev_uevent(struct device *device, struct kobj_uevent_env *env) 1215{ 1216 struct rc_dev *dev = to_rc_dev(device); 1217 1218 if (dev->rc_map.name) 1219 ADD_HOTPLUG_VAR("NAME=%s", dev->rc_map.name); 1220 if (dev->driver_name) 1221 ADD_HOTPLUG_VAR("DRV_NAME=%s", dev->driver_name); 1222 1223 return 0; 1224} 1225 1226/* 1227 * Static device attribute struct with the sysfs attributes for IR's 1228 */ 1229static RC_PROTO_ATTR(protocols, S_IRUGO | S_IWUSR, 1230 show_protocols, store_protocols, RC_FILTER_NORMAL); 1231static RC_PROTO_ATTR(wakeup_protocols, S_IRUGO | S_IWUSR, 1232 show_protocols, store_protocols, RC_FILTER_WAKEUP); 1233static RC_FILTER_ATTR(filter, S_IRUGO|S_IWUSR, 1234 show_filter, store_filter, RC_FILTER_NORMAL, false); 1235static RC_FILTER_ATTR(filter_mask, S_IRUGO|S_IWUSR, 1236 show_filter, store_filter, RC_FILTER_NORMAL, true); 1237static RC_FILTER_ATTR(wakeup_filter, S_IRUGO|S_IWUSR, 1238 show_filter, store_filter, RC_FILTER_WAKEUP, false); 1239static RC_FILTER_ATTR(wakeup_filter_mask, S_IRUGO|S_IWUSR, 1240 show_filter, store_filter, RC_FILTER_WAKEUP, true); 1241 1242static struct attribute *rc_dev_protocol_attrs[] = { 1243 &dev_attr_protocols.attr.attr, 1244 NULL, 1245}; 1246 1247static struct attribute_group rc_dev_protocol_attr_grp = { 1248 .attrs = rc_dev_protocol_attrs, 1249}; 1250 1251static struct attribute *rc_dev_wakeup_protocol_attrs[] = { 1252 &dev_attr_wakeup_protocols.attr.attr, 1253 NULL, 1254}; 1255 1256static struct attribute_group rc_dev_wakeup_protocol_attr_grp = { 1257 .attrs = rc_dev_wakeup_protocol_attrs, 1258}; 1259 1260static struct attribute *rc_dev_filter_attrs[] = { 1261 &dev_attr_filter.attr.attr, 1262 &dev_attr_filter_mask.attr.attr, 1263 NULL, 1264}; 1265 1266static struct attribute_group rc_dev_filter_attr_grp = { 1267 .attrs = rc_dev_filter_attrs, 1268}; 1269 1270static struct attribute *rc_dev_wakeup_filter_attrs[] = { 1271 &dev_attr_wakeup_filter.attr.attr, 1272 &dev_attr_wakeup_filter_mask.attr.attr, 1273 NULL, 1274}; 1275 1276static struct attribute_group rc_dev_wakeup_filter_attr_grp = { 1277 .attrs = rc_dev_wakeup_filter_attrs, 1278}; 1279 1280static struct device_type rc_dev_type = { 1281 .release = rc_dev_release, 1282 .uevent = rc_dev_uevent, 1283}; 1284 1285struct rc_dev *rc_allocate_device(void) 1286{ 1287 struct rc_dev *dev; 1288 1289 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 1290 if (!dev) 1291 return NULL; 1292 1293 dev->input_dev = input_allocate_device(); 1294 if (!dev->input_dev) { 1295 kfree(dev); 1296 return NULL; 1297 } 1298 1299 dev->input_dev->getkeycode = ir_getkeycode; 1300 dev->input_dev->setkeycode = ir_setkeycode; 1301 input_set_drvdata(dev->input_dev, dev); 1302 1303 spin_lock_init(&dev->rc_map.lock); 1304 spin_lock_init(&dev->keylock); 1305 mutex_init(&dev->lock); 1306 setup_timer(&dev->timer_keyup, ir_timer_keyup, (unsigned long)dev); 1307 1308 dev->dev.type = &rc_dev_type; 1309 dev->dev.class = &rc_class; 1310 device_initialize(&dev->dev); 1311 1312 __module_get(THIS_MODULE); 1313 return dev; 1314} 1315EXPORT_SYMBOL_GPL(rc_allocate_device); 1316 1317void rc_free_device(struct rc_dev *dev) 1318{ 1319 if (!dev) 1320 return; 1321 1322 input_free_device(dev->input_dev); 1323 1324 put_device(&dev->dev); 1325 1326 kfree(dev); 1327 module_put(THIS_MODULE); 1328} 1329EXPORT_SYMBOL_GPL(rc_free_device); 1330 1331int rc_register_device(struct rc_dev *dev) 1332{ 1333 static bool raw_init = false; /* raw decoders loaded? */ 1334 struct rc_map *rc_map; 1335 const char *path; 1336 int attr = 0; 1337 int minor; 1338 int rc; 1339 1340 if (!dev || !dev->map_name) 1341 return -EINVAL; 1342 1343 rc_map = rc_map_get(dev->map_name); 1344 if (!rc_map) 1345 rc_map = rc_map_get(RC_MAP_EMPTY); 1346 if (!rc_map || !rc_map->scan || rc_map->size == 0) 1347 return -EINVAL; 1348 1349 set_bit(EV_KEY, dev->input_dev->evbit); 1350 set_bit(EV_REP, dev->input_dev->evbit); 1351 set_bit(EV_MSC, dev->input_dev->evbit); 1352 set_bit(MSC_SCAN, dev->input_dev->mscbit); 1353 if (dev->open) 1354 dev->input_dev->open = ir_open; 1355 if (dev->close) 1356 dev->input_dev->close = ir_close; 1357 1358 minor = ida_simple_get(&rc_ida, 0, RC_DEV_MAX, GFP_KERNEL); 1359 if (minor < 0) 1360 return minor; 1361 1362 dev->minor = minor; 1363 dev_set_name(&dev->dev, "rc%u", dev->minor); 1364 dev_set_drvdata(&dev->dev, dev); 1365 1366 dev->dev.groups = dev->sysfs_groups; 1367 dev->sysfs_groups[attr++] = &rc_dev_protocol_attr_grp; 1368 if (dev->s_filter) 1369 dev->sysfs_groups[attr++] = &rc_dev_filter_attr_grp; 1370 if (dev->s_wakeup_filter) 1371 dev->sysfs_groups[attr++] = &rc_dev_wakeup_filter_attr_grp; 1372 if (dev->change_wakeup_protocol) 1373 dev->sysfs_groups[attr++] = &rc_dev_wakeup_protocol_attr_grp; 1374 dev->sysfs_groups[attr++] = NULL; 1375 1376 /* 1377 * Take the lock here, as the device sysfs node will appear 1378 * when device_add() is called, which may trigger an ir-keytable udev 1379 * rule, which will in turn call show_protocols and access 1380 * dev->enabled_protocols before it has been initialized. 1381 */ 1382 mutex_lock(&dev->lock); 1383 1384 rc = device_add(&dev->dev); 1385 if (rc) 1386 goto out_unlock; 1387 1388 rc = ir_setkeytable(dev, rc_map); 1389 if (rc) 1390 goto out_dev; 1391 1392 dev->input_dev->dev.parent = &dev->dev; 1393 memcpy(&dev->input_dev->id, &dev->input_id, sizeof(dev->input_id)); 1394 dev->input_dev->phys = dev->input_phys; 1395 dev->input_dev->name = dev->input_name; 1396 1397 /* input_register_device can call ir_open, so unlock mutex here */ 1398 mutex_unlock(&dev->lock); 1399 1400 rc = input_register_device(dev->input_dev); 1401 1402 mutex_lock(&dev->lock); 1403 1404 if (rc) 1405 goto out_table; 1406 1407 /* 1408 * Default delay of 250ms is too short for some protocols, especially 1409 * since the timeout is currently set to 250ms. Increase it to 500ms, 1410 * to avoid wrong repetition of the keycodes. Note that this must be 1411 * set after the call to input_register_device(). 1412 */ 1413 dev->input_dev->rep[REP_DELAY] = 500; 1414 1415 /* 1416 * As a repeat event on protocols like RC-5 and NEC take as long as 1417 * 110/114ms, using 33ms as a repeat period is not the right thing 1418 * to do. 1419 */ 1420 dev->input_dev->rep[REP_PERIOD] = 125; 1421 1422 path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL); 1423 printk(KERN_INFO "%s: %s as %s\n", 1424 dev_name(&dev->dev), 1425 dev->input_name ? dev->input_name : "Unspecified device", 1426 path ? path : "N/A"); 1427 kfree(path); 1428 1429 if (dev->driver_type == RC_DRIVER_IR_RAW) { 1430 /* Load raw decoders, if they aren't already */ 1431 if (!raw_init) { 1432 IR_dprintk(1, "Loading raw decoders\n"); 1433 ir_raw_init(); 1434 raw_init = true; 1435 } 1436 /* calls ir_register_device so unlock mutex here*/ 1437 mutex_unlock(&dev->lock); 1438 rc = ir_raw_event_register(dev); 1439 mutex_lock(&dev->lock); 1440 if (rc < 0) 1441 goto out_input; 1442 } 1443 1444 if (dev->change_protocol) { 1445 u64 rc_type = (1ll << rc_map->rc_type); 1446 rc = dev->change_protocol(dev, &rc_type); 1447 if (rc < 0) 1448 goto out_raw; 1449 dev->enabled_protocols = rc_type; 1450 } 1451 1452 mutex_unlock(&dev->lock); 1453 1454 IR_dprintk(1, "Registered rc%u (driver: %s, remote: %s, mode %s)\n", 1455 dev->minor, 1456 dev->driver_name ? dev->driver_name : "unknown", 1457 rc_map->name ? rc_map->name : "unknown", 1458 dev->driver_type == RC_DRIVER_IR_RAW ? "raw" : "cooked"); 1459 1460 return 0; 1461 1462out_raw: 1463 if (dev->driver_type == RC_DRIVER_IR_RAW) 1464 ir_raw_event_unregister(dev); 1465out_input: 1466 input_unregister_device(dev->input_dev); 1467 dev->input_dev = NULL; 1468out_table: 1469 ir_free_table(&dev->rc_map); 1470out_dev: 1471 device_del(&dev->dev); 1472out_unlock: 1473 mutex_unlock(&dev->lock); 1474 ida_simple_remove(&rc_ida, minor); 1475 return rc; 1476} 1477EXPORT_SYMBOL_GPL(rc_register_device); 1478 1479void rc_unregister_device(struct rc_dev *dev) 1480{ 1481 if (!dev) 1482 return; 1483 1484 del_timer_sync(&dev->timer_keyup); 1485 1486 if (dev->driver_type == RC_DRIVER_IR_RAW) 1487 ir_raw_event_unregister(dev); 1488 1489 /* Freeing the table should also call the stop callback */ 1490 ir_free_table(&dev->rc_map); 1491 IR_dprintk(1, "Freed keycode table\n"); 1492 1493 input_unregister_device(dev->input_dev); 1494 dev->input_dev = NULL; 1495 1496 device_del(&dev->dev); 1497 1498 ida_simple_remove(&rc_ida, dev->minor); 1499 1500 rc_free_device(dev); 1501} 1502 1503EXPORT_SYMBOL_GPL(rc_unregister_device); 1504 1505/* 1506 * Init/exit code for the module. Basically, creates/removes /sys/class/rc 1507 */ 1508 1509static int __init rc_core_init(void) 1510{ 1511 int rc = class_register(&rc_class); 1512 if (rc) { 1513 printk(KERN_ERR "rc_core: unable to register rc class\n"); 1514 return rc; 1515 } 1516 1517 led_trigger_register_simple("rc-feedback", &led_feedback); 1518 rc_map_register(&empty_map); 1519 1520 return 0; 1521} 1522 1523static void __exit rc_core_exit(void) 1524{ 1525 class_unregister(&rc_class); 1526 led_trigger_unregister_simple(led_feedback); 1527 rc_map_unregister(&empty_map); 1528} 1529 1530subsys_initcall(rc_core_init); 1531module_exit(rc_core_exit); 1532 1533int rc_core_debug; /* ir_debug level (0,1,2) */ 1534EXPORT_SYMBOL_GPL(rc_core_debug); 1535module_param_named(debug, rc_core_debug, int, 0644); 1536 1537MODULE_AUTHOR("Mauro Carvalho Chehab"); 1538MODULE_LICENSE("GPL"); 1539