1
2
3
4
5
6
7
8
9
10
11
12
13
14
15#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
16
17#include <media/rc-core.h>
18#include <linux/atomic.h>
19#include <linux/spinlock.h>
20#include <linux/delay.h>
21#include <linux/input.h>
22#include <linux/leds.h>
23#include <linux/slab.h>
24#include <linux/idr.h>
25#include <linux/device.h>
26#include <linux/module.h>
27#include "rc-core-priv.h"
28
29
30#define IR_TAB_MIN_SIZE 256
31#define IR_TAB_MAX_SIZE 8192
32#define RC_DEV_MAX 256
33
34
35#define IR_KEYPRESS_TIMEOUT 250
36
37
38static LIST_HEAD(rc_map_list);
39static DEFINE_SPINLOCK(rc_map_lock);
40static struct led_trigger *led_feedback;
41
42
43static DEFINE_IDA(rc_ida);
44
45static struct rc_map_list *seek_rc_map(const char *name)
46{
47 struct rc_map_list *map = NULL;
48
49 spin_lock(&rc_map_lock);
50 list_for_each_entry(map, &rc_map_list, list) {
51 if (!strcmp(name, map->map.name)) {
52 spin_unlock(&rc_map_lock);
53 return map;
54 }
55 }
56 spin_unlock(&rc_map_lock);
57
58 return NULL;
59}
60
61struct rc_map *rc_map_get(const char *name)
62{
63
64 struct rc_map_list *map;
65
66 map = seek_rc_map(name);
67#ifdef CONFIG_MODULES
68 if (!map) {
69 int rc = request_module("%s", name);
70 if (rc < 0) {
71 pr_err("Couldn't load IR keymap %s\n", name);
72 return NULL;
73 }
74 msleep(20);
75
76 map = seek_rc_map(name);
77 }
78#endif
79 if (!map) {
80 pr_err("IR keymap %s not found\n", name);
81 return NULL;
82 }
83
84 printk(KERN_INFO "Registered IR keymap %s\n", map->map.name);
85
86 return &map->map;
87}
88EXPORT_SYMBOL_GPL(rc_map_get);
89
90int rc_map_register(struct rc_map_list *map)
91{
92 spin_lock(&rc_map_lock);
93 list_add_tail(&map->list, &rc_map_list);
94 spin_unlock(&rc_map_lock);
95 return 0;
96}
97EXPORT_SYMBOL_GPL(rc_map_register);
98
99void rc_map_unregister(struct rc_map_list *map)
100{
101 spin_lock(&rc_map_lock);
102 list_del(&map->list);
103 spin_unlock(&rc_map_lock);
104}
105EXPORT_SYMBOL_GPL(rc_map_unregister);
106
107
108static struct rc_map_table empty[] = {
109 { 0x2a, KEY_COFFEE },
110};
111
112static struct rc_map_list empty_map = {
113 .map = {
114 .scan = empty,
115 .size = ARRAY_SIZE(empty),
116 .rc_type = RC_TYPE_UNKNOWN,
117 .name = RC_MAP_EMPTY,
118 }
119};
120
121
122
123
124
125
126
127
128
129
130
131
132static int ir_create_table(struct rc_map *rc_map,
133 const char *name, u64 rc_type, size_t size)
134{
135 rc_map->name = kstrdup(name, GFP_KERNEL);
136 if (!rc_map->name)
137 return -ENOMEM;
138 rc_map->rc_type = rc_type;
139 rc_map->alloc = roundup_pow_of_two(size * sizeof(struct rc_map_table));
140 rc_map->size = rc_map->alloc / sizeof(struct rc_map_table);
141 rc_map->scan = kmalloc(rc_map->alloc, GFP_KERNEL);
142 if (!rc_map->scan) {
143 kfree(rc_map->name);
144 rc_map->name = NULL;
145 return -ENOMEM;
146 }
147
148 IR_dprintk(1, "Allocated space for %u keycode entries (%u bytes)\n",
149 rc_map->size, rc_map->alloc);
150 return 0;
151}
152
153
154
155
156
157
158
159
160static void ir_free_table(struct rc_map *rc_map)
161{
162 rc_map->size = 0;
163 kfree(rc_map->name);
164 rc_map->name = NULL;
165 kfree(rc_map->scan);
166 rc_map->scan = NULL;
167}
168
169
170
171
172
173
174
175
176
177
178static int ir_resize_table(struct rc_map *rc_map, gfp_t gfp_flags)
179{
180 unsigned int oldalloc = rc_map->alloc;
181 unsigned int newalloc = oldalloc;
182 struct rc_map_table *oldscan = rc_map->scan;
183 struct rc_map_table *newscan;
184
185 if (rc_map->size == rc_map->len) {
186
187 if (rc_map->alloc >= IR_TAB_MAX_SIZE)
188 return -ENOMEM;
189
190 newalloc *= 2;
191 IR_dprintk(1, "Growing table to %u bytes\n", newalloc);
192 }
193
194 if ((rc_map->len * 3 < rc_map->size) && (oldalloc > IR_TAB_MIN_SIZE)) {
195
196 newalloc /= 2;
197 IR_dprintk(1, "Shrinking table to %u bytes\n", newalloc);
198 }
199
200 if (newalloc == oldalloc)
201 return 0;
202
203 newscan = kmalloc(newalloc, gfp_flags);
204 if (!newscan) {
205 IR_dprintk(1, "Failed to kmalloc %u bytes\n", newalloc);
206 return -ENOMEM;
207 }
208
209 memcpy(newscan, rc_map->scan, rc_map->len * sizeof(struct rc_map_table));
210 rc_map->scan = newscan;
211 rc_map->alloc = newalloc;
212 rc_map->size = rc_map->alloc / sizeof(struct rc_map_table);
213 kfree(oldscan);
214 return 0;
215}
216
217
218
219
220
221
222
223
224
225
226
227
228static unsigned int ir_update_mapping(struct rc_dev *dev,
229 struct rc_map *rc_map,
230 unsigned int index,
231 unsigned int new_keycode)
232{
233 int old_keycode = rc_map->scan[index].keycode;
234 int i;
235
236
237 if (new_keycode == KEY_RESERVED || new_keycode == KEY_UNKNOWN) {
238 IR_dprintk(1, "#%d: Deleting scan 0x%04x\n",
239 index, rc_map->scan[index].scancode);
240 rc_map->len--;
241 memmove(&rc_map->scan[index], &rc_map->scan[index+ 1],
242 (rc_map->len - index) * sizeof(struct rc_map_table));
243 } else {
244 IR_dprintk(1, "#%d: %s scan 0x%04x with key 0x%04x\n",
245 index,
246 old_keycode == KEY_RESERVED ? "New" : "Replacing",
247 rc_map->scan[index].scancode, new_keycode);
248 rc_map->scan[index].keycode = new_keycode;
249 __set_bit(new_keycode, dev->input_dev->keybit);
250 }
251
252 if (old_keycode != KEY_RESERVED) {
253
254 __clear_bit(old_keycode, dev->input_dev->keybit);
255
256 for (i = 0; i < rc_map->len; i++) {
257 if (rc_map->scan[i].keycode == old_keycode) {
258 __set_bit(old_keycode, dev->input_dev->keybit);
259 break;
260 }
261 }
262
263
264 ir_resize_table(rc_map, GFP_ATOMIC);
265 }
266
267 return old_keycode;
268}
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284static unsigned int ir_establish_scancode(struct rc_dev *dev,
285 struct rc_map *rc_map,
286 unsigned int scancode,
287 bool resize)
288{
289 unsigned int i;
290
291
292
293
294
295
296
297
298
299 if (dev->scancode_mask)
300 scancode &= dev->scancode_mask;
301
302
303 for (i = 0; i < rc_map->len; i++) {
304 if (rc_map->scan[i].scancode == scancode)
305 return i;
306
307
308 if (rc_map->scan[i].scancode >= scancode)
309 break;
310 }
311
312
313 if (rc_map->size == rc_map->len) {
314 if (!resize || ir_resize_table(rc_map, GFP_ATOMIC))
315 return -1U;
316 }
317
318
319 if (i < rc_map->len)
320 memmove(&rc_map->scan[i + 1], &rc_map->scan[i],
321 (rc_map->len - i) * sizeof(struct rc_map_table));
322 rc_map->scan[i].scancode = scancode;
323 rc_map->scan[i].keycode = KEY_RESERVED;
324 rc_map->len++;
325
326 return i;
327}
328
329
330
331
332
333
334
335
336
337
338static int ir_setkeycode(struct input_dev *idev,
339 const struct input_keymap_entry *ke,
340 unsigned int *old_keycode)
341{
342 struct rc_dev *rdev = input_get_drvdata(idev);
343 struct rc_map *rc_map = &rdev->rc_map;
344 unsigned int index;
345 unsigned int scancode;
346 int retval = 0;
347 unsigned long flags;
348
349 spin_lock_irqsave(&rc_map->lock, flags);
350
351 if (ke->flags & INPUT_KEYMAP_BY_INDEX) {
352 index = ke->index;
353 if (index >= rc_map->len) {
354 retval = -EINVAL;
355 goto out;
356 }
357 } else {
358 retval = input_scancode_to_scalar(ke, &scancode);
359 if (retval)
360 goto out;
361
362 index = ir_establish_scancode(rdev, rc_map, scancode, true);
363 if (index >= rc_map->len) {
364 retval = -ENOMEM;
365 goto out;
366 }
367 }
368
369 *old_keycode = ir_update_mapping(rdev, rc_map, index, ke->keycode);
370
371out:
372 spin_unlock_irqrestore(&rc_map->lock, flags);
373 return retval;
374}
375
376
377
378
379
380
381
382
383
384
385static int ir_setkeytable(struct rc_dev *dev,
386 const struct rc_map *from)
387{
388 struct rc_map *rc_map = &dev->rc_map;
389 unsigned int i, index;
390 int rc;
391
392 rc = ir_create_table(rc_map, from->name,
393 from->rc_type, from->size);
394 if (rc)
395 return rc;
396
397 IR_dprintk(1, "Allocated space for %u keycode entries (%u bytes)\n",
398 rc_map->size, rc_map->alloc);
399
400 for (i = 0; i < from->size; i++) {
401 index = ir_establish_scancode(dev, rc_map,
402 from->scan[i].scancode, false);
403 if (index >= rc_map->len) {
404 rc = -ENOMEM;
405 break;
406 }
407
408 ir_update_mapping(dev, rc_map, index,
409 from->scan[i].keycode);
410 }
411
412 if (rc)
413 ir_free_table(rc_map);
414
415 return rc;
416}
417
418
419
420
421
422
423
424
425
426
427static unsigned int ir_lookup_by_scancode(const struct rc_map *rc_map,
428 unsigned int scancode)
429{
430 int start = 0;
431 int end = rc_map->len - 1;
432 int mid;
433
434 while (start <= end) {
435 mid = (start + end) / 2;
436 if (rc_map->scan[mid].scancode < scancode)
437 start = mid + 1;
438 else if (rc_map->scan[mid].scancode > scancode)
439 end = mid - 1;
440 else
441 return mid;
442 }
443
444 return -1U;
445}
446
447
448
449
450
451
452
453
454
455
456static int ir_getkeycode(struct input_dev *idev,
457 struct input_keymap_entry *ke)
458{
459 struct rc_dev *rdev = input_get_drvdata(idev);
460 struct rc_map *rc_map = &rdev->rc_map;
461 struct rc_map_table *entry;
462 unsigned long flags;
463 unsigned int index;
464 unsigned int scancode;
465 int retval;
466
467 spin_lock_irqsave(&rc_map->lock, flags);
468
469 if (ke->flags & INPUT_KEYMAP_BY_INDEX) {
470 index = ke->index;
471 } else {
472 retval = input_scancode_to_scalar(ke, &scancode);
473 if (retval)
474 goto out;
475
476 index = ir_lookup_by_scancode(rc_map, scancode);
477 }
478
479 if (index < rc_map->len) {
480 entry = &rc_map->scan[index];
481
482 ke->index = index;
483 ke->keycode = entry->keycode;
484 ke->len = sizeof(entry->scancode);
485 memcpy(ke->scancode, &entry->scancode, sizeof(entry->scancode));
486
487 } else if (!(ke->flags & INPUT_KEYMAP_BY_INDEX)) {
488
489
490
491
492
493 ke->index = index;
494 ke->keycode = KEY_RESERVED;
495 } else {
496 retval = -EINVAL;
497 goto out;
498 }
499
500 retval = 0;
501
502out:
503 spin_unlock_irqrestore(&rc_map->lock, flags);
504 return retval;
505}
506
507
508
509
510
511
512
513
514
515
516
517u32 rc_g_keycode_from_table(struct rc_dev *dev, u32 scancode)
518{
519 struct rc_map *rc_map = &dev->rc_map;
520 unsigned int keycode;
521 unsigned int index;
522 unsigned long flags;
523
524 spin_lock_irqsave(&rc_map->lock, flags);
525
526 index = ir_lookup_by_scancode(rc_map, scancode);
527 keycode = index < rc_map->len ?
528 rc_map->scan[index].keycode : KEY_RESERVED;
529
530 spin_unlock_irqrestore(&rc_map->lock, flags);
531
532 if (keycode != KEY_RESERVED)
533 IR_dprintk(1, "%s: scancode 0x%04x keycode 0x%02x\n",
534 dev->input_name, scancode, keycode);
535
536 return keycode;
537}
538EXPORT_SYMBOL_GPL(rc_g_keycode_from_table);
539
540
541
542
543
544
545
546
547
548static void ir_do_keyup(struct rc_dev *dev, bool sync)
549{
550 if (!dev->keypressed)
551 return;
552
553 IR_dprintk(1, "keyup key 0x%04x\n", dev->last_keycode);
554 input_report_key(dev->input_dev, dev->last_keycode, 0);
555 led_trigger_event(led_feedback, LED_OFF);
556 if (sync)
557 input_sync(dev->input_dev);
558 dev->keypressed = false;
559}
560
561
562
563
564
565
566
567
568void rc_keyup(struct rc_dev *dev)
569{
570 unsigned long flags;
571
572 spin_lock_irqsave(&dev->keylock, flags);
573 ir_do_keyup(dev, true);
574 spin_unlock_irqrestore(&dev->keylock, flags);
575}
576EXPORT_SYMBOL_GPL(rc_keyup);
577
578
579
580
581
582
583
584
585static void ir_timer_keyup(unsigned long cookie)
586{
587 struct rc_dev *dev = (struct rc_dev *)cookie;
588 unsigned long flags;
589
590
591
592
593
594
595
596
597
598
599
600 spin_lock_irqsave(&dev->keylock, flags);
601 if (time_is_before_eq_jiffies(dev->keyup_jiffies))
602 ir_do_keyup(dev, true);
603 spin_unlock_irqrestore(&dev->keylock, flags);
604}
605
606
607
608
609
610
611
612
613
614void rc_repeat(struct rc_dev *dev)
615{
616 unsigned long flags;
617
618 spin_lock_irqsave(&dev->keylock, flags);
619
620 input_event(dev->input_dev, EV_MSC, MSC_SCAN, dev->last_scancode);
621 input_sync(dev->input_dev);
622
623 if (!dev->keypressed)
624 goto out;
625
626 dev->keyup_jiffies = jiffies + msecs_to_jiffies(IR_KEYPRESS_TIMEOUT);
627 mod_timer(&dev->timer_keyup, dev->keyup_jiffies);
628
629out:
630 spin_unlock_irqrestore(&dev->keylock, flags);
631}
632EXPORT_SYMBOL_GPL(rc_repeat);
633
634
635
636
637
638
639
640
641
642
643
644
645static void ir_do_keydown(struct rc_dev *dev, enum rc_type protocol,
646 u32 scancode, u32 keycode, u8 toggle)
647{
648 bool new_event = (!dev->keypressed ||
649 dev->last_protocol != protocol ||
650 dev->last_scancode != scancode ||
651 dev->last_toggle != toggle);
652
653 if (new_event && dev->keypressed)
654 ir_do_keyup(dev, false);
655
656 input_event(dev->input_dev, EV_MSC, MSC_SCAN, scancode);
657
658 if (new_event && keycode != KEY_RESERVED) {
659
660 dev->keypressed = true;
661 dev->last_protocol = protocol;
662 dev->last_scancode = scancode;
663 dev->last_toggle = toggle;
664 dev->last_keycode = keycode;
665
666 IR_dprintk(1, "%s: key down event, key 0x%04x, protocol 0x%04x, scancode 0x%08x\n",
667 dev->input_name, keycode, protocol, scancode);
668 input_report_key(dev->input_dev, keycode, 1);
669
670 led_trigger_event(led_feedback, LED_FULL);
671 }
672
673 input_sync(dev->input_dev);
674}
675
676
677
678
679
680
681
682
683
684
685
686
687void rc_keydown(struct rc_dev *dev, enum rc_type protocol, u32 scancode, u8 toggle)
688{
689 unsigned long flags;
690 u32 keycode = rc_g_keycode_from_table(dev, scancode);
691
692 spin_lock_irqsave(&dev->keylock, flags);
693 ir_do_keydown(dev, protocol, scancode, keycode, toggle);
694
695 if (dev->keypressed) {
696 dev->keyup_jiffies = jiffies + msecs_to_jiffies(IR_KEYPRESS_TIMEOUT);
697 mod_timer(&dev->timer_keyup, dev->keyup_jiffies);
698 }
699 spin_unlock_irqrestore(&dev->keylock, flags);
700}
701EXPORT_SYMBOL_GPL(rc_keydown);
702
703
704
705
706
707
708
709
710
711
712
713
714
715void rc_keydown_notimeout(struct rc_dev *dev, enum rc_type protocol,
716 u32 scancode, u8 toggle)
717{
718 unsigned long flags;
719 u32 keycode = rc_g_keycode_from_table(dev, scancode);
720
721 spin_lock_irqsave(&dev->keylock, flags);
722 ir_do_keydown(dev, protocol, scancode, keycode, toggle);
723 spin_unlock_irqrestore(&dev->keylock, flags);
724}
725EXPORT_SYMBOL_GPL(rc_keydown_notimeout);
726
727int rc_open(struct rc_dev *rdev)
728{
729 int rval = 0;
730
731 if (!rdev)
732 return -EINVAL;
733
734 mutex_lock(&rdev->lock);
735
736 if (!rdev->users++ && rdev->open != NULL)
737 rval = rdev->open(rdev);
738
739 if (rval)
740 rdev->users--;
741
742 mutex_unlock(&rdev->lock);
743
744 return rval;
745}
746EXPORT_SYMBOL_GPL(rc_open);
747
748static int ir_open(struct input_dev *idev)
749{
750 struct rc_dev *rdev = input_get_drvdata(idev);
751
752 return rc_open(rdev);
753}
754
755void rc_close(struct rc_dev *rdev)
756{
757 if (rdev) {
758 mutex_lock(&rdev->lock);
759
760 if (!--rdev->users && rdev->close != NULL)
761 rdev->close(rdev);
762
763 mutex_unlock(&rdev->lock);
764 }
765}
766EXPORT_SYMBOL_GPL(rc_close);
767
768static void ir_close(struct input_dev *idev)
769{
770 struct rc_dev *rdev = input_get_drvdata(idev);
771 rc_close(rdev);
772}
773
774
775static char *rc_devnode(struct device *dev, umode_t *mode)
776{
777 return kasprintf(GFP_KERNEL, "rc/%s", dev_name(dev));
778}
779
780static struct class rc_class = {
781 .name = "rc",
782 .devnode = rc_devnode,
783};
784
785
786
787
788
789
790static const struct {
791 u64 type;
792 const char *name;
793 const char *module_name;
794} proto_names[] = {
795 { RC_BIT_NONE, "none", NULL },
796 { RC_BIT_OTHER, "other", NULL },
797 { RC_BIT_UNKNOWN, "unknown", NULL },
798 { RC_BIT_RC5 |
799 RC_BIT_RC5X, "rc-5", "ir-rc5-decoder" },
800 { RC_BIT_NEC |
801 RC_BIT_NECX |
802 RC_BIT_NEC32, "nec", "ir-nec-decoder" },
803 { RC_BIT_RC6_0 |
804 RC_BIT_RC6_6A_20 |
805 RC_BIT_RC6_6A_24 |
806 RC_BIT_RC6_6A_32 |
807 RC_BIT_RC6_MCE, "rc-6", "ir-rc6-decoder" },
808 { RC_BIT_JVC, "jvc", "ir-jvc-decoder" },
809 { RC_BIT_SONY12 |
810 RC_BIT_SONY15 |
811 RC_BIT_SONY20, "sony", "ir-sony-decoder" },
812 { RC_BIT_RC5_SZ, "rc-5-sz", "ir-rc5-decoder" },
813 { RC_BIT_SANYO, "sanyo", "ir-sanyo-decoder" },
814 { RC_BIT_SHARP, "sharp", "ir-sharp-decoder" },
815 { RC_BIT_MCE_KBD, "mce_kbd", "ir-mce_kbd-decoder" },
816 { RC_BIT_XMP, "xmp", "ir-xmp-decoder" },
817 { RC_BIT_CEC, "cec", NULL },
818};
819
820
821
822
823
824
825
826struct rc_filter_attribute {
827 struct device_attribute attr;
828 enum rc_filter_type type;
829 bool mask;
830};
831#define to_rc_filter_attr(a) container_of(a, struct rc_filter_attribute, attr)
832
833#define RC_PROTO_ATTR(_name, _mode, _show, _store, _type) \
834 struct rc_filter_attribute dev_attr_##_name = { \
835 .attr = __ATTR(_name, _mode, _show, _store), \
836 .type = (_type), \
837 }
838#define RC_FILTER_ATTR(_name, _mode, _show, _store, _type, _mask) \
839 struct rc_filter_attribute dev_attr_##_name = { \
840 .attr = __ATTR(_name, _mode, _show, _store), \
841 .type = (_type), \
842 .mask = (_mask), \
843 }
844
845static bool lirc_is_present(void)
846{
847#if defined(CONFIG_LIRC_MODULE)
848 struct module *lirc;
849
850 mutex_lock(&module_mutex);
851 lirc = find_module("lirc_dev");
852 mutex_unlock(&module_mutex);
853
854 return lirc ? true : false;
855#elif defined(CONFIG_LIRC)
856 return true;
857#else
858 return false;
859#endif
860}
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876static ssize_t show_protocols(struct device *device,
877 struct device_attribute *mattr, char *buf)
878{
879 struct rc_dev *dev = to_rc_dev(device);
880 struct rc_filter_attribute *fattr = to_rc_filter_attr(mattr);
881 u64 allowed, enabled;
882 char *tmp = buf;
883 int i;
884
885
886 if (!dev)
887 return -EINVAL;
888
889 if (!atomic_read(&dev->initialized))
890 return -ERESTARTSYS;
891
892 mutex_lock(&dev->lock);
893
894 if (fattr->type == RC_FILTER_NORMAL) {
895 enabled = dev->enabled_protocols;
896 allowed = dev->allowed_protocols;
897 if (dev->raw && !allowed)
898 allowed = ir_raw_get_allowed_protocols();
899 } else {
900 enabled = dev->enabled_wakeup_protocols;
901 allowed = dev->allowed_wakeup_protocols;
902 }
903
904 mutex_unlock(&dev->lock);
905
906 IR_dprintk(1, "%s: allowed - 0x%llx, enabled - 0x%llx\n",
907 __func__, (long long)allowed, (long long)enabled);
908
909 for (i = 0; i < ARRAY_SIZE(proto_names); i++) {
910 if (allowed & enabled & proto_names[i].type)
911 tmp += sprintf(tmp, "[%s] ", proto_names[i].name);
912 else if (allowed & proto_names[i].type)
913 tmp += sprintf(tmp, "%s ", proto_names[i].name);
914
915 if (allowed & proto_names[i].type)
916 allowed &= ~proto_names[i].type;
917 }
918
919 if (dev->driver_type == RC_DRIVER_IR_RAW && lirc_is_present())
920 tmp += sprintf(tmp, "[lirc] ");
921
922 if (tmp != buf)
923 tmp--;
924 *tmp = '\n';
925
926 return tmp + 1 - buf;
927}
928
929
930
931
932
933
934
935
936
937
938
939
940static int parse_protocol_change(u64 *protocols, const char *buf)
941{
942 const char *tmp;
943 unsigned count = 0;
944 bool enable, disable;
945 u64 mask;
946 int i;
947
948 while ((tmp = strsep((char **)&buf, " \n")) != NULL) {
949 if (!*tmp)
950 break;
951
952 if (*tmp == '+') {
953 enable = true;
954 disable = false;
955 tmp++;
956 } else if (*tmp == '-') {
957 enable = false;
958 disable = true;
959 tmp++;
960 } else {
961 enable = false;
962 disable = false;
963 }
964
965 for (i = 0; i < ARRAY_SIZE(proto_names); i++) {
966 if (!strcasecmp(tmp, proto_names[i].name)) {
967 mask = proto_names[i].type;
968 break;
969 }
970 }
971
972 if (i == ARRAY_SIZE(proto_names)) {
973 if (!strcasecmp(tmp, "lirc"))
974 mask = 0;
975 else {
976 IR_dprintk(1, "Unknown protocol: '%s'\n", tmp);
977 return -EINVAL;
978 }
979 }
980
981 count++;
982
983 if (enable)
984 *protocols |= mask;
985 else if (disable)
986 *protocols &= ~mask;
987 else
988 *protocols = mask;
989 }
990
991 if (!count) {
992 IR_dprintk(1, "Protocol not specified\n");
993 return -EINVAL;
994 }
995
996 return count;
997}
998
999static void ir_raw_load_modules(u64 *protocols)
1000
1001{
1002 u64 available;
1003 int i, ret;
1004
1005 for (i = 0; i < ARRAY_SIZE(proto_names); i++) {
1006 if (proto_names[i].type == RC_BIT_NONE ||
1007 proto_names[i].type & (RC_BIT_OTHER | RC_BIT_UNKNOWN))
1008 continue;
1009
1010 available = ir_raw_get_allowed_protocols();
1011 if (!(*protocols & proto_names[i].type & ~available))
1012 continue;
1013
1014 if (!proto_names[i].module_name) {
1015 pr_err("Can't enable IR protocol %s\n",
1016 proto_names[i].name);
1017 *protocols &= ~proto_names[i].type;
1018 continue;
1019 }
1020
1021 ret = request_module("%s", proto_names[i].module_name);
1022 if (ret < 0) {
1023 pr_err("Couldn't load IR protocol module %s\n",
1024 proto_names[i].module_name);
1025 *protocols &= ~proto_names[i].type;
1026 continue;
1027 }
1028 msleep(20);
1029 available = ir_raw_get_allowed_protocols();
1030 if (!(*protocols & proto_names[i].type & ~available))
1031 continue;
1032
1033 pr_err("Loaded IR protocol module %s, \
1034 but protocol %s still not available\n",
1035 proto_names[i].module_name,
1036 proto_names[i].name);
1037 *protocols &= ~proto_names[i].type;
1038 }
1039}
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056static ssize_t store_protocols(struct device *device,
1057 struct device_attribute *mattr,
1058 const char *buf, size_t len)
1059{
1060 struct rc_dev *dev = to_rc_dev(device);
1061 struct rc_filter_attribute *fattr = to_rc_filter_attr(mattr);
1062 u64 *current_protocols;
1063 int (*change_protocol)(struct rc_dev *dev, u64 *rc_type);
1064 struct rc_scancode_filter *filter;
1065 int (*set_filter)(struct rc_dev *dev, struct rc_scancode_filter *filter);
1066 u64 old_protocols, new_protocols;
1067 ssize_t rc;
1068
1069
1070 if (!dev)
1071 return -EINVAL;
1072
1073 if (!atomic_read(&dev->initialized))
1074 return -ERESTARTSYS;
1075
1076 if (fattr->type == RC_FILTER_NORMAL) {
1077 IR_dprintk(1, "Normal protocol change requested\n");
1078 current_protocols = &dev->enabled_protocols;
1079 change_protocol = dev->change_protocol;
1080 filter = &dev->scancode_filter;
1081 set_filter = dev->s_filter;
1082 } else {
1083 IR_dprintk(1, "Wakeup protocol change requested\n");
1084 current_protocols = &dev->enabled_wakeup_protocols;
1085 change_protocol = dev->change_wakeup_protocol;
1086 filter = &dev->scancode_wakeup_filter;
1087 set_filter = dev->s_wakeup_filter;
1088 }
1089
1090 if (!change_protocol) {
1091 IR_dprintk(1, "Protocol switching not supported\n");
1092 return -EINVAL;
1093 }
1094
1095 mutex_lock(&dev->lock);
1096
1097 old_protocols = *current_protocols;
1098 new_protocols = old_protocols;
1099 rc = parse_protocol_change(&new_protocols, buf);
1100 if (rc < 0)
1101 goto out;
1102
1103 rc = change_protocol(dev, &new_protocols);
1104 if (rc < 0) {
1105 IR_dprintk(1, "Error setting protocols to 0x%llx\n",
1106 (long long)new_protocols);
1107 goto out;
1108 }
1109
1110 if (dev->driver_type == RC_DRIVER_IR_RAW)
1111 ir_raw_load_modules(&new_protocols);
1112
1113 if (new_protocols != old_protocols) {
1114 *current_protocols = new_protocols;
1115 IR_dprintk(1, "Protocols changed to 0x%llx\n",
1116 (long long)new_protocols);
1117 }
1118
1119
1120
1121
1122
1123
1124
1125
1126 if (set_filter && filter->mask) {
1127 if (new_protocols)
1128 rc = set_filter(dev, filter);
1129 else
1130 rc = -1;
1131
1132 if (rc < 0) {
1133 filter->data = 0;
1134 filter->mask = 0;
1135 set_filter(dev, filter);
1136 }
1137 }
1138
1139 rc = len;
1140
1141out:
1142 mutex_unlock(&dev->lock);
1143 return rc;
1144}
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163static ssize_t show_filter(struct device *device,
1164 struct device_attribute *attr,
1165 char *buf)
1166{
1167 struct rc_dev *dev = to_rc_dev(device);
1168 struct rc_filter_attribute *fattr = to_rc_filter_attr(attr);
1169 struct rc_scancode_filter *filter;
1170 u32 val;
1171
1172
1173 if (!dev)
1174 return -EINVAL;
1175
1176 if (!atomic_read(&dev->initialized))
1177 return -ERESTARTSYS;
1178
1179 mutex_lock(&dev->lock);
1180
1181 if (fattr->type == RC_FILTER_NORMAL)
1182 filter = &dev->scancode_filter;
1183 else
1184 filter = &dev->scancode_wakeup_filter;
1185
1186 if (fattr->mask)
1187 val = filter->mask;
1188 else
1189 val = filter->data;
1190 mutex_unlock(&dev->lock);
1191
1192 return sprintf(buf, "%#x\n", val);
1193}
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214static ssize_t store_filter(struct device *device,
1215 struct device_attribute *attr,
1216 const char *buf, size_t len)
1217{
1218 struct rc_dev *dev = to_rc_dev(device);
1219 struct rc_filter_attribute *fattr = to_rc_filter_attr(attr);
1220 struct rc_scancode_filter new_filter, *filter;
1221 int ret;
1222 unsigned long val;
1223 int (*set_filter)(struct rc_dev *dev, struct rc_scancode_filter *filter);
1224 u64 *enabled_protocols;
1225
1226
1227 if (!dev)
1228 return -EINVAL;
1229
1230 if (!atomic_read(&dev->initialized))
1231 return -ERESTARTSYS;
1232
1233 ret = kstrtoul(buf, 0, &val);
1234 if (ret < 0)
1235 return ret;
1236
1237 if (fattr->type == RC_FILTER_NORMAL) {
1238 set_filter = dev->s_filter;
1239 enabled_protocols = &dev->enabled_protocols;
1240 filter = &dev->scancode_filter;
1241 } else {
1242 set_filter = dev->s_wakeup_filter;
1243 enabled_protocols = &dev->enabled_wakeup_protocols;
1244 filter = &dev->scancode_wakeup_filter;
1245 }
1246
1247 if (!set_filter)
1248 return -EINVAL;
1249
1250 mutex_lock(&dev->lock);
1251
1252 new_filter = *filter;
1253 if (fattr->mask)
1254 new_filter.mask = val;
1255 else
1256 new_filter.data = val;
1257
1258 if (!*enabled_protocols && val) {
1259
1260 ret = -EINVAL;
1261 goto unlock;
1262 }
1263
1264 ret = set_filter(dev, &new_filter);
1265 if (ret < 0)
1266 goto unlock;
1267
1268 *filter = new_filter;
1269
1270unlock:
1271 mutex_unlock(&dev->lock);
1272 return (ret < 0) ? ret : len;
1273}
1274
1275static void rc_dev_release(struct device *device)
1276{
1277 struct rc_dev *dev = to_rc_dev(device);
1278
1279 kfree(dev);
1280}
1281
1282#define ADD_HOTPLUG_VAR(fmt, val...) \
1283 do { \
1284 int err = add_uevent_var(env, fmt, val); \
1285 if (err) \
1286 return err; \
1287 } while (0)
1288
1289static int rc_dev_uevent(struct device *device, struct kobj_uevent_env *env)
1290{
1291 struct rc_dev *dev = to_rc_dev(device);
1292
1293 if (dev->rc_map.name)
1294 ADD_HOTPLUG_VAR("NAME=%s", dev->rc_map.name);
1295 if (dev->driver_name)
1296 ADD_HOTPLUG_VAR("DRV_NAME=%s", dev->driver_name);
1297
1298 return 0;
1299}
1300
1301
1302
1303
1304static RC_PROTO_ATTR(protocols, S_IRUGO | S_IWUSR,
1305 show_protocols, store_protocols, RC_FILTER_NORMAL);
1306static RC_PROTO_ATTR(wakeup_protocols, S_IRUGO | S_IWUSR,
1307 show_protocols, store_protocols, RC_FILTER_WAKEUP);
1308static RC_FILTER_ATTR(filter, S_IRUGO|S_IWUSR,
1309 show_filter, store_filter, RC_FILTER_NORMAL, false);
1310static RC_FILTER_ATTR(filter_mask, S_IRUGO|S_IWUSR,
1311 show_filter, store_filter, RC_FILTER_NORMAL, true);
1312static RC_FILTER_ATTR(wakeup_filter, S_IRUGO|S_IWUSR,
1313 show_filter, store_filter, RC_FILTER_WAKEUP, false);
1314static RC_FILTER_ATTR(wakeup_filter_mask, S_IRUGO|S_IWUSR,
1315 show_filter, store_filter, RC_FILTER_WAKEUP, true);
1316
1317static struct attribute *rc_dev_protocol_attrs[] = {
1318 &dev_attr_protocols.attr.attr,
1319 NULL,
1320};
1321
1322static struct attribute_group rc_dev_protocol_attr_grp = {
1323 .attrs = rc_dev_protocol_attrs,
1324};
1325
1326static struct attribute *rc_dev_wakeup_protocol_attrs[] = {
1327 &dev_attr_wakeup_protocols.attr.attr,
1328 NULL,
1329};
1330
1331static struct attribute_group rc_dev_wakeup_protocol_attr_grp = {
1332 .attrs = rc_dev_wakeup_protocol_attrs,
1333};
1334
1335static struct attribute *rc_dev_filter_attrs[] = {
1336 &dev_attr_filter.attr.attr,
1337 &dev_attr_filter_mask.attr.attr,
1338 NULL,
1339};
1340
1341static struct attribute_group rc_dev_filter_attr_grp = {
1342 .attrs = rc_dev_filter_attrs,
1343};
1344
1345static struct attribute *rc_dev_wakeup_filter_attrs[] = {
1346 &dev_attr_wakeup_filter.attr.attr,
1347 &dev_attr_wakeup_filter_mask.attr.attr,
1348 NULL,
1349};
1350
1351static struct attribute_group rc_dev_wakeup_filter_attr_grp = {
1352 .attrs = rc_dev_wakeup_filter_attrs,
1353};
1354
1355static struct device_type rc_dev_type = {
1356 .release = rc_dev_release,
1357 .uevent = rc_dev_uevent,
1358};
1359
1360struct rc_dev *rc_allocate_device(void)
1361{
1362 struct rc_dev *dev;
1363
1364 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1365 if (!dev)
1366 return NULL;
1367
1368 dev->input_dev = input_allocate_device();
1369 if (!dev->input_dev) {
1370 kfree(dev);
1371 return NULL;
1372 }
1373
1374 dev->input_dev->getkeycode = ir_getkeycode;
1375 dev->input_dev->setkeycode = ir_setkeycode;
1376 input_set_drvdata(dev->input_dev, dev);
1377
1378 spin_lock_init(&dev->rc_map.lock);
1379 spin_lock_init(&dev->keylock);
1380 mutex_init(&dev->lock);
1381 setup_timer(&dev->timer_keyup, ir_timer_keyup, (unsigned long)dev);
1382
1383 dev->dev.type = &rc_dev_type;
1384 dev->dev.class = &rc_class;
1385 device_initialize(&dev->dev);
1386
1387 __module_get(THIS_MODULE);
1388 return dev;
1389}
1390EXPORT_SYMBOL_GPL(rc_allocate_device);
1391
1392void rc_free_device(struct rc_dev *dev)
1393{
1394 if (!dev)
1395 return;
1396
1397 input_free_device(dev->input_dev);
1398
1399 put_device(&dev->dev);
1400
1401
1402
1403
1404 module_put(THIS_MODULE);
1405}
1406EXPORT_SYMBOL_GPL(rc_free_device);
1407
1408static void devm_rc_alloc_release(struct device *dev, void *res)
1409{
1410 rc_free_device(*(struct rc_dev **)res);
1411}
1412
1413struct rc_dev *devm_rc_allocate_device(struct device *dev)
1414{
1415 struct rc_dev **dr, *rc;
1416
1417 dr = devres_alloc(devm_rc_alloc_release, sizeof(*dr), GFP_KERNEL);
1418 if (!dr)
1419 return NULL;
1420
1421 rc = rc_allocate_device();
1422 if (!rc) {
1423 devres_free(dr);
1424 return NULL;
1425 }
1426
1427 rc->dev.parent = dev;
1428 rc->managed_alloc = true;
1429 *dr = rc;
1430 devres_add(dev, dr);
1431
1432 return rc;
1433}
1434EXPORT_SYMBOL_GPL(devm_rc_allocate_device);
1435
1436int rc_register_device(struct rc_dev *dev)
1437{
1438 static bool raw_init = false;
1439 struct rc_map *rc_map;
1440 const char *path;
1441 int attr = 0;
1442 int minor;
1443 int rc;
1444
1445 if (!dev || !dev->map_name)
1446 return -EINVAL;
1447
1448 rc_map = rc_map_get(dev->map_name);
1449 if (!rc_map)
1450 rc_map = rc_map_get(RC_MAP_EMPTY);
1451 if (!rc_map || !rc_map->scan || rc_map->size == 0)
1452 return -EINVAL;
1453
1454 set_bit(EV_KEY, dev->input_dev->evbit);
1455 set_bit(EV_REP, dev->input_dev->evbit);
1456 set_bit(EV_MSC, dev->input_dev->evbit);
1457 set_bit(MSC_SCAN, dev->input_dev->mscbit);
1458 if (dev->open)
1459 dev->input_dev->open = ir_open;
1460 if (dev->close)
1461 dev->input_dev->close = ir_close;
1462
1463 minor = ida_simple_get(&rc_ida, 0, RC_DEV_MAX, GFP_KERNEL);
1464 if (minor < 0)
1465 return minor;
1466
1467 dev->minor = minor;
1468 dev_set_name(&dev->dev, "rc%u", dev->minor);
1469 dev_set_drvdata(&dev->dev, dev);
1470 atomic_set(&dev->initialized, 0);
1471
1472 dev->dev.groups = dev->sysfs_groups;
1473 dev->sysfs_groups[attr++] = &rc_dev_protocol_attr_grp;
1474 if (dev->s_filter)
1475 dev->sysfs_groups[attr++] = &rc_dev_filter_attr_grp;
1476 if (dev->s_wakeup_filter)
1477 dev->sysfs_groups[attr++] = &rc_dev_wakeup_filter_attr_grp;
1478 if (dev->change_wakeup_protocol)
1479 dev->sysfs_groups[attr++] = &rc_dev_wakeup_protocol_attr_grp;
1480 dev->sysfs_groups[attr++] = NULL;
1481
1482 rc = device_add(&dev->dev);
1483 if (rc)
1484 goto out_unlock;
1485
1486 rc = ir_setkeytable(dev, rc_map);
1487 if (rc)
1488 goto out_dev;
1489
1490 dev->input_dev->dev.parent = &dev->dev;
1491 memcpy(&dev->input_dev->id, &dev->input_id, sizeof(dev->input_id));
1492 dev->input_dev->phys = dev->input_phys;
1493 dev->input_dev->name = dev->input_name;
1494
1495 rc = input_register_device(dev->input_dev);
1496 if (rc)
1497 goto out_table;
1498
1499
1500
1501
1502
1503
1504
1505 dev->input_dev->rep[REP_DELAY] = 500;
1506
1507
1508
1509
1510
1511
1512 dev->input_dev->rep[REP_PERIOD] = 125;
1513
1514 path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);
1515 dev_info(&dev->dev, "%s as %s\n",
1516 dev->input_name ?: "Unspecified device", path ?: "N/A");
1517 kfree(path);
1518
1519 if (dev->driver_type == RC_DRIVER_IR_RAW) {
1520 if (!raw_init) {
1521 request_module_nowait("ir-lirc-codec");
1522 raw_init = true;
1523 }
1524 rc = ir_raw_event_register(dev);
1525 if (rc < 0)
1526 goto out_input;
1527 }
1528
1529 if (dev->change_protocol) {
1530 u64 rc_type = (1ll << rc_map->rc_type);
1531 rc = dev->change_protocol(dev, &rc_type);
1532 if (rc < 0)
1533 goto out_raw;
1534 dev->enabled_protocols = rc_type;
1535 }
1536
1537
1538 atomic_set(&dev->initialized, 1);
1539
1540 IR_dprintk(1, "Registered rc%u (driver: %s, remote: %s, mode %s)\n",
1541 dev->minor,
1542 dev->driver_name ? dev->driver_name : "unknown",
1543 rc_map->name ? rc_map->name : "unknown",
1544 dev->driver_type == RC_DRIVER_IR_RAW ? "raw" : "cooked");
1545
1546 return 0;
1547
1548out_raw:
1549 if (dev->driver_type == RC_DRIVER_IR_RAW)
1550 ir_raw_event_unregister(dev);
1551out_input:
1552 input_unregister_device(dev->input_dev);
1553 dev->input_dev = NULL;
1554out_table:
1555 ir_free_table(&dev->rc_map);
1556out_dev:
1557 device_del(&dev->dev);
1558out_unlock:
1559 ida_simple_remove(&rc_ida, minor);
1560 return rc;
1561}
1562EXPORT_SYMBOL_GPL(rc_register_device);
1563
1564static void devm_rc_release(struct device *dev, void *res)
1565{
1566 rc_unregister_device(*(struct rc_dev **)res);
1567}
1568
1569int devm_rc_register_device(struct device *parent, struct rc_dev *dev)
1570{
1571 struct rc_dev **dr;
1572 int ret;
1573
1574 dr = devres_alloc(devm_rc_release, sizeof(*dr), GFP_KERNEL);
1575 if (!dr)
1576 return -ENOMEM;
1577
1578 ret = rc_register_device(dev);
1579 if (ret) {
1580 devres_free(dr);
1581 return ret;
1582 }
1583
1584 *dr = dev;
1585 devres_add(parent, dr);
1586
1587 return 0;
1588}
1589EXPORT_SYMBOL_GPL(devm_rc_register_device);
1590
1591void rc_unregister_device(struct rc_dev *dev)
1592{
1593 if (!dev)
1594 return;
1595
1596 del_timer_sync(&dev->timer_keyup);
1597
1598 if (dev->driver_type == RC_DRIVER_IR_RAW)
1599 ir_raw_event_unregister(dev);
1600
1601
1602 ir_free_table(&dev->rc_map);
1603 IR_dprintk(1, "Freed keycode table\n");
1604
1605 input_unregister_device(dev->input_dev);
1606 dev->input_dev = NULL;
1607
1608 device_del(&dev->dev);
1609
1610 ida_simple_remove(&rc_ida, dev->minor);
1611
1612 if (!dev->managed_alloc)
1613 rc_free_device(dev);
1614}
1615
1616EXPORT_SYMBOL_GPL(rc_unregister_device);
1617
1618
1619
1620
1621
1622static int __init rc_core_init(void)
1623{
1624 int rc = class_register(&rc_class);
1625 if (rc) {
1626 pr_err("rc_core: unable to register rc class\n");
1627 return rc;
1628 }
1629
1630 led_trigger_register_simple("rc-feedback", &led_feedback);
1631 rc_map_register(&empty_map);
1632
1633 return 0;
1634}
1635
1636static void __exit rc_core_exit(void)
1637{
1638 class_unregister(&rc_class);
1639 led_trigger_unregister_simple(led_feedback);
1640 rc_map_unregister(&empty_map);
1641}
1642
1643subsys_initcall(rc_core_init);
1644module_exit(rc_core_exit);
1645
1646int rc_core_debug;
1647EXPORT_SYMBOL_GPL(rc_core_debug);
1648module_param_named(debug, rc_core_debug, int, 0644);
1649
1650MODULE_AUTHOR("Mauro Carvalho Chehab");
1651MODULE_LICENSE("GPL");
1652