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