1 /* rc-main.c - Remote Controller core module
2 *
3 * Copyright (C) 2009-2010 by Mauro Carvalho Chehab <mchehab@redhat.com>
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
seek_rc_map(const char * name)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);
40 list_for_each_entry(map, &rc_map_list, list) {
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
rc_map_get(const char * name)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 }
78 EXPORT_SYMBOL_GPL(rc_map_get);
79
rc_map_register(struct rc_map_list * map)80 int rc_map_register(struct rc_map_list *map)
81 {
82 spin_lock(&rc_map_lock);
83 list_add_tail(&map->list, &rc_map_list);
84 spin_unlock(&rc_map_lock);
85 return 0;
86 }
87 EXPORT_SYMBOL_GPL(rc_map_register);
88
rc_map_unregister(struct rc_map_list * map)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 }
95 EXPORT_SYMBOL_GPL(rc_map_unregister);
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
111 /**
112 * ir_create_table() - initializes a scancode table
113 * @rc_map: the rc_map to initialize
114 * @name: name to assign to the table
115 * @rc_type: ir type to assign to the new table
116 * @size: initial size of the table
117 * @return: zero on success or a negative error code
118 *
119 * This routine will initialize the rc_map and will allocate
120 * memory to hold at least the specified number of elements.
121 */
ir_create_table(struct rc_map * rc_map,const char * name,u64 rc_type,size_t size)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
138 /**
139 * ir_free_table() - frees memory allocated by a scancode table
140 * @rc_map: the table whose mappings need to be freed
141 *
142 * This routine will free memory alloctaed for key mappings used by given
143 * scancode table.
144 */
ir_free_table(struct rc_map * rc_map)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
152 /**
153 * ir_resize_table() - resizes a scancode table if necessary
154 * @rc_map: the rc_map to resize
155 * @gfp_flags: gfp flags to use when allocating memory
156 * @return: zero on success or a negative error code
157 *
158 * This routine will shrink the rc_map if it has lots of
159 * unused entries and grow it if it is full.
160 */
ir_resize_table(struct rc_map * rc_map,gfp_t gfp_flags)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
200 /**
201 * ir_update_mapping() - set a keycode in the scancode->keycode table
202 * @dev: the struct rc_dev device descriptor
203 * @rc_map: scancode table to be adjusted
204 * @index: index of the mapping that needs to be updated
205 * @keycode: the desired keycode
206 * @return: previous keycode assigned to the mapping
207 *
208 * This routine is used to update scancode->keycode mapping at given
209 * position.
210 */
ir_update_mapping(struct rc_dev * dev,struct rc_map * rc_map,unsigned int index,unsigned int new_keycode)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
253 /**
254 * ir_establish_scancode() - set a keycode in the scancode->keycode table
255 * @dev: the struct rc_dev device descriptor
256 * @rc_map: scancode table to be searched
257 * @scancode: the desired scancode
258 * @resize: controls whether we allowed to resize the table to
259 * accommodate not yet present scancodes
260 * @return: index of the mapping containing scancode in question
261 * or -1U in case of failure.
262 *
263 * This routine is used to locate given scancode in rc_map.
264 * If scancode is not yet present the routine will allocate a new slot
265 * for it.
266 */
ir_establish_scancode(struct rc_dev * dev,struct rc_map * rc_map,unsigned int scancode,bool resize)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
312 /**
313 * ir_setkeycode() - set a keycode in the scancode->keycode table
314 * @idev: the struct input_dev device descriptor
315 * @scancode: the desired scancode
316 * @keycode: result
317 * @return: -EINVAL if the keycode could not be inserted, otherwise zero.
318 *
319 * This routine is used to handle evdev EVIOCSKEY ioctl.
320 */
ir_setkeycode(struct input_dev * idev,const struct input_keymap_entry * ke,unsigned int * old_keycode)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
359 /**
360 * ir_setkeytable() - sets several entries in the scancode->keycode table
361 * @dev: the struct rc_dev device descriptor
362 * @to: the struct rc_map to copy entries to
363 * @from: the struct rc_map to copy entries from
364 * @return: -ENOMEM if all keycodes could not be inserted, otherwise zero.
365 *
366 * This routine is used to handle table initialization.
367 */
ir_setkeytable(struct rc_dev * dev,const struct rc_map * from)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
401 /**
402 * ir_lookup_by_scancode() - locate mapping by scancode
403 * @rc_map: the struct rc_map to search
404 * @scancode: scancode to look for in the table
405 * @return: index in the table, -1U if not found
406 *
407 * This routine performs binary search in RC keykeymap table for
408 * given scancode.
409 */
ir_lookup_by_scancode(const struct rc_map * rc_map,unsigned int scancode)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
430 /**
431 * ir_getkeycode() - get a keycode from the scancode->keycode table
432 * @idev: the struct input_dev device descriptor
433 * @scancode: the desired scancode
434 * @keycode: used to return the keycode, if found, or KEY_RESERVED
435 * @return: always returns zero.
436 *
437 * This routine is used to handle evdev EVIOCGKEY ioctl.
438 */
ir_getkeycode(struct input_dev * idev,struct input_keymap_entry * ke)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
490 /**
491 * rc_g_keycode_from_table() - gets the keycode that corresponds to a scancode
492 * @dev: the struct rc_dev descriptor of the device
493 * @scancode: the scancode to look for
494 * @return: the corresponding keycode, or KEY_RESERVED
495 *
496 * This routine is used by drivers which need to convert a scancode to a
497 * keycode. Normally it should not be used since drivers should have no
498 * interest in keycodes.
499 */
rc_g_keycode_from_table(struct rc_dev * dev,u32 scancode)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 }
521 EXPORT_SYMBOL_GPL(rc_g_keycode_from_table);
522
523 /**
524 * ir_do_keyup() - internal function to signal the release of a keypress
525 * @dev: the struct rc_dev descriptor of the device
526 * @sync: whether or not to call input_sync
527 *
528 * This function is used internally to release a keypress, it must be
529 * called with keylock held.
530 */
ir_do_keyup(struct rc_dev * dev,bool sync)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
543 /**
544 * rc_keyup() - signals the release of a keypress
545 * @dev: the struct rc_dev descriptor of the device
546 *
547 * This routine is used to signal that a key has been released on the
548 * remote control.
549 */
rc_keyup(struct rc_dev * dev)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 }
558 EXPORT_SYMBOL_GPL(rc_keyup);
559
560 /**
561 * ir_timer_keyup() - generates a keyup event after a timeout
562 * @cookie: a pointer to the struct rc_dev for the device
563 *
564 * This routine will generate a keyup event some time after a keydown event
565 * is generated when no further activity has been detected.
566 */
ir_timer_keyup(unsigned long cookie)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);
583 if (time_is_before_eq_jiffies(dev->keyup_jiffies))
584 ir_do_keyup(dev, true);
585 spin_unlock_irqrestore(&dev->keylock, flags);
586 }
587
588 /**
589 * rc_repeat() - signals that a key is still pressed
590 * @dev: the struct rc_dev descriptor of the device
591 *
592 * This routine is used by IR decoders when a repeat message which does
593 * not include the necessary bits to reproduce the scancode has been
594 * received.
595 */
rc_repeat(struct rc_dev * dev)596 void rc_repeat(struct rc_dev *dev)
597 {
598 unsigned long flags;
599
600 spin_lock_irqsave(&dev->keylock, flags);
601
602 input_event(dev->input_dev, EV_MSC, MSC_SCAN, dev->last_scancode);
603 input_sync(dev->input_dev);
604
605 if (!dev->keypressed)
606 goto out;
607
608 dev->keyup_jiffies = jiffies + msecs_to_jiffies(IR_KEYPRESS_TIMEOUT);
609 mod_timer(&dev->timer_keyup, dev->keyup_jiffies);
610
611 out:
612 spin_unlock_irqrestore(&dev->keylock, flags);
613 }
614 EXPORT_SYMBOL_GPL(rc_repeat);
615
616 /**
617 * ir_do_keydown() - internal function to process a keypress
618 * @dev: the struct rc_dev descriptor of the device
619 * @scancode: the scancode of the keypress
620 * @keycode: the keycode of the keypress
621 * @toggle: the toggle value of the keypress
622 *
623 * This function is used internally to register a keypress, it must be
624 * called with keylock held.
625 */
ir_do_keydown(struct rc_dev * dev,int scancode,u32 keycode,u8 toggle)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
654 /**
655 * rc_keydown() - generates input event for a key press
656 * @dev: the struct rc_dev descriptor of the device
657 * @scancode: the scancode that we're seeking
658 * @toggle: the toggle value (protocol dependent, if the protocol doesn't
659 * support toggle values, this should be set to zero)
660 *
661 * This routine is used to signal that a key has been pressed on the
662 * remote control.
663 */
rc_keydown(struct rc_dev * dev,int scancode,u8 toggle)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) {
673 dev->keyup_jiffies = jiffies + msecs_to_jiffies(IR_KEYPRESS_TIMEOUT);
674 mod_timer(&dev->timer_keyup, dev->keyup_jiffies);
675 }
676 spin_unlock_irqrestore(&dev->keylock, flags);
677 }
678 EXPORT_SYMBOL_GPL(rc_keydown);
679
680 /**
681 * rc_keydown_notimeout() - generates input event for a key press without
682 * an automatic keyup event at a later time
683 * @dev: the struct rc_dev descriptor of the device
684 * @scancode: the scancode that we're seeking
685 * @toggle: the toggle value (protocol dependent, if the protocol doesn't
686 * support toggle values, this should be set to zero)
687 *
688 * This routine is used to signal that a key has been pressed on the
689 * remote control. The driver must manually call rc_keyup() at a later stage.
690 */
rc_keydown_notimeout(struct rc_dev * dev,int scancode,u8 toggle)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 }
700 EXPORT_SYMBOL_GPL(rc_keydown_notimeout);
701
ir_open(struct input_dev * idev)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
ir_close(struct input_dev * idev)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 */
ir_devnode(struct device * dev,umode_t * mode)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 {
729 u64 type;
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
747 /**
748 * show_protocols() - shows the current IR protocol(s)
749 * @device: the device descriptor
750 * @mattr: the device attribute struct (unused)
751 * @buf: a pointer to the output buffer
752 *
753 * This routine is a callback routine for input read the IR protocol type(s).
754 * it is trigged by reading /sys/class/rc/rc?/protocols.
755 * It returns the protocol names of supported protocols.
756 * Enabled protocols are printed in brackets.
757 *
758 * dev->lock is taken to guard against races between device
759 * registration, store_protocols and show_protocols.
760 */
show_protocols(struct device * device,struct device_attribute * mattr,char * buf)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 mutex_unlock(&dev->lock);
783 return -ENODEV;
784 }
785
786 IR_dprintk(1, "allowed - 0x%llx, enabled - 0x%llx\n",
787 (long long)allowed,
788 (long long)enabled);
789
790 for (i = 0; i < ARRAY_SIZE(proto_names); i++) {
791 if (allowed & enabled & proto_names[i].type)
792 tmp += sprintf(tmp, "[%s] ", proto_names[i].name);
793 else if (allowed & proto_names[i].type)
794 tmp += sprintf(tmp, "%s ", proto_names[i].name);
795 }
796
797 if (tmp != buf)
798 tmp--;
799 *tmp = '\n';
800
801 mutex_unlock(&dev->lock);
802
803 return tmp + 1 - buf;
804 }
805
806 /**
807 * store_protocols() - changes the current IR protocol(s)
808 * @device: the device descriptor
809 * @mattr: the device attribute struct (unused)
810 * @buf: a pointer to the input buffer
811 * @len: length of the input buffer
812 *
813 * This routine is for changing the IR protocol type.
814 * It is trigged by writing to /sys/class/rc/rc?/protocols.
815 * Writing "+proto" will add a protocol to the list of enabled protocols.
816 * Writing "-proto" will remove a protocol from the list of enabled protocols.
817 * Writing "proto" will enable only "proto".
818 * Writing "none" will disable all protocols.
819 * Returns -EINVAL if an invalid protocol combination or unknown protocol name
820 * is used, otherwise @len.
821 *
822 * dev->lock is taken to guard against races between device
823 * registration, store_protocols and show_protocols.
824 */
store_protocols(struct device * device,struct device_attribute * mattr,const char * data,size_t len)825 static ssize_t store_protocols(struct device *device,
826 struct device_attribute *mattr,
827 const char *data,
828 size_t len)
829 {
830 struct rc_dev *dev = to_rc_dev(device);
831 bool enable, disable;
832 const char *tmp;
833 u64 type;
834 u64 mask;
835 int rc, i, count = 0;
836 unsigned long flags;
837 ssize_t ret;
838
839 /* Device is being removed */
840 if (!dev)
841 return -EINVAL;
842
843 mutex_lock(&dev->lock);
844
845 if (dev->driver_type == RC_DRIVER_SCANCODE)
846 type = dev->rc_map.rc_type;
847 else if (dev->raw)
848 type = dev->raw->enabled_protocols;
849 else {
850 IR_dprintk(1, "Protocol switching not supported\n");
851 ret = -EINVAL;
852 goto out;
853 }
854
855 while ((tmp = strsep((char **) &data, " \n")) != NULL) {
856 if (!*tmp)
857 break;
858
859 if (*tmp == '+') {
860 enable = true;
861 disable = false;
862 tmp++;
863 } else if (*tmp == '-') {
864 enable = false;
865 disable = true;
866 tmp++;
867 } else {
868 enable = false;
869 disable = false;
870 }
871
872 if (!enable && !disable && !strncasecmp(tmp, PROTO_NONE, sizeof(PROTO_NONE))) {
873 tmp += sizeof(PROTO_NONE);
874 mask = 0;
875 count++;
876 } else {
877 for (i = 0; i < ARRAY_SIZE(proto_names); i++) {
878 if (!strcasecmp(tmp, proto_names[i].name)) {
879 tmp += strlen(proto_names[i].name);
880 mask = proto_names[i].type;
881 break;
882 }
883 }
884 if (i == ARRAY_SIZE(proto_names)) {
885 IR_dprintk(1, "Unknown protocol: '%s'\n", tmp);
886 ret = -EINVAL;
887 goto out;
888 }
889 count++;
890 }
891
892 if (enable)
893 type |= mask;
894 else if (disable)
895 type &= ~mask;
896 else
897 type = mask;
898 }
899
900 if (!count) {
901 IR_dprintk(1, "Protocol not specified\n");
902 ret = -EINVAL;
903 goto out;
904 }
905
906 if (dev->change_protocol) {
907 rc = dev->change_protocol(dev, type);
908 if (rc < 0) {
909 IR_dprintk(1, "Error setting protocols to 0x%llx\n",
910 (long long)type);
911 ret = -EINVAL;
912 goto out;
913 }
914 }
915
916 if (dev->driver_type == RC_DRIVER_SCANCODE) {
917 spin_lock_irqsave(&dev->rc_map.lock, flags);
918 dev->rc_map.rc_type = type;
919 spin_unlock_irqrestore(&dev->rc_map.lock, flags);
920 } else {
921 dev->raw->enabled_protocols = type;
922 }
923
924 IR_dprintk(1, "Current protocol(s): 0x%llx\n",
925 (long long)type);
926
927 ret = len;
928
929 out:
930 mutex_unlock(&dev->lock);
931 return ret;
932 }
933
rc_dev_release(struct device * device)934 static void rc_dev_release(struct device *device)
935 {
936 }
937
938 #define ADD_HOTPLUG_VAR(fmt, val...) \
939 do { \
940 int err = add_uevent_var(env, fmt, val); \
941 if (err) \
942 return err; \
943 } while (0)
944
rc_dev_uevent(struct device * device,struct kobj_uevent_env * env)945 static int rc_dev_uevent(struct device *device, struct kobj_uevent_env *env)
946 {
947 struct rc_dev *dev = to_rc_dev(device);
948
949 if (!dev || !dev->input_dev)
950 return -ENODEV;
951
952 if (dev->rc_map.name)
953 ADD_HOTPLUG_VAR("NAME=%s", dev->rc_map.name);
954 if (dev->driver_name)
955 ADD_HOTPLUG_VAR("DRV_NAME=%s", dev->driver_name);
956
957 return 0;
958 }
959
960 /*
961 * Static device attribute struct with the sysfs attributes for IR's
962 */
963 static DEVICE_ATTR(protocols, S_IRUGO | S_IWUSR,
964 show_protocols, store_protocols);
965
966 static struct attribute *rc_dev_attrs[] = {
967 &dev_attr_protocols.attr,
968 NULL,
969 };
970
971 static struct attribute_group rc_dev_attr_grp = {
972 .attrs = rc_dev_attrs,
973 };
974
975 static const struct attribute_group *rc_dev_attr_groups[] = {
976 &rc_dev_attr_grp,
977 NULL
978 };
979
980 static struct device_type rc_dev_type = {
981 .groups = rc_dev_attr_groups,
982 .release = rc_dev_release,
983 .uevent = rc_dev_uevent,
984 };
985
rc_allocate_device(void)986 struct rc_dev *rc_allocate_device(void)
987 {
988 struct rc_dev *dev;
989
990 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
991 if (!dev)
992 return NULL;
993
994 dev->input_dev = input_allocate_device();
995 if (!dev->input_dev) {
996 kfree(dev);
997 return NULL;
998 }
999
1000 dev->input_dev->getkeycode = ir_getkeycode;
1001 dev->input_dev->setkeycode = ir_setkeycode;
1002 input_set_drvdata(dev->input_dev, dev);
1003
1004 spin_lock_init(&dev->rc_map.lock);
1005 spin_lock_init(&dev->keylock);
1006 mutex_init(&dev->lock);
1007 setup_timer(&dev->timer_keyup, ir_timer_keyup, (unsigned long)dev);
1008
1009 dev->dev.type = &rc_dev_type;
1010 dev->dev.class = &ir_input_class;
1011 device_initialize(&dev->dev);
1012
1013 __module_get(THIS_MODULE);
1014 return dev;
1015 }
1016 EXPORT_SYMBOL_GPL(rc_allocate_device);
1017
rc_free_device(struct rc_dev * dev)1018 void rc_free_device(struct rc_dev *dev)
1019 {
1020 if (!dev)
1021 return;
1022
1023 if (dev->input_dev)
1024 input_free_device(dev->input_dev);
1025
1026 put_device(&dev->dev);
1027
1028 kfree(dev);
1029 module_put(THIS_MODULE);
1030 }
1031 EXPORT_SYMBOL_GPL(rc_free_device);
1032
rc_register_device(struct rc_dev * dev)1033 int rc_register_device(struct rc_dev *dev)
1034 {
1035 static bool raw_init = false; /* raw decoders loaded? */
1036 static atomic_t devno = ATOMIC_INIT(0);
1037 struct rc_map *rc_map;
1038 const char *path;
1039 int rc;
1040
1041 if (!dev || !dev->map_name)
1042 return -EINVAL;
1043
1044 rc_map = rc_map_get(dev->map_name);
1045 if (!rc_map)
1046 rc_map = rc_map_get(RC_MAP_EMPTY);
1047 if (!rc_map || !rc_map->scan || rc_map->size == 0)
1048 return -EINVAL;
1049
1050 set_bit(EV_KEY, dev->input_dev->evbit);
1051 set_bit(EV_REP, dev->input_dev->evbit);
1052 set_bit(EV_MSC, dev->input_dev->evbit);
1053 set_bit(MSC_SCAN, dev->input_dev->mscbit);
1054 if (dev->open)
1055 dev->input_dev->open = ir_open;
1056 if (dev->close)
1057 dev->input_dev->close = ir_close;
1058
1059 /*
1060 * Take the lock here, as the device sysfs node will appear
1061 * when device_add() is called, which may trigger an ir-keytable udev
1062 * rule, which will in turn call show_protocols and access either
1063 * dev->rc_map.rc_type or dev->raw->enabled_protocols before it has
1064 * been initialized.
1065 */
1066 mutex_lock(&dev->lock);
1067
1068 dev->devno = (unsigned long)(atomic_inc_return(&devno) - 1);
1069 dev_set_name(&dev->dev, "rc%ld", dev->devno);
1070 dev_set_drvdata(&dev->dev, dev);
1071 rc = device_add(&dev->dev);
1072 if (rc)
1073 goto out_unlock;
1074
1075 rc = ir_setkeytable(dev, rc_map);
1076 if (rc)
1077 goto out_dev;
1078
1079 dev->input_dev->dev.parent = &dev->dev;
1080 memcpy(&dev->input_dev->id, &dev->input_id, sizeof(dev->input_id));
1081 dev->input_dev->phys = dev->input_phys;
1082 dev->input_dev->name = dev->input_name;
1083 rc = input_register_device(dev->input_dev);
1084 if (rc)
1085 goto out_table;
1086
1087 /*
1088 * Default delay of 250ms is too short for some protocols, especially
1089 * since the timeout is currently set to 250ms. Increase it to 500ms,
1090 * to avoid wrong repetition of the keycodes. Note that this must be
1091 * set after the call to input_register_device().
1092 */
1093 dev->input_dev->rep[REP_DELAY] = 500;
1094
1095 /*
1096 * As a repeat event on protocols like RC-5 and NEC take as long as
1097 * 110/114ms, using 33ms as a repeat period is not the right thing
1098 * to do.
1099 */
1100 dev->input_dev->rep[REP_PERIOD] = 125;
1101
1102 path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);
1103 printk(KERN_INFO "%s: %s as %s\n",
1104 dev_name(&dev->dev),
1105 dev->input_name ? dev->input_name : "Unspecified device",
1106 path ? path : "N/A");
1107 kfree(path);
1108
1109 if (dev->driver_type == RC_DRIVER_IR_RAW) {
1110 /* Load raw decoders, if they aren't already */
1111 if (!raw_init) {
1112 IR_dprintk(1, "Loading raw decoders\n");
1113 ir_raw_init();
1114 raw_init = true;
1115 }
1116 rc = ir_raw_event_register(dev);
1117 if (rc < 0)
1118 goto out_input;
1119 }
1120
1121 if (dev->change_protocol) {
1122 rc = dev->change_protocol(dev, rc_map->rc_type);
1123 if (rc < 0)
1124 goto out_raw;
1125 }
1126
1127 mutex_unlock(&dev->lock);
1128
1129 IR_dprintk(1, "Registered rc%ld (driver: %s, remote: %s, mode %s)\n",
1130 dev->devno,
1131 dev->driver_name ? dev->driver_name : "unknown",
1132 rc_map->name ? rc_map->name : "unknown",
1133 dev->driver_type == RC_DRIVER_IR_RAW ? "raw" : "cooked");
1134
1135 return 0;
1136
1137 out_raw:
1138 if (dev->driver_type == RC_DRIVER_IR_RAW)
1139 ir_raw_event_unregister(dev);
1140 out_input:
1141 input_unregister_device(dev->input_dev);
1142 dev->input_dev = NULL;
1143 out_table:
1144 ir_free_table(&dev->rc_map);
1145 out_dev:
1146 device_del(&dev->dev);
1147 out_unlock:
1148 mutex_unlock(&dev->lock);
1149 return rc;
1150 }
1151 EXPORT_SYMBOL_GPL(rc_register_device);
1152
rc_unregister_device(struct rc_dev * dev)1153 void rc_unregister_device(struct rc_dev *dev)
1154 {
1155 if (!dev)
1156 return;
1157
1158 del_timer_sync(&dev->timer_keyup);
1159
1160 if (dev->driver_type == RC_DRIVER_IR_RAW)
1161 ir_raw_event_unregister(dev);
1162
1163 /* Freeing the table should also call the stop callback */
1164 ir_free_table(&dev->rc_map);
1165 IR_dprintk(1, "Freed keycode table\n");
1166
1167 input_unregister_device(dev->input_dev);
1168 dev->input_dev = NULL;
1169
1170 device_del(&dev->dev);
1171
1172 rc_free_device(dev);
1173 }
1174
1175 EXPORT_SYMBOL_GPL(rc_unregister_device);
1176
1177 /*
1178 * Init/exit code for the module. Basically, creates/removes /sys/class/rc
1179 */
1180
rc_core_init(void)1181 static int __init rc_core_init(void)
1182 {
1183 int rc = class_register(&ir_input_class);
1184 if (rc) {
1185 printk(KERN_ERR "rc_core: unable to register rc class\n");
1186 return rc;
1187 }
1188
1189 rc_map_register(&empty_map);
1190
1191 return 0;
1192 }
1193
rc_core_exit(void)1194 static void __exit rc_core_exit(void)
1195 {
1196 class_unregister(&ir_input_class);
1197 rc_map_unregister(&empty_map);
1198 }
1199
1200 module_init(rc_core_init);
1201 module_exit(rc_core_exit);
1202
1203 int rc_core_debug; /* ir_debug level (0,1,2) */
1204 EXPORT_SYMBOL_GPL(rc_core_debug);
1205 module_param_named(debug, rc_core_debug, int, 0644);
1206
1207 MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@redhat.com>");
1208 MODULE_LICENSE("GPL");
1209