rc-main.c 38.0 KB
Newer Older
1
/* rc-main.c - Remote Controller core module
2
 *
3
 * Copyright (C) 2009-2010 by Mauro Carvalho Chehab
4 5 6 7 8 9 10 11 12
 *
 * This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation version 2 of the License.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
13 14
 */

15
#include <media/rc-core.h>
16 17
#include <linux/spinlock.h>
#include <linux/delay.h>
18
#include <linux/input.h>
19
#include <linux/leds.h>
20
#include <linux/slab.h>
21
#include <linux/device.h>
22
#include <linux/module.h>
23
#include "rc-core-priv.h"
24

25 26
/* Bitmap to store allocated device numbers from 0 to IRRCV_NUM_DEVICES - 1 */
#define IRRCV_NUM_DEVICES      256
27
static DECLARE_BITMAP(ir_core_dev_number, IRRCV_NUM_DEVICES);
28

29 30 31
/* Sizes are in bytes, 256 bytes allows for 32 entries on x64 */
#define IR_TAB_MIN_SIZE	256
#define IR_TAB_MAX_SIZE	8192
32

33 34 35
/* FIXME: IR_KEYPRESS_TIMEOUT should be protocol specific */
#define IR_KEYPRESS_TIMEOUT 250

36
/* Used to keep track of known keymaps */
37 38
static LIST_HEAD(rc_map_list);
static DEFINE_SPINLOCK(rc_map_lock);
39
static struct led_trigger *led_feedback;
40

41
static struct rc_map_list *seek_rc_map(const char *name)
42
{
43
	struct rc_map_list *map = NULL;
44 45 46 47 48 49 50 51 52 53 54 55 56

	spin_lock(&rc_map_lock);
	list_for_each_entry(map, &rc_map_list, list) {
		if (!strcmp(name, map->map.name)) {
			spin_unlock(&rc_map_lock);
			return map;
		}
	}
	spin_unlock(&rc_map_lock);

	return NULL;
}

57
struct rc_map *rc_map_get(const char *name)
58 59
{

60
	struct rc_map_list *map;
61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83

	map = seek_rc_map(name);
#ifdef MODULE
	if (!map) {
		int rc = request_module(name);
		if (rc < 0) {
			printk(KERN_ERR "Couldn't load IR keymap %s\n", name);
			return NULL;
		}
		msleep(20);	/* Give some time for IR to register */

		map = seek_rc_map(name);
	}
#endif
	if (!map) {
		printk(KERN_ERR "IR keymap %s not found\n", name);
		return NULL;
	}

	printk(KERN_INFO "Registered IR keymap %s\n", map->map.name);

	return &map->map;
}
84
EXPORT_SYMBOL_GPL(rc_map_get);
85

86
int rc_map_register(struct rc_map_list *map)
87 88 89 90 91 92
{
	spin_lock(&rc_map_lock);
	list_add_tail(&map->list, &rc_map_list);
	spin_unlock(&rc_map_lock);
	return 0;
}
93
EXPORT_SYMBOL_GPL(rc_map_register);
94

95
void rc_map_unregister(struct rc_map_list *map)
96 97 98 99 100
{
	spin_lock(&rc_map_lock);
	list_del(&map->list);
	spin_unlock(&rc_map_lock);
}
101
EXPORT_SYMBOL_GPL(rc_map_unregister);
102 103


104
static struct rc_map_table empty[] = {
105 106 107
	{ 0x2a, KEY_COFFEE },
};

108
static struct rc_map_list empty_map = {
109 110 111
	.map = {
		.scan    = empty,
		.size    = ARRAY_SIZE(empty),
112
		.rc_type = RC_TYPE_UNKNOWN,	/* Legacy IR type */
113 114 115 116
		.name    = RC_MAP_EMPTY,
	}
};

117 118
/**
 * ir_create_table() - initializes a scancode table
119
 * @rc_map:	the rc_map to initialize
120
 * @name:	name to assign to the table
121
 * @rc_type:	ir type to assign to the new table
122 123 124
 * @size:	initial size of the table
 * @return:	zero on success or a negative error code
 *
125
 * This routine will initialize the rc_map and will allocate
126
 * memory to hold at least the specified number of elements.
127
 */
128
static int ir_create_table(struct rc_map *rc_map,
129
			   const char *name, u64 rc_type, size_t size)
130
{
131 132
	rc_map->name = name;
	rc_map->rc_type = rc_type;
133 134
	rc_map->alloc = roundup_pow_of_two(size * sizeof(struct rc_map_table));
	rc_map->size = rc_map->alloc / sizeof(struct rc_map_table);
135 136
	rc_map->scan = kmalloc(rc_map->alloc, GFP_KERNEL);
	if (!rc_map->scan)
137 138 139
		return -ENOMEM;

	IR_dprintk(1, "Allocated space for %u keycode entries (%u bytes)\n",
140
		   rc_map->size, rc_map->alloc);
141 142 143 144 145
	return 0;
}

/**
 * ir_free_table() - frees memory allocated by a scancode table
146
 * @rc_map:	the table whose mappings need to be freed
147 148 149 150
 *
 * This routine will free memory alloctaed for key mappings used by given
 * scancode table.
 */
151
static void ir_free_table(struct rc_map *rc_map)
152
{
153 154 155
	rc_map->size = 0;
	kfree(rc_map->scan);
	rc_map->scan = NULL;
156 157
}

158
/**
159
 * ir_resize_table() - resizes a scancode table if necessary
160
 * @rc_map:	the rc_map to resize
161
 * @gfp_flags:	gfp flags to use when allocating memory
162
 * @return:	zero on success or a negative error code
163
 *
164
 * This routine will shrink the rc_map if it has lots of
165
 * unused entries and grow it if it is full.
166
 */
167
static int ir_resize_table(struct rc_map *rc_map, gfp_t gfp_flags)
168
{
169
	unsigned int oldalloc = rc_map->alloc;
170
	unsigned int newalloc = oldalloc;
171 172
	struct rc_map_table *oldscan = rc_map->scan;
	struct rc_map_table *newscan;
173

174
	if (rc_map->size == rc_map->len) {
175
		/* All entries in use -> grow keytable */
176
		if (rc_map->alloc >= IR_TAB_MAX_SIZE)
177
			return -ENOMEM;
178

179 180 181
		newalloc *= 2;
		IR_dprintk(1, "Growing table to %u bytes\n", newalloc);
	}
182

183
	if ((rc_map->len * 3 < rc_map->size) && (oldalloc > IR_TAB_MIN_SIZE)) {
184 185 186 187
		/* Less than 1/3 of entries in use -> shrink keytable */
		newalloc /= 2;
		IR_dprintk(1, "Shrinking table to %u bytes\n", newalloc);
	}
188

189 190
	if (newalloc == oldalloc)
		return 0;
191

192
	newscan = kmalloc(newalloc, gfp_flags);
193 194 195 196
	if (!newscan) {
		IR_dprintk(1, "Failed to kmalloc %u bytes\n", newalloc);
		return -ENOMEM;
	}
197

198
	memcpy(newscan, rc_map->scan, rc_map->len * sizeof(struct rc_map_table));
199 200
	rc_map->scan = newscan;
	rc_map->alloc = newalloc;
201
	rc_map->size = rc_map->alloc / sizeof(struct rc_map_table);
202 203
	kfree(oldscan);
	return 0;
204 205
}

