1// SPDX-License-Identifier: GPL-2.0 2// rc-main.c - Remote Controller core module 3// 4// Copyright (C) 2009-2010 by Mauro Carvalho Chehab 5 6#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 7 8#include <media/rc-core.h> 9#include <linux/bsearch.h> 10#include <linux/spinlock.h> 11#include <linux/delay.h> 12#include <linux/input.h> 13#include <linux/leds.h> 14#include <linux/slab.h> 15#include <linux/idr.h> 16#include <linux/device.h> 17#include <linux/module.h> 18#include "rc-core-priv.h" 19 20/* Sizes are in bytes, 256 bytes allows for 32 entries on x64 */ 21#define IR_TAB_MIN_SIZE 256 22#define IR_TAB_MAX_SIZE 8192 23 24static const struct { 25 const char *name; 26 unsigned int repeat_period; 27 unsigned int scancode_bits; 28} protocols[] = { 29 [RC_PROTO_UNKNOWN] = { .name = "unknown", .repeat_period = 125 }, 30 [RC_PROTO_OTHER] = { .name = "other", .repeat_period = 125 }, 31 [RC_PROTO_RC5] = { .name = "rc-5", 32 .scancode_bits = 0x1f7f, .repeat_period = 114 }, 33 [RC_PROTO_RC5X_20] = { .name = "rc-5x-20", 34 .scancode_bits = 0x1f7f3f, .repeat_period = 114 }, 35 [RC_PROTO_RC5_SZ] = { .name = "rc-5-sz", 36 .scancode_bits = 0x2fff, .repeat_period = 114 }, 37 [RC_PROTO_JVC] = { .name = "jvc", 38 .scancode_bits = 0xffff, .repeat_period = 125 }, 39 [RC_PROTO_SONY12] = { .name = "sony-12", 40 .scancode_bits = 0x1f007f, .repeat_period = 100 }, 41 [RC_PROTO_SONY15] = { .name = "sony-15", 42 .scancode_bits = 0xff007f, .repeat_period = 100 }, 43 [RC_PROTO_SONY20] = { .name = "sony-20", 44 .scancode_bits = 0x1fff7f, .repeat_period = 100 }, 45 [RC_PROTO_NEC] = { .name = "nec", 46 .scancode_bits = 0xffff, .repeat_period = 110 }, 47 [RC_PROTO_NECX] = { .name = "nec-x", 48 .scancode_bits = 0xffffff, .repeat_period = 110 }, 49 [RC_PROTO_NEC32] = { .name = "nec-32", 50 .scancode_bits = 0xffffffff, .repeat_period = 110 }, 51 [RC_PROTO_SANYO] = { .name = "sanyo", 52 .scancode_bits = 0x1fffff, .repeat_period = 125 }, 53 [RC_PROTO_MCIR2_KBD] = { .name = "mcir2-kbd", 54 .scancode_bits = 0xffffff, .repeat_period = 100 }, 55 [RC_PROTO_MCIR2_MSE] = { .name = "mcir2-mse", 56 .scancode_bits = 0x1fffff, .repeat_period = 100 }, 57 [RC_PROTO_RC6_0] = { .name = "rc-6-0", 58 .scancode_bits = 0xffff, .repeat_period = 114 }, 59 [RC_PROTO_RC6_6A_20] = { .name = "rc-6-6a-20", 60 .scancode_bits = 0xfffff, .repeat_period = 114 }, 61 [RC_PROTO_RC6_6A_24] = { .name = "rc-6-6a-24", 62 .scancode_bits = 0xffffff, .repeat_period = 114 }, 63 [RC_PROTO_RC6_6A_32] = { .name = "rc-6-6a-32", 64 .scancode_bits = 0xffffffff, .repeat_period = 114 }, 65 [RC_PROTO_RC6_MCE] = { .name = "rc-6-mce", 66 .scancode_bits = 0xffff7fff, .repeat_period = 114 }, 67 [RC_PROTO_SHARP] = { .name = "sharp", 68 .scancode_bits = 0x1fff, .repeat_period = 125 }, 69 [RC_PROTO_XMP] = { .name = "xmp", .repeat_period = 125 }, 70 [RC_PROTO_CEC] = { .name = "cec", .repeat_period = 0 }, 71 [RC_PROTO_IMON] = { .name = "imon", 72 .scancode_bits = 0x7fffffff, .repeat_period = 114 }, 73 [RC_PROTO_RCMM12] = { .name = "rc-mm-12", 74 .scancode_bits = 0x00000fff, .repeat_period = 114 }, 75 [RC_PROTO_RCMM24] = { .name = "rc-mm-24", 76 .scancode_bits = 0x00ffffff, .repeat_period = 114 }, 77 [RC_PROTO_RCMM32] = { .name = "rc-mm-32", 78 .scancode_bits = 0xffffffff, .repeat_period = 114 }, 79 [RC_PROTO_XBOX_DVD] = { .name = "xbox-dvd", .repeat_period = 64 }, 80}; 81 82/* Used to keep track of known keymaps */ 83static LIST_HEAD(rc_map_list); 84static DEFINE_SPINLOCK(rc_map_lock); 85static struct led_trigger *led_feedback; 86 87/* Used to keep track of rc devices */ 88static DEFINE_IDA(rc_ida); 89 90static struct rc_map_list *seek_rc_map(const char *name) 91{ 92 struct rc_map_list *map = NULL; 93 94 spin_lock(&rc_map_lock); 95 list_for_each_entry(map, &rc_map_list, list) { 96 if (!strcmp(name, map->map.name)) { 97 spin_unlock(&rc_map_lock); 98 return map; 99 } 100 } 101 spin_unlock(&rc_map_lock); 102 103 return NULL; 104} 105 106struct rc_map *rc_map_get(const char *name) 107{ 108 109 struct rc_map_list *map; 110 111 map = seek_rc_map(name); 112#ifdef CONFIG_MODULES 113 if (!map) { 114 int rc = request_module("%s", name); 115 if (rc < 0) { 116 pr_err("Couldn't load IR keymap %s\n", name); 117 return NULL; 118 } 119 msleep(20); /* Give some time for IR to register */ 120 121 map = seek_rc_map(name); 122 } 123#endif 124 if (!map) { 125 pr_err("IR keymap %s not found\n", name); 126 return NULL; 127 } 128 129 printk(KERN_INFO "Registered IR keymap %s\n", map->map.name); 130 131 return &map->map; 132} 133EXPORT_SYMBOL_GPL(rc_map_get); 134 135int rc_map_register(struct rc_map_list *map) 136{ 137 spin_lock(&rc_map_lock); 138 list_add_tail(&map->list, &rc_map_list); 139 spin_unlock(&rc_map_lock); 140 return 0; 141} 142EXPORT_SYMBOL_GPL(rc_map_register); 143 144void rc_map_unregister(struct rc_map_list *map) 145{ 146 spin_lock(&rc_map_lock); 147 list_del(&map->list); 148 spin_unlock(&rc_map_lock); 149} 150EXPORT_SYMBOL_GPL(rc_map_unregister); 151 152 153static struct rc_map_table empty[] = { 154 { 0x2a, KEY_COFFEE }, 155}; 156 157static struct rc_map_list empty_map = { 158 .map = { 159 .scan = empty, 160 .size = ARRAY_SIZE(empty), 161 .rc_proto = RC_PROTO_UNKNOWN, /* Legacy IR type */ 162 .name = RC_MAP_EMPTY, 163 } 164}; 165 166/** 167 * scancode_to_u64() - converts scancode in &struct input_keymap_entry 168 * @ke: keymap entry containing scancode to be converted. 169 * @scancode: pointer to the location where converted scancode should 170 * be stored. 171 * 172 * This function is a version of input_scancode_to_scalar specialized for 173 * rc-core. 174 */ 175static int scancode_to_u64(const struct input_keymap_entry *ke, u64 *scancode) 176{ 177 switch (ke->len) { 178 case 1: 179 *scancode = *((u8 *)ke->scancode); 180 break; 181 182 case 2: 183 *scancode = *((u16 *)ke->scancode); 184 break; 185 186 case 4: 187 *scancode = *((u32 *)ke->scancode); 188 break; 189 190 case 8: 191 *scancode = *((u64 *)ke->scancode); 192 break; 193 194 default: 195 return -EINVAL; 196 } 197 198 return 0; 199} 200 201/** 202 * ir_create_table() - initializes a scancode table 203 * @dev: the rc_dev device 204 * @rc_map: the rc_map to initialize 205 * @name: name to assign to the table 206 * @rc_proto: ir type to assign to the new table 207 * @size: initial size of the table 208 * 209 * This routine will initialize the rc_map and will allocate 210 * memory to hold at least the specified number of elements. 211 * 212 * return: zero on success or a negative error code 213 */ 214static int ir_create_table(struct rc_dev *dev, struct rc_map *rc_map, 215 const char *name, u64 rc_proto, size_t size) 216{ 217 rc_map->name = kstrdup(name, GFP_KERNEL); 218 if (!rc_map->name) 219 return -ENOMEM; 220 rc_map->rc_proto = rc_proto; 221 rc_map->alloc = roundup_pow_of_two(size * sizeof(struct rc_map_table)); 222 rc_map->size = rc_map->alloc / sizeof(struct rc_map_table); 223 rc_map->scan = kmalloc(rc_map->alloc, GFP_KERNEL); 224 if (!rc_map->scan) { 225 kfree(rc_map->name); 226 rc_map->name = NULL; 227 return -ENOMEM; 228 } 229 230 dev_dbg(&dev->dev, "Allocated space for %u keycode entries (%u bytes)\n", 231 rc_map->size, rc_map->alloc); 232 return 0; 233} 234 235/** 236 * ir_free_table() - frees memory allocated by a scancode table 237 * @rc_map: the table whose mappings need to be freed 238 * 239 * This routine will free memory alloctaed for key mappings used by given 240 * scancode table. 241 */ 242static void ir_free_table(struct rc_map *rc_map) 243{ 244 rc_map->size = 0; 245 kfree(rc_map->name); 246 rc_map->name = NULL; 247 kfree(rc_map->scan); 248 rc_map->scan = NULL; 249} 250 251/** 252 * ir_resize_table() - resizes a scancode table if necessary 253 * @dev: the rc_dev device 254 * @rc_map: the rc_map to resize 255 * @gfp_flags: gfp flags to use when allocating memory 256 * 257 * This routine will shrink the rc_map if it has lots of 258 * unused entries and grow it if it is full. 259 * 260 * return: zero on success or a negative error code 261 */ 262static int ir_resize_table(struct rc_dev *dev, struct rc_map *rc_map, 263 gfp_t gfp_flags) 264{ 265 unsigned int oldalloc = rc_map->alloc; 266 unsigned int newalloc = oldalloc; 267 struct rc_map_table *oldscan = rc_map->scan; 268 struct rc_map_table *newscan; 269 270 if (rc_map->size == rc_map->len) { 271 /* All entries in use -> grow keytable */ 272 if (rc_map->alloc >= IR_TAB_MAX_SIZE) 273 return -ENOMEM; 274 275 newalloc *= 2; 276 dev_dbg(&dev->dev, "Growing table to %u bytes\n", newalloc); 277 } 278 279 if ((rc_map->len * 3 < rc_map->size) && (oldalloc > IR_TAB_MIN_SIZE)) { 280 /* Less than 1/3 of entries in use -> shrink keytable */ 281 newalloc /= 2; 282 dev_dbg(&dev->dev, "Shrinking table to %u bytes\n", newalloc); 283 } 284 285 if (newalloc == oldalloc) 286 return 0; 287 288 newscan = kmalloc(newalloc, gfp_flags); 289 if (!newscan) 290 return -ENOMEM; 291 292 memcpy(newscan, rc_map->scan, rc_map->len * sizeof(struct rc_map_table)); 293 rc_map->scan = newscan; 294 rc_map->alloc = newalloc; 295 rc_map->size = rc_map->alloc / sizeof(struct rc_map_table); 296 kfree(oldscan); 297 return 0; 298} 299 300/** 301 * ir_update_mapping() - set a keycode in the scancode->keycode table 302 * @dev: the struct rc_dev device descriptor 303 * @rc_map: scancode table to be adjusted 304 * @index: index of the mapping that needs to be updated 305 * @new_keycode: the desired keycode 306 * 307 * This routine is used to update scancode->keycode mapping at given 308 * position. 309 * 310 * return: previous keycode assigned to the mapping 311 * 312 */ 313static unsigned int ir_update_mapping(struct rc_dev *dev, 314 struct rc_map *rc_map, 315 unsigned int index, 316 unsigned int new_keycode) 317{ 318 int old_keycode = rc_map->scan[index].keycode; 319 int i; 320 321 /* Did the user wish to remove the mapping? */ 322 if (new_keycode == KEY_RESERVED || new_keycode == KEY_UNKNOWN) { 323 dev_dbg(&dev->dev, "#%d: Deleting scan 0x%04llx\n", 324 index, rc_map->scan[index].scancode); 325 rc_map->len--; 326 memmove(&rc_map->scan[index], &rc_map->scan[index+ 1], 327 (rc_map->len - index) * sizeof(struct rc_map_table)); 328 } else { 329 dev_dbg(&dev->dev, "#%d: %s scan 0x%04llx with key 0x%04x\n", 330 index, 331 old_keycode == KEY_RESERVED ? "New" : "Replacing", 332 rc_map->scan[index].scancode, new_keycode); 333 rc_map->scan[index].keycode = new_keycode; 334 __set_bit(new_keycode, dev->input_dev->keybit); 335 } 336 337 if (old_keycode != KEY_RESERVED) { 338 /* A previous mapping was updated... */ 339 __clear_bit(old_keycode, dev->input_dev->keybit); 340 /* ... but another scancode might use the same keycode */ 341 for (i = 0; i < rc_map->len; i++) { 342 if (rc_map->scan[i].keycode == old_keycode) { 343 __set_bit(old_keycode, dev->input_dev->keybit); 344 break; 345 } 346 } 347 348 /* Possibly shrink the keytable, failure is not a problem */ 349 ir_resize_table(dev, rc_map, GFP_ATOMIC); 350 } 351 352 return old_keycode; 353} 354 355/** 356 * ir_establish_scancode() - set a keycode in the scancode->keycode table 357 * @dev: the struct rc_dev device descriptor 358 * @rc_map: scancode table to be searched 359 * @scancode: the desired scancode 360 * @resize: controls whether we allowed to resize the table to 361 * accommodate not yet present scancodes 362 * 363 * This routine is used to locate given scancode in rc_map. 364 * If scancode is not yet present the routine will allocate a new slot 365 * for it. 366 * 367 * return: index of the mapping containing scancode in question 368 * or -1U in case of failure. 369 */ 370static unsigned int ir_establish_scancode(struct rc_dev *dev, 371 struct rc_map *rc_map, 372 u64 scancode, bool resize) 373{ 374 unsigned int i; 375 376 /* 377 * Unfortunately, some hardware-based IR decoders don't provide 378 * all bits for the complete IR code. In general, they provide only 379 * the command part of the IR code. Yet, as it is possible to replace 380 * the provided IR with another one, it is needed to allow loading 381 * IR tables from other remotes. So, we support specifying a mask to 382 * indicate the valid bits of the scancodes. 383 */ 384 if (dev->scancode_mask) 385 scancode &= dev->scancode_mask; 386 387 /* First check if we already have a mapping for this ir command */ 388 for (i = 0; i < rc_map->len; i++) { 389 if (rc_map->scan[i].scancode == scancode) 390 return i; 391 392 /* Keytable is sorted from lowest to highest scancode */ 393 if (rc_map->scan[i].scancode >= scancode) 394 break; 395 } 396 397 /* No previous mapping found, we might need to grow the table */ 398 if (rc_map->size == rc_map->len) { 399 if (!resize || ir_resize_table(dev, rc_map, GFP_ATOMIC)) 400 return -1U; 401 } 402 403 /* i is the proper index to insert our new keycode */ 404 if (i < rc_map->len) 405 memmove(&rc_map->scan[i + 1], &rc_map->scan[i], 406 (rc_map->len - i) * sizeof(struct rc_map_table)); 407 rc_map->scan[i].scancode = scancode; 408 rc_map->scan[i].keycode = KEY_RESERVED; 409 rc_map->len++; 410 411 return i; 412} 413 414/** 415 * ir_setkeycode() - set a keycode in the scancode->keycode table 416 * @idev: the struct input_dev device descriptor 417 * @ke: Input keymap entry 418 * @old_keycode: result 419 * 420 * This routine is used to handle evdev EVIOCSKEY ioctl. 421 * 422 * return: -EINVAL if the keycode could not be inserted, otherwise zero. 423 */ 424static int ir_setkeycode(struct input_dev *idev, 425 const struct input_keymap_entry *ke, 426 unsigned int *old_keycode) 427{ 428 struct rc_dev *rdev = input_get_drvdata(idev); 429 struct rc_map *rc_map = &rdev->rc_map; 430 unsigned int index; 431 u64 scancode; 432 int retval = 0; 433 unsigned long flags; 434 435 spin_lock_irqsave(&rc_map->lock, flags); 436 437 if (ke->flags & INPUT_KEYMAP_BY_INDEX) { 438 index = ke->index; 439 if (index >= rc_map->len) { 440 retval = -EINVAL; 441 goto out; 442 } 443 } else { 444 retval = scancode_to_u64(ke, &scancode); 445 if (retval) 446 goto out; 447 448 index = ir_establish_scancode(rdev, rc_map, scancode, true); 449 if (index >= rc_map->len) { 450 retval = -ENOMEM; 451 goto out; 452 } 453 } 454 455 *old_keycode = ir_update_mapping(rdev, rc_map, index, ke->keycode); 456 457out: 458 spin_unlock_irqrestore(&rc_map->lock, flags); 459 return retval; 460} 461 462/** 463 * ir_setkeytable() - sets several entries in the scancode->keycode table 464 * @dev: the struct rc_dev device descriptor 465 * @from: the struct rc_map to copy entries from 466 * 467 * This routine is used to handle table initialization. 468 * 469 * return: -ENOMEM if all keycodes could not be inserted, otherwise zero. 470 */ 471static int ir_setkeytable(struct rc_dev *dev, const struct rc_map *from) 472{ 473 struct rc_map *rc_map = &dev->rc_map; 474 unsigned int i, index; 475 int rc; 476 477 rc = ir_create_table(dev, rc_map, from->name, from->rc_proto, 478 from->size); 479 if (rc) 480 return rc; 481 482 for (i = 0; i < from->size; i++) { 483 index = ir_establish_scancode(dev, rc_map, 484 from->scan[i].scancode, false); 485 if (index >= rc_map->len) { 486 rc = -ENOMEM; 487 break; 488 } 489 490 ir_update_mapping(dev, rc_map, index, 491 from->scan[i].keycode); 492 } 493 494 if (rc) 495 ir_free_table(rc_map); 496 497 return rc; 498} 499 500static int rc_map_cmp(const void *key, const void *elt) 501{ 502 const u64 *scancode = key; 503 const struct rc_map_table *e = elt; 504 505 if (*scancode < e->scancode) 506 return -1; 507 else if (*scancode > e->scancode) 508 return 1; 509 return 0; 510} 511 512/** 513 * ir_lookup_by_scancode() - locate mapping by scancode 514 * @rc_map: the struct rc_map to search 515 * @scancode: scancode to look for in the table 516 * 517 * This routine performs binary search in RC keykeymap table for 518 * given scancode. 519 * 520 * return: index in the table, -1U if not found 521 */ 522static unsigned int ir_lookup_by_scancode(const struct rc_map *rc_map, 523 u64 scancode) 524{ 525 struct rc_map_table *res; 526 527 res = bsearch(&scancode, rc_map->scan, rc_map->len, 528 sizeof(struct rc_map_table), rc_map_cmp); 529 if (!res) 530 return -1U; 531 else 532 return res - rc_map->scan; 533} 534 535/** 536 * ir_getkeycode() - get a keycode from the scancode->keycode table 537 * @idev: the struct input_dev device descriptor 538 * @ke: Input keymap entry 539 * 540 * This routine is used to handle evdev EVIOCGKEY ioctl. 541 * 542 * return: always returns zero. 543 */ 544static int ir_getkeycode(struct input_dev *idev, 545 struct input_keymap_entry *ke) 546{ 547 struct rc_dev *rdev = input_get_drvdata(idev); 548 struct rc_map *rc_map = &rdev->rc_map; 549 struct rc_map_table *entry; 550 unsigned long flags; 551 unsigned int index; 552 u64 scancode; 553 int retval; 554 555 spin_lock_irqsave(&rc_map->lock, flags); 556 557 if (ke->flags & INPUT_KEYMAP_BY_INDEX) { 558 index = ke->index; 559 } else { 560 retval = scancode_to_u64(ke, &scancode); 561 if (retval) 562 goto out; 563 564 index = ir_lookup_by_scancode(rc_map, scancode); 565 } 566 567 if (index < rc_map->len) { 568 entry = &rc_map->scan[index]; 569 570 ke->index = index; 571 ke->keycode = entry->keycode; 572 ke->len = sizeof(entry->scancode); 573 memcpy(ke->scancode, &entry->scancode, sizeof(entry->scancode)); 574 } else if (!(ke->flags & INPUT_KEYMAP_BY_INDEX)) { 575 /* 576 * We do not really know the valid range of scancodes 577 * so let's respond with KEY_RESERVED to anything we 578 * do not have mapping for [yet]. 579 */ 580 ke->index = index; 581 ke->keycode = KEY_RESERVED; 582 } else { 583 retval = -EINVAL; 584 goto out; 585 } 586 587 retval = 0; 588 589out: 590 spin_unlock_irqrestore(&rc_map->lock, flags); 591 return retval; 592} 593 594/** 595 * rc_g_keycode_from_table() - gets the keycode that corresponds to a scancode 596 * @dev: the struct rc_dev descriptor of the device 597 * @scancode: the scancode to look for 598 * 599 * This routine is used by drivers which need to convert a scancode to a 600 * keycode. Normally it should not be used since drivers should have no 601 * interest in keycodes. 602 * 603 * return: the corresponding keycode, or KEY_RESERVED 604 */ 605u32 rc_g_keycode_from_table(struct rc_dev *dev, u64 scancode) 606{ 607 struct rc_map *rc_map = &dev->rc_map; 608 unsigned int keycode; 609 unsigned int index; 610 unsigned long flags; 611 612 spin_lock_irqsave(&rc_map->lock, flags); 613 614 index = ir_lookup_by_scancode(rc_map, scancode); 615 keycode = index < rc_map->len ? 616 rc_map->scan[index].keycode : KEY_RESERVED; 617 618 spin_unlock_irqrestore(&rc_map->lock, flags); 619 620 if (keycode != KEY_RESERVED) 621 dev_dbg(&dev->dev, "%s: scancode 0x%04llx keycode 0x%02x\n", 622 dev->device_name, scancode, keycode); 623 624 return keycode; 625} 626EXPORT_SYMBOL_GPL(rc_g_keycode_from_table); 627 628/** 629 * ir_do_keyup() - internal function to signal the release of a keypress 630 * @dev: the struct rc_dev descriptor of the device 631 * @sync: whether or not to call input_sync 632 * 633 * This function is used internally to release a keypress, it must be 634 * called with keylock held. 635 */ 636static void ir_do_keyup(struct rc_dev *dev, bool sync) 637{ 638 if (!dev->keypressed) 639 return; 640 641 dev_dbg(&dev->dev, "keyup key 0x%04x\n", dev->last_keycode); 642 del_timer(&dev->timer_repeat); 643 input_report_key(dev->input_dev, dev->last_keycode, 0); 644 led_trigger_event(led_feedback, LED_OFF); 645 if (sync) 646 input_sync(dev->input_dev); 647 dev->keypressed = false; 648} 649 650/** 651 * rc_keyup() - signals the release of a keypress 652 * @dev: the struct rc_dev descriptor of the device 653 * 654 * This routine is used to signal that a key has been released on the 655 * remote control. 656 */ 657void rc_keyup(struct rc_dev *dev) 658{ 659 unsigned long flags; 660 661 spin_lock_irqsave(&dev->keylock, flags); 662 ir_do_keyup(dev, true); 663 spin_unlock_irqrestore(&dev->keylock, flags); 664} 665EXPORT_SYMBOL_GPL(rc_keyup); 666 667/** 668 * ir_timer_keyup() - generates a keyup event after a timeout 669 * 670 * @t: a pointer to the struct timer_list 671 * 672 * This routine will generate a keyup event some time after a keydown event 673 * is generated when no further activity has been detected. 674 */ 675static void ir_timer_keyup(struct timer_list *t) 676{ 677 struct rc_dev *dev = from_timer(dev, t, timer_keyup); 678 unsigned long flags; 679 680 /* 681 * ir->keyup_jiffies is used to prevent a race condition if a 682 * hardware interrupt occurs at this point and the keyup timer 683 * event is moved further into the future as a result. 684 * 685 * The timer will then be reactivated and this function called 686 * again in the future. We need to exit gracefully in that case 687 * to allow the input subsystem to do its auto-repeat magic or 688 * a keyup event might follow immediately after the keydown. 689 */ 690 spin_lock_irqsave(&dev->keylock, flags); 691 if (time_is_before_eq_jiffies(dev->keyup_jiffies)) 692 ir_do_keyup(dev, true); 693 spin_unlock_irqrestore(&dev->keylock, flags); 694} 695 696/** 697 * ir_timer_repeat() - generates a repeat event after a timeout 698 * 699 * @t: a pointer to the struct timer_list 700 * 701 * This routine will generate a soft repeat event every REP_PERIOD 702 * milliseconds. 703 */ 704static void ir_timer_repeat(struct timer_list *t) 705{ 706 struct rc_dev *dev = from_timer(dev, t, timer_repeat); 707 struct input_dev *input = dev->input_dev; 708 unsigned long flags; 709 710 spin_lock_irqsave(&dev->keylock, flags); 711 if (dev->keypressed) { 712 input_event(input, EV_KEY, dev->last_keycode, 2); 713 input_sync(input); 714 if (input->rep[REP_PERIOD]) 715 mod_timer(&dev->timer_repeat, jiffies + 716 msecs_to_jiffies(input->rep[REP_PERIOD])); 717 } 718 spin_unlock_irqrestore(&dev->keylock, flags); 719} 720 721static unsigned int repeat_period(int protocol) 722{ 723 if (protocol >= ARRAY_SIZE(protocols)) 724 return 100; 725 726 return protocols[protocol].repeat_period; 727} 728 729/** 730 * rc_repeat() - signals that a key is still pressed 731 * @dev: the struct rc_dev descriptor of the device 732 * 733 * This routine is used by IR decoders when a repeat message which does 734 * not include the necessary bits to reproduce the scancode has been 735 * received. 736 */ 737void rc_repeat(struct rc_dev *dev) 738{ 739 unsigned long flags; 740 unsigned int timeout = usecs_to_jiffies(dev->timeout) + 741 msecs_to_jiffies(repeat_period(dev->last_protocol)); 742 struct lirc_scancode sc = { 743 .scancode = dev->last_scancode, .rc_proto = dev->last_protocol, 744 .keycode = dev->keypressed ? dev->last_keycode : KEY_RESERVED, 745 .flags = LIRC_SCANCODE_FLAG_REPEAT | 746 (dev->last_toggle ? LIRC_SCANCODE_FLAG_TOGGLE : 0) 747 }; 748 749 if (dev->allowed_protocols != RC_PROTO_BIT_CEC) 750 lirc_scancode_event(dev, &sc); 751 752 spin_lock_irqsave(&dev->keylock, flags); 753 754 if (dev->last_scancode <= U32_MAX) { 755 input_event(dev->input_dev, EV_MSC, MSC_SCAN, 756 dev->last_scancode); 757 input_sync(dev->input_dev); 758 } 759 760 if (dev->keypressed) { 761 dev->keyup_jiffies = jiffies + timeout; 762 mod_timer(&dev->timer_keyup, dev->keyup_jiffies); 763 } 764 765 spin_unlock_irqrestore(&dev->keylock, flags); 766} 767EXPORT_SYMBOL_GPL(rc_repeat); 768 769/** 770 * ir_do_keydown() - internal function to process a keypress 771 * @dev: the struct rc_dev descriptor of the device 772 * @protocol: the protocol of the keypress 773 * @scancode: the scancode of the keypress 774 * @keycode: the keycode of the keypress 775 * @toggle: the toggle value of the keypress 776 * 777 * This function is used internally to register a keypress, it must be 778 * called with keylock held. 779 */ 780static void ir_do_keydown(struct rc_dev *dev, enum rc_proto protocol, 781 u64 scancode, u32 keycode, u8 toggle) 782{ 783 bool new_event = (!dev->keypressed || 784 dev->last_protocol != protocol || 785 dev->last_scancode != scancode || 786 dev->last_toggle != toggle); 787 struct lirc_scancode sc = { 788 .scancode = scancode, .rc_proto = protocol, 789 .flags = toggle ? LIRC_SCANCODE_FLAG_TOGGLE : 0, 790 .keycode = keycode 791 }; 792 793 if (dev->allowed_protocols != RC_PROTO_BIT_CEC) 794 lirc_scancode_event(dev, &sc); 795 796 if (new_event && dev->keypressed) 797 ir_do_keyup(dev, false); 798 799 if (scancode <= U32_MAX) 800 input_event(dev->input_dev, EV_MSC, MSC_SCAN, scancode); 801 802 dev->last_protocol = protocol; 803 dev->last_scancode = scancode; 804 dev->last_toggle = toggle; 805 dev->last_keycode = keycode; 806 807 if (new_event && keycode != KEY_RESERVED) { 808 /* Register a keypress */ 809 dev->keypressed = true; 810 811 dev_dbg(&dev->dev, "%s: key down event, key 0x%04x, protocol 0x%04x, scancode 0x%08llx\n", 812 dev->device_name, keycode, protocol, scancode); 813 input_report_key(dev->input_dev, keycode, 1); 814 815 led_trigger_event(led_feedback, LED_FULL); 816 } 817 818 /* 819 * For CEC, start sending repeat messages as soon as the first 820 * repeated message is sent, as long as REP_DELAY = 0 and REP_PERIOD 821 * is non-zero. Otherwise, the input layer will generate repeat 822 * messages. 823 */ 824 if (!new_event && keycode != KEY_RESERVED && 825 dev->allowed_protocols == RC_PROTO_BIT_CEC && 826 !timer_pending(&dev->timer_repeat) && 827 dev->input_dev->rep[REP_PERIOD] && 828 !dev->input_dev->rep[REP_DELAY]) { 829 input_event(dev->input_dev, EV_KEY, keycode, 2); 830 mod_timer(&dev->timer_repeat, jiffies + 831 msecs_to_jiffies(dev->input_dev->rep[REP_PERIOD])); 832 } 833 834 input_sync(dev->input_dev); 835} 836 837/** 838 * rc_keydown() - generates input event for a key press 839 * @dev: the struct rc_dev descriptor of the device 840 * @protocol: the protocol for the keypress 841 * @scancode: the scancode for the keypress 842 * @toggle: the toggle value (protocol dependent, if the protocol doesn't 843 * support toggle values, this should be set to zero) 844 * 845 * This routine is used to signal that a key has been pressed on the 846 * remote control. 847 */ 848void rc_keydown(struct rc_dev *dev, enum rc_proto protocol, u64 scancode, 849 u8 toggle) 850{ 851 unsigned long flags; 852 u32 keycode = rc_g_keycode_from_table(dev, scancode); 853 854 spin_lock_irqsave(&dev->keylock, flags); 855 ir_do_keydown(dev, protocol, scancode, keycode, toggle); 856 857 if (dev->keypressed) { 858 dev->keyup_jiffies = jiffies + usecs_to_jiffies(dev->timeout) + 859 msecs_to_jiffies(repeat_period(protocol)); 860 mod_timer(&dev->timer_keyup, dev->keyup_jiffies); 861 } 862 spin_unlock_irqrestore(&dev->keylock, flags); 863} 864EXPORT_SYMBOL_GPL(rc_keydown); 865 866/** 867 * rc_keydown_notimeout() - generates input event for a key press without 868 * an automatic keyup event at a later time 869 * @dev: the struct rc_dev descriptor of the device 870 * @protocol: the protocol for the keypress 871 * @scancode: the scancode for the keypress 872 * @toggle: the toggle value (protocol dependent, if the protocol doesn't 873 * support toggle values, this should be set to zero) 874 * 875 * This routine is used to signal that a key has been pressed on the 876 * remote control. The driver must manually call rc_keyup() at a later stage. 877 */ 878void rc_keydown_notimeout(struct rc_dev *dev, enum rc_proto protocol, 879 u64 scancode, u8 toggle) 880{ 881 unsigned long flags; 882 u32 keycode = rc_g_keycode_from_table(dev, scancode); 883 884 spin_lock_irqsave(&dev->keylock, flags); 885 ir_do_keydown(dev, protocol, scancode, keycode, toggle); 886 spin_unlock_irqrestore(&dev->keylock, flags); 887} 888EXPORT_SYMBOL_GPL(rc_keydown_notimeout); 889 890/** 891 * rc_validate_scancode() - checks that a scancode is valid for a protocol. 892 * For nec, it should do the opposite of ir_nec_bytes_to_scancode() 893 * @proto: protocol 894 * @scancode: scancode 895 */ 896bool rc_validate_scancode(enum rc_proto proto, u32 scancode) 897{ 898 switch (proto) { 899 /* 900 * NECX has a 16-bit address; if the lower 8 bits match the upper 901 * 8 bits inverted, then the address would match regular nec. 902 */ 903 case RC_PROTO_NECX: 904 if ((((scancode >> 16) ^ ~(scancode >> 8)) & 0xff) == 0) 905 return false; 906 break; 907 /* 908 * NEC32 has a 16 bit address and 16 bit command. If the lower 8 bits 909 * of the command match the upper 8 bits inverted, then it would 910 * be either NEC or NECX. 911 */ 912 case RC_PROTO_NEC32: 913 if ((((scancode >> 8) ^ ~scancode) & 0xff) == 0) 914 return false; 915 break; 916 /* 917 * If the customer code (top 32-bit) is 0x800f, it is MCE else it 918 * is regular mode-6a 32 bit 919 */ 920 case RC_PROTO_RC6_MCE: 921 if ((scancode & 0xffff0000) != 0x800f0000) 922 return false; 923 break; 924 case RC_PROTO_RC6_6A_32: 925 if ((scancode & 0xffff0000) == 0x800f0000) 926 return false; 927 break; 928 default: 929 break; 930 } 931 932 return true; 933} 934 935/** 936 * rc_validate_filter() - checks that the scancode and mask are valid and 937 * provides sensible defaults 938 * @dev: the struct rc_dev descriptor of the device 939 * @filter: the scancode and mask 940 * 941 * return: 0 or -EINVAL if the filter is not valid 942 */ 943static int rc_validate_filter(struct rc_dev *dev, 944 struct rc_scancode_filter *filter) 945{ 946 u32 mask, s = filter->data; 947 enum rc_proto protocol = dev->wakeup_protocol; 948 949 if (protocol >= ARRAY_SIZE(protocols)) 950 return -EINVAL; 951 952 mask = protocols[protocol].scancode_bits; 953 954 if (!rc_validate_scancode(protocol, s)) 955 return -EINVAL; 956 957 filter->data &= mask; 958 filter->mask &= mask; 959 960 /* 961 * If we have to raw encode the IR for wakeup, we cannot have a mask 962 */ 963 if (dev->encode_wakeup && filter->mask != 0 && filter->mask != mask) 964 return -EINVAL; 965 966 return 0; 967} 968 969int rc_open(struct rc_dev *rdev) 970{ 971 int rval = 0; 972 973 if (!rdev) 974 return -EINVAL; 975 976 mutex_lock(&rdev->lock); 977 978 if (!rdev->registered) { 979 rval = -ENODEV; 980 } else { 981 if (!rdev->users++ && rdev->open) 982 rval = rdev->open(rdev); 983 984 if (rval) 985 rdev->users--; 986 } 987 988 mutex_unlock(&rdev->lock); 989 990 return rval; 991} 992 993static int ir_open(struct input_dev *idev) 994{ 995 struct rc_dev *rdev = input_get_drvdata(idev); 996 997 return rc_open(rdev); 998} 999 1000void rc_close(struct rc_dev *rdev) 1001{ 1002 if (rdev) { 1003 mutex_lock(&rdev->lock); 1004 1005 if (!--rdev->users && rdev->close && rdev->registered) 1006 rdev->close(rdev); 1007 1008 mutex_unlock(&rdev->lock); 1009 } 1010} 1011 1012static void ir_close(struct input_dev *idev) 1013{ 1014 struct rc_dev *rdev = input_get_drvdata(idev); 1015 rc_close(rdev); 1016} 1017 1018/* class for /sys/class/rc */ 1019static char *rc_devnode(struct device *dev, umode_t *mode) 1020{ 1021 return kasprintf(GFP_KERNEL, "rc/%s", dev_name(dev)); 1022} 1023 1024static struct class rc_class = { 1025 .name = "rc", 1026 .devnode = rc_devnode, 1027}; 1028 1029/* 1030 * These are the protocol textual descriptions that are 1031 * used by the sysfs protocols file. Note that the order 1032 * of the entries is relevant. 1033 */ 1034static const struct { 1035 u64 type; 1036 const char *name; 1037 const char *module_name; 1038} proto_names[] = { 1039 { RC_PROTO_BIT_NONE, "none", NULL }, 1040 { RC_PROTO_BIT_OTHER, "other", NULL }, 1041 { RC_PROTO_BIT_UNKNOWN, "unknown", NULL }, 1042 { RC_PROTO_BIT_RC5 | 1043 RC_PROTO_BIT_RC5X_20, "rc-5", "ir-rc5-decoder" }, 1044 { RC_PROTO_BIT_NEC | 1045 RC_PROTO_BIT_NECX | 1046 RC_PROTO_BIT_NEC32, "nec", "ir-nec-decoder" }, 1047 { RC_PROTO_BIT_RC6_0 | 1048 RC_PROTO_BIT_RC6_6A_20 | 1049 RC_PROTO_BIT_RC6_6A_24 | 1050 RC_PROTO_BIT_RC6_6A_32 | 1051 RC_PROTO_BIT_RC6_MCE, "rc-6", "ir-rc6-decoder" }, 1052 { RC_PROTO_BIT_JVC, "jvc", "ir-jvc-decoder" }, 1053 { RC_PROTO_BIT_SONY12 | 1054 RC_PROTO_BIT_SONY15 | 1055 RC_PROTO_BIT_SONY20, "sony", "ir-sony-decoder" }, 1056 { RC_PROTO_BIT_RC5_SZ, "rc-5-sz", "ir-rc5-decoder" }, 1057 { RC_PROTO_BIT_SANYO, "sanyo", "ir-sanyo-decoder" }, 1058 { RC_PROTO_BIT_SHARP, "sharp", "ir-sharp-decoder" }, 1059 { RC_PROTO_BIT_MCIR2_KBD | 1060 RC_PROTO_BIT_MCIR2_MSE, "mce_kbd", "ir-mce_kbd-decoder" }, 1061 { RC_PROTO_BIT_XMP, "xmp", "ir-xmp-decoder" }, 1062 { RC_PROTO_BIT_CEC, "cec", NULL }, 1063 { RC_PROTO_BIT_IMON, "imon", "ir-imon-decoder" }, 1064 { RC_PROTO_BIT_RCMM12 | 1065 RC_PROTO_BIT_RCMM24 | 1066 RC_PROTO_BIT_RCMM32, "rc-mm", "ir-rcmm-decoder" }, 1067 { RC_PROTO_BIT_XBOX_DVD, "xbox-dvd", NULL }, 1068}; 1069 1070/** 1071 * struct rc_filter_attribute - Device attribute relating to a filter type. 1072 * @attr: Device attribute. 1073 * @type: Filter type. 1074 * @mask: false for filter value, true for filter mask. 1075 */ 1076struct rc_filter_attribute { 1077 struct device_attribute attr; 1078 enum rc_filter_type type; 1079 bool mask; 1080}; 1081#define to_rc_filter_attr(a) container_of(a, struct rc_filter_attribute, attr) 1082 1083#define RC_FILTER_ATTR(_name, _mode, _show, _store, _type, _mask) \ 1084 struct rc_filter_attribute dev_attr_##_name = { \ 1085 .attr = __ATTR(_name, _mode, _show, _store), \ 1086 .type = (_type), \ 1087 .mask = (_mask), \ 1088 } 1089 1090/** 1091 * show_protocols() - shows the current IR protocol(s) 1092 * @device: the device descriptor 1093 * @mattr: the device attribute struct 1094 * @buf: a pointer to the output buffer 1095 * 1096 * This routine is a callback routine for input read the IR protocol type(s). 1097 * it is triggered by reading /sys/class/rc/rc?/protocols. 1098 * It returns the protocol names of supported protocols. 1099 * Enabled protocols are printed in brackets. 1100 * 1101 * dev->lock is taken to guard against races between 1102 * store_protocols and show_protocols. 1103 */ 1104static ssize_t show_protocols(struct device *device, 1105 struct device_attribute *mattr, char *buf) 1106{ 1107 struct rc_dev *dev = to_rc_dev(device); 1108 u64 allowed, enabled; 1109 char *tmp = buf; 1110 int i; 1111 1112 mutex_lock(&dev->lock); 1113 1114 enabled = dev->enabled_protocols; 1115 allowed = dev->allowed_protocols; 1116 if (dev->raw && !allowed) 1117 allowed = ir_raw_get_allowed_protocols(); 1118 1119 mutex_unlock(&dev->lock); 1120 1121 dev_dbg(&dev->dev, "%s: allowed - 0x%llx, enabled - 0x%llx\n", 1122 __func__, (long long)allowed, (long long)enabled); 1123 1124 for (i = 0; i < ARRAY_SIZE(proto_names); i++) { 1125 if (allowed & enabled & proto_names[i].type) 1126 tmp += sprintf(tmp, "[%s] ", proto_names[i].name); 1127 else if (allowed & proto_names[i].type) 1128 tmp += sprintf(tmp, "%s ", proto_names[i].name); 1129 1130 if (allowed & proto_names[i].type) 1131 allowed &= ~proto_names[i].type; 1132 } 1133 1134#ifdef CONFIG_LIRC 1135 if (dev->driver_type == RC_DRIVER_IR_RAW) 1136 tmp += sprintf(tmp, "[lirc] "); 1137#endif 1138 1139 if (tmp != buf) 1140 tmp--; 1141 *tmp = '\n'; 1142 1143 return tmp + 1 - buf; 1144} 1145 1146/** 1147 * parse_protocol_change() - parses a protocol change request 1148 * @dev: rc_dev device 1149 * @protocols: pointer to the bitmask of current protocols 1150 * @buf: pointer to the buffer with a list of changes 1151 * 1152 * Writing "+proto" will add a protocol to the protocol mask. 1153 * Writing "-proto" will remove a protocol from protocol mask. 1154 * Writing "proto" will enable only "proto". 1155 * Writing "none" will disable all protocols. 1156 * Returns the number of changes performed or a negative error code. 1157 */ 1158static int parse_protocol_change(struct rc_dev *dev, u64 *protocols, 1159 const char *buf) 1160{ 1161 const char *tmp; 1162 unsigned count = 0; 1163 bool enable, disable; 1164 u64 mask; 1165 int i; 1166 1167 while ((tmp = strsep((char **)&buf, " \n")) != NULL) { 1168 if (!*tmp) 1169 break; 1170 1171 if (*tmp == '+') { 1172 enable = true; 1173 disable = false; 1174 tmp++; 1175 } else if (*tmp == '-') { 1176 enable = false; 1177 disable = true; 1178 tmp++; 1179 } else { 1180 enable = false; 1181 disable = false; 1182 } 1183 1184 for (i = 0; i < ARRAY_SIZE(proto_names); i++) { 1185 if (!strcasecmp(tmp, proto_names[i].name)) { 1186 mask = proto_names[i].type; 1187 break; 1188 } 1189 } 1190 1191 if (i == ARRAY_SIZE(proto_names)) { 1192 if (!strcasecmp(tmp, "lirc")) 1193 mask = 0; 1194 else { 1195 dev_dbg(&dev->dev, "Unknown protocol: '%s'\n", 1196 tmp); 1197 return -EINVAL; 1198 } 1199 } 1200 1201 count++; 1202 1203 if (enable) 1204 *protocols |= mask; 1205 else if (disable) 1206 *protocols &= ~mask; 1207 else 1208 *protocols = mask; 1209 } 1210 1211 if (!count) { 1212 dev_dbg(&dev->dev, "Protocol not specified\n"); 1213 return -EINVAL; 1214 } 1215 1216 return count; 1217} 1218 1219void ir_raw_load_modules(u64 *protocols) 1220{ 1221 u64 available; 1222 int i, ret; 1223 1224 for (i = 0; i < ARRAY_SIZE(proto_names); i++) { 1225 if (proto_names[i].type == RC_PROTO_BIT_NONE || 1226 proto_names[i].type & (RC_PROTO_BIT_OTHER | 1227 RC_PROTO_BIT_UNKNOWN)) 1228 continue; 1229 1230 available = ir_raw_get_allowed_protocols(); 1231 if (!(*protocols & proto_names[i].type & ~available)) 1232 continue; 1233 1234 if (!proto_names[i].module_name) { 1235 pr_err("Can't enable IR protocol %s\n", 1236 proto_names[i].name); 1237 *protocols &= ~proto_names[i].type; 1238 continue; 1239 } 1240 1241 ret = request_module("%s", proto_names[i].module_name); 1242 if (ret < 0) { 1243 pr_err("Couldn't load IR protocol module %s\n", 1244 proto_names[i].module_name); 1245 *protocols &= ~proto_names[i].type; 1246 continue; 1247 } 1248 msleep(20); 1249 available = ir_raw_get_allowed_protocols(); 1250 if (!(*protocols & proto_names[i].type & ~available)) 1251 continue; 1252 1253 pr_err("Loaded IR protocol module %s, but protocol %s still not available\n", 1254 proto_names[i].module_name, 1255 proto_names[i].name); 1256 *protocols &= ~proto_names[i].type; 1257 } 1258} 1259 1260/** 1261 * store_protocols() - changes the current/wakeup IR protocol(s) 1262 * @device: the device descriptor 1263 * @mattr: the device attribute struct 1264 * @buf: a pointer to the input buffer 1265 * @len: length of the input buffer 1266 * 1267 * This routine is for changing the IR protocol type. 1268 * It is triggered by writing to /sys/class/rc/rc?/[wakeup_]protocols. 1269 * See parse_protocol_change() for the valid commands. 1270 * Returns @len on success or a negative error code. 1271 * 1272 * dev->lock is taken to guard against races between 1273 * store_protocols and show_protocols. 1274 */ 1275static ssize_t store_protocols(struct device *device, 1276 struct device_attribute *mattr, 1277 const char *buf, size_t len) 1278{ 1279 struct rc_dev *dev = to_rc_dev(device); 1280 u64 *current_protocols; 1281 struct rc_scancode_filter *filter; 1282 u64 old_protocols, new_protocols; 1283 ssize_t rc; 1284 1285 dev_dbg(&dev->dev, "Normal protocol change requested\n"); 1286 current_protocols = &dev->enabled_protocols; 1287 filter = &dev->scancode_filter; 1288 1289 if (!dev->change_protocol) { 1290 dev_dbg(&dev->dev, "Protocol switching not supported\n"); 1291 return -EINVAL; 1292 } 1293 1294 mutex_lock(&dev->lock); 1295 if (!dev->registered) { 1296 mutex_unlock(&dev->lock); 1297 return -ENODEV; 1298 } 1299 1300 old_protocols = *current_protocols; 1301 new_protocols = old_protocols; 1302 rc = parse_protocol_change(dev, &new_protocols, buf); 1303 if (rc < 0) 1304 goto out; 1305 1306 if (dev->driver_type == RC_DRIVER_IR_RAW) 1307 ir_raw_load_modules(&new_protocols); 1308 1309 rc = dev->change_protocol(dev, &new_protocols); 1310 if (rc < 0) { 1311 dev_dbg(&dev->dev, "Error setting protocols to 0x%llx\n", 1312 (long long)new_protocols); 1313 goto out; 1314 } 1315 1316 if (new_protocols != old_protocols) { 1317 *current_protocols = new_protocols; 1318 dev_dbg(&dev->dev, "Protocols changed to 0x%llx\n", 1319 (long long)new_protocols); 1320 } 1321 1322 /* 1323 * If a protocol change was attempted the filter may need updating, even 1324 * if the actual protocol mask hasn't changed (since the driver may have 1325 * cleared the filter). 1326 * Try setting the same filter with the new protocol (if any). 1327 * Fall back to clearing the filter. 1328 */ 1329 if (dev->s_filter && filter->mask) { 1330 if (new_protocols) 1331 rc = dev->s_filter(dev, filter); 1332 else 1333 rc = -1; 1334 1335 if (rc < 0) { 1336 filter->data = 0; 1337 filter->mask = 0; 1338 dev->s_filter(dev, filter); 1339 } 1340 } 1341 1342 rc = len; 1343 1344out: 1345 mutex_unlock(&dev->lock); 1346 return rc; 1347} 1348 1349/** 1350 * show_filter() - shows the current scancode filter value or mask 1351 * @device: the device descriptor 1352 * @attr: the device attribute struct 1353 * @buf: a pointer to the output buffer 1354 * 1355 * This routine is a callback routine to read a scancode filter value or mask. 1356 * It is triggered by reading /sys/class/rc/rc?/[wakeup_]filter[_mask]. 1357 * It prints the current scancode filter value or mask of the appropriate filter 1358 * type in hexadecimal into @buf and returns the size of the buffer. 1359 * 1360 * Bits of the filter value corresponding to set bits in the filter mask are 1361 * compared against input scancodes and non-matching scancodes are discarded. 1362 * 1363 * dev->lock is taken to guard against races between 1364 * store_filter and show_filter. 1365 */ 1366static ssize_t show_filter(struct device *device, 1367 struct device_attribute *attr, 1368 char *buf) 1369{ 1370 struct rc_dev *dev = to_rc_dev(device); 1371 struct rc_filter_attribute *fattr = to_rc_filter_attr(attr); 1372 struct rc_scancode_filter *filter; 1373 u32 val; 1374 1375 mutex_lock(&dev->lock); 1376 1377 if (fattr->type == RC_FILTER_NORMAL) 1378 filter = &dev->scancode_filter; 1379 else 1380 filter = &dev->scancode_wakeup_filter; 1381 1382 if (fattr->mask) 1383 val = filter->mask; 1384 else 1385 val = filter->data; 1386 mutex_unlock(&dev->lock); 1387 1388 return sprintf(buf, "%#x\n", val); 1389} 1390 1391/** 1392 * store_filter() - changes the scancode filter value 1393 * @device: the device descriptor 1394 * @attr: the device attribute struct 1395 * @buf: a pointer to the input buffer 1396 * @len: length of the input buffer 1397 * 1398 * This routine is for changing a scancode filter value or mask. 1399 * It is triggered by writing to /sys/class/rc/rc?/[wakeup_]filter[_mask]. 1400 * Returns -EINVAL if an invalid filter value for the current protocol was 1401 * specified or if scancode filtering is not supported by the driver, otherwise 1402 * returns @len. 1403 * 1404 * Bits of the filter value corresponding to set bits in the filter mask are 1405 * compared against input scancodes and non-matching scancodes are discarded. 1406 * 1407 * dev->lock is taken to guard against races between 1408 * store_filter and show_filter. 1409 */ 1410static ssize_t store_filter(struct device *device, 1411 struct device_attribute *attr, 1412 const char *buf, size_t len) 1413{ 1414 struct rc_dev *dev = to_rc_dev(device); 1415 struct rc_filter_attribute *fattr = to_rc_filter_attr(attr); 1416 struct rc_scancode_filter new_filter, *filter; 1417 int ret; 1418 unsigned long val; 1419 int (*set_filter)(struct rc_dev *dev, struct rc_scancode_filter *filter); 1420 1421 ret = kstrtoul(buf, 0, &val); 1422 if (ret < 0) 1423 return ret; 1424 1425 if (fattr->type == RC_FILTER_NORMAL) { 1426 set_filter = dev->s_filter; 1427 filter = &dev->scancode_filter; 1428 } else { 1429 set_filter = dev->s_wakeup_filter; 1430 filter = &dev->scancode_wakeup_filter; 1431 } 1432 1433 if (!set_filter) 1434 return -EINVAL; 1435 1436 mutex_lock(&dev->lock); 1437 if (!dev->registered) { 1438 mutex_unlock(&dev->lock); 1439 return -ENODEV; 1440 } 1441 1442 new_filter = *filter; 1443 if (fattr->mask) 1444 new_filter.mask = val; 1445 else 1446 new_filter.data = val; 1447 1448 if (fattr->type == RC_FILTER_WAKEUP) { 1449 /* 1450 * Refuse to set a filter unless a protocol is enabled 1451 * and the filter is valid for that protocol 1452 */ 1453 if (dev->wakeup_protocol != RC_PROTO_UNKNOWN) 1454 ret = rc_validate_filter(dev, &new_filter); 1455 else 1456 ret = -EINVAL; 1457 1458 if (ret != 0) 1459 goto unlock; 1460 } 1461 1462 if (fattr->type == RC_FILTER_NORMAL && !dev->enabled_protocols && 1463 val) { 1464 /* refuse to set a filter unless a protocol is enabled */ 1465 ret = -EINVAL; 1466 goto unlock; 1467 } 1468 1469 ret = set_filter(dev, &new_filter); 1470 if (ret < 0) 1471 goto unlock; 1472 1473 *filter = new_filter; 1474 1475unlock: 1476 mutex_unlock(&dev->lock); 1477 return (ret < 0) ? ret : len; 1478} 1479 1480/** 1481 * show_wakeup_protocols() - shows the wakeup IR protocol 1482 * @device: the device descriptor 1483 * @mattr: the device attribute struct 1484 * @buf: a pointer to the output buffer 1485 * 1486 * This routine is a callback routine for input read the IR protocol type(s). 1487 * it is triggered by reading /sys/class/rc/rc?/wakeup_protocols. 1488 * It returns the protocol names of supported protocols. 1489 * The enabled protocols are printed in brackets. 1490 * 1491 * dev->lock is taken to guard against races between 1492 * store_wakeup_protocols and show_wakeup_protocols. 1493 */ 1494static ssize_t show_wakeup_protocols(struct device *device, 1495 struct device_attribute *mattr, 1496 char *buf) 1497{ 1498 struct rc_dev *dev = to_rc_dev(device); 1499 u64 allowed; 1500 enum rc_proto enabled; 1501 char *tmp = buf; 1502 int i; 1503 1504 mutex_lock(&dev->lock); 1505 1506 allowed = dev->allowed_wakeup_protocols; 1507 enabled = dev->wakeup_protocol; 1508 1509 mutex_unlock(&dev->lock); 1510 1511 dev_dbg(&dev->dev, "%s: allowed - 0x%llx, enabled - %d\n", 1512 __func__, (long long)allowed, enabled); 1513 1514 for (i = 0; i < ARRAY_SIZE(protocols); i++) { 1515 if (allowed & (1ULL << i)) { 1516 if (i == enabled) 1517 tmp += sprintf(tmp, "[%s] ", protocols[i].name); 1518 else 1519 tmp += sprintf(tmp, "%s ", protocols[i].name); 1520 } 1521 } 1522 1523 if (tmp != buf) 1524 tmp--; 1525 *tmp = '\n'; 1526 1527 return tmp + 1 - buf; 1528} 1529 1530/** 1531 * store_wakeup_protocols() - changes the wakeup IR protocol(s) 1532 * @device: the device descriptor 1533 * @mattr: the device attribute struct 1534 * @buf: a pointer to the input buffer 1535 * @len: length of the input buffer 1536 * 1537 * This routine is for changing the IR protocol type. 1538 * It is triggered by writing to /sys/class/rc/rc?/wakeup_protocols. 1539 * Returns @len on success or a negative error code. 1540 * 1541 * dev->lock is taken to guard against races between 1542 * store_wakeup_protocols and show_wakeup_protocols. 1543 */ 1544static ssize_t store_wakeup_protocols(struct device *device, 1545 struct device_attribute *mattr, 1546 const char *buf, size_t len) 1547{ 1548 struct rc_dev *dev = to_rc_dev(device); 1549 enum rc_proto protocol = RC_PROTO_UNKNOWN; 1550 ssize_t rc; 1551 u64 allowed; 1552 int i; 1553 1554 mutex_lock(&dev->lock); 1555 if (!dev->registered) { 1556 mutex_unlock(&dev->lock); 1557 return -ENODEV; 1558 } 1559 1560 allowed = dev->allowed_wakeup_protocols; 1561 1562 if (!sysfs_streq(buf, "none")) { 1563 for (i = 0; i < ARRAY_SIZE(protocols); i++) { 1564 if ((allowed & (1ULL << i)) && 1565 sysfs_streq(buf, protocols[i].name)) { 1566 protocol = i; 1567 break; 1568 } 1569 } 1570 1571 if (i == ARRAY_SIZE(protocols)) { 1572 rc = -EINVAL; 1573 goto out; 1574 } 1575 1576 if (dev->encode_wakeup) { 1577 u64 mask = 1ULL << protocol; 1578 1579 ir_raw_load_modules(&mask); 1580 if (!mask) { 1581 rc = -EINVAL; 1582 goto out; 1583 } 1584 } 1585 } 1586 1587 if (dev->wakeup_protocol != protocol) { 1588 dev->wakeup_protocol = protocol; 1589 dev_dbg(&dev->dev, "Wakeup protocol changed to %d\n", protocol); 1590 1591 if (protocol == RC_PROTO_RC6_MCE) 1592 dev->scancode_wakeup_filter.data = 0x800f0000; 1593 else 1594 dev->scancode_wakeup_filter.data = 0; 1595 dev->scancode_wakeup_filter.mask = 0; 1596 1597 rc = dev->s_wakeup_filter(dev, &dev->scancode_wakeup_filter); 1598 if (rc == 0) 1599 rc = len; 1600 } else { 1601 rc = len; 1602 } 1603 1604out: 1605 mutex_unlock(&dev->lock); 1606 return rc; 1607} 1608 1609static void rc_dev_release(struct device *device) 1610{ 1611 struct rc_dev *dev = to_rc_dev(device); 1612 1613 kfree(dev); 1614} 1615 1616static int rc_dev_uevent(struct device *device, struct kobj_uevent_env *env) 1617{ 1618 struct rc_dev *dev = to_rc_dev(device); 1619 int ret = 0; 1620 1621 mutex_lock(&dev->lock); 1622 1623 if (!dev->registered) 1624 ret = -ENODEV; 1625 if (ret == 0 && dev->rc_map.name) 1626 ret = add_uevent_var(env, "NAME=%s", dev->rc_map.name); 1627 if (ret == 0 && dev->driver_name) 1628 ret = add_uevent_var(env, "DRV_NAME=%s", dev->driver_name); 1629 if (ret == 0 && dev->device_name) 1630 ret = add_uevent_var(env, "DEV_NAME=%s", dev->device_name); 1631 1632 mutex_unlock(&dev->lock); 1633 1634 return ret; 1635} 1636 1637/* 1638 * Static device attribute struct with the sysfs attributes for IR's 1639 */ 1640static struct device_attribute dev_attr_ro_protocols = 1641__ATTR(protocols, 0444, show_protocols, NULL); 1642static struct device_attribute dev_attr_rw_protocols = 1643__ATTR(protocols, 0644, show_protocols, store_protocols); 1644static DEVICE_ATTR(wakeup_protocols, 0644, show_wakeup_protocols, 1645 store_wakeup_protocols); 1646static RC_FILTER_ATTR(filter, S_IRUGO|S_IWUSR, 1647 show_filter, store_filter, RC_FILTER_NORMAL, false); 1648static RC_FILTER_ATTR(filter_mask, S_IRUGO|S_IWUSR, 1649 show_filter, store_filter, RC_FILTER_NORMAL, true); 1650static RC_FILTER_ATTR(wakeup_filter, S_IRUGO|S_IWUSR, 1651 show_filter, store_filter, RC_FILTER_WAKEUP, false); 1652static RC_FILTER_ATTR(wakeup_filter_mask, S_IRUGO|S_IWUSR, 1653 show_filter, store_filter, RC_FILTER_WAKEUP, true); 1654 1655static struct attribute *rc_dev_rw_protocol_attrs[] = { 1656 &dev_attr_rw_protocols.attr, 1657 NULL, 1658}; 1659 1660static const struct attribute_group rc_dev_rw_protocol_attr_grp = { 1661 .attrs = rc_dev_rw_protocol_attrs, 1662}; 1663 1664static struct attribute *rc_dev_ro_protocol_attrs[] = { 1665 &dev_attr_ro_protocols.attr, 1666 NULL, 1667}; 1668 1669static const struct attribute_group rc_dev_ro_protocol_attr_grp = { 1670 .attrs = rc_dev_ro_protocol_attrs, 1671}; 1672 1673static struct attribute *rc_dev_filter_attrs[] = { 1674 &dev_attr_filter.attr.attr, 1675 &dev_attr_filter_mask.attr.attr, 1676 NULL, 1677}; 1678 1679static const struct attribute_group rc_dev_filter_attr_grp = { 1680 .attrs = rc_dev_filter_attrs, 1681}; 1682 1683static struct attribute *rc_dev_wakeup_filter_attrs[] = { 1684 &dev_attr_wakeup_filter.attr.attr, 1685 &dev_attr_wakeup_filter_mask.attr.attr, 1686 &dev_attr_wakeup_protocols.attr, 1687 NULL, 1688}; 1689 1690static const struct attribute_group rc_dev_wakeup_filter_attr_grp = { 1691 .attrs = rc_dev_wakeup_filter_attrs, 1692}; 1693 1694static const struct device_type rc_dev_type = { 1695 .release = rc_dev_release, 1696 .uevent = rc_dev_uevent, 1697}; 1698 1699struct rc_dev *rc_allocate_device(enum rc_driver_type type) 1700{ 1701 struct rc_dev *dev; 1702 1703 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 1704 if (!dev) 1705 return NULL; 1706 1707 if (type != RC_DRIVER_IR_RAW_TX) { 1708 dev->input_dev = input_allocate_device(); 1709 if (!dev->input_dev) { 1710 kfree(dev); 1711 return NULL; 1712 } 1713 1714 dev->input_dev->getkeycode = ir_getkeycode; 1715 dev->input_dev->setkeycode = ir_setkeycode; 1716 input_set_drvdata(dev->input_dev, dev); 1717 1718 dev->timeout = IR_DEFAULT_TIMEOUT; 1719 timer_setup(&dev->timer_keyup, ir_timer_keyup, 0); 1720 timer_setup(&dev->timer_repeat, ir_timer_repeat, 0); 1721 1722 spin_lock_init(&dev->rc_map.lock); 1723 spin_lock_init(&dev->keylock); 1724 } 1725 mutex_init(&dev->lock); 1726 1727 dev->dev.type = &rc_dev_type; 1728 dev->dev.class = &rc_class; 1729 device_initialize(&dev->dev); 1730 1731 dev->driver_type = type; 1732 1733 __module_get(THIS_MODULE); 1734 return dev; 1735} 1736EXPORT_SYMBOL_GPL(rc_allocate_device); 1737 1738void rc_free_device(struct rc_dev *dev) 1739{ 1740 if (!dev) 1741 return; 1742 1743 input_free_device(dev->input_dev); 1744 1745 put_device(&dev->dev); 1746 1747 /* kfree(dev) will be called by the callback function 1748 rc_dev_release() */ 1749 1750 module_put(THIS_MODULE); 1751} 1752EXPORT_SYMBOL_GPL(rc_free_device); 1753 1754static void devm_rc_alloc_release(struct device *dev, void *res) 1755{ 1756 rc_free_device(*(struct rc_dev **)res); 1757} 1758 1759struct rc_dev *devm_rc_allocate_device(struct device *dev, 1760 enum rc_driver_type type) 1761{ 1762 struct rc_dev **dr, *rc; 1763 1764 dr = devres_alloc(devm_rc_alloc_release, sizeof(*dr), GFP_KERNEL); 1765 if (!dr) 1766 return NULL; 1767 1768 rc = rc_allocate_device(type); 1769 if (!rc) { 1770 devres_free(dr); 1771 return NULL; 1772 } 1773 1774 rc->dev.parent = dev; 1775 rc->managed_alloc = true; 1776 *dr = rc; 1777 devres_add(dev, dr); 1778 1779 return rc; 1780} 1781EXPORT_SYMBOL_GPL(devm_rc_allocate_device); 1782 1783static int rc_prepare_rx_device(struct rc_dev *dev) 1784{ 1785 int rc; 1786 struct rc_map *rc_map; 1787 u64 rc_proto; 1788 1789 if (!dev->map_name) 1790 return -EINVAL; 1791 1792 rc_map = rc_map_get(dev->map_name); 1793 if (!rc_map) 1794 rc_map = rc_map_get(RC_MAP_EMPTY); 1795 if (!rc_map || !rc_map->scan || rc_map->size == 0) 1796 return -EINVAL; 1797 1798 rc = ir_setkeytable(dev, rc_map); 1799 if (rc) 1800 return rc; 1801 1802 rc_proto = BIT_ULL(rc_map->rc_proto); 1803 1804 if (dev->driver_type == RC_DRIVER_SCANCODE && !dev->change_protocol) 1805 dev->enabled_protocols = dev->allowed_protocols; 1806 1807 if (dev->driver_type == RC_DRIVER_IR_RAW) 1808 ir_raw_load_modules(&rc_proto); 1809 1810 if (dev->change_protocol) { 1811 rc = dev->change_protocol(dev, &rc_proto); 1812 if (rc < 0) 1813 goto out_table; 1814 dev->enabled_protocols = rc_proto; 1815 } 1816 1817 /* Keyboard events */ 1818 set_bit(EV_KEY, dev->input_dev->evbit); 1819 set_bit(EV_REP, dev->input_dev->evbit); 1820 set_bit(EV_MSC, dev->input_dev->evbit); 1821 set_bit(MSC_SCAN, dev->input_dev->mscbit); 1822 1823 /* Pointer/mouse events */ 1824 set_bit(INPUT_PROP_POINTING_STICK, dev->input_dev->propbit); 1825 set_bit(EV_REL, dev->input_dev->evbit); 1826 set_bit(REL_X, dev->input_dev->relbit); 1827 set_bit(REL_Y, dev->input_dev->relbit); 1828 1829 if (dev->open) 1830 dev->input_dev->open = ir_open; 1831 if (dev->close) 1832 dev->input_dev->close = ir_close; 1833 1834 dev->input_dev->dev.parent = &dev->dev; 1835 memcpy(&dev->input_dev->id, &dev->input_id, sizeof(dev->input_id)); 1836 dev->input_dev->phys = dev->input_phys; 1837 dev->input_dev->name = dev->device_name; 1838 1839 return 0; 1840 1841out_table: 1842 ir_free_table(&dev->rc_map); 1843 1844 return rc; 1845} 1846 1847static int rc_setup_rx_device(struct rc_dev *dev) 1848{ 1849 int rc; 1850 1851 /* rc_open will be called here */ 1852 rc = input_register_device(dev->input_dev); 1853 if (rc) 1854 return rc; 1855 1856 /* 1857 * Default delay of 250ms is too short for some protocols, especially 1858 * since the timeout is currently set to 250ms. Increase it to 500ms, 1859 * to avoid wrong repetition of the keycodes. Note that this must be 1860 * set after the call to input_register_device(). 1861 */ 1862 if (dev->allowed_protocols == RC_PROTO_BIT_CEC) 1863 dev->input_dev->rep[REP_DELAY] = 0; 1864 else 1865 dev->input_dev->rep[REP_DELAY] = 500; 1866 1867 /* 1868 * As a repeat event on protocols like RC-5 and NEC take as long as 1869 * 110/114ms, using 33ms as a repeat period is not the right thing 1870 * to do. 1871 */ 1872 dev->input_dev->rep[REP_PERIOD] = 125; 1873 1874 return 0; 1875} 1876 1877static void rc_free_rx_device(struct rc_dev *dev) 1878{ 1879 if (!dev) 1880 return; 1881 1882 if (dev->input_dev) { 1883 input_unregister_device(dev->input_dev); 1884 dev->input_dev = NULL; 1885 } 1886 1887 ir_free_table(&dev->rc_map); 1888} 1889 1890int rc_register_device(struct rc_dev *dev) 1891{ 1892 const char *path; 1893 int attr = 0; 1894 int minor; 1895 int rc; 1896 1897 if (!dev) 1898 return -EINVAL; 1899 1900 minor = ida_simple_get(&rc_ida, 0, RC_DEV_MAX, GFP_KERNEL); 1901 if (minor < 0) 1902 return minor; 1903 1904 dev->minor = minor; 1905 dev_set_name(&dev->dev, "rc%u", dev->minor); 1906 dev_set_drvdata(&dev->dev, dev); 1907 1908 dev->dev.groups = dev->sysfs_groups; 1909 if (dev->driver_type == RC_DRIVER_SCANCODE && !dev->change_protocol) 1910 dev->sysfs_groups[attr++] = &rc_dev_ro_protocol_attr_grp; 1911 else if (dev->driver_type != RC_DRIVER_IR_RAW_TX) 1912 dev->sysfs_groups[attr++] = &rc_dev_rw_protocol_attr_grp; 1913 if (dev->s_filter) 1914 dev->sysfs_groups[attr++] = &rc_dev_filter_attr_grp; 1915 if (dev->s_wakeup_filter) 1916 dev->sysfs_groups[attr++] = &rc_dev_wakeup_filter_attr_grp; 1917 dev->sysfs_groups[attr++] = NULL; 1918 1919 if (dev->driver_type == RC_DRIVER_IR_RAW) { 1920 rc = ir_raw_event_prepare(dev); 1921 if (rc < 0) 1922 goto out_minor; 1923 } 1924 1925 if (dev->driver_type != RC_DRIVER_IR_RAW_TX) { 1926 rc = rc_prepare_rx_device(dev); 1927 if (rc) 1928 goto out_raw; 1929 } 1930 1931 dev->registered = true; 1932 1933 rc = device_add(&dev->dev); 1934 if (rc) 1935 goto out_rx_free; 1936 1937 path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL); 1938 dev_info(&dev->dev, "%s as %s\n", 1939 dev->device_name ?: "Unspecified device", path ?: "N/A"); 1940 kfree(path); 1941 1942 /* 1943 * once the the input device is registered in rc_setup_rx_device, 1944 * userspace can open the input device and rc_open() will be called 1945 * as a result. This results in driver code being allowed to submit 1946 * keycodes with rc_keydown, so lirc must be registered first. 1947 */ 1948 if (dev->allowed_protocols != RC_PROTO_BIT_CEC) { 1949 rc = lirc_register(dev); 1950 if (rc < 0) 1951 goto out_dev; 1952 } 1953 1954 if (dev->driver_type != RC_DRIVER_IR_RAW_TX) { 1955 rc = rc_setup_rx_device(dev); 1956 if (rc) 1957 goto out_lirc; 1958 } 1959 1960 if (dev->driver_type == RC_DRIVER_IR_RAW) { 1961 rc = ir_raw_event_register(dev); 1962 if (rc < 0) 1963 goto out_rx; 1964 } 1965 1966 dev_dbg(&dev->dev, "Registered rc%u (driver: %s)\n", dev->minor, 1967 dev->driver_name ? dev->driver_name : "unknown"); 1968 1969 return 0; 1970 1971out_rx: 1972 rc_free_rx_device(dev); 1973out_lirc: 1974 if (dev->allowed_protocols != RC_PROTO_BIT_CEC) 1975 lirc_unregister(dev); 1976out_dev: 1977 device_del(&dev->dev); 1978out_rx_free: 1979 ir_free_table(&dev->rc_map); 1980out_raw: 1981 ir_raw_event_free(dev); 1982out_minor: 1983 ida_simple_remove(&rc_ida, minor); 1984 return rc; 1985} 1986EXPORT_SYMBOL_GPL(rc_register_device); 1987 1988static void devm_rc_release(struct device *dev, void *res) 1989{ 1990 rc_unregister_device(*(struct rc_dev **)res); 1991} 1992 1993int devm_rc_register_device(struct device *parent, struct rc_dev *dev) 1994{ 1995 struct rc_dev **dr; 1996 int ret; 1997 1998 dr = devres_alloc(devm_rc_release, sizeof(*dr), GFP_KERNEL); 1999 if (!dr) 2000 return -ENOMEM; 2001 2002 ret = rc_register_device(dev); 2003 if (ret) { 2004 devres_free(dr); 2005 return ret; 2006 } 2007 2008 *dr = dev; 2009 devres_add(parent, dr); 2010 2011 return 0; 2012} 2013EXPORT_SYMBOL_GPL(devm_rc_register_device); 2014 2015void rc_unregister_device(struct rc_dev *dev) 2016{ 2017 if (!dev) 2018 return; 2019 2020 if (dev->driver_type == RC_DRIVER_IR_RAW) 2021 ir_raw_event_unregister(dev); 2022 2023 del_timer_sync(&dev->timer_keyup); 2024 del_timer_sync(&dev->timer_repeat); 2025 2026 mutex_lock(&dev->lock); 2027 if (dev->users && dev->close) 2028 dev->close(dev); 2029 dev->registered = false; 2030 mutex_unlock(&dev->lock); 2031 2032 rc_free_rx_device(dev); 2033 2034 /* 2035 * lirc device should be freed with dev->registered = false, so 2036 * that userspace polling will get notified. 2037 */ 2038 if (dev->allowed_protocols != RC_PROTO_BIT_CEC) 2039 lirc_unregister(dev); 2040 2041 device_del(&dev->dev); 2042 2043 ida_simple_remove(&rc_ida, dev->minor); 2044 2045 if (!dev->managed_alloc) 2046 rc_free_device(dev); 2047} 2048 2049EXPORT_SYMBOL_GPL(rc_unregister_device); 2050 2051/* 2052 * Init/exit code for the module. Basically, creates/removes /sys/class/rc 2053 */ 2054 2055static int __init rc_core_init(void) 2056{ 2057 int rc = class_register(&rc_class); 2058 if (rc) { 2059 pr_err("rc_core: unable to register rc class\n"); 2060 return rc; 2061 } 2062 2063 rc = lirc_dev_init(); 2064 if (rc) { 2065 pr_err("rc_core: unable to init lirc\n"); 2066 class_unregister(&rc_class); 2067 return rc; 2068 } 2069 2070 led_trigger_register_simple("rc-feedback", &led_feedback); 2071 rc_map_register(&empty_map); 2072#ifdef CONFIG_MEDIA_CEC_RC 2073 rc_map_register(&cec_map); 2074#endif 2075 2076 return 0; 2077} 2078 2079static void __exit rc_core_exit(void) 2080{ 2081 lirc_dev_exit(); 2082 class_unregister(&rc_class); 2083 led_trigger_unregister_simple(led_feedback); 2084#ifdef CONFIG_MEDIA_CEC_RC 2085 rc_map_unregister(&cec_map); 2086#endif 2087 rc_map_unregister(&empty_map); 2088} 2089 2090subsys_initcall(rc_core_init); 2091module_exit(rc_core_exit); 2092 2093MODULE_AUTHOR("Mauro Carvalho Chehab"); 2094MODULE_LICENSE("GPL v2"); 2095