1 /* rc-main.c - Remote Controller core module 2 * 3 * Copyright (C) 2009-2010 by Mauro Carvalho Chehab <mchehab@redhat.com> 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 #include <media/rc-core.h> 16 #include <linux/spinlock.h> 17 #include <linux/delay.h> 18 #include <linux/input.h> 19 #include <linux/slab.h> 20 #include <linux/device.h> 21 #include "rc-core-priv.h" 22 23 /* Sizes are in bytes, 256 bytes allows for 32 entries on x64 */ 24 #define IR_TAB_MIN_SIZE 256 25 #define IR_TAB_MAX_SIZE 8192 26 27 /* FIXME: IR_KEYPRESS_TIMEOUT should be protocol specific */ 28 #define IR_KEYPRESS_TIMEOUT 250 29 30 /* Used to keep track of known keymaps */ 31 static LIST_HEAD(rc_map_list); 32 static DEFINE_SPINLOCK(rc_map_lock); 33 34 static struct rc_map_list *seek_rc_map(const char *name) 35 { 36 struct rc_map_list *map = NULL; 37 38 spin_lock(&rc_map_lock); 39 list_for_each_entry(map, &rc_map_list, list) { 40 if (!strcmp(name, map->map.name)) { 41 spin_unlock(&rc_map_lock); 42 return map; 43 } 44 } 45 spin_unlock(&rc_map_lock); 46 47 return NULL; 48 } 49 50 struct rc_map *rc_map_get(const char *name) 51 { 52 53 struct rc_map_list *map; 54 55 map = seek_rc_map(name); 56 #ifdef MODULE 57 if (!map) { 58 int rc = request_module(name); 59 if (rc < 0) { 60 printk(KERN_ERR "Couldn't load IR keymap %s\n", name); 61 return NULL; 62 } 63 msleep(20); /* Give some time for IR to register */ 64 65 map = seek_rc_map(name); 66 } 67 #endif 68 if (!map) { 69 printk(KERN_ERR "IR keymap %s not found\n", name); 70 return NULL; 71 } 72 73 printk(KERN_INFO "Registered IR keymap %s\n", map->map.name); 74 75 return &map->map; 76 } 77 EXPORT_SYMBOL_GPL(rc_map_get); 78 79 int rc_map_register(struct rc_map_list *map) 80 { 81 spin_lock(&rc_map_lock); 82 list_add_tail(&map->list, &rc_map_list); 83 spin_unlock(&rc_map_lock); 84 return 0; 85 } 86 EXPORT_SYMBOL_GPL(rc_map_register); 87 88 void rc_map_unregister(struct rc_map_list *map) 89 { 90 spin_lock(&rc_map_lock); 91 list_del(&map->list); 92 spin_unlock(&rc_map_lock); 93 } 94 EXPORT_SYMBOL_GPL(rc_map_unregister); 95 96 97 static struct rc_map_table empty[] = { 98 { 0x2a, KEY_COFFEE }, 99 }; 100 101 static struct rc_map_list empty_map = { 102 .map = { 103 .scan = empty, 104 .size = ARRAY_SIZE(empty), 105 .rc_type = RC_TYPE_UNKNOWN, /* Legacy IR type */ 106 .name = RC_MAP_EMPTY, 107 } 108 }; 109 110 /** 111 * ir_create_table() - initializes a scancode table 112 * @rc_map: the rc_map to initialize 113 * @name: name to assign to the table 114 * @rc_type: ir type to assign to the new table 115 * @size: initial size of the table 116 * @return: zero on success or a negative error code 117 * 118 * This routine will initialize the rc_map and will allocate 119 * memory to hold at least the specified number of elements. 120 */ 121 static int ir_create_table(struct rc_map *rc_map, 122 const char *name, u64 rc_type, size_t size) 123 { 124 rc_map->name = name; 125 rc_map->rc_type = rc_type; 126 rc_map->alloc = roundup_pow_of_two(size * sizeof(struct rc_map_table)); 127 rc_map->size = rc_map->alloc / sizeof(struct rc_map_table); 128 rc_map->scan = kmalloc(rc_map->alloc, GFP_KERNEL); 129 if (!rc_map->scan) 130 return -ENOMEM; 131 132 IR_dprintk(1, "Allocated space for %u keycode entries (%u bytes)\n", 133 rc_map->size, rc_map->alloc); 134 return 0; 135 } 136 137 /** 138 * ir_free_table() - frees memory allocated by a scancode table 139 * @rc_map: the table whose mappings need to be freed 140 * 141 * This routine will free memory alloctaed for key mappings used by given 142 * scancode table. 143 */ 144 static void ir_free_table(struct rc_map *rc_map) 145 { 146 rc_map->size = 0; 147 kfree(rc_map->scan); 148 rc_map->scan = NULL; 149 } 150 151 /** 152 * ir_resize_table() - resizes a scancode table if necessary 153 * @rc_map: the rc_map to resize 154 * @gfp_flags: gfp flags to use when allocating memory 155 * @return: zero on success or a negative error code 156 * 157 * This routine will shrink the rc_map if it has lots of 158 * unused entries and grow it if it is full. 159 */ 160 static int ir_resize_table(struct rc_map *rc_map, gfp_t gfp_flags) 161 { 162 unsigned int oldalloc = rc_map->alloc; 163 unsigned int newalloc = oldalloc; 164 struct rc_map_table *oldscan = rc_map->scan; 165 struct rc_map_table *newscan; 166 167 if (rc_map->size == rc_map->len) { 168 /* All entries in use -> grow keytable */ 169 if (rc_map->alloc >= IR_TAB_MAX_SIZE) 170 return -ENOMEM; 171 172 newalloc *= 2; 173 IR_dprintk(1, "Growing table to %u bytes\n", newalloc); 174 } 175 176 if ((rc_map->len * 3 < rc_map->size) && (oldalloc > IR_TAB_MIN_SIZE)) { 177 /* Less than 1/3 of entries in use -> shrink keytable */ 178 newalloc /= 2; 179 IR_dprintk(1, "Shrinking table to %u bytes\n", newalloc); 180 } 181 182 if (newalloc == oldalloc) 183 return 0; 184 185 newscan = kmalloc(newalloc, gfp_flags); 186 if (!newscan) { 187 IR_dprintk(1, "Failed to kmalloc %u bytes\n", newalloc); 188 return -ENOMEM; 189 } 190 191 memcpy(newscan, rc_map->scan, rc_map->len * sizeof(struct rc_map_table)); 192 rc_map->scan = newscan; 193 rc_map->alloc = newalloc; 194 rc_map->size = rc_map->alloc / sizeof(struct rc_map_table); 195 kfree(oldscan); 196 return 0; 197 } 198 199 /** 200 * ir_update_mapping() - set a keycode in the scancode->keycode table 201 * @dev: the struct rc_dev device descriptor 202 * @rc_map: scancode table to be adjusted 203 * @index: index of the mapping that needs to be updated 204 * @keycode: the desired keycode 205 * @return: previous keycode assigned to the mapping 206 * 207 * This routine is used to update scancode->keycode mapping at given 208 * position. 209 */ 210 static unsigned int ir_update_mapping(struct rc_dev *dev, 211 struct rc_map *rc_map, 212 unsigned int index, 213 unsigned int new_keycode) 214 { 215 int old_keycode = rc_map->scan[index].keycode; 216 int i; 217 218 /* Did the user wish to remove the mapping? */ 219 if (new_keycode == KEY_RESERVED || new_keycode == KEY_UNKNOWN) { 220 IR_dprintk(1, "#%d: Deleting scan 0x%04x\n", 221 index, rc_map->scan[index].scancode); 222 rc_map->len--; 223 memmove(&rc_map->scan[index], &rc_map->scan[index+ 1], 224 (rc_map->len - index) * sizeof(struct rc_map_table)); 225 } else { 226 IR_dprintk(1, "#%d: %s scan 0x%04x with key 0x%04x\n", 227 index, 228 old_keycode == KEY_RESERVED ? "New" : "Replacing", 229 rc_map->scan[index].scancode, new_keycode); 230 rc_map->scan[index].keycode = new_keycode; 231 __set_bit(new_keycode, dev->input_dev->keybit); 232 } 233 234 if (old_keycode != KEY_RESERVED) { 235 /* A previous mapping was updated... */ 236 __clear_bit(old_keycode, dev->input_dev->keybit); 237 /* ... but another scancode might use the same keycode */ 238 for (i = 0; i < rc_map->len; i++) { 239 if (rc_map->scan[i].keycode == old_keycode) { 240 __set_bit(old_keycode, dev->input_dev->keybit); 241 break; 242 } 243 } 244 245 /* Possibly shrink the keytable, failure is not a problem */ 246 ir_resize_table(rc_map, GFP_ATOMIC); 247 } 248 249 return old_keycode; 250 } 251 252 /** 253 * ir_establish_scancode() - set a keycode in the scancode->keycode table 254 * @dev: the struct rc_dev device descriptor 255 * @rc_map: scancode table to be searched 256 * @scancode: the desired scancode 257 * @resize: controls whether we allowed to resize the table to 258 * accommodate not yet present scancodes 259 * @return: index of the mapping containing scancode in question 260 * or -1U in case of failure. 261 * 262 * This routine is used to locate given scancode in rc_map. 263 * If scancode is not yet present the routine will allocate a new slot 264 * for it. 265 */ 266 static unsigned int ir_establish_scancode(struct rc_dev *dev, 267 struct rc_map *rc_map, 268 unsigned int scancode, 269 bool resize) 270 { 271 unsigned int i; 272 273 /* 274 * Unfortunately, some hardware-based IR decoders don't provide 275 * all bits for the complete IR code. In general, they provide only 276 * the command part of the IR code. Yet, as it is possible to replace 277 * the provided IR with another one, it is needed to allow loading 278 * IR tables from other remotes. So, we support specifying a mask to 279 * indicate the valid bits of the scancodes. 280 */ 281 if (dev->scanmask) 282 scancode &= dev->scanmask; 283 284 /* First check if we already have a mapping for this ir command */ 285 for (i = 0; i < rc_map->len; i++) { 286 if (rc_map->scan[i].scancode == scancode) 287 return i; 288 289 /* Keytable is sorted from lowest to highest scancode */ 290 if (rc_map->scan[i].scancode >= scancode) 291 break; 292 } 293 294 /* No previous mapping found, we might need to grow the table */ 295 if (rc_map->size == rc_map->len) { 296 if (!resize || ir_resize_table(rc_map, GFP_ATOMIC)) 297 return -1U; 298 } 299 300 /* i is the proper index to insert our new keycode */ 301 if (i < rc_map->len) 302 memmove(&rc_map->scan[i + 1], &rc_map->scan[i], 303 (rc_map->len - i) * sizeof(struct rc_map_table)); 304 rc_map->scan[i].scancode = scancode; 305 rc_map->scan[i].keycode = KEY_RESERVED; 306 rc_map->len++; 307 308 return i; 309 } 310 311 /** 312 * ir_setkeycode() - set a keycode in the scancode->keycode table 313 * @idev: the struct input_dev device descriptor 314 * @scancode: the desired scancode 315 * @keycode: result 316 * @return: -EINVAL if the keycode could not be inserted, otherwise zero. 317 * 318 * This routine is used to handle evdev EVIOCSKEY ioctl. 319 */ 320 static int ir_setkeycode(struct input_dev *idev, 321 const struct input_keymap_entry *ke, 322 unsigned int *old_keycode) 323 { 324 struct rc_dev *rdev = input_get_drvdata(idev); 325 struct rc_map *rc_map = &rdev->rc_map; 326 unsigned int index; 327 unsigned int scancode; 328 int retval = 0; 329 unsigned long flags; 330 331 spin_lock_irqsave(&rc_map->lock, flags); 332 333 if (ke->flags & INPUT_KEYMAP_BY_INDEX) { 334 index = ke->index; 335 if (index >= rc_map->len) { 336 retval = -EINVAL; 337 goto out; 338 } 339 } else { 340 retval = input_scancode_to_scalar(ke, &scancode); 341 if (retval) 342 goto out; 343 344 index = ir_establish_scancode(rdev, rc_map, scancode, true); 345 if (index >= rc_map->len) { 346 retval = -ENOMEM; 347 goto out; 348 } 349 } 350 351 *old_keycode = ir_update_mapping(rdev, rc_map, index, ke->keycode); 352 353 out: 354 spin_unlock_irqrestore(&rc_map->lock, flags); 355 return retval; 356 } 357 358 /** 359 * ir_setkeytable() - sets several entries in the scancode->keycode table 360 * @dev: the struct rc_dev device descriptor 361 * @to: the struct rc_map to copy entries to 362 * @from: the struct rc_map to copy entries from 363 * @return: -ENOMEM if all keycodes could not be inserted, otherwise zero. 364 * 365 * This routine is used to handle table initialization. 366 */ 367 static int ir_setkeytable(struct rc_dev *dev, 368 const struct rc_map *from) 369 { 370 struct rc_map *rc_map = &dev->rc_map; 371 unsigned int i, index; 372 int rc; 373 374 rc = ir_create_table(rc_map, from->name, 375 from->rc_type, from->size); 376 if (rc) 377 return rc; 378 379 IR_dprintk(1, "Allocated space for %u keycode entries (%u bytes)\n", 380 rc_map->size, rc_map->alloc); 381 382 for (i = 0; i < from->size; i++) { 383 index = ir_establish_scancode(dev, rc_map, 384 from->scan[i].scancode, false); 385 if (index >= rc_map->len) { 386 rc = -ENOMEM; 387 break; 388 } 389 390 ir_update_mapping(dev, rc_map, index, 391 from->scan[i].keycode); 392 } 393 394 if (rc) 395 ir_free_table(rc_map); 396 397 return rc; 398 } 399 400 /** 401 * ir_lookup_by_scancode() - locate mapping by scancode 402 * @rc_map: the struct rc_map to search 403 * @scancode: scancode to look for in the table 404 * @return: index in the table, -1U if not found 405 * 406 * This routine performs binary search in RC keykeymap table for 407 * given scancode. 408 */ 409 static unsigned int ir_lookup_by_scancode(const struct rc_map *rc_map, 410 unsigned int scancode) 411 { 412 int start = 0; 413 int end = rc_map->len - 1; 414 int mid; 415 416 while (start <= end) { 417 mid = (start + end) / 2; 418 if (rc_map->scan[mid].scancode < scancode) 419 start = mid + 1; 420 else if (rc_map->scan[mid].scancode > scancode) 421 end = mid - 1; 422 else 423 return mid; 424 } 425 426 return -1U; 427 } 428 429 /** 430 * ir_getkeycode() - get a keycode from the scancode->keycode table 431 * @idev: the struct input_dev device descriptor 432 * @scancode: the desired scancode 433 * @keycode: used to return the keycode, if found, or KEY_RESERVED 434 * @return: always returns zero. 435 * 436 * This routine is used to handle evdev EVIOCGKEY ioctl. 437 */ 438 static int ir_getkeycode(struct input_dev *idev, 439 struct input_keymap_entry *ke) 440 { 441 struct rc_dev *rdev = input_get_drvdata(idev); 442 struct rc_map *rc_map = &rdev->rc_map; 443 struct rc_map_table *entry; 444 unsigned long flags; 445 unsigned int index; 446 unsigned int scancode; 447 int retval; 448 449 spin_lock_irqsave(&rc_map->lock, flags); 450 451 if (ke->flags & INPUT_KEYMAP_BY_INDEX) { 452 index = ke->index; 453 } else { 454 retval = input_scancode_to_scalar(ke, &scancode); 455 if (retval) 456 goto out; 457 458 index = ir_lookup_by_scancode(rc_map, scancode); 459 } 460 461 if (index < rc_map->len) { 462 entry = &rc_map->scan[index]; 463 464 ke->index = index; 465 ke->keycode = entry->keycode; 466 ke->len = sizeof(entry->scancode); 467 memcpy(ke->scancode, &entry->scancode, sizeof(entry->scancode)); 468 469 } else if (!(ke->flags & INPUT_KEYMAP_BY_INDEX)) { 470 /* 471 * We do not really know the valid range of scancodes 472 * so let's respond with KEY_RESERVED to anything we 473 * do not have mapping for [yet]. 474 */ 475 ke->index = index; 476 ke->keycode = KEY_RESERVED; 477 } else { 478 retval = -EINVAL; 479 goto out; 480 } 481 482 retval = 0; 483 484 out: 485 spin_unlock_irqrestore(&rc_map->lock, flags); 486 return retval; 487 } 488 489 /** 490 * rc_g_keycode_from_table() - gets the keycode that corresponds to a scancode 491 * @dev: the struct rc_dev descriptor of the device 492 * @scancode: the scancode to look for 493 * @return: the corresponding keycode, or KEY_RESERVED 494 * 495 * This routine is used by drivers which need to convert a scancode to a 496 * keycode. Normally it should not be used since drivers should have no 497 * interest in keycodes. 498 */ 499 u32 rc_g_keycode_from_table(struct rc_dev *dev, u32 scancode) 500 { 501 struct rc_map *rc_map = &dev->rc_map; 502 unsigned int keycode; 503 unsigned int index; 504 unsigned long flags; 505 506 spin_lock_irqsave(&rc_map->lock, flags); 507 508 index = ir_lookup_by_scancode(rc_map, scancode); 509 keycode = index < rc_map->len ? 510 rc_map->scan[index].keycode : KEY_RESERVED; 511 512 spin_unlock_irqrestore(&rc_map->lock, flags); 513 514 if (keycode != KEY_RESERVED) 515 IR_dprintk(1, "%s: scancode 0x%04x keycode 0x%02x\n", 516 dev->input_name, scancode, keycode); 517 518 return keycode; 519 } 520 EXPORT_SYMBOL_GPL(rc_g_keycode_from_table); 521 522 /** 523 * ir_do_keyup() - internal function to signal the release of a keypress 524 * @dev: the struct rc_dev descriptor of the device 525 * @sync: whether or not to call input_sync 526 * 527 * This function is used internally to release a keypress, it must be 528 * called with keylock held. 529 */ 530 static void ir_do_keyup(struct rc_dev *dev, bool sync) 531 { 532 if (!dev->keypressed) 533 return; 534 535 IR_dprintk(1, "keyup key 0x%04x\n", dev->last_keycode); 536 input_report_key(dev->input_dev, dev->last_keycode, 0); 537 if (sync) 538 input_sync(dev->input_dev); 539 dev->keypressed = false; 540 } 541 542 /** 543 * rc_keyup() - signals the release of a keypress 544 * @dev: the struct rc_dev descriptor of the device 545 * 546 * This routine is used to signal that a key has been released on the 547 * remote control. 548 */ 549 void rc_keyup(struct rc_dev *dev) 550 { 551 unsigned long flags; 552 553 spin_lock_irqsave(&dev->keylock, flags); 554 ir_do_keyup(dev, true); 555 spin_unlock_irqrestore(&dev->keylock, flags); 556 } 557 EXPORT_SYMBOL_GPL(rc_keyup); 558 559 /** 560 * ir_timer_keyup() - generates a keyup event after a timeout 561 * @cookie: a pointer to the struct rc_dev for the device 562 * 563 * This routine will generate a keyup event some time after a keydown event 564 * is generated when no further activity has been detected. 565 */ 566 static void ir_timer_keyup(unsigned long cookie) 567 { 568 struct rc_dev *dev = (struct rc_dev *)cookie; 569 unsigned long flags; 570 571 /* 572 * ir->keyup_jiffies is used to prevent a race condition if a 573 * hardware interrupt occurs at this point and the keyup timer 574 * event is moved further into the future as a result. 575 * 576 * The timer will then be reactivated and this function called 577 * again in the future. We need to exit gracefully in that case 578 * to allow the input subsystem to do its auto-repeat magic or 579 * a keyup event might follow immediately after the keydown. 580 */ 581 spin_lock_irqsave(&dev->keylock, flags); 582 if (time_is_before_eq_jiffies(dev->keyup_jiffies)) 583 ir_do_keyup(dev, true); 584 spin_unlock_irqrestore(&dev->keylock, flags); 585 } 586 587 /** 588 * rc_repeat() - signals that a key is still pressed 589 * @dev: the struct rc_dev descriptor of the device 590 * 591 * This routine is used by IR decoders when a repeat message which does 592 * not include the necessary bits to reproduce the scancode has been 593 * received. 594 */ 595 void rc_repeat(struct rc_dev *dev) 596 { 597 unsigned long flags; 598 599 spin_lock_irqsave(&dev->keylock, flags); 600 601 input_event(dev->input_dev, EV_MSC, MSC_SCAN, dev->last_scancode); 602 input_sync(dev->input_dev); 603 604 if (!dev->keypressed) 605 goto out; 606 607 dev->keyup_jiffies = jiffies + msecs_to_jiffies(IR_KEYPRESS_TIMEOUT); 608 mod_timer(&dev->timer_keyup, dev->keyup_jiffies); 609 610 out: 611 spin_unlock_irqrestore(&dev->keylock, flags); 612 } 613 EXPORT_SYMBOL_GPL(rc_repeat); 614 615 /** 616 * ir_do_keydown() - internal function to process a keypress 617 * @dev: the struct rc_dev descriptor of the device 618 * @scancode: the scancode of the keypress 619 * @keycode: the keycode of the keypress 620 * @toggle: the toggle value of the keypress 621 * 622 * This function is used internally to register a keypress, it must be 623 * called with keylock held. 624 */ 625 static void ir_do_keydown(struct rc_dev *dev, int scancode, 626 u32 keycode, u8 toggle) 627 { 628 bool new_event = !dev->keypressed || 629 dev->last_scancode != scancode || 630 dev->last_toggle != toggle; 631 632 if (new_event && dev->keypressed) 633 ir_do_keyup(dev, false); 634 635 input_event(dev->input_dev, EV_MSC, MSC_SCAN, scancode); 636 637 if (new_event && keycode != KEY_RESERVED) { 638 /* Register a keypress */ 639 dev->keypressed = true; 640 dev->last_scancode = scancode; 641 dev->last_toggle = toggle; 642 dev->last_keycode = keycode; 643 644 IR_dprintk(1, "%s: key down event, " 645 "key 0x%04x, scancode 0x%04x\n", 646 dev->input_name, keycode, scancode); 647 input_report_key(dev->input_dev, keycode, 1); 648 } 649 650 input_sync(dev->input_dev); 651 } 652 653 /** 654 * rc_keydown() - generates input event for a key press 655 * @dev: the struct rc_dev descriptor of the device 656 * @scancode: the scancode that we're seeking 657 * @toggle: the toggle value (protocol dependent, if the protocol doesn't 658 * support toggle values, this should be set to zero) 659 * 660 * This routine is used to signal that a key has been pressed on the 661 * remote control. 662 */ 663 void rc_keydown(struct rc_dev *dev, int scancode, u8 toggle) 664 { 665 unsigned long flags; 666 u32 keycode = rc_g_keycode_from_table(dev, scancode); 667 668 spin_lock_irqsave(&dev->keylock, flags); 669 ir_do_keydown(dev, scancode, keycode, toggle); 670 671 if (dev->keypressed) { 672 dev->keyup_jiffies = jiffies + msecs_to_jiffies(IR_KEYPRESS_TIMEOUT); 673 mod_timer(&dev->timer_keyup, dev->keyup_jiffies); 674 } 675 spin_unlock_irqrestore(&dev->keylock, flags); 676 } 677 EXPORT_SYMBOL_GPL(rc_keydown); 678 679 /** 680 * rc_keydown_notimeout() - generates input event for a key press without 681 * an automatic keyup event at a later time 682 * @dev: the struct rc_dev descriptor of the device 683 * @scancode: the scancode that we're seeking 684 * @toggle: the toggle value (protocol dependent, if the protocol doesn't 685 * support toggle values, this should be set to zero) 686 * 687 * This routine is used to signal that a key has been pressed on the 688 * remote control. The driver must manually call rc_keyup() at a later stage. 689 */ 690 void rc_keydown_notimeout(struct rc_dev *dev, int scancode, u8 toggle) 691 { 692 unsigned long flags; 693 u32 keycode = rc_g_keycode_from_table(dev, scancode); 694 695 spin_lock_irqsave(&dev->keylock, flags); 696 ir_do_keydown(dev, scancode, keycode, toggle); 697 spin_unlock_irqrestore(&dev->keylock, flags); 698 } 699 EXPORT_SYMBOL_GPL(rc_keydown_notimeout); 700 701 static int ir_open(struct input_dev *idev) 702 { 703 struct rc_dev *rdev = input_get_drvdata(idev); 704 705 return rdev->open(rdev); 706 } 707 708 static void ir_close(struct input_dev *idev) 709 { 710 struct rc_dev *rdev = input_get_drvdata(idev); 711 712 if (rdev) 713 rdev->close(rdev); 714 } 715 716 /* class for /sys/class/rc */ 717 static char *ir_devnode(struct device *dev, mode_t *mode) 718 { 719 return kasprintf(GFP_KERNEL, "rc/%s", dev_name(dev)); 720 } 721 722 static struct class ir_input_class = { 723 .name = "rc", 724 .devnode = ir_devnode, 725 }; 726 727 static struct { 728 u64 type; 729 char *name; 730 } proto_names[] = { 731 { RC_TYPE_UNKNOWN, "unknown" }, 732 { RC_TYPE_RC5, "rc-5" }, 733 { RC_TYPE_NEC, "nec" }, 734 { RC_TYPE_RC6, "rc-6" }, 735 { RC_TYPE_JVC, "jvc" }, 736 { RC_TYPE_SONY, "sony" }, 737 { RC_TYPE_RC5_SZ, "rc-5-sz" }, 738 { RC_TYPE_MCE_KBD, "mce_kbd" }, 739 { RC_TYPE_LIRC, "lirc" }, 740 { RC_TYPE_OTHER, "other" }, 741 }; 742 743 #define PROTO_NONE "none" 744 745 /** 746 * show_protocols() - shows the current IR protocol(s) 747 * @device: the device descriptor 748 * @mattr: the device attribute struct (unused) 749 * @buf: a pointer to the output buffer 750 * 751 * This routine is a callback routine for input read the IR protocol type(s). 752 * it is trigged by reading /sys/class/rc/rc?/protocols. 753 * It returns the protocol names of supported protocols. 754 * Enabled protocols are printed in brackets. 755 * 756 * dev->lock is taken to guard against races between device 757 * registration, store_protocols and show_protocols. 758 */ 759 static ssize_t show_protocols(struct device *device, 760 struct device_attribute *mattr, char *buf) 761 { 762 struct rc_dev *dev = to_rc_dev(device); 763 u64 allowed, enabled; 764 char *tmp = buf; 765 int i; 766 767 /* Device is being removed */ 768 if (!dev) 769 return -EINVAL; 770 771 mutex_lock(&dev->lock); 772 773 if (dev->driver_type == RC_DRIVER_SCANCODE) { 774 enabled = dev->rc_map.rc_type; 775 allowed = dev->allowed_protos; 776 } else { 777 enabled = dev->raw->enabled_protocols; 778 allowed = ir_raw_get_allowed_protocols(); 779 } 780 781 IR_dprintk(1, "allowed - 0x%llx, enabled - 0x%llx\n", 782 (long long)allowed, 783 (long long)enabled); 784 785 for (i = 0; i < ARRAY_SIZE(proto_names); i++) { 786 if (allowed & enabled & proto_names[i].type) 787 tmp += sprintf(tmp, "[%s] ", proto_names[i].name); 788 else if (allowed & proto_names[i].type) 789 tmp += sprintf(tmp, "%s ", proto_names[i].name); 790 } 791 792 if (tmp != buf) 793 tmp--; 794 *tmp = '\n'; 795 796 mutex_unlock(&dev->lock); 797 798 return tmp + 1 - buf; 799 } 800 801 /** 802 * store_protocols() - changes the current IR protocol(s) 803 * @device: the device descriptor 804 * @mattr: the device attribute struct (unused) 805 * @buf: a pointer to the input buffer 806 * @len: length of the input buffer 807 * 808 * This routine is for changing the IR protocol type. 809 * It is trigged by writing to /sys/class/rc/rc?/protocols. 810 * Writing "+proto" will add a protocol to the list of enabled protocols. 811 * Writing "-proto" will remove a protocol from the list of enabled protocols. 812 * Writing "proto" will enable only "proto". 813 * Writing "none" will disable all protocols. 814 * Returns -EINVAL if an invalid protocol combination or unknown protocol name 815 * is used, otherwise @len. 816 * 817 * dev->lock is taken to guard against races between device 818 * registration, store_protocols and show_protocols. 819 */ 820 static ssize_t store_protocols(struct device *device, 821 struct device_attribute *mattr, 822 const char *data, 823 size_t len) 824 { 825 struct rc_dev *dev = to_rc_dev(device); 826 bool enable, disable; 827 const char *tmp; 828 u64 type; 829 u64 mask; 830 int rc, i, count = 0; 831 unsigned long flags; 832 ssize_t ret; 833 834 /* Device is being removed */ 835 if (!dev) 836 return -EINVAL; 837 838 mutex_lock(&dev->lock); 839 840 if (dev->driver_type == RC_DRIVER_SCANCODE) 841 type = dev->rc_map.rc_type; 842 else if (dev->raw) 843 type = dev->raw->enabled_protocols; 844 else { 845 IR_dprintk(1, "Protocol switching not supported\n"); 846 ret = -EINVAL; 847 goto out; 848 } 849 850 while ((tmp = strsep((char **) &data, " \n")) != NULL) { 851 if (!*tmp) 852 break; 853 854 if (*tmp == '+') { 855 enable = true; 856 disable = false; 857 tmp++; 858 } else if (*tmp == '-') { 859 enable = false; 860 disable = true; 861 tmp++; 862 } else { 863 enable = false; 864 disable = false; 865 } 866 867 if (!enable && !disable && !strncasecmp(tmp, PROTO_NONE, sizeof(PROTO_NONE))) { 868 tmp += sizeof(PROTO_NONE); 869 mask = 0; 870 count++; 871 } else { 872 for (i = 0; i < ARRAY_SIZE(proto_names); i++) { 873 if (!strcasecmp(tmp, proto_names[i].name)) { 874 tmp += strlen(proto_names[i].name); 875 mask = proto_names[i].type; 876 break; 877 } 878 } 879 if (i == ARRAY_SIZE(proto_names)) { 880 IR_dprintk(1, "Unknown protocol: '%s'\n", tmp); 881 ret = -EINVAL; 882 goto out; 883 } 884 count++; 885 } 886 887 if (enable) 888 type |= mask; 889 else if (disable) 890 type &= ~mask; 891 else 892 type = mask; 893 } 894 895 if (!count) { 896 IR_dprintk(1, "Protocol not specified\n"); 897 ret = -EINVAL; 898 goto out; 899 } 900 901 if (dev->change_protocol) { 902 rc = dev->change_protocol(dev, type); 903 if (rc < 0) { 904 IR_dprintk(1, "Error setting protocols to 0x%llx\n", 905 (long long)type); 906 ret = -EINVAL; 907 goto out; 908 } 909 } 910 911 if (dev->driver_type == RC_DRIVER_SCANCODE) { 912 spin_lock_irqsave(&dev->rc_map.lock, flags); 913 dev->rc_map.rc_type = type; 914 spin_unlock_irqrestore(&dev->rc_map.lock, flags); 915 } else { 916 dev->raw->enabled_protocols = type; 917 } 918 919 IR_dprintk(1, "Current protocol(s): 0x%llx\n", 920 (long long)type); 921 922 ret = len; 923 924 out: 925 mutex_unlock(&dev->lock); 926 return ret; 927 } 928 929 static void rc_dev_release(struct device *device) 930 { 931 struct rc_dev *dev = to_rc_dev(device); 932 933 kfree(dev); 934 module_put(THIS_MODULE); 935 } 936 937 #define ADD_HOTPLUG_VAR(fmt, val...) \ 938 do { \ 939 int err = add_uevent_var(env, fmt, val); \ 940 if (err) \ 941 return err; \ 942 } while (0) 943 944 static int rc_dev_uevent(struct device *device, struct kobj_uevent_env *env) 945 { 946 struct rc_dev *dev = to_rc_dev(device); 947 948 if (dev->rc_map.name) 949 ADD_HOTPLUG_VAR("NAME=%s", dev->rc_map.name); 950 if (dev->driver_name) 951 ADD_HOTPLUG_VAR("DRV_NAME=%s", dev->driver_name); 952 953 return 0; 954 } 955 956 /* 957 * Static device attribute struct with the sysfs attributes for IR's 958 */ 959 static DEVICE_ATTR(protocols, S_IRUGO | S_IWUSR, 960 show_protocols, store_protocols); 961 962 static struct attribute *rc_dev_attrs[] = { 963 &dev_attr_protocols.attr, 964 NULL, 965 }; 966 967 static struct attribute_group rc_dev_attr_grp = { 968 .attrs = rc_dev_attrs, 969 }; 970 971 static const struct attribute_group *rc_dev_attr_groups[] = { 972 &rc_dev_attr_grp, 973 NULL 974 }; 975 976 static struct device_type rc_dev_type = { 977 .groups = rc_dev_attr_groups, 978 .release = rc_dev_release, 979 .uevent = rc_dev_uevent, 980 }; 981 982 struct rc_dev *rc_allocate_device(void) 983 { 984 struct rc_dev *dev; 985 986 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 987 if (!dev) 988 return NULL; 989 990 dev->input_dev = input_allocate_device(); 991 if (!dev->input_dev) { 992 kfree(dev); 993 return NULL; 994 } 995 996 dev->input_dev->getkeycode = ir_getkeycode; 997 dev->input_dev->setkeycode = ir_setkeycode; 998 input_set_drvdata(dev->input_dev, dev); 999 1000 spin_lock_init(&dev->rc_map.lock); 1001 spin_lock_init(&dev->keylock); 1002 mutex_init(&dev->lock); 1003 setup_timer(&dev->timer_keyup, ir_timer_keyup, (unsigned long)dev); 1004 1005 dev->dev.type = &rc_dev_type; 1006 dev->dev.class = &ir_input_class; 1007 device_initialize(&dev->dev); 1008 1009 __module_get(THIS_MODULE); 1010 return dev; 1011 } 1012 EXPORT_SYMBOL_GPL(rc_allocate_device); 1013 1014 void rc_free_device(struct rc_dev *dev) 1015 { 1016 if (dev) { 1017 input_free_device(dev->input_dev); 1018 put_device(&dev->dev); 1019 } 1020 } 1021 EXPORT_SYMBOL_GPL(rc_free_device); 1022 1023 int rc_register_device(struct rc_dev *dev) 1024 { 1025 static atomic_t devno = ATOMIC_INIT(0); 1026 struct rc_map *rc_map; 1027 const char *path; 1028 int rc; 1029 1030 if (!dev || !dev->map_name) 1031 return -EINVAL; 1032 1033 rc_map = rc_map_get(dev->map_name); 1034 if (!rc_map) 1035 rc_map = rc_map_get(RC_MAP_EMPTY); 1036 if (!rc_map || !rc_map->scan || rc_map->size == 0) 1037 return -EINVAL; 1038 1039 set_bit(EV_KEY, dev->input_dev->evbit); 1040 set_bit(EV_REP, dev->input_dev->evbit); 1041 set_bit(EV_MSC, dev->input_dev->evbit); 1042 set_bit(MSC_SCAN, dev->input_dev->mscbit); 1043 if (dev->open) 1044 dev->input_dev->open = ir_open; 1045 if (dev->close) 1046 dev->input_dev->close = ir_close; 1047 1048 /* 1049 * Take the lock here, as the device sysfs node will appear 1050 * when device_add() is called, which may trigger an ir-keytable udev 1051 * rule, which will in turn call show_protocols and access either 1052 * dev->rc_map.rc_type or dev->raw->enabled_protocols before it has 1053 * been initialized. 1054 */ 1055 mutex_lock(&dev->lock); 1056 1057 dev->devno = (unsigned long)(atomic_inc_return(&devno) - 1); 1058 dev_set_name(&dev->dev, "rc%ld", dev->devno); 1059 dev_set_drvdata(&dev->dev, dev); 1060 rc = device_add(&dev->dev); 1061 if (rc) 1062 goto out_unlock; 1063 1064 rc = ir_setkeytable(dev, rc_map); 1065 if (rc) 1066 goto out_dev; 1067 1068 dev->input_dev->dev.parent = &dev->dev; 1069 memcpy(&dev->input_dev->id, &dev->input_id, sizeof(dev->input_id)); 1070 dev->input_dev->phys = dev->input_phys; 1071 dev->input_dev->name = dev->input_name; 1072 rc = input_register_device(dev->input_dev); 1073 if (rc) 1074 goto out_table; 1075 1076 /* 1077 * Default delay of 250ms is too short for some protocols, especially 1078 * since the timeout is currently set to 250ms. Increase it to 500ms, 1079 * to avoid wrong repetition of the keycodes. Note that this must be 1080 * set after the call to input_register_device(). 1081 */ 1082 dev->input_dev->rep[REP_DELAY] = 500; 1083 1084 /* 1085 * As a repeat event on protocols like RC-5 and NEC take as long as 1086 * 110/114ms, using 33ms as a repeat period is not the right thing 1087 * to do. 1088 */ 1089 dev->input_dev->rep[REP_PERIOD] = 125; 1090 1091 path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL); 1092 printk(KERN_INFO "%s: %s as %s\n", 1093 dev_name(&dev->dev), 1094 dev->input_name ? dev->input_name : "Unspecified device", 1095 path ? path : "N/A"); 1096 kfree(path); 1097 1098 if (dev->driver_type == RC_DRIVER_IR_RAW) { 1099 rc = ir_raw_event_register(dev); 1100 if (rc < 0) 1101 goto out_input; 1102 } 1103 1104 if (dev->change_protocol) { 1105 rc = dev->change_protocol(dev, rc_map->rc_type); 1106 if (rc < 0) 1107 goto out_raw; 1108 } 1109 1110 mutex_unlock(&dev->lock); 1111 1112 IR_dprintk(1, "Registered rc%ld (driver: %s, remote: %s, mode %s)\n", 1113 dev->devno, 1114 dev->driver_name ? dev->driver_name : "unknown", 1115 rc_map->name ? rc_map->name : "unknown", 1116 dev->driver_type == RC_DRIVER_IR_RAW ? "raw" : "cooked"); 1117 1118 return 0; 1119 1120 out_raw: 1121 if (dev->driver_type == RC_DRIVER_IR_RAW) 1122 ir_raw_event_unregister(dev); 1123 out_input: 1124 input_unregister_device(dev->input_dev); 1125 dev->input_dev = NULL; 1126 out_table: 1127 ir_free_table(&dev->rc_map); 1128 out_dev: 1129 device_del(&dev->dev); 1130 out_unlock: 1131 mutex_unlock(&dev->lock); 1132 return rc; 1133 } 1134 EXPORT_SYMBOL_GPL(rc_register_device); 1135 1136 void rc_unregister_device(struct rc_dev *dev) 1137 { 1138 if (!dev) 1139 return; 1140 1141 del_timer_sync(&dev->timer_keyup); 1142 1143 if (dev->driver_type == RC_DRIVER_IR_RAW) 1144 ir_raw_event_unregister(dev); 1145 1146 input_unregister_device(dev->input_dev); 1147 dev->input_dev = NULL; 1148 1149 ir_free_table(&dev->rc_map); 1150 IR_dprintk(1, "Freed keycode table\n"); 1151 1152 device_unregister(&dev->dev); 1153 } 1154 EXPORT_SYMBOL_GPL(rc_unregister_device); 1155 1156 /* 1157 * Init/exit code for the module. Basically, creates/removes /sys/class/rc 1158 */ 1159 1160 static int __init rc_core_init(void) 1161 { 1162 int rc = class_register(&ir_input_class); 1163 if (rc) { 1164 printk(KERN_ERR "rc_core: unable to register rc class\n"); 1165 return rc; 1166 } 1167 1168 /* Initialize/load the decoders/keymap code that will be used */ 1169 ir_raw_init(); 1170 rc_map_register(&empty_map); 1171 1172 return 0; 1173 } 1174 1175 static void __exit rc_core_exit(void) 1176 { 1177 class_unregister(&ir_input_class); 1178 rc_map_unregister(&empty_map); 1179 } 1180 1181 module_init(rc_core_init); 1182 module_exit(rc_core_exit); 1183 1184 int rc_core_debug; /* ir_debug level (0,1,2) */ 1185 EXPORT_SYMBOL_GPL(rc_core_debug); 1186 module_param_named(debug, rc_core_debug, int, 0644); 1187 1188 MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@redhat.com>"); 1189 MODULE_LICENSE("GPL"); 1190