206
/**
207
 * ir_update_mapping() - set a keycode in the scancode->keycode table
208
 * @dev:	the struct rc_dev device descriptor
209
 * @rc_map:	scancode table to be adjusted
210 211 212 213
 * @index:	index of the mapping that needs to be updated
 * @keycode:	the desired keycode
 * @return:	previous keycode assigned to the mapping
 *
214
 * This routine is used to update scancode->keycode mapping at given
215 216
 * position.
 */
217
static unsigned int ir_update_mapping(struct rc_dev *dev,
218
				      struct rc_map *rc_map,
219 220 221
				      unsigned int index,
				      unsigned int new_keycode)
{
222
	int old_keycode = rc_map->scan[index].keycode;
223 224 225 226 227
	int i;

	/* Did the user wish to remove the mapping? */
	if (new_keycode == KEY_RESERVED || new_keycode == KEY_UNKNOWN) {
		IR_dprintk(1, "#%d: Deleting scan 0x%04x\n",
228 229 230
			   index, rc_map->scan[index].scancode);
		rc_map->len--;
		memmove(&rc_map->scan[index], &rc_map->scan[index+ 1],
231
			(rc_map->len - index) * sizeof(struct rc_map_table));
232 233 234 235
	} else {
		IR_dprintk(1, "#%d: %s scan 0x%04x with key 0x%04x\n",
			   index,
			   old_keycode == KEY_RESERVED ? "New" : "Replacing",
236 237
			   rc_map->scan[index].scancode, new_keycode);
		rc_map->scan[index].keycode = new_keycode;
238
		__set_bit(new_keycode, dev->input_dev->keybit);
239 240 241 242
	}

	if (old_keycode != KEY_RESERVED) {
		/* A previous mapping was updated... */
243
		__clear_bit(old_keycode, dev->input_dev->keybit);
244
		/* ... but another scancode might use the same keycode */
245 246
		for (i = 0; i < rc_map->len; i++) {
			if (rc_map->scan[i].keycode == old_keycode) {
247
				__set_bit(old_keycode, dev->input_dev->keybit);
248 249 250 251 252
				break;
			}
		}

		/* Possibly shrink the keytable, failure is not a problem */
253
		ir_resize_table(rc_map, GFP_ATOMIC);
254 255 256 257 258 259
	}

	return old_keycode;
}

/**
260
 * ir_establish_scancode() - set a keycode in the scancode->keycode table
261
 * @dev:	the struct rc_dev device descriptor
262
 * @rc_map:	scancode table to be searched
263 264
 * @scancode:	the desired scancode
 * @resize:	controls whether we allowed to resize the table to
L
Lucas De Marchi 已提交
265
 *		accommodate not yet present scancodes
266 267
 * @return:	index of the mapping containing scancode in question
 *		or -1U in case of failure.
268
 *
269
 * This routine is used to locate given scancode in rc_map.
270 271
 * If scancode is not yet present the routine will allocate a new slot
 * for it.
272
 */
273
static unsigned int ir_establish_scancode(struct rc_dev *dev,
274
					  struct rc_map *rc_map,
275 276
					  unsigned int scancode,
					  bool resize)
277
{
278
	unsigned int i;
279 280 281 282 283 284

	/*
	 * Unfortunately, some hardware-based IR decoders don't provide
	 * all bits for the complete IR code. In general, they provide only
	 * the command part of the IR code. Yet, as it is possible to replace
	 * the provided IR with another one, it is needed to allow loading
285 286
	 * IR tables from other remotes. So, we support specifying a mask to
	 * indicate the valid bits of the scancodes.
287
	 */
288 289
	if (dev->scanmask)
		scancode &= dev->scanmask;
290 291

	/* First check if we already have a mapping for this ir command */
292 293
	for (i = 0; i < rc_map->len; i++) {
		if (rc_map->scan[i].scancode == scancode)
294 295
			return i;

296
		/* Keytable is sorted from lowest to highest scancode */
297
		if (rc_map->scan[i].scancode >= scancode)
298 299
			break;
	}
300

301
	/* No previous mapping found, we might need to grow the table */
302 303
	if (rc_map->size == rc_map->len) {
		if (!resize || ir_resize_table(rc_map, GFP_ATOMIC))
304 305
			return -1U;
	}
306

307
	/* i is the proper index to insert our new keycode */
308 309
	if (i < rc_map->len)
		memmove(&rc_map->scan[i + 1], &rc_map->scan[i],
310
			(rc_map->len - i) * sizeof(struct rc_map_table));
311 312 313
	rc_map->scan[i].scancode = scancode;
	rc_map->scan[i].keycode = KEY_RESERVED;
	rc_map->len++;
314

315
	return i;
316 317
}

318
/**
319
 * ir_setkeycode() - set a keycode in the scancode->keycode table
320
 * @idev:	the struct input_dev device descriptor
321
 * @scancode:	the desired scancode
322 323
 * @keycode:	result
 * @return:	-EINVAL if the keycode could not be inserted, otherwise zero.
324
 *
325
 * This routine is used to handle evdev EVIOCSKEY ioctl.
326
 */
327
static int ir_setkeycode(struct input_dev *idev,
328 329
			 const struct input_keymap_entry *ke,
			 unsigned int *old_keycode)
330
{
331
	struct rc_dev *rdev = input_get_drvdata(idev);
332
	struct rc_map *rc_map = &rdev->rc_map;
333 334
	unsigned int index;
	unsigned int scancode;
335
	int retval = 0;
336
	unsigned long flags;
337

338
	spin_lock_irqsave(&rc_map->lock, flags);
339 340 341

	if (ke->flags & INPUT_KEYMAP_BY_INDEX) {
		index = ke->index;
342
		if (index >= rc_map->len) {
343 344 345 346 347 348 349 350
			retval = -EINVAL;
			goto out;
		}
	} else {
		retval = input_scancode_to_scalar(ke, &scancode);
		if (retval)
			goto out;

351 352
		index = ir_establish_scancode(rdev, rc_map, scancode, true);
		if (index >= rc_map->len) {
353 354 355 356 357
			retval = -ENOMEM;
			goto out;
		}
	}

358
	*old_keycode = ir_update_mapping(rdev, rc_map, index, ke->keycode);
359 360

out:
361
	spin_unlock_irqrestore(&rc_map->lock, flags);
362
	return retval;
363 364 365
}

