Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
rc-main.c
Go to the documentation of this file.
1 /* rc-main.c - Remote Controller core module
2  *
3  * Copyright (C) 2009-2010 by Mauro Carvalho Chehab <[email protected]>
4  *
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.
8  *
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.
13  */
14 
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"
23 
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
27 
28 /* FIXME: IR_KEYPRESS_TIMEOUT should be protocol specific */
29 #define IR_KEYPRESS_TIMEOUT 250
30 
31 /* Used to keep track of known keymaps */
32 static LIST_HEAD(rc_map_list);
33 static DEFINE_SPINLOCK(rc_map_lock);
34 
35 static struct rc_map_list *seek_rc_map(const char *name)
36 {
37  struct rc_map_list *map = NULL;
38 
39  spin_lock(&rc_map_lock);
41  if (!strcmp(name, map->map.name)) {
42  spin_unlock(&rc_map_lock);
43  return map;
44  }
45  }
46  spin_unlock(&rc_map_lock);
47 
48  return NULL;
49 }
50 
51 struct rc_map *rc_map_get(const char *name)
52 {
53 
54  struct rc_map_list *map;
55 
56  map = seek_rc_map(name);
57 #ifdef MODULE
58  if (!map) {
59  int rc = request_module(name);
60  if (rc < 0) {
61  printk(KERN_ERR "Couldn't load IR keymap %s\n", name);
62  return NULL;
63  }
64  msleep(20); /* Give some time for IR to register */
65 
66  map = seek_rc_map(name);
67  }
68 #endif
69  if (!map) {
70  printk(KERN_ERR "IR keymap %s not found\n", name);
71  return NULL;
72  }
73 
74  printk(KERN_INFO "Registered IR keymap %s\n", map->map.name);
75 
76  return &map->map;
77 }
79 
80 int rc_map_register(struct rc_map_list *map)
81 {
82  spin_lock(&rc_map_lock);
84  spin_unlock(&rc_map_lock);
85  return 0;
86 }
88 
89 void rc_map_unregister(struct rc_map_list *map)
90 {
91  spin_lock(&rc_map_lock);
92  list_del(&map->list);
93  spin_unlock(&rc_map_lock);
94 }
96 
97 
98 static struct rc_map_table empty[] = {
99  { 0x2a, KEY_COFFEE },
100 };
101 
102 static struct rc_map_list empty_map = {
103  .map = {
104  .scan = empty,
105  .size = ARRAY_SIZE(empty),
106  .rc_type = RC_TYPE_UNKNOWN, /* Legacy IR type */
107  .name = RC_MAP_EMPTY,
108  }
109 };
110 
122 static int ir_create_table(struct rc_map *rc_map,
123  const char *name, u64 rc_type, size_t size)
124 {
125  rc_map->name = name;
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);
130  if (!rc_map->scan)
131  return -ENOMEM;
132 
133  IR_dprintk(1, "Allocated space for %u keycode entries (%u bytes)\n",
134  rc_map->size, rc_map->alloc);
135  return 0;
136 }
137 
145 static void ir_free_table(struct rc_map *rc_map)
146 {
147  rc_map->size = 0;
148  kfree(rc_map->scan);
149  rc_map->scan = NULL;
150 }
151 
161 static int ir_resize_table(struct rc_map *rc_map, gfp_t gfp_flags)
162 {
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;
167 
168  if (rc_map->size == rc_map->len) {
169  /* All entries in use -> grow keytable */
170  if (rc_map->alloc >= IR_TAB_MAX_SIZE)
171  return -ENOMEM;
172 
173  newalloc *= 2;
174  IR_dprintk(1, "Growing table to %u bytes\n", newalloc);
175  }
176 
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 */
179  newalloc /= 2;
180  IR_dprintk(1, "Shrinking table to %u bytes\n", newalloc);
181  }
182 
183  if (newalloc == oldalloc)
184  return 0;
185 
186  newscan = kmalloc(newalloc, gfp_flags);
187  if (!newscan) {
188  IR_dprintk(1, "Failed to kmalloc %u bytes\n", newalloc);
189  return -ENOMEM;
190  }
191 
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);
196  kfree(oldscan);
197  return 0;
198 }
199 
211 static unsigned int ir_update_mapping(struct rc_dev *dev,
212  struct rc_map *rc_map,
213  unsigned int index,
214  unsigned int new_keycode)
215 {
216  int old_keycode = rc_map->scan[index].keycode;
217  int i;
218 
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);
223  rc_map->len--;
224  memmove(&rc_map->scan[index], &rc_map->scan[index+ 1],
225  (rc_map->len - index) * sizeof(struct rc_map_table));
226  } else {
227  IR_dprintk(1, "#%d: %s scan 0x%04x with key 0x%04x\n",
228  index,
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);
233  }
234 
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);
242  break;
243  }
244  }
245 
246  /* Possibly shrink the keytable, failure is not a problem */
247  ir_resize_table(rc_map, GFP_ATOMIC);
248  }
249 
250  return old_keycode;
251 }
252 
267 static unsigned int ir_establish_scancode(struct rc_dev *dev,
268  struct rc_map *rc_map,
269  unsigned int scancode,
270  bool resize)
271 {
272  unsigned int i;
273 
274  /*
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.
281  */
282  if (dev->scanmask)
283  scancode &= dev->scanmask;
284 
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)
288  return i;
289 
290  /* Keytable is sorted from lowest to highest scancode */
291  if (rc_map->scan[i].scancode >= scancode)
292  break;
293  }
294 
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))
298  return -1U;
299  }
300 
301  /* i is the proper index to insert our new keycode */
302  if (i < rc_map->len)
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;
307  rc_map->len++;
308 
309  return i;
310 }
311 
321 static int ir_setkeycode(struct input_dev *idev,
322  const struct input_keymap_entry *ke,
323  unsigned int *old_keycode)
324 {
325  struct rc_dev *rdev = input_get_drvdata(idev);
326  struct rc_map *rc_map = &rdev->rc_map;
327  unsigned int index;
328  unsigned int scancode;
329  int retval = 0;
330  unsigned long flags;
331 
332  spin_lock_irqsave(&rc_map->lock, flags);
333 
334  if (ke->flags & INPUT_KEYMAP_BY_INDEX) {
335  index = ke->index;
336  if (index >= rc_map->len) {
337  retval = -EINVAL;
338  goto out;
339  }
340  } else {
341  retval = input_scancode_to_scalar(ke, &scancode);
342  if (retval)
343  goto out;
344 
345  index = ir_establish_scancode(rdev, rc_map, scancode, true);
346  if (index >= rc_map->len) {
347  retval = -ENOMEM;
348  goto out;
349  }
350  }
351 
352  *old_keycode = ir_update_mapping(rdev, rc_map, index, ke->keycode);
353 
354 out:
355  spin_unlock_irqrestore(&rc_map->lock, flags);
356  return retval;
357 }
358 
368 static int ir_setkeytable(struct rc_dev *dev,
369  const struct rc_map *from)
370 {
371  struct rc_map *rc_map = &dev->rc_map;
372  unsigned int i, index;
373  int rc;
374 
375  rc = ir_create_table(rc_map, from->name,
376  from->rc_type, from->size);
377  if (rc)
378  return rc;
379 
380  IR_dprintk(1, "Allocated space for %u keycode entries (%u bytes)\n",
381  rc_map->size, rc_map->alloc);
382 
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) {
387  rc = -ENOMEM;
388  break;
389  }
390 
391  ir_update_mapping(dev, rc_map, index,
392  from->scan[i].keycode);
393  }
394 
395  if (rc)
396  ir_free_table(rc_map);
397 
398  return rc;
399 }
400 
410 static unsigned int ir_lookup_by_scancode(const struct rc_map *rc_map,
411  unsigned int scancode)
412 {
413  int start = 0;
414  int end = rc_map->len - 1;
415  int mid;
416 
417  while (start <= end) {
418  mid = (start + end) / 2;
419  if (rc_map->scan[mid].scancode < scancode)
420  start = mid + 1;
421  else if (rc_map->scan[mid].scancode > scancode)
422  end = mid - 1;
423  else
424  return mid;
425  }
426 
427  return -1U;
428 }
429 
439 static int ir_getkeycode(struct input_dev *idev,
440  struct input_keymap_entry *ke)
441 {
442  struct rc_dev *rdev = input_get_drvdata(idev);
443  struct rc_map *rc_map = &rdev->rc_map;
444  struct rc_map_table *entry;
445  unsigned long flags;
446  unsigned int index;
447  unsigned int scancode;
448  int retval;
449 
450  spin_lock_irqsave(&rc_map->lock, flags);
451 
452  if (ke->flags & INPUT_KEYMAP_BY_INDEX) {
453  index = ke->index;
454  } else {
455  retval = input_scancode_to_scalar(ke, &scancode);
456  if (retval)
457  goto out;
458 
459  index = ir_lookup_by_scancode(rc_map, scancode);
460  }
461 
462  if (index < rc_map->len) {
463  entry = &rc_map->scan[index];
464 
465  ke->index = index;
466  ke->keycode = entry->keycode;
467  ke->len = sizeof(entry->scancode);
468  memcpy(ke->scancode, &entry->scancode, sizeof(entry->scancode));
469 
470  } else if (!(ke->flags & INPUT_KEYMAP_BY_INDEX)) {
471  /*
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].
475  */
476  ke->index = index;
477  ke->keycode = KEY_RESERVED;
478  } else {
479  retval = -EINVAL;
480  goto out;
481  }
482 
483  retval = 0;
484 
485 out:
486  spin_unlock_irqrestore(&rc_map->lock, flags);
487  return retval;
488 }
489 
500 u32 rc_g_keycode_from_table(struct rc_dev *dev, u32 scancode)
501 {
502  struct rc_map *rc_map = &dev->rc_map;
503  unsigned int keycode;
504  unsigned int index;
505  unsigned long flags;
506 
507  spin_lock_irqsave(&rc_map->lock, flags);
508 
509  index = ir_lookup_by_scancode(rc_map, scancode);
510  keycode = index < rc_map->len ?
511  rc_map->scan[index].keycode : KEY_RESERVED;
512 
513  spin_unlock_irqrestore(&rc_map->lock, flags);
514 
515  if (keycode != KEY_RESERVED)
516  IR_dprintk(1, "%s: scancode 0x%04x keycode 0x%02x\n",
517  dev->input_name, scancode, keycode);
518 
519  return keycode;
520 }
522 
531 static void ir_do_keyup(struct rc_dev *dev, bool sync)
532 {
533  if (!dev->keypressed)
534  return;
535 
536  IR_dprintk(1, "keyup key 0x%04x\n", dev->last_keycode);
537  input_report_key(dev->input_dev, dev->last_keycode, 0);
538  if (sync)
539  input_sync(dev->input_dev);
540  dev->keypressed = false;
541 }
542 
550 void rc_keyup(struct rc_dev *dev)
551 {
552  unsigned long flags;
553 
554  spin_lock_irqsave(&dev->keylock, flags);
555  ir_do_keyup(dev, true);
556  spin_unlock_irqrestore(&dev->keylock, flags);
557 }
559 
567 static void ir_timer_keyup(unsigned long cookie)
568 {
569  struct rc_dev *dev = (struct rc_dev *)cookie;
570  unsigned long flags;
571 
572  /*
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.
576  *
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.
581  */
582  spin_lock_irqsave(&dev->keylock, flags);
584  ir_do_keyup(dev, true);
585  spin_unlock_irqrestore(&dev->keylock, flags);
586 }
587 
596 void rc_repeat(struct rc_dev *dev)
597 {
598  unsigned long flags;
599 
600  spin_lock_irqsave(&dev->keylock, flags);
601 
603  input_sync(dev->input_dev);
604 
605  if (!dev->keypressed)
606  goto out;
607 
609  mod_timer(&dev->timer_keyup, dev->keyup_jiffies);
610 
611 out:
612  spin_unlock_irqrestore(&dev->keylock, flags);
613 }
615 
626 static void ir_do_keydown(struct rc_dev *dev, int scancode,
627  u32 keycode, u8 toggle)
628 {
629  bool new_event = !dev->keypressed ||
630  dev->last_scancode != scancode ||
631  dev->last_toggle != toggle;
632 
633  if (new_event && dev->keypressed)
634  ir_do_keyup(dev, false);
635 
636  input_event(dev->input_dev, EV_MSC, MSC_SCAN, scancode);
637 
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;
644 
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);
649  }
650 
651  input_sync(dev->input_dev);
652 }
653 
664 void rc_keydown(struct rc_dev *dev, int scancode, u8 toggle)
665 {
666  unsigned long flags;
667  u32 keycode = rc_g_keycode_from_table(dev, scancode);
668 
669  spin_lock_irqsave(&dev->keylock, flags);
670  ir_do_keydown(dev, scancode, keycode, toggle);
671 
672  if (dev->keypressed) {
674  mod_timer(&dev->timer_keyup, dev->keyup_jiffies);
675  }
676  spin_unlock_irqrestore(&dev->keylock, flags);
677 }
679 
691 void rc_keydown_notimeout(struct rc_dev *dev, int scancode, u8 toggle)
692 {
693  unsigned long flags;
694  u32 keycode = rc_g_keycode_from_table(dev, scancode);
695 
696  spin_lock_irqsave(&dev->keylock, flags);
697  ir_do_keydown(dev, scancode, keycode, toggle);
698  spin_unlock_irqrestore(&dev->keylock, flags);
699 }
701 
702 static int ir_open(struct input_dev *idev)
703 {
704  struct rc_dev *rdev = input_get_drvdata(idev);
705 
706  return rdev->open(rdev);
707 }
708 
709 static void ir_close(struct input_dev *idev)
710 {
711  struct rc_dev *rdev = input_get_drvdata(idev);
712 
713  if (rdev)
714  rdev->close(rdev);
715 }
716 
717 /* class for /sys/class/rc */
718 static char *ir_devnode(struct device *dev, umode_t *mode)
719 {
720  return kasprintf(GFP_KERNEL, "rc/%s", dev_name(dev));
721 }
722 
723 static struct class ir_input_class = {
724  .name = "rc",
725  .devnode = ir_devnode,
726 };
727 
728 static struct {
730  char *name;
731 } proto_names[] = {
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" },
743 };
744 
745 #define PROTO_NONE "none"
746 
761 static ssize_t show_protocols(struct device *device,
762  struct device_attribute *mattr, char *buf)
763 {
764  struct rc_dev *dev = to_rc_dev(device);
765  u64 allowed, enabled;
766  char *tmp = buf;
767  int i;
768 
769  /* Device is being removed */
770  if (!dev)
771  return -EINVAL;
772 
773  mutex_lock(&dev->lock);
774 
775  if (dev->driver_type == RC_DRIVER_SCANCODE) {
776  enabled = dev->rc_map.rc_type;
777  allowed = dev->allowed_protos;
778  } else if (dev->raw) {
779  enabled = dev->raw->enabled_protocols;
780  allowed = ir_raw_get_allowed_protocols();
781  } else
782  return -ENODEV;
783 
784  IR_dprintk(1, "allowed - 0x%llx, enabled - 0x%llx\n",
785  (long long)allowed,
786  (long long)enabled);
787 
788  for (i = 0; i < ARRAY_SIZE(proto_names); i++) {
789  if (allowed & enabled & proto_names[i].type)
790  tmp += sprintf(tmp, "[%s] ", proto_names[i].name);
791  else if (allowed & proto_names[i].type)
792  tmp += sprintf(tmp, "%s ", proto_names[i].name);
793  }
794 
795  if (tmp != buf)
796  tmp--;
797  *tmp = '\n';
798 
799  mutex_unlock(&dev->lock);
800 
801  return tmp + 1 - buf;
802 }
803 
823 static ssize_t store_protocols(struct device *device,
824  struct device_attribute *mattr,
825  const char *data,
826  size_t len)
827 {
828  struct rc_dev *dev = to_rc_dev(device);
829  bool enable, disable;
830  const char *tmp;
831  u64 type;
832  u64 mask;
833  int rc, i, count = 0;
834  unsigned long flags;
835  ssize_t ret;
836 
837  /* Device is being removed */
838  if (!dev)
839  return -EINVAL;
840 
841  mutex_lock(&dev->lock);
842 
843  if (dev->driver_type == RC_DRIVER_SCANCODE)
844  type = dev->rc_map.rc_type;
845  else if (dev->raw)
846  type = dev->raw->enabled_protocols;
847  else {
848  IR_dprintk(1, "Protocol switching not supported\n");
849  ret = -EINVAL;
850  goto out;
851  }
852 
853  while ((tmp = strsep((char **) &data, " \n")) != NULL) {
854  if (!*tmp)
855  break;
856 
857  if (*tmp == '+') {
858  enable = true;
859  disable = false;
860  tmp++;
861  } else if (*tmp == '-') {
862  enable = false;
863  disable = true;
864  tmp++;
865  } else {
866  enable = false;
867  disable = false;
868  }
869 
870  if (!enable && !disable && !strncasecmp(tmp, PROTO_NONE, sizeof(PROTO_NONE))) {
871  tmp += sizeof(PROTO_NONE);
872  mask = 0;
873  count++;
874  } else {
875  for (i = 0; i < ARRAY_SIZE(proto_names); i++) {
876  if (!strcasecmp(tmp, proto_names[i].name)) {
877  tmp += strlen(proto_names[i].name);
878  mask = proto_names[i].type;
879  break;
880  }
881  }
882  if (i == ARRAY_SIZE(proto_names)) {
883  IR_dprintk(1, "Unknown protocol: '%s'\n", tmp);
884  ret = -EINVAL;
885  goto out;
886  }
887  count++;
888  }
889 
890  if (enable)
891  type |= mask;
892  else if (disable)
893  type &= ~mask;
894  else
895  type = mask;
896  }
897 
898  if (!count) {
899  IR_dprintk(1, "Protocol not specified\n");
900  ret = -EINVAL;
901  goto out;
902  }
903 
904  if (dev->change_protocol) {
905  rc = dev->change_protocol(dev, type);
906  if (rc < 0) {
907  IR_dprintk(1, "Error setting protocols to 0x%llx\n",
908  (long long)type);
909  ret = -EINVAL;
910  goto out;
911  }
912  }
913 
914  if (dev->driver_type == RC_DRIVER_SCANCODE) {
915  spin_lock_irqsave(&dev->rc_map.lock, flags);
916  dev->rc_map.rc_type = type;
917  spin_unlock_irqrestore(&dev->rc_map.lock, flags);
918  } else {
919  dev->raw->enabled_protocols = type;
920  }
921 
922  IR_dprintk(1, "Current protocol(s): 0x%llx\n",
923  (long long)type);
924 
925  ret = len;
926 
927 out:
928  mutex_unlock(&dev->lock);
929  return ret;
930 }
931 
932 static void rc_dev_release(struct device *device)
933 {
934 }
935 
936 #define ADD_HOTPLUG_VAR(fmt, val...) \
937  do { \
938  int err = add_uevent_var(env, fmt, val); \
939  if (err) \
940  return err; \
941  } while (0)
942 
943 static int rc_dev_uevent(struct device *device, struct kobj_uevent_env *env)
944 {
945  struct rc_dev *dev = to_rc_dev(device);
946 
947  if (!dev || !dev->input_dev)
948  return -ENODEV;
949 
950  if (dev->rc_map.name)
951  ADD_HOTPLUG_VAR("NAME=%s", dev->rc_map.name);
952  if (dev->driver_name)
953  ADD_HOTPLUG_VAR("DRV_NAME=%s", dev->driver_name);
954 
955  return 0;
956 }
957 
958 /*
959  * Static device attribute struct with the sysfs attributes for IR's
960  */
961 static DEVICE_ATTR(protocols, S_IRUGO | S_IWUSR,
962  show_protocols, store_protocols);
963 
964 static struct attribute *rc_dev_attrs[] = {
965  &dev_attr_protocols.attr,
966  NULL,
967 };
968 
969 static struct attribute_group rc_dev_attr_grp = {
970  .attrs = rc_dev_attrs,
971 };
972 
973 static const struct attribute_group *rc_dev_attr_groups[] = {
974  &rc_dev_attr_grp,
975  NULL
976 };
977 
978 static struct device_type rc_dev_type = {
979  .groups = rc_dev_attr_groups,
980  .release = rc_dev_release,
981  .uevent = rc_dev_uevent,
982 };
983 
985 {
986  struct rc_dev *dev;
987 
988  dev = kzalloc(sizeof(*dev), GFP_KERNEL);
989  if (!dev)
990  return NULL;
991 
992  dev->input_dev = input_allocate_device();
993  if (!dev->input_dev) {
994  kfree(dev);
995  return NULL;
996  }
997 
998  dev->input_dev->getkeycode = ir_getkeycode;
999  dev->input_dev->setkeycode = ir_setkeycode;
1000  input_set_drvdata(dev->input_dev, dev);
1001 
1002  spin_lock_init(&dev->rc_map.lock);
1003  spin_lock_init(&dev->keylock);
1004  mutex_init(&dev->lock);
1005  setup_timer(&dev->timer_keyup, ir_timer_keyup, (unsigned long)dev);
1006 
1007  dev->dev.type = &rc_dev_type;
1008  dev->dev.class = &ir_input_class;
1009  device_initialize(&dev->dev);
1010 
1011  __module_get(THIS_MODULE);
1012  return dev;
1013 }
1015 
1016 void rc_free_device(struct rc_dev *dev)
1017 {
1018  if (!dev)
1019  return;
1020 
1021  if (dev->input_dev)
1022  input_free_device(dev->input_dev);
1023 
1024  put_device(&dev->dev);
1025 
1026  kfree(dev);
1027  module_put(THIS_MODULE);
1028 }
1030 
1031 int rc_register_device(struct rc_dev *dev)
1032 {
1033  static bool raw_init = false; /* raw decoders loaded? */
1034  static atomic_t devno = ATOMIC_INIT(0);
1035  struct rc_map *rc_map;
1036  const char *path;
1037  int rc;
1038 
1039  if (!dev || !dev->map_name)
1040  return -EINVAL;
1041 
1042  rc_map = rc_map_get(dev->map_name);
1043  if (!rc_map)
1044  rc_map = rc_map_get(RC_MAP_EMPTY);
1045  if (!rc_map || !rc_map->scan || rc_map->size == 0)
1046  return -EINVAL;
1047 
1048  set_bit(EV_KEY, dev->input_dev->evbit);
1049  set_bit(EV_REP, dev->input_dev->evbit);
1050  set_bit(EV_MSC, dev->input_dev->evbit);
1051  set_bit(MSC_SCAN, dev->input_dev->mscbit);
1052  if (dev->open)
1053  dev->input_dev->open = ir_open;
1054  if (dev->close)
1055  dev->input_dev->close = ir_close;
1056 
1057  /*
1058  * Take the lock here, as the device sysfs node will appear
1059  * when device_add() is called, which may trigger an ir-keytable udev
1060  * rule, which will in turn call show_protocols and access either
1061  * dev->rc_map.rc_type or dev->raw->enabled_protocols before it has
1062  * been initialized.
1063  */
1064  mutex_lock(&dev->lock);
1065 
1066  dev->devno = (unsigned long)(atomic_inc_return(&devno) - 1);
1067  dev_set_name(&dev->dev, "rc%ld", dev->devno);
1068  dev_set_drvdata(&dev->dev, dev);
1069  rc = device_add(&dev->dev);
1070  if (rc)
1071  goto out_unlock;
1072 
1073  rc = ir_setkeytable(dev, rc_map);
1074  if (rc)
1075  goto out_dev;
1076 
1077  dev->input_dev->dev.parent = &dev->dev;
1078  memcpy(&dev->input_dev->id, &dev->input_id, sizeof(dev->input_id));
1079  dev->input_dev->phys = dev->input_phys;
1080  dev->input_dev->name = dev->input_name;
1081  rc = input_register_device(dev->input_dev);
1082  if (rc)
1083  goto out_table;
1084 
1085  /*
1086  * Default delay of 250ms is too short for some protocols, especially
1087  * since the timeout is currently set to 250ms. Increase it to 500ms,
1088  * to avoid wrong repetition of the keycodes. Note that this must be
1089  * set after the call to input_register_device().
1090  */
1091  dev->input_dev->rep[REP_DELAY] = 500;
1092 
1093  /*
1094  * As a repeat event on protocols like RC-5 and NEC take as long as
1095  * 110/114ms, using 33ms as a repeat period is not the right thing
1096  * to do.
1097  */
1098  dev->input_dev->rep[REP_PERIOD] = 125;
1099 
1100  path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);
1101  printk(KERN_INFO "%s: %s as %s\n",
1102  dev_name(&dev->dev),
1103  dev->input_name ? dev->input_name : "Unspecified device",
1104  path ? path : "N/A");
1105  kfree(path);
1106 
1107  if (dev->driver_type == RC_DRIVER_IR_RAW) {
1108  /* Load raw decoders, if they aren't already */
1109  if (!raw_init) {
1110  IR_dprintk(1, "Loading raw decoders\n");
1111  ir_raw_init();
1112  raw_init = true;
1113  }
1114  rc = ir_raw_event_register(dev);
1115  if (rc < 0)
1116  goto out_input;
1117  }
1118 
1119  if (dev->change_protocol) {
1120  rc = dev->change_protocol(dev, rc_map->rc_type);
1121  if (rc < 0)
1122  goto out_raw;
1123  }
1124 
1125  mutex_unlock(&dev->lock);
1126 
1127  IR_dprintk(1, "Registered rc%ld (driver: %s, remote: %s, mode %s)\n",
1128  dev->devno,
1129  dev->driver_name ? dev->driver_name : "unknown",
1130  rc_map->name ? rc_map->name : "unknown",
1131  dev->driver_type == RC_DRIVER_IR_RAW ? "raw" : "cooked");
1132 
1133  return 0;
1134 
1135 out_raw:
1136  if (dev->driver_type == RC_DRIVER_IR_RAW)
1138 out_input:
1139  input_unregister_device(dev->input_dev);
1140  dev->input_dev = NULL;
1141 out_table:
1142  ir_free_table(&dev->rc_map);
1143 out_dev:
1144  device_del(&dev->dev);
1145 out_unlock:
1146  mutex_unlock(&dev->lock);
1147  return rc;
1148 }
1150 
1151 void rc_unregister_device(struct rc_dev *dev)
1152 {
1153  if (!dev)
1154  return;
1155 
1156  del_timer_sync(&dev->timer_keyup);
1157 
1158  if (dev->driver_type == RC_DRIVER_IR_RAW)
1160 
1161  /* Freeing the table should also call the stop callback */
1162  ir_free_table(&dev->rc_map);
1163  IR_dprintk(1, "Freed keycode table\n");
1164 
1165  input_unregister_device(dev->input_dev);
1166  dev->input_dev = NULL;
1167 
1168  device_del(&dev->dev);
1169 
1170  rc_free_device(dev);
1171 }
1172 
1174 
1175 /*
1176  * Init/exit code for the module. Basically, creates/removes /sys/class/rc
1177  */
1178 
1179 static int __init rc_core_init(void)
1180 {
1181  int rc = class_register(&ir_input_class);
1182  if (rc) {
1183  printk(KERN_ERR "rc_core: unable to register rc class\n");
1184  return rc;
1185  }
1186 
1187  rc_map_register(&empty_map);
1188 
1189  return 0;
1190 }
1191 
1192 static void __exit rc_core_exit(void)
1193 {
1194  class_unregister(&ir_input_class);
1195  rc_map_unregister(&empty_map);
1196 }
1197 
1198 module_init(rc_core_init);
1199 module_exit(rc_core_exit);
1200 
1201 int rc_core_debug; /* ir_debug level (0,1,2) */
1202 EXPORT_SYMBOL_GPL(rc_core_debug);
1203 module_param_named(debug, rc_core_debug, int, 0644);
1204 
1205 MODULE_AUTHOR("Mauro Carvalho Chehab <[email protected]>");
1206 MODULE_LICENSE("GPL");