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