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 24 static 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 */ 83 static LIST_HEAD(rc_map_list); 84 static DEFINE_SPINLOCK(rc_map_lock); 85 static struct led_trigger *led_feedback; 86 87 /* Used to keep track of rc devices */ 88 static DEFINE_IDA(rc_ida); 89 90 static 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 106 struct 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 } 133 EXPORT_SYMBOL_GPL(rc_map_get); 134 135 int 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 } 142 EXPORT_SYMBOL_GPL(rc_map_register); 143 144 void 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 } 150 EXPORT_SYMBOL_GPL(rc_map_unregister); 151 152 153 static struct rc_map_table empty[] = { 154 { 0x2a, KEY_COFFEE }, 155 }; 156 157 static 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 */ 175 static 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 */ 214 static 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 */ 242 static 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 */ 262 static 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 */ 313 static 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 */ 370 static 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 */ 424 static 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 457 out: 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 */ 471 static 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 500 static 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 */ 522 static 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 */ 544 static 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 589 out: 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 */ 605 u32 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 } 626 EXPORT_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 */ 636 static 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 */ 657 void 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 } 665 EXPORT_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 */ 675 static 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 */ 704 static 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 721 static 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 */ 737 void 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 } 767 EXPORT_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 */ 780 static 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 (!new_event ? LIRC_SCANCODE_FLAG_REPEAT : 0), 791 .keycode = keycode 792 }; 793 794 if (dev->allowed_protocols != RC_PROTO_BIT_CEC) 795 lirc_scancode_event(dev, &sc); 796 797 if (new_event && dev->keypressed) 798 ir_do_keyup(dev, false); 799 800 if (scancode <= U32_MAX) 801 input_event(dev->input_dev, EV_MSC, MSC_SCAN, scancode); 802 803 dev->last_protocol = protocol; 804 dev->last_scancode = scancode; 805 dev->last_toggle = toggle; 806 dev->last_keycode = keycode; 807 808 if (new_event && keycode != KEY_RESERVED) { 809 /* Register a keypress */ 810 dev->keypressed = true; 811 812 dev_dbg(&dev->dev, "%s: key down event, key 0x%04x, protocol 0x%04x, scancode 0x%08llx\n", 813 dev->device_name, keycode, protocol, scancode); 814 input_report_key(dev->input_dev, keycode, 1); 815 816 led_trigger_event(led_feedback, LED_FULL); 817 } 818 819 /* 820 * For CEC, start sending repeat messages as soon as the first 821 * repeated message is sent, as long as REP_DELAY = 0 and REP_PERIOD 822 * is non-zero. Otherwise, the input layer will generate repeat 823 * messages. 824 */ 825 if (!new_event && keycode != KEY_RESERVED && 826 dev->allowed_protocols == RC_PROTO_BIT_CEC && 827 !timer_pending(&dev->timer_repeat) && 828 dev->input_dev->rep[REP_PERIOD] && 829 !dev->input_dev->rep[REP_DELAY]) { 830 input_event(dev->input_dev, EV_KEY, keycode, 2); 831 mod_timer(&dev->timer_repeat, jiffies + 832 msecs_to_jiffies(dev->input_dev->rep[REP_PERIOD])); 833 } 834 835 input_sync(dev->input_dev); 836 } 837 838 /** 839 * rc_keydown() - generates input event for a key press 840 * @dev: the struct rc_dev descriptor of the device 841 * @protocol: the protocol for the keypress 842 * @scancode: the scancode for the keypress 843 * @toggle: the toggle value (protocol dependent, if the protocol doesn't 844 * support toggle values, this should be set to zero) 845 * 846 * This routine is used to signal that a key has been pressed on the 847 * remote control. 848 */ 849 void rc_keydown(struct rc_dev *dev, enum rc_proto protocol, u64 scancode, 850 u8 toggle) 851 { 852 unsigned long flags; 853 u32 keycode = rc_g_keycode_from_table(dev, scancode); 854 855 spin_lock_irqsave(&dev->keylock, flags); 856 ir_do_keydown(dev, protocol, scancode, keycode, toggle); 857 858 if (dev->keypressed) { 859 dev->keyup_jiffies = jiffies + usecs_to_jiffies(dev->timeout) + 860 msecs_to_jiffies(repeat_period(protocol)); 861 mod_timer(&dev->timer_keyup, dev->keyup_jiffies); 862 } 863 spin_unlock_irqrestore(&dev->keylock, flags); 864 } 865 EXPORT_SYMBOL_GPL(rc_keydown); 866 867 /** 868 * rc_keydown_notimeout() - generates input event for a key press without 869 * an automatic keyup event at a later time 870 * @dev: the struct rc_dev descriptor of the device 871 * @protocol: the protocol for the keypress 872 * @scancode: the scancode for the keypress 873 * @toggle: the toggle value (protocol dependent, if the protocol doesn't 874 * support toggle values, this should be set to zero) 875 * 876 * This routine is used to signal that a key has been pressed on the 877 * remote control. The driver must manually call rc_keyup() at a later stage. 878 */ 879 void rc_keydown_notimeout(struct rc_dev *dev, enum rc_proto protocol, 880 u64 scancode, u8 toggle) 881 { 882 unsigned long flags; 883 u32 keycode = rc_g_keycode_from_table(dev, scancode); 884 885 spin_lock_irqsave(&dev->keylock, flags); 886 ir_do_keydown(dev, protocol, scancode, keycode, toggle); 887 spin_unlock_irqrestore(&dev->keylock, flags); 888 } 889 EXPORT_SYMBOL_GPL(rc_keydown_notimeout); 890 891 /** 892 * rc_validate_scancode() - checks that a scancode is valid for a protocol. 893 * For nec, it should do the opposite of ir_nec_bytes_to_scancode() 894 * @proto: protocol 895 * @scancode: scancode 896 */ 897 bool rc_validate_scancode(enum rc_proto proto, u32 scancode) 898 { 899 switch (proto) { 900 /* 901 * NECX has a 16-bit address; if the lower 8 bits match the upper 902 * 8 bits inverted, then the address would match regular nec. 903 */ 904 case RC_PROTO_NECX: 905 if ((((scancode >> 16) ^ ~(scancode >> 8)) & 0xff) == 0) 906 return false; 907 break; 908 /* 909 * NEC32 has a 16 bit address and 16 bit command. If the lower 8 bits 910 * of the command match the upper 8 bits inverted, then it would 911 * be either NEC or NECX. 912 */ 913 case RC_PROTO_NEC32: 914 if ((((scancode >> 8) ^ ~scancode) & 0xff) == 0) 915 return false; 916 break; 917 /* 918 * If the customer code (top 32-bit) is 0x800f, it is MCE else it 919 * is regular mode-6a 32 bit 920 */ 921 case RC_PROTO_RC6_MCE: 922 if ((scancode & 0xffff0000) != 0x800f0000) 923 return false; 924 break; 925 case RC_PROTO_RC6_6A_32: 926 if ((scancode & 0xffff0000) == 0x800f0000) 927 return false; 928 break; 929 default: 930 break; 931 } 932 933 return true; 934 } 935 936 /** 937 * rc_validate_filter() - checks that the scancode and mask are valid and 938 * provides sensible defaults 939 * @dev: the struct rc_dev descriptor of the device 940 * @filter: the scancode and mask 941 * 942 * return: 0 or -EINVAL if the filter is not valid 943 */ 944 static int rc_validate_filter(struct rc_dev *dev, 945 struct rc_scancode_filter *filter) 946 { 947 u32 mask, s = filter->data; 948 enum rc_proto protocol = dev->wakeup_protocol; 949 950 if (protocol >= ARRAY_SIZE(protocols)) 951 return -EINVAL; 952 953 mask = protocols[protocol].scancode_bits; 954 955 if (!rc_validate_scancode(protocol, s)) 956 return -EINVAL; 957 958 filter->data &= mask; 959 filter->mask &= mask; 960 961 /* 962 * If we have to raw encode the IR for wakeup, we cannot have a mask 963 */ 964 if (dev->encode_wakeup && filter->mask != 0 && filter->mask != mask) 965 return -EINVAL; 966 967 return 0; 968 } 969 970 int rc_open(struct rc_dev *rdev) 971 { 972 int rval = 0; 973 974 if (!rdev) 975 return -EINVAL; 976 977 mutex_lock(&rdev->lock); 978 979 if (!rdev->registered) { 980 rval = -ENODEV; 981 } else { 982 if (!rdev->users++ && rdev->open) 983 rval = rdev->open(rdev); 984 985 if (rval) 986 rdev->users--; 987 } 988 989 mutex_unlock(&rdev->lock); 990 991 return rval; 992 } 993 994 static int ir_open(struct input_dev *idev) 995 { 996 struct rc_dev *rdev = input_get_drvdata(idev); 997 998 return rc_open(rdev); 999 } 1000 1001 void rc_close(struct rc_dev *rdev) 1002 { 1003 if (rdev) { 1004 mutex_lock(&rdev->lock); 1005 1006 if (!--rdev->users && rdev->close && rdev->registered) 1007 rdev->close(rdev); 1008 1009 mutex_unlock(&rdev->lock); 1010 } 1011 } 1012 1013 static void ir_close(struct input_dev *idev) 1014 { 1015 struct rc_dev *rdev = input_get_drvdata(idev); 1016 rc_close(rdev); 1017 } 1018 1019 /* class for /sys/class/rc */ 1020 static char *rc_devnode(const struct device *dev, umode_t *mode) 1021 { 1022 return kasprintf(GFP_KERNEL, "rc/%s", dev_name(dev)); 1023 } 1024 1025 static struct class rc_class = { 1026 .name = "rc", 1027 .devnode = rc_devnode, 1028 }; 1029 1030 /* 1031 * These are the protocol textual descriptions that are 1032 * used by the sysfs protocols file. Note that the order 1033 * of the entries is relevant. 1034 */ 1035 static const struct { 1036 u64 type; 1037 const char *name; 1038 const char *module_name; 1039 } proto_names[] = { 1040 { RC_PROTO_BIT_NONE, "none", NULL }, 1041 { RC_PROTO_BIT_OTHER, "other", NULL }, 1042 { RC_PROTO_BIT_UNKNOWN, "unknown", NULL }, 1043 { RC_PROTO_BIT_RC5 | 1044 RC_PROTO_BIT_RC5X_20, "rc-5", "ir-rc5-decoder" }, 1045 { RC_PROTO_BIT_NEC | 1046 RC_PROTO_BIT_NECX | 1047 RC_PROTO_BIT_NEC32, "nec", "ir-nec-decoder" }, 1048 { RC_PROTO_BIT_RC6_0 | 1049 RC_PROTO_BIT_RC6_6A_20 | 1050 RC_PROTO_BIT_RC6_6A_24 | 1051 RC_PROTO_BIT_RC6_6A_32 | 1052 RC_PROTO_BIT_RC6_MCE, "rc-6", "ir-rc6-decoder" }, 1053 { RC_PROTO_BIT_JVC, "jvc", "ir-jvc-decoder" }, 1054 { RC_PROTO_BIT_SONY12 | 1055 RC_PROTO_BIT_SONY15 | 1056 RC_PROTO_BIT_SONY20, "sony", "ir-sony-decoder" }, 1057 { RC_PROTO_BIT_RC5_SZ, "rc-5-sz", "ir-rc5-decoder" }, 1058 { RC_PROTO_BIT_SANYO, "sanyo", "ir-sanyo-decoder" }, 1059 { RC_PROTO_BIT_SHARP, "sharp", "ir-sharp-decoder" }, 1060 { RC_PROTO_BIT_MCIR2_KBD | 1061 RC_PROTO_BIT_MCIR2_MSE, "mce_kbd", "ir-mce_kbd-decoder" }, 1062 { RC_PROTO_BIT_XMP, "xmp", "ir-xmp-decoder" }, 1063 { RC_PROTO_BIT_CEC, "cec", NULL }, 1064 { RC_PROTO_BIT_IMON, "imon", "ir-imon-decoder" }, 1065 { RC_PROTO_BIT_RCMM12 | 1066 RC_PROTO_BIT_RCMM24 | 1067 RC_PROTO_BIT_RCMM32, "rc-mm", "ir-rcmm-decoder" }, 1068 { RC_PROTO_BIT_XBOX_DVD, "xbox-dvd", NULL }, 1069 }; 1070 1071 /** 1072 * struct rc_filter_attribute - Device attribute relating to a filter type. 1073 * @attr: Device attribute. 1074 * @type: Filter type. 1075 * @mask: false for filter value, true for filter mask. 1076 */ 1077 struct rc_filter_attribute { 1078 struct device_attribute attr; 1079 enum rc_filter_type type; 1080 bool mask; 1081 }; 1082 #define to_rc_filter_attr(a) container_of(a, struct rc_filter_attribute, attr) 1083 1084 #define RC_FILTER_ATTR(_name, _mode, _show, _store, _type, _mask) \ 1085 struct rc_filter_attribute dev_attr_##_name = { \ 1086 .attr = __ATTR(_name, _mode, _show, _store), \ 1087 .type = (_type), \ 1088 .mask = (_mask), \ 1089 } 1090 1091 /** 1092 * show_protocols() - shows the current IR protocol(s) 1093 * @device: the device descriptor 1094 * @mattr: the device attribute struct 1095 * @buf: a pointer to the output buffer 1096 * 1097 * This routine is a callback routine for input read the IR protocol type(s). 1098 * it is triggered by reading /sys/class/rc/rc?/protocols. 1099 * It returns the protocol names of supported protocols. 1100 * Enabled protocols are printed in brackets. 1101 * 1102 * dev->lock is taken to guard against races between 1103 * store_protocols and show_protocols. 1104 */ 1105 static ssize_t show_protocols(struct device *device, 1106 struct device_attribute *mattr, char *buf) 1107 { 1108 struct rc_dev *dev = to_rc_dev(device); 1109 u64 allowed, enabled; 1110 char *tmp = buf; 1111 int i; 1112 1113 mutex_lock(&dev->lock); 1114 1115 enabled = dev->enabled_protocols; 1116 allowed = dev->allowed_protocols; 1117 if (dev->raw && !allowed) 1118 allowed = ir_raw_get_allowed_protocols(); 1119 1120 mutex_unlock(&dev->lock); 1121 1122 dev_dbg(&dev->dev, "%s: allowed - 0x%llx, enabled - 0x%llx\n", 1123 __func__, (long long)allowed, (long long)enabled); 1124 1125 for (i = 0; i < ARRAY_SIZE(proto_names); i++) { 1126 if (allowed & enabled & proto_names[i].type) 1127 tmp += sprintf(tmp, "[%s] ", proto_names[i].name); 1128 else if (allowed & proto_names[i].type) 1129 tmp += sprintf(tmp, "%s ", proto_names[i].name); 1130 1131 if (allowed & proto_names[i].type) 1132 allowed &= ~proto_names[i].type; 1133 } 1134 1135 #ifdef CONFIG_LIRC 1136 if (dev->driver_type == RC_DRIVER_IR_RAW) 1137 tmp += sprintf(tmp, "[lirc] "); 1138 #endif 1139 1140 if (tmp != buf) 1141 tmp--; 1142 *tmp = '\n'; 1143 1144 return tmp + 1 - buf; 1145 } 1146 1147 /** 1148 * parse_protocol_change() - parses a protocol change request 1149 * @dev: rc_dev device 1150 * @protocols: pointer to the bitmask of current protocols 1151 * @buf: pointer to the buffer with a list of changes 1152 * 1153 * Writing "+proto" will add a protocol to the protocol mask. 1154 * Writing "-proto" will remove a protocol from protocol mask. 1155 * Writing "proto" will enable only "proto". 1156 * Writing "none" will disable all protocols. 1157 * Returns the number of changes performed or a negative error code. 1158 */ 1159 static int parse_protocol_change(struct rc_dev *dev, u64 *protocols, 1160 const char *buf) 1161 { 1162 const char *tmp; 1163 unsigned count = 0; 1164 bool enable, disable; 1165 u64 mask; 1166 int i; 1167 1168 while ((tmp = strsep((char **)&buf, " \n")) != NULL) { 1169 if (!*tmp) 1170 break; 1171 1172 if (*tmp == '+') { 1173 enable = true; 1174 disable = false; 1175 tmp++; 1176 } else if (*tmp == '-') { 1177 enable = false; 1178 disable = true; 1179 tmp++; 1180 } else { 1181 enable = false; 1182 disable = false; 1183 } 1184 1185 for (i = 0; i < ARRAY_SIZE(proto_names); i++) { 1186 if (!strcasecmp(tmp, proto_names[i].name)) { 1187 mask = proto_names[i].type; 1188 break; 1189 } 1190 } 1191 1192 if (i == ARRAY_SIZE(proto_names)) { 1193 if (!strcasecmp(tmp, "lirc")) 1194 mask = 0; 1195 else { 1196 dev_dbg(&dev->dev, "Unknown protocol: '%s'\n", 1197 tmp); 1198 return -EINVAL; 1199 } 1200 } 1201 1202 count++; 1203 1204 if (enable) 1205 *protocols |= mask; 1206 else if (disable) 1207 *protocols &= ~mask; 1208 else 1209 *protocols = mask; 1210 } 1211 1212 if (!count) { 1213 dev_dbg(&dev->dev, "Protocol not specified\n"); 1214 return -EINVAL; 1215 } 1216 1217 return count; 1218 } 1219 1220 void ir_raw_load_modules(u64 *protocols) 1221 { 1222 u64 available; 1223 int i, ret; 1224 1225 for (i = 0; i < ARRAY_SIZE(proto_names); i++) { 1226 if (proto_names[i].type == RC_PROTO_BIT_NONE || 1227 proto_names[i].type & (RC_PROTO_BIT_OTHER | 1228 RC_PROTO_BIT_UNKNOWN)) 1229 continue; 1230 1231 available = ir_raw_get_allowed_protocols(); 1232 if (!(*protocols & proto_names[i].type & ~available)) 1233 continue; 1234 1235 if (!proto_names[i].module_name) { 1236 pr_err("Can't enable IR protocol %s\n", 1237 proto_names[i].name); 1238 *protocols &= ~proto_names[i].type; 1239 continue; 1240 } 1241 1242 ret = request_module("%s", proto_names[i].module_name); 1243 if (ret < 0) { 1244 pr_err("Couldn't load IR protocol module %s\n", 1245 proto_names[i].module_name); 1246 *protocols &= ~proto_names[i].type; 1247 continue; 1248 } 1249 msleep(20); 1250 available = ir_raw_get_allowed_protocols(); 1251 if (!(*protocols & proto_names[i].type & ~available)) 1252 continue; 1253 1254 pr_err("Loaded IR protocol module %s, but protocol %s still not available\n", 1255 proto_names[i].module_name, 1256 proto_names[i].name); 1257 *protocols &= ~proto_names[i].type; 1258 } 1259 } 1260 1261 /** 1262 * store_protocols() - changes the current/wakeup IR protocol(s) 1263 * @device: the device descriptor 1264 * @mattr: the device attribute struct 1265 * @buf: a pointer to the input buffer 1266 * @len: length of the input buffer 1267 * 1268 * This routine is for changing the IR protocol type. 1269 * It is triggered by writing to /sys/class/rc/rc?/[wakeup_]protocols. 1270 * See parse_protocol_change() for the valid commands. 1271 * Returns @len on success or a negative error code. 1272 * 1273 * dev->lock is taken to guard against races between 1274 * store_protocols and show_protocols. 1275 */ 1276 static ssize_t store_protocols(struct device *device, 1277 struct device_attribute *mattr, 1278 const char *buf, size_t len) 1279 { 1280 struct rc_dev *dev = to_rc_dev(device); 1281 u64 *current_protocols; 1282 struct rc_scancode_filter *filter; 1283 u64 old_protocols, new_protocols; 1284 ssize_t rc; 1285 1286 dev_dbg(&dev->dev, "Normal protocol change requested\n"); 1287 current_protocols = &dev->enabled_protocols; 1288 filter = &dev->scancode_filter; 1289 1290 if (!dev->change_protocol) { 1291 dev_dbg(&dev->dev, "Protocol switching not supported\n"); 1292 return -EINVAL; 1293 } 1294 1295 mutex_lock(&dev->lock); 1296 if (!dev->registered) { 1297 mutex_unlock(&dev->lock); 1298 return -ENODEV; 1299 } 1300 1301 old_protocols = *current_protocols; 1302 new_protocols = old_protocols; 1303 rc = parse_protocol_change(dev, &new_protocols, buf); 1304 if (rc < 0) 1305 goto out; 1306 1307 if (dev->driver_type == RC_DRIVER_IR_RAW) 1308 ir_raw_load_modules(&new_protocols); 1309 1310 rc = dev->change_protocol(dev, &new_protocols); 1311 if (rc < 0) { 1312 dev_dbg(&dev->dev, "Error setting protocols to 0x%llx\n", 1313 (long long)new_protocols); 1314 goto out; 1315 } 1316 1317 if (new_protocols != old_protocols) { 1318 *current_protocols = new_protocols; 1319 dev_dbg(&dev->dev, "Protocols changed to 0x%llx\n", 1320 (long long)new_protocols); 1321 } 1322 1323 /* 1324 * If a protocol change was attempted the filter may need updating, even 1325 * if the actual protocol mask hasn't changed (since the driver may have 1326 * cleared the filter). 1327 * Try setting the same filter with the new protocol (if any). 1328 * Fall back to clearing the filter. 1329 */ 1330 if (dev->s_filter && filter->mask) { 1331 if (new_protocols) 1332 rc = dev->s_filter(dev, filter); 1333 else 1334 rc = -1; 1335 1336 if (rc < 0) { 1337 filter->data = 0; 1338 filter->mask = 0; 1339 dev->s_filter(dev, filter); 1340 } 1341 } 1342 1343 rc = len; 1344 1345 out: 1346 mutex_unlock(&dev->lock); 1347 return rc; 1348 } 1349 1350 /** 1351 * show_filter() - shows the current scancode filter value or mask 1352 * @device: the device descriptor 1353 * @attr: the device attribute struct 1354 * @buf: a pointer to the output buffer 1355 * 1356 * This routine is a callback routine to read a scancode filter value or mask. 1357 * It is triggered by reading /sys/class/rc/rc?/[wakeup_]filter[_mask]. 1358 * It prints the current scancode filter value or mask of the appropriate filter 1359 * type in hexadecimal into @buf and returns the size of the buffer. 1360 * 1361 * Bits of the filter value corresponding to set bits in the filter mask are 1362 * compared against input scancodes and non-matching scancodes are discarded. 1363 * 1364 * dev->lock is taken to guard against races between 1365 * store_filter and show_filter. 1366 */ 1367 static ssize_t show_filter(struct device *device, 1368 struct device_attribute *attr, 1369 char *buf) 1370 { 1371 struct rc_dev *dev = to_rc_dev(device); 1372 struct rc_filter_attribute *fattr = to_rc_filter_attr(attr); 1373 struct rc_scancode_filter *filter; 1374 u32 val; 1375 1376 mutex_lock(&dev->lock); 1377 1378 if (fattr->type == RC_FILTER_NORMAL) 1379 filter = &dev->scancode_filter; 1380 else 1381 filter = &dev->scancode_wakeup_filter; 1382 1383 if (fattr->mask) 1384 val = filter->mask; 1385 else 1386 val = filter->data; 1387 mutex_unlock(&dev->lock); 1388 1389 return sprintf(buf, "%#x\n", val); 1390 } 1391 1392 /** 1393 * store_filter() - changes the scancode filter value 1394 * @device: the device descriptor 1395 * @attr: the device attribute struct 1396 * @buf: a pointer to the input buffer 1397 * @len: length of the input buffer 1398 * 1399 * This routine is for changing a scancode filter value or mask. 1400 * It is triggered by writing to /sys/class/rc/rc?/[wakeup_]filter[_mask]. 1401 * Returns -EINVAL if an invalid filter value for the current protocol was 1402 * specified or if scancode filtering is not supported by the driver, otherwise 1403 * returns @len. 1404 * 1405 * Bits of the filter value corresponding to set bits in the filter mask are 1406 * compared against input scancodes and non-matching scancodes are discarded. 1407 * 1408 * dev->lock is taken to guard against races between 1409 * store_filter and show_filter. 1410 */ 1411 static ssize_t store_filter(struct device *device, 1412 struct device_attribute *attr, 1413 const char *buf, size_t len) 1414 { 1415 struct rc_dev *dev = to_rc_dev(device); 1416 struct rc_filter_attribute *fattr = to_rc_filter_attr(attr); 1417 struct rc_scancode_filter new_filter, *filter; 1418 int ret; 1419 unsigned long val; 1420 int (*set_filter)(struct rc_dev *dev, struct rc_scancode_filter *filter); 1421 1422 ret = kstrtoul(buf, 0, &val); 1423 if (ret < 0) 1424 return ret; 1425 1426 if (fattr->type == RC_FILTER_NORMAL) { 1427 set_filter = dev->s_filter; 1428 filter = &dev->scancode_filter; 1429 } else { 1430 set_filter = dev->s_wakeup_filter; 1431 filter = &dev->scancode_wakeup_filter; 1432 } 1433 1434 if (!set_filter) 1435 return -EINVAL; 1436 1437 mutex_lock(&dev->lock); 1438 if (!dev->registered) { 1439 mutex_unlock(&dev->lock); 1440 return -ENODEV; 1441 } 1442 1443 new_filter = *filter; 1444 if (fattr->mask) 1445 new_filter.mask = val; 1446 else 1447 new_filter.data = val; 1448 1449 if (fattr->type == RC_FILTER_WAKEUP) { 1450 /* 1451 * Refuse to set a filter unless a protocol is enabled 1452 * and the filter is valid for that protocol 1453 */ 1454 if (dev->wakeup_protocol != RC_PROTO_UNKNOWN) 1455 ret = rc_validate_filter(dev, &new_filter); 1456 else 1457 ret = -EINVAL; 1458 1459 if (ret != 0) 1460 goto unlock; 1461 } 1462 1463 if (fattr->type == RC_FILTER_NORMAL && !dev->enabled_protocols && 1464 val) { 1465 /* refuse to set a filter unless a protocol is enabled */ 1466 ret = -EINVAL; 1467 goto unlock; 1468 } 1469 1470 ret = set_filter(dev, &new_filter); 1471 if (ret < 0) 1472 goto unlock; 1473 1474 *filter = new_filter; 1475 1476 unlock: 1477 mutex_unlock(&dev->lock); 1478 return (ret < 0) ? ret : len; 1479 } 1480 1481 /** 1482 * show_wakeup_protocols() - shows the wakeup IR protocol 1483 * @device: the device descriptor 1484 * @mattr: the device attribute struct 1485 * @buf: a pointer to the output buffer 1486 * 1487 * This routine is a callback routine for input read the IR protocol type(s). 1488 * it is triggered by reading /sys/class/rc/rc?/wakeup_protocols. 1489 * It returns the protocol names of supported protocols. 1490 * The enabled protocols are printed in brackets. 1491 * 1492 * dev->lock is taken to guard against races between 1493 * store_wakeup_protocols and show_wakeup_protocols. 1494 */ 1495 static ssize_t show_wakeup_protocols(struct device *device, 1496 struct device_attribute *mattr, 1497 char *buf) 1498 { 1499 struct rc_dev *dev = to_rc_dev(device); 1500 u64 allowed; 1501 enum rc_proto enabled; 1502 char *tmp = buf; 1503 int i; 1504 1505 mutex_lock(&dev->lock); 1506 1507 allowed = dev->allowed_wakeup_protocols; 1508 enabled = dev->wakeup_protocol; 1509 1510 mutex_unlock(&dev->lock); 1511 1512 dev_dbg(&dev->dev, "%s: allowed - 0x%llx, enabled - %d\n", 1513 __func__, (long long)allowed, enabled); 1514 1515 for (i = 0; i < ARRAY_SIZE(protocols); i++) { 1516 if (allowed & (1ULL << i)) { 1517 if (i == enabled) 1518 tmp += sprintf(tmp, "[%s] ", protocols[i].name); 1519 else 1520 tmp += sprintf(tmp, "%s ", protocols[i].name); 1521 } 1522 } 1523 1524 if (tmp != buf) 1525 tmp--; 1526 *tmp = '\n'; 1527 1528 return tmp + 1 - buf; 1529 } 1530 1531 /** 1532 * store_wakeup_protocols() - changes the wakeup IR protocol(s) 1533 * @device: the device descriptor 1534 * @mattr: the device attribute struct 1535 * @buf: a pointer to the input buffer 1536 * @len: length of the input buffer 1537 * 1538 * This routine is for changing the IR protocol type. 1539 * It is triggered by writing to /sys/class/rc/rc?/wakeup_protocols. 1540 * Returns @len on success or a negative error code. 1541 * 1542 * dev->lock is taken to guard against races between 1543 * store_wakeup_protocols and show_wakeup_protocols. 1544 */ 1545 static ssize_t store_wakeup_protocols(struct device *device, 1546 struct device_attribute *mattr, 1547 const char *buf, size_t len) 1548 { 1549 struct rc_dev *dev = to_rc_dev(device); 1550 enum rc_proto protocol = RC_PROTO_UNKNOWN; 1551 ssize_t rc; 1552 u64 allowed; 1553 int i; 1554 1555 mutex_lock(&dev->lock); 1556 if (!dev->registered) { 1557 mutex_unlock(&dev->lock); 1558 return -ENODEV; 1559 } 1560 1561 allowed = dev->allowed_wakeup_protocols; 1562 1563 if (!sysfs_streq(buf, "none")) { 1564 for (i = 0; i < ARRAY_SIZE(protocols); i++) { 1565 if ((allowed & (1ULL << i)) && 1566 sysfs_streq(buf, protocols[i].name)) { 1567 protocol = i; 1568 break; 1569 } 1570 } 1571 1572 if (i == ARRAY_SIZE(protocols)) { 1573 rc = -EINVAL; 1574 goto out; 1575 } 1576 1577 if (dev->encode_wakeup) { 1578 u64 mask = 1ULL << protocol; 1579 1580 ir_raw_load_modules(&mask); 1581 if (!mask) { 1582 rc = -EINVAL; 1583 goto out; 1584 } 1585 } 1586 } 1587 1588 if (dev->wakeup_protocol != protocol) { 1589 dev->wakeup_protocol = protocol; 1590 dev_dbg(&dev->dev, "Wakeup protocol changed to %d\n", protocol); 1591 1592 if (protocol == RC_PROTO_RC6_MCE) 1593 dev->scancode_wakeup_filter.data = 0x800f0000; 1594 else 1595 dev->scancode_wakeup_filter.data = 0; 1596 dev->scancode_wakeup_filter.mask = 0; 1597 1598 rc = dev->s_wakeup_filter(dev, &dev->scancode_wakeup_filter); 1599 if (rc == 0) 1600 rc = len; 1601 } else { 1602 rc = len; 1603 } 1604 1605 out: 1606 mutex_unlock(&dev->lock); 1607 return rc; 1608 } 1609 1610 static void rc_dev_release(struct device *device) 1611 { 1612 struct rc_dev *dev = to_rc_dev(device); 1613 1614 kfree(dev); 1615 } 1616 1617 static int rc_dev_uevent(const struct device *device, struct kobj_uevent_env *env) 1618 { 1619 struct rc_dev *dev = to_rc_dev(device); 1620 int ret = 0; 1621 1622 mutex_lock(&dev->lock); 1623 1624 if (!dev->registered) 1625 ret = -ENODEV; 1626 if (ret == 0 && dev->rc_map.name) 1627 ret = add_uevent_var(env, "NAME=%s", dev->rc_map.name); 1628 if (ret == 0 && dev->driver_name) 1629 ret = add_uevent_var(env, "DRV_NAME=%s", dev->driver_name); 1630 if (ret == 0 && dev->device_name) 1631 ret = add_uevent_var(env, "DEV_NAME=%s", dev->device_name); 1632 1633 mutex_unlock(&dev->lock); 1634 1635 return ret; 1636 } 1637 1638 /* 1639 * Static device attribute struct with the sysfs attributes for IR's 1640 */ 1641 static struct device_attribute dev_attr_ro_protocols = 1642 __ATTR(protocols, 0444, show_protocols, NULL); 1643 static struct device_attribute dev_attr_rw_protocols = 1644 __ATTR(protocols, 0644, show_protocols, store_protocols); 1645 static DEVICE_ATTR(wakeup_protocols, 0644, show_wakeup_protocols, 1646 store_wakeup_protocols); 1647 static RC_FILTER_ATTR(filter, S_IRUGO|S_IWUSR, 1648 show_filter, store_filter, RC_FILTER_NORMAL, false); 1649 static RC_FILTER_ATTR(filter_mask, S_IRUGO|S_IWUSR, 1650 show_filter, store_filter, RC_FILTER_NORMAL, true); 1651 static RC_FILTER_ATTR(wakeup_filter, S_IRUGO|S_IWUSR, 1652 show_filter, store_filter, RC_FILTER_WAKEUP, false); 1653 static RC_FILTER_ATTR(wakeup_filter_mask, S_IRUGO|S_IWUSR, 1654 show_filter, store_filter, RC_FILTER_WAKEUP, true); 1655 1656 static struct attribute *rc_dev_rw_protocol_attrs[] = { 1657 &dev_attr_rw_protocols.attr, 1658 NULL, 1659 }; 1660 1661 static const struct attribute_group rc_dev_rw_protocol_attr_grp = { 1662 .attrs = rc_dev_rw_protocol_attrs, 1663 }; 1664 1665 static struct attribute *rc_dev_ro_protocol_attrs[] = { 1666 &dev_attr_ro_protocols.attr, 1667 NULL, 1668 }; 1669 1670 static const struct attribute_group rc_dev_ro_protocol_attr_grp = { 1671 .attrs = rc_dev_ro_protocol_attrs, 1672 }; 1673 1674 static struct attribute *rc_dev_filter_attrs[] = { 1675 &dev_attr_filter.attr.attr, 1676 &dev_attr_filter_mask.attr.attr, 1677 NULL, 1678 }; 1679 1680 static const struct attribute_group rc_dev_filter_attr_grp = { 1681 .attrs = rc_dev_filter_attrs, 1682 }; 1683 1684 static struct attribute *rc_dev_wakeup_filter_attrs[] = { 1685 &dev_attr_wakeup_filter.attr.attr, 1686 &dev_attr_wakeup_filter_mask.attr.attr, 1687 &dev_attr_wakeup_protocols.attr, 1688 NULL, 1689 }; 1690 1691 static const struct attribute_group rc_dev_wakeup_filter_attr_grp = { 1692 .attrs = rc_dev_wakeup_filter_attrs, 1693 }; 1694 1695 static const struct device_type rc_dev_type = { 1696 .release = rc_dev_release, 1697 .uevent = rc_dev_uevent, 1698 }; 1699 1700 struct rc_dev *rc_allocate_device(enum rc_driver_type type) 1701 { 1702 struct rc_dev *dev; 1703 1704 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 1705 if (!dev) 1706 return NULL; 1707 1708 if (type != RC_DRIVER_IR_RAW_TX) { 1709 dev->input_dev = input_allocate_device(); 1710 if (!dev->input_dev) { 1711 kfree(dev); 1712 return NULL; 1713 } 1714 1715 dev->input_dev->getkeycode = ir_getkeycode; 1716 dev->input_dev->setkeycode = ir_setkeycode; 1717 input_set_drvdata(dev->input_dev, dev); 1718 1719 dev->timeout = IR_DEFAULT_TIMEOUT; 1720 timer_setup(&dev->timer_keyup, ir_timer_keyup, 0); 1721 timer_setup(&dev->timer_repeat, ir_timer_repeat, 0); 1722 1723 spin_lock_init(&dev->rc_map.lock); 1724 spin_lock_init(&dev->keylock); 1725 } 1726 mutex_init(&dev->lock); 1727 1728 dev->dev.type = &rc_dev_type; 1729 dev->dev.class = &rc_class; 1730 device_initialize(&dev->dev); 1731 1732 dev->driver_type = type; 1733 1734 __module_get(THIS_MODULE); 1735 return dev; 1736 } 1737 EXPORT_SYMBOL_GPL(rc_allocate_device); 1738 1739 void rc_free_device(struct rc_dev *dev) 1740 { 1741 if (!dev) 1742 return; 1743 1744 input_free_device(dev->input_dev); 1745 1746 put_device(&dev->dev); 1747 1748 /* kfree(dev) will be called by the callback function 1749 rc_dev_release() */ 1750 1751 module_put(THIS_MODULE); 1752 } 1753 EXPORT_SYMBOL_GPL(rc_free_device); 1754 1755 static void devm_rc_alloc_release(struct device *dev, void *res) 1756 { 1757 rc_free_device(*(struct rc_dev **)res); 1758 } 1759 1760 struct rc_dev *devm_rc_allocate_device(struct device *dev, 1761 enum rc_driver_type type) 1762 { 1763 struct rc_dev **dr, *rc; 1764 1765 dr = devres_alloc(devm_rc_alloc_release, sizeof(*dr), GFP_KERNEL); 1766 if (!dr) 1767 return NULL; 1768 1769 rc = rc_allocate_device(type); 1770 if (!rc) { 1771 devres_free(dr); 1772 return NULL; 1773 } 1774 1775 rc->dev.parent = dev; 1776 rc->managed_alloc = true; 1777 *dr = rc; 1778 devres_add(dev, dr); 1779 1780 return rc; 1781 } 1782 EXPORT_SYMBOL_GPL(devm_rc_allocate_device); 1783 1784 static int rc_prepare_rx_device(struct rc_dev *dev) 1785 { 1786 int rc; 1787 struct rc_map *rc_map; 1788 u64 rc_proto; 1789 1790 if (!dev->map_name) 1791 return -EINVAL; 1792 1793 rc_map = rc_map_get(dev->map_name); 1794 if (!rc_map) 1795 rc_map = rc_map_get(RC_MAP_EMPTY); 1796 if (!rc_map || !rc_map->scan || rc_map->size == 0) 1797 return -EINVAL; 1798 1799 rc = ir_setkeytable(dev, rc_map); 1800 if (rc) 1801 return rc; 1802 1803 rc_proto = BIT_ULL(rc_map->rc_proto); 1804 1805 if (dev->driver_type == RC_DRIVER_SCANCODE && !dev->change_protocol) 1806 dev->enabled_protocols = dev->allowed_protocols; 1807 1808 if (dev->driver_type == RC_DRIVER_IR_RAW) 1809 ir_raw_load_modules(&rc_proto); 1810 1811 if (dev->change_protocol) { 1812 rc = dev->change_protocol(dev, &rc_proto); 1813 if (rc < 0) 1814 goto out_table; 1815 dev->enabled_protocols = rc_proto; 1816 } 1817 1818 /* Keyboard events */ 1819 set_bit(EV_KEY, dev->input_dev->evbit); 1820 set_bit(EV_REP, dev->input_dev->evbit); 1821 set_bit(EV_MSC, dev->input_dev->evbit); 1822 set_bit(MSC_SCAN, dev->input_dev->mscbit); 1823 1824 /* Pointer/mouse events */ 1825 set_bit(INPUT_PROP_POINTING_STICK, dev->input_dev->propbit); 1826 set_bit(EV_REL, dev->input_dev->evbit); 1827 set_bit(REL_X, dev->input_dev->relbit); 1828 set_bit(REL_Y, dev->input_dev->relbit); 1829 1830 if (dev->open) 1831 dev->input_dev->open = ir_open; 1832 if (dev->close) 1833 dev->input_dev->close = ir_close; 1834 1835 dev->input_dev->dev.parent = &dev->dev; 1836 memcpy(&dev->input_dev->id, &dev->input_id, sizeof(dev->input_id)); 1837 dev->input_dev->phys = dev->input_phys; 1838 dev->input_dev->name = dev->device_name; 1839 1840 return 0; 1841 1842 out_table: 1843 ir_free_table(&dev->rc_map); 1844 1845 return rc; 1846 } 1847 1848 static int rc_setup_rx_device(struct rc_dev *dev) 1849 { 1850 int rc; 1851 1852 /* rc_open will be called here */ 1853 rc = input_register_device(dev->input_dev); 1854 if (rc) 1855 return rc; 1856 1857 /* 1858 * Default delay of 250ms is too short for some protocols, especially 1859 * since the timeout is currently set to 250ms. Increase it to 500ms, 1860 * to avoid wrong repetition of the keycodes. Note that this must be 1861 * set after the call to input_register_device(). 1862 */ 1863 if (dev->allowed_protocols == RC_PROTO_BIT_CEC) 1864 dev->input_dev->rep[REP_DELAY] = 0; 1865 else 1866 dev->input_dev->rep[REP_DELAY] = 500; 1867 1868 /* 1869 * As a repeat event on protocols like RC-5 and NEC take as long as 1870 * 110/114ms, using 33ms as a repeat period is not the right thing 1871 * to do. 1872 */ 1873 dev->input_dev->rep[REP_PERIOD] = 125; 1874 1875 return 0; 1876 } 1877 1878 static void rc_free_rx_device(struct rc_dev *dev) 1879 { 1880 if (!dev) 1881 return; 1882 1883 if (dev->input_dev) { 1884 input_unregister_device(dev->input_dev); 1885 dev->input_dev = NULL; 1886 } 1887 1888 ir_free_table(&dev->rc_map); 1889 } 1890 1891 int rc_register_device(struct rc_dev *dev) 1892 { 1893 const char *path; 1894 int attr = 0; 1895 int minor; 1896 int rc; 1897 1898 if (!dev) 1899 return -EINVAL; 1900 1901 minor = ida_alloc_max(&rc_ida, RC_DEV_MAX - 1, GFP_KERNEL); 1902 if (minor < 0) 1903 return minor; 1904 1905 dev->minor = minor; 1906 dev_set_name(&dev->dev, "rc%u", dev->minor); 1907 dev_set_drvdata(&dev->dev, dev); 1908 1909 dev->dev.groups = dev->sysfs_groups; 1910 if (dev->driver_type == RC_DRIVER_SCANCODE && !dev->change_protocol) 1911 dev->sysfs_groups[attr++] = &rc_dev_ro_protocol_attr_grp; 1912 else if (dev->driver_type != RC_DRIVER_IR_RAW_TX) 1913 dev->sysfs_groups[attr++] = &rc_dev_rw_protocol_attr_grp; 1914 if (dev->s_filter) 1915 dev->sysfs_groups[attr++] = &rc_dev_filter_attr_grp; 1916 if (dev->s_wakeup_filter) 1917 dev->sysfs_groups[attr++] = &rc_dev_wakeup_filter_attr_grp; 1918 dev->sysfs_groups[attr++] = NULL; 1919 1920 if (dev->driver_type == RC_DRIVER_IR_RAW) { 1921 rc = ir_raw_event_prepare(dev); 1922 if (rc < 0) 1923 goto out_minor; 1924 } 1925 1926 if (dev->driver_type != RC_DRIVER_IR_RAW_TX) { 1927 rc = rc_prepare_rx_device(dev); 1928 if (rc) 1929 goto out_raw; 1930 } 1931 1932 dev->registered = true; 1933 1934 rc = device_add(&dev->dev); 1935 if (rc) 1936 goto out_rx_free; 1937 1938 path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL); 1939 dev_info(&dev->dev, "%s as %s\n", 1940 dev->device_name ?: "Unspecified device", path ?: "N/A"); 1941 kfree(path); 1942 1943 /* 1944 * once the input device is registered in rc_setup_rx_device, 1945 * userspace can open the input device and rc_open() will be called 1946 * as a result. This results in driver code being allowed to submit 1947 * keycodes with rc_keydown, so lirc must be registered first. 1948 */ 1949 if (dev->allowed_protocols != RC_PROTO_BIT_CEC) { 1950 rc = lirc_register(dev); 1951 if (rc < 0) 1952 goto out_dev; 1953 } 1954 1955 if (dev->driver_type != RC_DRIVER_IR_RAW_TX) { 1956 rc = rc_setup_rx_device(dev); 1957 if (rc) 1958 goto out_lirc; 1959 } 1960 1961 if (dev->driver_type == RC_DRIVER_IR_RAW) { 1962 rc = ir_raw_event_register(dev); 1963 if (rc < 0) 1964 goto out_rx; 1965 } 1966 1967 dev_dbg(&dev->dev, "Registered rc%u (driver: %s)\n", dev->minor, 1968 dev->driver_name ? dev->driver_name : "unknown"); 1969 1970 return 0; 1971 1972 out_rx: 1973 rc_free_rx_device(dev); 1974 out_lirc: 1975 if (dev->allowed_protocols != RC_PROTO_BIT_CEC) 1976 lirc_unregister(dev); 1977 out_dev: 1978 device_del(&dev->dev); 1979 out_rx_free: 1980 ir_free_table(&dev->rc_map); 1981 out_raw: 1982 ir_raw_event_free(dev); 1983 out_minor: 1984 ida_free(&rc_ida, minor); 1985 return rc; 1986 } 1987 EXPORT_SYMBOL_GPL(rc_register_device); 1988 1989 static void devm_rc_release(struct device *dev, void *res) 1990 { 1991 rc_unregister_device(*(struct rc_dev **)res); 1992 } 1993 1994 int devm_rc_register_device(struct device *parent, struct rc_dev *dev) 1995 { 1996 struct rc_dev **dr; 1997 int ret; 1998 1999 dr = devres_alloc(devm_rc_release, sizeof(*dr), GFP_KERNEL); 2000 if (!dr) 2001 return -ENOMEM; 2002 2003 ret = rc_register_device(dev); 2004 if (ret) { 2005 devres_free(dr); 2006 return ret; 2007 } 2008 2009 *dr = dev; 2010 devres_add(parent, dr); 2011 2012 return 0; 2013 } 2014 EXPORT_SYMBOL_GPL(devm_rc_register_device); 2015 2016 void rc_unregister_device(struct rc_dev *dev) 2017 { 2018 if (!dev) 2019 return; 2020 2021 if (dev->driver_type == RC_DRIVER_IR_RAW) 2022 ir_raw_event_unregister(dev); 2023 2024 del_timer_sync(&dev->timer_keyup); 2025 del_timer_sync(&dev->timer_repeat); 2026 2027 mutex_lock(&dev->lock); 2028 if (dev->users && dev->close) 2029 dev->close(dev); 2030 dev->registered = false; 2031 mutex_unlock(&dev->lock); 2032 2033 rc_free_rx_device(dev); 2034 2035 /* 2036 * lirc device should be freed with dev->registered = false, so 2037 * that userspace polling will get notified. 2038 */ 2039 if (dev->allowed_protocols != RC_PROTO_BIT_CEC) 2040 lirc_unregister(dev); 2041 2042 device_del(&dev->dev); 2043 2044 ida_free(&rc_ida, dev->minor); 2045 2046 if (!dev->managed_alloc) 2047 rc_free_device(dev); 2048 } 2049 2050 EXPORT_SYMBOL_GPL(rc_unregister_device); 2051 2052 /* 2053 * Init/exit code for the module. Basically, creates/removes /sys/class/rc 2054 */ 2055 2056 static int __init rc_core_init(void) 2057 { 2058 int rc = class_register(&rc_class); 2059 if (rc) { 2060 pr_err("rc_core: unable to register rc class\n"); 2061 return rc; 2062 } 2063 2064 rc = lirc_dev_init(); 2065 if (rc) { 2066 pr_err("rc_core: unable to init lirc\n"); 2067 class_unregister(&rc_class); 2068 return rc; 2069 } 2070 2071 led_trigger_register_simple("rc-feedback", &led_feedback); 2072 rc_map_register(&empty_map); 2073 #ifdef CONFIG_MEDIA_CEC_RC 2074 rc_map_register(&cec_map); 2075 #endif 2076 2077 return 0; 2078 } 2079 2080 static void __exit rc_core_exit(void) 2081 { 2082 lirc_dev_exit(); 2083 class_unregister(&rc_class); 2084 led_trigger_unregister_simple(led_feedback); 2085 #ifdef CONFIG_MEDIA_CEC_RC 2086 rc_map_unregister(&cec_map); 2087 #endif 2088 rc_map_unregister(&empty_map); 2089 } 2090 2091 subsys_initcall(rc_core_init); 2092 module_exit(rc_core_exit); 2093 2094 MODULE_AUTHOR("Mauro Carvalho Chehab"); 2095 MODULE_LICENSE("GPL v2"); 2096