/**
366
 * ir_setkeytable() - sets several entries in the scancode->keycode table
367
 * @dev:	the struct rc_dev device descriptor
368 369
 * @to:		the struct rc_map to copy entries to
 * @from:	the struct rc_map to copy entries from
370
 * @return:	-ENOMEM if all keycodes could not be inserted, otherwise zero.
371
 *
372
 * This routine is used to handle table initialization.
373
 */
374
static int ir_setkeytable(struct rc_dev *dev,
375
			  const struct rc_map *from)
376
{
377
	struct rc_map *rc_map = &dev->rc_map;
378 379 380
	unsigned int i, index;
	int rc;

381
	rc = ir_create_table(rc_map, from->name,
382
			     from->rc_type, from->size);
383 384 385 386
	if (rc)
		return rc;

	IR_dprintk(1, "Allocated space for %u keycode entries (%u bytes)\n",
387
		   rc_map->size, rc_map->alloc);
388

389
	for (i = 0; i < from->size; i++) {
390
		index = ir_establish_scancode(dev, rc_map,
391
					      from->scan[i].scancode, false);
392
		if (index >= rc_map->len) {
393
			rc = -ENOMEM;
394
			break;
395 396
		}

397
		ir_update_mapping(dev, rc_map, index,
398
				  from->scan[i].keycode);
399
	}
400 401

	if (rc)
402
		ir_free_table(rc_map);
403

404
	return rc;
405 406
}

407 408
/**
 * ir_lookup_by_scancode() - locate mapping by scancode
409
 * @rc_map:	the struct rc_map to search
410 411 412 413 414 415
 * @scancode:	scancode to look for in the table
 * @return:	index in the table, -1U if not found
 *
 * This routine performs binary search in RC keykeymap table for
 * given scancode.
 */
416
static unsigned int ir_lookup_by_scancode(const struct rc_map *rc_map,
417 418
					  unsigned int scancode)
{
419
	int start = 0;
420
	int end = rc_map->len - 1;
421
	int mid;
422 423 424

	while (start <= end) {
		mid = (start + end) / 2;
425
		if (rc_map->scan[mid].scancode < scancode)
426
			start = mid + 1;
427
		else if (rc_map->scan[mid].scancode > scancode)
428 429 430 431 432 433 434 435
			end = mid - 1;
		else
			return mid;
	}

	return -1U;
}

436
/**
437
 * ir_getkeycode() - get a keycode from the scancode->keycode table
438
 * @idev:	the struct input_dev device descriptor
439
 * @scancode:	the desired scancode
440 441
 * @keycode:	used to return the keycode, if found, or KEY_RESERVED
 * @return:	always returns zero.
442
 *
443
 * This routine is used to handle evdev EVIOCGKEY ioctl.
444
 */
445
static int ir_getkeycode(struct input_dev *idev,
446
			 struct input_keymap_entry *ke)
447
{
448
	struct rc_dev *rdev = input_get_drvdata(idev);
449
	struct rc_map *rc_map = &rdev->rc_map;
450
	struct rc_map_table *entry;
451 452 453 454
	unsigned long flags;
	unsigned int index;
	unsigned int scancode;
	int retval;
455

456
	spin_lock_irqsave(&rc_map->lock, flags);
457 458 459 460 461 462 463 464

	if (ke->flags & INPUT_KEYMAP_BY_INDEX) {
		index = ke->index;
	} else {
		retval = input_scancode_to_scalar(ke, &scancode);
		if (retval)
			goto out;

465
		index = ir_lookup_by_scancode(rc_map, scancode);
466 467
	}

468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484
	if (index < rc_map->len) {
		entry = &rc_map->scan[index];

		ke->index = index;
		ke->keycode = entry->keycode;
		ke->len = sizeof(entry->scancode);
		memcpy(ke->scancode, &entry->scancode, sizeof(entry->scancode));

	} else if (!(ke->flags & INPUT_KEYMAP_BY_INDEX)) {
		/*
		 * We do not really know the valid range of scancodes
		 * so let's respond with KEY_RESERVED to anything we
		 * do not have mapping for [yet].
		 */
		ke->index = index;
		ke->keycode = KEY_RESERVED;
	} else {
485 486
		retval = -EINVAL;
		goto out;
487 488
	}

489 490
	retval = 0;

491
out:
492
	spin_unlock_irqrestore(&rc_map->lock, flags);
493
	return retval;
494 495 496
}

/**
497
 * rc_g_keycode_from_table() - gets the keycode that corresponds to a scancode
498 499 500
 * @dev:	the struct rc_dev descriptor of the device
 * @scancode:	the scancode to look for
 * @return:	the corresponding keycode, or KEY_RESERVED
501
 *
502 503 504
 * This routine is used by drivers which need to convert a scancode to a
 * keycode. Normally it should not be used since drivers should have no
 * interest in keycodes.
505
 */
506
u32 rc_g_keycode_from_table(struct rc_dev *dev, u32 scancode)
507
{
508
	struct rc_map *rc_map = &dev->rc_map;
509 510 511 512
	unsigned int keycode;
	unsigned int index;
	unsigned long flags;

513
	spin_lock_irqsave(&rc_map->lock, flags);
514

515 516 517
	index = ir_lookup_by_scancode(rc_map, scancode);
	keycode = index < rc_map->len ?
			rc_map->scan[index].keycode : KEY_RESERVED;
518

519
	spin_unlock_irqrestore(&rc_map->lock, flags);
520

521 522
	if (keycode != KEY_RESERVED)
		IR_dprintk(1, "%s: scancode 0x%04x keycode 0x%02x\n",
523
			   dev->input_name, scancode, keycode);
524

525
	return keycode;
526
}
527
EXPORT_SYMBOL_GPL(rc_g_keycode_from_table);
528

529
/**
530
 * ir_do_keyup() - internal function to signal the release of a keypress
531
 * @dev:	the struct rc_dev descriptor of the device
532
 * @sync:	whether or not to call input_sync
533
 *
534 535
 * This function is used internally to release a keypress, it must be
 * called with keylock held.
536
 */
537
static void ir_do_keyup(struct rc_dev *dev, bool sync)
538
{
539
	if (!dev->keypressed)
540 541
		return;

542 543
	IR_dprintk(1, "keyup key 0x%04x\n", dev->last_keycode);
	input_report_key(dev->input_dev, dev->last_keycode, 0);
544
	led_trigger_event(led_feedback, LED_OFF);
545 546
	if (sync)
		input_sync(dev->input_dev);
547
	dev->keypressed = false;
548
}
549 550

/**
551
 * rc_keyup() - signals the release of a keypress
552
 * @dev:	the struct rc_dev descriptor of the device
553 554 555 556
 *
 * This routine is used to signal that a key has been released on the
 * remote control.
 */
