?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[IA64] perfmon: Change vmalloc to vzalloc and drop memset.
[linux-2.6.git] / drivers / input / input.c
blobdb409d6bd5d2b9672ad94f370564f870bed25b19
1 /*
2 * The input core
3 *
4 * Copyright (c) 1999-2002 Vojtech Pavlik
5 */
6
7 /*
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License version 2 as published by
10 * the Free Software Foundation.
11 */
12
13 #include <linux/init.h>
14 #include <linux/types.h>
15 #include <linux/input.h>
16 #include <linux/module.h>
17 #include <linux/slab.h>
18 #include <linux/random.h>
19 #include <linux/major.h>
20 #include <linux/proc_fs.h>
21 #include <linux/sched.h>
22 #include <linux/seq_file.h>
23 #include <linux/poll.h>
24 #include <linux/device.h>
25 #include <linux/mutex.h>
26 #include <linux/rcupdate.h>
27 #include "input-compat.h"
28
29 MODULE_AUTHOR("Vojtech Pavlik <vojtech@suse.cz>");
30 MODULE_DESCRIPTION("Input core");
31 MODULE_LICENSE("GPL");
32
33 #define INPUT_DEVICES 256
34
35 static LIST_HEAD(input_dev_list);
36 static LIST_HEAD(input_handler_list);
37
38 /*
39 * input_mutex protects access to both input_dev_list and input_handler_list.
40 * This also causes input_[un]register_device and input_[un]register_handler
41 * be mutually exclusive which simplifies locking in drivers implementing
42 * input handlers.
43 */
44 static DEFINE_MUTEX(input_mutex);
45
46 static struct input_handler *input_table[8];
47
48 static inline int is_event_supported(unsigned int code,
49 unsigned long *bm, unsigned int max)
50 {
51 return code <= max && test_bit(code, bm);
52 }
53
54 static int input_defuzz_abs_event(int value, int old_val, int fuzz)
55 {
56 if (fuzz) {
57 if (value > old_val - fuzz / 2 && value < old_val + fuzz / 2)
58 return old_val;
59
60 if (value > old_val - fuzz && value < old_val + fuzz)
61 return (old_val * 3 + value) / 4;
62
63 if (value > old_val - fuzz * 2 && value < old_val + fuzz * 2)
64 return (old_val + value) / 2;
65 }
66
67 return value;
68 }
69
70 /*
71 * Pass event first through all filters and then, if event has not been
72 * filtered out, through all open handles. This function is called with
73 * dev->event_lock held and interrupts disabled.
74 */
75 static void input_pass_event(struct input_dev *dev,
76 struct input_handler *src_handler,
77 unsigned int type, unsigned int code, int value)
78 {
79 struct input_handler *handler;
80 struct input_handle *handle;
81
82 rcu_read_lock();
83
84 handle = rcu_dereference(dev->grab);
85 if (handle)
86 handle->handler->event(handle, type, code, value);
87 else {
88 bool filtered = false;
89
90 list_for_each_entry_rcu(handle, &dev->h_list, d_node) {
91 if (!handle->open)
92 continue;
93
94 handler = handle->handler;
95
96 /*
97 * If this is the handler that injected this
98 * particular event we want to skip it to avoid
99 * filters firing again and again.
100 */
101 if (handler == src_handler)
102 continue;
103
104 if (!handler->filter) {
105 if (filtered)
106 break;
107
108 handler->event(handle, type, code, value);
109
110 } else if (handler->filter(handle, type, code, value))
111 filtered = true;
112 }
113 }
114
115 rcu_read_unlock();
116 }
117
118 /*
119 * Generate software autorepeat event. Note that we take
120 * dev->event_lock here to avoid racing with input_event
121 * which may cause keys get "stuck".
122 */
123 static void input_repeat_key(unsigned long data)
124 {
125 struct input_dev *dev = (void *) data;
126 unsigned long flags;
127
128 spin_lock_irqsave(&dev->event_lock, flags);
129
130 if (test_bit(dev->repeat_key, dev->key) &&
131 is_event_supported(dev->repeat_key, dev->keybit, KEY_MAX)) {
132
133 input_pass_event(dev, NULL, EV_KEY, dev->repeat_key, 2);
134
135 if (dev->sync) {
136 /*
137 * Only send SYN_REPORT if we are not in a middle
138 * of driver parsing a new hardware packet.
139 * Otherwise assume that the driver will send
140 * SYN_REPORT once it's done.
141 */
142 input_pass_event(dev, NULL, EV_SYN, SYN_REPORT, 1);
143 }
144
145 if (dev->rep[REP_PERIOD])
146 mod_timer(&dev->timer, jiffies +
147 msecs_to_jiffies(dev->rep[REP_PERIOD]));
148 }
149
150 spin_unlock_irqrestore(&dev->event_lock, flags);
151 }
152
153 static void input_start_autorepeat(struct input_dev *dev, int code)
154 {
155 if (test_bit(EV_REP, dev->evbit) &&
156 dev->rep[REP_PERIOD] && dev->rep[REP_DELAY] &&
157 dev->timer.data) {
158 dev->repeat_key = code;
159 mod_timer(&dev->timer,
160 jiffies + msecs_to_jiffies(dev->rep[REP_DELAY]));
161 }
162 }
163
164 static void input_stop_autorepeat(struct input_dev *dev)
165 {
166 del_timer(&dev->timer);
167 }
168
169 #define INPUT_IGNORE_EVENT 0
170 #define INPUT_PASS_TO_HANDLERS 1
171 #define INPUT_PASS_TO_DEVICE 2
172 #define INPUT_PASS_TO_ALL (INPUT_PASS_TO_HANDLERS | INPUT_PASS_TO_DEVICE)
173
174 static int input_handle_abs_event(struct input_dev *dev,
175 struct input_handler *src_handler,
176 unsigned int code, int *pval)
177 {
178 bool is_mt_event;
179 int *pold;
180
181 if (code == ABS_MT_SLOT) {
182 /*
183 * "Stage" the event; we'll flush it later, when we
184 * get actual touch data.
185 */
186 if (*pval >= 0 && *pval < dev->mtsize)
187 dev->slot = *pval;
188
189 return INPUT_IGNORE_EVENT;
190 }
191
192 is_mt_event = code >= ABS_MT_FIRST && code <= ABS_MT_LAST;
193
194 if (!is_mt_event) {
195 pold = &dev->absinfo[code].value;
196 } else if (dev->mt) {
197 struct input_mt_slot *mtslot = &dev->mt[dev->slot];
198 pold = &mtslot->abs[code - ABS_MT_FIRST];
199 } else {
200 /*
201 * Bypass filtering for multi-touch events when
202 * not employing slots.
203 */
204 pold = NULL;
205 }
206
207 if (pold) {
208 *pval = input_defuzz_abs_event(*pval, *pold,
209 dev->absinfo[code].fuzz);
210 if (*pold == *pval)
211 return INPUT_IGNORE_EVENT;
212
213 *pold = *pval;
214 }
215
216 /* Flush pending "slot" event */
217 if (is_mt_event && dev->slot != input_abs_get_val(dev, ABS_MT_SLOT)) {
218 input_abs_set_val(dev, ABS_MT_SLOT, dev->slot);
219 input_pass_event(dev, src_handler,
220 EV_ABS, ABS_MT_SLOT, dev->slot);
221 }
222
223 return INPUT_PASS_TO_HANDLERS;
224 }
225
226 static void input_handle_event(struct input_dev *dev,
227 struct input_handler *src_handler,
228 unsigned int type, unsigned int code, int value)
229 {
230 int disposition = INPUT_IGNORE_EVENT;
231
232 switch (type) {
233
234 case EV_SYN:
235 switch (code) {
236 case SYN_CONFIG:
237 disposition = INPUT_PASS_TO_ALL;
238 break;
239
240 case SYN_REPORT:
241 if (!dev->sync) {
242 dev->sync = true;
243 disposition = INPUT_PASS_TO_HANDLERS;
244 }
245 break;
246 case SYN_MT_REPORT:
247 dev->sync = false;
248 disposition = INPUT_PASS_TO_HANDLERS;
249 break;
250 }
251 break;
252
253 case EV_KEY:
254 if (is_event_supported(code, dev->keybit, KEY_MAX) &&
255 !!test_bit(code, dev->key) != value) {
256
257 if (value != 2) {
258 __change_bit(code, dev->key);
259 if (value)
260 input_start_autorepeat(dev, code);
261 else
262 input_stop_autorepeat(dev);
263 }
264
265 disposition = INPUT_PASS_TO_HANDLERS;
266 }
267 break;
268
269 case EV_SW:
270 if (is_event_supported(code, dev->swbit, SW_MAX) &&
271 !!test_bit(code, dev->sw) != value) {
272
273 __change_bit(code, dev->sw);
274 disposition = INPUT_PASS_TO_HANDLERS;
275 }
276 break;
277
278 case EV_ABS:
279 if (is_event_supported(code, dev->absbit, ABS_MAX))
280 disposition = input_handle_abs_event(dev, src_handler,
281 code, &value);
282
283 break;
284
285 case EV_REL:
286 if (is_event_supported(code, dev->relbit, REL_MAX) && value)
287 disposition = INPUT_PASS_TO_HANDLERS;
288
289 break;
290
291 case EV_MSC:
292 if (is_event_supported(code, dev->mscbit, MSC_MAX))
293 disposition = INPUT_PASS_TO_ALL;
294
295 break;
296
297 case EV_LED:
298 if (is_event_supported(code, dev->ledbit, LED_MAX) &&
299 !!test_bit(code, dev->led) != value) {
300
301 __change_bit(code, dev->led);
302 disposition = INPUT_PASS_TO_ALL;
303 }
304 break;
305
306 case EV_SND:
307 if (is_event_supported(code, dev->sndbit, SND_MAX)) {
308
309 if (!!test_bit(code, dev->snd) != !!value)
310 __change_bit(code, dev->snd);
311 disposition = INPUT_PASS_TO_ALL;
312 }
313 break;
314
315 case EV_REP:
316 if (code <= REP_MAX && value >= 0 && dev->rep[code] != value) {
317 dev->rep[code] = value;
318 disposition = INPUT_PASS_TO_ALL;
319 }
320 break;
321
322 case EV_FF:
323 if (value >= 0)
324 disposition = INPUT_PASS_TO_ALL;
325 break;
326
327 case EV_PWR:
328 disposition = INPUT_PASS_TO_ALL;
329 break;
330 }
331
332 if (disposition != INPUT_IGNORE_EVENT && type != EV_SYN)
333 dev->sync = false;
334
335 if ((disposition & INPUT_PASS_TO_DEVICE) && dev->event)
336 dev->event(dev, type, code, value);
337
338 if (disposition & INPUT_PASS_TO_HANDLERS)
339 input_pass_event(dev, src_handler, type, code, value);
340 }
341
342 /**
343 * input_event() - report new input event
344 * @dev: device that generated the event
345 * @type: type of the event
346 * @code: event code
347 * @value: value of the event
348 *
349 * This function should be used by drivers implementing various input
350 * devices to report input events. See also input_inject_event().
351 *
352 * NOTE: input_event() may be safely used right after input device was
353 * allocated with input_allocate_device(), even before it is registered
354 * with input_register_device(), but the event will not reach any of the
355 * input handlers. Such early invocation of input_event() may be used
356 * to 'seed' initial state of a switch or initial position of absolute
357 * axis, etc.
358 */
359 void input_event(struct input_dev *dev,
360 unsigned int type, unsigned int code, int value)
361 {
362 unsigned long flags;
363
364 if (is_event_supported(type, dev->evbit, EV_MAX)) {
365
366 spin_lock_irqsave(&dev->event_lock, flags);
367 add_input_randomness(type, code, value);
368 input_handle_event(dev, NULL, type, code, value);
369 spin_unlock_irqrestore(&dev->event_lock, flags);
370 }
371 }
372 EXPORT_SYMBOL(input_event);
373
374 /**
375 * input_inject_event() - send input event from input handler
376 * @handle: input handle to send event through
377 * @type: type of the event
378 * @code: event code
379 * @value: value of the event
380 *
381 * Similar to input_event() but will ignore event if device is
382 * "grabbed" and handle injecting event is not the one that owns
383 * the device.
384 */
385 void input_inject_event(struct input_handle *handle,
386 unsigned int type, unsigned int code, int value)
387 {
388 struct input_dev *dev = handle->dev;
389 struct input_handle *grab;
390 unsigned long flags;
391
392 if (is_event_supported(type, dev->evbit, EV_MAX)) {
393 spin_lock_irqsave(&dev->event_lock, flags);
394
395 rcu_read_lock();
396 grab = rcu_dereference(dev->grab);
397 if (!grab || grab == handle)
398 input_handle_event(dev, handle->handler,
399 type, code, value);
400 rcu_read_unlock();
401
402 spin_unlock_irqrestore(&dev->event_lock, flags);
403 }
404 }
405 EXPORT_SYMBOL(input_inject_event);
406
407 /**
408 * input_alloc_absinfo - allocates array of input_absinfo structs
409 * @dev: the input device emitting absolute events
410 *
411 * If the absinfo struct the caller asked for is already allocated, this
412 * functions will not do anything.
413 */
414 void input_alloc_absinfo(struct input_dev *dev)
415 {
416 if (!dev->absinfo)
417 dev->absinfo = kcalloc(ABS_CNT, sizeof(struct input_absinfo),
418 GFP_KERNEL);
419
420 WARN(!dev->absinfo, "%s(): kcalloc() failed?\n", __func__);
421 }
422 EXPORT_SYMBOL(input_alloc_absinfo);
423
424 void input_set_abs_params(struct input_dev *dev, unsigned int axis,
425 int min, int max, int fuzz, int flat)
426 {
427 struct input_absinfo *absinfo;
428
429 input_alloc_absinfo(dev);
430 if (!dev->absinfo)
431 return;
432
433 absinfo = &dev->absinfo[axis];
434 absinfo->minimum = min;
435 absinfo->maximum = max;
436 absinfo->fuzz = fuzz;
437 absinfo->flat = flat;
438
439 dev->absbit[BIT_WORD(axis)] |= BIT_MASK(axis);
440 }
441 EXPORT_SYMBOL(input_set_abs_params);
442
443
444 /**
445 * input_grab_device - grabs device for exclusive use
446 * @handle: input handle that wants to own the device
447 *
448 * When a device is grabbed by an input handle all events generated by
449 * the device are delivered only to this handle. Also events injected
450 * by other input handles are ignored while device is grabbed.
451 */
452 int input_grab_device(struct input_handle *handle)
453 {
454 struct input_dev *dev = handle->dev;
455 int retval;
456
457 retval = mutex_lock_interruptible(&dev->mutex);
458 if (retval)
459 return retval;
460
461 if (dev->grab) {
462 retval = -EBUSY;
463 goto out;
464 }
465
466 rcu_assign_pointer(dev->grab, handle);
467 synchronize_rcu();
468
469 out:
470 mutex_unlock(&dev->mutex);
471 return retval;
472 }
473 EXPORT_SYMBOL(input_grab_device);
474
475 static void __input_release_device(struct input_handle *handle)
476 {
477 struct input_dev *dev = handle->dev;
478
479 if (dev->grab == handle) {
480 rcu_assign_pointer(dev->grab, NULL);
481 /* Make sure input_pass_event() notices that grab is gone */
482 synchronize_rcu();
483
484 list_for_each_entry(handle, &dev->h_list, d_node)
485 if (handle->open && handle->handler->start)
486 handle->handler->start(handle);
487 }
488 }
489
490 /**
491 * input_release_device - release previously grabbed device
492 * @handle: input handle that owns the device
493 *
494 * Releases previously grabbed device so that other input handles can
495 * start receiving input events. Upon release all handlers attached
496 * to the device have their start() method called so they have a change
497 * to synchronize device state with the rest of the system.
498 */
499 void input_release_device(struct input_handle *handle)
500 {
501 struct input_dev *dev = handle->dev;
502
503 mutex_lock(&dev->mutex);
504 __input_release_device(handle);
505 mutex_unlock(&dev->mutex);
506 }
507 EXPORT_SYMBOL(input_release_device);
508
509 /**
510 * input_open_device - open input device
511 * @handle: handle through which device is being accessed
512 *
513 * This function should be called by input handlers when they
514 * want to start receive events from given input device.
515 */
516 int input_open_device(struct input_handle *handle)
517 {
518 struct input_dev *dev = handle->dev;
519 int retval;
520
521 retval = mutex_lock_interruptible(&dev->mutex);
522 if (retval)
523 return retval;
524
525 if (dev->going_away) {
526 retval = -ENODEV;
527 goto out;
528 }
529
530 handle->open++;
531
532 if (!dev->users++ && dev->open)
533 retval = dev->open(dev);
534
535 if (retval) {
536 dev->users--;
537 if (!--handle->open) {
538 /*
539 * Make sure we are not delivering any more events
540 * through this handle
541 */
542 synchronize_rcu();
543 }
544 }
545
546 out:
547 mutex_unlock(&dev->mutex);
548 return retval;
549 }
550 EXPORT_SYMBOL(input_open_device);
551
552 int input_flush_device(struct input_handle *handle, struct file *file)
553 {
554 struct input_dev *dev = handle->dev;
555 int retval;
556
557 retval = mutex_lock_interruptible(&dev->mutex);
558 if (retval)
559 return retval;
560
561 if (dev->flush)
562 retval = dev->flush(dev, file);
563
564 mutex_unlock(&dev->mutex);
565 return retval;
566 }
567 EXPORT_SYMBOL(input_flush_device);
568
569 /**
570 * input_close_device - close input device
571 * @handle: handle through which device is being accessed
572 *
573 * This function should be called by input handlers when they
574 * want to stop receive events from given input device.
575 */
576 void input_close_device(struct input_handle *handle)
577 {
578 struct input_dev *dev = handle->dev;
579
580 mutex_lock(&dev->mutex);
581
582 __input_release_device(handle);
583
584 if (!--dev->users && dev->close)
585 dev->close(dev);
586
587 if (!--handle->open) {
588 /*
589 * synchronize_rcu() makes sure that input_pass_event()
590 * completed and that no more input events are delivered
591 * through this handle
592 */
593 synchronize_rcu();
594 }
595
596 mutex_unlock(&dev->mutex);
597 }
598 EXPORT_SYMBOL(input_close_device);
599
600 /*
601 * Simulate keyup events for all keys that are marked as pressed.
602 * The function must be called with dev->event_lock held.
603 */
604 static void input_dev_release_keys(struct input_dev *dev)
605 {
606 int code;
607
608 if (is_event_supported(EV_KEY, dev->evbit, EV_MAX)) {
609 for (code = 0; code <= KEY_MAX; code++) {
610 if (is_event_supported(code, dev->keybit, KEY_MAX) &&
611 __test_and_clear_bit(code, dev->key)) {
612 input_pass_event(dev, NULL, EV_KEY, code, 0);
613 }
614 }
615 input_pass_event(dev, NULL, EV_SYN, SYN_REPORT, 1);
616 }
617 }
618
619 /*
620 * Prepare device for unregistering
621 */
622 static void input_disconnect_device(struct input_dev *dev)
623 {
624 struct input_handle *handle;
625
626 /*
627 * Mark device as going away. Note that we take dev->mutex here
628 * not to protect access to dev->going_away but rather to ensure
629 * that there are no threads in the middle of input_open_device()
630 */
631 mutex_lock(&dev->mutex);
632 dev->going_away = true;
633 mutex_unlock(&dev->mutex);
634
635 spin_lock_irq(&dev->event_lock);
636
637 /*
638 * Simulate keyup events for all pressed keys so that handlers
639 * are not left with "stuck" keys. The driver may continue
640 * generate events even after we done here but they will not
641 * reach any handlers.
642 */
643 input_dev_release_keys(dev);
644
645 list_for_each_entry(handle, &dev->h_list, d_node)
646 handle->open = 0;
647
648 spin_unlock_irq(&dev->event_lock);
649 }
650
651 /**
652 * input_scancode_to_scalar() - converts scancode in &struct input_keymap_entry
653 * @ke: keymap entry containing scancode to be converted.
654 * @scancode: pointer to the location where converted scancode should
655 * be stored.
656 *
657 * This function is used to convert scancode stored in &struct keymap_entry
658 * into scalar form understood by legacy keymap handling methods. These
659 * methods expect scancodes to be represented as 'unsigned int'.
660 */
661 int input_scancode_to_scalar(const struct input_keymap_entry *ke,
662 unsigned int *scancode)
663 {
664 switch (ke->len) {
665 case 1:
666 *scancode = *((u8 *)ke->scancode);
667 break;
668
669 case 2:
670 *scancode = *((u16 *)ke->scancode);
671 break;
672
673 case 4:
674 *scancode = *((u32 *)ke->scancode);
675 break;
676
677 default:
678 return -EINVAL;
679 }
680
681 return 0;
682 }
683 EXPORT_SYMBOL(input_scancode_to_scalar);
684
685 /*
686 * Those routines handle the default case where no [gs]etkeycode() is
687 * defined. In this case, an array indexed by the scancode is used.
688 */
689
690 static unsigned int input_fetch_keycode(struct input_dev *dev,
691 unsigned int index)
692 {
693 switch (dev->keycodesize) {
694 case 1:
695 return ((u8 *)dev->keycode)[index];
696
697 case 2:
698 return ((u16 *)dev->keycode)[index];
699
700 default:
701 return ((u32 *)dev->keycode)[index];
702 }
703 }
704
705 static int input_default_getkeycode(struct input_dev *dev,
706 struct input_keymap_entry *ke)
707 {
708 unsigned int index;
709 int error;
710
711 if (!dev->keycodesize)
712 return -EINVAL;
713
714 if (ke->flags & INPUT_KEYMAP_BY_INDEX)
715 index = ke->index;
716 else {
717 error = input_scancode_to_scalar(ke, &index);
718 if (error)
719 return error;
720 }
721
722 if (index >= dev->keycodemax)
723 return -EINVAL;
724
725 ke->keycode = input_fetch_keycode(dev, index);
726 ke->index = index;
727 ke->len = sizeof(index);
728 memcpy(ke->scancode, &index, sizeof(index));
729
730 return 0;
731 }
732
733 static int input_default_setkeycode(struct input_dev *dev,
734 const struct input_keymap_entry *ke,
735 unsigned int *old_keycode)
736 {
737 unsigned int index;
738 int error;
739 int i;
740
741 if (!dev->keycodesize)
742 return -EINVAL;
743
744 if (ke->flags & INPUT_KEYMAP_BY_INDEX) {
745 index = ke->index;
746 } else {
747 error = input_scancode_to_scalar(ke, &index);
748 if (error)
749 return error;
750 }
751
752 if (index >= dev->keycodemax)
753 return -EINVAL;
754
755 if (dev->keycodesize < sizeof(ke->keycode) &&
756 (ke->keycode >> (dev->keycodesize * 8)))
757 return -EINVAL;
758
759 switch (dev->keycodesize) {
760 case 1: {
761 u8 *k = (u8 *)dev->keycode;
762 *old_keycode = k[index];
763 k[index] = ke->keycode;
764 break;
765 }
766 case 2: {
767 u16 *k = (u16 *)dev->keycode;
768 *old_keycode = k[index];
769 k[index] = ke->keycode;
770 break;
771 }
772 default: {
773 u32 *k = (u32 *)dev->keycode;
774 *old_keycode = k[index];
775 k[index] = ke->keycode;
776 break;
777 }
778 }
779
780 __clear_bit(*old_keycode, dev->keybit);
781 __set_bit(ke->keycode, dev->keybit);
782
783 for (i = 0; i < dev->keycodemax; i++) {
784 if (input_fetch_keycode(dev, i) == *old_keycode) {
785 __set_bit(*old_keycode, dev->keybit);
786 break; /* Setting the bit twice is useless, so break */
787 }
788 }
789
790 return 0;
791 }
792
793 /**
794 * input_get_keycode - retrieve keycode currently mapped to a given scancode
795 * @dev: input device which keymap is being queried
796 * @ke: keymap entry
797 *
798 * This function should be called by anyone interested in retrieving current
799 * keymap. Presently evdev handlers use it.
800 */
801 int input_get_keycode(struct input_dev *dev, struct input_keymap_entry *ke)
802 {
803 unsigned long flags;
804 int retval;
805
806 spin_lock_irqsave(&dev->event_lock, flags);
807
808 if (dev->getkeycode) {
809 /*
810 * Support for legacy drivers, that don't implement the new
811 * ioctls
812 */
813 u32 scancode = ke->index;
814
815 memcpy(ke->scancode, &scancode, sizeof(scancode));
816 ke->len = sizeof(scancode);
817 retval = dev->getkeycode(dev, scancode, &ke->keycode);
818 } else {
819 retval = dev->getkeycode_new(dev, ke);
820 }
821
822 spin_unlock_irqrestore(&dev->event_lock, flags);
823 return retval;
824 }
825 EXPORT_SYMBOL(input_get_keycode);
826
827 /**
828 * input_set_keycode - attribute a keycode to a given scancode
829 * @dev: input device which keymap is being updated
830 * @ke: new keymap entry
831 *
832 * This function should be called by anyone needing to update current
833 * keymap. Presently keyboard and evdev handlers use it.
834 */
835 int input_set_keycode(struct input_dev *dev,
836 const struct input_keymap_entry *ke)
837 {
838 unsigned long flags;
839 unsigned int old_keycode;
840 int retval;
841
842 if (ke->keycode > KEY_MAX)
843 return -EINVAL;
844
845 spin_lock_irqsave(&dev->event_lock, flags);
846
847 if (dev->setkeycode) {
848 /*
849 * Support for legacy drivers, that don't implement the new
850 * ioctls
851 */
852 unsigned int scancode;
853
854 retval = input_scancode_to_scalar(ke, &scancode);
855 if (retval)
856 goto out;
857
858 /*
859 * We need to know the old scancode, in order to generate a
860 * keyup effect, if the set operation happens successfully
861 */
862 if (!dev->getkeycode) {
863 retval = -EINVAL;
864 goto out;
865 }
866
867 retval = dev->getkeycode(dev, scancode, &old_keycode);
868 if (retval)
869 goto out;
870
871 retval = dev->setkeycode(dev, scancode, ke->keycode);
872 } else {
873 retval = dev->setkeycode_new(dev, ke, &old_keycode);
874 }
875
876 if (retval)
877 goto out;
878
879 /* Make sure KEY_RESERVED did not get enabled. */
880 __clear_bit(KEY_RESERVED, dev->keybit);
881
882 /*
883 * Simulate keyup event if keycode is not present
884 * in the keymap anymore
885 */
886 if (test_bit(EV_KEY, dev->evbit) &&
887 !is_event_supported(old_keycode, dev->keybit, KEY_MAX) &&
888 __test_and_clear_bit(old_keycode, dev->key)) {
889
890 input_pass_event(dev, NULL, EV_KEY, old_keycode, 0);
891 if (dev->sync)
892 input_pass_event(dev, NULL, EV_SYN, SYN_REPORT, 1);
893 }
894
895 out:
896 spin_unlock_irqrestore(&dev->event_lock, flags);
897
898 return retval;
899 }
900 EXPORT_SYMBOL(input_set_keycode);
901
902 #define MATCH_BIT(bit, max) \
903 for (i = 0; i < BITS_TO_LONGS(max); i++) \
904 if ((id->bit[i] & dev->bit[i]) != id->bit[i]) \
905 break; \
906 if (i != BITS_TO_LONGS(max)) \
907 continue;
908
909 static const struct input_device_id *input_match_device(struct input_handler *handler,
910 struct input_dev *dev)
911 {
912 const struct input_device_id *id;
913 int i;
914
915 for (id = handler->id_table; id->flags || id->driver_info; id++) {
916
917 if (id->flags & INPUT_DEVICE_ID_MATCH_BUS)
918 if (id->bustype != dev->id.bustype)
919 continue;
920
921 if (id->flags & INPUT_DEVICE_ID_MATCH_VENDOR)
922 if (id->vendor != dev->id.vendor)
923 continue;
924
925 if (id->flags & INPUT_DEVICE_ID_MATCH_PRODUCT)
926 if (id->product != dev->id.product)
927 continue;
928
929 if (id->flags & INPUT_DEVICE_ID_MATCH_VERSION)
930 if (id->version != dev->id.version)
931 continue;
932
933 MATCH_BIT(evbit, EV_MAX);
934 MATCH_BIT(keybit, KEY_MAX);
935 MATCH_BIT(relbit, REL_MAX);
936 MATCH_BIT(absbit, ABS_MAX);
937 MATCH_BIT(mscbit, MSC_MAX);
938 MATCH_BIT(ledbit, LED_MAX);
939 MATCH_BIT(sndbit, SND_MAX);
940 MATCH_BIT(ffbit, FF_MAX);
941 MATCH_BIT(swbit, SW_MAX);
942
943 if (!handler->match || handler->match(handler, dev))
944 return id;
945 }
946
947 return NULL;
948 }
949
950 static int input_attach_handler(struct input_dev *dev, struct input_handler *handler)
951 {
952 const struct input_device_id *id;
953 int error;
954
955 id = input_match_device(handler, dev);
956 if (!id)
957 return -ENODEV;
958
959 error = handler->connect(handler, dev, id);
960 if (error && error != -ENODEV)
961 printk(KERN_ERR
962 "input: failed to attach handler %s to device %s, "
963 "error: %d\n",
964 handler->name, kobject_name(&dev->dev.kobj), error);
965
966 return error;
967 }
968
969 #ifdef CONFIG_COMPAT
970
971 static int input_bits_to_string(char *buf, int buf_size,
972 unsigned long bits, bool skip_empty)
973 {
974 int len = 0;
975
976 if (INPUT_COMPAT_TEST) {
977 u32 dword = bits >> 32;
978 if (dword || !skip_empty)
979 len += snprintf(buf, buf_size, "%x ", dword);
980
981 dword = bits & 0xffffffffUL;
982 if (dword || !skip_empty || len)
983 len += snprintf(buf + len, max(buf_size - len, 0),
984 "%x", dword);
985 } else {
986 if (bits || !skip_empty)
987 len += snprintf(buf, buf_size, "%lx", bits);
988 }
989
990 return len;
991 }
992
993 #else /* !CONFIG_COMPAT */
994
995 static int input_bits_to_string(char *buf, int buf_size,
996 unsigned long bits, bool skip_empty)
997 {
998 return bits || !skip_empty ?
999 snprintf(buf, buf_size, "%lx", bits) : 0;
1000 }
1001
1002 #endif
1003
1004 #ifdef CONFIG_PROC_FS
1005
1006 static struct proc_dir_entry *proc_bus_input_dir;
1007 static DECLARE_WAIT_QUEUE_HEAD(input_devices_poll_wait);
1008 static int input_devices_state;
1009
1010 static inline void input_wakeup_procfs_readers(void)
1011 {
1012 input_devices_state++;
1013 wake_up(&input_devices_poll_wait);
1014 }
1015
1016 static unsigned int input_proc_devices_poll(struct file *file, poll_table *wait)
1017 {
1018 poll_wait(file, &input_devices_poll_wait, wait);
1019 if (file->f_version != input_devices_state) {
1020 file->f_version = input_devices_state;
1021 return POLLIN | POLLRDNORM;
1022 }
1023
1024 return 0;
1025 }
1026
1027 union input_seq_state {
1028 struct {
1029 unsigned short pos;
1030 bool mutex_acquired;
1031 };
1032 void *p;
1033 };
1034
1035 static void *input_devices_seq_start(struct seq_file *seq, loff_t *pos)
1036 {
1037 union input_seq_state *state = (union input_seq_state *)&seq->private;
1038 int error;
1039
1040 /* We need to fit into seq->private pointer */
1041 BUILD_BUG_ON(sizeof(union input_seq_state) != sizeof(seq->private));
1042
1043 error = mutex_lock_interruptible(&input_mutex);
1044 if (error) {
1045 state->mutex_acquired = false;
1046 return ERR_PTR(error);
1047 }
1048
1049 state->mutex_acquired = true;
1050
1051 return seq_list_start(&input_dev_list, *pos);
1052 }
1053
1054 static void *input_devices_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1055 {
1056 return seq_list_next(v, &input_dev_list, pos);
1057 }
1058
1059 static void input_seq_stop(struct seq_file *seq, void *v)
1060 {
1061 union input_seq_state *state = (union input_seq_state *)&seq->private;
1062
1063 if (state->mutex_acquired)
1064 mutex_unlock(&input_mutex);
1065 }
1066
1067 static void input_seq_print_bitmap(struct seq_file *seq, const char *name,
1068 unsigned long *bitmap, int max)
1069 {
1070 int i;
1071 bool skip_empty = true;
1072 char buf[18];
1073
1074 seq_printf(seq, "B: %s=", name);
1075
1076 for (i = BITS_TO_LONGS(max) - 1; i >= 0; i--) {
1077 if (input_bits_to_string(buf, sizeof(buf),
1078 bitmap[i], skip_empty)) {
1079 skip_empty = false;
1080 seq_printf(seq, "%s%s", buf, i > 0 ? " " : "");
1081 }
1082 }
1083
1084 /*
1085 * If no output was produced print a single 0.
1086 */
1087 if (skip_empty)
1088 seq_puts(seq, "0");
1089
1090 seq_putc(seq, '\n');
1091 }
1092
1093 static int input_devices_seq_show(struct seq_file *seq, void *v)
1094 {
1095 struct input_dev *dev = container_of(v, struct input_dev, node);
1096 const char *path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);
1097 struct input_handle *handle;
1098
1099 seq_printf(seq, "I: Bus=%04x Vendor=%04x Product=%04x Version=%04x\n",
1100 dev->id.bustype, dev->id.vendor, dev->id.product, dev->id.version);
1101
1102 seq_printf(seq, "N: Name=\"%s\"\n", dev->name ? dev->name : "");
1103 seq_printf(seq, "P: Phys=%s\n", dev->phys ? dev->phys : "");
1104 seq_printf(seq, "S: Sysfs=%s\n", path ? path : "");
1105 seq_printf(seq, "U: Uniq=%s\n", dev->uniq ? dev->uniq : "");
1106 seq_printf(seq, "H: Handlers=");
1107
1108 list_for_each_entry(handle, &dev->h_list, d_node)
1109 seq_printf(seq, "%s ", handle->name);
1110 seq_putc(seq, '\n');
1111
1112 input_seq_print_bitmap(seq, "EV", dev->evbit, EV_MAX);
1113 if (test_bit(EV_KEY, dev->evbit))
1114 input_seq_print_bitmap(seq, "KEY", dev->keybit, KEY_MAX);
1115 if (test_bit(EV_REL, dev->evbit))
1116 input_seq_print_bitmap(seq, "REL", dev->relbit, REL_MAX);
1117 if (test_bit(EV_ABS, dev->evbit))
1118 input_seq_print_bitmap(seq, "ABS", dev->absbit, ABS_MAX);
1119 if (test_bit(EV_MSC, dev->evbit))
1120 input_seq_print_bitmap(seq, "MSC", dev->mscbit, MSC_MAX);
1121 if (test_bit(EV_LED, dev->evbit))
1122 input_seq_print_bitmap(seq, "LED", dev->ledbit, LED_MAX);
1123 if (test_bit(EV_SND, dev->evbit))
1124 input_seq_print_bitmap(seq, "SND", dev->sndbit, SND_MAX);
1125 if (test_bit(EV_FF, dev->evbit))
1126 input_seq_print_bitmap(seq, "FF", dev->ffbit, FF_MAX);
1127 if (test_bit(EV_SW, dev->evbit))
1128 input_seq_print_bitmap(seq, "SW", dev->swbit, SW_MAX);
1129
1130 seq_putc(seq, '\n');
1131
1132 kfree(path);
1133 return 0;
1134 }
1135
1136 static const struct seq_operations input_devices_seq_ops = {
1137 .start = input_devices_seq_start,
1138 .next = input_devices_seq_next,
1139 .stop = input_seq_stop,
1140 .show = input_devices_seq_show,
1141 };
1142
1143 static int input_proc_devices_open(struct inode *inode, struct file *file)
1144 {
1145 return seq_open(file, &input_devices_seq_ops);
1146 }
1147
1148 static const struct file_operations input_devices_fileops = {
1149 .owner = THIS_MODULE,
1150 .open = input_proc_devices_open,
1151 .poll = input_proc_devices_poll,
1152 .read = seq_read,
1153 .llseek = seq_lseek,
1154 .release = seq_release,
1155 };
1156
1157 static void *input_handlers_seq_start(struct seq_file *seq, loff_t *pos)
1158 {
1159 union input_seq_state *state = (union input_seq_state *)&seq->private;
1160 int error;
1161
1162 /* We need to fit into seq->private pointer */
1163 BUILD_BUG_ON(sizeof(union input_seq_state) != sizeof(seq->private));
1164
1165 error = mutex_lock_interruptible(&input_mutex);
1166 if (error) {
1167 state->mutex_acquired = false;
1168 return ERR_PTR(error);
1169 }
1170
1171 state->mutex_acquired = true;
1172 state->pos = *pos;
1173
1174 return seq_list_start(&input_handler_list, *pos);
1175 }
1176
1177 static void *input_handlers_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1178 {
1179 union input_seq_state *state = (union input_seq_state *)&seq->private;
1180
1181 state->pos = *pos + 1;
1182 return seq_list_next(v, &input_handler_list, pos);
1183 }
1184
1185 static int input_handlers_seq_show(struct seq_file *seq, void *v)
1186 {
1187 struct input_handler *handler = container_of(v, struct input_handler, node);
1188 union input_seq_state *state = (union input_seq_state *)&seq->private;
1189
1190 seq_printf(seq, "N: Number=%u Name=%s", state->pos, handler->name);
1191 if (handler->filter)
1192 seq_puts(seq, " (filter)");
1193 if (handler->fops)
1194 seq_printf(seq, " Minor=%d", handler->minor);
1195 seq_putc(seq, '\n');
1196
1197 return 0;
1198 }
1199
1200 static const struct seq_operations input_handlers_seq_ops = {
1201 .start = input_handlers_seq_start,
1202 .next = input_handlers_seq_next,
1203 .stop = input_seq_stop,
1204 .show = input_handlers_seq_show,
1205 };
1206
1207 static int input_proc_handlers_open(struct inode *inode, struct file *file)
1208 {
1209 return seq_open(file, &input_handlers_seq_ops);
1210 }
1211
1212 static const struct file_operations input_handlers_fileops = {
1213 .owner = THIS_MODULE,
1214 .open = input_proc_handlers_open,
1215 .read = seq_read,
1216 .llseek = seq_lseek,
1217 .release = seq_release,
1218 };
1219
1220 static int __init input_proc_init(void)
1221 {
1222 struct proc_dir_entry *entry;
1223
1224 proc_bus_input_dir = proc_mkdir("bus/input", NULL);
1225 if (!proc_bus_input_dir)
1226 return -ENOMEM;
1227
1228 entry = proc_create("devices", 0, proc_bus_input_dir,
1229 &input_devices_fileops);
1230 if (!entry)
1231 goto fail1;
1232
1233 entry = proc_create("handlers", 0, proc_bus_input_dir,
1234 &input_handlers_fileops);
1235 if (!entry)
1236 goto fail2;
1237
1238 return 0;
1239
1240 fail2: remove_proc_entry("devices", proc_bus_input_dir);
1241 fail1: remove_proc_entry("bus/input", NULL);
1242 return -ENOMEM;
1243 }
1244
1245 static void input_proc_exit(void)
1246 {
1247 remove_proc_entry("devices", proc_bus_input_dir);
1248 remove_proc_entry("handlers", proc_bus_input_dir);
1249 remove_proc_entry("bus/input", NULL);
1250 }
1251
1252 #else /* !CONFIG_PROC_FS */
1253 static inline void input_wakeup_procfs_readers(void) { }
1254 static inline int input_proc_init(void) { return 0; }
1255 static inline void input_proc_exit(void) { }
1256 #endif
1257
1258 #define INPUT_DEV_STRING_ATTR_SHOW(name) \
1259 static ssize_t input_dev_show_##name(struct device *dev, \
1260 struct device_attribute *attr, \
1261 char *buf) \
1262 { \
1263 struct input_dev *input_dev = to_input_dev(dev); \
1264 \
1265 return scnprintf(buf, PAGE_SIZE, "%s\n", \
1266 input_dev->name ? input_dev->name : ""); \
1267 } \
1268 static DEVICE_ATTR(name, S_IRUGO, input_dev_show_##name, NULL)
1269
1270 INPUT_DEV_STRING_ATTR_SHOW(name);
1271 INPUT_DEV_STRING_ATTR_SHOW(phys);
1272 INPUT_DEV_STRING_ATTR_SHOW(uniq);
1273
1274 static int input_print_modalias_bits(char *buf, int size,
1275 char name, unsigned long *bm,
1276 unsigned int min_bit, unsigned int max_bit)
1277 {
1278 int len = 0, i;
1279
1280 len += snprintf(buf, max(size, 0), "%c", name);
1281 for (i = min_bit; i < max_bit; i++)
1282 if (bm[BIT_WORD(i)] & BIT_MASK(i))
1283 len += snprintf(buf + len, max(size - len, 0), "%X,", i);
1284 return len;
1285 }
1286
1287 static int input_print_modalias(char *buf, int size, struct input_dev *id,
1288 int add_cr)
1289 {
1290 int len;
1291
1292 len = snprintf(buf, max(size, 0),
1293 "input:b%04Xv%04Xp%04Xe%04X-",
1294 id->id.bustype, id->id.vendor,
1295 id->id.product, id->id.version);
1296
1297 len += input_print_modalias_bits(buf + len, size - len,
1298 'e', id->evbit, 0, EV_MAX);
1299 len += input_print_modalias_bits(buf + len, size - len,
1300 'k', id->keybit, KEY_MIN_INTERESTING, KEY_MAX);
1301 len += input_print_modalias_bits(buf + len, size - len,
1302 'r', id->relbit, 0, REL_MAX);
1303 len += input_print_modalias_bits(buf + len, size - len,
1304 'a', id->absbit, 0, ABS_MAX);
1305 len += input_print_modalias_bits(buf + len, size - len,
1306 'm', id->mscbit, 0, MSC_MAX);
1307 len += input_print_modalias_bits(buf + len, size - len,
1308 'l', id->ledbit, 0, LED_MAX);
1309 len += input_print_modalias_bits(buf + len, size - len,
1310 's', id->sndbit, 0, SND_MAX);
1311 len += input_print_modalias_bits(buf + len, size - len,
1312 'f', id->ffbit, 0, FF_MAX);
1313 len += input_print_modalias_bits(buf + len, size - len,
1314 'w', id->swbit, 0, SW_MAX);
1315
1316 if (add_cr)
1317 len += snprintf(buf + len, max(size - len, 0), "\n");
1318
1319 return len;
1320 }
1321
1322 static ssize_t input_dev_show_modalias(struct device *dev,
1323 struct device_attribute *attr,
1324 char *buf)
1325 {
1326 struct input_dev *id = to_input_dev(dev);
1327 ssize_t len;
1328
1329 len = input_print_modalias(buf, PAGE_SIZE, id, 1);
1330
1331 return min_t(int, len, PAGE_SIZE);
1332 }
1333 static DEVICE_ATTR(modalias, S_IRUGO, input_dev_show_modalias, NULL);
1334
1335 static struct attribute *input_dev_attrs[] = {
1336 &dev_attr_name.attr,
1337 &dev_attr_phys.attr,
1338 &dev_attr_uniq.attr,
1339 &dev_attr_modalias.attr,
1340 NULL
1341 };
1342
1343 static struct attribute_group input_dev_attr_group = {
1344 .attrs = input_dev_attrs,
1345 };
1346
1347 #define INPUT_DEV_ID_ATTR(name) \
1348 static ssize_t input_dev_show_id_##name(struct device *dev, \
1349 struct device_attribute *attr, \
1350 char *buf) \
1351 { \
1352 struct input_dev *input_dev = to_input_dev(dev); \
1353 return scnprintf(buf, PAGE_SIZE, "%04x\n", input_dev->id.name); \
1354 } \
1355 static DEVICE_ATTR(name, S_IRUGO, input_dev_show_id_##name, NULL)
1356
1357 INPUT_DEV_ID_ATTR(bustype);
1358 INPUT_DEV_ID_ATTR(vendor);
1359 INPUT_DEV_ID_ATTR(product);
1360 INPUT_DEV_ID_ATTR(version);
1361
1362 static struct attribute *input_dev_id_attrs[] = {
1363 &dev_attr_bustype.attr,
1364 &dev_attr_vendor.attr,
1365 &dev_attr_product.attr,
1366 &dev_attr_version.attr,
1367 NULL
1368 };
1369
1370 static struct attribute_group input_dev_id_attr_group = {
1371 .name = "id",
1372 .attrs = input_dev_id_attrs,
1373 };
1374
1375 static int input_print_bitmap(char *buf, int buf_size, unsigned long *bitmap,
1376 int max, int add_cr)
1377 {
1378 int i;
1379 int len = 0;
1380 bool skip_empty = true;
1381
1382 for (i = BITS_TO_LONGS(max) - 1; i >= 0; i--) {
1383 len += input_bits_to_string(buf + len, max(buf_size - len, 0),
1384 bitmap[i], skip_empty);
1385 if (len) {
1386 skip_empty = false;
1387 if (i > 0)
1388 len += snprintf(buf + len, max(buf_size - len, 0), " ");
1389 }
1390 }
1391
1392 /*
1393 * If no output was produced print a single 0.
1394 */
1395 if (len == 0)
1396 len = snprintf(buf, buf_size, "%d", 0);
1397
1398 if (add_cr)
1399 len += snprintf(buf + len, max(buf_size - len, 0), "\n");
1400
1401 return len;
1402 }
1403
1404 #define INPUT_DEV_CAP_ATTR(ev, bm) \
1405 static ssize_t input_dev_show_cap_##bm(struct device *dev, \
1406 struct device_attribute *attr, \
1407 char *buf) \
1408 { \
1409 struct input_dev *input_dev = to_input_dev(dev); \
1410 int len = input_print_bitmap(buf, PAGE_SIZE, \
1411 input_dev->bm##bit, ev##_MAX, \
1412 true); \
1413 return min_t(int, len, PAGE_SIZE); \
1414 } \
1415 static DEVICE_ATTR(bm, S_IRUGO, input_dev_show_cap_##bm, NULL)
1416
1417 INPUT_DEV_CAP_ATTR(EV, ev);
1418 INPUT_DEV_CAP_ATTR(KEY, key);
1419 INPUT_DEV_CAP_ATTR(REL, rel);
1420 INPUT_DEV_CAP_ATTR(ABS, abs);
1421 INPUT_DEV_CAP_ATTR(MSC, msc);
1422 INPUT_DEV_CAP_ATTR(LED, led);
1423 INPUT_DEV_CAP_ATTR(SND, snd);
1424 INPUT_DEV_CAP_ATTR(FF, ff);
1425 INPUT_DEV_CAP_ATTR(SW, sw);
1426
1427 static struct attribute *input_dev_caps_attrs[] = {
1428 &dev_attr_ev.attr,
1429 &dev_attr_key.attr,
1430 &dev_attr_rel.attr,
1431 &dev_attr_abs.attr,
1432 &dev_attr_msc.attr,
1433 &dev_attr_led.attr,
1434 &dev_attr_snd.attr,
1435 &dev_attr_ff.attr,
1436 &dev_attr_sw.attr,
1437 NULL
1438 };
1439
1440 static struct attribute_group input_dev_caps_attr_group = {
1441 .name = "capabilities",
1442 .attrs = input_dev_caps_attrs,
1443 };
1444
1445 static const struct attribute_group *input_dev_attr_groups[] = {
1446 &input_dev_attr_group,
1447 &input_dev_id_attr_group,
1448 &input_dev_caps_attr_group,
1449 NULL
1450 };
1451
1452 static void input_dev_release(struct device *device)
1453 {
1454 struct input_dev *dev = to_input_dev(device);
1455
1456 input_ff_destroy(dev);
1457 input_mt_destroy_slots(dev);
1458 kfree(dev->absinfo);
1459 kfree(dev);
1460
1461 module_put(THIS_MODULE);
1462 }
1463
1464 /*
1465 * Input uevent interface - loading event handlers based on
1466 * device bitfields.
1467 */
1468 static int input_add_uevent_bm_var(struct kobj_uevent_env *env,
1469 const char *name, unsigned long *bitmap, int max)
1470 {
1471 int len;
1472
1473 if (add_uevent_var(env, "%s=", name))
1474 return -ENOMEM;
1475
1476 len = input_print_bitmap(&env->buf[env->buflen - 1],
1477 sizeof(env->buf) - env->buflen,
1478 bitmap, max, false);
1479 if (len >= (sizeof(env->buf) - env->buflen))
1480 return -ENOMEM;
1481
1482 env->buflen += len;
1483 return 0;
1484 }
1485
1486 static int input_add_uevent_modalias_var(struct kobj_uevent_env *env,
1487 struct input_dev *dev)
1488 {
1489 int len;
1490
1491 if (add_uevent_var(env, "MODALIAS="))
1492 return -ENOMEM;
1493
1494 len = input_print_modalias(&env->buf[env->buflen - 1],
1495 sizeof(env->buf) - env->buflen,
1496 dev, 0);
1497 if (len >= (sizeof(env->buf) - env->buflen))
1498 return -ENOMEM;
1499
1500 env->buflen += len;
1501 return 0;
1502 }
1503
1504 #define INPUT_ADD_HOTPLUG_VAR(fmt, val...) \
1505 do { \
1506 int err = add_uevent_var(env, fmt, val); \
1507 if (err) \
1508 return err; \
1509 } while (0)
1510
1511 #define INPUT_ADD_HOTPLUG_BM_VAR(name, bm, max) \
1512 do { \
1513 int err = input_add_uevent_bm_var(env, name, bm, max); \
1514 if (err) \
1515 return err; \
1516 } while (0)
1517
1518 #define INPUT_ADD_HOTPLUG_MODALIAS_VAR(dev) \
1519 do { \
1520 int err = input_add_uevent_modalias_var(env, dev); \
1521 if (err) \
1522 return err; \
1523 } while (0)
1524
1525 static int input_dev_uevent(struct device *device, struct kobj_uevent_env *env)
1526 {
1527 struct input_dev *dev = to_input_dev(device);
1528
1529 INPUT_ADD_HOTPLUG_VAR("PRODUCT=%x/%x/%x/%x",
1530 dev->id.bustype, dev->id.vendor,
1531 dev->id.product, dev->id.version);
1532 if (dev->name)
1533 INPUT_ADD_HOTPLUG_VAR("NAME=\"%s\"", dev->name);
1534 if (dev->phys)
1535 INPUT_ADD_HOTPLUG_VAR("PHYS=\"%s\"", dev->phys);
1536 if (dev->uniq)
1537 INPUT_ADD_HOTPLUG_VAR("UNIQ=\"%s\"", dev->uniq);
1538
1539 INPUT_ADD_HOTPLUG_BM_VAR("EV=", dev->evbit, EV_MAX);
1540 if (test_bit(EV_KEY, dev->evbit))
1541 INPUT_ADD_HOTPLUG_BM_VAR("KEY=", dev->keybit, KEY_MAX);
1542 if (test_bit(EV_REL, dev->evbit))
1543 INPUT_ADD_HOTPLUG_BM_VAR("REL=", dev->relbit, REL_MAX);
1544 if (test_bit(EV_ABS, dev->evbit))
1545 INPUT_ADD_HOTPLUG_BM_VAR("ABS=", dev->absbit, ABS_MAX);
1546 if (test_bit(EV_MSC, dev->evbit))
1547 INPUT_ADD_HOTPLUG_BM_VAR("MSC=", dev->mscbit, MSC_MAX);
1548 if (test_bit(EV_LED, dev->evbit))
1549 INPUT_ADD_HOTPLUG_BM_VAR("LED=", dev->ledbit, LED_MAX);
1550 if (test_bit(EV_SND, dev->evbit))
1551 INPUT_ADD_HOTPLUG_BM_VAR("SND=", dev->sndbit, SND_MAX);
1552 if (test_bit(EV_FF, dev->evbit))
1553 INPUT_ADD_HOTPLUG_BM_VAR("FF=", dev->ffbit, FF_MAX);
1554 if (test_bit(EV_SW, dev->evbit))
1555 INPUT_ADD_HOTPLUG_BM_VAR("SW=", dev->swbit, SW_MAX);
1556
1557 INPUT_ADD_HOTPLUG_MODALIAS_VAR(dev);
1558
1559 return 0;
1560 }
1561
1562 #define INPUT_DO_TOGGLE(dev, type, bits, on) \
1563 do { \
1564 int i; \
1565 bool active; \
1566 \
1567 if (!test_bit(EV_##type, dev->evbit)) \
1568 break; \
1569 \
1570 for (i = 0; i < type##_MAX; i++) { \
1571 if (!test_bit(i, dev->bits##bit)) \
1572 continue; \
1573 \
1574 active = test_bit(i, dev->bits); \
1575 if (!active && !on) \
1576 continue; \
1577 \
1578 dev->event(dev, EV_##type, i, on ? active : 0); \
1579 } \
1580 } while (0)
1581
1582 static void input_dev_toggle(struct input_dev *dev, bool activate)
1583 {
1584 if (!dev->event)
1585 return;
1586
1587 INPUT_DO_TOGGLE(dev, LED, led, activate);
1588 INPUT_DO_TOGGLE(dev, SND, snd, activate);
1589
1590 if (activate && test_bit(EV_REP, dev->evbit)) {
1591 dev->event(dev, EV_REP, REP_PERIOD, dev->rep[REP_PERIOD]);
1592 dev->event(dev, EV_REP, REP_DELAY, dev->rep[REP_DELAY]);
1593 }
1594 }
1595
1596 /**
1597 * input_reset_device() - reset/restore the state of input device
1598 * @dev: input device whose state needs to be reset
1599 *
1600 * This function tries to reset the state of an opened input device and
1601 * bring internal state and state if the hardware in sync with each other.
1602 * We mark all keys as released, restore LED state, repeat rate, etc.
1603 */
1604 void input_reset_device(struct input_dev *dev)
1605 {
1606 mutex_lock(&dev->mutex);
1607
1608 if (dev->users) {
1609 input_dev_toggle(dev, true);
1610
1611 /*
1612 * Keys that have been pressed at suspend time are unlikely
1613 * to be still pressed when we resume.
1614 */
1615 spin_lock_irq(&dev->event_lock);
1616 input_dev_release_keys(dev);
1617 spin_unlock_irq(&dev->event_lock);
1618 }
1619
1620 mutex_unlock(&dev->mutex);
1621 }
1622 EXPORT_SYMBOL(input_reset_device);
1623
1624 #ifdef CONFIG_PM
1625 static int input_dev_suspend(struct device *dev)
1626 {
1627 struct input_dev *input_dev = to_input_dev(dev);
1628
1629 mutex_lock(&input_dev->mutex);
1630
1631 if (input_dev->users)
1632 input_dev_toggle(input_dev, false);
1633
1634 mutex_unlock(&input_dev->mutex);
1635
1636 return 0;
1637 }
1638
1639 static int input_dev_resume(struct device *dev)
1640 {
1641 struct input_dev *input_dev = to_input_dev(dev);
1642
1643 input_reset_device(input_dev);
1644
1645 return 0;
1646 }
1647
1648 static const struct dev_pm_ops input_dev_pm_ops = {
1649 .suspend = input_dev_suspend,
1650 .resume = input_dev_resume,
1651 .poweroff = input_dev_suspend,
1652 .restore = input_dev_resume,
1653 };
1654 #endif /* CONFIG_PM */
1655
1656 static struct device_type input_dev_type = {
1657 .groups = input_dev_attr_groups,
1658 .release = input_dev_release,
1659 .uevent = input_dev_uevent,
1660 #ifdef CONFIG_PM
1661 .pm = &input_dev_pm_ops,
1662 #endif
1663 };
1664
1665 static char *input_devnode(struct device *dev, mode_t *mode)
1666 {
1667 return kasprintf(GFP_KERNEL, "input/%s", dev_name(dev));
1668 }
1669
1670 struct class input_class = {
1671 .name = "input",
1672 .devnode = input_devnode,
1673 };
1674 EXPORT_SYMBOL_GPL(input_class);
1675
1676 /**
1677 * input_allocate_device - allocate memory for new input device
1678 *
1679 * Returns prepared struct input_dev or NULL.
1680 *
1681 * NOTE: Use input_free_device() to free devices that have not been
1682 * registered; input_unregister_device() should be used for already
1683 * registered devices.
1684 */
1685 struct input_dev *input_allocate_device(void)
1686 {
1687 struct input_dev *dev;
1688
1689 dev = kzalloc(sizeof(struct input_dev), GFP_KERNEL);
1690 if (dev) {
1691 dev->dev.type = &input_dev_type;
1692 dev->dev.class = &input_class;
1693 device_initialize(&dev->dev);
1694 mutex_init(&dev->mutex);
1695 spin_lock_init(&dev->event_lock);
1696 INIT_LIST_HEAD(&dev->h_list);
1697 INIT_LIST_HEAD(&dev->node);
1698
1699 __module_get(THIS_MODULE);
1700 }
1701
1702 return dev;
1703 }
1704 EXPORT_SYMBOL(input_allocate_device);
1705
1706 /**
1707 * input_free_device - free memory occupied by input_dev structure
1708 * @dev: input device to free
1709 *
1710 * This function should only be used if input_register_device()
1711 * was not called yet or if it failed. Once device was registered
1712 * use input_unregister_device() and memory will be freed once last
1713 * reference to the device is dropped.
1714 *
1715 * Device should be allocated by input_allocate_device().
1716 *
1717 * NOTE: If there are references to the input device then memory
1718 * will not be freed until last reference is dropped.
1719 */
1720 void input_free_device(struct input_dev *dev)
1721 {
1722 if (dev)
1723 input_put_device(dev);
1724 }
1725 EXPORT_SYMBOL(input_free_device);
1726
1727 /**
1728 * input_mt_create_slots() - create MT input slots
1729 * @dev: input device supporting MT events and finger tracking
1730 * @num_slots: number of slots used by the device
1731 *
1732 * This function allocates all necessary memory for MT slot handling in the
1733 * input device, and adds ABS_MT_SLOT to the device capabilities. All slots
1734 * are initially marked as unused by setting ABS_MT_TRACKING_ID to -1.
1735 */
1736 int input_mt_create_slots(struct input_dev *dev, unsigned int num_slots)
1737 {
1738 int i;
1739
1740 if (!num_slots)
1741 return 0;
1742
1743 dev->mt = kcalloc(num_slots, sizeof(struct input_mt_slot), GFP_KERNEL);
1744 if (!dev->mt)
1745 return -ENOMEM;
1746
1747 dev->mtsize = num_slots;
1748 input_set_abs_params(dev, ABS_MT_SLOT, 0, num_slots - 1, 0, 0);
1749
1750 /* Mark slots as 'unused' */
1751 for (i = 0; i < num_slots; i++)
1752 dev->mt[i].abs[ABS_MT_TRACKING_ID - ABS_MT_FIRST] = -1;
1753
1754 return 0;
1755 }
1756 EXPORT_SYMBOL(input_mt_create_slots);
1757
1758 /**
1759 * input_mt_destroy_slots() - frees the MT slots of the input device
1760 * @dev: input device with allocated MT slots
1761 *
1762 * This function is only needed in error path as the input core will
1763 * automatically free the MT slots when the device is destroyed.
1764 */
1765 void input_mt_destroy_slots(struct input_dev *dev)
1766 {
1767 kfree(dev->mt);
1768 dev->mt = NULL;
1769 dev->mtsize = 0;
1770 }
1771 EXPORT_SYMBOL(input_mt_destroy_slots);
1772
1773 /**
1774 * input_set_capability - mark device as capable of a certain event
1775 * @dev: device that is capable of emitting or accepting event
1776 * @type: type of the event (EV_KEY, EV_REL, etc...)
1777 * @code: event code
1778 *
1779 * In addition to setting up corresponding bit in appropriate capability
1780 * bitmap the function also adjusts dev->evbit.
1781 */
1782 void input_set_capability(struct input_dev *dev, unsigned int type, unsigned int code)
1783 {
1784 switch (type) {
1785 case EV_KEY:
1786 __set_bit(code, dev->keybit);
1787 break;
1788
1789 case EV_REL:
1790 __set_bit(code, dev->relbit);
1791 break;
1792
1793 case EV_ABS:
1794 __set_bit(code, dev->absbit);
1795 break;
1796
1797 case EV_MSC:
1798 __set_bit(code, dev->mscbit);
1799 break;
1800
1801 case EV_SW:
1802 __set_bit(code, dev->swbit);
1803 break;
1804
1805 case EV_LED:
1806 __set_bit(code, dev->ledbit);
1807 break;
1808
1809 case EV_SND:
1810 __set_bit(code, dev->sndbit);
1811 break;
1812
1813 case EV_FF:
1814 __set_bit(code, dev->ffbit);
1815 break;
1816
1817 case EV_PWR:
1818 /* do nothing */
1819 break;
1820
1821 default:
1822 printk(KERN_ERR
1823 "input_set_capability: unknown type %u (code %u)\n",
1824 type, code);
1825 dump_stack();
1826 return;
1827 }
1828
1829 __set_bit(type, dev->evbit);
1830 }
1831 EXPORT_SYMBOL(input_set_capability);
1832
1833 #define INPUT_CLEANSE_BITMASK(dev, type, bits) \
1834 do { \
1835 if (!test_bit(EV_##type, dev->evbit)) \
1836 memset(dev->bits##bit, 0, \
1837 sizeof(dev->bits##bit)); \
1838 } while (0)
1839
1840 static void input_cleanse_bitmasks(struct input_dev *dev)
1841 {
1842 INPUT_CLEANSE_BITMASK(dev, KEY, key);
1843 INPUT_CLEANSE_BITMASK(dev, REL, rel);
1844 INPUT_CLEANSE_BITMASK(dev, ABS, abs);
1845 INPUT_CLEANSE_BITMASK(dev, MSC, msc);
1846 INPUT_CLEANSE_BITMASK(dev, LED, led);
1847 INPUT_CLEANSE_BITMASK(dev, SND, snd);
1848 INPUT_CLEANSE_BITMASK(dev, FF, ff);
1849 INPUT_CLEANSE_BITMASK(dev, SW, sw);
1850 }
1851
1852 /**
1853 * input_register_device - register device with input core
1854 * @dev: device to be registered
1855 *
1856 * This function registers device with input core. The device must be
1857 * allocated with input_allocate_device() and all it's capabilities
1858 * set up before registering.
1859 * If function fails the device must be freed with input_free_device().
1860 * Once device has been successfully registered it can be unregistered
1861 * with input_unregister_device(); input_free_device() should not be
1862 * called in this case.
1863 */
1864 int input_register_device(struct input_dev *dev)
1865 {
1866 static atomic_t input_no = ATOMIC_INIT(0);
1867 struct input_handler *handler;
1868 const char *path;
1869 int error;
1870
1871 /* Every input device generates EV_SYN/SYN_REPORT events. */
1872 __set_bit(EV_SYN, dev->evbit);
1873
1874 /* KEY_RESERVED is not supposed to be transmitted to userspace. */
1875 __clear_bit(KEY_RESERVED, dev->keybit);
1876
1877 /* Make sure that bitmasks not mentioned in dev->evbit are clean. */
1878 input_cleanse_bitmasks(dev);
1879
1880 /*
1881 * If delay and period are pre-set by the driver, then autorepeating
1882 * is handled by the driver itself and we don't do it in input.c.
1883 */
1884 init_timer(&dev->timer);
1885 if (!dev->rep[REP_DELAY] && !dev->rep[REP_PERIOD]) {
1886 dev->timer.data = (long) dev;
1887 dev->timer.function = input_repeat_key;
1888 dev->rep[REP_DELAY] = 250;
1889 dev->rep[REP_PERIOD] = 33;
1890 }
1891
1892 if (!dev->getkeycode && !dev->getkeycode_new)
1893 dev->getkeycode_new = input_default_getkeycode;
1894
1895 if (!dev->setkeycode && !dev->setkeycode_new)
1896 dev->setkeycode_new = input_default_setkeycode;
1897
1898 dev_set_name(&dev->dev, "input%ld",
1899 (unsigned long) atomic_inc_return(&input_no) - 1);
1900
1901 error = device_add(&dev->dev);
1902 if (error)
1903 return error;
1904
1905 path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);
1906 printk(KERN_INFO "input: %s as %s\n",
1907 dev->name ? dev->name : "Unspecified device", path ? path : "N/A");
1908 kfree(path);
1909
1910 error = mutex_lock_interruptible(&input_mutex);
1911 if (error) {
1912 device_del(&dev->dev);
1913 return error;
1914 }
1915
1916 list_add_tail(&dev->node, &input_dev_list);
1917
1918 list_for_each_entry(handler, &input_handler_list, node)
1919 input_attach_handler(dev, handler);
1920
1921 input_wakeup_procfs_readers();
1922
1923 mutex_unlock(&input_mutex);
1924
1925 return 0;
1926 }
1927 EXPORT_SYMBOL(input_register_device);
1928
1929 /**
1930 * input_unregister_device - unregister previously registered device
1931 * @dev: device to be unregistered
1932 *
1933 * This function unregisters an input device. Once device is unregistered
1934 * the caller should not try to access it as it may get freed at any moment.
1935 */
1936 void input_unregister_device(struct input_dev *dev)
1937 {
1938 struct input_handle *handle, *next;
1939
1940 input_disconnect_device(dev);
1941
1942 mutex_lock(&input_mutex);
1943
1944 list_for_each_entry_safe(handle, next, &dev->h_list, d_node)
1945 handle->handler->disconnect(handle);
1946 WARN_ON(!list_empty(&dev->h_list));
1947
1948 del_timer_sync(&dev->timer);
1949 list_del_init(&dev->node);
1950
1951 input_wakeup_procfs_readers();
1952
1953 mutex_unlock(&input_mutex);
1954
1955 device_unregister(&dev->dev);
1956 }
1957 EXPORT_SYMBOL(input_unregister_device);
1958
1959 /**
1960 * input_register_handler - register a new input handler
1961 * @handler: handler to be registered
1962 *
1963 * This function registers a new input handler (interface) for input
1964 * devices in the system and attaches it to all input devices that
1965 * are compatible with the handler.
1966 */
1967 int input_register_handler(struct input_handler *handler)
1968 {
1969 struct input_dev *dev;
1970 int retval;
1971
1972 retval = mutex_lock_interruptible(&input_mutex);
1973 if (retval)
1974 return retval;
1975
1976 INIT_LIST_HEAD(&handler->h_list);
1977
1978 if (handler->fops != NULL) {
1979 if (input_table[handler->minor >> 5]) {
1980 retval = -EBUSY;
1981 goto out;
1982 }
1983 input_table[handler->minor >> 5] = handler;
1984 }
1985
1986 list_add_tail(&handler->node, &input_handler_list);
1987
1988 list_for_each_entry(dev, &input_dev_list, node)
1989 input_attach_handler(dev, handler);
1990
1991 input_wakeup_procfs_readers();
1992
1993 out:
1994 mutex_unlock(&input_mutex);
1995 return retval;
1996 }
1997 EXPORT_SYMBOL(input_register_handler);
1998
1999 /**
2000 * input_unregister_handler - unregisters an input handler
2001 * @handler: handler to be unregistered
2002 *
2003 * This function disconnects a handler from its input devices and
2004 * removes it from lists of known handlers.
2005 */
2006 void input_unregister_handler(struct input_handler *handler)
2007 {
2008 struct input_handle *handle, *next;
2009
2010 mutex_lock(&input_mutex);
2011
2012 list_for_each_entry_safe(handle, next, &handler->h_list, h_node)
2013 handler->disconnect(handle);
2014 WARN_ON(!list_empty(&handler->h_list));
2015
2016 list_del_init(&handler->node);
2017
2018 if (handler->fops != NULL)
2019 input_table[handler->minor >> 5] = NULL;
2020
2021 input_wakeup_procfs_readers();
2022
2023 mutex_unlock(&input_mutex);
2024 }
2025 EXPORT_SYMBOL(input_unregister_handler);
2026
2027 /**
2028 * input_handler_for_each_handle - handle iterator
2029 * @handler: input handler to iterate
2030 * @data: data for the callback
2031 * @fn: function to be called for each handle
2032 *
2033 * Iterate over @bus's list of devices, and call @fn for each, passing
2034 * it @data and stop when @fn returns a non-zero value. The function is
2035 * using RCU to traverse the list and therefore may be usind in atonic
2036 * contexts. The @fn callback is invoked from RCU critical section and
2037 * thus must not sleep.
2038 */
2039 int input_handler_for_each_handle(struct input_handler *handler, void *data,
2040 int (*fn)(struct input_handle *, void *))
2041 {
2042 struct input_handle *handle;
2043 int retval = 0;
2044
2045 rcu_read_lock();
2046
2047 list_for_each_entry_rcu(handle, &handler->h_list, h_node) {
2048 retval = fn(handle, data);
2049 if (retval)
2050 break;
2051 }
2052
2053 rcu_read_unlock();
2054
2055 return retval;
2056 }
2057 EXPORT_SYMBOL(input_handler_for_each_handle);
2058
2059 /**
2060 * input_register_handle - register a new input handle
2061 * @handle: handle to register
2062 *
2063 * This function puts a new input handle onto device's
2064 * and handler's lists so that events can flow through
2065 * it once it is opened using input_open_device().
2066 *
2067 * This function is supposed to be called from handler's
2068 * connect() method.
2069 */
2070 int input_register_handle(struct input_handle *handle)
2071 {
2072 struct input_handler *handler = handle->handler;
2073 struct input_dev *dev = handle->dev;
2074 int error;
2075
2076 /*
2077 * We take dev->mutex here to prevent race with
2078 * input_release_device().
2079 */
2080 error = mutex_lock_interruptible(&dev->mutex);
2081 if (error)
2082 return error;
2083
2084 /*
2085 * Filters go to the head of the list, normal handlers
2086 * to the tail.
2087 */
2088 if (handler->filter)
2089 list_add_rcu(&handle->d_node, &dev->h_list);
2090 else
2091 list_add_tail_rcu(&handle->d_node, &dev->h_list);
2092
2093 mutex_unlock(&dev->mutex);
2094
2095 /*
2096 * Since we are supposed to be called from ->connect()
2097 * which is mutually exclusive with ->disconnect()
2098 * we can't be racing with input_unregister_handle()
2099 * and so separate lock is not needed here.
2100 */
2101 list_add_tail_rcu(&handle->h_node, &handler->h_list);
2102
2103 if (handler->start)
2104 handler->start(handle);
2105
2106 return 0;
2107 }
2108 EXPORT_SYMBOL(input_register_handle);
2109
2110 /**
2111 * input_unregister_handle - unregister an input handle
2112 * @handle: handle to unregister
2113 *
2114 * This function removes input handle from device's
2115 * and handler's lists.
2116 *
2117 * This function is supposed to be called from handler's
2118 * disconnect() method.
2119 */
2120 void input_unregister_handle(struct input_handle *handle)
2121 {
2122 struct input_dev *dev = handle->dev;
2123
2124 list_del_rcu(&handle->h_node);
2125
2126 /*
2127 * Take dev->mutex to prevent race with input_release_device().
2128 */
2129 mutex_lock(&dev->mutex);
2130 list_del_rcu(&handle->d_node);
2131 mutex_unlock(&dev->mutex);
2132
2133 synchronize_rcu();
2134 }
2135 EXPORT_SYMBOL(input_unregister_handle);
2136
2137 static int input_open_file(struct inode *inode, struct file *file)
2138 {
2139 struct input_handler *handler;
2140 const struct file_operations *old_fops, *new_fops = NULL;
2141 int err;
2142
2143 err = mutex_lock_interruptible(&input_mutex);
2144 if (err)
2145 return err;
2146
2147 /* No load-on-demand here? */
2148 handler = input_table[iminor(inode) >> 5];
2149 if (handler)
2150 new_fops = fops_get(handler->fops);
2151
2152 mutex_unlock(&input_mutex);
2153
2154 /*
2155 * That's _really_ odd. Usually NULL ->open means "nothing special",
2156 * not "no device". Oh, well...
2157 */
2158 if (!new_fops || !new_fops->open) {
2159 fops_put(new_fops);
2160 err = -ENODEV;
2161 goto out;
2162 }
2163
2164 old_fops = file->f_op;
2165 file->f_op = new_fops;
2166
2167 err = new_fops->open(inode, file);
2168 if (err) {
2169 fops_put(file->f_op);
2170 file->f_op = fops_get(old_fops);
2171 }
2172 fops_put(old_fops);
2173 out:
2174 return err;
2175 }
2176
2177 static const struct file_operations input_fops = {
2178 .owner = THIS_MODULE,
2179 .open = input_open_file,
2180 .llseek = noop_llseek,
2181 };
2182
2183 static int __init input_init(void)
2184 {
2185 int err;
2186
2187 err = class_register(&input_class);
2188 if (err) {
2189 printk(KERN_ERR "input: unable to register input_dev class\n");
2190 return err;
2191 }
2192
2193 err = input_proc_init();
2194 if (err)
2195 goto fail1;
2196
2197 err = register_chrdev(INPUT_MAJOR, "input", &input_fops);
2198 if (err) {
2199 printk(KERN_ERR "input: unable to register char major %d", INPUT_MAJOR);
2200 goto fail2;
2201 }
2202
2203 return 0;
2204
2205 fail2: input_proc_exit();
2206 fail1: class_unregister(&input_class);
2207 return err;
2208 }
2209
2210 static void __exit input_exit(void)
2211 {
2212 input_proc_exit();
2213 unregister_chrdev(INPUT_MAJOR, "input");
2214 class_unregister(&input_class);
2215 }
2216
2217 subsys_initcall(input_init);
2218 module_exit(input_exit);
Linus' kernel tree