1 /* rc-main.c - Remote Controller core module
3 * Copyright (C) 2009-2010 by Mauro Carvalho Chehab
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation version 2 of the License.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
15 #include <media/rc-core.h>
16 #include <linux/spinlock.h>
17 #include <linux/delay.h>
18 #include <linux/input.h>
19 #include <linux/leds.h>
20 #include <linux/slab.h>
21 #include <linux/device.h>
22 #include <linux/module.h>
23 #include "rc-core-priv.h"
25 /* Bitmap to store allocated device numbers from 0 to IRRCV_NUM_DEVICES - 1 */
26 #define IRRCV_NUM_DEVICES 256
27 static DECLARE_BITMAP(ir_core_dev_number, IRRCV_NUM_DEVICES);
29 /* Sizes are in bytes, 256 bytes allows for 32 entries on x64 */
30 #define IR_TAB_MIN_SIZE 256
31 #define IR_TAB_MAX_SIZE 8192
33 /* FIXME: IR_KEYPRESS_TIMEOUT should be protocol specific */
34 #define IR_KEYPRESS_TIMEOUT 250
36 /* Used to keep track of known keymaps */
37 static LIST_HEAD(rc_map_list);
38 static DEFINE_SPINLOCK(rc_map_lock);
39 static struct led_trigger *led_feedback;
41 static struct rc_map_list *seek_rc_map(const char *name)
43 struct rc_map_list *map = NULL;
45 spin_lock(&rc_map_lock);
46 list_for_each_entry(map, &rc_map_list, list) {
47 if (!strcmp(name, map->map.name)) {
48 spin_unlock(&rc_map_lock);
52 spin_unlock(&rc_map_lock);
57 struct rc_map *rc_map_get(const char *name)
60 struct rc_map_list *map;
62 map = seek_rc_map(name);
65 int rc = request_module("%s", name);
67 printk(KERN_ERR "Couldn't load IR keymap %s\n", name);
70 msleep(20); /* Give some time for IR to register */
72 map = seek_rc_map(name);
76 printk(KERN_ERR "IR keymap %s not found\n", name);
80 printk(KERN_INFO "Registered IR keymap %s\n", map->map.name);
84 EXPORT_SYMBOL_GPL(rc_map_get);
86 int rc_map_register(struct rc_map_list *map)
88 spin_lock(&rc_map_lock);
89 list_add_tail(&map->list, &rc_map_list);
90 spin_unlock(&rc_map_lock);
93 EXPORT_SYMBOL_GPL(rc_map_register);
95 void rc_map_unregister(struct rc_map_list *map)
97 spin_lock(&rc_map_lock);
99 spin_unlock(&rc_map_lock);
101 EXPORT_SYMBOL_GPL(rc_map_unregister);
104 static struct rc_map_table empty[] = {
105 { 0x2a, KEY_COFFEE },
108 static struct rc_map_list empty_map = {
111 .size = ARRAY_SIZE(empty),
112 .rc_type = RC_TYPE_UNKNOWN, /* Legacy IR type */
113 .name = RC_MAP_EMPTY,
118 * ir_create_table() - initializes a scancode table
119 * @rc_map: the rc_map to initialize
120 * @name: name to assign to the table
121 * @rc_type: ir type to assign to the new table
122 * @size: initial size of the table
123 * @return: zero on success or a negative error code
125 * This routine will initialize the rc_map and will allocate
126 * memory to hold at least the specified number of elements.
128 static int ir_create_table(struct rc_map *rc_map,
129 const char *name, u64 rc_type, size_t size)
132 rc_map->rc_type = rc_type;
133 rc_map->alloc = roundup_pow_of_two(size * sizeof(struct rc_map_table));
134 rc_map->size = rc_map->alloc / sizeof(struct rc_map_table);
135 rc_map->scan = kmalloc(rc_map->alloc, GFP_KERNEL);
139 IR_dprintk(1, "Allocated space for %u keycode entries (%u bytes)\n",
140 rc_map->size, rc_map->alloc);
145 * ir_free_table() - frees memory allocated by a scancode table
146 * @rc_map: the table whose mappings need to be freed
148 * This routine will free memory alloctaed for key mappings used by given
151 static void ir_free_table(struct rc_map *rc_map)
159 * ir_resize_table() - resizes a scancode table if necessary
160 * @rc_map: the rc_map to resize
161 * @gfp_flags: gfp flags to use when allocating memory
162 * @return: zero on success or a negative error code
164 * This routine will shrink the rc_map if it has lots of
165 * unused entries and grow it if it is full.
167 static int ir_resize_table(struct rc_map *rc_map, gfp_t gfp_flags)
169 unsigned int oldalloc = rc_map->alloc;
170 unsigned int newalloc = oldalloc;
171 struct rc_map_table *oldscan = rc_map->scan;
172 struct rc_map_table *newscan;
174 if (rc_map->size == rc_map->len) {
175 /* All entries in use -> grow keytable */
176 if (rc_map->alloc >= IR_TAB_MAX_SIZE)
180 IR_dprintk(1, "Growing table to %u bytes\n", newalloc);
183 if ((rc_map->len * 3 < rc_map->size) && (oldalloc > IR_TAB_MIN_SIZE)) {
184 /* Less than 1/3 of entries in use -> shrink keytable */
186 IR_dprintk(1, "Shrinking table to %u bytes\n", newalloc);
189 if (newalloc == oldalloc)
192 newscan = kmalloc(newalloc, gfp_flags);
194 IR_dprintk(1, "Failed to kmalloc %u bytes\n", newalloc);
198 memcpy(newscan, rc_map->scan, rc_map->len * sizeof(struct rc_map_table));
199 rc_map->scan = newscan;
200 rc_map->alloc = newalloc;
201 rc_map->size = rc_map->alloc / sizeof(struct rc_map_table);
207 * ir_update_mapping() - set a keycode in the scancode->keycode table
208 * @dev: the struct rc_dev device descriptor
209 * @rc_map: scancode table to be adjusted
210 * @index: index of the mapping that needs to be updated
211 * @keycode: the desired keycode
212 * @return: previous keycode assigned to the mapping
214 * This routine is used to update scancode->keycode mapping at given
217 static unsigned int ir_update_mapping(struct rc_dev *dev,
218 struct rc_map *rc_map,
220 unsigned int new_keycode)
222 int old_keycode = rc_map->scan[index].keycode;
225 /* Did the user wish to remove the mapping? */
226 if (new_keycode == KEY_RESERVED || new_keycode == KEY_UNKNOWN) {
227 IR_dprintk(1, "#%d: Deleting scan 0x%04x\n",
228 index, rc_map->scan[index].scancode);
230 memmove(&rc_map->scan[index], &rc_map->scan[index+ 1],
231 (rc_map->len - index) * sizeof(struct rc_map_table));
233 IR_dprintk(1, "#%d: %s scan 0x%04x with key 0x%04x\n",
235 old_keycode == KEY_RESERVED ? "New" : "Replacing",
236 rc_map->scan[index].scancode, new_keycode);
237 rc_map->scan[index].keycode = new_keycode;
238 __set_bit(new_keycode, dev->input_dev->keybit);
241 if (old_keycode != KEY_RESERVED) {
242 /* A previous mapping was updated... */
243 __clear_bit(old_keycode, dev->input_dev->keybit);
244 /* ... but another scancode might use the same keycode */
245 for (i = 0; i < rc_map->len; i++) {
246 if (rc_map->scan[i].keycode == old_keycode) {
247 __set_bit(old_keycode, dev->input_dev->keybit);
252 /* Possibly shrink the keytable, failure is not a problem */
253 ir_resize_table(rc_map, GFP_ATOMIC);
260 * ir_establish_scancode() - set a keycode in the scancode->keycode table
261 * @dev: the struct rc_dev device descriptor
262 * @rc_map: scancode table to be searched
263 * @scancode: the desired scancode
264 * @resize: controls whether we allowed to resize the table to
265 * accommodate not yet present scancodes
266 * @return: index of the mapping containing scancode in question
267 * or -1U in case of failure.
269 * This routine is used to locate given scancode in rc_map.
270 * If scancode is not yet present the routine will allocate a new slot
273 static unsigned int ir_establish_scancode(struct rc_dev *dev,
274 struct rc_map *rc_map,
275 unsigned int scancode,
281 * Unfortunately, some hardware-based IR decoders don't provide
282 * all bits for the complete IR code. In general, they provide only
283 * the command part of the IR code. Yet, as it is possible to replace
284 * the provided IR with another one, it is needed to allow loading
285 * IR tables from other remotes. So, we support specifying a mask to
286 * indicate the valid bits of the scancodes.
288 if (dev->scancode_mask)
289 scancode &= dev->scancode_mask;
291 /* First check if we already have a mapping for this ir command */
292 for (i = 0; i < rc_map->len; i++) {
293 if (rc_map->scan[i].scancode == scancode)
296 /* Keytable is sorted from lowest to highest scancode */
297 if (rc_map->scan[i].scancode >= scancode)
301 /* No previous mapping found, we might need to grow the table */
302 if (rc_map->size == rc_map->len) {
303 if (!resize || ir_resize_table(rc_map, GFP_ATOMIC))
307 /* i is the proper index to insert our new keycode */
309 memmove(&rc_map->scan[i + 1], &rc_map->scan[i],
310 (rc_map->len - i) * sizeof(struct rc_map_table));
311 rc_map->scan[i].scancode = scancode;
312 rc_map->scan[i].keycode = KEY_RESERVED;
319 * ir_setkeycode() - set a keycode in the scancode->keycode table
320 * @idev: the struct input_dev device descriptor
321 * @scancode: the desired scancode
323 * @return: -EINVAL if the keycode could not be inserted, otherwise zero.
325 * This routine is used to handle evdev EVIOCSKEY ioctl.
327 static int ir_setkeycode(struct input_dev *idev,
328 const struct input_keymap_entry *ke,
329 unsigned int *old_keycode)
331 struct rc_dev *rdev = input_get_drvdata(idev);
332 struct rc_map *rc_map = &rdev->rc_map;
334 unsigned int scancode;
338 spin_lock_irqsave(&rc_map->lock, flags);
340 if (ke->flags & INPUT_KEYMAP_BY_INDEX) {
342 if (index >= rc_map->len) {
347 retval = input_scancode_to_scalar(ke, &scancode);
351 index = ir_establish_scancode(rdev, rc_map, scancode, true);
352 if (index >= rc_map->len) {
358 *old_keycode = ir_update_mapping(rdev, rc_map, index, ke->keycode);
361 spin_unlock_irqrestore(&rc_map->lock, flags);
366 * ir_setkeytable() - sets several entries in the scancode->keycode table
367 * @dev: the struct rc_dev device descriptor
368 * @to: the struct rc_map to copy entries to
369 * @from: the struct rc_map to copy entries from
370 * @return: -ENOMEM if all keycodes could not be inserted, otherwise zero.
372 * This routine is used to handle table initialization.
374 static int ir_setkeytable(struct rc_dev *dev,
375 const struct rc_map *from)
377 struct rc_map *rc_map = &dev->rc_map;
378 unsigned int i, index;
381 rc = ir_create_table(rc_map, from->name,
382 from->rc_type, from->size);
386 IR_dprintk(1, "Allocated space for %u keycode entries (%u bytes)\n",
387 rc_map->size, rc_map->alloc);
389 for (i = 0; i < from->size; i++) {
390 index = ir_establish_scancode(dev, rc_map,
391 from->scan[i].scancode, false);
392 if (index >= rc_map->len) {
397 ir_update_mapping(dev, rc_map, index,
398 from->scan[i].keycode);
402 ir_free_table(rc_map);
408 * ir_lookup_by_scancode() - locate mapping by scancode
409 * @rc_map: the struct rc_map to search
410 * @scancode: scancode to look for in the table
411 * @return: index in the table, -1U if not found
413 * This routine performs binary search in RC keykeymap table for
416 static unsigned int ir_lookup_by_scancode(const struct rc_map *rc_map,
417 unsigned int scancode)
420 int end = rc_map->len - 1;
423 while (start <= end) {
424 mid = (start + end) / 2;
425 if (rc_map->scan[mid].scancode < scancode)
427 else if (rc_map->scan[mid].scancode > scancode)
437 * ir_getkeycode() - get a keycode from the scancode->keycode table
438 * @idev: the struct input_dev device descriptor
439 * @scancode: the desired scancode
440 * @keycode: used to return the keycode, if found, or KEY_RESERVED
441 * @return: always returns zero.
443 * This routine is used to handle evdev EVIOCGKEY ioctl.
445 static int ir_getkeycode(struct input_dev *idev,
446 struct input_keymap_entry *ke)
448 struct rc_dev *rdev = input_get_drvdata(idev);
449 struct rc_map *rc_map = &rdev->rc_map;
450 struct rc_map_table *entry;
453 unsigned int scancode;
456 spin_lock_irqsave(&rc_map->lock, flags);
458 if (ke->flags & INPUT_KEYMAP_BY_INDEX) {
461 retval = input_scancode_to_scalar(ke, &scancode);
465 index = ir_lookup_by_scancode(rc_map, scancode);
468 if (index < rc_map->len) {
469 entry = &rc_map->scan[index];
472 ke->keycode = entry->keycode;
473 ke->len = sizeof(entry->scancode);
474 memcpy(ke->scancode, &entry->scancode, sizeof(entry->scancode));
476 } else if (!(ke->flags & INPUT_KEYMAP_BY_INDEX)) {
478 * We do not really know the valid range of scancodes
479 * so let's respond with KEY_RESERVED to anything we
480 * do not have mapping for [yet].
483 ke->keycode = KEY_RESERVED;
492 spin_unlock_irqrestore(&rc_map->lock, flags);
497 * rc_g_keycode_from_table() - gets the keycode that corresponds to a scancode
498 * @dev: the struct rc_dev descriptor of the device
499 * @scancode: the scancode to look for
500 * @return: the corresponding keycode, or KEY_RESERVED
502 * This routine is used by drivers which need to convert a scancode to a
503 * keycode. Normally it should not be used since drivers should have no
504 * interest in keycodes.
506 u32 rc_g_keycode_from_table(struct rc_dev *dev, u32 scancode)
508 struct rc_map *rc_map = &dev->rc_map;
509 unsigned int keycode;
513 spin_lock_irqsave(&rc_map->lock, flags);
515 index = ir_lookup_by_scancode(rc_map, scancode);
516 keycode = index < rc_map->len ?
517 rc_map->scan[index].keycode : KEY_RESERVED;
519 spin_unlock_irqrestore(&rc_map->lock, flags);
521 if (keycode != KEY_RESERVED)
522 IR_dprintk(1, "%s: scancode 0x%04x keycode 0x%02x\n",
523 dev->input_name, scancode, keycode);
527 EXPORT_SYMBOL_GPL(rc_g_keycode_from_table);
530 * ir_do_keyup() - internal function to signal the release of a keypress
531 * @dev: the struct rc_dev descriptor of the device
532 * @sync: whether or not to call input_sync
534 * This function is used internally to release a keypress, it must be
535 * called with keylock held.
537 static void ir_do_keyup(struct rc_dev *dev, bool sync)
539 if (!dev->keypressed)
542 IR_dprintk(1, "keyup key 0x%04x\n", dev->last_keycode);
543 input_report_key(dev->input_dev, dev->last_keycode, 0);
544 led_trigger_event(led_feedback, LED_OFF);
546 input_sync(dev->input_dev);
547 dev->keypressed = false;
551 * rc_keyup() - signals the release of a keypress
552 * @dev: the struct rc_dev descriptor of the device
554 * This routine is used to signal that a key has been released on the
557 void rc_keyup(struct rc_dev *dev)
561 spin_lock_irqsave(&dev->keylock, flags);
562 ir_do_keyup(dev, true);
563 spin_unlock_irqrestore(&dev->keylock, flags);
565 EXPORT_SYMBOL_GPL(rc_keyup);
568 * ir_timer_keyup() - generates a keyup event after a timeout
569 * @cookie: a pointer to the struct rc_dev for the device
571 * This routine will generate a keyup event some time after a keydown event
572 * is generated when no further activity has been detected.
574 static void ir_timer_keyup(unsigned long cookie)
576 struct rc_dev *dev = (struct rc_dev *)cookie;
580 * ir->keyup_jiffies is used to prevent a race condition if a
581 * hardware interrupt occurs at this point and the keyup timer
582 * event is moved further into the future as a result.
584 * The timer will then be reactivated and this function called
585 * again in the future. We need to exit gracefully in that case
586 * to allow the input subsystem to do its auto-repeat magic or
587 * a keyup event might follow immediately after the keydown.
589 spin_lock_irqsave(&dev->keylock, flags);
590 if (time_is_before_eq_jiffies(dev->keyup_jiffies))
591 ir_do_keyup(dev, true);
592 spin_unlock_irqrestore(&dev->keylock, flags);
596 * rc_repeat() - signals that a key is still pressed
597 * @dev: the struct rc_dev descriptor of the device
599 * This routine is used by IR decoders when a repeat message which does
600 * not include the necessary bits to reproduce the scancode has been
603 void rc_repeat(struct rc_dev *dev)
607 spin_lock_irqsave(&dev->keylock, flags);
609 input_event(dev->input_dev, EV_MSC, MSC_SCAN, dev->last_scancode);
610 input_sync(dev->input_dev);
612 if (!dev->keypressed)
615 dev->keyup_jiffies = jiffies + msecs_to_jiffies(IR_KEYPRESS_TIMEOUT);
616 mod_timer(&dev->timer_keyup, dev->keyup_jiffies);
619 spin_unlock_irqrestore(&dev->keylock, flags);
621 EXPORT_SYMBOL_GPL(rc_repeat);
624 * ir_do_keydown() - internal function to process a keypress
625 * @dev: the struct rc_dev descriptor of the device
626 * @protocol: the protocol of the keypress
627 * @scancode: the scancode of the keypress
628 * @keycode: the keycode of the keypress
629 * @toggle: the toggle value of the keypress
631 * This function is used internally to register a keypress, it must be
632 * called with keylock held.
634 static void ir_do_keydown(struct rc_dev *dev, enum rc_type protocol,
635 u32 scancode, u32 keycode, u8 toggle)
637 bool new_event = (!dev->keypressed ||
638 dev->last_protocol != protocol ||
639 dev->last_scancode != scancode ||
640 dev->last_toggle != toggle);
642 if (new_event && dev->keypressed)
643 ir_do_keyup(dev, false);
645 input_event(dev->input_dev, EV_MSC, MSC_SCAN, scancode);
647 if (new_event && keycode != KEY_RESERVED) {
648 /* Register a keypress */
649 dev->keypressed = true;
650 dev->last_protocol = protocol;
651 dev->last_scancode = scancode;
652 dev->last_toggle = toggle;
653 dev->last_keycode = keycode;
655 IR_dprintk(1, "%s: key down event, "
656 "key 0x%04x, protocol 0x%04x, scancode 0x%08x\n",
657 dev->input_name, keycode, protocol, scancode);
658 input_report_key(dev->input_dev, keycode, 1);
660 led_trigger_event(led_feedback, LED_FULL);
663 input_sync(dev->input_dev);
667 * rc_keydown() - generates input event for a key press
668 * @dev: the struct rc_dev descriptor of the device
669 * @protocol: the protocol for the keypress
670 * @scancode: the scancode for the keypress
671 * @toggle: the toggle value (protocol dependent, if the protocol doesn't
672 * support toggle values, this should be set to zero)
674 * This routine is used to signal that a key has been pressed on the
677 void rc_keydown(struct rc_dev *dev, enum rc_type protocol, u32 scancode, u8 toggle)
680 u32 keycode = rc_g_keycode_from_table(dev, scancode);
682 spin_lock_irqsave(&dev->keylock, flags);
683 ir_do_keydown(dev, protocol, scancode, keycode, toggle);
685 if (dev->keypressed) {
686 dev->keyup_jiffies = jiffies + msecs_to_jiffies(IR_KEYPRESS_TIMEOUT);
687 mod_timer(&dev->timer_keyup, dev->keyup_jiffies);
689 spin_unlock_irqrestore(&dev->keylock, flags);
691 EXPORT_SYMBOL_GPL(rc_keydown);
694 * rc_keydown_notimeout() - generates input event for a key press without
695 * an automatic keyup event at a later time
696 * @dev: the struct rc_dev descriptor of the device
697 * @protocol: the protocol for the keypress
698 * @scancode: the scancode for the keypress
699 * @toggle: the toggle value (protocol dependent, if the protocol doesn't
700 * support toggle values, this should be set to zero)
702 * This routine is used to signal that a key has been pressed on the
703 * remote control. The driver must manually call rc_keyup() at a later stage.
705 void rc_keydown_notimeout(struct rc_dev *dev, enum rc_type protocol,
706 u32 scancode, u8 toggle)
709 u32 keycode = rc_g_keycode_from_table(dev, scancode);
711 spin_lock_irqsave(&dev->keylock, flags);
712 ir_do_keydown(dev, protocol, scancode, keycode, toggle);
713 spin_unlock_irqrestore(&dev->keylock, flags);
715 EXPORT_SYMBOL_GPL(rc_keydown_notimeout);
717 int rc_open(struct rc_dev *rdev)
724 mutex_lock(&rdev->lock);
725 if (!rdev->users++ && rdev->open != NULL)
726 rval = rdev->open(rdev);
731 mutex_unlock(&rdev->lock);
735 EXPORT_SYMBOL_GPL(rc_open);
737 static int ir_open(struct input_dev *idev)
739 struct rc_dev *rdev = input_get_drvdata(idev);
741 return rc_open(rdev);
744 void rc_close(struct rc_dev *rdev)
747 mutex_lock(&rdev->lock);
749 if (!--rdev->users && rdev->close != NULL)
752 mutex_unlock(&rdev->lock);
755 EXPORT_SYMBOL_GPL(rc_close);
757 static void ir_close(struct input_dev *idev)
759 struct rc_dev *rdev = input_get_drvdata(idev);
763 /* class for /sys/class/rc */
764 static char *rc_devnode(struct device *dev, umode_t *mode)
766 return kasprintf(GFP_KERNEL, "rc/%s", dev_name(dev));
769 static struct class rc_class = {
771 .devnode = rc_devnode,
775 * These are the protocol textual descriptions that are
776 * used by the sysfs protocols file. Note that the order
777 * of the entries is relevant.
783 { RC_BIT_NONE, "none" },
784 { RC_BIT_OTHER, "other" },
785 { RC_BIT_UNKNOWN, "unknown" },
787 RC_BIT_RC5X, "rc-5" },
788 { RC_BIT_NEC, "nec" },
793 RC_BIT_RC6_MCE, "rc-6" },
794 { RC_BIT_JVC, "jvc" },
797 RC_BIT_SONY20, "sony" },
798 { RC_BIT_RC5_SZ, "rc-5-sz" },
799 { RC_BIT_SANYO, "sanyo" },
800 { RC_BIT_SHARP, "sharp" },
801 { RC_BIT_MCE_KBD, "mce_kbd" },
802 { RC_BIT_LIRC, "lirc" },
803 { RC_BIT_XMP, "xmp" },
807 * struct rc_filter_attribute - Device attribute relating to a filter type.
808 * @attr: Device attribute.
809 * @type: Filter type.
810 * @mask: false for filter value, true for filter mask.
812 struct rc_filter_attribute {
813 struct device_attribute attr;
814 enum rc_filter_type type;
817 #define to_rc_filter_attr(a) container_of(a, struct rc_filter_attribute, attr)
819 #define RC_PROTO_ATTR(_name, _mode, _show, _store, _type) \
820 struct rc_filter_attribute dev_attr_##_name = { \
821 .attr = __ATTR(_name, _mode, _show, _store), \
824 #define RC_FILTER_ATTR(_name, _mode, _show, _store, _type, _mask) \
825 struct rc_filter_attribute dev_attr_##_name = { \
826 .attr = __ATTR(_name, _mode, _show, _store), \
832 * show_protocols() - shows the current/wakeup IR protocol(s)
833 * @device: the device descriptor
834 * @mattr: the device attribute struct
835 * @buf: a pointer to the output buffer
837 * This routine is a callback routine for input read the IR protocol type(s).
838 * it is trigged by reading /sys/class/rc/rc?/[wakeup_]protocols.
839 * It returns the protocol names of supported protocols.
840 * Enabled protocols are printed in brackets.
842 * dev->lock is taken to guard against races between device
843 * registration, store_protocols and show_protocols.
845 static ssize_t show_protocols(struct device *device,
846 struct device_attribute *mattr, char *buf)
848 struct rc_dev *dev = to_rc_dev(device);
849 struct rc_filter_attribute *fattr = to_rc_filter_attr(mattr);
850 u64 allowed, enabled;
854 /* Device is being removed */
858 mutex_lock(&dev->lock);
860 if (fattr->type == RC_FILTER_NORMAL) {
861 enabled = dev->enabled_protocols;
862 allowed = dev->allowed_protocols;
863 if (dev->raw && !allowed)
864 allowed = ir_raw_get_allowed_protocols();
866 enabled = dev->enabled_wakeup_protocols;
867 allowed = dev->allowed_wakeup_protocols;
868 if (dev->encode_wakeup && !allowed)
869 allowed = ir_raw_get_encode_protocols();
872 mutex_unlock(&dev->lock);
874 IR_dprintk(1, "%s: allowed - 0x%llx, enabled - 0x%llx\n",
875 __func__, (long long)allowed, (long long)enabled);
877 for (i = 0; i < ARRAY_SIZE(proto_names); i++) {
878 if (allowed & enabled & proto_names[i].type)
879 tmp += sprintf(tmp, "[%s] ", proto_names[i].name);
880 else if (allowed & proto_names[i].type)
881 tmp += sprintf(tmp, "%s ", proto_names[i].name);
883 if (allowed & proto_names[i].type)
884 allowed &= ~proto_names[i].type;
891 return tmp + 1 - buf;
895 * parse_protocol_change() - parses a protocol change request
896 * @protocols: pointer to the bitmask of current protocols
897 * @buf: pointer to the buffer with a list of changes
899 * Writing "+proto" will add a protocol to the protocol mask.
900 * Writing "-proto" will remove a protocol from protocol mask.
901 * Writing "proto" will enable only "proto".
902 * Writing "none" will disable all protocols.
903 * Returns the number of changes performed or a negative error code.
905 static int parse_protocol_change(u64 *protocols, const char *buf)
909 bool enable, disable;
913 while ((tmp = strsep((char **)&buf, " \n")) != NULL) {
921 } else if (*tmp == '-') {
930 for (i = 0; i < ARRAY_SIZE(proto_names); i++) {
931 if (!strcasecmp(tmp, proto_names[i].name)) {
932 mask = proto_names[i].type;
937 if (i == ARRAY_SIZE(proto_names)) {
938 IR_dprintk(1, "Unknown protocol: '%s'\n", tmp);
953 IR_dprintk(1, "Protocol not specified\n");
961 * store_protocols() - changes the current/wakeup IR protocol(s)
962 * @device: the device descriptor
963 * @mattr: the device attribute struct
964 * @buf: a pointer to the input buffer
965 * @len: length of the input buffer
967 * This routine is for changing the IR protocol type.
968 * It is trigged by writing to /sys/class/rc/rc?/[wakeup_]protocols.
969 * See parse_protocol_change() for the valid commands.
970 * Returns @len on success or a negative error code.
972 * dev->lock is taken to guard against races between device
973 * registration, store_protocols and show_protocols.
975 static ssize_t store_protocols(struct device *device,
976 struct device_attribute *mattr,
977 const char *buf, size_t len)
979 struct rc_dev *dev = to_rc_dev(device);
980 struct rc_filter_attribute *fattr = to_rc_filter_attr(mattr);
981 u64 *current_protocols;
982 int (*change_protocol)(struct rc_dev *dev, u64 *rc_type);
983 struct rc_scancode_filter *filter;
984 int (*set_filter)(struct rc_dev *dev, struct rc_scancode_filter *filter);
985 u64 old_protocols, new_protocols;
988 /* Device is being removed */
992 if (fattr->type == RC_FILTER_NORMAL) {
993 IR_dprintk(1, "Normal protocol change requested\n");
994 current_protocols = &dev->enabled_protocols;
995 change_protocol = dev->change_protocol;
996 filter = &dev->scancode_filter;
997 set_filter = dev->s_filter;
999 IR_dprintk(1, "Wakeup protocol change requested\n");
1000 current_protocols = &dev->enabled_wakeup_protocols;
1001 change_protocol = dev->change_wakeup_protocol;
1002 filter = &dev->scancode_wakeup_filter;
1003 set_filter = dev->s_wakeup_filter;
1006 if (!change_protocol) {
1007 IR_dprintk(1, "Protocol switching not supported\n");
1011 mutex_lock(&dev->lock);
1013 old_protocols = *current_protocols;
1014 new_protocols = old_protocols;
1015 rc = parse_protocol_change(&new_protocols, buf);
1019 rc = change_protocol(dev, &new_protocols);
1021 IR_dprintk(1, "Error setting protocols to 0x%llx\n",
1022 (long long)new_protocols);
1026 if (new_protocols != old_protocols) {
1027 *current_protocols = new_protocols;
1028 IR_dprintk(1, "Protocols changed to 0x%llx\n",
1029 (long long)new_protocols);
1033 * If a protocol change was attempted the filter may need updating, even
1034 * if the actual protocol mask hasn't changed (since the driver may have
1035 * cleared the filter).
1036 * Try setting the same filter with the new protocol (if any).
1037 * Fall back to clearing the filter.
1039 if (set_filter && filter->mask) {
1041 rc = set_filter(dev, filter);
1048 set_filter(dev, filter);
1055 mutex_unlock(&dev->lock);
1060 * show_filter() - shows the current scancode filter value or mask
1061 * @device: the device descriptor
1062 * @attr: the device attribute struct
1063 * @buf: a pointer to the output buffer
1065 * This routine is a callback routine to read a scancode filter value or mask.
1066 * It is trigged by reading /sys/class/rc/rc?/[wakeup_]filter[_mask].
1067 * It prints the current scancode filter value or mask of the appropriate filter
1068 * type in hexadecimal into @buf and returns the size of the buffer.
1070 * Bits of the filter value corresponding to set bits in the filter mask are
1071 * compared against input scancodes and non-matching scancodes are discarded.
1073 * dev->lock is taken to guard against races between device registration,
1074 * store_filter and show_filter.
1076 static ssize_t show_filter(struct device *device,
1077 struct device_attribute *attr,
1080 struct rc_dev *dev = to_rc_dev(device);
1081 struct rc_filter_attribute *fattr = to_rc_filter_attr(attr);
1082 struct rc_scancode_filter *filter;
1085 /* Device is being removed */
1089 if (fattr->type == RC_FILTER_NORMAL)
1090 filter = &dev->scancode_filter;
1092 filter = &dev->scancode_wakeup_filter;
1094 mutex_lock(&dev->lock);
1099 mutex_unlock(&dev->lock);
1101 return sprintf(buf, "%#x\n", val);
1105 * store_filter() - changes the scancode filter value
1106 * @device: the device descriptor
1107 * @attr: the device attribute struct
1108 * @buf: a pointer to the input buffer
1109 * @len: length of the input buffer
1111 * This routine is for changing a scancode filter value or mask.
1112 * It is trigged by writing to /sys/class/rc/rc?/[wakeup_]filter[_mask].
1113 * Returns -EINVAL if an invalid filter value for the current protocol was
1114 * specified or if scancode filtering is not supported by the driver, otherwise
1117 * Bits of the filter value corresponding to set bits in the filter mask are
1118 * compared against input scancodes and non-matching scancodes are discarded.
1120 * dev->lock is taken to guard against races between device registration,
1121 * store_filter and show_filter.
1123 static ssize_t store_filter(struct device *device,
1124 struct device_attribute *attr,
1125 const char *buf, size_t len)
1127 struct rc_dev *dev = to_rc_dev(device);
1128 struct rc_filter_attribute *fattr = to_rc_filter_attr(attr);
1129 struct rc_scancode_filter new_filter, *filter;
1132 int (*set_filter)(struct rc_dev *dev, struct rc_scancode_filter *filter);
1133 u64 *enabled_protocols;
1135 /* Device is being removed */
1139 ret = kstrtoul(buf, 0, &val);
1143 if (fattr->type == RC_FILTER_NORMAL) {
1144 set_filter = dev->s_filter;
1145 enabled_protocols = &dev->enabled_protocols;
1146 filter = &dev->scancode_filter;
1148 set_filter = dev->s_wakeup_filter;
1149 enabled_protocols = &dev->enabled_wakeup_protocols;
1150 filter = &dev->scancode_wakeup_filter;
1156 mutex_lock(&dev->lock);
1158 new_filter = *filter;
1160 new_filter.mask = val;
1162 new_filter.data = val;
1164 if (!*enabled_protocols && val) {
1165 /* refuse to set a filter unless a protocol is enabled */
1170 ret = set_filter(dev, &new_filter);
1174 *filter = new_filter;
1177 mutex_unlock(&dev->lock);
1178 return (ret < 0) ? ret : len;
1181 static void rc_dev_release(struct device *device)
1185 #define ADD_HOTPLUG_VAR(fmt, val...) \
1187 int err = add_uevent_var(env, fmt, val); \
1192 static int rc_dev_uevent(struct device *device, struct kobj_uevent_env *env)
1194 struct rc_dev *dev = to_rc_dev(device);
1196 if (!dev || !dev->input_dev)
1199 if (dev->rc_map.name)
1200 ADD_HOTPLUG_VAR("NAME=%s", dev->rc_map.name);
1201 if (dev->driver_name)
1202 ADD_HOTPLUG_VAR("DRV_NAME=%s", dev->driver_name);
1208 * Static device attribute struct with the sysfs attributes for IR's
1210 static RC_PROTO_ATTR(protocols, S_IRUGO | S_IWUSR,
1211 show_protocols, store_protocols, RC_FILTER_NORMAL);
1212 static RC_PROTO_ATTR(wakeup_protocols, S_IRUGO | S_IWUSR,
1213 show_protocols, store_protocols, RC_FILTER_WAKEUP);
1214 static RC_FILTER_ATTR(filter, S_IRUGO|S_IWUSR,
1215 show_filter, store_filter, RC_FILTER_NORMAL, false);
1216 static RC_FILTER_ATTR(filter_mask, S_IRUGO|S_IWUSR,
1217 show_filter, store_filter, RC_FILTER_NORMAL, true);
1218 static RC_FILTER_ATTR(wakeup_filter, S_IRUGO|S_IWUSR,
1219 show_filter, store_filter, RC_FILTER_WAKEUP, false);
1220 static RC_FILTER_ATTR(wakeup_filter_mask, S_IRUGO|S_IWUSR,
1221 show_filter, store_filter, RC_FILTER_WAKEUP, true);
1223 static struct attribute *rc_dev_protocol_attrs[] = {
1224 &dev_attr_protocols.attr.attr,
1228 static struct attribute_group rc_dev_protocol_attr_grp = {
1229 .attrs = rc_dev_protocol_attrs,
1232 static struct attribute *rc_dev_wakeup_protocol_attrs[] = {
1233 &dev_attr_wakeup_protocols.attr.attr,
1237 static struct attribute_group rc_dev_wakeup_protocol_attr_grp = {
1238 .attrs = rc_dev_wakeup_protocol_attrs,
1241 static struct attribute *rc_dev_filter_attrs[] = {
1242 &dev_attr_filter.attr.attr,
1243 &dev_attr_filter_mask.attr.attr,
1247 static struct attribute_group rc_dev_filter_attr_grp = {
1248 .attrs = rc_dev_filter_attrs,
1251 static struct attribute *rc_dev_wakeup_filter_attrs[] = {
1252 &dev_attr_wakeup_filter.attr.attr,
1253 &dev_attr_wakeup_filter_mask.attr.attr,
1257 static struct attribute_group rc_dev_wakeup_filter_attr_grp = {
1258 .attrs = rc_dev_wakeup_filter_attrs,
1261 static struct device_type rc_dev_type = {
1262 .release = rc_dev_release,
1263 .uevent = rc_dev_uevent,
1266 struct rc_dev *rc_allocate_device(void)
1270 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1274 dev->input_dev = input_allocate_device();
1275 if (!dev->input_dev) {
1280 dev->input_dev->getkeycode = ir_getkeycode;
1281 dev->input_dev->setkeycode = ir_setkeycode;
1282 input_set_drvdata(dev->input_dev, dev);
1284 spin_lock_init(&dev->rc_map.lock);
1285 spin_lock_init(&dev->keylock);
1286 mutex_init(&dev->lock);
1287 setup_timer(&dev->timer_keyup, ir_timer_keyup, (unsigned long)dev);
1289 dev->dev.type = &rc_dev_type;
1290 dev->dev.class = &rc_class;
1291 device_initialize(&dev->dev);
1293 __module_get(THIS_MODULE);
1296 EXPORT_SYMBOL_GPL(rc_allocate_device);
1298 void rc_free_device(struct rc_dev *dev)
1303 input_free_device(dev->input_dev);
1305 put_device(&dev->dev);
1308 module_put(THIS_MODULE);
1310 EXPORT_SYMBOL_GPL(rc_free_device);
1312 int rc_register_device(struct rc_dev *dev)
1314 static bool raw_init = false; /* raw decoders loaded? */
1315 struct rc_map *rc_map;
1317 int rc, devno, attr = 0;
1319 if (!dev || !dev->map_name)
1322 rc_map = rc_map_get(dev->map_name);
1324 rc_map = rc_map_get(RC_MAP_EMPTY);
1325 if (!rc_map || !rc_map->scan || rc_map->size == 0)
1328 set_bit(EV_KEY, dev->input_dev->evbit);
1329 set_bit(EV_REP, dev->input_dev->evbit);
1330 set_bit(EV_MSC, dev->input_dev->evbit);
1331 set_bit(MSC_SCAN, dev->input_dev->mscbit);
1333 dev->input_dev->open = ir_open;
1335 dev->input_dev->close = ir_close;
1338 devno = find_first_zero_bit(ir_core_dev_number,
1340 /* No free device slots */
1341 if (devno >= IRRCV_NUM_DEVICES)
1343 } while (test_and_set_bit(devno, ir_core_dev_number));
1345 dev->dev.groups = dev->sysfs_groups;
1346 dev->sysfs_groups[attr++] = &rc_dev_protocol_attr_grp;
1348 dev->sysfs_groups[attr++] = &rc_dev_filter_attr_grp;
1349 if (dev->s_wakeup_filter)
1350 dev->sysfs_groups[attr++] = &rc_dev_wakeup_filter_attr_grp;
1351 if (dev->change_wakeup_protocol)
1352 dev->sysfs_groups[attr++] = &rc_dev_wakeup_protocol_attr_grp;
1353 dev->sysfs_groups[attr++] = NULL;
1356 * Take the lock here, as the device sysfs node will appear
1357 * when device_add() is called, which may trigger an ir-keytable udev
1358 * rule, which will in turn call show_protocols and access
1359 * dev->enabled_protocols before it has been initialized.
1361 mutex_lock(&dev->lock);
1364 dev_set_name(&dev->dev, "rc%ld", dev->devno);
1365 dev_set_drvdata(&dev->dev, dev);
1366 rc = device_add(&dev->dev);
1370 rc = ir_setkeytable(dev, rc_map);
1374 dev->input_dev->dev.parent = &dev->dev;
1375 memcpy(&dev->input_dev->id, &dev->input_id, sizeof(dev->input_id));
1376 dev->input_dev->phys = dev->input_phys;
1377 dev->input_dev->name = dev->input_name;
1379 /* input_register_device can call ir_open, so unlock mutex here */
1380 mutex_unlock(&dev->lock);
1382 rc = input_register_device(dev->input_dev);
1384 mutex_lock(&dev->lock);
1390 * Default delay of 250ms is too short for some protocols, especially
1391 * since the timeout is currently set to 250ms. Increase it to 500ms,
1392 * to avoid wrong repetition of the keycodes. Note that this must be
1393 * set after the call to input_register_device().
1395 dev->input_dev->rep[REP_DELAY] = 500;
1398 * As a repeat event on protocols like RC-5 and NEC take as long as
1399 * 110/114ms, using 33ms as a repeat period is not the right thing
1402 dev->input_dev->rep[REP_PERIOD] = 125;
1404 path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);
1405 printk(KERN_INFO "%s: %s as %s\n",
1406 dev_name(&dev->dev),
1407 dev->input_name ? dev->input_name : "Unspecified device",
1408 path ? path : "N/A");
1411 if (dev->driver_type == RC_DRIVER_IR_RAW || dev->encode_wakeup) {
1412 /* Load raw decoders, if they aren't already */
1414 IR_dprintk(1, "Loading raw decoders\n");
1420 if (dev->driver_type == RC_DRIVER_IR_RAW) {
1421 /* calls ir_register_device so unlock mutex here*/
1422 mutex_unlock(&dev->lock);
1423 rc = ir_raw_event_register(dev);
1424 mutex_lock(&dev->lock);
1429 if (dev->change_protocol) {
1430 u64 rc_type = (1ll << rc_map->rc_type);
1431 if (dev->driver_type == RC_DRIVER_IR_RAW)
1432 rc_type |= RC_BIT_LIRC;
1433 rc = dev->change_protocol(dev, &rc_type);
1436 dev->enabled_protocols = rc_type;
1439 mutex_unlock(&dev->lock);
1441 IR_dprintk(1, "Registered rc%ld (driver: %s, remote: %s, mode %s)\n",
1443 dev->driver_name ? dev->driver_name : "unknown",
1444 rc_map->name ? rc_map->name : "unknown",
1445 dev->driver_type == RC_DRIVER_IR_RAW ? "raw" : "cooked");
1450 if (dev->driver_type == RC_DRIVER_IR_RAW)
1451 ir_raw_event_unregister(dev);
1453 input_unregister_device(dev->input_dev);
1454 dev->input_dev = NULL;
1456 ir_free_table(&dev->rc_map);
1458 device_del(&dev->dev);
1460 mutex_unlock(&dev->lock);
1461 clear_bit(dev->devno, ir_core_dev_number);
1464 EXPORT_SYMBOL_GPL(rc_register_device);
1466 void rc_unregister_device(struct rc_dev *dev)
1471 del_timer_sync(&dev->timer_keyup);
1473 clear_bit(dev->devno, ir_core_dev_number);
1475 if (dev->driver_type == RC_DRIVER_IR_RAW)
1476 ir_raw_event_unregister(dev);
1478 /* Freeing the table should also call the stop callback */
1479 ir_free_table(&dev->rc_map);
1480 IR_dprintk(1, "Freed keycode table\n");
1482 input_unregister_device(dev->input_dev);
1483 dev->input_dev = NULL;
1485 device_del(&dev->dev);
1487 rc_free_device(dev);
1490 EXPORT_SYMBOL_GPL(rc_unregister_device);
1493 * Init/exit code for the module. Basically, creates/removes /sys/class/rc
1496 static int __init rc_core_init(void)
1498 int rc = class_register(&rc_class);
1500 printk(KERN_ERR "rc_core: unable to register rc class\n");
1504 led_trigger_register_simple("rc-feedback", &led_feedback);
1505 rc_map_register(&empty_map);
1510 static void __exit rc_core_exit(void)
1512 class_unregister(&rc_class);
1513 led_trigger_unregister_simple(led_feedback);
1514 rc_map_unregister(&empty_map);
1517 subsys_initcall(rc_core_init);
1518 module_exit(rc_core_exit);
1520 int rc_core_debug; /* ir_debug level (0,1,2) */
1521 EXPORT_SYMBOL_GPL(rc_core_debug);
1522 module_param_named(debug, rc_core_debug, int, 0644);
1524 MODULE_AUTHOR("Mauro Carvalho Chehab");
1525 MODULE_LICENSE("GPL");