557
void rc_keyup(struct rc_dev *dev)
558 559 560
{
	unsigned long flags;

561
	spin_lock_irqsave(&dev->keylock, flags);
562
	ir_do_keyup(dev, true);
563
	spin_unlock_irqrestore(&dev->keylock, flags);
564
}
565
EXPORT_SYMBOL_GPL(rc_keyup);
566 567 568

/**
 * ir_timer_keyup() - generates a keyup event after a timeout
569
 * @cookie:	a pointer to the struct rc_dev for the device
570 571 572
 *
 * This routine will generate a keyup event some time after a keydown event
 * is generated when no further activity has been detected.
573
 */
574
static void ir_timer_keyup(unsigned long cookie)
575
{
576
	struct rc_dev *dev = (struct rc_dev *)cookie;
577 578 579 580 581 582 583 584 585 586 587 588
	unsigned long flags;

	/*
	 * ir->keyup_jiffies is used to prevent a race condition if a
	 * hardware interrupt occurs at this point and the keyup timer
	 * event is moved further into the future as a result.
	 *
	 * The timer will then be reactivated and this function called
	 * again in the future. We need to exit gracefully in that case
	 * to allow the input subsystem to do its auto-repeat magic or
	 * a keyup event might follow immediately after the keydown.
	 */
589 590
	spin_lock_irqsave(&dev->keylock, flags);
	if (time_is_before_eq_jiffies(dev->keyup_jiffies))
591
		ir_do_keyup(dev, true);
592
	spin_unlock_irqrestore(&dev->keylock, flags);
593 594 595
}

/**
596
 * rc_repeat() - signals that a key is still pressed
597
 * @dev:	the struct rc_dev descriptor of the device
598 599 600 601 602
 *
 * This routine is used by IR decoders when a repeat message which does
 * not include the necessary bits to reproduce the scancode has been
 * received.
 */
603
void rc_repeat(struct rc_dev *dev)
604 605
{
	unsigned long flags;
606

607
	spin_lock_irqsave(&dev->keylock, flags);
608

609
	input_event(dev->input_dev, EV_MSC, MSC_SCAN, dev->last_scancode);
610
	input_sync(dev->input_dev);
611

612
	if (!dev->keypressed)
613
		goto out;
614

615 616
	dev->keyup_jiffies = jiffies + msecs_to_jiffies(IR_KEYPRESS_TIMEOUT);
	mod_timer(&dev->timer_keyup, dev->keyup_jiffies);
617 618

out:
619
	spin_unlock_irqrestore(&dev->keylock, flags);
620
}
621
EXPORT_SYMBOL_GPL(rc_repeat);
622 623

/**
624
 * ir_do_keydown() - internal function to process a keypress
625
 * @dev:	the struct rc_dev descriptor of the device
626 627 628
 * @scancode:   the scancode of the keypress
 * @keycode:    the keycode of the keypress
 * @toggle:     the toggle value of the keypress
629
 *
630 631
 * This function is used internally to register a keypress, it must be
 * called with keylock held.
632
 */
633
static void ir_do_keydown(struct rc_dev *dev, int scancode,
634
			  u32 keycode, u8 toggle)
635
{
636
	struct rc_scancode_filter *filter;
637 638 639
	bool new_event = !dev->keypressed ||
			 dev->last_scancode != scancode ||
			 dev->last_toggle != toggle;
640

641 642
	if (new_event && dev->keypressed)
		ir_do_keyup(dev, false);
643

644 645 646 647 648
	/* Generic scancode filtering */
	filter = &dev->scancode_filters[RC_FILTER_NORMAL];
	if (filter->mask && ((scancode ^ filter->data) & filter->mask))
		return;

649
	input_event(dev->input_dev, EV_MSC, MSC_SCAN, scancode);
650

651 652 653 654 655 656 657 658 659 660 661
	if (new_event && keycode != KEY_RESERVED) {
		/* Register a keypress */
		dev->keypressed = true;
		dev->last_scancode = scancode;
		dev->last_toggle = toggle;
		dev->last_keycode = keycode;

		IR_dprintk(1, "%s: key down event, "
			   "key 0x%04x, scancode 0x%04x\n",
			   dev->input_name, keycode, scancode);
		input_report_key(dev->input_dev, keycode, 1);
662 663

		led_trigger_event(led_feedback, LED_FULL);
664
	}
665

666
	input_sync(dev->input_dev);
667
}
668

669
/**
670
 * rc_keydown() - generates input event for a key press
671
 * @dev:	the struct rc_dev descriptor of the device
672 673 674 675
 * @scancode:   the scancode that we're seeking
 * @toggle:     the toggle value (protocol dependent, if the protocol doesn't
 *              support toggle values, this should be set to zero)
 *
676 677
 * This routine is used to signal that a key has been pressed on the
 * remote control.
678
 */
679
void rc_keydown(struct rc_dev *dev, int scancode, u8 toggle)
680 681
{
	unsigned long flags;
682
	u32 keycode = rc_g_keycode_from_table(dev, scancode);
683

684
	spin_lock_irqsave(&dev->keylock, flags);
685 686
	ir_do_keydown(dev, scancode, keycode, toggle);

687 688 689
	if (dev->keypressed) {
		dev->keyup_jiffies = jiffies + msecs_to_jiffies(IR_KEYPRESS_TIMEOUT);
		mod_timer(&dev->timer_keyup, dev->keyup_jiffies);
690
	}
691
	spin_unlock_irqrestore(&dev->keylock, flags);
692
}
693
EXPORT_SYMBOL_GPL(rc_keydown);
694

695
/**
696
 * rc_keydown_notimeout() - generates input event for a key press without
697
 *                          an automatic keyup event at a later time
698
 * @dev:	the struct rc_dev descriptor of the device
699 700 701 702
 * @scancode:   the scancode that we're seeking
 * @toggle:     the toggle value (protocol dependent, if the protocol doesn't
 *              support toggle values, this should be set to zero)
 *
703
 * This routine is used to signal that a key has been pressed on the
704
 * remote control. The driver must manually call rc_keyup() at a later stage.
705
 */
706
void rc_keydown_notimeout(struct rc_dev *dev, int scancode, u8 toggle)
707 708
{
	unsigned long flags;
709
	u32 keycode = rc_g_keycode_from_table(dev, scancode);
710

711
	spin_lock_irqsave(&dev->keylock, flags);
712
	ir_do_keydown(dev, scancode, keycode, toggle);
713
	spin_unlock_irqrestore(&dev->keylock, flags);
714
}
715
EXPORT_SYMBOL_GPL(rc_keydown_notimeout);
716

