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
727
728
729
730
731
732
733
734static int rc_validate_filter(struct rc_dev *dev,
735 struct rc_scancode_filter *filter)
736{
737 static u32 masks[] = {
738 [RC_TYPE_RC5] = 0x1f7f,
739 [RC_TYPE_RC5X_20] = 0x1f7f3f,
740 [RC_TYPE_RC5_SZ] = 0x2fff,
741 [RC_TYPE_SONY12] = 0x1f007f,
742 [RC_TYPE_SONY15] = 0xff007f,
743 [RC_TYPE_SONY20] = 0x1fff7f,
744 [RC_TYPE_JVC] = 0xffff,
745 [RC_TYPE_NEC] = 0xffff,
746 [RC_TYPE_NECX] = 0xffffff,
747 [RC_TYPE_NEC32] = 0xffffffff,
748 [RC_TYPE_SANYO] = 0x1fffff,
749 [RC_TYPE_MCIR2_KBD] = 0xffff,
750 [RC_TYPE_MCIR2_MSE] = 0x1fffff,
751 [RC_TYPE_RC6_0] = 0xffff,
752 [RC_TYPE_RC6_6A_20] = 0xfffff,
753 [RC_TYPE_RC6_6A_24] = 0xffffff,
754 [RC_TYPE_RC6_6A_32] = 0xffffffff,
755 [RC_TYPE_RC6_MCE] = 0xffff7fff,
756 [RC_TYPE_SHARP] = 0x1fff,
757 };
758 u32 s = filter->data;
759 enum rc_type protocol = dev->wakeup_protocol;
760
761 switch (protocol) {
762 case RC_TYPE_NECX:
763 if ((((s >> 16) ^ ~(s >> 8)) & 0xff) == 0)
764 return -EINVAL;
765 break;
766 case RC_TYPE_NEC32:
767 if ((((s >> 24) ^ ~(s >> 16)) & 0xff) == 0)
768 return -EINVAL;
769 break;
770 case RC_TYPE_RC6_MCE:
771 if ((s & 0xffff0000) != 0x800f0000)
772 return -EINVAL;
773 break;
774 case RC_TYPE_RC6_6A_32:
775 if ((s & 0xffff0000) == 0x800f0000)
776 return -EINVAL;
777 break;
778 default:
779 break;
780 }
781
782 filter->data &= masks[protocol];
783 filter->mask &= masks[protocol];
784
785
786
787
788 if (dev->encode_wakeup &&
789 filter->mask != 0 && filter->mask != masks[protocol])
790 return -EINVAL;
791
792 return 0;
793}
794
795int rc_open(struct rc_dev *rdev)
796{
797 int rval = 0;
798
799 if (!rdev)
800 return -EINVAL;
801
802 mutex_lock(&rdev->lock);
803
804 if (!rdev->users++ && rdev->open != NULL)
805 rval = rdev->open(rdev);
806
807 if (rval)
808 rdev->users--;
809
810 mutex_unlock(&rdev->lock);
811
812 return rval;
813}
814EXPORT_SYMBOL_GPL(rc_open);
815
816static int ir_open(struct input_dev *idev)
817{
818 struct rc_dev *rdev = input_get_drvdata(idev);
819
820 return rc_open(rdev);
821}
822
823void rc_close(struct rc_dev *rdev)
824{
825 if (rdev) {
826 mutex_lock(&rdev->lock);
827
828 if (!--rdev->users && rdev->close != NULL)
829 rdev->close(rdev);
830
831 mutex_unlock(&rdev->lock);
832 }
833}
834EXPORT_SYMBOL_GPL(rc_close);
835
836static void ir_close(struct input_dev *idev)
837{
838 struct rc_dev *rdev = input_get_drvdata(idev);
839 rc_close(rdev);
840}
841
842
843static char *rc_devnode(struct device *dev, umode_t *mode)
844{
845 return kasprintf(GFP_KERNEL, "rc/%s", dev_name(dev));
846}
847
848static struct class rc_class = {
849 .name = "rc",
850 .devnode = rc_devnode,
851};
852
853
854
855
856
857
858static const struct {
859 u64 type;
860 const char *name;
861 const char *module_name;
862} proto_names[] = {
863 { RC_BIT_NONE, "none", NULL },
864 { RC_BIT_OTHER, "other", NULL },
865 { RC_BIT_UNKNOWN, "unknown", NULL },
866 { RC_BIT_RC5 |
867 RC_BIT_RC5X_20, "rc-5", "ir-rc5-decoder" },
868 { RC_BIT_NEC |
869 RC_BIT_NECX |
870 RC_BIT_NEC32, "nec", "ir-nec-decoder" },
871 { RC_BIT_RC6_0 |
872 RC_BIT_RC6_6A_20 |
873 RC_BIT_RC6_6A_24 |
874 RC_BIT_RC6_6A_32 |
875 RC_BIT_RC6_MCE, "rc-6", "ir-rc6-decoder" },
876 { RC_BIT_JVC, "jvc", "ir-jvc-decoder" },
877 { RC_BIT_SONY12 |
878 RC_BIT_SONY15 |
879 RC_BIT_SONY20, "sony", "ir-sony-decoder" },
880 { RC_BIT_RC5_SZ, "rc-5-sz", "ir-rc5-decoder" },
881 { RC_BIT_SANYO, "sanyo", "ir-sanyo-decoder" },
882 { RC_BIT_SHARP, "sharp", "ir-sharp-decoder" },
883 { RC_BIT_MCIR2_KBD |
884 RC_BIT_MCIR2_MSE, "mce_kbd", "ir-mce_kbd-decoder" },
885 { RC_BIT_XMP, "xmp", "ir-xmp-decoder" },
886 { RC_BIT_CEC, "cec", NULL },
887};
888
889
890
891
892
893
894
895struct rc_filter_attribute {
896 struct device_attribute attr;
897 enum rc_filter_type type;
898 bool mask;
899};
900#define to_rc_filter_attr(a) container_of(a, struct rc_filter_attribute, attr)
901
902#define RC_FILTER_ATTR(_name, _mode, _show, _store, _type, _mask) \
903 struct rc_filter_attribute dev_attr_##_name = { \
904 .attr = __ATTR(_name, _mode, _show, _store), \
905 .type = (_type), \
906 .mask = (_mask), \
907 }
908
909static bool lirc_is_present(void)
910{
911#if defined(CONFIG_LIRC_MODULE)
912 struct module *lirc;
913
914 mutex_lock(&module_mutex);
915 lirc = find_module("lirc_dev");
916 mutex_unlock(&module_mutex);
917
918 return lirc ? true : false;
919#elif defined(CONFIG_LIRC)
920 return true;
921#else
922 return false;
923#endif
924}
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940static ssize_t show_protocols(struct device *device,
941 struct device_attribute *mattr, char *buf)
942{
943 struct rc_dev *dev = to_rc_dev(device);
944 u64 allowed, enabled;
945 char *tmp = buf;
946 int i;
947
948
949 if (!dev)
950 return -EINVAL;
951
952 if (!atomic_read(&dev->initialized))
953 return -ERESTARTSYS;
954
955 mutex_lock(&dev->lock);
956
957 enabled = dev->enabled_protocols;
958 allowed = dev->allowed_protocols;
959 if (dev->raw && !allowed)
960 allowed = ir_raw_get_allowed_protocols();
961
962 mutex_unlock(&dev->lock);
963
964 IR_dprintk(1, "%s: allowed - 0x%llx, enabled - 0x%llx\n",
965 __func__, (long long)allowed, (long long)enabled);
966
967 for (i = 0; i < ARRAY_SIZE(proto_names); i++) {
968 if (allowed & enabled & proto_names[i].type)
969 tmp += sprintf(tmp, "[%s] ", proto_names[i].name);
970 else if (allowed & proto_names[i].type)
971 tmp += sprintf(tmp, "%s ", proto_names[i].name);
972
973 if (allowed & proto_names[i].type)
974 allowed &= ~proto_names[i].type;
975 }
976
977 if (dev->driver_type == RC_DRIVER_IR_RAW && lirc_is_present())
978 tmp += sprintf(tmp, "[lirc] ");
979
980 if (tmp != buf)
981 tmp--;
982 *tmp = '\n';
983
984 return tmp + 1 - buf;
985}
986
987
988
989
990
991
992
993
994
995
996
997
998static int parse_protocol_change(u64 *protocols, const char *buf)
999{
1000 const char *tmp;
1001 unsigned count = 0;
1002 bool enable, disable;
1003 u64 mask;
1004 int i;
1005
1006 while ((tmp = strsep((char **)&buf, " \n")) != NULL) {
1007 if (!*tmp)
1008 break;
1009
1010 if (*tmp == '+') {
1011 enable = true;
1012 disable = false;
1013 tmp++;
1014 } else if (*tmp == '-') {
1015 enable = false;
1016 disable = true;
1017 tmp++;
1018 } else {
1019 enable = false;
1020 disable = false;
1021 }
1022
1023 for (i = 0; i < ARRAY_SIZE(proto_names); i++) {
1024 if (!strcasecmp(tmp, proto_names[i].name)) {
1025 mask = proto_names[i].type;
1026 break;
1027 }
1028 }
1029
1030 if (i == ARRAY_SIZE(proto_names)) {
1031 if (!strcasecmp(tmp, "lirc"))
1032 mask = 0;
1033 else {
1034 IR_dprintk(1, "Unknown protocol: '%s'\n", tmp);
1035 return -EINVAL;
1036 }
1037 }
1038
1039 count++;
1040
1041 if (enable)
1042 *protocols |= mask;
1043 else if (disable)
1044 *protocols &= ~mask;
1045 else
1046 *protocols = mask;
1047 }
1048
1049 if (!count) {
1050 IR_dprintk(1, "Protocol not specified\n");
1051 return -EINVAL;
1052 }
1053
1054 return count;
1055}
1056
1057static void ir_raw_load_modules(u64 *protocols)
1058{
1059 u64 available;
1060 int i, ret;
1061
1062 for (i = 0; i < ARRAY_SIZE(proto_names); i++) {
1063 if (proto_names[i].type == RC_BIT_NONE ||
1064 proto_names[i].type & (RC_BIT_OTHER | RC_BIT_UNKNOWN))
1065 continue;
1066
1067 available = ir_raw_get_allowed_protocols();
1068 if (!(*protocols & proto_names[i].type & ~available))
1069 continue;
1070
1071 if (!proto_names[i].module_name) {
1072 pr_err("Can't enable IR protocol %s\n",
1073 proto_names[i].name);
1074 *protocols &= ~proto_names[i].type;
1075 continue;
1076 }
1077
1078 ret = request_module("%s", proto_names[i].module_name);
1079 if (ret < 0) {
1080 pr_err("Couldn't load IR protocol module %s\n",
1081 proto_names[i].module_name);
1082 *protocols &= ~proto_names[i].type;
1083 continue;
1084 }
1085 msleep(20);
1086 available = ir_raw_get_allowed_protocols();
1087 if (!(*protocols & proto_names[i].type & ~available))
1088 continue;
1089
1090 pr_err("Loaded IR protocol module %s, but protocol %s still not available\n",
1091 proto_names[i].module_name,
1092 proto_names[i].name);
1093 *protocols &= ~proto_names[i].type;
1094 }
1095}
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112static ssize_t store_protocols(struct device *device,
1113 struct device_attribute *mattr,
1114 const char *buf, size_t len)
1115{
1116 struct rc_dev *dev = to_rc_dev(device);
1117 u64 *current_protocols;
1118 struct rc_scancode_filter *filter;
1119 u64 old_protocols, new_protocols;
1120 ssize_t rc;
1121
1122
1123 if (!dev)
1124 return -EINVAL;
1125
1126 if (!atomic_read(&dev->initialized))
1127 return -ERESTARTSYS;
1128
1129 IR_dprintk(1, "Normal protocol change requested\n");
1130 current_protocols = &dev->enabled_protocols;
1131 filter = &dev->scancode_filter;
1132
1133 if (!dev->change_protocol) {
1134 IR_dprintk(1, "Protocol switching not supported\n");
1135 return -EINVAL;
1136 }
1137
1138 mutex_lock(&dev->lock);
1139
1140 old_protocols = *current_protocols;
1141 new_protocols = old_protocols;
1142 rc = parse_protocol_change(&new_protocols, buf);
1143 if (rc < 0)
1144 goto out;
1145
1146 rc = dev->change_protocol(dev, &new_protocols);
1147 if (rc < 0) {
1148 IR_dprintk(1, "Error setting protocols to 0x%llx\n",
1149 (long long)new_protocols);
1150 goto out;
1151 }
1152
1153 if (dev->driver_type == RC_DRIVER_IR_RAW)
1154 ir_raw_load_modules(&new_protocols);
1155
1156 if (new_protocols != old_protocols) {
1157 *current_protocols = new_protocols;
1158 IR_dprintk(1, "Protocols changed to 0x%llx\n",
1159 (long long)new_protocols);
1160 }
1161
1162
1163
1164
1165
1166
1167
1168
1169 if (dev->s_filter && filter->mask) {
1170 if (new_protocols)
1171 rc = dev->s_filter(dev, filter);
1172 else
1173 rc = -1;
1174
1175 if (rc < 0) {
1176 filter->data = 0;
1177 filter->mask = 0;
1178 dev->s_filter(dev, filter);
1179 }
1180 }
1181
1182 rc = len;
1183
1184out:
1185 mutex_unlock(&dev->lock);
1186 return rc;
1187}
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206static ssize_t show_filter(struct device *device,
1207 struct device_attribute *attr,
1208 char *buf)
1209{
1210 struct rc_dev *dev = to_rc_dev(device);
1211 struct rc_filter_attribute *fattr = to_rc_filter_attr(attr);
1212 struct rc_scancode_filter *filter;
1213 u32 val;
1214
1215
1216 if (!dev)
1217 return -EINVAL;
1218
1219 if (!atomic_read(&dev->initialized))
1220 return -ERESTARTSYS;
1221
1222 mutex_lock(&dev->lock);
1223
1224 if (fattr->type == RC_FILTER_NORMAL)
1225 filter = &dev->scancode_filter;
1226 else
1227 filter = &dev->scancode_wakeup_filter;
1228
1229 if (fattr->mask)
1230 val = filter->mask;
1231 else
1232 val = filter->data;
1233 mutex_unlock(&dev->lock);
1234
1235 return sprintf(buf, "%#x\n", val);
1236}
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257static ssize_t store_filter(struct device *device,
1258 struct device_attribute *attr,
1259 const char *buf, size_t len)
1260{
1261 struct rc_dev *dev = to_rc_dev(device);
1262 struct rc_filter_attribute *fattr = to_rc_filter_attr(attr);
1263 struct rc_scancode_filter new_filter, *filter;
1264 int ret;
1265 unsigned long val;
1266 int (*set_filter)(struct rc_dev *dev, struct rc_scancode_filter *filter);
1267
1268
1269 if (!dev)
1270 return -EINVAL;
1271
1272 if (!atomic_read(&dev->initialized))
1273 return -ERESTARTSYS;
1274
1275 ret = kstrtoul(buf, 0, &val);
1276 if (ret < 0)
1277 return ret;
1278
1279 if (fattr->type == RC_FILTER_NORMAL) {
1280 set_filter = dev->s_filter;
1281 filter = &dev->scancode_filter;
1282 } else {
1283 set_filter = dev->s_wakeup_filter;
1284 filter = &dev->scancode_wakeup_filter;
1285 }
1286
1287 if (!set_filter)
1288 return -EINVAL;
1289
1290 mutex_lock(&dev->lock);
1291
1292 new_filter = *filter;
1293 if (fattr->mask)
1294 new_filter.mask = val;
1295 else
1296 new_filter.data = val;
1297
1298 if (fattr->type == RC_FILTER_WAKEUP) {
1299
1300
1301
1302
1303 if (dev->wakeup_protocol != RC_TYPE_UNKNOWN)
1304 ret = rc_validate_filter(dev, &new_filter);
1305 else
1306 ret = -EINVAL;
1307
1308 if (ret != 0)
1309 goto unlock;
1310 }
1311
1312 if (fattr->type == RC_FILTER_NORMAL && !dev->enabled_protocols &&
1313 val) {
1314
1315 ret = -EINVAL;
1316 goto unlock;
1317 }
1318
1319 ret = set_filter(dev, &new_filter);
1320 if (ret < 0)
1321 goto unlock;
1322
1323 *filter = new_filter;
1324
1325unlock:
1326 mutex_unlock(&dev->lock);
1327 return (ret < 0) ? ret : len;
1328}
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338static const char * const proto_variant_names[] = {
1339 [RC_TYPE_UNKNOWN] = "unknown",
1340 [RC_TYPE_OTHER] = "other",
1341 [RC_TYPE_RC5] = "rc-5",
1342 [RC_TYPE_RC5X_20] = "rc-5x-20",
1343 [RC_TYPE_RC5_SZ] = "rc-5-sz",
1344 [RC_TYPE_JVC] = "jvc",
1345 [RC_TYPE_SONY12] = "sony-12",
1346 [RC_TYPE_SONY15] = "sony-15",
1347 [RC_TYPE_SONY20] = "sony-20",
1348 [RC_TYPE_NEC] = "nec",
1349 [RC_TYPE_NECX] = "nec-x",
1350 [RC_TYPE_NEC32] = "nec-32",
1351 [RC_TYPE_SANYO] = "sanyo",
1352 [RC_TYPE_MCIR2_KBD] = "mcir2-kbd",
1353 [RC_TYPE_MCIR2_MSE] = "mcir2-mse",
1354 [RC_TYPE_RC6_0] = "rc-6-0",
1355 [RC_TYPE_RC6_6A_20] = "rc-6-6a-20",
1356 [RC_TYPE_RC6_6A_24] = "rc-6-6a-24",
1357 [RC_TYPE_RC6_6A_32] = "rc-6-6a-32",
1358 [RC_TYPE_RC6_MCE] = "rc-6-mce",
1359 [RC_TYPE_SHARP] = "sharp",
1360 [RC_TYPE_XMP] = "xmp",
1361 [RC_TYPE_CEC] = "cec",
1362};
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378static ssize_t show_wakeup_protocols(struct device *device,
1379 struct device_attribute *mattr,
1380 char *buf)
1381{
1382 struct rc_dev *dev = to_rc_dev(device);
1383 u64 allowed;
1384 enum rc_type enabled;
1385 char *tmp = buf;
1386 int i;
1387
1388
1389 if (!dev)
1390 return -EINVAL;
1391
1392 if (!atomic_read(&dev->initialized))
1393 return -ERESTARTSYS;
1394
1395 mutex_lock(&dev->lock);
1396
1397 allowed = dev->allowed_wakeup_protocols;
1398 enabled = dev->wakeup_protocol;
1399
1400 mutex_unlock(&dev->lock);
1401
1402 IR_dprintk(1, "%s: allowed - 0x%llx, enabled - %d\n",
1403 __func__, (long long)allowed, enabled);
1404
1405 for (i = 0; i < ARRAY_SIZE(proto_variant_names); i++) {
1406 if (allowed & (1ULL << i)) {
1407 if (i == enabled)
1408 tmp += sprintf(tmp, "[%s] ",
1409 proto_variant_names[i]);
1410 else
1411 tmp += sprintf(tmp, "%s ",
1412 proto_variant_names[i]);
1413 }
1414 }
1415
1416 if (tmp != buf)
1417 tmp--;
1418 *tmp = '\n';
1419
1420 return tmp + 1 - buf;
1421}
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437static ssize_t store_wakeup_protocols(struct device *device,
1438 struct device_attribute *mattr,
1439 const char *buf, size_t len)
1440{
1441 struct rc_dev *dev = to_rc_dev(device);
1442 enum rc_type protocol;
1443 ssize_t rc;
1444 u64 allowed;
1445 int i;
1446
1447
1448 if (!dev)
1449 return -EINVAL;
1450
1451 if (!atomic_read(&dev->initialized))
1452 return -ERESTARTSYS;
1453
1454 mutex_lock(&dev->lock);
1455
1456 allowed = dev->allowed_wakeup_protocols;
1457
1458 if (sysfs_streq(buf, "none")) {
1459 protocol = RC_TYPE_UNKNOWN;
1460 } else {
1461 for (i = 0; i < ARRAY_SIZE(proto_variant_names); i++) {
1462 if ((allowed & (1ULL << i)) &&
1463 sysfs_streq(buf, proto_variant_names[i])) {
1464 protocol = i;
1465 break;
1466 }
1467 }
1468
1469 if (i == ARRAY_SIZE(proto_variant_names)) {
1470 rc = -EINVAL;
1471 goto out;
1472 }
1473
1474 if (dev->encode_wakeup) {
1475 u64 mask = 1ULL << protocol;
1476
1477 ir_raw_load_modules(&mask);
1478 if (!mask) {
1479 rc = -EINVAL;
1480 goto out;
1481 }
1482 }
1483 }
1484
1485 if (dev->wakeup_protocol != protocol) {
1486 dev->wakeup_protocol = protocol;
1487 IR_dprintk(1, "Wakeup protocol changed to %d\n", protocol);
1488
1489 if (protocol == RC_TYPE_RC6_MCE)
1490 dev->scancode_wakeup_filter.data = 0x800f0000;
1491 else
1492 dev->scancode_wakeup_filter.data = 0;
1493 dev->scancode_wakeup_filter.mask = 0;
1494
1495 rc = dev->s_wakeup_filter(dev, &dev->scancode_wakeup_filter);
1496 if (rc == 0)
1497 rc = len;
1498 } else {
1499 rc = len;
1500 }
1501
1502out:
1503 mutex_unlock(&dev->lock);
1504 return rc;
1505}
1506
1507static void rc_dev_release(struct device *device)
1508{
1509 struct rc_dev *dev = to_rc_dev(device);
1510
1511 kfree(dev);
1512}
1513
1514#define ADD_HOTPLUG_VAR(fmt, val...) \
1515 do { \
1516 int err = add_uevent_var(env, fmt, val); \
1517 if (err) \
1518 return err; \
1519 } while (0)
1520
1521static int rc_dev_uevent(struct device *device, struct kobj_uevent_env *env)
1522{
1523 struct rc_dev *dev = to_rc_dev(device);
1524
1525 if (dev->rc_map.name)
1526 ADD_HOTPLUG_VAR("NAME=%s", dev->rc_map.name);
1527 if (dev->driver_name)
1528 ADD_HOTPLUG_VAR("DRV_NAME=%s", dev->driver_name);
1529
1530 return 0;
1531}
1532
1533
1534
1535
1536static DEVICE_ATTR(protocols, 0644, show_protocols, store_protocols);
1537static DEVICE_ATTR(wakeup_protocols, 0644, show_wakeup_protocols,
1538 store_wakeup_protocols);
1539static RC_FILTER_ATTR(filter, S_IRUGO|S_IWUSR,
1540 show_filter, store_filter, RC_FILTER_NORMAL, false);
1541static RC_FILTER_ATTR(filter_mask, S_IRUGO|S_IWUSR,
1542 show_filter, store_filter, RC_FILTER_NORMAL, true);
1543static RC_FILTER_ATTR(wakeup_filter, S_IRUGO|S_IWUSR,
1544 show_filter, store_filter, RC_FILTER_WAKEUP, false);
1545static RC_FILTER_ATTR(wakeup_filter_mask, S_IRUGO|S_IWUSR,
1546 show_filter, store_filter, RC_FILTER_WAKEUP, true);
1547
1548static struct attribute *rc_dev_protocol_attrs[] = {
1549 &dev_attr_protocols.attr,
1550 NULL,
1551};
1552
1553static struct attribute_group rc_dev_protocol_attr_grp = {
1554 .attrs = rc_dev_protocol_attrs,
1555};
1556
1557static struct attribute *rc_dev_filter_attrs[] = {
1558 &dev_attr_filter.attr.attr,
1559 &dev_attr_filter_mask.attr.attr,
1560 NULL,
1561};
1562
1563static struct attribute_group rc_dev_filter_attr_grp = {
1564 .attrs = rc_dev_filter_attrs,
1565};
1566
1567static struct attribute *rc_dev_wakeup_filter_attrs[] = {
1568 &dev_attr_wakeup_filter.attr.attr,
1569 &dev_attr_wakeup_filter_mask.attr.attr,
1570 &dev_attr_wakeup_protocols.attr,
1571 NULL,
1572};
1573
1574static struct attribute_group rc_dev_wakeup_filter_attr_grp = {
1575 .attrs = rc_dev_wakeup_filter_attrs,
1576};
1577
1578static struct device_type rc_dev_type = {
1579 .release = rc_dev_release,
1580 .uevent = rc_dev_uevent,
1581};
1582
1583struct rc_dev *rc_allocate_device(enum rc_driver_type type)
1584{
1585 struct rc_dev *dev;
1586
1587 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1588 if (!dev)
1589 return NULL;
1590
1591 if (type != RC_DRIVER_IR_RAW_TX) {
1592 dev->input_dev = input_allocate_device();
1593 if (!dev->input_dev) {
1594 kfree(dev);
1595 return NULL;
1596 }
1597
1598 dev->input_dev->getkeycode = ir_getkeycode;
1599 dev->input_dev->setkeycode = ir_setkeycode;
1600 input_set_drvdata(dev->input_dev, dev);
1601
1602 setup_timer(&dev->timer_keyup, ir_timer_keyup,
1603 (unsigned long)dev);
1604
1605 spin_lock_init(&dev->rc_map.lock);
1606 spin_lock_init(&dev->keylock);
1607 }
1608 mutex_init(&dev->lock);
1609
1610 dev->dev.type = &rc_dev_type;
1611 dev->dev.class = &rc_class;
1612 device_initialize(&dev->dev);
1613
1614 dev->driver_type = type;
1615
1616 __module_get(THIS_MODULE);
1617 return dev;
1618}
1619EXPORT_SYMBOL_GPL(rc_allocate_device);
1620
1621void rc_free_device(struct rc_dev *dev)
1622{
1623 if (!dev)
1624 return;
1625
1626 input_free_device(dev->input_dev);
1627
1628 put_device(&dev->dev);
1629
1630
1631
1632
1633 module_put(THIS_MODULE);
1634}
1635EXPORT_SYMBOL_GPL(rc_free_device);
1636
1637static void devm_rc_alloc_release(struct device *dev, void *res)
1638{
1639 rc_free_device(*(struct rc_dev **)res);
1640}
1641
1642struct rc_dev *devm_rc_allocate_device(struct device *dev,
1643 enum rc_driver_type type)
1644{
1645 struct rc_dev **dr, *rc;
1646
1647 dr = devres_alloc(devm_rc_alloc_release, sizeof(*dr), GFP_KERNEL);
1648 if (!dr)
1649 return NULL;
1650
1651 rc = rc_allocate_device(type);
1652 if (!rc) {
1653 devres_free(dr);
1654 return NULL;
1655 }
1656
1657 rc->dev.parent = dev;
1658 rc->managed_alloc = true;
1659 *dr = rc;
1660 devres_add(dev, dr);
1661
1662 return rc;
1663}
1664EXPORT_SYMBOL_GPL(devm_rc_allocate_device);
1665
1666static int rc_setup_rx_device(struct rc_dev *dev)
1667{
1668 int rc;
1669 struct rc_map *rc_map;
1670 u64 rc_type;
1671
1672 if (!dev->map_name)
1673 return -EINVAL;
1674
1675 rc_map = rc_map_get(dev->map_name);
1676 if (!rc_map)
1677 rc_map = rc_map_get(RC_MAP_EMPTY);
1678 if (!rc_map || !rc_map->scan || rc_map->size == 0)
1679 return -EINVAL;
1680
1681 rc = ir_setkeytable(dev, rc_map);
1682 if (rc)
1683 return rc;
1684
1685 rc_type = BIT_ULL(rc_map->rc_type);
1686
1687 if (dev->change_protocol) {
1688 rc = dev->change_protocol(dev, &rc_type);
1689 if (rc < 0)
1690 goto out_table;
1691 dev->enabled_protocols = rc_type;
1692 }
1693
1694 if (dev->driver_type == RC_DRIVER_IR_RAW)
1695 ir_raw_load_modules(&rc_type);
1696
1697 set_bit(EV_KEY, dev->input_dev->evbit);
1698 set_bit(EV_REP, dev->input_dev->evbit);
1699 set_bit(EV_MSC, dev->input_dev->evbit);
1700 set_bit(MSC_SCAN, dev->input_dev->mscbit);
1701 if (dev->open)
1702 dev->input_dev->open = ir_open;
1703 if (dev->close)
1704 dev->input_dev->close = ir_close;
1705
1706
1707
1708
1709
1710
1711
1712 dev->input_dev->rep[REP_DELAY] = 500;
1713
1714
1715
1716
1717
1718
1719 dev->input_dev->rep[REP_PERIOD] = 125;
1720
1721 dev->input_dev->dev.parent = &dev->dev;
1722 memcpy(&dev->input_dev->id, &dev->input_id, sizeof(dev->input_id));
1723 dev->input_dev->phys = dev->input_phys;
1724 dev->input_dev->name = dev->input_name;
1725
1726
1727 rc = input_register_device(dev->input_dev);
1728 if (rc)
1729 goto out_table;
1730
1731 return 0;
1732
1733out_table:
1734 ir_free_table(&dev->rc_map);
1735
1736 return rc;
1737}
1738
1739static void rc_free_rx_device(struct rc_dev *dev)
1740{
1741 if (!dev || dev->driver_type == RC_DRIVER_IR_RAW_TX)
1742 return;
1743
1744 ir_free_table(&dev->rc_map);
1745
1746 input_unregister_device(dev->input_dev);
1747 dev->input_dev = NULL;
1748}
1749
1750int rc_register_device(struct rc_dev *dev)
1751{
1752 static bool raw_init;
1753 const char *path;
1754 int attr = 0;
1755 int minor;
1756 int rc;
1757
1758 if (!dev)
1759 return -EINVAL;
1760
1761 minor = ida_simple_get(&rc_ida, 0, RC_DEV_MAX, GFP_KERNEL);
1762 if (minor < 0)
1763 return minor;
1764
1765 dev->minor = minor;
1766 dev_set_name(&dev->dev, "rc%u", dev->minor);
1767 dev_set_drvdata(&dev->dev, dev);
1768 atomic_set(&dev->initialized, 0);
1769
1770 dev->dev.groups = dev->sysfs_groups;
1771 if (dev->driver_type != RC_DRIVER_IR_RAW_TX)
1772 dev->sysfs_groups[attr++] = &rc_dev_protocol_attr_grp;
1773 if (dev->s_filter)
1774 dev->sysfs_groups[attr++] = &rc_dev_filter_attr_grp;
1775 if (dev->s_wakeup_filter)
1776 dev->sysfs_groups[attr++] = &rc_dev_wakeup_filter_attr_grp;
1777 dev->sysfs_groups[attr++] = NULL;
1778
1779 rc = device_add(&dev->dev);
1780 if (rc)
1781 goto out_unlock;
1782
1783 path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);
1784 dev_info(&dev->dev, "%s as %s\n",
1785 dev->input_name ?: "Unspecified device", path ?: "N/A");
1786 kfree(path);
1787
1788 if (dev->driver_type == RC_DRIVER_IR_RAW ||
1789 dev->driver_type == RC_DRIVER_IR_RAW_TX) {
1790 if (!raw_init) {
1791 request_module_nowait("ir-lirc-codec");
1792 raw_init = true;
1793 }
1794 rc = ir_raw_event_register(dev);
1795 if (rc < 0)
1796 goto out_dev;
1797 }
1798
1799 if (dev->driver_type != RC_DRIVER_IR_RAW_TX) {
1800 rc = rc_setup_rx_device(dev);
1801 if (rc)
1802 goto out_raw;
1803 }
1804
1805
1806 atomic_set(&dev->initialized, 1);
1807
1808 IR_dprintk(1, "Registered rc%u (driver: %s)\n",
1809 dev->minor,
1810 dev->driver_name ? dev->driver_name : "unknown");
1811
1812 return 0;
1813
1814out_raw:
1815 ir_raw_event_unregister(dev);
1816out_dev:
1817 device_del(&dev->dev);
1818out_unlock:
1819 ida_simple_remove(&rc_ida, minor);
1820 return rc;
1821}
1822EXPORT_SYMBOL_GPL(rc_register_device);
1823
1824static void devm_rc_release(struct device *dev, void *res)
1825{
1826 rc_unregister_device(*(struct rc_dev **)res);
1827}
1828
1829int devm_rc_register_device(struct device *parent, struct rc_dev *dev)
1830{
1831 struct rc_dev **dr;
1832 int ret;
1833
1834 dr = devres_alloc(devm_rc_release, sizeof(*dr), GFP_KERNEL);
1835 if (!dr)
1836 return -ENOMEM;
1837
1838 ret = rc_register_device(dev);
1839 if (ret) {
1840 devres_free(dr);
1841 return ret;
1842 }
1843
1844 *dr = dev;
1845 devres_add(parent, dr);
1846
1847 return 0;
1848}
1849EXPORT_SYMBOL_GPL(devm_rc_register_device);
1850
1851void rc_unregister_device(struct rc_dev *dev)
1852{
1853 if (!dev)
1854 return;
1855
1856 del_timer_sync(&dev->timer_keyup);
1857
1858 if (dev->driver_type == RC_DRIVER_IR_RAW)
1859 ir_raw_event_unregister(dev);
1860
1861 rc_free_rx_device(dev);
1862
1863 device_del(&dev->dev);
1864
1865 ida_simple_remove(&rc_ida, dev->minor);
1866
1867 if (!dev->managed_alloc)
1868 rc_free_device(dev);
1869}
1870
1871EXPORT_SYMBOL_GPL(rc_unregister_device);
1872
1873
1874
1875
1876
1877static int __init rc_core_init(void)
1878{
1879 int rc = class_register(&rc_class);
1880 if (rc) {
1881 pr_err("rc_core: unable to register rc class\n");
1882 return rc;
1883 }
1884
1885 led_trigger_register_simple("rc-feedback", &led_feedback);
1886 rc_map_register(&empty_map);
1887
1888 return 0;
1889}
1890
1891static void __exit rc_core_exit(void)
1892{
1893 class_unregister(&rc_class);
1894 led_trigger_unregister_simple(led_feedback);
1895 rc_map_unregister(&empty_map);
1896}
1897
1898subsys_initcall(rc_core_init);
1899module_exit(rc_core_exit);
1900
1901int rc_core_debug;
1902EXPORT_SYMBOL_GPL(rc_core_debug);
1903module_param_named(debug, rc_core_debug, int, 0644);
1904
1905MODULE_AUTHOR("Mauro Carvalho Chehab");
1906MODULE_LICENSE("GPL");
1907