drivers/media/rc/rc-main.c

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