717 718 719 720 721 722 723 724
int rc_open(struct rc_dev *rdev)
{
	int rval = 0;

	if (!rdev)
		return -EINVAL;

	mutex_lock(&rdev->lock);
725
	if (!rdev->users++ && rdev->open != NULL)
726 727 728 729 730 731 732 733 734 735 736
		rval = rdev->open(rdev);

	if (rval)
		rdev->users--;

	mutex_unlock(&rdev->lock);

	return rval;
}
EXPORT_SYMBOL_GPL(rc_open);

737
static int ir_open(struct input_dev *idev)
738
{
739
	struct rc_dev *rdev = input_get_drvdata(idev);
740

741 742 743 744 745 746 747 748
	return rc_open(rdev);
}

void rc_close(struct rc_dev *rdev)
{
	if (rdev) {
		mutex_lock(&rdev->lock);

749
		 if (!--rdev->users && rdev->close != NULL)
750 751 752 753
			rdev->close(rdev);

		mutex_unlock(&rdev->lock);
	}
754
}
755
EXPORT_SYMBOL_GPL(rc_close);
756

757
static void ir_close(struct input_dev *idev)
758
{
759
	struct rc_dev *rdev = input_get_drvdata(idev);
760
	rc_close(rdev);
761 762
}

763
/* class for /sys/class/rc */
764
static char *rc_devnode(struct device *dev, umode_t *mode)
765 766 767 768
{
	return kasprintf(GFP_KERNEL, "rc/%s", dev_name(dev));
}

769
static struct class rc_class = {
770
	.name		= "rc",
771
	.devnode	= rc_devnode,
772 773
};

774 775 776 777 778
/*
 * These are the protocol textual descriptions that are
 * used by the sysfs protocols file. Note that the order
 * of the entries is relevant.
 */
779 780 781 782
static struct {
	u64	type;
	char	*name;
} proto_names[] = {
783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799
	{ RC_BIT_NONE,		"none"		},
	{ RC_BIT_OTHER,		"other"		},
	{ RC_BIT_UNKNOWN,	"unknown"	},
	{ RC_BIT_RC5 |
	  RC_BIT_RC5X,		"rc-5"		},
	{ RC_BIT_NEC,		"nec"		},
	{ RC_BIT_RC6_0 |
	  RC_BIT_RC6_6A_20 |
	  RC_BIT_RC6_6A_24 |
	  RC_BIT_RC6_6A_32 |
	  RC_BIT_RC6_MCE,	"rc-6"		},
	{ RC_BIT_JVC,		"jvc"		},
	{ RC_BIT_SONY12 |
	  RC_BIT_SONY15 |
	  RC_BIT_SONY20,	"sony"		},
	{ RC_BIT_RC5_SZ,	"rc-5-sz"	},
	{ RC_BIT_SANYO,		"sanyo"		},
800
	{ RC_BIT_SHARP,		"sharp"		},
801 802
	{ RC_BIT_MCE_KBD,	"mce_kbd"	},
	{ RC_BIT_LIRC,		"lirc"		},
803 804 805
};

/**
806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831
 * struct rc_filter_attribute - Device attribute relating to a filter type.
 * @attr:	Device attribute.
 * @type:	Filter type.
 * @mask:	false for filter value, true for filter mask.
 */
struct rc_filter_attribute {
	struct device_attribute		attr;
	enum rc_filter_type		type;
	bool				mask;
};
#define to_rc_filter_attr(a) container_of(a, struct rc_filter_attribute, attr)

#define RC_PROTO_ATTR(_name, _mode, _show, _store, _type)		\
	struct rc_filter_attribute dev_attr_##_name = {			\
		.attr = __ATTR(_name, _mode, _show, _store),		\
		.type = (_type),					\
	}
#define RC_FILTER_ATTR(_name, _mode, _show, _store, _type, _mask)	\
	struct rc_filter_attribute dev_attr_##_name = {			\
		.attr = __ATTR(_name, _mode, _show, _store),		\
		.type = (_type),					\
		.mask = (_mask),					\
	}

/**
 * show_protocols() - shows the current/wakeup IR protocol(s)
832
 * @device:	the device descriptor
833 834 835 836
 * @mattr:	the device attribute struct (unused)
 * @buf:	a pointer to the output buffer
 *
 * This routine is a callback routine for input read the IR protocol type(s).
837
 * it is trigged by reading /sys/class/rc/rc?/[wakeup_]protocols.
838 839
 * It returns the protocol names of supported protocols.
 * Enabled protocols are printed in brackets.
840 841 842
 *
 * dev->lock is taken to guard against races between device
 * registration, store_protocols and show_protocols.
843
 */
844
static ssize_t show_protocols(struct device *device,
845 846
			      struct device_attribute *mattr, char *buf)
{
847
	struct rc_dev *dev = to_rc_dev(device);
848
	struct rc_filter_attribute *fattr = to_rc_filter_attr(mattr);
849 850 851 852 853
	u64 allowed, enabled;
	char *tmp = buf;
	int i;

	/* Device is being removed */
854
	if (!dev)
855 856
		return -EINVAL;

857 858
	mutex_lock(&dev->lock);

859 860 861 862
	enabled = dev->enabled_protocols[fattr->type];
	if (dev->driver_type == RC_DRIVER_SCANCODE ||
	    fattr->type == RC_FILTER_WAKEUP)
		allowed = dev->allowed_protocols[fattr->type];
863
	else if (dev->raw)
864
		allowed = ir_raw_get_allowed_protocols();
865
	else {
866
		mutex_unlock(&dev->lock);
867
		return -ENODEV;
868
	}
869 870 871 872 873 874 875 876 877 878

	IR_dprintk(1, "allowed - 0x%llx, enabled - 0x%llx\n",
		   (long long)allowed,
		   (long long)enabled);

	for (i = 0; i < ARRAY_SIZE(proto_names); i++) {
		if (allowed & enabled & proto_names[i].type)
			tmp += sprintf(tmp, "[%s] ", proto_names[i].name);
		else if (allowed & proto_names[i].type)
			tmp += sprintf(tmp, "%s ", proto_names[i].name);
879 880 881

		if (allowed & proto_names[i].type)
			allowed &= ~proto_names[i].type;
882 883 884 885 886
	}

	if (tmp != buf)
		tmp--;
	*tmp = '\n';
887 888 889

	mutex_unlock(&dev->lock);

890 891 892 893
	return tmp + 1 - buf;
}

/**
894
 * store_protocols() - changes the current/wakeup IR protocol(s)
895
 * @device:	the device descriptor
896 897 898 899
 * @mattr:	the device attribute struct (unused)
 * @buf:	a pointer to the input buffer
 * @len:	length of the input buffer
 *
900
 * This routine is for changing the IR protocol type.
901
 * It is trigged by writing to /sys/class/rc/rc?/[wakeup_]protocols.
902 903 904 905 906 907
 * Writing "+proto" will add a protocol to the list of enabled protocols.
 * Writing "-proto" will remove a protocol from the list of enabled protocols.
 * Writing "proto" will enable only "proto".
 * Writing "none" will disable all protocols.
 * Returns -EINVAL if an invalid protocol combination or unknown protocol name
 * is used, otherwise @len.
908 909 910
 *
 * dev->lock is taken to guard against races between device
 * registration, store_protocols and show_protocols.
911
 */
