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