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.
289 scancode &= dev->scanmask;
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 * @scancode: the scancode of the keypress
627 * @keycode: the keycode of the keypress
628 * @toggle: the toggle value of the keypress
630 * This function is used internally to register a keypress, it must be
631 * called with keylock held.
633 static void ir_do_keydown(struct rc_dev *dev, int scancode,
634 u32 keycode, u8 toggle)
636 struct rc_scancode_filter *filter;
637 bool new_event = !dev->keypressed ||
638 dev->last_scancode != scancode ||
639 dev->last_toggle != toggle;
641 if (new_event && dev->keypressed)
642 ir_do_keyup(dev, false);
644 /* Generic scancode filtering */
645 filter = &dev->scancode_filters[RC_FILTER_NORMAL];
646 if (filter->mask && ((scancode ^ filter->data) & filter->mask))
649 input_event(dev->input_dev, EV_MSC, MSC_SCAN, scancode);
651 if (new_event && keycode != KEY_RESERVED) {
652 /* Register a keypress */
653 dev->keypressed = true;
654 dev->last_scancode = scancode;
655 dev->last_toggle = toggle;
656 dev->last_keycode = keycode;
658 IR_dprintk(1, "%s: key down event, "
659 "key 0x%04x, scancode 0x%04x\n",
660 dev->input_name, keycode, scancode);
661 input_report_key(dev->input_dev, keycode, 1);
663 led_trigger_event(led_feedback, LED_FULL);
666 input_sync(dev->input_dev);
670 * rc_keydown() - generates input event for a key press
671 * @dev: the struct rc_dev descriptor of the device
672 * @scancode: the scancode that we're seeking
673 * @toggle: the toggle value (protocol dependent, if the protocol doesn't
674 * support toggle values, this should be set to zero)
676 * This routine is used to signal that a key has been pressed on the
679 void rc_keydown(struct rc_dev *dev, int scancode, u8 toggle)
682 u32 keycode = rc_g_keycode_from_table(dev, scancode);
684 spin_lock_irqsave(&dev->keylock, flags);
685 ir_do_keydown(dev, scancode, keycode, toggle);
687 if (dev->keypressed) {
688 dev->keyup_jiffies = jiffies + msecs_to_jiffies(IR_KEYPRESS_TIMEOUT);
689 mod_timer(&dev->timer_keyup, dev->keyup_jiffies);
691 spin_unlock_irqrestore(&dev->keylock, flags);
693 EXPORT_SYMBOL_GPL(rc_keydown);
696 * rc_keydown_notimeout() - generates input event for a key press without
697 * an automatic keyup event at a later time
698 * @dev: the struct rc_dev descriptor of the device
699 * @scancode: the scancode that we're seeking
700 * @toggle: the toggle value (protocol dependent, if the protocol doesn't
701 * support toggle values, this should be set to zero)
703 * This routine is used to signal that a key has been pressed on the
704 * remote control. The driver must manually call rc_keyup() at a later stage.
706 void rc_keydown_notimeout(struct rc_dev *dev, int 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, 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" },
806 * struct rc_filter_attribute - Device attribute relating to a filter type.
807 * @attr: Device attribute.
808 * @type: Filter type.
809 * @mask: false for filter value, true for filter mask.
811 struct rc_filter_attribute {
812 struct device_attribute attr;
813 enum rc_filter_type type;
816 #define to_rc_filter_attr(a) container_of(a, struct rc_filter_attribute, attr)
818 #define RC_PROTO_ATTR(_name, _mode, _show, _store, _type) \
819 struct rc_filter_attribute dev_attr_##_name = { \
820 .attr = __ATTR(_name, _mode, _show, _store), \
823 #define RC_FILTER_ATTR(_name, _mode, _show, _store, _type, _mask) \
824 struct rc_filter_attribute dev_attr_##_name = { \
825 .attr = __ATTR(_name, _mode, _show, _store), \
831 * show_protocols() - shows the current/wakeup IR protocol(s)
832 * @device: the device descriptor
833 * @mattr: the device attribute struct (unused)
834 * @buf: a pointer to the output buffer
836 * This routine is a callback routine for input read the IR protocol type(s).
837 * it is trigged by reading /sys/class/rc/rc?/[wakeup_]protocols.
838 * It returns the protocol names of supported protocols.
839 * Enabled protocols are printed in brackets.
841 * dev->lock is taken to guard against races between device
842 * registration, store_protocols and show_protocols.
844 static ssize_t show_protocols(struct device *device,
845 struct device_attribute *mattr, char *buf)
847 struct rc_dev *dev = to_rc_dev(device);
848 struct rc_filter_attribute *fattr = to_rc_filter_attr(mattr);
849 u64 allowed, enabled;
853 /* Device is being removed */
857 mutex_lock(&dev->lock);
859 enabled = dev->enabled_protocols[fattr->type];
860 if (dev->driver_type == RC_DRIVER_SCANCODE ||
861 fattr->type == RC_FILTER_WAKEUP)
862 allowed = dev->allowed_protocols[fattr->type];
864 allowed = ir_raw_get_allowed_protocols();
866 mutex_unlock(&dev->lock);
870 IR_dprintk(1, "allowed - 0x%llx, enabled - 0x%llx\n",
874 for (i = 0; i < ARRAY_SIZE(proto_names); i++) {
875 if (allowed & enabled & proto_names[i].type)
876 tmp += sprintf(tmp, "[%s] ", proto_names[i].name);
877 else if (allowed & proto_names[i].type)
878 tmp += sprintf(tmp, "%s ", proto_names[i].name);
880 if (allowed & proto_names[i].type)
881 allowed &= ~proto_names[i].type;
888 mutex_unlock(&dev->lock);
890 return tmp + 1 - buf;
894 * store_protocols() - changes the current/wakeup IR protocol(s)
895 * @device: the device descriptor
896 * @mattr: the device attribute struct (unused)
897 * @buf: a pointer to the input buffer
898 * @len: length of the input buffer
900 * This routine is for changing the IR protocol type.
901 * It is trigged by writing to /sys/class/rc/rc?/[wakeup_]protocols.
902 * Writing "+proto" will add a protocol to the list of enabled protocols.
903 * Writing "-proto" will remove a protocol from the list of enabled protocols.
904 * Writing "proto" will enable only "proto".
905 * Writing "none" will disable all protocols.
906 * Returns -EINVAL if an invalid protocol combination or unknown protocol name
907 * is used, otherwise @len.
909 * dev->lock is taken to guard against races between device
910 * registration, store_protocols and show_protocols.
912 static ssize_t store_protocols(struct device *device,
913 struct device_attribute *mattr,
917 struct rc_dev *dev = to_rc_dev(device);
918 struct rc_filter_attribute *fattr = to_rc_filter_attr(mattr);
919 bool enable, disable;
923 int rc, i, count = 0;
925 int (*change_protocol)(struct rc_dev *dev, u64 *rc_type);
926 struct rc_scancode_filter local_filter, *filter;
928 /* Device is being removed */
932 mutex_lock(&dev->lock);
934 if (dev->driver_type != RC_DRIVER_SCANCODE && !dev->raw) {
935 IR_dprintk(1, "Protocol switching not supported\n");
939 old_type = dev->enabled_protocols[fattr->type];
942 while ((tmp = strsep((char **) &data, " \n")) != NULL) {
950 } else if (*tmp == '-') {
959 for (i = 0; i < ARRAY_SIZE(proto_names); i++) {
960 if (!strcasecmp(tmp, proto_names[i].name)) {
961 mask = proto_names[i].type;
966 if (i == ARRAY_SIZE(proto_names)) {
967 IR_dprintk(1, "Unknown protocol: '%s'\n", tmp);
983 IR_dprintk(1, "Protocol not specified\n");
988 change_protocol = (fattr->type == RC_FILTER_NORMAL)
989 ? dev->change_protocol : dev->change_wakeup_protocol;
990 if (change_protocol) {
991 rc = change_protocol(dev, &type);
993 IR_dprintk(1, "Error setting protocols to 0x%llx\n",
1000 dev->enabled_protocols[fattr->type] = type;
1001 IR_dprintk(1, "Current protocol(s): 0x%llx\n",
1005 * If the protocol is changed the filter needs updating.
1006 * Try setting the same filter with the new protocol (if any).
1007 * Fall back to clearing the filter.
1009 filter = &dev->scancode_filters[fattr->type];
1010 if (old_type != type && filter->mask) {
1011 local_filter = *filter;
1013 /* no protocol => clear filter */
1015 } else if (!dev->s_filter) {
1016 /* generic filtering => accept any filter */
1019 /* hardware filtering => try setting, otherwise clear */
1020 ret = dev->s_filter(dev, fattr->type, &local_filter);
1023 /* clear the filter */
1024 local_filter.data = 0;
1025 local_filter.mask = 0;
1027 dev->s_filter(dev, fattr->type, &local_filter);
1030 /* commit the new filter */
1031 *filter = local_filter;
1037 mutex_unlock(&dev->lock);
1042 * show_filter() - shows the current scancode filter value or mask
1043 * @device: the device descriptor
1044 * @attr: the device attribute struct
1045 * @buf: a pointer to the output buffer
1047 * This routine is a callback routine to read a scancode filter value or mask.
1048 * It is trigged by reading /sys/class/rc/rc?/[wakeup_]filter[_mask].
1049 * It prints the current scancode filter value or mask of the appropriate filter
1050 * type in hexadecimal into @buf and returns the size of the buffer.
1052 * Bits of the filter value corresponding to set bits in the filter mask are
1053 * compared against input scancodes and non-matching scancodes are discarded.
1055 * dev->lock is taken to guard against races between device registration,
1056 * store_filter and show_filter.
1058 static ssize_t show_filter(struct device *device,
1059 struct device_attribute *attr,
1062 struct rc_dev *dev = to_rc_dev(device);
1063 struct rc_filter_attribute *fattr = to_rc_filter_attr(attr);
1066 /* Device is being removed */
1070 mutex_lock(&dev->lock);
1072 val = dev->scancode_filters[fattr->type].mask;
1074 val = dev->scancode_filters[fattr->type].data;
1075 mutex_unlock(&dev->lock);
1077 return sprintf(buf, "%#x\n", val);
1081 * store_filter() - changes the scancode filter value
1082 * @device: the device descriptor
1083 * @attr: the device attribute struct
1084 * @buf: a pointer to the input buffer
1085 * @len: length of the input buffer
1087 * This routine is for changing a scancode filter value or mask.
1088 * It is trigged by writing to /sys/class/rc/rc?/[wakeup_]filter[_mask].
1089 * Returns -EINVAL if an invalid filter value for the current protocol was
1090 * specified or if scancode filtering is not supported by the driver, otherwise
1093 * Bits of the filter value corresponding to set bits in the filter mask are
1094 * compared against input scancodes and non-matching scancodes are discarded.
1096 * dev->lock is taken to guard against races between device registration,
1097 * store_filter and show_filter.
1099 static ssize_t store_filter(struct device *device,
1100 struct device_attribute *attr,
1104 struct rc_dev *dev = to_rc_dev(device);
1105 struct rc_filter_attribute *fattr = to_rc_filter_attr(attr);
1106 struct rc_scancode_filter local_filter, *filter;
1110 /* Device is being removed */
1114 ret = kstrtoul(buf, 0, &val);
1118 /* Scancode filter not supported (but still accept 0) */
1119 if (!dev->s_filter && fattr->type != RC_FILTER_NORMAL)
1120 return val ? -EINVAL : count;
1122 mutex_lock(&dev->lock);
1124 /* Tell the driver about the new filter */
1125 filter = &dev->scancode_filters[fattr->type];
1126 local_filter = *filter;
1128 local_filter.mask = val;
1130 local_filter.data = val;
1131 if (!dev->enabled_protocols[fattr->type] && local_filter.mask) {
1132 /* refuse to set a filter unless a protocol is enabled */
1136 if (dev->s_filter) {
1137 ret = dev->s_filter(dev, fattr->type, &local_filter);
1142 /* Success, commit the new filter */
1143 *filter = local_filter;
1146 mutex_unlock(&dev->lock);
1147 return (ret < 0) ? ret : count;
1150 static void rc_dev_release(struct device *device)
1154 #define ADD_HOTPLUG_VAR(fmt, val...) \
1156 int err = add_uevent_var(env, fmt, val); \
1161 static int rc_dev_uevent(struct device *device, struct kobj_uevent_env *env)
1163 struct rc_dev *dev = to_rc_dev(device);
1165 if (!dev || !dev->input_dev)
1168 if (dev->rc_map.name)
1169 ADD_HOTPLUG_VAR("NAME=%s", dev->rc_map.name);
1170 if (dev->driver_name)
1171 ADD_HOTPLUG_VAR("DRV_NAME=%s", dev->driver_name);
1177 * Static device attribute struct with the sysfs attributes for IR's
1179 static RC_PROTO_ATTR(protocols, S_IRUGO | S_IWUSR,
1180 show_protocols, store_protocols, RC_FILTER_NORMAL);
1181 static RC_PROTO_ATTR(wakeup_protocols, S_IRUGO | S_IWUSR,
1182 show_protocols, store_protocols, RC_FILTER_WAKEUP);
1183 static RC_FILTER_ATTR(filter, S_IRUGO|S_IWUSR,
1184 show_filter, store_filter, RC_FILTER_NORMAL, false);
1185 static RC_FILTER_ATTR(filter_mask, S_IRUGO|S_IWUSR,
1186 show_filter, store_filter, RC_FILTER_NORMAL, true);
1187 static RC_FILTER_ATTR(wakeup_filter, S_IRUGO|S_IWUSR,
1188 show_filter, store_filter, RC_FILTER_WAKEUP, false);
1189 static RC_FILTER_ATTR(wakeup_filter_mask, S_IRUGO|S_IWUSR,
1190 show_filter, store_filter, RC_FILTER_WAKEUP, true);
1192 static struct attribute *rc_dev_attrs[] = {
1193 &dev_attr_protocols.attr.attr,
1194 &dev_attr_wakeup_protocols.attr.attr,
1195 &dev_attr_filter.attr.attr,
1196 &dev_attr_filter_mask.attr.attr,
1197 &dev_attr_wakeup_filter.attr.attr,
1198 &dev_attr_wakeup_filter_mask.attr.attr,
1202 static struct attribute_group rc_dev_attr_grp = {
1203 .attrs = rc_dev_attrs,
1206 static const struct attribute_group *rc_dev_attr_groups[] = {
1211 static struct device_type rc_dev_type = {
1212 .groups = rc_dev_attr_groups,
1213 .release = rc_dev_release,
1214 .uevent = rc_dev_uevent,
1217 struct rc_dev *rc_allocate_device(void)
1221 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1225 dev->input_dev = input_allocate_device();
1226 if (!dev->input_dev) {
1231 dev->input_dev->getkeycode = ir_getkeycode;
1232 dev->input_dev->setkeycode = ir_setkeycode;
1233 input_set_drvdata(dev->input_dev, dev);
1235 spin_lock_init(&dev->rc_map.lock);
1236 spin_lock_init(&dev->keylock);
1237 mutex_init(&dev->lock);
1238 setup_timer(&dev->timer_keyup, ir_timer_keyup, (unsigned long)dev);
1240 dev->dev.type = &rc_dev_type;
1241 dev->dev.class = &rc_class;
1242 device_initialize(&dev->dev);
1244 __module_get(THIS_MODULE);
1247 EXPORT_SYMBOL_GPL(rc_allocate_device);
1249 void rc_free_device(struct rc_dev *dev)
1255 input_free_device(dev->input_dev);
1257 put_device(&dev->dev);
1260 module_put(THIS_MODULE);
1262 EXPORT_SYMBOL_GPL(rc_free_device);
1264 int rc_register_device(struct rc_dev *dev)
1266 static bool raw_init = false; /* raw decoders loaded? */
1267 struct rc_map *rc_map;
1271 if (!dev || !dev->map_name)
1274 rc_map = rc_map_get(dev->map_name);
1276 rc_map = rc_map_get(RC_MAP_EMPTY);
1277 if (!rc_map || !rc_map->scan || rc_map->size == 0)
1280 set_bit(EV_KEY, dev->input_dev->evbit);
1281 set_bit(EV_REP, dev->input_dev->evbit);
1282 set_bit(EV_MSC, dev->input_dev->evbit);
1283 set_bit(MSC_SCAN, dev->input_dev->mscbit);
1285 dev->input_dev->open = ir_open;
1287 dev->input_dev->close = ir_close;
1290 devno = find_first_zero_bit(ir_core_dev_number,
1292 /* No free device slots */
1293 if (devno >= IRRCV_NUM_DEVICES)
1295 } while (test_and_set_bit(devno, ir_core_dev_number));
1298 * Take the lock here, as the device sysfs node will appear
1299 * when device_add() is called, which may trigger an ir-keytable udev
1300 * rule, which will in turn call show_protocols and access
1301 * dev->enabled_protocols before it has been initialized.
1303 mutex_lock(&dev->lock);
1306 dev_set_name(&dev->dev, "rc%ld", dev->devno);
1307 dev_set_drvdata(&dev->dev, dev);
1308 rc = device_add(&dev->dev);
1312 rc = ir_setkeytable(dev, rc_map);
1316 dev->input_dev->dev.parent = &dev->dev;
1317 memcpy(&dev->input_dev->id, &dev->input_id, sizeof(dev->input_id));
1318 dev->input_dev->phys = dev->input_phys;
1319 dev->input_dev->name = dev->input_name;
1321 /* input_register_device can call ir_open, so unlock mutex here */
1322 mutex_unlock(&dev->lock);
1324 rc = input_register_device(dev->input_dev);
1326 mutex_lock(&dev->lock);
1332 * Default delay of 250ms is too short for some protocols, especially
1333 * since the timeout is currently set to 250ms. Increase it to 500ms,
1334 * to avoid wrong repetition of the keycodes. Note that this must be
1335 * set after the call to input_register_device().
1337 dev->input_dev->rep[REP_DELAY] = 500;
1340 * As a repeat event on protocols like RC-5 and NEC take as long as
1341 * 110/114ms, using 33ms as a repeat period is not the right thing
1344 dev->input_dev->rep[REP_PERIOD] = 125;
1346 path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);
1347 printk(KERN_INFO "%s: %s as %s\n",
1348 dev_name(&dev->dev),
1349 dev->input_name ? dev->input_name : "Unspecified device",
1350 path ? path : "N/A");
1353 if (dev->driver_type == RC_DRIVER_IR_RAW) {
1354 /* Load raw decoders, if they aren't already */
1356 IR_dprintk(1, "Loading raw decoders\n");
1360 rc = ir_raw_event_register(dev);
1365 if (dev->change_protocol) {
1366 u64 rc_type = (1 << rc_map->rc_type);
1367 rc = dev->change_protocol(dev, &rc_type);
1370 dev->enabled_protocols[RC_FILTER_NORMAL] = rc_type;
1373 mutex_unlock(&dev->lock);
1375 IR_dprintk(1, "Registered rc%ld (driver: %s, remote: %s, mode %s)\n",
1377 dev->driver_name ? dev->driver_name : "unknown",
1378 rc_map->name ? rc_map->name : "unknown",
1379 dev->driver_type == RC_DRIVER_IR_RAW ? "raw" : "cooked");
1384 if (dev->driver_type == RC_DRIVER_IR_RAW)
1385 ir_raw_event_unregister(dev);
1387 input_unregister_device(dev->input_dev);
1388 dev->input_dev = NULL;
1390 ir_free_table(&dev->rc_map);
1392 device_del(&dev->dev);
1394 mutex_unlock(&dev->lock);
1395 clear_bit(dev->devno, ir_core_dev_number);
1398 EXPORT_SYMBOL_GPL(rc_register_device);
1400 void rc_unregister_device(struct rc_dev *dev)
1405 del_timer_sync(&dev->timer_keyup);
1407 clear_bit(dev->devno, ir_core_dev_number);
1409 if (dev->driver_type == RC_DRIVER_IR_RAW)
1410 ir_raw_event_unregister(dev);
1412 /* Freeing the table should also call the stop callback */
1413 ir_free_table(&dev->rc_map);
1414 IR_dprintk(1, "Freed keycode table\n");
1416 input_unregister_device(dev->input_dev);
1417 dev->input_dev = NULL;
1419 device_del(&dev->dev);
1421 rc_free_device(dev);
1424 EXPORT_SYMBOL_GPL(rc_unregister_device);
1427 * Init/exit code for the module. Basically, creates/removes /sys/class/rc
1430 static int __init rc_core_init(void)
1432 int rc = class_register(&rc_class);
1434 printk(KERN_ERR "rc_core: unable to register rc class\n");
1438 led_trigger_register_simple("rc-feedback", &led_feedback);
1439 rc_map_register(&empty_map);
1444 static void __exit rc_core_exit(void)
1446 class_unregister(&rc_class);
1447 led_trigger_unregister_simple(led_feedback);
1448 rc_map_unregister(&empty_map);
1451 subsys_initcall(rc_core_init);
1452 module_exit(rc_core_exit);
1454 int rc_core_debug; /* ir_debug level (0,1,2) */
1455 EXPORT_SYMBOL_GPL(rc_core_debug);
1456 module_param_named(debug, rc_core_debug, int, 0644);
1458 MODULE_AUTHOR("Mauro Carvalho Chehab");
1459 MODULE_LICENSE("GPL");