rc-main.c revision b32e724308300a6ecead0f4895f0452a06a4291d
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 "rc-core-priv.h"
22
23/* Sizes are in bytes, 256 bytes allows for 32 entries on x64 */
24#define IR_TAB_MIN_SIZE	256
25#define IR_TAB_MAX_SIZE	8192
26
27/* FIXME: IR_KEYPRESS_TIMEOUT should be protocol specific */
28#define IR_KEYPRESS_TIMEOUT 250
29
30/* Used to keep track of known keymaps */
31static LIST_HEAD(rc_map_list);
32static DEFINE_SPINLOCK(rc_map_lock);
33
34static struct rc_map_list *seek_rc_map(const char *name)
35{
36	struct rc_map_list *map = NULL;
37
38	spin_lock(&rc_map_lock);
39	list_for_each_entry(map, &rc_map_list, list) {
40		if (!strcmp(name, map->map.name)) {
41			spin_unlock(&rc_map_lock);
42			return map;
43		}
44	}
45	spin_unlock(&rc_map_lock);
46
47	return NULL;
48}
49
50struct rc_map *rc_map_get(const char *name)
51{
52
53	struct rc_map_list *map;
54
55	map = seek_rc_map(name);
56#ifdef MODULE
57	if (!map) {
58		int rc = request_module(name);
59		if (rc < 0) {
60			printk(KERN_ERR "Couldn't load IR keymap %s\n", name);
61			return NULL;
62		}
63		msleep(20);	/* Give some time for IR to register */
64
65		map = seek_rc_map(name);
66	}
67#endif
68	if (!map) {
69		printk(KERN_ERR "IR keymap %s not found\n", name);
70		return NULL;
71	}
72
73	printk(KERN_INFO "Registered IR keymap %s\n", map->map.name);
74
75	return &map->map;
76}
77EXPORT_SYMBOL_GPL(rc_map_get);
78
79int rc_map_register(struct rc_map_list *map)
80{
81	spin_lock(&rc_map_lock);
82	list_add_tail(&map->list, &rc_map_list);
83	spin_unlock(&rc_map_lock);
84	return 0;
85}
86EXPORT_SYMBOL_GPL(rc_map_register);
87
88void rc_map_unregister(struct rc_map_list *map)
89{
90	spin_lock(&rc_map_lock);
91	list_del(&map->list);
92	spin_unlock(&rc_map_lock);
93}
94EXPORT_SYMBOL_GPL(rc_map_unregister);
95
96
97static struct rc_map_table empty[] = {
98	{ 0x2a, KEY_COFFEE },
99};
100
101static struct rc_map_list empty_map = {
102	.map = {
103		.scan    = empty,
104		.size    = ARRAY_SIZE(empty),
105		.rc_type = RC_TYPE_UNKNOWN,	/* Legacy IR type */
106		.name    = RC_MAP_EMPTY,
107	}
108};
109
110/**
111 * ir_create_table() - initializes a scancode table
112 * @rc_map:	the rc_map to initialize
113 * @name:	name to assign to the table
114 * @rc_type:	ir type to assign to the new table
115 * @size:	initial size of the table
116 * @return:	zero on success or a negative error code
117 *
118 * This routine will initialize the rc_map and will allocate
119 * memory to hold at least the specified number of elements.
120 */
121static int ir_create_table(struct rc_map *rc_map,
122			   const char *name, u64 rc_type, size_t size)
123{
124	rc_map->name = name;
125	rc_map->rc_type = rc_type;
126	rc_map->alloc = roundup_pow_of_two(size * sizeof(struct rc_map_table));
127	rc_map->size = rc_map->alloc / sizeof(struct rc_map_table);
128	rc_map->scan = kmalloc(rc_map->alloc, GFP_KERNEL);
129	if (!rc_map->scan)
130		return -ENOMEM;
131
132	IR_dprintk(1, "Allocated space for %u keycode entries (%u bytes)\n",
133		   rc_map->size, rc_map->alloc);
134	return 0;
135}
136
137/**
138 * ir_free_table() - frees memory allocated by a scancode table
139 * @rc_map:	the table whose mappings need to be freed
140 *
141 * This routine will free memory alloctaed for key mappings used by given
142 * scancode table.
143 */
144static void ir_free_table(struct rc_map *rc_map)
145{
146	rc_map->size = 0;
147	kfree(rc_map->scan);
148	rc_map->scan = NULL;
149}
150
151/**
152 * ir_resize_table() - resizes a scancode table if necessary
153 * @rc_map:	the rc_map to resize
154 * @gfp_flags:	gfp flags to use when allocating memory
155 * @return:	zero on success or a negative error code
156 *
157 * This routine will shrink the rc_map if it has lots of
158 * unused entries and grow it if it is full.
159 */
160static int ir_resize_table(struct rc_map *rc_map, gfp_t gfp_flags)
161{
162	unsigned int oldalloc = rc_map->alloc;
163	unsigned int newalloc = oldalloc;
164	struct rc_map_table *oldscan = rc_map->scan;
165	struct rc_map_table *newscan;
166
167	if (rc_map->size == rc_map->len) {
168		/* All entries in use -> grow keytable */
169		if (rc_map->alloc >= IR_TAB_MAX_SIZE)
170			return -ENOMEM;
171
172		newalloc *= 2;
173		IR_dprintk(1, "Growing table to %u bytes\n", newalloc);
174	}
175
176	if ((rc_map->len * 3 < rc_map->size) && (oldalloc > IR_TAB_MIN_SIZE)) {
177		/* Less than 1/3 of entries in use -> shrink keytable */
178		newalloc /= 2;
179		IR_dprintk(1, "Shrinking table to %u bytes\n", newalloc);
180	}
181
182	if (newalloc == oldalloc)
183		return 0;
184
185	newscan = kmalloc(newalloc, gfp_flags);
186	if (!newscan) {
187		IR_dprintk(1, "Failed to kmalloc %u bytes\n", newalloc);
188		return -ENOMEM;
189	}
190
191	memcpy(newscan, rc_map->scan, rc_map->len * sizeof(struct rc_map_table));
192	rc_map->scan = newscan;
193	rc_map->alloc = newalloc;
194	rc_map->size = rc_map->alloc / sizeof(struct rc_map_table);
195	kfree(oldscan);
196	return 0;
197}
198
199/**
200 * ir_update_mapping() - set a keycode in the scancode->keycode table
201 * @dev:	the struct rc_dev device descriptor
202 * @rc_map:	scancode table to be adjusted
203 * @index:	index of the mapping that needs to be updated
204 * @keycode:	the desired keycode
205 * @return:	previous keycode assigned to the mapping
206 *
207 * This routine is used to update scancode->keycode mapping at given
208 * position.
209 */
210static unsigned int ir_update_mapping(struct rc_dev *dev,
211				      struct rc_map *rc_map,
212				      unsigned int index,
213				      unsigned int new_keycode)
214{
215	int old_keycode = rc_map->scan[index].keycode;
216	int i;
217
218	/* Did the user wish to remove the mapping? */
219	if (new_keycode == KEY_RESERVED || new_keycode == KEY_UNKNOWN) {
220		IR_dprintk(1, "#%d: Deleting scan 0x%04x\n",
221			   index, rc_map->scan[index].scancode);
222		rc_map->len--;
223		memmove(&rc_map->scan[index], &rc_map->scan[index+ 1],
224			(rc_map->len - index) * sizeof(struct rc_map_table));
225	} else {
226		IR_dprintk(1, "#%d: %s scan 0x%04x with key 0x%04x\n",
227			   index,
228			   old_keycode == KEY_RESERVED ? "New" : "Replacing",
229			   rc_map->scan[index].scancode, new_keycode);
230		rc_map->scan[index].keycode = new_keycode;
231		__set_bit(new_keycode, dev->input_dev->keybit);
232	}
233
234	if (old_keycode != KEY_RESERVED) {
235		/* A previous mapping was updated... */
236		__clear_bit(old_keycode, dev->input_dev->keybit);
237		/* ... but another scancode might use the same keycode */
238		for (i = 0; i < rc_map->len; i++) {
239			if (rc_map->scan[i].keycode == old_keycode) {
240				__set_bit(old_keycode, dev->input_dev->keybit);
241				break;
242			}
243		}
244
245		/* Possibly shrink the keytable, failure is not a problem */
246		ir_resize_table(rc_map, GFP_ATOMIC);
247	}
248
249	return old_keycode;
250}
251
252/**
253 * ir_establish_scancode() - set a keycode in the scancode->keycode table
254 * @dev:	the struct rc_dev device descriptor
255 * @rc_map:	scancode table to be searched
256 * @scancode:	the desired scancode
257 * @resize:	controls whether we allowed to resize the table to
258 *		accommodate not yet present scancodes
259 * @return:	index of the mapping containing scancode in question
260 *		or -1U in case of failure.
261 *
262 * This routine is used to locate given scancode in rc_map.
263 * If scancode is not yet present the routine will allocate a new slot
264 * for it.
265 */
266static unsigned int ir_establish_scancode(struct rc_dev *dev,
267					  struct rc_map *rc_map,
268					  unsigned int scancode,
269					  bool resize)
270{
271	unsigned int i;
272
273	/*
274	 * Unfortunately, some hardware-based IR decoders don't provide
275	 * all bits for the complete IR code. In general, they provide only
276	 * the command part of the IR code. Yet, as it is possible to replace
277	 * the provided IR with another one, it is needed to allow loading
278	 * IR tables from other remotes. So, we support specifying a mask to
279	 * indicate the valid bits of the scancodes.
280	 */
281	if (dev->scanmask)
282		scancode &= dev->scanmask;
283
284	/* First check if we already have a mapping for this ir command */
285	for (i = 0; i < rc_map->len; i++) {
286		if (rc_map->scan[i].scancode == scancode)
287			return i;
288
289		/* Keytable is sorted from lowest to highest scancode */
290		if (rc_map->scan[i].scancode >= scancode)
291			break;
292	}
293
294	/* No previous mapping found, we might need to grow the table */
295	if (rc_map->size == rc_map->len) {
296		if (!resize || ir_resize_table(rc_map, GFP_ATOMIC))
297			return -1U;
298	}
299
300	/* i is the proper index to insert our new keycode */
301	if (i < rc_map->len)
302		memmove(&rc_map->scan[i + 1], &rc_map->scan[i],
303			(rc_map->len - i) * sizeof(struct rc_map_table));
304	rc_map->scan[i].scancode = scancode;
305	rc_map->scan[i].keycode = KEY_RESERVED;
306	rc_map->len++;
307
308	return i;
309}
310
311/**
312 * ir_setkeycode() - set a keycode in the scancode->keycode table
313 * @idev:	the struct input_dev device descriptor
314 * @scancode:	the desired scancode
315 * @keycode:	result
316 * @return:	-EINVAL if the keycode could not be inserted, otherwise zero.
317 *
318 * This routine is used to handle evdev EVIOCSKEY ioctl.
319 */
320static int ir_setkeycode(struct input_dev *idev,
321			 const struct input_keymap_entry *ke,
322			 unsigned int *old_keycode)
323{
324	struct rc_dev *rdev = input_get_drvdata(idev);
325	struct rc_map *rc_map = &rdev->rc_map;
326	unsigned int index;
327	unsigned int scancode;
328	int retval = 0;
329	unsigned long flags;
330
331	spin_lock_irqsave(&rc_map->lock, flags);
332
333	if (ke->flags & INPUT_KEYMAP_BY_INDEX) {
334		index = ke->index;
335		if (index >= rc_map->len) {
336			retval = -EINVAL;
337			goto out;
338		}
339	} else {
340		retval = input_scancode_to_scalar(ke, &scancode);
341		if (retval)
342			goto out;
343
344		index = ir_establish_scancode(rdev, rc_map, scancode, true);
345		if (index >= rc_map->len) {
346			retval = -ENOMEM;
347			goto out;
348		}
349	}
350
351	*old_keycode = ir_update_mapping(rdev, rc_map, index, ke->keycode);
352
353out:
354	spin_unlock_irqrestore(&rc_map->lock, flags);
355	return retval;
356}
357
358/**
359 * ir_setkeytable() - sets several entries in the scancode->keycode table
360 * @dev:	the struct rc_dev device descriptor
361 * @to:		the struct rc_map to copy entries to
362 * @from:	the struct rc_map to copy entries from
363 * @return:	-ENOMEM if all keycodes could not be inserted, otherwise zero.
364 *
365 * This routine is used to handle table initialization.
366 */
367static int ir_setkeytable(struct rc_dev *dev,
368			  const struct rc_map *from)
369{
370	struct rc_map *rc_map = &dev->rc_map;
371	unsigned int i, index;
372	int rc;
373
374	rc = ir_create_table(rc_map, from->name,
375			     from->rc_type, from->size);
376	if (rc)
377		return rc;
378
379	IR_dprintk(1, "Allocated space for %u keycode entries (%u bytes)\n",
380		   rc_map->size, rc_map->alloc);
381
382	for (i = 0; i < from->size; i++) {
383		index = ir_establish_scancode(dev, rc_map,
384					      from->scan[i].scancode, false);
385		if (index >= rc_map->len) {
386			rc = -ENOMEM;
387			break;
388		}
389
390		ir_update_mapping(dev, rc_map, index,
391				  from->scan[i].keycode);
392	}
393
394	if (rc)
395		ir_free_table(rc_map);
396
397	return rc;
398}
399
400/**
401 * ir_lookup_by_scancode() - locate mapping by scancode
402 * @rc_map:	the struct rc_map to search
403 * @scancode:	scancode to look for in the table
404 * @return:	index in the table, -1U if not found
405 *
406 * This routine performs binary search in RC keykeymap table for
407 * given scancode.
408 */
409static unsigned int ir_lookup_by_scancode(const struct rc_map *rc_map,
410					  unsigned int scancode)
411{
412	int start = 0;
413	int end = rc_map->len - 1;
414	int mid;
415
416	while (start <= end) {
417		mid = (start + end) / 2;
418		if (rc_map->scan[mid].scancode < scancode)
419			start = mid + 1;
420		else if (rc_map->scan[mid].scancode > scancode)
421			end = mid - 1;
422		else
423			return mid;
424	}
425
426	return -1U;
427}
428
429/**
430 * ir_getkeycode() - get a keycode from the scancode->keycode table
431 * @idev:	the struct input_dev device descriptor
432 * @scancode:	the desired scancode
433 * @keycode:	used to return the keycode, if found, or KEY_RESERVED
434 * @return:	always returns zero.
435 *
436 * This routine is used to handle evdev EVIOCGKEY ioctl.
437 */
438static int ir_getkeycode(struct input_dev *idev,
439			 struct input_keymap_entry *ke)
440{
441	struct rc_dev *rdev = input_get_drvdata(idev);
442	struct rc_map *rc_map = &rdev->rc_map;
443	struct rc_map_table *entry;
444	unsigned long flags;
445	unsigned int index;
446	unsigned int scancode;
447	int retval;
448
449	spin_lock_irqsave(&rc_map->lock, flags);
450
451	if (ke->flags & INPUT_KEYMAP_BY_INDEX) {
452		index = ke->index;
453	} else {
454		retval = input_scancode_to_scalar(ke, &scancode);
455		if (retval)
456			goto out;
457
458		index = ir_lookup_by_scancode(rc_map, scancode);
459	}
460
461	if (index < rc_map->len) {
462		entry = &rc_map->scan[index];
463
464		ke->index = index;
465		ke->keycode = entry->keycode;
466		ke->len = sizeof(entry->scancode);
467		memcpy(ke->scancode, &entry->scancode, sizeof(entry->scancode));
468
469	} else if (!(ke->flags & INPUT_KEYMAP_BY_INDEX)) {
470		/*
471		 * We do not really know the valid range of scancodes
472		 * so let's respond with KEY_RESERVED to anything we
473		 * do not have mapping for [yet].
474		 */
475		ke->index = index;
476		ke->keycode = KEY_RESERVED;
477	} else {
478		retval = -EINVAL;
479		goto out;
480	}
481
482	retval = 0;
483
484out:
485	spin_unlock_irqrestore(&rc_map->lock, flags);
486	return retval;
487}
488
489/**
490 * rc_g_keycode_from_table() - gets the keycode that corresponds to a scancode
491 * @dev:	the struct rc_dev descriptor of the device
492 * @scancode:	the scancode to look for
493 * @return:	the corresponding keycode, or KEY_RESERVED
494 *
495 * This routine is used by drivers which need to convert a scancode to a
496 * keycode. Normally it should not be used since drivers should have no
497 * interest in keycodes.
498 */
499u32 rc_g_keycode_from_table(struct rc_dev *dev, u32 scancode)
500{
501	struct rc_map *rc_map = &dev->rc_map;
502	unsigned int keycode;
503	unsigned int index;
504	unsigned long flags;
505
506	spin_lock_irqsave(&rc_map->lock, flags);
507
508	index = ir_lookup_by_scancode(rc_map, scancode);
509	keycode = index < rc_map->len ?
510			rc_map->scan[index].keycode : KEY_RESERVED;
511
512	spin_unlock_irqrestore(&rc_map->lock, flags);
513
514	if (keycode != KEY_RESERVED)
515		IR_dprintk(1, "%s: scancode 0x%04x keycode 0x%02x\n",
516			   dev->input_name, scancode, keycode);
517
518	return keycode;
519}
520EXPORT_SYMBOL_GPL(rc_g_keycode_from_table);
521
522/**
523 * ir_do_keyup() - internal function to signal the release of a keypress
524 * @dev:	the struct rc_dev descriptor of the device
525 * @sync:	whether or not to call input_sync
526 *
527 * This function is used internally to release a keypress, it must be
528 * called with keylock held.
529 */
530static void ir_do_keyup(struct rc_dev *dev, bool sync)
531{
532	if (!dev->keypressed)
533		return;
534
535	IR_dprintk(1, "keyup key 0x%04x\n", dev->last_keycode);
536	input_report_key(dev->input_dev, dev->last_keycode, 0);
537	if (sync)
538		input_sync(dev->input_dev);
539	dev->keypressed = false;
540}
541
542/**
543 * rc_keyup() - signals the release of a keypress
544 * @dev:	the struct rc_dev descriptor of the device
545 *
546 * This routine is used to signal that a key has been released on the
547 * remote control.
548 */
549void rc_keyup(struct rc_dev *dev)
550{
551	unsigned long flags;
552
553	spin_lock_irqsave(&dev->keylock, flags);
554	ir_do_keyup(dev, true);
555	spin_unlock_irqrestore(&dev->keylock, flags);
556}
557EXPORT_SYMBOL_GPL(rc_keyup);
558
559/**
560 * ir_timer_keyup() - generates a keyup event after a timeout
561 * @cookie:	a pointer to the struct rc_dev for the device
562 *
563 * This routine will generate a keyup event some time after a keydown event
564 * is generated when no further activity has been detected.
565 */
566static void ir_timer_keyup(unsigned long cookie)
567{
568	struct rc_dev *dev = (struct rc_dev *)cookie;
569	unsigned long flags;
570
571	/*
572	 * ir->keyup_jiffies is used to prevent a race condition if a
573	 * hardware interrupt occurs at this point and the keyup timer
574	 * event is moved further into the future as a result.
575	 *
576	 * The timer will then be reactivated and this function called
577	 * again in the future. We need to exit gracefully in that case
578	 * to allow the input subsystem to do its auto-repeat magic or
579	 * a keyup event might follow immediately after the keydown.
580	 */
581	spin_lock_irqsave(&dev->keylock, flags);
582	if (time_is_before_eq_jiffies(dev->keyup_jiffies))
583		ir_do_keyup(dev, true);
584	spin_unlock_irqrestore(&dev->keylock, flags);
585}
586
587/**
588 * rc_repeat() - signals that a key is still pressed
589 * @dev:	the struct rc_dev descriptor of the device
590 *
591 * This routine is used by IR decoders when a repeat message which does
592 * not include the necessary bits to reproduce the scancode has been
593 * received.
594 */
595void rc_repeat(struct rc_dev *dev)
596{
597	unsigned long flags;
598
599	spin_lock_irqsave(&dev->keylock, flags);
600
601	input_event(dev->input_dev, EV_MSC, MSC_SCAN, dev->last_scancode);
602	input_sync(dev->input_dev);
603
604	if (!dev->keypressed)
605		goto out;
606
607	dev->keyup_jiffies = jiffies + msecs_to_jiffies(IR_KEYPRESS_TIMEOUT);
608	mod_timer(&dev->timer_keyup, dev->keyup_jiffies);
609
610out:
611	spin_unlock_irqrestore(&dev->keylock, flags);
612}
613EXPORT_SYMBOL_GPL(rc_repeat);
614
615/**
616 * ir_do_keydown() - internal function to process a keypress
617 * @dev:	the struct rc_dev descriptor of the device
618 * @scancode:   the scancode of the keypress
619 * @keycode:    the keycode of the keypress
620 * @toggle:     the toggle value of the keypress
621 *
622 * This function is used internally to register a keypress, it must be
623 * called with keylock held.
624 */
625static void ir_do_keydown(struct rc_dev *dev, int scancode,
626			  u32 keycode, u8 toggle)
627{
628	bool new_event = !dev->keypressed ||
629			 dev->last_scancode != scancode ||
630			 dev->last_toggle != toggle;
631
632	if (new_event && dev->keypressed)
633		ir_do_keyup(dev, false);
634
635	input_event(dev->input_dev, EV_MSC, MSC_SCAN, scancode);
636
637	if (new_event && keycode != KEY_RESERVED) {
638		/* Register a keypress */
639		dev->keypressed = true;
640		dev->last_scancode = scancode;
641		dev->last_toggle = toggle;
642		dev->last_keycode = keycode;
643
644		IR_dprintk(1, "%s: key down event, "
645			   "key 0x%04x, scancode 0x%04x\n",
646			   dev->input_name, keycode, scancode);
647		input_report_key(dev->input_dev, keycode, 1);
648	}
649
650	input_sync(dev->input_dev);
651}
652
653/**
654 * rc_keydown() - generates input event for a key press
655 * @dev:	the struct rc_dev descriptor of the device
656 * @scancode:   the scancode that we're seeking
657 * @toggle:     the toggle value (protocol dependent, if the protocol doesn't
658 *              support toggle values, this should be set to zero)
659 *
660 * This routine is used to signal that a key has been pressed on the
661 * remote control.
662 */
663void rc_keydown(struct rc_dev *dev, int scancode, u8 toggle)
664{
665	unsigned long flags;
666	u32 keycode = rc_g_keycode_from_table(dev, scancode);
667
668	spin_lock_irqsave(&dev->keylock, flags);
669	ir_do_keydown(dev, scancode, keycode, toggle);
670
671	if (dev->keypressed) {
672		dev->keyup_jiffies = jiffies + msecs_to_jiffies(IR_KEYPRESS_TIMEOUT);
673		mod_timer(&dev->timer_keyup, dev->keyup_jiffies);
674	}
675	spin_unlock_irqrestore(&dev->keylock, flags);
676}
677EXPORT_SYMBOL_GPL(rc_keydown);
678
679/**
680 * rc_keydown_notimeout() - generates input event for a key press without
681 *                          an automatic keyup event at a later time
682 * @dev:	the struct rc_dev descriptor of the device
683 * @scancode:   the scancode that we're seeking
684 * @toggle:     the toggle value (protocol dependent, if the protocol doesn't
685 *              support toggle values, this should be set to zero)
686 *
687 * This routine is used to signal that a key has been pressed on the
688 * remote control. The driver must manually call rc_keyup() at a later stage.
689 */
690void rc_keydown_notimeout(struct rc_dev *dev, int scancode, u8 toggle)
691{
692	unsigned long flags;
693	u32 keycode = rc_g_keycode_from_table(dev, scancode);
694
695	spin_lock_irqsave(&dev->keylock, flags);
696	ir_do_keydown(dev, scancode, keycode, toggle);
697	spin_unlock_irqrestore(&dev->keylock, flags);
698}
699EXPORT_SYMBOL_GPL(rc_keydown_notimeout);
700
701static int ir_open(struct input_dev *idev)
702{
703	struct rc_dev *rdev = input_get_drvdata(idev);
704
705	return rdev->open(rdev);
706}
707
708static void ir_close(struct input_dev *idev)
709{
710	struct rc_dev *rdev = input_get_drvdata(idev);
711
712	 if (rdev)
713		rdev->close(rdev);
714}
715
716/* class for /sys/class/rc */
717static char *ir_devnode(struct device *dev, mode_t *mode)
718{
719	return kasprintf(GFP_KERNEL, "rc/%s", dev_name(dev));
720}
721
722static struct class ir_input_class = {
723	.name		= "rc",
724	.devnode	= ir_devnode,
725};
726
727static struct {
728	u64	type;
729	char	*name;
730} proto_names[] = {
731	{ RC_TYPE_UNKNOWN,	"unknown"	},
732	{ RC_TYPE_RC5,		"rc-5"		},
733	{ RC_TYPE_NEC,		"nec"		},
734	{ RC_TYPE_RC6,		"rc-6"		},
735	{ RC_TYPE_JVC,		"jvc"		},
736	{ RC_TYPE_SONY,		"sony"		},
737	{ RC_TYPE_RC5_SZ,	"rc-5-sz"	},
738	{ RC_TYPE_SANYO,	"sanyo"		},
739	{ RC_TYPE_MCE_KBD,	"mce_kbd"	},
740	{ RC_TYPE_LIRC,		"lirc"		},
741	{ RC_TYPE_OTHER,	"other"		},
742};
743
744#define PROTO_NONE	"none"
745
746/**
747 * show_protocols() - shows the current IR protocol(s)
748 * @device:	the device descriptor
749 * @mattr:	the device attribute struct (unused)
750 * @buf:	a pointer to the output buffer
751 *
752 * This routine is a callback routine for input read the IR protocol type(s).
753 * it is trigged by reading /sys/class/rc/rc?/protocols.
754 * It returns the protocol names of supported protocols.
755 * Enabled protocols are printed in brackets.
756 *
757 * dev->lock is taken to guard against races between device
758 * registration, store_protocols and show_protocols.
759 */
760static ssize_t show_protocols(struct device *device,
761			      struct device_attribute *mattr, char *buf)
762{
763	struct rc_dev *dev = to_rc_dev(device);
764	u64 allowed, enabled;
765	char *tmp = buf;
766	int i;
767
768	/* Device is being removed */
769	if (!dev)
770		return -EINVAL;
771
772	mutex_lock(&dev->lock);
773
774	if (dev->driver_type == RC_DRIVER_SCANCODE) {
775		enabled = dev->rc_map.rc_type;
776		allowed = dev->allowed_protos;
777	} else {
778		enabled = dev->raw->enabled_protocols;
779		allowed = ir_raw_get_allowed_protocols();
780	}
781
782	IR_dprintk(1, "allowed - 0x%llx, enabled - 0x%llx\n",
783		   (long long)allowed,
784		   (long long)enabled);
785
786	for (i = 0; i < ARRAY_SIZE(proto_names); i++) {
787		if (allowed & enabled & proto_names[i].type)
788			tmp += sprintf(tmp, "[%s] ", proto_names[i].name);
789		else if (allowed & proto_names[i].type)
790			tmp += sprintf(tmp, "%s ", proto_names[i].name);
791	}
792
793	if (tmp != buf)
794		tmp--;
795	*tmp = '\n';
796
797	mutex_unlock(&dev->lock);
798
799	return tmp + 1 - buf;
800}
801
802/**
803 * store_protocols() - changes the current IR protocol(s)
804 * @device:	the device descriptor
805 * @mattr:	the device attribute struct (unused)
806 * @buf:	a pointer to the input buffer
807 * @len:	length of the input buffer
808 *
809 * This routine is for changing the IR protocol type.
810 * It is trigged by writing to /sys/class/rc/rc?/protocols.
811 * Writing "+proto" will add a protocol to the list of enabled protocols.
812 * Writing "-proto" will remove a protocol from the list of enabled protocols.
813 * Writing "proto" will enable only "proto".
814 * Writing "none" will disable all protocols.
815 * Returns -EINVAL if an invalid protocol combination or unknown protocol name
816 * is used, otherwise @len.
817 *
818 * dev->lock is taken to guard against races between device
819 * registration, store_protocols and show_protocols.
820 */
821static ssize_t store_protocols(struct device *device,
822			       struct device_attribute *mattr,
823			       const char *data,
824			       size_t len)
825{
826	struct rc_dev *dev = to_rc_dev(device);
827	bool enable, disable;
828	const char *tmp;
829	u64 type;
830	u64 mask;
831	int rc, i, count = 0;
832	unsigned long flags;
833	ssize_t ret;
834
835	/* Device is being removed */
836	if (!dev)
837		return -EINVAL;
838
839	mutex_lock(&dev->lock);
840
841	if (dev->driver_type == RC_DRIVER_SCANCODE)
842		type = dev->rc_map.rc_type;
843	else if (dev->raw)
844		type = dev->raw->enabled_protocols;
845	else {
846		IR_dprintk(1, "Protocol switching not supported\n");
847		ret = -EINVAL;
848		goto out;
849	}
850
851	while ((tmp = strsep((char **) &data, " \n")) != NULL) {
852		if (!*tmp)
853			break;
854
855		if (*tmp == '+') {
856			enable = true;
857			disable = false;
858			tmp++;
859		} else if (*tmp == '-') {
860			enable = false;
861			disable = true;
862			tmp++;
863		} else {
864			enable = false;
865			disable = false;
866		}
867
868		if (!enable && !disable && !strncasecmp(tmp, PROTO_NONE, sizeof(PROTO_NONE))) {
869			tmp += sizeof(PROTO_NONE);
870			mask = 0;
871			count++;
872		} else {
873			for (i = 0; i < ARRAY_SIZE(proto_names); i++) {
874				if (!strcasecmp(tmp, proto_names[i].name)) {
875					tmp += strlen(proto_names[i].name);
876					mask = proto_names[i].type;
877					break;
878				}
879			}
880			if (i == ARRAY_SIZE(proto_names)) {
881				IR_dprintk(1, "Unknown protocol: '%s'\n", tmp);
882				ret = -EINVAL;
883				goto out;
884			}
885			count++;
886		}
887
888		if (enable)
889			type |= mask;
890		else if (disable)
891			type &= ~mask;
892		else
893			type = mask;
894	}
895
896	if (!count) {
897		IR_dprintk(1, "Protocol not specified\n");
898		ret = -EINVAL;
899		goto out;
900	}
901
902	if (dev->change_protocol) {
903		rc = dev->change_protocol(dev, type);
904		if (rc < 0) {
905			IR_dprintk(1, "Error setting protocols to 0x%llx\n",
906				   (long long)type);
907			ret = -EINVAL;
908			goto out;
909		}
910	}
911
912	if (dev->driver_type == RC_DRIVER_SCANCODE) {
913		spin_lock_irqsave(&dev->rc_map.lock, flags);
914		dev->rc_map.rc_type = type;
915		spin_unlock_irqrestore(&dev->rc_map.lock, flags);
916	} else {
917		dev->raw->enabled_protocols = type;
918	}
919
920	IR_dprintk(1, "Current protocol(s): 0x%llx\n",
921		   (long long)type);
922
923	ret = len;
924
925out:
926	mutex_unlock(&dev->lock);
927	return ret;
928}
929
930static void rc_dev_release(struct device *device)
931{
932}
933
934#define ADD_HOTPLUG_VAR(fmt, val...)					\
935	do {								\
936		int err = add_uevent_var(env, fmt, val);		\
937		if (err)						\
938			return err;					\
939	} while (0)
940
941static int rc_dev_uevent(struct device *device, struct kobj_uevent_env *env)
942{
943	struct rc_dev *dev = to_rc_dev(device);
944
945	if (!dev || !dev->input_dev)
946		return -ENODEV;
947
948	if (dev->rc_map.name)
949		ADD_HOTPLUG_VAR("NAME=%s", dev->rc_map.name);
950	if (dev->driver_name)
951		ADD_HOTPLUG_VAR("DRV_NAME=%s", dev->driver_name);
952
953	return 0;
954}
955
956/*
957 * Static device attribute struct with the sysfs attributes for IR's
958 */
959static DEVICE_ATTR(protocols, S_IRUGO | S_IWUSR,
960		   show_protocols, store_protocols);
961
962static struct attribute *rc_dev_attrs[] = {
963	&dev_attr_protocols.attr,
964	NULL,
965};
966
967static struct attribute_group rc_dev_attr_grp = {
968	.attrs	= rc_dev_attrs,
969};
970
971static const struct attribute_group *rc_dev_attr_groups[] = {
972	&rc_dev_attr_grp,
973	NULL
974};
975
976static struct device_type rc_dev_type = {
977	.groups		= rc_dev_attr_groups,
978	.release	= rc_dev_release,
979	.uevent		= rc_dev_uevent,
980};
981
982struct rc_dev *rc_allocate_device(void)
983{
984	struct rc_dev *dev;
985
986	dev = kzalloc(sizeof(*dev), GFP_KERNEL);
987	if (!dev)
988		return NULL;
989
990	dev->input_dev = input_allocate_device();
991	if (!dev->input_dev) {
992		kfree(dev);
993		return NULL;
994	}
995
996	dev->input_dev->getkeycode = ir_getkeycode;
997	dev->input_dev->setkeycode = ir_setkeycode;
998	input_set_drvdata(dev->input_dev, dev);
999
1000	spin_lock_init(&dev->rc_map.lock);
1001	spin_lock_init(&dev->keylock);
1002	mutex_init(&dev->lock);
1003	setup_timer(&dev->timer_keyup, ir_timer_keyup, (unsigned long)dev);
1004
1005	dev->dev.type = &rc_dev_type;
1006	dev->dev.class = &ir_input_class;
1007	device_initialize(&dev->dev);
1008
1009	__module_get(THIS_MODULE);
1010	return dev;
1011}
1012EXPORT_SYMBOL_GPL(rc_allocate_device);
1013
1014void rc_free_device(struct rc_dev *dev)
1015{
1016	if (!dev)
1017		return;
1018
1019	if (dev->input_dev)
1020		input_free_device(dev->input_dev);
1021
1022	put_device(&dev->dev);
1023
1024	kfree(dev);
1025	module_put(THIS_MODULE);
1026}
1027EXPORT_SYMBOL_GPL(rc_free_device);
1028
1029int rc_register_device(struct rc_dev *dev)
1030{
1031	static atomic_t devno = ATOMIC_INIT(0);
1032	struct rc_map *rc_map;
1033	const char *path;
1034	int rc;
1035
1036	if (!dev || !dev->map_name)
1037		return -EINVAL;
1038
1039	rc_map = rc_map_get(dev->map_name);
1040	if (!rc_map)
1041		rc_map = rc_map_get(RC_MAP_EMPTY);
1042	if (!rc_map || !rc_map->scan || rc_map->size == 0)
1043		return -EINVAL;
1044
1045	set_bit(EV_KEY, dev->input_dev->evbit);
1046	set_bit(EV_REP, dev->input_dev->evbit);
1047	set_bit(EV_MSC, dev->input_dev->evbit);
1048	set_bit(MSC_SCAN, dev->input_dev->mscbit);
1049	if (dev->open)
1050		dev->input_dev->open = ir_open;
1051	if (dev->close)
1052		dev->input_dev->close = ir_close;
1053
1054	/*
1055	 * Take the lock here, as the device sysfs node will appear
1056	 * when device_add() is called, which may trigger an ir-keytable udev
1057	 * rule, which will in turn call show_protocols and access either
1058	 * dev->rc_map.rc_type or dev->raw->enabled_protocols before it has
1059	 * been initialized.
1060	 */
1061	mutex_lock(&dev->lock);
1062
1063	dev->devno = (unsigned long)(atomic_inc_return(&devno) - 1);
1064	dev_set_name(&dev->dev, "rc%ld", dev->devno);
1065	dev_set_drvdata(&dev->dev, dev);
1066	rc = device_add(&dev->dev);
1067	if (rc)
1068		goto out_unlock;
1069
1070	rc = ir_setkeytable(dev, rc_map);
1071	if (rc)
1072		goto out_dev;
1073
1074	dev->input_dev->dev.parent = &dev->dev;
1075	memcpy(&dev->input_dev->id, &dev->input_id, sizeof(dev->input_id));
1076	dev->input_dev->phys = dev->input_phys;
1077	dev->input_dev->name = dev->input_name;
1078	rc = input_register_device(dev->input_dev);
1079	if (rc)
1080		goto out_table;
1081
1082	/*
1083	 * Default delay of 250ms is too short for some protocols, especially
1084	 * since the timeout is currently set to 250ms. Increase it to 500ms,
1085	 * to avoid wrong repetition of the keycodes. Note that this must be
1086	 * set after the call to input_register_device().
1087	 */
1088	dev->input_dev->rep[REP_DELAY] = 500;
1089
1090	/*
1091	 * As a repeat event on protocols like RC-5 and NEC take as long as
1092	 * 110/114ms, using 33ms as a repeat period is not the right thing
1093	 * to do.
1094	 */
1095	dev->input_dev->rep[REP_PERIOD] = 125;
1096
1097	path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);
1098	printk(KERN_INFO "%s: %s as %s\n",
1099		dev_name(&dev->dev),
1100		dev->input_name ? dev->input_name : "Unspecified device",
1101		path ? path : "N/A");
1102	kfree(path);
1103
1104	if (dev->driver_type == RC_DRIVER_IR_RAW) {
1105		rc = ir_raw_event_register(dev);
1106		if (rc < 0)
1107			goto out_input;
1108	}
1109
1110	if (dev->change_protocol) {
1111		rc = dev->change_protocol(dev, rc_map->rc_type);
1112		if (rc < 0)
1113			goto out_raw;
1114	}
1115
1116	mutex_unlock(&dev->lock);
1117
1118	IR_dprintk(1, "Registered rc%ld (driver: %s, remote: %s, mode %s)\n",
1119		   dev->devno,
1120		   dev->driver_name ? dev->driver_name : "unknown",
1121		   rc_map->name ? rc_map->name : "unknown",
1122		   dev->driver_type == RC_DRIVER_IR_RAW ? "raw" : "cooked");
1123
1124	return 0;
1125
1126out_raw:
1127	if (dev->driver_type == RC_DRIVER_IR_RAW)
1128		ir_raw_event_unregister(dev);
1129out_input:
1130	input_unregister_device(dev->input_dev);
1131	dev->input_dev = NULL;
1132out_table:
1133	ir_free_table(&dev->rc_map);
1134out_dev:
1135	device_del(&dev->dev);
1136out_unlock:
1137	mutex_unlock(&dev->lock);
1138	return rc;
1139}
1140EXPORT_SYMBOL_GPL(rc_register_device);
1141
1142void rc_unregister_device(struct rc_dev *dev)
1143{
1144	if (!dev)
1145		return;
1146
1147	del_timer_sync(&dev->timer_keyup);
1148
1149	if (dev->driver_type == RC_DRIVER_IR_RAW)
1150		ir_raw_event_unregister(dev);
1151
1152	/* Freeing the table should also call the stop callback */
1153	ir_free_table(&dev->rc_map);
1154	IR_dprintk(1, "Freed keycode table\n");
1155
1156	input_unregister_device(dev->input_dev);
1157	dev->input_dev = NULL;
1158
1159	device_del(&dev->dev);
1160
1161	rc_free_device(dev);
1162}
1163
1164EXPORT_SYMBOL_GPL(rc_unregister_device);
1165
1166/*
1167 * Init/exit code for the module. Basically, creates/removes /sys/class/rc
1168 */
1169
1170static int __init rc_core_init(void)
1171{
1172	int rc = class_register(&ir_input_class);
1173	if (rc) {
1174		printk(KERN_ERR "rc_core: unable to register rc class\n");
1175		return rc;
1176	}
1177
1178	/* Initialize/load the decoders/keymap code that will be used */
1179	ir_raw_init();
1180	rc_map_register(&empty_map);
1181
1182	return 0;
1183}
1184
1185static void __exit rc_core_exit(void)
1186{
1187	class_unregister(&ir_input_class);
1188	rc_map_unregister(&empty_map);
1189}
1190
1191module_init(rc_core_init);
1192module_exit(rc_core_exit);
1193
1194int rc_core_debug;    /* ir_debug level (0,1,2) */
1195EXPORT_SYMBOL_GPL(rc_core_debug);
1196module_param_named(debug, rc_core_debug, int, 0644);
1197
1198MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@redhat.com>");
1199MODULE_LICENSE("GPL");
1200