912
static ssize_t store_protocols(struct device *device,
913 914 915 916
			       struct device_attribute *mattr,
			       const char *data,
			       size_t len)
{
917
	struct rc_dev *dev = to_rc_dev(device);
918
	struct rc_filter_attribute *fattr = to_rc_filter_attr(mattr);
919 920
	bool enable, disable;
	const char *tmp;
921
	u64 old_type, type;
922 923
	u64 mask;
	int rc, i, count = 0;
924
	ssize_t ret;
925
	int (*change_protocol)(struct rc_dev *dev, u64 *rc_type);
926
	struct rc_scancode_filter local_filter, *filter;
927 928

	/* Device is being removed */
929
	if (!dev)
930 931
		return -EINVAL;

932 933
	mutex_lock(&dev->lock);

934
	if (dev->driver_type != RC_DRIVER_SCANCODE && !dev->raw) {
935
		IR_dprintk(1, "Protocol switching not supported\n");
936 937
		ret = -EINVAL;
		goto out;
938
	}
939 940
	old_type = dev->enabled_protocols[fattr->type];
	type = old_type;
941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958

	while ((tmp = strsep((char **) &data, " \n")) != NULL) {
		if (!*tmp)
			break;

		if (*tmp == '+') {
			enable = true;
			disable = false;
			tmp++;
		} else if (*tmp == '-') {
			enable = false;
			disable = true;
			tmp++;
		} else {
			enable = false;
			disable = false;
		}

959 960 961 962
		for (i = 0; i < ARRAY_SIZE(proto_names); i++) {
			if (!strcasecmp(tmp, proto_names[i].name)) {
				mask = proto_names[i].type;
				break;
963 964 965
			}
		}

966 967
		if (i == ARRAY_SIZE(proto_names)) {
			IR_dprintk(1, "Unknown protocol: '%s'\n", tmp);
968 969
			ret = -EINVAL;
			goto out;
970 971 972 973
		}

		count++;

974 975 976 977 978 979 980 981 982 983
		if (enable)
			type |= mask;
		else if (disable)
			type &= ~mask;
		else
			type = mask;
	}

	if (!count) {
		IR_dprintk(1, "Protocol not specified\n");
984 985
		ret = -EINVAL;
		goto out;
986 987
	}

988 989 990 991
	change_protocol = (fattr->type == RC_FILTER_NORMAL)
		? dev->change_protocol : dev->change_wakeup_protocol;
	if (change_protocol) {
		rc = change_protocol(dev, &type);
992 993 994
		if (rc < 0) {
			IR_dprintk(1, "Error setting protocols to 0x%llx\n",
				   (long long)type);
995 996
			ret = -EINVAL;
			goto out;
997 998 999
		}
	}

1000
	dev->enabled_protocols[fattr->type] = type;
1001 1002 1003
	IR_dprintk(1, "Current protocol(s): 0x%llx\n",
		   (long long)type);

1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033
	/*
	 * If the protocol is changed the filter needs updating.
	 * Try setting the same filter with the new protocol (if any).
	 * Fall back to clearing the filter.
	 */
	filter = &dev->scancode_filters[fattr->type];
	if (old_type != type && filter->mask) {
		local_filter = *filter;
		if (!type) {
			/* no protocol => clear filter */
			ret = -1;
		} else if (!dev->s_filter) {
			/* generic filtering => accept any filter */
			ret = 0;
		} else {
			/* hardware filtering => try setting, otherwise clear */
			ret = dev->s_filter(dev, fattr->type, &local_filter);
		}
		if (ret < 0) {
			/* clear the filter */
			local_filter.data = 0;
			local_filter.mask = 0;
			if (dev->s_filter)
				dev->s_filter(dev, fattr->type, &local_filter);
		}

		/* commit the new filter */
		*filter = local_filter;
	}

1034 1035 1036 1037 1038
	ret = len;

out:
	mutex_unlock(&dev->lock);
	return ret;
1039 1040
}

1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070
/**
 * show_filter() - shows the current scancode filter value or mask
 * @device:	the device descriptor
 * @attr:	the device attribute struct
 * @buf:	a pointer to the output buffer
 *
 * This routine is a callback routine to read a scancode filter value or mask.
 * It is trigged by reading /sys/class/rc/rc?/[wakeup_]filter[_mask].
 * It prints the current scancode filter value or mask of the appropriate filter
 * type in hexadecimal into @buf and returns the size of the buffer.
 *
 * Bits of the filter value corresponding to set bits in the filter mask are
 * compared against input scancodes and non-matching scancodes are discarded.
 *
 * dev->lock is taken to guard against races between device registration,
 * store_filter and show_filter.
 */
static ssize_t show_filter(struct device *device,
			   struct device_attribute *attr,
			   char *buf)
{
	struct rc_dev *dev = to_rc_dev(device);
	struct rc_filter_attribute *fattr = to_rc_filter_attr(attr);
	u32 val;

	/* Device is being removed */
	if (!dev)
		return -EINVAL;

	mutex_lock(&dev->lock);
1071
	if (fattr->mask)
1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118
		val = dev->scancode_filters[fattr->type].mask;
	else
		val = dev->scancode_filters[fattr->type].data;
	mutex_unlock(&dev->lock);

	return sprintf(buf, "%#x\n", val);
}

/**
 * store_filter() - changes the scancode filter value
 * @device:	the device descriptor
 * @attr:	the device attribute struct
 * @buf:	a pointer to the input buffer
 * @len:	length of the input buffer
 *
 * This routine is for changing a scancode filter value or mask.
 * It is trigged by writing to /sys/class/rc/rc?/[wakeup_]filter[_mask].
 * Returns -EINVAL if an invalid filter value for the current protocol was
 * specified or if scancode filtering is not supported by the driver, otherwise
 * returns @len.
 *
 * Bits of the filter value corresponding to set bits in the filter mask are
 * compared against input scancodes and non-matching scancodes are discarded.
 *
 * dev->lock is taken to guard against races between device registration,
 * store_filter and show_filter.
 */
