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/leds.h>
20 #include <linux/slab.h>
21 #include <linux/device.h>
22 #include <linux/module.h>
23 #include "rc-core-priv.h"
25 /* Sizes are in bytes, 256 bytes allows for 32 entries on x64 */
26 #define IR_TAB_MIN_SIZE 256
27 #define IR_TAB_MAX_SIZE 8192
29 /* FIXME: IR_KEYPRESS_TIMEOUT should be protocol specific */
30 #define IR_KEYPRESS_TIMEOUT 250
32 /* Used to keep track of known keymaps */
33 static LIST_HEAD(rc_map_list);
34 static DEFINE_SPINLOCK(rc_map_lock);
35 static struct led_trigger *led_feedback;
37 static struct rc_map_list *seek_rc_map(const char *name)
39 struct rc_map_list *map = NULL;
41 spin_lock(&rc_map_lock);
42 list_for_each_entry(map, &rc_map_list, list) {
43 if (!strcmp(name, map->map.name)) {
44 spin_unlock(&rc_map_lock);
48 spin_unlock(&rc_map_lock);
53 struct rc_map *rc_map_get(const char *name)
56 struct rc_map_list *map;
58 map = seek_rc_map(name);
61 int rc = request_module(name);
63 printk(KERN_ERR "Couldn't load IR keymap %s\n", name);
66 msleep(20); /* Give some time for IR to register */
68 map = seek_rc_map(name);
72 printk(KERN_ERR "IR keymap %s not found\n", name);
76 printk(KERN_INFO "Registered IR keymap %s\n", map->map.name);
80 EXPORT_SYMBOL_GPL(rc_map_get);
82 int rc_map_register(struct rc_map_list *map)
84 spin_lock(&rc_map_lock);
85 list_add_tail(&map->list, &rc_map_list);
86 spin_unlock(&rc_map_lock);
89 EXPORT_SYMBOL_GPL(rc_map_register);
91 void rc_map_unregister(struct rc_map_list *map)
93 spin_lock(&rc_map_lock);
95 spin_unlock(&rc_map_lock);
97 EXPORT_SYMBOL_GPL(rc_map_unregister);
100 static struct rc_map_table empty[] = {
101 { 0x2a, KEY_COFFEE },
104 static struct rc_map_list empty_map = {
107 .size = ARRAY_SIZE(empty),
108 .rc_type = RC_TYPE_UNKNOWN, /* Legacy IR type */
109 .name = RC_MAP_EMPTY,
114 * ir_create_table() - initializes a scancode table
115 * @rc_map: the rc_map to initialize
116 * @name: name to assign to the table
117 * @rc_type: ir type to assign to the new table
118 * @size: initial size of the table
119 * @return: zero on success or a negative error code
121 * This routine will initialize the rc_map and will allocate
122 * memory to hold at least the specified number of elements.
124 static int ir_create_table(struct rc_map *rc_map,
125 const char *name, u64 rc_type, size_t size)
128 rc_map->rc_type = rc_type;
129 rc_map->alloc = roundup_pow_of_two(size * sizeof(struct rc_map_table));
130 rc_map->size = rc_map->alloc / sizeof(struct rc_map_table);
131 rc_map->scan = kmalloc(rc_map->alloc, GFP_KERNEL);
135 IR_dprintk(1, "Allocated space for %u keycode entries (%u bytes)\n",
136 rc_map->size, rc_map->alloc);
141 * ir_free_table() - frees memory allocated by a scancode table
142 * @rc_map: the table whose mappings need to be freed
144 * This routine will free memory alloctaed for key mappings used by given
147 static void ir_free_table(struct rc_map *rc_map)
155 * ir_resize_table() - resizes a scancode table if necessary
156 * @rc_map: the rc_map to resize
157 * @gfp_flags: gfp flags to use when allocating memory
158 * @return: zero on success or a negative error code
160 * This routine will shrink the rc_map if it has lots of
161 * unused entries and grow it if it is full.
163 static int ir_resize_table(struct rc_map *rc_map, gfp_t gfp_flags)
165 unsigned int oldalloc = rc_map->alloc;
166 unsigned int newalloc = oldalloc;
167 struct rc_map_table *oldscan = rc_map->scan;
168 struct rc_map_table *newscan;
170 if (rc_map->size == rc_map->len) {
171 /* All entries in use -> grow keytable */
172 if (rc_map->alloc >= IR_TAB_MAX_SIZE)
176 IR_dprintk(1, "Growing table to %u bytes\n", newalloc);
179 if ((rc_map->len * 3 < rc_map->size) && (oldalloc > IR_TAB_MIN_SIZE)) {
180 /* Less than 1/3 of entries in use -> shrink keytable */
182 IR_dprintk(1, "Shrinking table to %u bytes\n", newalloc);
185 if (newalloc == oldalloc)
188 newscan = kmalloc(newalloc, gfp_flags);
190 IR_dprintk(1, "Failed to kmalloc %u bytes\n", newalloc);
194 memcpy(newscan, rc_map->scan, rc_map->len * sizeof(struct rc_map_table));
195 rc_map->scan = newscan;
196 rc_map->alloc = newalloc;
197 rc_map->size = rc_map->alloc / sizeof(struct rc_map_table);
203 * ir_update_mapping() - set a keycode in the scancode->keycode table
204 * @dev: the struct rc_dev device descriptor
205 * @rc_map: scancode table to be adjusted
206 * @index: index of the mapping that needs to be updated
207 * @keycode: the desired keycode
208 * @return: previous keycode assigned to the mapping
210 * This routine is used to update scancode->keycode mapping at given
213 static unsigned int ir_update_mapping(struct rc_dev *dev,
214 struct rc_map *rc_map,
216 unsigned int new_keycode)
218 int old_keycode = rc_map->scan[index].keycode;
221 /* Did the user wish to remove the mapping? */
222 if (new_keycode == KEY_RESERVED || new_keycode == KEY_UNKNOWN) {
223 IR_dprintk(1, "#%d: Deleting scan 0x%04x\n",
224 index, rc_map->scan[index].scancode);
226 memmove(&rc_map->scan[index], &rc_map->scan[index+ 1],
227 (rc_map->len - index) * sizeof(struct rc_map_table));
229 IR_dprintk(1, "#%d: %s scan 0x%04x with key 0x%04x\n",
231 old_keycode == KEY_RESERVED ? "New" : "Replacing",
232 rc_map->scan[index].scancode, new_keycode);
233 rc_map->scan[index].keycode = new_keycode;
234 __set_bit(new_keycode, dev->input_dev->keybit);
237 if (old_keycode != KEY_RESERVED) {
238 /* A previous mapping was updated... */
239 __clear_bit(old_keycode, dev->input_dev->keybit);
240 /* ... but another scancode might use the same keycode */
241 for (i = 0; i < rc_map->len; i++) {
242 if (rc_map->scan[i].keycode == old_keycode) {
243 __set_bit(old_keycode, dev->input_dev->keybit);
248 /* Possibly shrink the keytable, failure is not a problem */
249 ir_resize_table(rc_map, GFP_ATOMIC);
256 * ir_establish_scancode() - set a keycode in the scancode->keycode table
257 * @dev: the struct rc_dev device descriptor
258 * @rc_map: scancode table to be searched
259 * @scancode: the desired scancode
260 * @resize: controls whether we allowed to resize the table to
261 * accommodate not yet present scancodes
262 * @return: index of the mapping containing scancode in question
263 * or -1U in case of failure.
265 * This routine is used to locate given scancode in rc_map.
266 * If scancode is not yet present the routine will allocate a new slot
269 static unsigned int ir_establish_scancode(struct rc_dev *dev,
270 struct rc_map *rc_map,
271 unsigned int scancode,
277 * Unfortunately, some hardware-based IR decoders don't provide
278 * all bits for the complete IR code. In general, they provide only
279 * the command part of the IR code. Yet, as it is possible to replace
280 * the provided IR with another one, it is needed to allow loading
281 * IR tables from other remotes. So, we support specifying a mask to
282 * indicate the valid bits of the scancodes.
285 scancode &= dev->scanmask;
287 /* First check if we already have a mapping for this ir command */
288 for (i = 0; i < rc_map->len; i++) {
289 if (rc_map->scan[i].scancode == scancode)
292 /* Keytable is sorted from lowest to highest scancode */
293 if (rc_map->scan[i].scancode >= scancode)
297 /* No previous mapping found, we might need to grow the table */
298 if (rc_map->size == rc_map->len) {
299 if (!resize || ir_resize_table(rc_map, GFP_ATOMIC))
303 /* i is the proper index to insert our new keycode */
305 memmove(&rc_map->scan[i + 1], &rc_map->scan[i],
306 (rc_map->len - i) * sizeof(struct rc_map_table));
307 rc_map->scan[i].scancode = scancode;
308 rc_map->scan[i].keycode = KEY_RESERVED;
315 * ir_setkeycode() - set a keycode in the scancode->keycode table
316 * @idev: the struct input_dev device descriptor
317 * @scancode: the desired scancode
319 * @return: -EINVAL if the keycode could not be inserted, otherwise zero.
321 * This routine is used to handle evdev EVIOCSKEY ioctl.
323 static int ir_setkeycode(struct input_dev *idev,
324 const struct input_keymap_entry *ke,
325 unsigned int *old_keycode)
327 struct rc_dev *rdev = input_get_drvdata(idev);
328 struct rc_map *rc_map = &rdev->rc_map;
330 unsigned int scancode;
334 spin_lock_irqsave(&rc_map->lock, flags);
336 if (ke->flags & INPUT_KEYMAP_BY_INDEX) {
338 if (index >= rc_map->len) {
343 retval = input_scancode_to_scalar(ke, &scancode);
347 index = ir_establish_scancode(rdev, rc_map, scancode, true);
348 if (index >= rc_map->len) {
354 *old_keycode = ir_update_mapping(rdev, rc_map, index, ke->keycode);
357 spin_unlock_irqrestore(&rc_map->lock, flags);
362 * ir_setkeytable() - sets several entries in the scancode->keycode table
363 * @dev: the struct rc_dev device descriptor
364 * @to: the struct rc_map to copy entries to
365 * @from: the struct rc_map to copy entries from
366 * @return: -ENOMEM if all keycodes could not be inserted, otherwise zero.
368 * This routine is used to handle table initialization.
370 static int ir_setkeytable(struct rc_dev *dev,
371 const struct rc_map *from)
373 struct rc_map *rc_map = &dev->rc_map;
374 unsigned int i, index;
377 rc = ir_create_table(rc_map, from->name,
378 from->rc_type, from->size);
382 IR_dprintk(1, "Allocated space for %u keycode entries (%u bytes)\n",
383 rc_map->size, rc_map->alloc);
385 for (i = 0; i < from->size; i++) {
386 index = ir_establish_scancode(dev, rc_map,
387 from->scan[i].scancode, false);
388 if (index >= rc_map->len) {
393 ir_update_mapping(dev, rc_map, index,
394 from->scan[i].keycode);
398 ir_free_table(rc_map);
404 * ir_lookup_by_scancode() - locate mapping by scancode
405 * @rc_map: the struct rc_map to search
406 * @scancode: scancode to look for in the table
407 * @return: index in the table, -1U if not found
409 * This routine performs binary search in RC keykeymap table for
412 static unsigned int ir_lookup_by_scancode(const struct rc_map *rc_map,
413 unsigned int scancode)
416 int end = rc_map->len - 1;
419 while (start <= end) {
420 mid = (start + end) / 2;
421 if (rc_map->scan[mid].scancode < scancode)
423 else if (rc_map->scan[mid].scancode > scancode)
433 * ir_getkeycode() - get a keycode from the scancode->keycode table
434 * @idev: the struct input_dev device descriptor
435 * @scancode: the desired scancode
436 * @keycode: used to return the keycode, if found, or KEY_RESERVED
437 * @return: always returns zero.
439 * This routine is used to handle evdev EVIOCGKEY ioctl.
441 static int ir_getkeycode(struct input_dev *idev,
442 struct input_keymap_entry *ke)
444 struct rc_dev *rdev = input_get_drvdata(idev);
445 struct rc_map *rc_map = &rdev->rc_map;
446 struct rc_map_table *entry;
449 unsigned int scancode;
452 spin_lock_irqsave(&rc_map->lock, flags);
454 if (ke->flags & INPUT_KEYMAP_BY_INDEX) {
457 retval = input_scancode_to_scalar(ke, &scancode);
461 index = ir_lookup_by_scancode(rc_map, scancode);
464 if (index < rc_map->len) {
465 entry = &rc_map->scan[index];
468 ke->keycode = entry->keycode;
469 ke->len = sizeof(entry->scancode);
470 memcpy(ke->scancode, &entry->scancode, sizeof(entry->scancode));
472 } else if (!(ke->flags & INPUT_KEYMAP_BY_INDEX)) {
474 * We do not really know the valid range of scancodes
475 * so let's respond with KEY_RESERVED to anything we
476 * do not have mapping for [yet].
479 ke->keycode = KEY_RESERVED;
488 spin_unlock_irqrestore(&rc_map->lock, flags);
493 * rc_g_keycode_from_table() - gets the keycode that corresponds to a scancode
494 * @dev: the struct rc_dev descriptor of the device
495 * @scancode: the scancode to look for
496 * @return: the corresponding keycode, or KEY_RESERVED
498 * This routine is used by drivers which need to convert a scancode to a
499 * keycode. Normally it should not be used since drivers should have no
500 * interest in keycodes.
502 u32 rc_g_keycode_from_table(struct rc_dev *dev, u32 scancode)
504 struct rc_map *rc_map = &dev->rc_map;
505 unsigned int keycode;
509 spin_lock_irqsave(&rc_map->lock, flags);
511 index = ir_lookup_by_scancode(rc_map, scancode);
512 keycode = index < rc_map->len ?
513 rc_map->scan[index].keycode : KEY_RESERVED;
515 spin_unlock_irqrestore(&rc_map->lock, flags);
517 if (keycode != KEY_RESERVED)
518 IR_dprintk(1, "%s: scancode 0x%04x keycode 0x%02x\n",
519 dev->input_name, scancode, keycode);
523 EXPORT_SYMBOL_GPL(rc_g_keycode_from_table);
526 * ir_do_keyup() - internal function to signal the release of a keypress
527 * @dev: the struct rc_dev descriptor of the device
528 * @sync: whether or not to call input_sync
530 * This function is used internally to release a keypress, it must be
531 * called with keylock held.
533 static void ir_do_keyup(struct rc_dev *dev, bool sync)
535 if (!dev->keypressed)
538 IR_dprintk(1, "keyup key 0x%04x\n", dev->last_keycode);
539 input_report_key(dev->input_dev, dev->last_keycode, 0);
540 led_trigger_event(led_feedback, LED_OFF);
542 input_sync(dev->input_dev);
543 dev->keypressed = false;
547 * rc_keyup() - signals the release of a keypress
548 * @dev: the struct rc_dev descriptor of the device
550 * This routine is used to signal that a key has been released on the
553 void rc_keyup(struct rc_dev *dev)
557 spin_lock_irqsave(&dev->keylock, flags);
558 ir_do_keyup(dev, true);
559 spin_unlock_irqrestore(&dev->keylock, flags);
561 EXPORT_SYMBOL_GPL(rc_keyup);
564 * ir_timer_keyup() - generates a keyup event after a timeout
565 * @cookie: a pointer to the struct rc_dev for the device
567 * This routine will generate a keyup event some time after a keydown event
568 * is generated when no further activity has been detected.
570 static void ir_timer_keyup(unsigned long cookie)
572 struct rc_dev *dev = (struct rc_dev *)cookie;
576 * ir->keyup_jiffies is used to prevent a race condition if a
577 * hardware interrupt occurs at this point and the keyup timer
578 * event is moved further into the future as a result.
580 * The timer will then be reactivated and this function called
581 * again in the future. We need to exit gracefully in that case
582 * to allow the input subsystem to do its auto-repeat magic or
583 * a keyup event might follow immediately after the keydown.
585 spin_lock_irqsave(&dev->keylock, flags);
586 if (time_is_before_eq_jiffies(dev->keyup_jiffies))
587 ir_do_keyup(dev, true);
588 spin_unlock_irqrestore(&dev->keylock, flags);
592 * rc_repeat() - signals that a key is still pressed
593 * @dev: the struct rc_dev descriptor of the device
595 * This routine is used by IR decoders when a repeat message which does
596 * not include the necessary bits to reproduce the scancode has been
599 void rc_repeat(struct rc_dev *dev)
603 spin_lock_irqsave(&dev->keylock, flags);
605 input_event(dev->input_dev, EV_MSC, MSC_SCAN, dev->last_scancode);
606 input_sync(dev->input_dev);
608 if (!dev->keypressed)
611 dev->keyup_jiffies = jiffies + msecs_to_jiffies(IR_KEYPRESS_TIMEOUT);
612 mod_timer(&dev->timer_keyup, dev->keyup_jiffies);
615 spin_unlock_irqrestore(&dev->keylock, flags);
617 EXPORT_SYMBOL_GPL(rc_repeat);
620 * ir_do_keydown() - internal function to process a keypress
621 * @dev: the struct rc_dev descriptor of the device
622 * @scancode: the scancode of the keypress
623 * @keycode: the keycode of the keypress
624 * @toggle: the toggle value of the keypress
626 * This function is used internally to register a keypress, it must be
627 * called with keylock held.
629 static void ir_do_keydown(struct rc_dev *dev, int scancode,
630 u32 keycode, u8 toggle)
632 bool new_event = !dev->keypressed ||
633 dev->last_scancode != scancode ||
634 dev->last_toggle != toggle;
636 if (new_event && dev->keypressed)
637 ir_do_keyup(dev, false);
639 input_event(dev->input_dev, EV_MSC, MSC_SCAN, scancode);
641 if (new_event && keycode != KEY_RESERVED) {
642 /* Register a keypress */
643 dev->keypressed = true;
644 dev->last_scancode = scancode;
645 dev->last_toggle = toggle;
646 dev->last_keycode = keycode;
648 IR_dprintk(1, "%s: key down event, "
649 "key 0x%04x, scancode 0x%04x\n",
650 dev->input_name, keycode, scancode);
651 input_report_key(dev->input_dev, keycode, 1);
654 led_trigger_event(led_feedback, LED_FULL);
655 input_sync(dev->input_dev);
659 * rc_keydown() - generates input event for a key press
660 * @dev: the struct rc_dev descriptor of the device
661 * @scancode: the scancode that we're seeking
662 * @toggle: the toggle value (protocol dependent, if the protocol doesn't
663 * support toggle values, this should be set to zero)
665 * This routine is used to signal that a key has been pressed on the
668 void rc_keydown(struct rc_dev *dev, int scancode, u8 toggle)
671 u32 keycode = rc_g_keycode_from_table(dev, scancode);
673 spin_lock_irqsave(&dev->keylock, flags);
674 ir_do_keydown(dev, scancode, keycode, toggle);
676 if (dev->keypressed) {
677 dev->keyup_jiffies = jiffies + msecs_to_jiffies(IR_KEYPRESS_TIMEOUT);
678 mod_timer(&dev->timer_keyup, dev->keyup_jiffies);
680 spin_unlock_irqrestore(&dev->keylock, flags);
682 EXPORT_SYMBOL_GPL(rc_keydown);
685 * rc_keydown_notimeout() - generates input event for a key press without
686 * an automatic keyup event at a later time
687 * @dev: the struct rc_dev descriptor of the device
688 * @scancode: the scancode that we're seeking
689 * @toggle: the toggle value (protocol dependent, if the protocol doesn't
690 * support toggle values, this should be set to zero)
692 * This routine is used to signal that a key has been pressed on the
693 * remote control. The driver must manually call rc_keyup() at a later stage.
695 void rc_keydown_notimeout(struct rc_dev *dev, int scancode, u8 toggle)
698 u32 keycode = rc_g_keycode_from_table(dev, scancode);
700 spin_lock_irqsave(&dev->keylock, flags);
701 ir_do_keydown(dev, scancode, keycode, toggle);
702 spin_unlock_irqrestore(&dev->keylock, flags);
704 EXPORT_SYMBOL_GPL(rc_keydown_notimeout);
706 int rc_open(struct rc_dev *rdev)
713 mutex_lock(&rdev->lock);
714 if (!rdev->users++ && rdev->open != NULL)
715 rval = rdev->open(rdev);
720 mutex_unlock(&rdev->lock);
724 EXPORT_SYMBOL_GPL(rc_open);
726 static int ir_open(struct input_dev *idev)
728 struct rc_dev *rdev = input_get_drvdata(idev);
730 return rc_open(rdev);
733 void rc_close(struct rc_dev *rdev)
736 mutex_lock(&rdev->lock);
738 if (!--rdev->users && rdev->close != NULL)
741 mutex_unlock(&rdev->lock);
744 EXPORT_SYMBOL_GPL(rc_close);
746 static void ir_close(struct input_dev *idev)
748 struct rc_dev *rdev = input_get_drvdata(idev);
752 /* class for /sys/class/rc */
753 static char *rc_devnode(struct device *dev, umode_t *mode)
755 return kasprintf(GFP_KERNEL, "rc/%s", dev_name(dev));
758 static struct class rc_class = {
760 .devnode = rc_devnode,
764 * These are the protocol textual descriptions that are
765 * used by the sysfs protocols file. Note that the order
766 * of the entries is relevant.
772 { RC_BIT_NONE, "none" },
773 { RC_BIT_OTHER, "other" },
774 { RC_BIT_UNKNOWN, "unknown" },
776 RC_BIT_RC5X, "rc-5" },
777 { RC_BIT_NEC, "nec" },
782 RC_BIT_RC6_MCE, "rc-6" },
783 { RC_BIT_JVC, "jvc" },
786 RC_BIT_SONY20, "sony" },
787 { RC_BIT_RC5_SZ, "rc-5-sz" },
788 { RC_BIT_SANYO, "sanyo" },
789 { RC_BIT_MCE_KBD, "mce_kbd" },
790 { RC_BIT_LIRC, "lirc" },
794 * show_protocols() - shows the current IR protocol(s)
795 * @device: the device descriptor
796 * @mattr: the device attribute struct (unused)
797 * @buf: a pointer to the output buffer
799 * This routine is a callback routine for input read the IR protocol type(s).
800 * it is trigged by reading /sys/class/rc/rc?/protocols.
801 * It returns the protocol names of supported protocols.
802 * Enabled protocols are printed in brackets.
804 * dev->lock is taken to guard against races between device
805 * registration, store_protocols and show_protocols.
807 static ssize_t show_protocols(struct device *device,
808 struct device_attribute *mattr, char *buf)
810 struct rc_dev *dev = to_rc_dev(device);
811 u64 allowed, enabled;
815 /* Device is being removed */
819 mutex_lock(&dev->lock);
821 enabled = dev->enabled_protocols;
822 if (dev->driver_type == RC_DRIVER_SCANCODE)
823 allowed = dev->allowed_protos;
825 allowed = ir_raw_get_allowed_protocols();
827 mutex_unlock(&dev->lock);
831 IR_dprintk(1, "allowed - 0x%llx, enabled - 0x%llx\n",
835 for (i = 0; i < ARRAY_SIZE(proto_names); i++) {
836 if (allowed & enabled & proto_names[i].type)
837 tmp += sprintf(tmp, "[%s] ", proto_names[i].name);
838 else if (allowed & proto_names[i].type)
839 tmp += sprintf(tmp, "%s ", proto_names[i].name);
841 if (allowed & proto_names[i].type)
842 allowed &= ~proto_names[i].type;
849 mutex_unlock(&dev->lock);
851 return tmp + 1 - buf;
855 * store_protocols() - changes the current IR protocol(s)
856 * @device: the device descriptor
857 * @mattr: the device attribute struct (unused)
858 * @buf: a pointer to the input buffer
859 * @len: length of the input buffer
861 * This routine is for changing the IR protocol type.
862 * It is trigged by writing to /sys/class/rc/rc?/protocols.
863 * Writing "+proto" will add a protocol to the list of enabled protocols.
864 * Writing "-proto" will remove a protocol from the list of enabled protocols.
865 * Writing "proto" will enable only "proto".
866 * Writing "none" will disable all protocols.
867 * Returns -EINVAL if an invalid protocol combination or unknown protocol name
868 * is used, otherwise @len.
870 * dev->lock is taken to guard against races between device
871 * registration, store_protocols and show_protocols.
873 static ssize_t store_protocols(struct device *device,
874 struct device_attribute *mattr,
878 struct rc_dev *dev = to_rc_dev(device);
879 bool enable, disable;
883 int rc, i, count = 0;
886 /* Device is being removed */
890 mutex_lock(&dev->lock);
892 if (dev->driver_type != RC_DRIVER_SCANCODE && !dev->raw) {
893 IR_dprintk(1, "Protocol switching not supported\n");
897 type = dev->enabled_protocols;
899 while ((tmp = strsep((char **) &data, " \n")) != NULL) {
907 } else if (*tmp == '-') {
916 for (i = 0; i < ARRAY_SIZE(proto_names); i++) {
917 if (!strcasecmp(tmp, proto_names[i].name)) {
918 mask = proto_names[i].type;
923 if (i == ARRAY_SIZE(proto_names)) {
924 IR_dprintk(1, "Unknown protocol: '%s'\n", tmp);
940 IR_dprintk(1, "Protocol not specified\n");
945 if (dev->change_protocol) {
946 rc = dev->change_protocol(dev, &type);
948 IR_dprintk(1, "Error setting protocols to 0x%llx\n",
955 dev->enabled_protocols = type;
956 IR_dprintk(1, "Current protocol(s): 0x%llx\n",
962 mutex_unlock(&dev->lock);
966 static void rc_dev_release(struct device *device)
970 #define ADD_HOTPLUG_VAR(fmt, val...) \
972 int err = add_uevent_var(env, fmt, val); \
977 static int rc_dev_uevent(struct device *device, struct kobj_uevent_env *env)
979 struct rc_dev *dev = to_rc_dev(device);
981 if (!dev || !dev->input_dev)
984 if (dev->rc_map.name)
985 ADD_HOTPLUG_VAR("NAME=%s", dev->rc_map.name);
986 if (dev->driver_name)
987 ADD_HOTPLUG_VAR("DRV_NAME=%s", dev->driver_name);
993 * Static device attribute struct with the sysfs attributes for IR's
995 static DEVICE_ATTR(protocols, S_IRUGO | S_IWUSR,
996 show_protocols, store_protocols);
998 static struct attribute *rc_dev_attrs[] = {
999 &dev_attr_protocols.attr,
1003 static struct attribute_group rc_dev_attr_grp = {
1004 .attrs = rc_dev_attrs,
1007 static const struct attribute_group *rc_dev_attr_groups[] = {
1012 static struct device_type rc_dev_type = {
1013 .groups = rc_dev_attr_groups,
1014 .release = rc_dev_release,
1015 .uevent = rc_dev_uevent,
1018 struct rc_dev *rc_allocate_device(void)
1022 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1026 dev->input_dev = input_allocate_device();
1027 if (!dev->input_dev) {
1032 dev->input_dev->getkeycode = ir_getkeycode;
1033 dev->input_dev->setkeycode = ir_setkeycode;
1034 input_set_drvdata(dev->input_dev, dev);
1036 spin_lock_init(&dev->rc_map.lock);
1037 spin_lock_init(&dev->keylock);
1038 mutex_init(&dev->lock);
1039 setup_timer(&dev->timer_keyup, ir_timer_keyup, (unsigned long)dev);
1041 dev->dev.type = &rc_dev_type;
1042 dev->dev.class = &rc_class;
1043 device_initialize(&dev->dev);
1045 __module_get(THIS_MODULE);
1048 EXPORT_SYMBOL_GPL(rc_allocate_device);
1050 void rc_free_device(struct rc_dev *dev)
1056 input_free_device(dev->input_dev);
1058 put_device(&dev->dev);
1061 module_put(THIS_MODULE);
1063 EXPORT_SYMBOL_GPL(rc_free_device);
1065 int rc_register_device(struct rc_dev *dev)
1067 static bool raw_init = false; /* raw decoders loaded? */
1068 static atomic_t devno = ATOMIC_INIT(0);
1069 struct rc_map *rc_map;
1073 if (!dev || !dev->map_name)
1076 rc_map = rc_map_get(dev->map_name);
1078 rc_map = rc_map_get(RC_MAP_EMPTY);
1079 if (!rc_map || !rc_map->scan || rc_map->size == 0)
1082 set_bit(EV_KEY, dev->input_dev->evbit);
1083 set_bit(EV_REP, dev->input_dev->evbit);
1084 set_bit(EV_MSC, dev->input_dev->evbit);
1085 set_bit(MSC_SCAN, dev->input_dev->mscbit);
1087 dev->input_dev->open = ir_open;
1089 dev->input_dev->close = ir_close;
1092 * Take the lock here, as the device sysfs node will appear
1093 * when device_add() is called, which may trigger an ir-keytable udev
1094 * rule, which will in turn call show_protocols and access
1095 * dev->enabled_protocols before it has been initialized.
1097 mutex_lock(&dev->lock);
1099 dev->devno = (unsigned long)(atomic_inc_return(&devno) - 1);
1100 dev_set_name(&dev->dev, "rc%ld", dev->devno);
1101 dev_set_drvdata(&dev->dev, dev);
1102 rc = device_add(&dev->dev);
1106 rc = ir_setkeytable(dev, rc_map);
1110 dev->input_dev->dev.parent = &dev->dev;
1111 memcpy(&dev->input_dev->id, &dev->input_id, sizeof(dev->input_id));
1112 dev->input_dev->phys = dev->input_phys;
1113 dev->input_dev->name = dev->input_name;
1115 /* input_register_device can call ir_open, so unlock mutex here */
1116 mutex_unlock(&dev->lock);
1118 rc = input_register_device(dev->input_dev);
1120 mutex_lock(&dev->lock);
1126 * Default delay of 250ms is too short for some protocols, especially
1127 * since the timeout is currently set to 250ms. Increase it to 500ms,
1128 * to avoid wrong repetition of the keycodes. Note that this must be
1129 * set after the call to input_register_device().
1131 dev->input_dev->rep[REP_DELAY] = 500;
1134 * As a repeat event on protocols like RC-5 and NEC take as long as
1135 * 110/114ms, using 33ms as a repeat period is not the right thing
1138 dev->input_dev->rep[REP_PERIOD] = 125;
1140 path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);
1141 printk(KERN_INFO "%s: %s as %s\n",
1142 dev_name(&dev->dev),
1143 dev->input_name ? dev->input_name : "Unspecified device",
1144 path ? path : "N/A");
1147 if (dev->driver_type == RC_DRIVER_IR_RAW) {
1148 /* Load raw decoders, if they aren't already */
1150 IR_dprintk(1, "Loading raw decoders\n");
1154 rc = ir_raw_event_register(dev);
1159 if (dev->change_protocol) {
1160 u64 rc_type = (1 << rc_map->rc_type);
1161 rc = dev->change_protocol(dev, &rc_type);
1164 dev->enabled_protocols = rc_type;
1167 mutex_unlock(&dev->lock);
1169 IR_dprintk(1, "Registered rc%ld (driver: %s, remote: %s, mode %s)\n",
1171 dev->driver_name ? dev->driver_name : "unknown",
1172 rc_map->name ? rc_map->name : "unknown",
1173 dev->driver_type == RC_DRIVER_IR_RAW ? "raw" : "cooked");
1178 if (dev->driver_type == RC_DRIVER_IR_RAW)
1179 ir_raw_event_unregister(dev);
1181 input_unregister_device(dev->input_dev);
1182 dev->input_dev = NULL;
1184 ir_free_table(&dev->rc_map);
1186 device_del(&dev->dev);
1188 mutex_unlock(&dev->lock);
1191 EXPORT_SYMBOL_GPL(rc_register_device);
1193 void rc_unregister_device(struct rc_dev *dev)
1198 del_timer_sync(&dev->timer_keyup);
1200 if (dev->driver_type == RC_DRIVER_IR_RAW)
1201 ir_raw_event_unregister(dev);
1203 /* Freeing the table should also call the stop callback */
1204 ir_free_table(&dev->rc_map);
1205 IR_dprintk(1, "Freed keycode table\n");
1207 input_unregister_device(dev->input_dev);
1208 dev->input_dev = NULL;
1210 device_del(&dev->dev);
1212 rc_free_device(dev);
1215 EXPORT_SYMBOL_GPL(rc_unregister_device);
1218 * Init/exit code for the module. Basically, creates/removes /sys/class/rc
1221 static int __init rc_core_init(void)
1223 int rc = class_register(&rc_class);
1225 printk(KERN_ERR "rc_core: unable to register rc class\n");
1229 led_trigger_register_simple("rc-feedback", &led_feedback);
1230 rc_map_register(&empty_map);
1235 static void __exit rc_core_exit(void)
1237 class_unregister(&rc_class);
1238 led_trigger_unregister_simple(led_feedback);
1239 rc_map_unregister(&empty_map);
1242 subsys_initcall(rc_core_init);
1243 module_exit(rc_core_exit);
1245 int rc_core_debug; /* ir_debug level (0,1,2) */
1246 EXPORT_SYMBOL_GPL(rc_core_debug);
1247 module_param_named(debug, rc_core_debug, int, 0644);
1249 MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@redhat.com>");
1250 MODULE_LICENSE("GPL");