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
, mode_t
*mode
)
720 return kasprintf(GFP_KERNEL
, "rc/%s", dev_name(dev
));
723 static struct class ir_input_class
= {
725 .devnode
= ir_devnode
,
732 { RC_TYPE_UNKNOWN
, "unknown" },
733 { RC_TYPE_RC5
, "rc-5" },
734 { RC_TYPE_NEC
, "nec" },
735 { RC_TYPE_RC6
, "rc-6" },
736 { RC_TYPE_JVC
, "jvc" },
737 { RC_TYPE_SONY
, "sony" },
738 { RC_TYPE_RC5_SZ
, "rc-5-sz" },
739 { RC_TYPE_SANYO
, "sanyo" },
740 { RC_TYPE_MCE_KBD
, "mce_kbd" },
741 { RC_TYPE_LIRC
, "lirc" },
742 { RC_TYPE_OTHER
, "other" },
745 #define PROTO_NONE "none"
748 * show_protocols() - shows the current IR protocol(s)
749 * @device: the device descriptor
750 * @mattr: the device attribute struct (unused)
751 * @buf: a pointer to the output buffer
753 * This routine is a callback routine for input read the IR protocol type(s).
754 * it is trigged by reading /sys/class/rc/rc?/protocols.
755 * It returns the protocol names of supported protocols.
756 * Enabled protocols are printed in brackets.
758 * dev->lock is taken to guard against races between device
759 * registration, store_protocols and show_protocols.
761 static ssize_t
show_protocols(struct device
*device
,
762 struct device_attribute
*mattr
, char *buf
)
764 struct rc_dev
*dev
= to_rc_dev(device
);
765 u64 allowed
, enabled
;
769 /* Device is being removed */
773 mutex_lock(&dev
->lock
);
775 if (dev
->driver_type
== RC_DRIVER_SCANCODE
) {
776 enabled
= dev
->rc_map
.rc_type
;
777 allowed
= dev
->allowed_protos
;
779 enabled
= dev
->raw
->enabled_protocols
;
780 allowed
= ir_raw_get_allowed_protocols();
783 IR_dprintk(1, "allowed - 0x%llx, enabled - 0x%llx\n",
787 for (i
= 0; i
< ARRAY_SIZE(proto_names
); i
++) {
788 if (allowed
& enabled
& proto_names
[i
].type
)
789 tmp
+= sprintf(tmp
, "[%s] ", proto_names
[i
].name
);
790 else if (allowed
& proto_names
[i
].type
)
791 tmp
+= sprintf(tmp
, "%s ", proto_names
[i
].name
);
798 mutex_unlock(&dev
->lock
);
800 return tmp
+ 1 - buf
;
804 * store_protocols() - changes the current IR protocol(s)
805 * @device: the device descriptor
806 * @mattr: the device attribute struct (unused)
807 * @buf: a pointer to the input buffer
808 * @len: length of the input buffer
810 * This routine is for changing the IR protocol type.
811 * It is trigged by writing to /sys/class/rc/rc?/protocols.
812 * Writing "+proto" will add a protocol to the list of enabled protocols.
813 * Writing "-proto" will remove a protocol from the list of enabled protocols.
814 * Writing "proto" will enable only "proto".
815 * Writing "none" will disable all protocols.
816 * Returns -EINVAL if an invalid protocol combination or unknown protocol name
817 * is used, otherwise @len.
819 * dev->lock is taken to guard against races between device
820 * registration, store_protocols and show_protocols.
822 static ssize_t
store_protocols(struct device
*device
,
823 struct device_attribute
*mattr
,
827 struct rc_dev
*dev
= to_rc_dev(device
);
828 bool enable
, disable
;
832 int rc
, i
, count
= 0;
836 /* Device is being removed */
840 mutex_lock(&dev
->lock
);
842 if (dev
->driver_type
== RC_DRIVER_SCANCODE
)
843 type
= dev
->rc_map
.rc_type
;
845 type
= dev
->raw
->enabled_protocols
;
847 IR_dprintk(1, "Protocol switching not supported\n");
852 while ((tmp
= strsep((char **) &data
, " \n")) != NULL
) {
860 } else if (*tmp
== '-') {
869 if (!enable
&& !disable
&& !strncasecmp(tmp
, PROTO_NONE
, sizeof(PROTO_NONE
))) {
870 tmp
+= sizeof(PROTO_NONE
);
874 for (i
= 0; i
< ARRAY_SIZE(proto_names
); i
++) {
875 if (!strcasecmp(tmp
, proto_names
[i
].name
)) {
876 tmp
+= strlen(proto_names
[i
].name
);
877 mask
= proto_names
[i
].type
;
881 if (i
== ARRAY_SIZE(proto_names
)) {
882 IR_dprintk(1, "Unknown protocol: '%s'\n", tmp
);
898 IR_dprintk(1, "Protocol not specified\n");
903 if (dev
->change_protocol
) {
904 rc
= dev
->change_protocol(dev
, type
);
906 IR_dprintk(1, "Error setting protocols to 0x%llx\n",
913 if (dev
->driver_type
== RC_DRIVER_SCANCODE
) {
914 spin_lock_irqsave(&dev
->rc_map
.lock
, flags
);
915 dev
->rc_map
.rc_type
= type
;
916 spin_unlock_irqrestore(&dev
->rc_map
.lock
, flags
);
918 dev
->raw
->enabled_protocols
= type
;
921 IR_dprintk(1, "Current protocol(s): 0x%llx\n",
927 mutex_unlock(&dev
->lock
);
931 static void rc_dev_release(struct device
*device
)
935 #define ADD_HOTPLUG_VAR(fmt, val...) \
937 int err = add_uevent_var(env, fmt, val); \
942 static int rc_dev_uevent(struct device
*device
, struct kobj_uevent_env
*env
)
944 struct rc_dev
*dev
= to_rc_dev(device
);
946 if (!dev
|| !dev
->input_dev
)
949 if (dev
->rc_map
.name
)
950 ADD_HOTPLUG_VAR("NAME=%s", dev
->rc_map
.name
);
951 if (dev
->driver_name
)
952 ADD_HOTPLUG_VAR("DRV_NAME=%s", dev
->driver_name
);
958 * Static device attribute struct with the sysfs attributes for IR's
960 static DEVICE_ATTR(protocols
, S_IRUGO
| S_IWUSR
,
961 show_protocols
, store_protocols
);
963 static struct attribute
*rc_dev_attrs
[] = {
964 &dev_attr_protocols
.attr
,
968 static struct attribute_group rc_dev_attr_grp
= {
969 .attrs
= rc_dev_attrs
,
972 static const struct attribute_group
*rc_dev_attr_groups
[] = {
977 static struct device_type rc_dev_type
= {
978 .groups
= rc_dev_attr_groups
,
979 .release
= rc_dev_release
,
980 .uevent
= rc_dev_uevent
,
983 struct rc_dev
*rc_allocate_device(void)
987 dev
= kzalloc(sizeof(*dev
), GFP_KERNEL
);
991 dev
->input_dev
= input_allocate_device();
992 if (!dev
->input_dev
) {
997 dev
->input_dev
->getkeycode
= ir_getkeycode
;
998 dev
->input_dev
->setkeycode
= ir_setkeycode
;
999 input_set_drvdata(dev
->input_dev
, dev
);
1001 spin_lock_init(&dev
->rc_map
.lock
);
1002 spin_lock_init(&dev
->keylock
);
1003 mutex_init(&dev
->lock
);
1004 setup_timer(&dev
->timer_keyup
, ir_timer_keyup
, (unsigned long)dev
);
1006 dev
->dev
.type
= &rc_dev_type
;
1007 dev
->dev
.class = &ir_input_class
;
1008 device_initialize(&dev
->dev
);
1010 __module_get(THIS_MODULE
);
1013 EXPORT_SYMBOL_GPL(rc_allocate_device
);
1015 void rc_free_device(struct rc_dev
*dev
)
1021 input_free_device(dev
->input_dev
);
1023 put_device(&dev
->dev
);
1026 module_put(THIS_MODULE
);
1028 EXPORT_SYMBOL_GPL(rc_free_device
);
1030 int rc_register_device(struct rc_dev
*dev
)
1032 static atomic_t devno
= ATOMIC_INIT(0);
1033 struct rc_map
*rc_map
;
1037 if (!dev
|| !dev
->map_name
)
1040 rc_map
= rc_map_get(dev
->map_name
);
1042 rc_map
= rc_map_get(RC_MAP_EMPTY
);
1043 if (!rc_map
|| !rc_map
->scan
|| rc_map
->size
== 0)
1046 set_bit(EV_KEY
, dev
->input_dev
->evbit
);
1047 set_bit(EV_REP
, dev
->input_dev
->evbit
);
1048 set_bit(EV_MSC
, dev
->input_dev
->evbit
);
1049 set_bit(MSC_SCAN
, dev
->input_dev
->mscbit
);
1051 dev
->input_dev
->open
= ir_open
;
1053 dev
->input_dev
->close
= ir_close
;
1056 * Take the lock here, as the device sysfs node will appear
1057 * when device_add() is called, which may trigger an ir-keytable udev
1058 * rule, which will in turn call show_protocols and access either
1059 * dev->rc_map.rc_type or dev->raw->enabled_protocols before it has
1062 mutex_lock(&dev
->lock
);
1064 dev
->devno
= (unsigned long)(atomic_inc_return(&devno
) - 1);
1065 dev_set_name(&dev
->dev
, "rc%ld", dev
->devno
);
1066 dev_set_drvdata(&dev
->dev
, dev
);
1067 rc
= device_add(&dev
->dev
);
1071 rc
= ir_setkeytable(dev
, rc_map
);
1075 dev
->input_dev
->dev
.parent
= &dev
->dev
;
1076 memcpy(&dev
->input_dev
->id
, &dev
->input_id
, sizeof(dev
->input_id
));
1077 dev
->input_dev
->phys
= dev
->input_phys
;
1078 dev
->input_dev
->name
= dev
->input_name
;
1079 rc
= input_register_device(dev
->input_dev
);
1084 * Default delay of 250ms is too short for some protocols, especially
1085 * since the timeout is currently set to 250ms. Increase it to 500ms,
1086 * to avoid wrong repetition of the keycodes. Note that this must be
1087 * set after the call to input_register_device().
1089 dev
->input_dev
->rep
[REP_DELAY
] = 500;
1092 * As a repeat event on protocols like RC-5 and NEC take as long as
1093 * 110/114ms, using 33ms as a repeat period is not the right thing
1096 dev
->input_dev
->rep
[REP_PERIOD
] = 125;
1098 path
= kobject_get_path(&dev
->dev
.kobj
, GFP_KERNEL
);
1099 printk(KERN_INFO
"%s: %s as %s\n",
1100 dev_name(&dev
->dev
),
1101 dev
->input_name
? dev
->input_name
: "Unspecified device",
1102 path
? path
: "N/A");
1105 if (dev
->driver_type
== RC_DRIVER_IR_RAW
) {
1106 rc
= ir_raw_event_register(dev
);
1111 if (dev
->change_protocol
) {
1112 rc
= dev
->change_protocol(dev
, rc_map
->rc_type
);
1117 mutex_unlock(&dev
->lock
);
1119 IR_dprintk(1, "Registered rc%ld (driver: %s, remote: %s, mode %s)\n",
1121 dev
->driver_name
? dev
->driver_name
: "unknown",
1122 rc_map
->name
? rc_map
->name
: "unknown",
1123 dev
->driver_type
== RC_DRIVER_IR_RAW
? "raw" : "cooked");
1128 if (dev
->driver_type
== RC_DRIVER_IR_RAW
)
1129 ir_raw_event_unregister(dev
);
1131 input_unregister_device(dev
->input_dev
);
1132 dev
->input_dev
= NULL
;
1134 ir_free_table(&dev
->rc_map
);
1136 device_del(&dev
->dev
);
1138 mutex_unlock(&dev
->lock
);
1141 EXPORT_SYMBOL_GPL(rc_register_device
);
1143 void rc_unregister_device(struct rc_dev
*dev
)
1148 del_timer_sync(&dev
->timer_keyup
);
1150 if (dev
->driver_type
== RC_DRIVER_IR_RAW
)
1151 ir_raw_event_unregister(dev
);
1153 /* Freeing the table should also call the stop callback */
1154 ir_free_table(&dev
->rc_map
);
1155 IR_dprintk(1, "Freed keycode table\n");
1157 input_unregister_device(dev
->input_dev
);
1158 dev
->input_dev
= NULL
;
1160 device_del(&dev
->dev
);
1162 rc_free_device(dev
);
1165 EXPORT_SYMBOL_GPL(rc_unregister_device
);
1168 * Init/exit code for the module. Basically, creates/removes /sys/class/rc
1171 static int __init
rc_core_init(void)
1173 int rc
= class_register(&ir_input_class
);
1175 printk(KERN_ERR
"rc_core: unable to register rc class\n");
1179 /* Initialize/load the decoders/keymap code that will be used */
1181 rc_map_register(&empty_map
);
1186 static void __exit
rc_core_exit(void)
1188 class_unregister(&ir_input_class
);
1189 rc_map_unregister(&empty_map
);
1192 module_init(rc_core_init
);
1193 module_exit(rc_core_exit
);
1195 int rc_core_debug
; /* ir_debug level (0,1,2) */
1196 EXPORT_SYMBOL_GPL(rc_core_debug
);
1197 module_param_named(debug
, rc_core_debug
, int, 0644);
1199 MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@redhat.com>");
1200 MODULE_LICENSE("GPL");