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