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