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