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