static ssize_t store_filter(struct device *device,
			    struct device_attribute *attr,
			    const char *buf,
			    size_t count)
{
	struct rc_dev *dev = to_rc_dev(device);
	struct rc_filter_attribute *fattr = to_rc_filter_attr(attr);
	struct rc_scancode_filter local_filter, *filter;
	int ret;
	unsigned long val;

	/* Device is being removed */
	if (!dev)
		return -EINVAL;

	ret = kstrtoul(buf, 0, &val);
	if (ret < 0)
		return ret;

	/* Scancode filter not supported (but still accept 0) */
1119
	if (!dev->s_filter && fattr->type != RC_FILTER_NORMAL)
1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130
		return val ? -EINVAL : count;

	mutex_lock(&dev->lock);

	/* Tell the driver about the new filter */
	filter = &dev->scancode_filters[fattr->type];
	local_filter = *filter;
	if (fattr->mask)
		local_filter.mask = val;
	else
		local_filter.data = val;
1131 1132 1133 1134 1135
	if (!dev->enabled_protocols[fattr->type] && local_filter.mask) {
		/* refuse to set a filter unless a protocol is enabled */
		ret = -EINVAL;
		goto unlock;
	}
1136 1137 1138 1139 1140
	if (dev->s_filter) {
		ret = dev->s_filter(dev, fattr->type, &local_filter);
		if (ret < 0)
			goto unlock;
	}
1141 1142 1143 1144 1145 1146

	/* Success, commit the new filter */
	*filter = local_filter;

unlock:
	mutex_unlock(&dev->lock);
1147
	return (ret < 0) ? ret : count;
1148 1149
}

1150 1151 1152 1153
static void rc_dev_release(struct device *device)
{
}

1154 1155 1156 1157 1158 1159 1160 1161 1162
#define ADD_HOTPLUG_VAR(fmt, val...)					\
	do {								\
		int err = add_uevent_var(env, fmt, val);		\
		if (err)						\
			return err;					\
	} while (0)

static int rc_dev_uevent(struct device *device, struct kobj_uevent_env *env)
{
1163
	struct rc_dev *dev = to_rc_dev(device);
1164

1165 1166 1167
	if (!dev || !dev->input_dev)
		return -ENODEV;

1168 1169
	if (dev->rc_map.name)
		ADD_HOTPLUG_VAR("NAME=%s", dev->rc_map.name);
1170 1171
	if (dev->driver_name)
		ADD_HOTPLUG_VAR("DRV_NAME=%s", dev->driver_name);
1172 1173 1174 1175 1176 1177 1178

	return 0;
}

/*
 * Static device attribute struct with the sysfs attributes for IR's
 */
1179 1180 1181 1182
static RC_PROTO_ATTR(protocols, S_IRUGO | S_IWUSR,
		     show_protocols, store_protocols, RC_FILTER_NORMAL);
static RC_PROTO_ATTR(wakeup_protocols, S_IRUGO | S_IWUSR,
		     show_protocols, store_protocols, RC_FILTER_WAKEUP);
1183 1184 1185 1186 1187 1188 1189 1190
static RC_FILTER_ATTR(filter, S_IRUGO|S_IWUSR,
		      show_filter, store_filter, RC_FILTER_NORMAL, false);
static RC_FILTER_ATTR(filter_mask, S_IRUGO|S_IWUSR,
		      show_filter, store_filter, RC_FILTER_NORMAL, true);
static RC_FILTER_ATTR(wakeup_filter, S_IRUGO|S_IWUSR,
		      show_filter, store_filter, RC_FILTER_WAKEUP, false);
static RC_FILTER_ATTR(wakeup_filter_mask, S_IRUGO|S_IWUSR,
		      show_filter, store_filter, RC_FILTER_WAKEUP, true);
1191 1192

static struct attribute *rc_dev_attrs[] = {
1193 1194
	&dev_attr_protocols.attr.attr,
	&dev_attr_wakeup_protocols.attr.attr,
1195 1196 1197 1198
	&dev_attr_filter.attr.attr,
	&dev_attr_filter_mask.attr.attr,
	&dev_attr_wakeup_filter.attr.attr,
	&dev_attr_wakeup_filter_mask.attr.attr,
1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212
	NULL,
};

static struct attribute_group rc_dev_attr_grp = {
	.attrs	= rc_dev_attrs,
};

static const struct attribute_group *rc_dev_attr_groups[] = {
	&rc_dev_attr_grp,
	NULL
};

static struct device_type rc_dev_type = {
	.groups		= rc_dev_attr_groups,
1213
	.release	= rc_dev_release,
1214 1215 1216
	.uevent		= rc_dev_uevent,
};

1217
struct rc_dev *rc_allocate_device(void)
1218
{
1219
	struct rc_dev *dev;
1220

1221 1222 1223 1224 1225 1226 1227 1228 1229 1230
	dev = kzalloc(sizeof(*dev), GFP_KERNEL);
	if (!dev)
		return NULL;

	dev->input_dev = input_allocate_device();
	if (!dev->input_dev) {
		kfree(dev);
		return NULL;
	}

1231 1232
	dev->input_dev->getkeycode = ir_getkeycode;
	dev->input_dev->setkeycode = ir_setkeycode;
1233 1234
	input_set_drvdata(dev->input_dev, dev);

1235
	spin_lock_init(&dev->rc_map.lock);
1236
	spin_lock_init(&dev->keylock);
1237
	mutex_init(&dev->lock);
1238
	setup_timer(&dev->timer_keyup, ir_timer_keyup, (unsigned long)dev);
1239

1240
	dev->dev.type = &rc_dev_type;
1241
	dev->dev.class = &rc_class;
1242 1243 1244 1245 1246 1247 1248 1249
	device_initialize(&dev->dev);

	__module_get(THIS_MODULE);
	return dev;
}
EXPORT_SYMBOL_GPL(rc_allocate_device);

void rc_free_device(struct rc_dev *dev)
1250
{
1251 1252 1253 1254
	if (!dev)
		return;

	if (dev->input_dev)
1255
		input_free_device(dev->input_dev);
1256 1257 1258 1259 1260

	put_device(&dev->dev);

	kfree(dev);
	module_put(THIS_MODULE);
1261 1262 1263 1264 1265
}
EXPORT_SYMBOL_GPL(rc_free_device);

