drivers/media/rc/rc-main.c

   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 = 250 },
  42         [RC_PROTO_RC5X_20] = { .name = "rc-5x-20",
  43                 .scancode_bits = 0x1f7f3f, .repeat_period = 250 },
  44         [RC_PROTO_RC5_SZ] = { .name = "rc-5-sz",
  45                 .scancode_bits = 0x2fff, .repeat_period = 250 },
  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 = 250 },
  50         [RC_PROTO_SONY15] = { .name = "sony-15",
  51                 .scancode_bits = 0xff007f, .repeat_period = 250 },
  52         [RC_PROTO_SONY20] = { .name = "sony-20",
  53                 .scancode_bits = 0x1fff7f, .repeat_period = 250 },
  54         [RC_PROTO_NEC] = { .name = "nec",
  55                 .scancode_bits = 0xffff, .repeat_period = 250 },
  56         [RC_PROTO_NECX] = { .name = "nec-x",
  57                 .scancode_bits = 0xffffff, .repeat_period = 250 },
  58         [RC_PROTO_NEC32] = { .name = "nec-32",
  59                 .scancode_bits = 0xffffffff, .repeat_period = 250 },
  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 = 250 },
  64         [RC_PROTO_MCIR2_MSE] = { .name = "mcir2-mse",
  65                 .scancode_bits = 0x1fffff, .repeat_period = 250 },
  66         [RC_PROTO_RC6_0] = { .name = "rc-6-0",
  67                 .scancode_bits = 0xffff, .repeat_period = 250 },
  68         [RC_PROTO_RC6_6A_20] = { .name = "rc-6-6a-20",
  69                 .scancode_bits = 0xfffff, .repeat_period = 250 },
  70         [RC_PROTO_RC6_6A_24] = { .name = "rc-6-6a-24",
  71                 .scancode_bits = 0xffffff, .repeat_period = 250 },
  72         [RC_PROTO_RC6_6A_32] = { .name = "rc-6-6a-32",
  73                 .scancode_bits = 0xffffffff, .repeat_period = 250 },
  74         [RC_PROTO_RC6_MCE] = { .name = "rc-6-mce",
  75                 .scancode_bits = 0xffff7fff, .repeat_period = 250 },
  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         if (dev->driver_type == RC_DRIVER_IR_RAW)
1828                 ir_raw_event_unregister(dev);
1829
1830         del_timer_sync(&dev->timer_keyup);
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");