1 /* rc-main.c - Remote Controller core module
3 * Copyright (C) 2009-2010 by Mauro Carvalho Chehab <mchehab@redhat.com>
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/slab.h>
20 #include <linux/device.h>
21 #include <linux/module.h>
22 #include "rc-core-priv.h"
24 /* Sizes are in bytes, 256 bytes allows for 32 entries on x64 */
25 #define IR_TAB_MIN_SIZE 256
26 #define IR_TAB_MAX_SIZE 8192
28 /* FIXME: IR_KEYPRESS_TIMEOUT should be protocol specific */
29 #define IR_KEYPRESS_TIMEOUT 250
31 /* Used to keep track of known keymaps */
32 static LIST_HEAD(rc_map_list);
33 static DEFINE_SPINLOCK(rc_map_lock);
35 static struct rc_map_list *seek_rc_map(const char *name)
37 struct rc_map_list *map = NULL;
39 spin_lock(&rc_map_lock);
40 list_for_each_entry(map, &rc_map_list, list) {
41 if (!strcmp(name, map->map.name)) {
42 spin_unlock(&rc_map_lock);
46 spin_unlock(&rc_map_lock);
51 struct rc_map *rc_map_get(const char *name)
54 struct rc_map_list *map;
56 map = seek_rc_map(name);
59 int rc = request_module(name);
61 printk(KERN_ERR "Couldn't load IR keymap %s\n", name);
64 msleep(20); /* Give some time for IR to register */
66 map = seek_rc_map(name);
70 printk(KERN_ERR "IR keymap %s not found\n", name);
74 printk(KERN_INFO "Registered IR keymap %s\n", map->map.name);
78 EXPORT_SYMBOL_GPL(rc_map_get);
80 int rc_map_register(struct rc_map_list *map)
82 spin_lock(&rc_map_lock);
83 list_add_tail(&map->list, &rc_map_list);
84 spin_unlock(&rc_map_lock);
87 EXPORT_SYMBOL_GPL(rc_map_register);
89 void rc_map_unregister(struct rc_map_list *map)
91 spin_lock(&rc_map_lock);
93 spin_unlock(&rc_map_lock);
95 EXPORT_SYMBOL_GPL(rc_map_unregister);
98 static struct rc_map_table empty[] = {
102 static struct rc_map_list empty_map = {
105 .size = ARRAY_SIZE(empty),
106 .rc_type = RC_TYPE_UNKNOWN, /* Legacy IR type */
107 .name = RC_MAP_EMPTY,
112 * ir_create_table() - initializes a scancode table
113 * @rc_map: the rc_map to initialize
114 * @name: name to assign to the table
115 * @rc_type: ir type to assign to the new table
116 * @size: initial size of the table
117 * @return: zero on success or a negative error code
119 * This routine will initialize the rc_map and will allocate
120 * memory to hold at least the specified number of elements.
122 static int ir_create_table(struct rc_map *rc_map,
123 const char *name, u64 rc_type, size_t size)
126 rc_map->rc_type = rc_type;
127 rc_map->alloc = roundup_pow_of_two(size * sizeof(struct rc_map_table));
128 rc_map->size = rc_map->alloc / sizeof(struct rc_map_table);
129 rc_map->scan = kmalloc(rc_map->alloc, GFP_KERNEL);
133 IR_dprintk(1, "Allocated space for %u keycode entries (%u bytes)\n",
134 rc_map->size, rc_map->alloc);
139 * ir_free_table() - frees memory allocated by a scancode table
140 * @rc_map: the table whose mappings need to be freed
142 * This routine will free memory alloctaed for key mappings used by given
145 static void ir_free_table(struct rc_map *rc_map)
153 * ir_resize_table() - resizes a scancode table if necessary
154 * @rc_map: the rc_map to resize
155 * @gfp_flags: gfp flags to use when allocating memory
156 * @return: zero on success or a negative error code
158 * This routine will shrink the rc_map if it has lots of
159 * unused entries and grow it if it is full.
161 static int ir_resize_table(struct rc_map *rc_map, gfp_t gfp_flags)
163 unsigned int oldalloc = rc_map->alloc;
164 unsigned int newalloc = oldalloc;
165 struct rc_map_table *oldscan = rc_map->scan;
166 struct rc_map_table *newscan;
168 if (rc_map->size == rc_map->len) {
169 /* All entries in use -> grow keytable */
170 if (rc_map->alloc >= IR_TAB_MAX_SIZE)
174 IR_dprintk(1, "Growing table to %u bytes\n", newalloc);
177 if ((rc_map->len * 3 < rc_map->size) && (oldalloc > IR_TAB_MIN_SIZE)) {
178 /* Less than 1/3 of entries in use -> shrink keytable */
180 IR_dprintk(1, "Shrinking table to %u bytes\n", newalloc);
183 if (newalloc == oldalloc)
186 newscan = kmalloc(newalloc, gfp_flags);
188 IR_dprintk(1, "Failed to kmalloc %u bytes\n", newalloc);
192 memcpy(newscan, rc_map->scan, rc_map->len * sizeof(struct rc_map_table));
193 rc_map->scan = newscan;
194 rc_map->alloc = newalloc;
195 rc_map->size = rc_map->alloc / sizeof(struct rc_map_table);
201 * ir_update_mapping() - set a keycode in the scancode->keycode table
202 * @dev: the struct rc_dev device descriptor
203 * @rc_map: scancode table to be adjusted
204 * @index: index of the mapping that needs to be updated
205 * @keycode: the desired keycode
206 * @return: previous keycode assigned to the mapping
208 * This routine is used to update scancode->keycode mapping at given
211 static unsigned int ir_update_mapping(struct rc_dev *dev,
212 struct rc_map *rc_map,
214 unsigned int new_keycode)
216 int old_keycode = rc_map->scan[index].keycode;
219 /* Did the user wish to remove the mapping? */
220 if (new_keycode == KEY_RESERVED || new_keycode == KEY_UNKNOWN) {
221 IR_dprintk(1, "#%d: Deleting scan 0x%04x\n",
222 index, rc_map->scan[index].scancode);
224 memmove(&rc_map->scan[index], &rc_map->scan[index+ 1],
225 (rc_map->len - index) * sizeof(struct rc_map_table));
227 IR_dprintk(1, "#%d: %s scan 0x%04x with key 0x%04x\n",
229 old_keycode == KEY_RESERVED ? "New" : "Replacing",
230 rc_map->scan[index].scancode, new_keycode);
231 rc_map->scan[index].keycode = new_keycode;
232 __set_bit(new_keycode, dev->input_dev->keybit);
235 if (old_keycode != KEY_RESERVED) {
236 /* A previous mapping was updated... */
237 __clear_bit(old_keycode, dev->input_dev->keybit);
238 /* ... but another scancode might use the same keycode */
239 for (i = 0; i < rc_map->len; i++) {
240 if (rc_map->scan[i].keycode == old_keycode) {
241 __set_bit(old_keycode, dev->input_dev->keybit);
246 /* Possibly shrink the keytable, failure is not a problem */
247 ir_resize_table(rc_map, GFP_ATOMIC);
254 * ir_establish_scancode() - set a keycode in the scancode->keycode table
255 * @dev: the struct rc_dev device descriptor
256 * @rc_map: scancode table to be searched
257 * @scancode: the desired scancode
258 * @resize: controls whether we allowed to resize the table to
259 * accommodate not yet present scancodes
260 * @return: index of the mapping containing scancode in question
261 * or -1U in case of failure.
263 * This routine is used to locate given scancode in rc_map.
264 * If scancode is not yet present the routine will allocate a new slot
267 static unsigned int ir_establish_scancode(struct rc_dev *dev,
268 struct rc_map *rc_map,
269 unsigned int scancode,
275 * Unfortunately, some hardware-based IR decoders don't provide
276 * all bits for the complete IR code. In general, they provide only
277 * the command part of the IR code. Yet, as it is possible to replace
278 * the provided IR with another one, it is needed to allow loading
279 * IR tables from other remotes. So, we support specifying a mask to
280 * indicate the valid bits of the scancodes.
283 scancode &= dev->scanmask;
285 /* First check if we already have a mapping for this ir command */
286 for (i = 0; i < rc_map->len; i++) {
287 if (rc_map->scan[i].scancode == scancode)
290 /* Keytable is sorted from lowest to highest scancode */
291 if (rc_map->scan[i].scancode >= scancode)
295 /* No previous mapping found, we might need to grow the table */
296 if (rc_map->size == rc_map->len) {
297 if (!resize || ir_resize_table(rc_map, GFP_ATOMIC))
301 /* i is the proper index to insert our new keycode */
303 memmove(&rc_map->scan[i + 1], &rc_map->scan[i],
304 (rc_map->len - i) * sizeof(struct rc_map_table));
305 rc_map->scan[i].scancode = scancode;
306 rc_map->scan[i].keycode = KEY_RESERVED;
313 * ir_setkeycode() - set a keycode in the scancode->keycode table
314 * @idev: the struct input_dev device descriptor
315 * @scancode: the desired scancode
317 * @return: -EINVAL if the keycode could not be inserted, otherwise zero.
319 * This routine is used to handle evdev EVIOCSKEY ioctl.
321 static int ir_setkeycode(struct input_dev *idev,
322 const struct input_keymap_entry *ke,
323 unsigned int *old_keycode)
325 struct rc_dev *rdev = input_get_drvdata(idev);
326 struct rc_map *rc_map = &rdev->rc_map;
328 unsigned int scancode;
332 spin_lock_irqsave(&rc_map->lock, flags);
334 if (ke->flags & INPUT_KEYMAP_BY_INDEX) {
336 if (index >= rc_map->len) {
341 retval = input_scancode_to_scalar(ke, &scancode);
345 index = ir_establish_scancode(rdev, rc_map, scancode, true);
346 if (index >= rc_map->len) {
352 *old_keycode = ir_update_mapping(rdev, rc_map, index, ke->keycode);
355 spin_unlock_irqrestore(&rc_map->lock, flags);
360 * ir_setkeytable() - sets several entries in the scancode->keycode table
361 * @dev: the struct rc_dev device descriptor
362 * @to: the struct rc_map to copy entries to
363 * @from: the struct rc_map to copy entries from
364 * @return: -ENOMEM if all keycodes could not be inserted, otherwise zero.
366 * This routine is used to handle table initialization.
368 static int ir_setkeytable(struct rc_dev *dev,
369 const struct rc_map *from)
371 struct rc_map *rc_map = &dev->rc_map;
372 unsigned int i, index;
375 rc = ir_create_table(rc_map, from->name,
376 from->rc_type, from->size);
380 IR_dprintk(1, "Allocated space for %u keycode entries (%u bytes)\n",
381 rc_map->size, rc_map->alloc);
383 for (i = 0; i < from->size; i++) {
384 index = ir_establish_scancode(dev, rc_map,
385 from->scan[i].scancode, false);
386 if (index >= rc_map->len) {
391 ir_update_mapping(dev, rc_map, index,
392 from->scan[i].keycode);
396 ir_free_table(rc_map);
402 * ir_lookup_by_scancode() - locate mapping by scancode
403 * @rc_map: the struct rc_map to search
404 * @scancode: scancode to look for in the table
405 * @return: index in the table, -1U if not found
407 * This routine performs binary search in RC keykeymap table for
410 static unsigned int ir_lookup_by_scancode(const struct rc_map *rc_map,
411 unsigned int scancode)
414 int end = rc_map->len - 1;
417 while (start <= end) {
418 mid = (start + end) / 2;
419 if (rc_map->scan[mid].scancode < scancode)
421 else if (rc_map->scan[mid].scancode > scancode)
431 * ir_getkeycode() - get a keycode from the scancode->keycode table
432 * @idev: the struct input_dev device descriptor
433 * @scancode: the desired scancode
434 * @keycode: used to return the keycode, if found, or KEY_RESERVED
435 * @return: always returns zero.
437 * This routine is used to handle evdev EVIOCGKEY ioctl.
439 static int ir_getkeycode(struct input_dev *idev,
440 struct input_keymap_entry *ke)
442 struct rc_dev *rdev = input_get_drvdata(idev);
443 struct rc_map *rc_map = &rdev->rc_map;
444 struct rc_map_table *entry;
447 unsigned int scancode;
450 spin_lock_irqsave(&rc_map->lock, flags);
452 if (ke->flags & INPUT_KEYMAP_BY_INDEX) {
455 retval = input_scancode_to_scalar(ke, &scancode);
459 index = ir_lookup_by_scancode(rc_map, scancode);
462 if (index < rc_map->len) {
463 entry = &rc_map->scan[index];
466 ke->keycode = entry->keycode;
467 ke->len = sizeof(entry->scancode);
468 memcpy(ke->scancode, &entry->scancode, sizeof(entry->scancode));
470 } else if (!(ke->flags & INPUT_KEYMAP_BY_INDEX)) {
472 * We do not really know the valid range of scancodes
473 * so let's respond with KEY_RESERVED to anything we
474 * do not have mapping for [yet].
477 ke->keycode = KEY_RESERVED;
486 spin_unlock_irqrestore(&rc_map->lock, flags);
491 * rc_g_keycode_from_table() - gets the keycode that corresponds to a scancode
492 * @dev: the struct rc_dev descriptor of the device
493 * @scancode: the scancode to look for
494 * @return: the corresponding keycode, or KEY_RESERVED
496 * This routine is used by drivers which need to convert a scancode to a
497 * keycode. Normally it should not be used since drivers should have no
498 * interest in keycodes.
500 u32 rc_g_keycode_from_table(struct rc_dev *dev, u32 scancode)
502 struct rc_map *rc_map = &dev->rc_map;
503 unsigned int keycode;
507 spin_lock_irqsave(&rc_map->lock, flags);
509 index = ir_lookup_by_scancode(rc_map, scancode);
510 keycode = index < rc_map->len ?
511 rc_map->scan[index].keycode : KEY_RESERVED;
513 spin_unlock_irqrestore(&rc_map->lock, flags);
515 if (keycode != KEY_RESERVED)
516 IR_dprintk(1, "%s: scancode 0x%04x keycode 0x%02x\n",
517 dev->input_name, scancode, keycode);
521 EXPORT_SYMBOL_GPL(rc_g_keycode_from_table);
524 * ir_do_keyup() - internal function to signal the release of a keypress
525 * @dev: the struct rc_dev descriptor of the device
526 * @sync: whether or not to call input_sync
528 * This function is used internally to release a keypress, it must be
529 * called with keylock held.
531 static void ir_do_keyup(struct rc_dev *dev, bool sync)
533 if (!dev->keypressed)
536 IR_dprintk(1, "keyup key 0x%04x\n", dev->last_keycode);
537 input_report_key(dev->input_dev, dev->last_keycode, 0);
539 input_sync(dev->input_dev);
540 dev->keypressed = false;
544 * rc_keyup() - signals the release of a keypress
545 * @dev: the struct rc_dev descriptor of the device
547 * This routine is used to signal that a key has been released on the
550 void rc_keyup(struct rc_dev *dev)
554 spin_lock_irqsave(&dev->keylock, flags);
555 ir_do_keyup(dev, true);
556 spin_unlock_irqrestore(&dev->keylock, flags);
558 EXPORT_SYMBOL_GPL(rc_keyup);
561 * ir_timer_keyup() - generates a keyup event after a timeout
562 * @cookie: a pointer to the struct rc_dev for the device
564 * This routine will generate a keyup event some time after a keydown event
565 * is generated when no further activity has been detected.
567 static void ir_timer_keyup(unsigned long cookie)
569 struct rc_dev *dev = (struct rc_dev *)cookie;
573 * ir->keyup_jiffies is used to prevent a race condition if a
574 * hardware interrupt occurs at this point and the keyup timer
575 * event is moved further into the future as a result.
577 * The timer will then be reactivated and this function called
578 * again in the future. We need to exit gracefully in that case
579 * to allow the input subsystem to do its auto-repeat magic or
580 * a keyup event might follow immediately after the keydown.
582 spin_lock_irqsave(&dev->keylock, flags);
583 if (time_is_before_eq_jiffies(dev->keyup_jiffies))
584 ir_do_keyup(dev, true);
585 spin_unlock_irqrestore(&dev->keylock, flags);
589 * rc_repeat() - signals that a key is still pressed
590 * @dev: the struct rc_dev descriptor of the device
592 * This routine is used by IR decoders when a repeat message which does
593 * not include the necessary bits to reproduce the scancode has been
596 void rc_repeat(struct rc_dev *dev)
600 spin_lock_irqsave(&dev->keylock, flags);
602 input_event(dev->input_dev, EV_MSC, MSC_SCAN, dev->last_scancode);
603 input_sync(dev->input_dev);
605 if (!dev->keypressed)
608 dev->keyup_jiffies = jiffies + msecs_to_jiffies(IR_KEYPRESS_TIMEOUT);
609 mod_timer(&dev->timer_keyup, dev->keyup_jiffies);
612 spin_unlock_irqrestore(&dev->keylock, flags);
614 EXPORT_SYMBOL_GPL(rc_repeat);
617 * ir_do_keydown() - internal function to process a keypress
618 * @dev: the struct rc_dev descriptor of the device
619 * @scancode: the scancode of the keypress
620 * @keycode: the keycode of the keypress
621 * @toggle: the toggle value of the keypress
623 * This function is used internally to register a keypress, it must be
624 * called with keylock held.
626 static void ir_do_keydown(struct rc_dev *dev, int scancode,
627 u32 keycode, u8 toggle)
629 bool new_event = !dev->keypressed ||
630 dev->last_scancode != scancode ||
631 dev->last_toggle != toggle;
633 if (new_event && dev->keypressed)
634 ir_do_keyup(dev, false);
636 input_event(dev->input_dev, EV_MSC, MSC_SCAN, scancode);
638 if (new_event && keycode != KEY_RESERVED) {
639 /* Register a keypress */
640 dev->keypressed = true;
641 dev->last_scancode = scancode;
642 dev->last_toggle = toggle;
643 dev->last_keycode = keycode;
645 IR_dprintk(1, "%s: key down event, "
646 "key 0x%04x, scancode 0x%04x\n",
647 dev->input_name, keycode, scancode);
648 input_report_key(dev->input_dev, keycode, 1);
651 input_sync(dev->input_dev);
655 * rc_keydown() - generates input event for a key press
656 * @dev: the struct rc_dev descriptor of the device
657 * @scancode: the scancode that we're seeking
658 * @toggle: the toggle value (protocol dependent, if the protocol doesn't
659 * support toggle values, this should be set to zero)
661 * This routine is used to signal that a key has been pressed on the
664 void rc_keydown(struct rc_dev *dev, int scancode, u8 toggle)
667 u32 keycode = rc_g_keycode_from_table(dev, scancode);
669 spin_lock_irqsave(&dev->keylock, flags);
670 ir_do_keydown(dev, scancode, keycode, toggle);
672 if (dev->keypressed) {
673 dev->keyup_jiffies = jiffies + msecs_to_jiffies(IR_KEYPRESS_TIMEOUT);
674 mod_timer(&dev->timer_keyup, dev->keyup_jiffies);
676 spin_unlock_irqrestore(&dev->keylock, flags);
678 EXPORT_SYMBOL_GPL(rc_keydown);
681 * rc_keydown_notimeout() - generates input event for a key press without
682 * an automatic keyup event at a later time
683 * @dev: the struct rc_dev descriptor of the device
684 * @scancode: the scancode that we're seeking
685 * @toggle: the toggle value (protocol dependent, if the protocol doesn't
686 * support toggle values, this should be set to zero)
688 * This routine is used to signal that a key has been pressed on the
689 * remote control. The driver must manually call rc_keyup() at a later stage.
691 void rc_keydown_notimeout(struct rc_dev *dev, int scancode, u8 toggle)
694 u32 keycode = rc_g_keycode_from_table(dev, scancode);
696 spin_lock_irqsave(&dev->keylock, flags);
697 ir_do_keydown(dev, scancode, keycode, toggle);
698 spin_unlock_irqrestore(&dev->keylock, flags);
700 EXPORT_SYMBOL_GPL(rc_keydown_notimeout);
702 static int ir_open(struct input_dev *idev)
704 struct rc_dev *rdev = input_get_drvdata(idev);
706 return rdev->open(rdev);
709 static void ir_close(struct input_dev *idev)
711 struct rc_dev *rdev = input_get_drvdata(idev);
717 /* class for /sys/class/rc */
718 static char *ir_devnode(struct device *dev, umode_t *mode)
720 return kasprintf(GFP_KERNEL, "rc/%s", dev_name(dev));
723 static struct class ir_input_class = {
725 .devnode = ir_devnode,
729 * These are the protocol textual descriptions that are
730 * used by the sysfs protocols file. Note that the order
731 * of the entries is relevant.
737 { RC_BIT_NONE, "none" },
738 { RC_BIT_OTHER, "other" },
739 { RC_BIT_UNKNOWN, "unknown" },
741 RC_BIT_RC5X, "rc-5" },
742 { RC_BIT_NEC, "nec" },
747 RC_BIT_RC6_MCE, "rc-6" },
748 { RC_BIT_JVC, "jvc" },
751 RC_BIT_SONY20, "sony" },
752 { RC_BIT_RC5_SZ, "rc-5-sz" },
753 { RC_BIT_SANYO, "sanyo" },
754 { RC_BIT_MCE_KBD, "mce_kbd" },
755 { RC_BIT_LIRC, "lirc" },
759 * show_protocols() - shows the current IR protocol(s)
760 * @device: the device descriptor
761 * @mattr: the device attribute struct (unused)
762 * @buf: a pointer to the output buffer
764 * This routine is a callback routine for input read the IR protocol type(s).
765 * it is trigged by reading /sys/class/rc/rc?/protocols.
766 * It returns the protocol names of supported protocols.
767 * Enabled protocols are printed in brackets.
769 * dev->lock is taken to guard against races between device
770 * registration, store_protocols and show_protocols.
772 static ssize_t show_protocols(struct device *device,
773 struct device_attribute *mattr, char *buf)
775 struct rc_dev *dev = to_rc_dev(device);
776 u64 allowed, enabled;
780 /* Device is being removed */
784 mutex_lock(&dev->lock);
786 if (dev->driver_type == RC_DRIVER_SCANCODE) {
787 enabled = dev->rc_map.rc_type;
788 allowed = dev->allowed_protos;
789 } else if (dev->raw) {
790 enabled = dev->raw->enabled_protocols;
791 allowed = ir_raw_get_allowed_protocols();
793 mutex_unlock(&dev->lock);
797 IR_dprintk(1, "allowed - 0x%llx, enabled - 0x%llx\n",
801 for (i = 0; i < ARRAY_SIZE(proto_names); i++) {
802 if (allowed & enabled & proto_names[i].type)
803 tmp += sprintf(tmp, "[%s] ", proto_names[i].name);
804 else if (allowed & proto_names[i].type)
805 tmp += sprintf(tmp, "%s ", proto_names[i].name);
807 if (allowed & proto_names[i].type)
808 allowed &= ~proto_names[i].type;
815 mutex_unlock(&dev->lock);
817 return tmp + 1 - buf;
821 * store_protocols() - changes the current IR protocol(s)
822 * @device: the device descriptor
823 * @mattr: the device attribute struct (unused)
824 * @buf: a pointer to the input buffer
825 * @len: length of the input buffer
827 * This routine is for changing the IR protocol type.
828 * It is trigged by writing to /sys/class/rc/rc?/protocols.
829 * Writing "+proto" will add a protocol to the list of enabled protocols.
830 * Writing "-proto" will remove a protocol from the list of enabled protocols.
831 * Writing "proto" will enable only "proto".
832 * Writing "none" will disable all protocols.
833 * Returns -EINVAL if an invalid protocol combination or unknown protocol name
834 * is used, otherwise @len.
836 * dev->lock is taken to guard against races between device
837 * registration, store_protocols and show_protocols.
839 static ssize_t store_protocols(struct device *device,
840 struct device_attribute *mattr,
844 struct rc_dev *dev = to_rc_dev(device);
845 bool enable, disable;
849 int rc, i, count = 0;
853 /* Device is being removed */
857 mutex_lock(&dev->lock);
859 if (dev->driver_type == RC_DRIVER_SCANCODE)
860 type = dev->rc_map.rc_type;
862 type = dev->raw->enabled_protocols;
864 IR_dprintk(1, "Protocol switching not supported\n");
869 while ((tmp = strsep((char **) &data, " \n")) != NULL) {
877 } else if (*tmp == '-') {
886 for (i = 0; i < ARRAY_SIZE(proto_names); i++) {
887 if (!strcasecmp(tmp, proto_names[i].name)) {
888 mask = proto_names[i].type;
893 if (i == ARRAY_SIZE(proto_names)) {
894 IR_dprintk(1, "Unknown protocol: '%s'\n", tmp);
909 IR_dprintk(1, "Protocol not specified\n");
914 if (dev->change_protocol) {
915 rc = dev->change_protocol(dev, &type);
917 IR_dprintk(1, "Error setting protocols to 0x%llx\n",
924 if (dev->driver_type == RC_DRIVER_SCANCODE) {
925 spin_lock_irqsave(&dev->rc_map.lock, flags);
926 dev->rc_map.rc_type = type;
927 spin_unlock_irqrestore(&dev->rc_map.lock, flags);
929 dev->raw->enabled_protocols = type;
932 IR_dprintk(1, "Current protocol(s): 0x%llx\n",
938 mutex_unlock(&dev->lock);
942 static void rc_dev_release(struct device *device)
946 #define ADD_HOTPLUG_VAR(fmt, val...) \
948 int err = add_uevent_var(env, fmt, val); \
953 static int rc_dev_uevent(struct device *device, struct kobj_uevent_env *env)
955 struct rc_dev *dev = to_rc_dev(device);
957 if (!dev || !dev->input_dev)
960 if (dev->rc_map.name)
961 ADD_HOTPLUG_VAR("NAME=%s", dev->rc_map.name);
962 if (dev->driver_name)
963 ADD_HOTPLUG_VAR("DRV_NAME=%s", dev->driver_name);
969 * Static device attribute struct with the sysfs attributes for IR's
971 static DEVICE_ATTR(protocols, S_IRUGO | S_IWUSR,
972 show_protocols, store_protocols);
974 static struct attribute *rc_dev_attrs[] = {
975 &dev_attr_protocols.attr,
979 static struct attribute_group rc_dev_attr_grp = {
980 .attrs = rc_dev_attrs,
983 static const struct attribute_group *rc_dev_attr_groups[] = {
988 static struct device_type rc_dev_type = {
989 .groups = rc_dev_attr_groups,
990 .release = rc_dev_release,
991 .uevent = rc_dev_uevent,
994 struct rc_dev *rc_allocate_device(void)
998 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1002 dev->input_dev = input_allocate_device();
1003 if (!dev->input_dev) {
1008 dev->input_dev->getkeycode = ir_getkeycode;
1009 dev->input_dev->setkeycode = ir_setkeycode;
1010 input_set_drvdata(dev->input_dev, dev);
1012 spin_lock_init(&dev->rc_map.lock);
1013 spin_lock_init(&dev->keylock);
1014 mutex_init(&dev->lock);
1015 setup_timer(&dev->timer_keyup, ir_timer_keyup, (unsigned long)dev);
1017 dev->dev.type = &rc_dev_type;
1018 dev->dev.class = &ir_input_class;
1019 device_initialize(&dev->dev);
1021 __module_get(THIS_MODULE);
1024 EXPORT_SYMBOL_GPL(rc_allocate_device);
1026 void rc_free_device(struct rc_dev *dev)
1032 input_free_device(dev->input_dev);
1034 put_device(&dev->dev);
1037 module_put(THIS_MODULE);
1039 EXPORT_SYMBOL_GPL(rc_free_device);
1041 int rc_register_device(struct rc_dev *dev)
1043 static bool raw_init = false; /* raw decoders loaded? */
1044 static atomic_t devno = ATOMIC_INIT(0);
1045 struct rc_map *rc_map;
1049 if (!dev || !dev->map_name)
1052 rc_map = rc_map_get(dev->map_name);
1054 rc_map = rc_map_get(RC_MAP_EMPTY);
1055 if (!rc_map || !rc_map->scan || rc_map->size == 0)
1058 set_bit(EV_KEY, dev->input_dev->evbit);
1059 set_bit(EV_REP, dev->input_dev->evbit);
1060 set_bit(EV_MSC, dev->input_dev->evbit);
1061 set_bit(MSC_SCAN, dev->input_dev->mscbit);
1063 dev->input_dev->open = ir_open;
1065 dev->input_dev->close = ir_close;
1068 * Take the lock here, as the device sysfs node will appear
1069 * when device_add() is called, which may trigger an ir-keytable udev
1070 * rule, which will in turn call show_protocols and access either
1071 * dev->rc_map.rc_type or dev->raw->enabled_protocols before it has
1074 mutex_lock(&dev->lock);
1076 dev->devno = (unsigned long)(atomic_inc_return(&devno) - 1);
1077 dev_set_name(&dev->dev, "rc%ld", dev->devno);
1078 dev_set_drvdata(&dev->dev, dev);
1079 rc = device_add(&dev->dev);
1083 rc = ir_setkeytable(dev, rc_map);
1087 dev->input_dev->dev.parent = &dev->dev;
1088 memcpy(&dev->input_dev->id, &dev->input_id, sizeof(dev->input_id));
1089 dev->input_dev->phys = dev->input_phys;
1090 dev->input_dev->name = dev->input_name;
1091 rc = input_register_device(dev->input_dev);
1096 * Default delay of 250ms is too short for some protocols, especially
1097 * since the timeout is currently set to 250ms. Increase it to 500ms,
1098 * to avoid wrong repetition of the keycodes. Note that this must be
1099 * set after the call to input_register_device().
1101 dev->input_dev->rep[REP_DELAY] = 500;
1104 * As a repeat event on protocols like RC-5 and NEC take as long as
1105 * 110/114ms, using 33ms as a repeat period is not the right thing
1108 dev->input_dev->rep[REP_PERIOD] = 125;
1110 path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);
1111 printk(KERN_INFO "%s: %s as %s\n",
1112 dev_name(&dev->dev),
1113 dev->input_name ? dev->input_name : "Unspecified device",
1114 path ? path : "N/A");
1117 if (dev->driver_type == RC_DRIVER_IR_RAW) {
1118 /* Load raw decoders, if they aren't already */
1120 IR_dprintk(1, "Loading raw decoders\n");
1124 rc = ir_raw_event_register(dev);
1129 if (dev->change_protocol) {
1130 u64 rc_type = (1 << rc_map->rc_type);
1131 rc = dev->change_protocol(dev, &rc_type);
1136 mutex_unlock(&dev->lock);
1138 IR_dprintk(1, "Registered rc%ld (driver: %s, remote: %s, mode %s)\n",
1140 dev->driver_name ? dev->driver_name : "unknown",
1141 rc_map->name ? rc_map->name : "unknown",
1142 dev->driver_type == RC_DRIVER_IR_RAW ? "raw" : "cooked");
1147 if (dev->driver_type == RC_DRIVER_IR_RAW)
1148 ir_raw_event_unregister(dev);
1150 input_unregister_device(dev->input_dev);
1151 dev->input_dev = NULL;
1153 ir_free_table(&dev->rc_map);
1155 device_del(&dev->dev);
1157 mutex_unlock(&dev->lock);
1160 EXPORT_SYMBOL_GPL(rc_register_device);
1162 void rc_unregister_device(struct rc_dev *dev)
1167 del_timer_sync(&dev->timer_keyup);
1169 if (dev->driver_type == RC_DRIVER_IR_RAW)
1170 ir_raw_event_unregister(dev);
1172 /* Freeing the table should also call the stop callback */
1173 ir_free_table(&dev->rc_map);
1174 IR_dprintk(1, "Freed keycode table\n");
1176 input_unregister_device(dev->input_dev);
1177 dev->input_dev = NULL;
1179 device_del(&dev->dev);
1181 rc_free_device(dev);
1184 EXPORT_SYMBOL_GPL(rc_unregister_device);
1187 * Init/exit code for the module. Basically, creates/removes /sys/class/rc
1190 static int __init rc_core_init(void)
1192 int rc = class_register(&ir_input_class);
1194 printk(KERN_ERR "rc_core: unable to register rc class\n");
1198 rc_map_register(&empty_map);
1203 static void __exit rc_core_exit(void)
1205 class_unregister(&ir_input_class);
1206 rc_map_unregister(&empty_map);
1209 module_init(rc_core_init);
1210 module_exit(rc_core_exit);
1212 int rc_core_debug; /* ir_debug level (0,1,2) */
1213 EXPORT_SYMBOL_GPL(rc_core_debug);
1214 module_param_named(debug, rc_core_debug, int, 0644);
1216 MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@redhat.com>");
1217 MODULE_LICENSE("GPL");