int rc_register_device(struct rc_dev *dev)
{
1266
	static bool raw_init = false; /* raw decoders loaded? */
1267
	struct rc_map *rc_map;
1268
	const char *path;
1269
	int rc, devno;
1270

1271 1272
	if (!dev || !dev->map_name)
		return -EINVAL;
1273

1274
	rc_map = rc_map_get(dev->map_name);
1275
	if (!rc_map)
1276
		rc_map = rc_map_get(RC_MAP_EMPTY);
1277
	if (!rc_map || !rc_map->scan || rc_map->size == 0)
1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288
		return -EINVAL;

	set_bit(EV_KEY, dev->input_dev->evbit);
	set_bit(EV_REP, dev->input_dev->evbit);
	set_bit(EV_MSC, dev->input_dev->evbit);
	set_bit(MSC_SCAN, dev->input_dev->mscbit);
	if (dev->open)
		dev->input_dev->open = ir_open;
	if (dev->close)
		dev->input_dev->close = ir_close;

1289 1290 1291
	/*
	 * Take the lock here, as the device sysfs node will appear
	 * when device_add() is called, which may trigger an ir-keytable udev
1292 1293
	 * rule, which will in turn call show_protocols and access
	 * dev->enabled_protocols before it has been initialized.
1294 1295 1296
	 */
	mutex_lock(&dev->lock);

1297 1298 1299 1300 1301 1302 1303 1304 1305
	do {
		devno = find_first_zero_bit(ir_core_dev_number,
					    IRRCV_NUM_DEVICES);
		/* No free device slots */
		if (devno >= IRRCV_NUM_DEVICES)
			return -ENOMEM;
	} while (test_and_set_bit(devno, ir_core_dev_number));

	dev->devno = devno;
1306 1307 1308 1309
	dev_set_name(&dev->dev, "rc%ld", dev->devno);
	dev_set_drvdata(&dev->dev, dev);
	rc = device_add(&dev->dev);
	if (rc)
1310
		goto out_unlock;
1311

1312
	rc = ir_setkeytable(dev, rc_map);
1313 1314 1315 1316 1317 1318 1319
	if (rc)
		goto out_dev;

	dev->input_dev->dev.parent = &dev->dev;
	memcpy(&dev->input_dev->id, &dev->input_id, sizeof(dev->input_id));
	dev->input_dev->phys = dev->input_phys;
	dev->input_dev->name = dev->input_name;
1320 1321 1322 1323

	/* input_register_device can call ir_open, so unlock mutex here */
	mutex_unlock(&dev->lock);

1324
	rc = input_register_device(dev->input_dev);
1325 1326 1327

	mutex_lock(&dev->lock);

1328 1329
	if (rc)
		goto out_table;
1330

1331
	/*
L
Lucas De Marchi 已提交
1332
	 * Default delay of 250ms is too short for some protocols, especially
1333 1334 1335 1336 1337 1338
	 * since the timeout is currently set to 250ms. Increase it to 500ms,
	 * to avoid wrong repetition of the keycodes. Note that this must be
	 * set after the call to input_register_device().
	 */
	dev->input_dev->rep[REP_DELAY] = 500;

1339 1340 1341 1342 1343 1344 1345
	/*
	 * As a repeat event on protocols like RC-5 and NEC take as long as
	 * 110/114ms, using 33ms as a repeat period is not the right thing
	 * to do.
	 */
	dev->input_dev->rep[REP_PERIOD] = 125;

1346
	path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);
1347
	printk(KERN_INFO "%s: %s as %s\n",
1348 1349
		dev_name(&dev->dev),
		dev->input_name ? dev->input_name : "Unspecified device",
1350 1351 1352
		path ? path : "N/A");
	kfree(path);

1353
	if (dev->driver_type == RC_DRIVER_IR_RAW) {
1354 1355 1356 1357 1358 1359
		/* Load raw decoders, if they aren't already */
		if (!raw_init) {
			IR_dprintk(1, "Loading raw decoders\n");
			ir_raw_init();
			raw_init = true;
		}
1360 1361 1362 1363 1364 1365
		rc = ir_raw_event_register(dev);
		if (rc < 0)
			goto out_input;
	}

	if (dev->change_protocol) {
1366 1367
		u64 rc_type = (1 << rc_map->rc_type);
		rc = dev->change_protocol(dev, &rc_type);
1368 1369
		if (rc < 0)
			goto out_raw;
1370
		dev->enabled_protocols[RC_FILTER_NORMAL] = rc_type;
1371 1372
	}

1373 1374
	mutex_unlock(&dev->lock);

1375 1376 1377
	IR_dprintk(1, "Registered rc%ld (driver: %s, remote: %s, mode %s)\n",
		   dev->devno,
		   dev->driver_name ? dev->driver_name : "unknown",
1378
		   rc_map->name ? rc_map->name : "unknown",
1379 1380
		   dev->driver_type == RC_DRIVER_IR_RAW ? "raw" : "cooked");

1381
	return 0;
1382 1383 1384 1385 1386 1387 1388 1389

out_raw:
	if (dev->driver_type == RC_DRIVER_IR_RAW)
		ir_raw_event_unregister(dev);
out_input:
	input_unregister_device(dev->input_dev);
	dev->input_dev = NULL;
out_table:
1390
	ir_free_table(&dev->rc_map);
1391 1392
out_dev:
	device_del(&dev->dev);
1393 1394
out_unlock:
	mutex_unlock(&dev->lock);
1395
	clear_bit(dev->devno, ir_core_dev_number);
1396
	return rc;
1397
}
1398
EXPORT_SYMBOL_GPL(rc_register_device);
1399

1400
void rc_unregister_device(struct rc_dev *dev)
1401
{
1402 1403
	if (!dev)
		return;
1404

1405
	del_timer_sync(&dev->timer_keyup);
1406

1407 1408
	clear_bit(dev->devno, ir_core_dev_number);

1409 1410 1411
	if (dev->driver_type == RC_DRIVER_IR_RAW)
		ir_raw_event_unregister(dev);

1412 1413 1414 1415
	/* Freeing the table should also call the stop callback */
	ir_free_table(&dev->rc_map);
	IR_dprintk(1, "Freed keycode table\n");

1416 1417 1418
	input_unregister_device(dev->input_dev);
	dev->input_dev = NULL;

1419
	device_del(&dev->dev);
1420

1421
	rc_free_device(dev);
1422
}
1423

1424
EXPORT_SYMBOL_GPL(rc_unregister_device);
1425 1426 1427 1428 1429

/*
 * Init/exit code for the module. Basically, creates/removes /sys/class/rc
 */

1430
static int __init rc_core_init(void)
1431
{
1432
	int rc = class_register(&rc_class);
1433
	if (rc) {
1434
		printk(KERN_ERR "rc_core: unable to register rc class\n");
1435 1436 1437
		return rc;
	}

1438
	led_trigger_register_simple("rc-feedback", &led_feedback);
1439
	rc_map_register(&empty_map);
1440 1441 1442 1443

	return 0;
}

1444
static void __exit rc_core_exit(void)
1445
{
1446
	class_unregister(&rc_class);
1447
	led_trigger_unregister_simple(led_feedback);
1448
	rc_map_unregister(&empty_map);
1449 1450
}

1451
subsys_initcall(rc_core_init);
1452
module_exit(rc_core_exit);
1453

1454 1455 1456
int rc_core_debug;    /* ir_debug level (0,1,2) */
EXPORT_SYMBOL_GPL(rc_core_debug);
module_param_named(debug, rc_core_debug, int, 0644);
1457

1458
MODULE_AUTHOR("Mauro Carvalho Chehab");
1459
MODULE_LICENSE("GPL");