Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dtor/input
[~shefty/rdma-dev.git] / drivers / media / IR / ir-keytable.c
1 /* ir-keytable.c - handle IR scancode->keycode tables
2  *
3  * Copyright (C) 2009 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
16 #include <linux/input.h>
17 #include <linux/slab.h>
18 #include "ir-core-priv.h"
19
20 /* Sizes are in bytes, 256 bytes allows for 32 entries on x64 */
21 #define IR_TAB_MIN_SIZE 256
22 #define IR_TAB_MAX_SIZE 8192
23
24 /* FIXME: IR_KEYPRESS_TIMEOUT should be protocol specific */
25 #define IR_KEYPRESS_TIMEOUT 250
26
27 /**
28  * ir_create_table() - initializes a scancode table
29  * @rc_tab:     the ir_scancode_table to initialize
30  * @name:       name to assign to the table
31  * @ir_type:    ir type to assign to the new table
32  * @size:       initial size of the table
33  * @return:     zero on success or a negative error code
34  *
35  * This routine will initialize the ir_scancode_table and will allocate
36  * memory to hold at least the specified number elements.
37  */
38 static int ir_create_table(struct ir_scancode_table *rc_tab,
39                            const char *name, u64 ir_type, size_t size)
40 {
41         rc_tab->name = name;
42         rc_tab->ir_type = ir_type;
43         rc_tab->alloc = roundup_pow_of_two(size * sizeof(struct ir_scancode));
44         rc_tab->size = rc_tab->alloc / sizeof(struct ir_scancode);
45         rc_tab->scan = kmalloc(rc_tab->alloc, GFP_KERNEL);
46         if (!rc_tab->scan)
47                 return -ENOMEM;
48
49         IR_dprintk(1, "Allocated space for %u keycode entries (%u bytes)\n",
50                    rc_tab->size, rc_tab->alloc);
51         return 0;
52 }
53
54 /**
55  * ir_free_table() - frees memory allocated by a scancode table
56  * @rc_tab:     the table whose mappings need to be freed
57  *
58  * This routine will free memory alloctaed for key mappings used by given
59  * scancode table.
60  */
61 static void ir_free_table(struct ir_scancode_table *rc_tab)
62 {
63         rc_tab->size = 0;
64         kfree(rc_tab->scan);
65         rc_tab->scan = NULL;
66 }
67
68 /**
69  * ir_resize_table() - resizes a scancode table if necessary
70  * @rc_tab:     the ir_scancode_table to resize
71  * @gfp_flags:  gfp flags to use when allocating memory
72  * @return:     zero on success or a negative error code
73  *
74  * This routine will shrink the ir_scancode_table if it has lots of
75  * unused entries and grow it if it is full.
76  */
77 static int ir_resize_table(struct ir_scancode_table *rc_tab, gfp_t gfp_flags)
78 {
79         unsigned int oldalloc = rc_tab->alloc;
80         unsigned int newalloc = oldalloc;
81         struct ir_scancode *oldscan = rc_tab->scan;
82         struct ir_scancode *newscan;
83
84         if (rc_tab->size == rc_tab->len) {
85                 /* All entries in use -> grow keytable */
86                 if (rc_tab->alloc >= IR_TAB_MAX_SIZE)
87                         return -ENOMEM;
88
89                 newalloc *= 2;
90                 IR_dprintk(1, "Growing table to %u bytes\n", newalloc);
91         }
92
93         if ((rc_tab->len * 3 < rc_tab->size) && (oldalloc > IR_TAB_MIN_SIZE)) {
94                 /* Less than 1/3 of entries in use -> shrink keytable */
95                 newalloc /= 2;
96                 IR_dprintk(1, "Shrinking table to %u bytes\n", newalloc);
97         }
98
99         if (newalloc == oldalloc)
100                 return 0;
101
102         newscan = kmalloc(newalloc, gfp_flags);
103         if (!newscan) {
104                 IR_dprintk(1, "Failed to kmalloc %u bytes\n", newalloc);
105                 return -ENOMEM;
106         }
107
108         memcpy(newscan, rc_tab->scan, rc_tab->len * sizeof(struct ir_scancode));
109         rc_tab->scan = newscan;
110         rc_tab->alloc = newalloc;
111         rc_tab->size = rc_tab->alloc / sizeof(struct ir_scancode);
112         kfree(oldscan);
113         return 0;
114 }
115
116 /**
117  * ir_update_mapping() - set a keycode in the scancode->keycode table
118  * @dev:        the struct input_dev device descriptor
119  * @rc_tab:     scancode table to be adjusted
120  * @index:      index of the mapping that needs to be updated
121  * @keycode:    the desired keycode
122  * @return:     previous keycode assigned to the mapping
123  *
124  * This routine is used to update scancode->keycopde mapping at given
125  * position.
126  */
127 static unsigned int ir_update_mapping(struct input_dev *dev,
128                                       struct ir_scancode_table *rc_tab,
129                                       unsigned int index,
130                                       unsigned int new_keycode)
131 {
132         int old_keycode = rc_tab->scan[index].keycode;
133         int i;
134
135         /* Did the user wish to remove the mapping? */
136         if (new_keycode == KEY_RESERVED || new_keycode == KEY_UNKNOWN) {
137                 IR_dprintk(1, "#%d: Deleting scan 0x%04x\n",
138                            index, rc_tab->scan[index].scancode);
139                 rc_tab->len--;
140                 memmove(&rc_tab->scan[index], &rc_tab->scan[index+ 1],
141                         (rc_tab->len - index) * sizeof(struct ir_scancode));
142         } else {
143                 IR_dprintk(1, "#%d: %s scan 0x%04x with key 0x%04x\n",
144                            index,
145                            old_keycode == KEY_RESERVED ? "New" : "Replacing",
146                            rc_tab->scan[index].scancode, new_keycode);
147                 rc_tab->scan[index].keycode = new_keycode;
148                 __set_bit(new_keycode, dev->keybit);
149         }
150
151         if (old_keycode != KEY_RESERVED) {
152                 /* A previous mapping was updated... */
153                 __clear_bit(old_keycode, dev->keybit);
154                 /* ... but another scancode might use the same keycode */
155                 for (i = 0; i < rc_tab->len; i++) {
156                         if (rc_tab->scan[i].keycode == old_keycode) {
157                                 __set_bit(old_keycode, dev->keybit);
158                                 break;
159                         }
160                 }
161
162                 /* Possibly shrink the keytable, failure is not a problem */
163                 ir_resize_table(rc_tab, GFP_ATOMIC);
164         }
165
166         return old_keycode;
167 }
168
169 /**
170  * ir_locate_scancode() - set a keycode in the scancode->keycode table
171  * @ir_dev:     the struct ir_input_dev device descriptor
172  * @rc_tab:     scancode table to be searched
173  * @scancode:   the desired scancode
174  * @resize:     controls whether we allowed to resize the table to
175  *              accomodate not yet present scancodes
176  * @return:     index of the mapping containing scancode in question
177  *              or -1U in case of failure.
178  *
179  * This routine is used to locate given scancode in ir_scancode_table.
180  * If scancode is not yet present the routine will allocate a new slot
181  * for it.
182  */
183 static unsigned int ir_establish_scancode(struct ir_input_dev *ir_dev,
184                                           struct ir_scancode_table *rc_tab,
185                                           unsigned int scancode,
186                                           bool resize)
187 {
188         unsigned int i;
189
190         /*
191          * Unfortunately, some hardware-based IR decoders don't provide
192          * all bits for the complete IR code. In general, they provide only
193          * the command part of the IR code. Yet, as it is possible to replace
194          * the provided IR with another one, it is needed to allow loading
195          * IR tables from other remotes. So,
196          */
197         if (ir_dev->props && ir_dev->props->scanmask)
198                 scancode &= ir_dev->props->scanmask;
199
200         /* First check if we already have a mapping for this ir command */
201         for (i = 0; i < rc_tab->len; i++) {
202                 if (rc_tab->scan[i].scancode == scancode)
203                         return i;
204
205                 /* Keytable is sorted from lowest to highest scancode */
206                 if (rc_tab->scan[i].scancode >= scancode)
207                         break;
208         }
209
210         /* No previous mapping found, we might need to grow the table */
211         if (rc_tab->size == rc_tab->len) {
212                 if (!resize || ir_resize_table(rc_tab, GFP_ATOMIC))
213                         return -1U;
214         }
215
216         /* i is the proper index to insert our new keycode */
217         if (i < rc_tab->len)
218                 memmove(&rc_tab->scan[i + 1], &rc_tab->scan[i],
219                         (rc_tab->len - i) * sizeof(struct ir_scancode));
220         rc_tab->scan[i].scancode = scancode;
221         rc_tab->scan[i].keycode = KEY_RESERVED;
222         rc_tab->len++;
223
224         return i;
225 }
226
227 /**
228  * ir_setkeycode() - set a keycode in the scancode->keycode table
229  * @dev:        the struct input_dev device descriptor
230  * @scancode:   the desired scancode
231  * @keycode:    result
232  * @return:     -EINVAL if the keycode could not be inserted, otherwise zero.
233  *
234  * This routine is used to handle evdev EVIOCSKEY ioctl.
235  */
236 static int ir_setkeycode(struct input_dev *dev,
237                          const struct input_keymap_entry *ke,
238                          unsigned int *old_keycode)
239 {
240         struct ir_input_dev *ir_dev = input_get_drvdata(dev);
241         struct ir_scancode_table *rc_tab = &ir_dev->rc_tab;
242         unsigned int index;
243         unsigned int scancode;
244         int retval;
245         unsigned long flags;
246
247         spin_lock_irqsave(&rc_tab->lock, flags);
248
249         if (ke->flags & INPUT_KEYMAP_BY_INDEX) {
250                 index = ke->index;
251                 if (index >= rc_tab->len) {
252                         retval = -EINVAL;
253                         goto out;
254                 }
255         } else {
256                 retval = input_scancode_to_scalar(ke, &scancode);
257                 if (retval)
258                         goto out;
259
260                 index = ir_establish_scancode(ir_dev, rc_tab, scancode, true);
261                 if (index >= rc_tab->len) {
262                         retval = -ENOMEM;
263                         goto out;
264                 }
265         }
266
267         *old_keycode = ir_update_mapping(dev, rc_tab, index, ke->keycode);
268
269 out:
270         spin_unlock_irqrestore(&rc_tab->lock, flags);
271         return retval;
272 }
273
274 /**
275  * ir_setkeytable() - sets several entries in the scancode->keycode table
276  * @dev:        the struct input_dev device descriptor
277  * @to:         the struct ir_scancode_table to copy entries to
278  * @from:       the struct ir_scancode_table to copy entries from
279  * @return:     -ENOMEM if all keycodes could not be inserted, otherwise zero.
280  *
281  * This routine is used to handle table initialization.
282  */
283 static int ir_setkeytable(struct ir_input_dev *ir_dev,
284                           const struct ir_scancode_table *from)
285 {
286         struct ir_scancode_table *rc_tab = &ir_dev->rc_tab;
287         unsigned int i, index;
288         int rc;
289
290         rc = ir_create_table(&ir_dev->rc_tab,
291                              from->name, from->ir_type, from->size);
292         if (rc)
293                 return rc;
294
295         IR_dprintk(1, "Allocated space for %u keycode entries (%u bytes)\n",
296                    rc_tab->size, rc_tab->alloc);
297
298         for (i = 0; i < from->size; i++) {
299                 index = ir_establish_scancode(ir_dev, rc_tab,
300                                               from->scan[i].scancode, false);
301                 if (index >= rc_tab->len) {
302                         rc = -ENOMEM;
303                         break;
304                 }
305
306                 ir_update_mapping(ir_dev->input_dev, rc_tab, index,
307                                   from->scan[i].keycode);
308         }
309
310         if (rc)
311                 ir_free_table(rc_tab);
312
313         return rc;
314 }
315
316 /**
317  * ir_lookup_by_scancode() - locate mapping by scancode
318  * @rc_tab:     the &struct ir_scancode_table to search
319  * @scancode:   scancode to look for in the table
320  * @return:     index in the table, -1U if not found
321  *
322  * This routine performs binary search in RC keykeymap table for
323  * given scancode.
324  */
325 static unsigned int ir_lookup_by_scancode(const struct ir_scancode_table *rc_tab,
326                                           unsigned int scancode)
327 {
328         unsigned int start = 0;
329         unsigned int end = rc_tab->len - 1;
330         unsigned int mid;
331
332         while (start <= end) {
333                 mid = (start + end) / 2;
334                 if (rc_tab->scan[mid].scancode < scancode)
335                         start = mid + 1;
336                 else if (rc_tab->scan[mid].scancode > scancode)
337                         end = mid - 1;
338                 else
339                         return mid;
340         }
341
342         return -1U;
343 }
344
345 /**
346  * ir_getkeycode() - get a keycode from the scancode->keycode table
347  * @dev:        the struct input_dev device descriptor
348  * @scancode:   the desired scancode
349  * @keycode:    used to return the keycode, if found, or KEY_RESERVED
350  * @return:     always returns zero.
351  *
352  * This routine is used to handle evdev EVIOCGKEY ioctl.
353  */
354 static int ir_getkeycode(struct input_dev *dev,
355                          struct input_keymap_entry *ke)
356 {
357         struct ir_input_dev *ir_dev = input_get_drvdata(dev);
358         struct ir_scancode_table *rc_tab = &ir_dev->rc_tab;
359         struct ir_scancode *entry;
360         unsigned long flags;
361         unsigned int index;
362         unsigned int scancode;
363         int retval;
364
365         spin_lock_irqsave(&rc_tab->lock, flags);
366
367         if (ke->flags & INPUT_KEYMAP_BY_INDEX) {
368                 index = ke->index;
369         } else {
370                 retval = input_scancode_to_scalar(ke, &scancode);
371                 if (retval)
372                         goto out;
373
374                 index = ir_lookup_by_scancode(rc_tab, scancode);
375         }
376
377         if (index >= rc_tab->len) {
378                 if (!(ke->flags & INPUT_KEYMAP_BY_INDEX))
379                         IR_dprintk(1, "unknown key for scancode 0x%04x\n",
380                                    scancode);
381                 retval = -EINVAL;
382                 goto out;
383         }
384
385         entry = &rc_tab->scan[index];
386
387         ke->index = index;
388         ke->keycode = entry->keycode;
389         ke->len = sizeof(entry->scancode);
390         memcpy(ke->scancode, &entry->scancode, sizeof(entry->scancode));
391
392 out:
393         spin_unlock_irqrestore(&rc_tab->lock, flags);
394         return retval;
395 }
396
397 /**
398  * ir_g_keycode_from_table() - gets the keycode that corresponds to a scancode
399  * @input_dev:  the struct input_dev descriptor of the device
400  * @scancode:   the scancode that we're seeking
401  *
402  * This routine is used by the input routines when a key is pressed at the
403  * IR. The scancode is received and needs to be converted into a keycode.
404  * If the key is not found, it returns KEY_RESERVED. Otherwise, returns the
405  * corresponding keycode from the table.
406  */
407 u32 ir_g_keycode_from_table(struct input_dev *dev, u32 scancode)
408 {
409         struct ir_input_dev *ir_dev = input_get_drvdata(dev);
410         struct ir_scancode_table *rc_tab = &ir_dev->rc_tab;
411         unsigned int keycode;
412         unsigned int index;
413         unsigned long flags;
414
415         spin_lock_irqsave(&rc_tab->lock, flags);
416
417         index = ir_lookup_by_scancode(rc_tab, scancode);
418         keycode = index < rc_tab->len ?
419                         rc_tab->scan[index].keycode : KEY_RESERVED;
420
421         spin_unlock_irqrestore(&rc_tab->lock, flags);
422
423         if (keycode != KEY_RESERVED)
424                 IR_dprintk(1, "%s: scancode 0x%04x keycode 0x%02x\n",
425                            dev->name, scancode, keycode);
426
427         return keycode;
428 }
429 EXPORT_SYMBOL_GPL(ir_g_keycode_from_table);
430
431 /**
432  * ir_keyup() - generates input event to cleanup a key press
433  * @ir:         the struct ir_input_dev descriptor of the device
434  *
435  * This routine is used to signal that a key has been released on the
436  * remote control. It reports a keyup input event via input_report_key().
437  */
438 static void ir_keyup(struct ir_input_dev *ir)
439 {
440         if (!ir->keypressed)
441                 return;
442
443         IR_dprintk(1, "keyup key 0x%04x\n", ir->last_keycode);
444         input_report_key(ir->input_dev, ir->last_keycode, 0);
445         input_sync(ir->input_dev);
446         ir->keypressed = false;
447 }
448
449 /**
450  * ir_timer_keyup() - generates a keyup event after a timeout
451  * @cookie:     a pointer to struct ir_input_dev passed to setup_timer()
452  *
453  * This routine will generate a keyup event some time after a keydown event
454  * is generated when no further activity has been detected.
455  */
456 static void ir_timer_keyup(unsigned long cookie)
457 {
458         struct ir_input_dev *ir = (struct ir_input_dev *)cookie;
459         unsigned long flags;
460
461         /*
462          * ir->keyup_jiffies is used to prevent a race condition if a
463          * hardware interrupt occurs at this point and the keyup timer
464          * event is moved further into the future as a result.
465          *
466          * The timer will then be reactivated and this function called
467          * again in the future. We need to exit gracefully in that case
468          * to allow the input subsystem to do its auto-repeat magic or
469          * a keyup event might follow immediately after the keydown.
470          */
471         spin_lock_irqsave(&ir->keylock, flags);
472         if (time_is_before_eq_jiffies(ir->keyup_jiffies))
473                 ir_keyup(ir);
474         spin_unlock_irqrestore(&ir->keylock, flags);
475 }
476
477 /**
478  * ir_repeat() - notifies the IR core that a key is still pressed
479  * @dev:        the struct input_dev descriptor of the device
480  *
481  * This routine is used by IR decoders when a repeat message which does
482  * not include the necessary bits to reproduce the scancode has been
483  * received.
484  */
485 void ir_repeat(struct input_dev *dev)
486 {
487         unsigned long flags;
488         struct ir_input_dev *ir = input_get_drvdata(dev);
489
490         spin_lock_irqsave(&ir->keylock, flags);
491
492         input_event(dev, EV_MSC, MSC_SCAN, ir->last_scancode);
493
494         if (!ir->keypressed)
495                 goto out;
496
497         ir->keyup_jiffies = jiffies + msecs_to_jiffies(IR_KEYPRESS_TIMEOUT);
498         mod_timer(&ir->timer_keyup, ir->keyup_jiffies);
499
500 out:
501         spin_unlock_irqrestore(&ir->keylock, flags);
502 }
503 EXPORT_SYMBOL_GPL(ir_repeat);
504
505 /**
506  * ir_keydown() - generates input event for a key press
507  * @dev:        the struct input_dev descriptor of the device
508  * @scancode:   the scancode that we're seeking
509  * @toggle:     the toggle value (protocol dependent, if the protocol doesn't
510  *              support toggle values, this should be set to zero)
511  *
512  * This routine is used by the input routines when a key is pressed at the
513  * IR. It gets the keycode for a scancode and reports an input event via
514  * input_report_key().
515  */
516 void ir_keydown(struct input_dev *dev, int scancode, u8 toggle)
517 {
518         unsigned long flags;
519         struct ir_input_dev *ir = input_get_drvdata(dev);
520
521         u32 keycode = ir_g_keycode_from_table(dev, scancode);
522
523         spin_lock_irqsave(&ir->keylock, flags);
524
525         input_event(dev, EV_MSC, MSC_SCAN, scancode);
526
527         /* Repeat event? */
528         if (ir->keypressed &&
529             ir->last_scancode == scancode &&
530             ir->last_toggle == toggle)
531                 goto set_timer;
532
533         /* Release old keypress */
534         ir_keyup(ir);
535
536         ir->last_scancode = scancode;
537         ir->last_toggle = toggle;
538         ir->last_keycode = keycode;
539
540
541         if (keycode == KEY_RESERVED)
542                 goto out;
543
544
545         /* Register a keypress */
546         ir->keypressed = true;
547         IR_dprintk(1, "%s: key down event, key 0x%04x, scancode 0x%04x\n",
548                    dev->name, keycode, scancode);
549         input_report_key(dev, ir->last_keycode, 1);
550         input_sync(dev);
551
552 set_timer:
553         ir->keyup_jiffies = jiffies + msecs_to_jiffies(IR_KEYPRESS_TIMEOUT);
554         mod_timer(&ir->timer_keyup, ir->keyup_jiffies);
555 out:
556         spin_unlock_irqrestore(&ir->keylock, flags);
557 }
558 EXPORT_SYMBOL_GPL(ir_keydown);
559
560 static int ir_open(struct input_dev *input_dev)
561 {
562         struct ir_input_dev *ir_dev = input_get_drvdata(input_dev);
563
564         return ir_dev->props->open(ir_dev->props->priv);
565 }
566
567 static void ir_close(struct input_dev *input_dev)
568 {
569         struct ir_input_dev *ir_dev = input_get_drvdata(input_dev);
570
571         ir_dev->props->close(ir_dev->props->priv);
572 }
573
574 /**
575  * __ir_input_register() - sets the IR keycode table and add the handlers
576  *                          for keymap table get/set
577  * @input_dev:  the struct input_dev descriptor of the device
578  * @rc_tab:     the struct ir_scancode_table table of scancode/keymap
579  *
580  * This routine is used to initialize the input infrastructure
581  * to work with an IR.
582  * It will register the input/evdev interface for the device and
583  * register the syfs code for IR class
584  */
585 int __ir_input_register(struct input_dev *input_dev,
586                       const struct ir_scancode_table *rc_tab,
587                       struct ir_dev_props *props,
588                       const char *driver_name)
589 {
590         struct ir_input_dev *ir_dev;
591         int rc;
592
593         if (rc_tab->scan == NULL || !rc_tab->size)
594                 return -EINVAL;
595
596         ir_dev = kzalloc(sizeof(*ir_dev), GFP_KERNEL);
597         if (!ir_dev)
598                 return -ENOMEM;
599
600         ir_dev->driver_name = kasprintf(GFP_KERNEL, "%s", driver_name);
601         if (!ir_dev->driver_name) {
602                 rc = -ENOMEM;
603                 goto out_dev;
604         }
605
606         input_dev->getkeycode_new = ir_getkeycode;
607         input_dev->setkeycode_new = ir_setkeycode;
608         input_set_drvdata(input_dev, ir_dev);
609         ir_dev->input_dev = input_dev;
610
611         spin_lock_init(&ir_dev->rc_tab.lock);
612         spin_lock_init(&ir_dev->keylock);
613         setup_timer(&ir_dev->timer_keyup, ir_timer_keyup, (unsigned long)ir_dev);
614
615         if (props) {
616                 ir_dev->props = props;
617                 if (props->open)
618                         input_dev->open = ir_open;
619                 if (props->close)
620                         input_dev->close = ir_close;
621         }
622
623         set_bit(EV_KEY, input_dev->evbit);
624         set_bit(EV_REP, input_dev->evbit);
625         set_bit(EV_MSC, input_dev->evbit);
626         set_bit(MSC_SCAN, input_dev->mscbit);
627
628         rc = ir_setkeytable(ir_dev, rc_tab);
629         if (rc)
630                 goto out_name;
631
632         rc = ir_register_class(input_dev);
633         if (rc < 0)
634                 goto out_table;
635
636         if (ir_dev->props)
637                 if (ir_dev->props->driver_type == RC_DRIVER_IR_RAW) {
638                         rc = ir_raw_event_register(input_dev);
639                         if (rc < 0)
640                                 goto out_event;
641                 }
642
643         IR_dprintk(1, "Registered input device on %s for %s remote%s.\n",
644                    driver_name, rc_tab->name,
645                    (ir_dev->props && ir_dev->props->driver_type == RC_DRIVER_IR_RAW) ?
646                         " in raw mode" : "");
647
648         /*
649          * Default delay of 250ms is too short for some protocols, expecially
650          * since the timeout is currently set to 250ms. Increase it to 500ms,
651          * to avoid wrong repetition of the keycodes.
652          */
653         input_dev->rep[REP_DELAY] = 500;
654
655         return 0;
656
657 out_event:
658         ir_unregister_class(input_dev);
659 out_table:
660         ir_free_table(&ir_dev->rc_tab);
661 out_name:
662         kfree(ir_dev->driver_name);
663 out_dev:
664         kfree(ir_dev);
665         return rc;
666 }
667 EXPORT_SYMBOL_GPL(__ir_input_register);
668
669 /**
670  * ir_input_unregister() - unregisters IR and frees resources
671  * @input_dev:  the struct input_dev descriptor of the device
672
673  * This routine is used to free memory and de-register interfaces.
674  */
675 void ir_input_unregister(struct input_dev *input_dev)
676 {
677         struct ir_input_dev *ir_dev = input_get_drvdata(input_dev);
678
679         if (!ir_dev)
680                 return;
681
682         IR_dprintk(1, "Freed keycode table\n");
683
684         del_timer_sync(&ir_dev->timer_keyup);
685         if (ir_dev->props)
686                 if (ir_dev->props->driver_type == RC_DRIVER_IR_RAW)
687                         ir_raw_event_unregister(input_dev);
688
689         ir_free_table(&ir_dev->rc_tab);
690
691         ir_unregister_class(input_dev);
692
693         kfree(ir_dev->driver_name);
694         kfree(ir_dev);
695 }
696 EXPORT_SYMBOL_GPL(ir_input_unregister);
697
698 int ir_core_debug;    /* ir_debug level (0,1,2) */
699 EXPORT_SYMBOL_GPL(ir_core_debug);
700 module_param_named(debug, ir_core_debug, int, 0644);
701
702 MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@redhat.com>");
703 MODULE_LICENSE("GPL");