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