Line data Source code
1 : // SPDX-License-Identifier: GPL-2.0-only
2 : /*
3 : * The input core
4 : *
5 : * Copyright (c) 1999-2002 Vojtech Pavlik
6 : */
7 :
8 :
9 : #define pr_fmt(fmt) KBUILD_BASENAME ": " fmt
10 :
11 : #include <linux/init.h>
12 : #include <linux/types.h>
13 : #include <linux/idr.h>
14 : #include <linux/input/mt.h>
15 : #include <linux/module.h>
16 : #include <linux/slab.h>
17 : #include <linux/random.h>
18 : #include <linux/major.h>
19 : #include <linux/proc_fs.h>
20 : #include <linux/sched.h>
21 : #include <linux/seq_file.h>
22 : #include <linux/poll.h>
23 : #include <linux/device.h>
24 : #include <linux/mutex.h>
25 : #include <linux/rcupdate.h>
26 : #include "input-compat.h"
27 : #include "input-poller.h"
28 :
29 : MODULE_AUTHOR("Vojtech Pavlik <vojtech@suse.cz>");
30 : MODULE_DESCRIPTION("Input core");
31 : MODULE_LICENSE("GPL");
32 :
33 : #define INPUT_MAX_CHAR_DEVICES 1024
34 : #define INPUT_FIRST_DYNAMIC_DEV 256
35 : static DEFINE_IDA(input_ida);
36 :
37 : static LIST_HEAD(input_dev_list);
38 : static LIST_HEAD(input_handler_list);
39 :
40 : /*
41 : * input_mutex protects access to both input_dev_list and input_handler_list.
42 : * This also causes input_[un]register_device and input_[un]register_handler
43 : * be mutually exclusive which simplifies locking in drivers implementing
44 : * input handlers.
45 : */
46 : static DEFINE_MUTEX(input_mutex);
47 :
48 : static const struct input_value input_value_sync = { EV_SYN, SYN_REPORT, 1 };
49 :
50 : static const unsigned int input_max_code[EV_CNT] = {
51 : [EV_KEY] = KEY_MAX,
52 : [EV_REL] = REL_MAX,
53 : [EV_ABS] = ABS_MAX,
54 : [EV_MSC] = MSC_MAX,
55 : [EV_SW] = SW_MAX,
56 : [EV_LED] = LED_MAX,
57 : [EV_SND] = SND_MAX,
58 : [EV_FF] = FF_MAX,
59 : };
60 :
61 : static inline int is_event_supported(unsigned int code,
62 : unsigned long *bm, unsigned int max)
63 : {
64 0 : return code <= max && test_bit(code, bm);
65 : }
66 :
67 0 : static int input_defuzz_abs_event(int value, int old_val, int fuzz)
68 : {
69 0 : if (fuzz) {
70 0 : if (value > old_val - fuzz / 2 && value < old_val + fuzz / 2)
71 : return old_val;
72 :
73 0 : if (value > old_val - fuzz && value < old_val + fuzz)
74 0 : return (old_val * 3 + value) / 4;
75 :
76 0 : if (value > old_val - fuzz * 2 && value < old_val + fuzz * 2)
77 0 : return (old_val + value) / 2;
78 : }
79 :
80 : return value;
81 : }
82 :
83 0 : static void input_start_autorepeat(struct input_dev *dev, int code)
84 : {
85 0 : if (test_bit(EV_REP, dev->evbit) &&
86 0 : dev->rep[REP_PERIOD] && dev->rep[REP_DELAY] &&
87 0 : dev->timer.function) {
88 0 : dev->repeat_key = code;
89 0 : mod_timer(&dev->timer,
90 0 : jiffies + msecs_to_jiffies(dev->rep[REP_DELAY]));
91 : }
92 0 : }
93 :
94 : static void input_stop_autorepeat(struct input_dev *dev)
95 : {
96 0 : del_timer(&dev->timer);
97 : }
98 :
99 : /*
100 : * Pass event first through all filters and then, if event has not been
101 : * filtered out, through all open handles. This function is called with
102 : * dev->event_lock held and interrupts disabled.
103 : */
104 0 : static unsigned int input_to_handler(struct input_handle *handle,
105 : struct input_value *vals, unsigned int count)
106 : {
107 0 : struct input_handler *handler = handle->handler;
108 0 : struct input_value *end = vals;
109 : struct input_value *v;
110 :
111 0 : if (handler->filter) {
112 0 : for (v = vals; v != vals + count; v++) {
113 0 : if (handler->filter(handle, v->type, v->code, v->value))
114 0 : continue;
115 0 : if (end != v)
116 0 : *end = *v;
117 0 : end++;
118 : }
119 0 : count = end - vals;
120 : }
121 :
122 0 : if (!count)
123 : return 0;
124 :
125 0 : if (handler->events)
126 0 : handler->events(handle, vals, count);
127 0 : else if (handler->event)
128 0 : for (v = vals; v != vals + count; v++)
129 0 : handler->event(handle, v->type, v->code, v->value);
130 :
131 : return count;
132 : }
133 :
134 : /*
135 : * Pass values first through all filters and then, if event has not been
136 : * filtered out, through all open handles. This function is called with
137 : * dev->event_lock held and interrupts disabled.
138 : */
139 0 : static void input_pass_values(struct input_dev *dev,
140 : struct input_value *vals, unsigned int count)
141 : {
142 : struct input_handle *handle;
143 : struct input_value *v;
144 :
145 0 : if (!count)
146 : return;
147 :
148 : rcu_read_lock();
149 :
150 0 : handle = rcu_dereference(dev->grab);
151 0 : if (handle) {
152 0 : count = input_to_handler(handle, vals, count);
153 : } else {
154 0 : list_for_each_entry_rcu(handle, &dev->h_list, d_node)
155 0 : if (handle->open) {
156 0 : count = input_to_handler(handle, vals, count);
157 0 : if (!count)
158 : break;
159 : }
160 : }
161 :
162 : rcu_read_unlock();
163 :
164 : /* trigger auto repeat for key events */
165 0 : if (test_bit(EV_REP, dev->evbit) && test_bit(EV_KEY, dev->evbit)) {
166 0 : for (v = vals; v != vals + count; v++) {
167 0 : if (v->type == EV_KEY && v->value != 2) {
168 0 : if (v->value)
169 0 : input_start_autorepeat(dev, v->code);
170 : else
171 : input_stop_autorepeat(dev);
172 : }
173 : }
174 : }
175 : }
176 :
177 : static void input_pass_event(struct input_dev *dev,
178 : unsigned int type, unsigned int code, int value)
179 : {
180 0 : struct input_value vals[] = { { type, code, value } };
181 :
182 0 : input_pass_values(dev, vals, ARRAY_SIZE(vals));
183 : }
184 :
185 : /*
186 : * Generate software autorepeat event. Note that we take
187 : * dev->event_lock here to avoid racing with input_event
188 : * which may cause keys get "stuck".
189 : */
190 0 : static void input_repeat_key(struct timer_list *t)
191 : {
192 0 : struct input_dev *dev = from_timer(dev, t, timer);
193 : unsigned long flags;
194 :
195 0 : spin_lock_irqsave(&dev->event_lock, flags);
196 :
197 0 : if (test_bit(dev->repeat_key, dev->key) &&
198 0 : is_event_supported(dev->repeat_key, dev->keybit, KEY_MAX)) {
199 0 : struct input_value vals[] = {
200 0 : { EV_KEY, dev->repeat_key, 2 },
201 : input_value_sync
202 : };
203 :
204 0 : input_set_timestamp(dev, ktime_get());
205 0 : input_pass_values(dev, vals, ARRAY_SIZE(vals));
206 :
207 0 : if (dev->rep[REP_PERIOD])
208 0 : mod_timer(&dev->timer, jiffies +
209 0 : msecs_to_jiffies(dev->rep[REP_PERIOD]));
210 : }
211 :
212 0 : spin_unlock_irqrestore(&dev->event_lock, flags);
213 0 : }
214 :
215 : #define INPUT_IGNORE_EVENT 0
216 : #define INPUT_PASS_TO_HANDLERS 1
217 : #define INPUT_PASS_TO_DEVICE 2
218 : #define INPUT_SLOT 4
219 : #define INPUT_FLUSH 8
220 : #define INPUT_PASS_TO_ALL (INPUT_PASS_TO_HANDLERS | INPUT_PASS_TO_DEVICE)
221 :
222 0 : static int input_handle_abs_event(struct input_dev *dev,
223 : unsigned int code, int *pval)
224 : {
225 0 : struct input_mt *mt = dev->mt;
226 : bool is_mt_event;
227 : int *pold;
228 :
229 0 : if (code == ABS_MT_SLOT) {
230 : /*
231 : * "Stage" the event; we'll flush it later, when we
232 : * get actual touch data.
233 : */
234 0 : if (mt && *pval >= 0 && *pval < mt->num_slots)
235 0 : mt->slot = *pval;
236 :
237 : return INPUT_IGNORE_EVENT;
238 : }
239 :
240 0 : is_mt_event = input_is_mt_value(code);
241 :
242 0 : if (!is_mt_event) {
243 0 : pold = &dev->absinfo[code].value;
244 0 : } else if (mt) {
245 0 : pold = &mt->slots[mt->slot].abs[code - ABS_MT_FIRST];
246 : } else {
247 : /*
248 : * Bypass filtering for multi-touch events when
249 : * not employing slots.
250 : */
251 : pold = NULL;
252 : }
253 :
254 0 : if (pold) {
255 0 : *pval = input_defuzz_abs_event(*pval, *pold,
256 0 : dev->absinfo[code].fuzz);
257 0 : if (*pold == *pval)
258 : return INPUT_IGNORE_EVENT;
259 :
260 0 : *pold = *pval;
261 : }
262 :
263 : /* Flush pending "slot" event */
264 0 : if (is_mt_event && mt && mt->slot != input_abs_get_val(dev, ABS_MT_SLOT)) {
265 0 : input_abs_set_val(dev, ABS_MT_SLOT, mt->slot);
266 : return INPUT_PASS_TO_HANDLERS | INPUT_SLOT;
267 : }
268 :
269 : return INPUT_PASS_TO_HANDLERS;
270 : }
271 :
272 0 : static int input_get_disposition(struct input_dev *dev,
273 : unsigned int type, unsigned int code, int *pval)
274 : {
275 0 : int disposition = INPUT_IGNORE_EVENT;
276 0 : int value = *pval;
277 :
278 0 : switch (type) {
279 :
280 : case EV_SYN:
281 0 : switch (code) {
282 : case SYN_CONFIG:
283 0 : disposition = INPUT_PASS_TO_ALL;
284 0 : break;
285 :
286 : case SYN_REPORT:
287 0 : disposition = INPUT_PASS_TO_HANDLERS | INPUT_FLUSH;
288 0 : break;
289 : case SYN_MT_REPORT:
290 0 : disposition = INPUT_PASS_TO_HANDLERS;
291 0 : break;
292 : }
293 : break;
294 :
295 : case EV_KEY:
296 0 : if (is_event_supported(code, dev->keybit, KEY_MAX)) {
297 :
298 : /* auto-repeat bypasses state updates */
299 0 : if (value == 2) {
300 : disposition = INPUT_PASS_TO_HANDLERS;
301 : break;
302 : }
303 :
304 0 : if (!!test_bit(code, dev->key) != !!value) {
305 :
306 0 : __change_bit(code, dev->key);
307 0 : disposition = INPUT_PASS_TO_HANDLERS;
308 : }
309 : }
310 : break;
311 :
312 : case EV_SW:
313 0 : if (is_event_supported(code, dev->swbit, SW_MAX) &&
314 0 : !!test_bit(code, dev->sw) != !!value) {
315 :
316 0 : __change_bit(code, dev->sw);
317 0 : disposition = INPUT_PASS_TO_HANDLERS;
318 : }
319 : break;
320 :
321 : case EV_ABS:
322 0 : if (is_event_supported(code, dev->absbit, ABS_MAX))
323 0 : disposition = input_handle_abs_event(dev, code, &value);
324 :
325 : break;
326 :
327 : case EV_REL:
328 0 : if (is_event_supported(code, dev->relbit, REL_MAX) && value)
329 0 : disposition = INPUT_PASS_TO_HANDLERS;
330 :
331 : break;
332 :
333 : case EV_MSC:
334 0 : if (is_event_supported(code, dev->mscbit, MSC_MAX))
335 0 : disposition = INPUT_PASS_TO_ALL;
336 :
337 : break;
338 :
339 : case EV_LED:
340 0 : if (is_event_supported(code, dev->ledbit, LED_MAX) &&
341 0 : !!test_bit(code, dev->led) != !!value) {
342 :
343 0 : __change_bit(code, dev->led);
344 0 : disposition = INPUT_PASS_TO_ALL;
345 : }
346 : break;
347 :
348 : case EV_SND:
349 0 : if (is_event_supported(code, dev->sndbit, SND_MAX)) {
350 :
351 0 : if (!!test_bit(code, dev->snd) != !!value)
352 0 : __change_bit(code, dev->snd);
353 : disposition = INPUT_PASS_TO_ALL;
354 : }
355 : break;
356 :
357 : case EV_REP:
358 0 : if (code <= REP_MAX && value >= 0 && dev->rep[code] != value) {
359 0 : dev->rep[code] = value;
360 0 : disposition = INPUT_PASS_TO_ALL;
361 : }
362 : break;
363 :
364 : case EV_FF:
365 0 : if (value >= 0)
366 0 : disposition = INPUT_PASS_TO_ALL;
367 : break;
368 :
369 : case EV_PWR:
370 0 : disposition = INPUT_PASS_TO_ALL;
371 0 : break;
372 : }
373 :
374 0 : *pval = value;
375 0 : return disposition;
376 : }
377 :
378 0 : static void input_handle_event(struct input_dev *dev,
379 : unsigned int type, unsigned int code, int value)
380 : {
381 : int disposition;
382 :
383 : /* filter-out events from inhibited devices */
384 0 : if (dev->inhibited)
385 : return;
386 :
387 0 : disposition = input_get_disposition(dev, type, code, &value);
388 0 : if (disposition != INPUT_IGNORE_EVENT && type != EV_SYN)
389 0 : add_input_randomness(type, code, value);
390 :
391 0 : if ((disposition & INPUT_PASS_TO_DEVICE) && dev->event)
392 0 : dev->event(dev, type, code, value);
393 :
394 0 : if (!dev->vals)
395 : return;
396 :
397 0 : if (disposition & INPUT_PASS_TO_HANDLERS) {
398 : struct input_value *v;
399 :
400 0 : if (disposition & INPUT_SLOT) {
401 0 : v = &dev->vals[dev->num_vals++];
402 0 : v->type = EV_ABS;
403 0 : v->code = ABS_MT_SLOT;
404 0 : v->value = dev->mt->slot;
405 : }
406 :
407 0 : v = &dev->vals[dev->num_vals++];
408 0 : v->type = type;
409 0 : v->code = code;
410 0 : v->value = value;
411 : }
412 :
413 0 : if (disposition & INPUT_FLUSH) {
414 0 : if (dev->num_vals >= 2)
415 0 : input_pass_values(dev, dev->vals, dev->num_vals);
416 0 : dev->num_vals = 0;
417 : /*
418 : * Reset the timestamp on flush so we won't end up
419 : * with a stale one. Note we only need to reset the
420 : * monolithic one as we use its presence when deciding
421 : * whether to generate a synthetic timestamp.
422 : */
423 0 : dev->timestamp[INPUT_CLK_MONO] = ktime_set(0, 0);
424 0 : } else if (dev->num_vals >= dev->max_vals - 2) {
425 0 : dev->vals[dev->num_vals++] = input_value_sync;
426 0 : input_pass_values(dev, dev->vals, dev->num_vals);
427 0 : dev->num_vals = 0;
428 : }
429 :
430 : }
431 :
432 : /**
433 : * input_event() - report new input event
434 : * @dev: device that generated the event
435 : * @type: type of the event
436 : * @code: event code
437 : * @value: value of the event
438 : *
439 : * This function should be used by drivers implementing various input
440 : * devices to report input events. See also input_inject_event().
441 : *
442 : * NOTE: input_event() may be safely used right after input device was
443 : * allocated with input_allocate_device(), even before it is registered
444 : * with input_register_device(), but the event will not reach any of the
445 : * input handlers. Such early invocation of input_event() may be used
446 : * to 'seed' initial state of a switch or initial position of absolute
447 : * axis, etc.
448 : */
449 0 : void input_event(struct input_dev *dev,
450 : unsigned int type, unsigned int code, int value)
451 : {
452 : unsigned long flags;
453 :
454 0 : if (is_event_supported(type, dev->evbit, EV_MAX)) {
455 :
456 0 : spin_lock_irqsave(&dev->event_lock, flags);
457 0 : input_handle_event(dev, type, code, value);
458 0 : spin_unlock_irqrestore(&dev->event_lock, flags);
459 : }
460 0 : }
461 : EXPORT_SYMBOL(input_event);
462 :
463 : /**
464 : * input_inject_event() - send input event from input handler
465 : * @handle: input handle to send event through
466 : * @type: type of the event
467 : * @code: event code
468 : * @value: value of the event
469 : *
470 : * Similar to input_event() but will ignore event if device is
471 : * "grabbed" and handle injecting event is not the one that owns
472 : * the device.
473 : */
474 0 : void input_inject_event(struct input_handle *handle,
475 : unsigned int type, unsigned int code, int value)
476 : {
477 0 : struct input_dev *dev = handle->dev;
478 : struct input_handle *grab;
479 : unsigned long flags;
480 :
481 0 : if (is_event_supported(type, dev->evbit, EV_MAX)) {
482 0 : spin_lock_irqsave(&dev->event_lock, flags);
483 :
484 : rcu_read_lock();
485 0 : grab = rcu_dereference(dev->grab);
486 0 : if (!grab || grab == handle)
487 0 : input_handle_event(dev, type, code, value);
488 : rcu_read_unlock();
489 :
490 0 : spin_unlock_irqrestore(&dev->event_lock, flags);
491 : }
492 0 : }
493 : EXPORT_SYMBOL(input_inject_event);
494 :
495 : /**
496 : * input_alloc_absinfo - allocates array of input_absinfo structs
497 : * @dev: the input device emitting absolute events
498 : *
499 : * If the absinfo struct the caller asked for is already allocated, this
500 : * functions will not do anything.
501 : */
502 0 : void input_alloc_absinfo(struct input_dev *dev)
503 : {
504 0 : if (dev->absinfo)
505 : return;
506 :
507 0 : dev->absinfo = kcalloc(ABS_CNT, sizeof(*dev->absinfo), GFP_KERNEL);
508 0 : if (!dev->absinfo) {
509 0 : dev_err(dev->dev.parent ?: &dev->dev,
510 : "%s: unable to allocate memory\n", __func__);
511 : /*
512 : * We will handle this allocation failure in
513 : * input_register_device() when we refuse to register input
514 : * device with ABS bits but without absinfo.
515 : */
516 : }
517 : }
518 : EXPORT_SYMBOL(input_alloc_absinfo);
519 :
520 0 : void input_set_abs_params(struct input_dev *dev, unsigned int axis,
521 : int min, int max, int fuzz, int flat)
522 : {
523 : struct input_absinfo *absinfo;
524 :
525 0 : __set_bit(EV_ABS, dev->evbit);
526 0 : __set_bit(axis, dev->absbit);
527 :
528 0 : input_alloc_absinfo(dev);
529 0 : if (!dev->absinfo)
530 : return;
531 :
532 0 : absinfo = &dev->absinfo[axis];
533 0 : absinfo->minimum = min;
534 0 : absinfo->maximum = max;
535 0 : absinfo->fuzz = fuzz;
536 0 : absinfo->flat = flat;
537 : }
538 : EXPORT_SYMBOL(input_set_abs_params);
539 :
540 : /**
541 : * input_copy_abs - Copy absinfo from one input_dev to another
542 : * @dst: Destination input device to copy the abs settings to
543 : * @dst_axis: ABS_* value selecting the destination axis
544 : * @src: Source input device to copy the abs settings from
545 : * @src_axis: ABS_* value selecting the source axis
546 : *
547 : * Set absinfo for the selected destination axis by copying it from
548 : * the specified source input device's source axis.
549 : * This is useful to e.g. setup a pen/stylus input-device for combined
550 : * touchscreen/pen hardware where the pen uses the same coordinates as
551 : * the touchscreen.
552 : */
553 0 : void input_copy_abs(struct input_dev *dst, unsigned int dst_axis,
554 : const struct input_dev *src, unsigned int src_axis)
555 : {
556 : /* src must have EV_ABS and src_axis set */
557 0 : if (WARN_ON(!(test_bit(EV_ABS, src->evbit) &&
558 : test_bit(src_axis, src->absbit))))
559 : return;
560 :
561 : /*
562 : * input_alloc_absinfo() may have failed for the source. Our caller is
563 : * expected to catch this when registering the input devices, which may
564 : * happen after the input_copy_abs() call.
565 : */
566 0 : if (!src->absinfo)
567 : return;
568 :
569 0 : input_set_capability(dst, EV_ABS, dst_axis);
570 0 : if (!dst->absinfo)
571 : return;
572 :
573 0 : dst->absinfo[dst_axis] = src->absinfo[src_axis];
574 : }
575 : EXPORT_SYMBOL(input_copy_abs);
576 :
577 : /**
578 : * input_grab_device - grabs device for exclusive use
579 : * @handle: input handle that wants to own the device
580 : *
581 : * When a device is grabbed by an input handle all events generated by
582 : * the device are delivered only to this handle. Also events injected
583 : * by other input handles are ignored while device is grabbed.
584 : */
585 0 : int input_grab_device(struct input_handle *handle)
586 : {
587 0 : struct input_dev *dev = handle->dev;
588 : int retval;
589 :
590 0 : retval = mutex_lock_interruptible(&dev->mutex);
591 0 : if (retval)
592 : return retval;
593 :
594 0 : if (dev->grab) {
595 : retval = -EBUSY;
596 : goto out;
597 : }
598 :
599 0 : rcu_assign_pointer(dev->grab, handle);
600 :
601 : out:
602 0 : mutex_unlock(&dev->mutex);
603 0 : return retval;
604 : }
605 : EXPORT_SYMBOL(input_grab_device);
606 :
607 0 : static void __input_release_device(struct input_handle *handle)
608 : {
609 0 : struct input_dev *dev = handle->dev;
610 : struct input_handle *grabber;
611 :
612 0 : grabber = rcu_dereference_protected(dev->grab,
613 : lockdep_is_held(&dev->mutex));
614 0 : if (grabber == handle) {
615 0 : rcu_assign_pointer(dev->grab, NULL);
616 : /* Make sure input_pass_event() notices that grab is gone */
617 0 : synchronize_rcu();
618 :
619 0 : list_for_each_entry(handle, &dev->h_list, d_node)
620 0 : if (handle->open && handle->handler->start)
621 0 : handle->handler->start(handle);
622 : }
623 0 : }
624 :
625 : /**
626 : * input_release_device - release previously grabbed device
627 : * @handle: input handle that owns the device
628 : *
629 : * Releases previously grabbed device so that other input handles can
630 : * start receiving input events. Upon release all handlers attached
631 : * to the device have their start() method called so they have a change
632 : * to synchronize device state with the rest of the system.
633 : */
634 0 : void input_release_device(struct input_handle *handle)
635 : {
636 0 : struct input_dev *dev = handle->dev;
637 :
638 0 : mutex_lock(&dev->mutex);
639 0 : __input_release_device(handle);
640 0 : mutex_unlock(&dev->mutex);
641 0 : }
642 : EXPORT_SYMBOL(input_release_device);
643 :
644 : /**
645 : * input_open_device - open input device
646 : * @handle: handle through which device is being accessed
647 : *
648 : * This function should be called by input handlers when they
649 : * want to start receive events from given input device.
650 : */
651 0 : int input_open_device(struct input_handle *handle)
652 : {
653 0 : struct input_dev *dev = handle->dev;
654 : int retval;
655 :
656 0 : retval = mutex_lock_interruptible(&dev->mutex);
657 0 : if (retval)
658 : return retval;
659 :
660 0 : if (dev->going_away) {
661 : retval = -ENODEV;
662 : goto out;
663 : }
664 :
665 0 : handle->open++;
666 :
667 0 : if (dev->users++ || dev->inhibited) {
668 : /*
669 : * Device is already opened and/or inhibited,
670 : * so we can exit immediately and report success.
671 : */
672 : goto out;
673 : }
674 :
675 0 : if (dev->open) {
676 0 : retval = dev->open(dev);
677 0 : if (retval) {
678 0 : dev->users--;
679 0 : handle->open--;
680 : /*
681 : * Make sure we are not delivering any more events
682 : * through this handle
683 : */
684 0 : synchronize_rcu();
685 0 : goto out;
686 : }
687 : }
688 :
689 0 : if (dev->poller)
690 0 : input_dev_poller_start(dev->poller);
691 :
692 : out:
693 0 : mutex_unlock(&dev->mutex);
694 0 : return retval;
695 : }
696 : EXPORT_SYMBOL(input_open_device);
697 :
698 0 : int input_flush_device(struct input_handle *handle, struct file *file)
699 : {
700 0 : struct input_dev *dev = handle->dev;
701 : int retval;
702 :
703 0 : retval = mutex_lock_interruptible(&dev->mutex);
704 0 : if (retval)
705 : return retval;
706 :
707 0 : if (dev->flush)
708 0 : retval = dev->flush(dev, file);
709 :
710 0 : mutex_unlock(&dev->mutex);
711 0 : return retval;
712 : }
713 : EXPORT_SYMBOL(input_flush_device);
714 :
715 : /**
716 : * input_close_device - close input device
717 : * @handle: handle through which device is being accessed
718 : *
719 : * This function should be called by input handlers when they
720 : * want to stop receive events from given input device.
721 : */
722 0 : void input_close_device(struct input_handle *handle)
723 : {
724 0 : struct input_dev *dev = handle->dev;
725 :
726 0 : mutex_lock(&dev->mutex);
727 :
728 0 : __input_release_device(handle);
729 :
730 0 : if (!dev->inhibited && !--dev->users) {
731 0 : if (dev->poller)
732 0 : input_dev_poller_stop(dev->poller);
733 0 : if (dev->close)
734 0 : dev->close(dev);
735 : }
736 :
737 0 : if (!--handle->open) {
738 : /*
739 : * synchronize_rcu() makes sure that input_pass_event()
740 : * completed and that no more input events are delivered
741 : * through this handle
742 : */
743 0 : synchronize_rcu();
744 : }
745 :
746 0 : mutex_unlock(&dev->mutex);
747 0 : }
748 : EXPORT_SYMBOL(input_close_device);
749 :
750 : /*
751 : * Simulate keyup events for all keys that are marked as pressed.
752 : * The function must be called with dev->event_lock held.
753 : */
754 0 : static void input_dev_release_keys(struct input_dev *dev)
755 : {
756 0 : bool need_sync = false;
757 : int code;
758 :
759 0 : if (is_event_supported(EV_KEY, dev->evbit, EV_MAX)) {
760 0 : for_each_set_bit(code, dev->key, KEY_CNT) {
761 0 : input_pass_event(dev, EV_KEY, code, 0);
762 0 : need_sync = true;
763 : }
764 :
765 0 : if (need_sync)
766 : input_pass_event(dev, EV_SYN, SYN_REPORT, 1);
767 :
768 0 : memset(dev->key, 0, sizeof(dev->key));
769 : }
770 0 : }
771 :
772 : /*
773 : * Prepare device for unregistering
774 : */
775 0 : static void input_disconnect_device(struct input_dev *dev)
776 : {
777 : struct input_handle *handle;
778 :
779 : /*
780 : * Mark device as going away. Note that we take dev->mutex here
781 : * not to protect access to dev->going_away but rather to ensure
782 : * that there are no threads in the middle of input_open_device()
783 : */
784 0 : mutex_lock(&dev->mutex);
785 0 : dev->going_away = true;
786 0 : mutex_unlock(&dev->mutex);
787 :
788 0 : spin_lock_irq(&dev->event_lock);
789 :
790 : /*
791 : * Simulate keyup events for all pressed keys so that handlers
792 : * are not left with "stuck" keys. The driver may continue
793 : * generate events even after we done here but they will not
794 : * reach any handlers.
795 : */
796 0 : input_dev_release_keys(dev);
797 :
798 0 : list_for_each_entry(handle, &dev->h_list, d_node)
799 0 : handle->open = 0;
800 :
801 0 : spin_unlock_irq(&dev->event_lock);
802 0 : }
803 :
804 : /**
805 : * input_scancode_to_scalar() - converts scancode in &struct input_keymap_entry
806 : * @ke: keymap entry containing scancode to be converted.
807 : * @scancode: pointer to the location where converted scancode should
808 : * be stored.
809 : *
810 : * This function is used to convert scancode stored in &struct keymap_entry
811 : * into scalar form understood by legacy keymap handling methods. These
812 : * methods expect scancodes to be represented as 'unsigned int'.
813 : */
814 0 : int input_scancode_to_scalar(const struct input_keymap_entry *ke,
815 : unsigned int *scancode)
816 : {
817 0 : switch (ke->len) {
818 : case 1:
819 0 : *scancode = *((u8 *)ke->scancode);
820 0 : break;
821 :
822 : case 2:
823 0 : *scancode = *((u16 *)ke->scancode);
824 0 : break;
825 :
826 : case 4:
827 0 : *scancode = *((u32 *)ke->scancode);
828 0 : break;
829 :
830 : default:
831 : return -EINVAL;
832 : }
833 :
834 : return 0;
835 : }
836 : EXPORT_SYMBOL(input_scancode_to_scalar);
837 :
838 : /*
839 : * Those routines handle the default case where no [gs]etkeycode() is
840 : * defined. In this case, an array indexed by the scancode is used.
841 : */
842 :
843 : static unsigned int input_fetch_keycode(struct input_dev *dev,
844 : unsigned int index)
845 : {
846 0 : switch (dev->keycodesize) {
847 : case 1:
848 0 : return ((u8 *)dev->keycode)[index];
849 :
850 : case 2:
851 0 : return ((u16 *)dev->keycode)[index];
852 :
853 : default:
854 0 : return ((u32 *)dev->keycode)[index];
855 : }
856 : }
857 :
858 0 : static int input_default_getkeycode(struct input_dev *dev,
859 : struct input_keymap_entry *ke)
860 : {
861 : unsigned int index;
862 : int error;
863 :
864 0 : if (!dev->keycodesize)
865 : return -EINVAL;
866 :
867 0 : if (ke->flags & INPUT_KEYMAP_BY_INDEX)
868 0 : index = ke->index;
869 : else {
870 0 : error = input_scancode_to_scalar(ke, &index);
871 0 : if (error)
872 : return error;
873 : }
874 :
875 0 : if (index >= dev->keycodemax)
876 : return -EINVAL;
877 :
878 0 : ke->keycode = input_fetch_keycode(dev, index);
879 0 : ke->index = index;
880 0 : ke->len = sizeof(index);
881 0 : memcpy(ke->scancode, &index, sizeof(index));
882 :
883 0 : return 0;
884 : }
885 :
886 0 : static int input_default_setkeycode(struct input_dev *dev,
887 : const struct input_keymap_entry *ke,
888 : unsigned int *old_keycode)
889 : {
890 : unsigned int index;
891 : int error;
892 : int i;
893 :
894 0 : if (!dev->keycodesize)
895 : return -EINVAL;
896 :
897 0 : if (ke->flags & INPUT_KEYMAP_BY_INDEX) {
898 0 : index = ke->index;
899 : } else {
900 0 : error = input_scancode_to_scalar(ke, &index);
901 0 : if (error)
902 : return error;
903 : }
904 :
905 0 : if (index >= dev->keycodemax)
906 : return -EINVAL;
907 :
908 0 : if (dev->keycodesize < sizeof(ke->keycode) &&
909 0 : (ke->keycode >> (dev->keycodesize * 8)))
910 : return -EINVAL;
911 :
912 0 : switch (dev->keycodesize) {
913 : case 1: {
914 0 : u8 *k = (u8 *)dev->keycode;
915 0 : *old_keycode = k[index];
916 0 : k[index] = ke->keycode;
917 0 : break;
918 : }
919 : case 2: {
920 0 : u16 *k = (u16 *)dev->keycode;
921 0 : *old_keycode = k[index];
922 0 : k[index] = ke->keycode;
923 0 : break;
924 : }
925 : default: {
926 0 : u32 *k = (u32 *)dev->keycode;
927 0 : *old_keycode = k[index];
928 0 : k[index] = ke->keycode;
929 0 : break;
930 : }
931 : }
932 :
933 0 : if (*old_keycode <= KEY_MAX) {
934 0 : __clear_bit(*old_keycode, dev->keybit);
935 0 : for (i = 0; i < dev->keycodemax; i++) {
936 0 : if (input_fetch_keycode(dev, i) == *old_keycode) {
937 0 : __set_bit(*old_keycode, dev->keybit);
938 : /* Setting the bit twice is useless, so break */
939 : break;
940 : }
941 : }
942 : }
943 :
944 0 : __set_bit(ke->keycode, dev->keybit);
945 0 : return 0;
946 : }
947 :
948 : /**
949 : * input_get_keycode - retrieve keycode currently mapped to a given scancode
950 : * @dev: input device which keymap is being queried
951 : * @ke: keymap entry
952 : *
953 : * This function should be called by anyone interested in retrieving current
954 : * keymap. Presently evdev handlers use it.
955 : */
956 0 : int input_get_keycode(struct input_dev *dev, struct input_keymap_entry *ke)
957 : {
958 : unsigned long flags;
959 : int retval;
960 :
961 0 : spin_lock_irqsave(&dev->event_lock, flags);
962 0 : retval = dev->getkeycode(dev, ke);
963 0 : spin_unlock_irqrestore(&dev->event_lock, flags);
964 :
965 0 : return retval;
966 : }
967 : EXPORT_SYMBOL(input_get_keycode);
968 :
969 : /**
970 : * input_set_keycode - attribute a keycode to a given scancode
971 : * @dev: input device which keymap is being updated
972 : * @ke: new keymap entry
973 : *
974 : * This function should be called by anyone needing to update current
975 : * keymap. Presently keyboard and evdev handlers use it.
976 : */
977 0 : int input_set_keycode(struct input_dev *dev,
978 : const struct input_keymap_entry *ke)
979 : {
980 : unsigned long flags;
981 : unsigned int old_keycode;
982 : int retval;
983 :
984 0 : if (ke->keycode > KEY_MAX)
985 : return -EINVAL;
986 :
987 0 : spin_lock_irqsave(&dev->event_lock, flags);
988 :
989 0 : retval = dev->setkeycode(dev, ke, &old_keycode);
990 0 : if (retval)
991 : goto out;
992 :
993 : /* Make sure KEY_RESERVED did not get enabled. */
994 0 : __clear_bit(KEY_RESERVED, dev->keybit);
995 :
996 : /*
997 : * Simulate keyup event if keycode is not present
998 : * in the keymap anymore
999 : */
1000 0 : if (old_keycode > KEY_MAX) {
1001 0 : dev_warn(dev->dev.parent ?: &dev->dev,
1002 : "%s: got too big old keycode %#x\n",
1003 : __func__, old_keycode);
1004 0 : } else if (test_bit(EV_KEY, dev->evbit) &&
1005 0 : !is_event_supported(old_keycode, dev->keybit, KEY_MAX) &&
1006 0 : __test_and_clear_bit(old_keycode, dev->key)) {
1007 0 : struct input_value vals[] = {
1008 : { EV_KEY, old_keycode, 0 },
1009 : input_value_sync
1010 : };
1011 :
1012 0 : input_pass_values(dev, vals, ARRAY_SIZE(vals));
1013 : }
1014 :
1015 : out:
1016 0 : spin_unlock_irqrestore(&dev->event_lock, flags);
1017 :
1018 0 : return retval;
1019 : }
1020 : EXPORT_SYMBOL(input_set_keycode);
1021 :
1022 0 : bool input_match_device_id(const struct input_dev *dev,
1023 : const struct input_device_id *id)
1024 : {
1025 0 : if (id->flags & INPUT_DEVICE_ID_MATCH_BUS)
1026 0 : if (id->bustype != dev->id.bustype)
1027 : return false;
1028 :
1029 0 : if (id->flags & INPUT_DEVICE_ID_MATCH_VENDOR)
1030 0 : if (id->vendor != dev->id.vendor)
1031 : return false;
1032 :
1033 0 : if (id->flags & INPUT_DEVICE_ID_MATCH_PRODUCT)
1034 0 : if (id->product != dev->id.product)
1035 : return false;
1036 :
1037 0 : if (id->flags & INPUT_DEVICE_ID_MATCH_VERSION)
1038 0 : if (id->version != dev->id.version)
1039 : return false;
1040 :
1041 0 : if (!bitmap_subset(id->evbit, dev->evbit, EV_MAX) ||
1042 0 : !bitmap_subset(id->keybit, dev->keybit, KEY_MAX) ||
1043 0 : !bitmap_subset(id->relbit, dev->relbit, REL_MAX) ||
1044 0 : !bitmap_subset(id->absbit, dev->absbit, ABS_MAX) ||
1045 0 : !bitmap_subset(id->mscbit, dev->mscbit, MSC_MAX) ||
1046 0 : !bitmap_subset(id->ledbit, dev->ledbit, LED_MAX) ||
1047 0 : !bitmap_subset(id->sndbit, dev->sndbit, SND_MAX) ||
1048 0 : !bitmap_subset(id->ffbit, dev->ffbit, FF_MAX) ||
1049 0 : !bitmap_subset(id->swbit, dev->swbit, SW_MAX) ||
1050 0 : !bitmap_subset(id->propbit, dev->propbit, INPUT_PROP_MAX)) {
1051 : return false;
1052 : }
1053 :
1054 : return true;
1055 : }
1056 : EXPORT_SYMBOL(input_match_device_id);
1057 :
1058 0 : static const struct input_device_id *input_match_device(struct input_handler *handler,
1059 : struct input_dev *dev)
1060 : {
1061 : const struct input_device_id *id;
1062 :
1063 0 : for (id = handler->id_table; id->flags || id->driver_info; id++) {
1064 0 : if (input_match_device_id(dev, id) &&
1065 0 : (!handler->match || handler->match(handler, dev))) {
1066 : return id;
1067 : }
1068 : }
1069 :
1070 : return NULL;
1071 : }
1072 :
1073 0 : static int input_attach_handler(struct input_dev *dev, struct input_handler *handler)
1074 : {
1075 : const struct input_device_id *id;
1076 : int error;
1077 :
1078 0 : id = input_match_device(handler, dev);
1079 0 : if (!id)
1080 : return -ENODEV;
1081 :
1082 0 : error = handler->connect(handler, dev, id);
1083 0 : if (error && error != -ENODEV)
1084 0 : pr_err("failed to attach handler %s to device %s, error: %d\n",
1085 : handler->name, kobject_name(&dev->dev.kobj), error);
1086 :
1087 : return error;
1088 : }
1089 :
1090 : #ifdef CONFIG_COMPAT
1091 :
1092 : static int input_bits_to_string(char *buf, int buf_size,
1093 : unsigned long bits, bool skip_empty)
1094 : {
1095 : int len = 0;
1096 :
1097 : if (in_compat_syscall()) {
1098 : u32 dword = bits >> 32;
1099 : if (dword || !skip_empty)
1100 : len += snprintf(buf, buf_size, "%x ", dword);
1101 :
1102 : dword = bits & 0xffffffffUL;
1103 : if (dword || !skip_empty || len)
1104 : len += snprintf(buf + len, max(buf_size - len, 0),
1105 : "%x", dword);
1106 : } else {
1107 : if (bits || !skip_empty)
1108 : len += snprintf(buf, buf_size, "%lx", bits);
1109 : }
1110 :
1111 : return len;
1112 : }
1113 :
1114 : #else /* !CONFIG_COMPAT */
1115 :
1116 : static int input_bits_to_string(char *buf, int buf_size,
1117 : unsigned long bits, bool skip_empty)
1118 : {
1119 0 : return bits || !skip_empty ?
1120 0 : snprintf(buf, buf_size, "%lx", bits) : 0;
1121 : }
1122 :
1123 : #endif
1124 :
1125 : #ifdef CONFIG_PROC_FS
1126 :
1127 : static struct proc_dir_entry *proc_bus_input_dir;
1128 : static DECLARE_WAIT_QUEUE_HEAD(input_devices_poll_wait);
1129 : static int input_devices_state;
1130 :
1131 : static inline void input_wakeup_procfs_readers(void)
1132 : {
1133 0 : input_devices_state++;
1134 0 : wake_up(&input_devices_poll_wait);
1135 : }
1136 :
1137 0 : static __poll_t input_proc_devices_poll(struct file *file, poll_table *wait)
1138 : {
1139 0 : poll_wait(file, &input_devices_poll_wait, wait);
1140 0 : if (file->f_version != input_devices_state) {
1141 0 : file->f_version = input_devices_state;
1142 0 : return EPOLLIN | EPOLLRDNORM;
1143 : }
1144 :
1145 : return 0;
1146 : }
1147 :
1148 : union input_seq_state {
1149 : struct {
1150 : unsigned short pos;
1151 : bool mutex_acquired;
1152 : };
1153 : void *p;
1154 : };
1155 :
1156 0 : static void *input_devices_seq_start(struct seq_file *seq, loff_t *pos)
1157 : {
1158 0 : union input_seq_state *state = (union input_seq_state *)&seq->private;
1159 : int error;
1160 :
1161 : /* We need to fit into seq->private pointer */
1162 : BUILD_BUG_ON(sizeof(union input_seq_state) != sizeof(seq->private));
1163 :
1164 0 : error = mutex_lock_interruptible(&input_mutex);
1165 0 : if (error) {
1166 0 : state->mutex_acquired = false;
1167 0 : return ERR_PTR(error);
1168 : }
1169 :
1170 0 : state->mutex_acquired = true;
1171 :
1172 0 : return seq_list_start(&input_dev_list, *pos);
1173 : }
1174 :
1175 0 : static void *input_devices_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1176 : {
1177 0 : return seq_list_next(v, &input_dev_list, pos);
1178 : }
1179 :
1180 0 : static void input_seq_stop(struct seq_file *seq, void *v)
1181 : {
1182 0 : union input_seq_state *state = (union input_seq_state *)&seq->private;
1183 :
1184 0 : if (state->mutex_acquired)
1185 0 : mutex_unlock(&input_mutex);
1186 0 : }
1187 :
1188 0 : static void input_seq_print_bitmap(struct seq_file *seq, const char *name,
1189 : unsigned long *bitmap, int max)
1190 : {
1191 : int i;
1192 0 : bool skip_empty = true;
1193 : char buf[18];
1194 :
1195 0 : seq_printf(seq, "B: %s=", name);
1196 :
1197 0 : for (i = BITS_TO_LONGS(max) - 1; i >= 0; i--) {
1198 0 : if (input_bits_to_string(buf, sizeof(buf),
1199 0 : bitmap[i], skip_empty)) {
1200 0 : skip_empty = false;
1201 0 : seq_printf(seq, "%s%s", buf, i > 0 ? " " : "");
1202 : }
1203 : }
1204 :
1205 : /*
1206 : * If no output was produced print a single 0.
1207 : */
1208 0 : if (skip_empty)
1209 0 : seq_putc(seq, '0');
1210 :
1211 0 : seq_putc(seq, '\n');
1212 0 : }
1213 :
1214 0 : static int input_devices_seq_show(struct seq_file *seq, void *v)
1215 : {
1216 0 : struct input_dev *dev = container_of(v, struct input_dev, node);
1217 0 : const char *path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);
1218 : struct input_handle *handle;
1219 :
1220 0 : seq_printf(seq, "I: Bus=%04x Vendor=%04x Product=%04x Version=%04x\n",
1221 0 : dev->id.bustype, dev->id.vendor, dev->id.product, dev->id.version);
1222 :
1223 0 : seq_printf(seq, "N: Name=\"%s\"\n", dev->name ? dev->name : "");
1224 0 : seq_printf(seq, "P: Phys=%s\n", dev->phys ? dev->phys : "");
1225 0 : seq_printf(seq, "S: Sysfs=%s\n", path ? path : "");
1226 0 : seq_printf(seq, "U: Uniq=%s\n", dev->uniq ? dev->uniq : "");
1227 0 : seq_puts(seq, "H: Handlers=");
1228 :
1229 0 : list_for_each_entry(handle, &dev->h_list, d_node)
1230 0 : seq_printf(seq, "%s ", handle->name);
1231 0 : seq_putc(seq, '\n');
1232 :
1233 0 : input_seq_print_bitmap(seq, "PROP", dev->propbit, INPUT_PROP_MAX);
1234 :
1235 0 : input_seq_print_bitmap(seq, "EV", dev->evbit, EV_MAX);
1236 0 : if (test_bit(EV_KEY, dev->evbit))
1237 0 : input_seq_print_bitmap(seq, "KEY", dev->keybit, KEY_MAX);
1238 0 : if (test_bit(EV_REL, dev->evbit))
1239 0 : input_seq_print_bitmap(seq, "REL", dev->relbit, REL_MAX);
1240 0 : if (test_bit(EV_ABS, dev->evbit))
1241 0 : input_seq_print_bitmap(seq, "ABS", dev->absbit, ABS_MAX);
1242 0 : if (test_bit(EV_MSC, dev->evbit))
1243 0 : input_seq_print_bitmap(seq, "MSC", dev->mscbit, MSC_MAX);
1244 0 : if (test_bit(EV_LED, dev->evbit))
1245 0 : input_seq_print_bitmap(seq, "LED", dev->ledbit, LED_MAX);
1246 0 : if (test_bit(EV_SND, dev->evbit))
1247 0 : input_seq_print_bitmap(seq, "SND", dev->sndbit, SND_MAX);
1248 0 : if (test_bit(EV_FF, dev->evbit))
1249 0 : input_seq_print_bitmap(seq, "FF", dev->ffbit, FF_MAX);
1250 0 : if (test_bit(EV_SW, dev->evbit))
1251 0 : input_seq_print_bitmap(seq, "SW", dev->swbit, SW_MAX);
1252 :
1253 0 : seq_putc(seq, '\n');
1254 :
1255 0 : kfree(path);
1256 0 : return 0;
1257 : }
1258 :
1259 : static const struct seq_operations input_devices_seq_ops = {
1260 : .start = input_devices_seq_start,
1261 : .next = input_devices_seq_next,
1262 : .stop = input_seq_stop,
1263 : .show = input_devices_seq_show,
1264 : };
1265 :
1266 0 : static int input_proc_devices_open(struct inode *inode, struct file *file)
1267 : {
1268 0 : return seq_open(file, &input_devices_seq_ops);
1269 : }
1270 :
1271 : static const struct proc_ops input_devices_proc_ops = {
1272 : .proc_open = input_proc_devices_open,
1273 : .proc_poll = input_proc_devices_poll,
1274 : .proc_read = seq_read,
1275 : .proc_lseek = seq_lseek,
1276 : .proc_release = seq_release,
1277 : };
1278 :
1279 0 : static void *input_handlers_seq_start(struct seq_file *seq, loff_t *pos)
1280 : {
1281 0 : union input_seq_state *state = (union input_seq_state *)&seq->private;
1282 : int error;
1283 :
1284 : /* We need to fit into seq->private pointer */
1285 : BUILD_BUG_ON(sizeof(union input_seq_state) != sizeof(seq->private));
1286 :
1287 0 : error = mutex_lock_interruptible(&input_mutex);
1288 0 : if (error) {
1289 0 : state->mutex_acquired = false;
1290 0 : return ERR_PTR(error);
1291 : }
1292 :
1293 0 : state->mutex_acquired = true;
1294 0 : state->pos = *pos;
1295 :
1296 0 : return seq_list_start(&input_handler_list, *pos);
1297 : }
1298 :
1299 0 : static void *input_handlers_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1300 : {
1301 0 : union input_seq_state *state = (union input_seq_state *)&seq->private;
1302 :
1303 0 : state->pos = *pos + 1;
1304 0 : return seq_list_next(v, &input_handler_list, pos);
1305 : }
1306 :
1307 0 : static int input_handlers_seq_show(struct seq_file *seq, void *v)
1308 : {
1309 0 : struct input_handler *handler = container_of(v, struct input_handler, node);
1310 0 : union input_seq_state *state = (union input_seq_state *)&seq->private;
1311 :
1312 0 : seq_printf(seq, "N: Number=%u Name=%s", state->pos, handler->name);
1313 0 : if (handler->filter)
1314 0 : seq_puts(seq, " (filter)");
1315 0 : if (handler->legacy_minors)
1316 0 : seq_printf(seq, " Minor=%d", handler->minor);
1317 0 : seq_putc(seq, '\n');
1318 :
1319 0 : return 0;
1320 : }
1321 :
1322 : static const struct seq_operations input_handlers_seq_ops = {
1323 : .start = input_handlers_seq_start,
1324 : .next = input_handlers_seq_next,
1325 : .stop = input_seq_stop,
1326 : .show = input_handlers_seq_show,
1327 : };
1328 :
1329 0 : static int input_proc_handlers_open(struct inode *inode, struct file *file)
1330 : {
1331 0 : return seq_open(file, &input_handlers_seq_ops);
1332 : }
1333 :
1334 : static const struct proc_ops input_handlers_proc_ops = {
1335 : .proc_open = input_proc_handlers_open,
1336 : .proc_read = seq_read,
1337 : .proc_lseek = seq_lseek,
1338 : .proc_release = seq_release,
1339 : };
1340 :
1341 1 : static int __init input_proc_init(void)
1342 : {
1343 : struct proc_dir_entry *entry;
1344 :
1345 1 : proc_bus_input_dir = proc_mkdir("bus/input", NULL);
1346 1 : if (!proc_bus_input_dir)
1347 : return -ENOMEM;
1348 :
1349 1 : entry = proc_create("devices", 0, proc_bus_input_dir,
1350 : &input_devices_proc_ops);
1351 1 : if (!entry)
1352 : goto fail1;
1353 :
1354 1 : entry = proc_create("handlers", 0, proc_bus_input_dir,
1355 : &input_handlers_proc_ops);
1356 1 : if (!entry)
1357 : goto fail2;
1358 :
1359 : return 0;
1360 :
1361 0 : fail2: remove_proc_entry("devices", proc_bus_input_dir);
1362 0 : fail1: remove_proc_entry("bus/input", NULL);
1363 0 : return -ENOMEM;
1364 : }
1365 :
1366 0 : static void input_proc_exit(void)
1367 : {
1368 0 : remove_proc_entry("devices", proc_bus_input_dir);
1369 0 : remove_proc_entry("handlers", proc_bus_input_dir);
1370 0 : remove_proc_entry("bus/input", NULL);
1371 0 : }
1372 :
1373 : #else /* !CONFIG_PROC_FS */
1374 : static inline void input_wakeup_procfs_readers(void) { }
1375 : static inline int input_proc_init(void) { return 0; }
1376 : static inline void input_proc_exit(void) { }
1377 : #endif
1378 :
1379 : #define INPUT_DEV_STRING_ATTR_SHOW(name) \
1380 : static ssize_t input_dev_show_##name(struct device *dev, \
1381 : struct device_attribute *attr, \
1382 : char *buf) \
1383 : { \
1384 : struct input_dev *input_dev = to_input_dev(dev); \
1385 : \
1386 : return scnprintf(buf, PAGE_SIZE, "%s\n", \
1387 : input_dev->name ? input_dev->name : ""); \
1388 : } \
1389 : static DEVICE_ATTR(name, S_IRUGO, input_dev_show_##name, NULL)
1390 :
1391 0 : INPUT_DEV_STRING_ATTR_SHOW(name);
1392 0 : INPUT_DEV_STRING_ATTR_SHOW(phys);
1393 0 : INPUT_DEV_STRING_ATTR_SHOW(uniq);
1394 :
1395 0 : static int input_print_modalias_bits(char *buf, int size,
1396 : char name, unsigned long *bm,
1397 : unsigned int min_bit, unsigned int max_bit)
1398 : {
1399 0 : int len = 0, i;
1400 :
1401 0 : len += snprintf(buf, max(size, 0), "%c", name);
1402 0 : for (i = min_bit; i < max_bit; i++)
1403 0 : if (bm[BIT_WORD(i)] & BIT_MASK(i))
1404 0 : len += snprintf(buf + len, max(size - len, 0), "%X,", i);
1405 0 : return len;
1406 : }
1407 :
1408 0 : static int input_print_modalias(char *buf, int size, struct input_dev *id,
1409 : int add_cr)
1410 : {
1411 : int len;
1412 :
1413 0 : len = snprintf(buf, max(size, 0),
1414 : "input:b%04Xv%04Xp%04Xe%04X-",
1415 0 : id->id.bustype, id->id.vendor,
1416 0 : id->id.product, id->id.version);
1417 :
1418 0 : len += input_print_modalias_bits(buf + len, size - len,
1419 0 : 'e', id->evbit, 0, EV_MAX);
1420 0 : len += input_print_modalias_bits(buf + len, size - len,
1421 0 : 'k', id->keybit, KEY_MIN_INTERESTING, KEY_MAX);
1422 0 : len += input_print_modalias_bits(buf + len, size - len,
1423 0 : 'r', id->relbit, 0, REL_MAX);
1424 0 : len += input_print_modalias_bits(buf + len, size - len,
1425 0 : 'a', id->absbit, 0, ABS_MAX);
1426 0 : len += input_print_modalias_bits(buf + len, size - len,
1427 0 : 'm', id->mscbit, 0, MSC_MAX);
1428 0 : len += input_print_modalias_bits(buf + len, size - len,
1429 0 : 'l', id->ledbit, 0, LED_MAX);
1430 0 : len += input_print_modalias_bits(buf + len, size - len,
1431 0 : 's', id->sndbit, 0, SND_MAX);
1432 0 : len += input_print_modalias_bits(buf + len, size - len,
1433 0 : 'f', id->ffbit, 0, FF_MAX);
1434 0 : len += input_print_modalias_bits(buf + len, size - len,
1435 0 : 'w', id->swbit, 0, SW_MAX);
1436 :
1437 0 : if (add_cr)
1438 0 : len += snprintf(buf + len, max(size - len, 0), "\n");
1439 :
1440 0 : return len;
1441 : }
1442 :
1443 0 : static ssize_t input_dev_show_modalias(struct device *dev,
1444 : struct device_attribute *attr,
1445 : char *buf)
1446 : {
1447 0 : struct input_dev *id = to_input_dev(dev);
1448 : ssize_t len;
1449 :
1450 0 : len = input_print_modalias(buf, PAGE_SIZE, id, 1);
1451 :
1452 0 : return min_t(int, len, PAGE_SIZE);
1453 : }
1454 : static DEVICE_ATTR(modalias, S_IRUGO, input_dev_show_modalias, NULL);
1455 :
1456 : static int input_print_bitmap(char *buf, int buf_size, unsigned long *bitmap,
1457 : int max, int add_cr);
1458 :
1459 0 : static ssize_t input_dev_show_properties(struct device *dev,
1460 : struct device_attribute *attr,
1461 : char *buf)
1462 : {
1463 0 : struct input_dev *input_dev = to_input_dev(dev);
1464 0 : int len = input_print_bitmap(buf, PAGE_SIZE, input_dev->propbit,
1465 : INPUT_PROP_MAX, true);
1466 0 : return min_t(int, len, PAGE_SIZE);
1467 : }
1468 : static DEVICE_ATTR(properties, S_IRUGO, input_dev_show_properties, NULL);
1469 :
1470 : static int input_inhibit_device(struct input_dev *dev);
1471 : static int input_uninhibit_device(struct input_dev *dev);
1472 :
1473 0 : static ssize_t inhibited_show(struct device *dev,
1474 : struct device_attribute *attr,
1475 : char *buf)
1476 : {
1477 0 : struct input_dev *input_dev = to_input_dev(dev);
1478 :
1479 0 : return scnprintf(buf, PAGE_SIZE, "%d\n", input_dev->inhibited);
1480 : }
1481 :
1482 0 : static ssize_t inhibited_store(struct device *dev,
1483 : struct device_attribute *attr, const char *buf,
1484 : size_t len)
1485 : {
1486 0 : struct input_dev *input_dev = to_input_dev(dev);
1487 : ssize_t rv;
1488 : bool inhibited;
1489 :
1490 0 : if (strtobool(buf, &inhibited))
1491 : return -EINVAL;
1492 :
1493 0 : if (inhibited)
1494 0 : rv = input_inhibit_device(input_dev);
1495 : else
1496 0 : rv = input_uninhibit_device(input_dev);
1497 :
1498 0 : if (rv != 0)
1499 : return rv;
1500 :
1501 0 : return len;
1502 : }
1503 :
1504 : static DEVICE_ATTR_RW(inhibited);
1505 :
1506 : static struct attribute *input_dev_attrs[] = {
1507 : &dev_attr_name.attr,
1508 : &dev_attr_phys.attr,
1509 : &dev_attr_uniq.attr,
1510 : &dev_attr_modalias.attr,
1511 : &dev_attr_properties.attr,
1512 : &dev_attr_inhibited.attr,
1513 : NULL
1514 : };
1515 :
1516 : static const struct attribute_group input_dev_attr_group = {
1517 : .attrs = input_dev_attrs,
1518 : };
1519 :
1520 : #define INPUT_DEV_ID_ATTR(name) \
1521 : static ssize_t input_dev_show_id_##name(struct device *dev, \
1522 : struct device_attribute *attr, \
1523 : char *buf) \
1524 : { \
1525 : struct input_dev *input_dev = to_input_dev(dev); \
1526 : return scnprintf(buf, PAGE_SIZE, "%04x\n", input_dev->id.name); \
1527 : } \
1528 : static DEVICE_ATTR(name, S_IRUGO, input_dev_show_id_##name, NULL)
1529 :
1530 0 : INPUT_DEV_ID_ATTR(bustype);
1531 0 : INPUT_DEV_ID_ATTR(vendor);
1532 0 : INPUT_DEV_ID_ATTR(product);
1533 0 : INPUT_DEV_ID_ATTR(version);
1534 :
1535 : static struct attribute *input_dev_id_attrs[] = {
1536 : &dev_attr_bustype.attr,
1537 : &dev_attr_vendor.attr,
1538 : &dev_attr_product.attr,
1539 : &dev_attr_version.attr,
1540 : NULL
1541 : };
1542 :
1543 : static const struct attribute_group input_dev_id_attr_group = {
1544 : .name = "id",
1545 : .attrs = input_dev_id_attrs,
1546 : };
1547 :
1548 0 : static int input_print_bitmap(char *buf, int buf_size, unsigned long *bitmap,
1549 : int max, int add_cr)
1550 : {
1551 : int i;
1552 0 : int len = 0;
1553 0 : bool skip_empty = true;
1554 :
1555 0 : for (i = BITS_TO_LONGS(max) - 1; i >= 0; i--) {
1556 0 : len += input_bits_to_string(buf + len, max(buf_size - len, 0),
1557 0 : bitmap[i], skip_empty);
1558 0 : if (len) {
1559 0 : skip_empty = false;
1560 0 : if (i > 0)
1561 0 : len += snprintf(buf + len, max(buf_size - len, 0), " ");
1562 : }
1563 : }
1564 :
1565 : /*
1566 : * If no output was produced print a single 0.
1567 : */
1568 0 : if (len == 0)
1569 0 : len = snprintf(buf, buf_size, "%d", 0);
1570 :
1571 0 : if (add_cr)
1572 0 : len += snprintf(buf + len, max(buf_size - len, 0), "\n");
1573 :
1574 0 : return len;
1575 : }
1576 :
1577 : #define INPUT_DEV_CAP_ATTR(ev, bm) \
1578 : static ssize_t input_dev_show_cap_##bm(struct device *dev, \
1579 : struct device_attribute *attr, \
1580 : char *buf) \
1581 : { \
1582 : struct input_dev *input_dev = to_input_dev(dev); \
1583 : int len = input_print_bitmap(buf, PAGE_SIZE, \
1584 : input_dev->bm##bit, ev##_MAX, \
1585 : true); \
1586 : return min_t(int, len, PAGE_SIZE); \
1587 : } \
1588 : static DEVICE_ATTR(bm, S_IRUGO, input_dev_show_cap_##bm, NULL)
1589 :
1590 0 : INPUT_DEV_CAP_ATTR(EV, ev);
1591 0 : INPUT_DEV_CAP_ATTR(KEY, key);
1592 0 : INPUT_DEV_CAP_ATTR(REL, rel);
1593 0 : INPUT_DEV_CAP_ATTR(ABS, abs);
1594 0 : INPUT_DEV_CAP_ATTR(MSC, msc);
1595 0 : INPUT_DEV_CAP_ATTR(LED, led);
1596 0 : INPUT_DEV_CAP_ATTR(SND, snd);
1597 0 : INPUT_DEV_CAP_ATTR(FF, ff);
1598 0 : INPUT_DEV_CAP_ATTR(SW, sw);
1599 :
1600 : static struct attribute *input_dev_caps_attrs[] = {
1601 : &dev_attr_ev.attr,
1602 : &dev_attr_key.attr,
1603 : &dev_attr_rel.attr,
1604 : &dev_attr_abs.attr,
1605 : &dev_attr_msc.attr,
1606 : &dev_attr_led.attr,
1607 : &dev_attr_snd.attr,
1608 : &dev_attr_ff.attr,
1609 : &dev_attr_sw.attr,
1610 : NULL
1611 : };
1612 :
1613 : static const struct attribute_group input_dev_caps_attr_group = {
1614 : .name = "capabilities",
1615 : .attrs = input_dev_caps_attrs,
1616 : };
1617 :
1618 : static const struct attribute_group *input_dev_attr_groups[] = {
1619 : &input_dev_attr_group,
1620 : &input_dev_id_attr_group,
1621 : &input_dev_caps_attr_group,
1622 : &input_poller_attribute_group,
1623 : NULL
1624 : };
1625 :
1626 0 : static void input_dev_release(struct device *device)
1627 : {
1628 0 : struct input_dev *dev = to_input_dev(device);
1629 :
1630 0 : input_ff_destroy(dev);
1631 0 : input_mt_destroy_slots(dev);
1632 0 : kfree(dev->poller);
1633 0 : kfree(dev->absinfo);
1634 0 : kfree(dev->vals);
1635 0 : kfree(dev);
1636 :
1637 0 : module_put(THIS_MODULE);
1638 0 : }
1639 :
1640 : /*
1641 : * Input uevent interface - loading event handlers based on
1642 : * device bitfields.
1643 : */
1644 0 : static int input_add_uevent_bm_var(struct kobj_uevent_env *env,
1645 : const char *name, unsigned long *bitmap, int max)
1646 : {
1647 : int len;
1648 :
1649 0 : if (add_uevent_var(env, "%s", name))
1650 : return -ENOMEM;
1651 :
1652 0 : len = input_print_bitmap(&env->buf[env->buflen - 1],
1653 0 : sizeof(env->buf) - env->buflen,
1654 : bitmap, max, false);
1655 0 : if (len >= (sizeof(env->buf) - env->buflen))
1656 : return -ENOMEM;
1657 :
1658 0 : env->buflen += len;
1659 0 : return 0;
1660 : }
1661 :
1662 0 : static int input_add_uevent_modalias_var(struct kobj_uevent_env *env,
1663 : struct input_dev *dev)
1664 : {
1665 : int len;
1666 :
1667 0 : if (add_uevent_var(env, "MODALIAS="))
1668 : return -ENOMEM;
1669 :
1670 0 : len = input_print_modalias(&env->buf[env->buflen - 1],
1671 0 : sizeof(env->buf) - env->buflen,
1672 : dev, 0);
1673 0 : if (len >= (sizeof(env->buf) - env->buflen))
1674 : return -ENOMEM;
1675 :
1676 0 : env->buflen += len;
1677 0 : return 0;
1678 : }
1679 :
1680 : #define INPUT_ADD_HOTPLUG_VAR(fmt, val...) \
1681 : do { \
1682 : int err = add_uevent_var(env, fmt, val); \
1683 : if (err) \
1684 : return err; \
1685 : } while (0)
1686 :
1687 : #define INPUT_ADD_HOTPLUG_BM_VAR(name, bm, max) \
1688 : do { \
1689 : int err = input_add_uevent_bm_var(env, name, bm, max); \
1690 : if (err) \
1691 : return err; \
1692 : } while (0)
1693 :
1694 : #define INPUT_ADD_HOTPLUG_MODALIAS_VAR(dev) \
1695 : do { \
1696 : int err = input_add_uevent_modalias_var(env, dev); \
1697 : if (err) \
1698 : return err; \
1699 : } while (0)
1700 :
1701 0 : static int input_dev_uevent(struct device *device, struct kobj_uevent_env *env)
1702 : {
1703 0 : struct input_dev *dev = to_input_dev(device);
1704 :
1705 0 : INPUT_ADD_HOTPLUG_VAR("PRODUCT=%x/%x/%x/%x",
1706 : dev->id.bustype, dev->id.vendor,
1707 : dev->id.product, dev->id.version);
1708 0 : if (dev->name)
1709 0 : INPUT_ADD_HOTPLUG_VAR("NAME=\"%s\"", dev->name);
1710 0 : if (dev->phys)
1711 0 : INPUT_ADD_HOTPLUG_VAR("PHYS=\"%s\"", dev->phys);
1712 0 : if (dev->uniq)
1713 0 : INPUT_ADD_HOTPLUG_VAR("UNIQ=\"%s\"", dev->uniq);
1714 :
1715 0 : INPUT_ADD_HOTPLUG_BM_VAR("PROP=", dev->propbit, INPUT_PROP_MAX);
1716 :
1717 0 : INPUT_ADD_HOTPLUG_BM_VAR("EV=", dev->evbit, EV_MAX);
1718 0 : if (test_bit(EV_KEY, dev->evbit))
1719 0 : INPUT_ADD_HOTPLUG_BM_VAR("KEY=", dev->keybit, KEY_MAX);
1720 0 : if (test_bit(EV_REL, dev->evbit))
1721 0 : INPUT_ADD_HOTPLUG_BM_VAR("REL=", dev->relbit, REL_MAX);
1722 0 : if (test_bit(EV_ABS, dev->evbit))
1723 0 : INPUT_ADD_HOTPLUG_BM_VAR("ABS=", dev->absbit, ABS_MAX);
1724 0 : if (test_bit(EV_MSC, dev->evbit))
1725 0 : INPUT_ADD_HOTPLUG_BM_VAR("MSC=", dev->mscbit, MSC_MAX);
1726 0 : if (test_bit(EV_LED, dev->evbit))
1727 0 : INPUT_ADD_HOTPLUG_BM_VAR("LED=", dev->ledbit, LED_MAX);
1728 0 : if (test_bit(EV_SND, dev->evbit))
1729 0 : INPUT_ADD_HOTPLUG_BM_VAR("SND=", dev->sndbit, SND_MAX);
1730 0 : if (test_bit(EV_FF, dev->evbit))
1731 0 : INPUT_ADD_HOTPLUG_BM_VAR("FF=", dev->ffbit, FF_MAX);
1732 0 : if (test_bit(EV_SW, dev->evbit))
1733 0 : INPUT_ADD_HOTPLUG_BM_VAR("SW=", dev->swbit, SW_MAX);
1734 :
1735 0 : INPUT_ADD_HOTPLUG_MODALIAS_VAR(dev);
1736 :
1737 0 : return 0;
1738 : }
1739 :
1740 : #define INPUT_DO_TOGGLE(dev, type, bits, on) \
1741 : do { \
1742 : int i; \
1743 : bool active; \
1744 : \
1745 : if (!test_bit(EV_##type, dev->evbit)) \
1746 : break; \
1747 : \
1748 : for_each_set_bit(i, dev->bits##bit, type##_CNT) { \
1749 : active = test_bit(i, dev->bits); \
1750 : if (!active && !on) \
1751 : continue; \
1752 : \
1753 : dev->event(dev, EV_##type, i, on ? active : 0); \
1754 : } \
1755 : } while (0)
1756 :
1757 0 : static void input_dev_toggle(struct input_dev *dev, bool activate)
1758 : {
1759 0 : if (!dev->event)
1760 : return;
1761 :
1762 0 : INPUT_DO_TOGGLE(dev, LED, led, activate);
1763 0 : INPUT_DO_TOGGLE(dev, SND, snd, activate);
1764 :
1765 0 : if (activate && test_bit(EV_REP, dev->evbit)) {
1766 0 : dev->event(dev, EV_REP, REP_PERIOD, dev->rep[REP_PERIOD]);
1767 0 : dev->event(dev, EV_REP, REP_DELAY, dev->rep[REP_DELAY]);
1768 : }
1769 : }
1770 :
1771 : /**
1772 : * input_reset_device() - reset/restore the state of input device
1773 : * @dev: input device whose state needs to be reset
1774 : *
1775 : * This function tries to reset the state of an opened input device and
1776 : * bring internal state and state if the hardware in sync with each other.
1777 : * We mark all keys as released, restore LED state, repeat rate, etc.
1778 : */
1779 0 : void input_reset_device(struct input_dev *dev)
1780 : {
1781 : unsigned long flags;
1782 :
1783 0 : mutex_lock(&dev->mutex);
1784 0 : spin_lock_irqsave(&dev->event_lock, flags);
1785 :
1786 0 : input_dev_toggle(dev, true);
1787 0 : input_dev_release_keys(dev);
1788 :
1789 0 : spin_unlock_irqrestore(&dev->event_lock, flags);
1790 0 : mutex_unlock(&dev->mutex);
1791 0 : }
1792 : EXPORT_SYMBOL(input_reset_device);
1793 :
1794 0 : static int input_inhibit_device(struct input_dev *dev)
1795 : {
1796 0 : int ret = 0;
1797 :
1798 0 : mutex_lock(&dev->mutex);
1799 :
1800 0 : if (dev->inhibited)
1801 : goto out;
1802 :
1803 0 : if (dev->users) {
1804 0 : if (dev->close)
1805 0 : dev->close(dev);
1806 0 : if (dev->poller)
1807 0 : input_dev_poller_stop(dev->poller);
1808 : }
1809 :
1810 0 : spin_lock_irq(&dev->event_lock);
1811 0 : input_dev_release_keys(dev);
1812 0 : input_dev_toggle(dev, false);
1813 0 : spin_unlock_irq(&dev->event_lock);
1814 :
1815 0 : dev->inhibited = true;
1816 :
1817 : out:
1818 0 : mutex_unlock(&dev->mutex);
1819 0 : return ret;
1820 : }
1821 :
1822 0 : static int input_uninhibit_device(struct input_dev *dev)
1823 : {
1824 0 : int ret = 0;
1825 :
1826 0 : mutex_lock(&dev->mutex);
1827 :
1828 0 : if (!dev->inhibited)
1829 : goto out;
1830 :
1831 0 : if (dev->users) {
1832 0 : if (dev->open) {
1833 0 : ret = dev->open(dev);
1834 0 : if (ret)
1835 : goto out;
1836 : }
1837 0 : if (dev->poller)
1838 0 : input_dev_poller_start(dev->poller);
1839 : }
1840 :
1841 0 : dev->inhibited = false;
1842 0 : spin_lock_irq(&dev->event_lock);
1843 0 : input_dev_toggle(dev, true);
1844 0 : spin_unlock_irq(&dev->event_lock);
1845 :
1846 : out:
1847 0 : mutex_unlock(&dev->mutex);
1848 0 : return ret;
1849 : }
1850 :
1851 : #ifdef CONFIG_PM_SLEEP
1852 0 : static int input_dev_suspend(struct device *dev)
1853 : {
1854 0 : struct input_dev *input_dev = to_input_dev(dev);
1855 :
1856 0 : spin_lock_irq(&input_dev->event_lock);
1857 :
1858 : /*
1859 : * Keys that are pressed now are unlikely to be
1860 : * still pressed when we resume.
1861 : */
1862 0 : input_dev_release_keys(input_dev);
1863 :
1864 : /* Turn off LEDs and sounds, if any are active. */
1865 0 : input_dev_toggle(input_dev, false);
1866 :
1867 0 : spin_unlock_irq(&input_dev->event_lock);
1868 :
1869 0 : return 0;
1870 : }
1871 :
1872 0 : static int input_dev_resume(struct device *dev)
1873 : {
1874 0 : struct input_dev *input_dev = to_input_dev(dev);
1875 :
1876 0 : spin_lock_irq(&input_dev->event_lock);
1877 :
1878 : /* Restore state of LEDs and sounds, if any were active. */
1879 0 : input_dev_toggle(input_dev, true);
1880 :
1881 0 : spin_unlock_irq(&input_dev->event_lock);
1882 :
1883 0 : return 0;
1884 : }
1885 :
1886 0 : static int input_dev_freeze(struct device *dev)
1887 : {
1888 0 : struct input_dev *input_dev = to_input_dev(dev);
1889 :
1890 0 : spin_lock_irq(&input_dev->event_lock);
1891 :
1892 : /*
1893 : * Keys that are pressed now are unlikely to be
1894 : * still pressed when we resume.
1895 : */
1896 0 : input_dev_release_keys(input_dev);
1897 :
1898 0 : spin_unlock_irq(&input_dev->event_lock);
1899 :
1900 0 : return 0;
1901 : }
1902 :
1903 0 : static int input_dev_poweroff(struct device *dev)
1904 : {
1905 0 : struct input_dev *input_dev = to_input_dev(dev);
1906 :
1907 0 : spin_lock_irq(&input_dev->event_lock);
1908 :
1909 : /* Turn off LEDs and sounds, if any are active. */
1910 0 : input_dev_toggle(input_dev, false);
1911 :
1912 0 : spin_unlock_irq(&input_dev->event_lock);
1913 :
1914 0 : return 0;
1915 : }
1916 :
1917 : static const struct dev_pm_ops input_dev_pm_ops = {
1918 : .suspend = input_dev_suspend,
1919 : .resume = input_dev_resume,
1920 : .freeze = input_dev_freeze,
1921 : .poweroff = input_dev_poweroff,
1922 : .restore = input_dev_resume,
1923 : };
1924 : #endif /* CONFIG_PM */
1925 :
1926 : static const struct device_type input_dev_type = {
1927 : .groups = input_dev_attr_groups,
1928 : .release = input_dev_release,
1929 : .uevent = input_dev_uevent,
1930 : #ifdef CONFIG_PM_SLEEP
1931 : .pm = &input_dev_pm_ops,
1932 : #endif
1933 : };
1934 :
1935 0 : static char *input_devnode(struct device *dev, umode_t *mode)
1936 : {
1937 0 : return kasprintf(GFP_KERNEL, "input/%s", dev_name(dev));
1938 : }
1939 :
1940 : struct class input_class = {
1941 : .name = "input",
1942 : .devnode = input_devnode,
1943 : };
1944 : EXPORT_SYMBOL_GPL(input_class);
1945 :
1946 : /**
1947 : * input_allocate_device - allocate memory for new input device
1948 : *
1949 : * Returns prepared struct input_dev or %NULL.
1950 : *
1951 : * NOTE: Use input_free_device() to free devices that have not been
1952 : * registered; input_unregister_device() should be used for already
1953 : * registered devices.
1954 : */
1955 0 : struct input_dev *input_allocate_device(void)
1956 : {
1957 : static atomic_t input_no = ATOMIC_INIT(-1);
1958 : struct input_dev *dev;
1959 :
1960 0 : dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1961 0 : if (dev) {
1962 0 : dev->dev.type = &input_dev_type;
1963 0 : dev->dev.class = &input_class;
1964 0 : device_initialize(&dev->dev);
1965 0 : mutex_init(&dev->mutex);
1966 0 : spin_lock_init(&dev->event_lock);
1967 0 : timer_setup(&dev->timer, NULL, 0);
1968 0 : INIT_LIST_HEAD(&dev->h_list);
1969 0 : INIT_LIST_HEAD(&dev->node);
1970 :
1971 0 : dev_set_name(&dev->dev, "input%lu",
1972 0 : (unsigned long)atomic_inc_return(&input_no));
1973 :
1974 0 : __module_get(THIS_MODULE);
1975 : }
1976 :
1977 0 : return dev;
1978 : }
1979 : EXPORT_SYMBOL(input_allocate_device);
1980 :
1981 : struct input_devres {
1982 : struct input_dev *input;
1983 : };
1984 :
1985 0 : static int devm_input_device_match(struct device *dev, void *res, void *data)
1986 : {
1987 0 : struct input_devres *devres = res;
1988 :
1989 0 : return devres->input == data;
1990 : }
1991 :
1992 0 : static void devm_input_device_release(struct device *dev, void *res)
1993 : {
1994 0 : struct input_devres *devres = res;
1995 0 : struct input_dev *input = devres->input;
1996 :
1997 : dev_dbg(dev, "%s: dropping reference to %s\n",
1998 : __func__, dev_name(&input->dev));
1999 0 : input_put_device(input);
2000 0 : }
2001 :
2002 : /**
2003 : * devm_input_allocate_device - allocate managed input device
2004 : * @dev: device owning the input device being created
2005 : *
2006 : * Returns prepared struct input_dev or %NULL.
2007 : *
2008 : * Managed input devices do not need to be explicitly unregistered or
2009 : * freed as it will be done automatically when owner device unbinds from
2010 : * its driver (or binding fails). Once managed input device is allocated,
2011 : * it is ready to be set up and registered in the same fashion as regular
2012 : * input device. There are no special devm_input_device_[un]register()
2013 : * variants, regular ones work with both managed and unmanaged devices,
2014 : * should you need them. In most cases however, managed input device need
2015 : * not be explicitly unregistered or freed.
2016 : *
2017 : * NOTE: the owner device is set up as parent of input device and users
2018 : * should not override it.
2019 : */
2020 0 : struct input_dev *devm_input_allocate_device(struct device *dev)
2021 : {
2022 : struct input_dev *input;
2023 : struct input_devres *devres;
2024 :
2025 0 : devres = devres_alloc(devm_input_device_release,
2026 : sizeof(*devres), GFP_KERNEL);
2027 0 : if (!devres)
2028 : return NULL;
2029 :
2030 0 : input = input_allocate_device();
2031 0 : if (!input) {
2032 0 : devres_free(devres);
2033 0 : return NULL;
2034 : }
2035 :
2036 0 : input->dev.parent = dev;
2037 0 : input->devres_managed = true;
2038 :
2039 0 : devres->input = input;
2040 0 : devres_add(dev, devres);
2041 :
2042 0 : return input;
2043 : }
2044 : EXPORT_SYMBOL(devm_input_allocate_device);
2045 :
2046 : /**
2047 : * input_free_device - free memory occupied by input_dev structure
2048 : * @dev: input device to free
2049 : *
2050 : * This function should only be used if input_register_device()
2051 : * was not called yet or if it failed. Once device was registered
2052 : * use input_unregister_device() and memory will be freed once last
2053 : * reference to the device is dropped.
2054 : *
2055 : * Device should be allocated by input_allocate_device().
2056 : *
2057 : * NOTE: If there are references to the input device then memory
2058 : * will not be freed until last reference is dropped.
2059 : */
2060 0 : void input_free_device(struct input_dev *dev)
2061 : {
2062 0 : if (dev) {
2063 0 : if (dev->devres_managed)
2064 0 : WARN_ON(devres_destroy(dev->dev.parent,
2065 : devm_input_device_release,
2066 : devm_input_device_match,
2067 : dev));
2068 : input_put_device(dev);
2069 : }
2070 0 : }
2071 : EXPORT_SYMBOL(input_free_device);
2072 :
2073 : /**
2074 : * input_set_timestamp - set timestamp for input events
2075 : * @dev: input device to set timestamp for
2076 : * @timestamp: the time at which the event has occurred
2077 : * in CLOCK_MONOTONIC
2078 : *
2079 : * This function is intended to provide to the input system a more
2080 : * accurate time of when an event actually occurred. The driver should
2081 : * call this function as soon as a timestamp is acquired ensuring
2082 : * clock conversions in input_set_timestamp are done correctly.
2083 : *
2084 : * The system entering suspend state between timestamp acquisition and
2085 : * calling input_set_timestamp can result in inaccurate conversions.
2086 : */
2087 0 : void input_set_timestamp(struct input_dev *dev, ktime_t timestamp)
2088 : {
2089 0 : dev->timestamp[INPUT_CLK_MONO] = timestamp;
2090 0 : dev->timestamp[INPUT_CLK_REAL] = ktime_mono_to_real(timestamp);
2091 0 : dev->timestamp[INPUT_CLK_BOOT] = ktime_mono_to_any(timestamp,
2092 : TK_OFFS_BOOT);
2093 0 : }
2094 : EXPORT_SYMBOL(input_set_timestamp);
2095 :
2096 : /**
2097 : * input_get_timestamp - get timestamp for input events
2098 : * @dev: input device to get timestamp from
2099 : *
2100 : * A valid timestamp is a timestamp of non-zero value.
2101 : */
2102 0 : ktime_t *input_get_timestamp(struct input_dev *dev)
2103 : {
2104 0 : const ktime_t invalid_timestamp = ktime_set(0, 0);
2105 :
2106 0 : if (!ktime_compare(dev->timestamp[INPUT_CLK_MONO], invalid_timestamp))
2107 0 : input_set_timestamp(dev, ktime_get());
2108 :
2109 0 : return dev->timestamp;
2110 : }
2111 : EXPORT_SYMBOL(input_get_timestamp);
2112 :
2113 : /**
2114 : * input_set_capability - mark device as capable of a certain event
2115 : * @dev: device that is capable of emitting or accepting event
2116 : * @type: type of the event (EV_KEY, EV_REL, etc...)
2117 : * @code: event code
2118 : *
2119 : * In addition to setting up corresponding bit in appropriate capability
2120 : * bitmap the function also adjusts dev->evbit.
2121 : */
2122 0 : void input_set_capability(struct input_dev *dev, unsigned int type, unsigned int code)
2123 : {
2124 0 : if (type < EV_CNT && input_max_code[type] &&
2125 : code > input_max_code[type]) {
2126 0 : pr_err("%s: invalid code %u for type %u\n", __func__, code,
2127 : type);
2128 0 : dump_stack();
2129 0 : return;
2130 : }
2131 :
2132 0 : switch (type) {
2133 : case EV_KEY:
2134 0 : __set_bit(code, dev->keybit);
2135 : break;
2136 :
2137 : case EV_REL:
2138 0 : __set_bit(code, dev->relbit);
2139 : break;
2140 :
2141 : case EV_ABS:
2142 0 : input_alloc_absinfo(dev);
2143 0 : __set_bit(code, dev->absbit);
2144 : break;
2145 :
2146 : case EV_MSC:
2147 0 : __set_bit(code, dev->mscbit);
2148 : break;
2149 :
2150 : case EV_SW:
2151 0 : __set_bit(code, dev->swbit);
2152 : break;
2153 :
2154 : case EV_LED:
2155 0 : __set_bit(code, dev->ledbit);
2156 : break;
2157 :
2158 : case EV_SND:
2159 0 : __set_bit(code, dev->sndbit);
2160 : break;
2161 :
2162 : case EV_FF:
2163 0 : __set_bit(code, dev->ffbit);
2164 : break;
2165 :
2166 : case EV_PWR:
2167 : /* do nothing */
2168 : break;
2169 :
2170 : default:
2171 0 : pr_err("%s: unknown type %u (code %u)\n", __func__, type, code);
2172 0 : dump_stack();
2173 0 : return;
2174 : }
2175 :
2176 0 : __set_bit(type, dev->evbit);
2177 : }
2178 : EXPORT_SYMBOL(input_set_capability);
2179 :
2180 0 : static unsigned int input_estimate_events_per_packet(struct input_dev *dev)
2181 : {
2182 : int mt_slots;
2183 : int i;
2184 : unsigned int events;
2185 :
2186 0 : if (dev->mt) {
2187 0 : mt_slots = dev->mt->num_slots;
2188 0 : } else if (test_bit(ABS_MT_TRACKING_ID, dev->absbit)) {
2189 0 : mt_slots = dev->absinfo[ABS_MT_TRACKING_ID].maximum -
2190 0 : dev->absinfo[ABS_MT_TRACKING_ID].minimum + 1,
2191 0 : mt_slots = clamp(mt_slots, 2, 32);
2192 0 : } else if (test_bit(ABS_MT_POSITION_X, dev->absbit)) {
2193 : mt_slots = 2;
2194 : } else {
2195 0 : mt_slots = 0;
2196 : }
2197 :
2198 0 : events = mt_slots + 1; /* count SYN_MT_REPORT and SYN_REPORT */
2199 :
2200 0 : if (test_bit(EV_ABS, dev->evbit))
2201 0 : for_each_set_bit(i, dev->absbit, ABS_CNT)
2202 0 : events += input_is_mt_axis(i) ? mt_slots : 1;
2203 :
2204 0 : if (test_bit(EV_REL, dev->evbit))
2205 0 : events += bitmap_weight(dev->relbit, REL_CNT);
2206 :
2207 : /* Make room for KEY and MSC events */
2208 0 : events += 7;
2209 :
2210 0 : return events;
2211 : }
2212 :
2213 : #define INPUT_CLEANSE_BITMASK(dev, type, bits) \
2214 : do { \
2215 : if (!test_bit(EV_##type, dev->evbit)) \
2216 : memset(dev->bits##bit, 0, \
2217 : sizeof(dev->bits##bit)); \
2218 : } while (0)
2219 :
2220 0 : static void input_cleanse_bitmasks(struct input_dev *dev)
2221 : {
2222 0 : INPUT_CLEANSE_BITMASK(dev, KEY, key);
2223 0 : INPUT_CLEANSE_BITMASK(dev, REL, rel);
2224 0 : INPUT_CLEANSE_BITMASK(dev, ABS, abs);
2225 0 : INPUT_CLEANSE_BITMASK(dev, MSC, msc);
2226 0 : INPUT_CLEANSE_BITMASK(dev, LED, led);
2227 0 : INPUT_CLEANSE_BITMASK(dev, SND, snd);
2228 0 : INPUT_CLEANSE_BITMASK(dev, FF, ff);
2229 0 : INPUT_CLEANSE_BITMASK(dev, SW, sw);
2230 0 : }
2231 :
2232 0 : static void __input_unregister_device(struct input_dev *dev)
2233 : {
2234 : struct input_handle *handle, *next;
2235 :
2236 0 : input_disconnect_device(dev);
2237 :
2238 0 : mutex_lock(&input_mutex);
2239 :
2240 0 : list_for_each_entry_safe(handle, next, &dev->h_list, d_node)
2241 0 : handle->handler->disconnect(handle);
2242 0 : WARN_ON(!list_empty(&dev->h_list));
2243 :
2244 0 : del_timer_sync(&dev->timer);
2245 0 : list_del_init(&dev->node);
2246 :
2247 : input_wakeup_procfs_readers();
2248 :
2249 0 : mutex_unlock(&input_mutex);
2250 :
2251 0 : device_del(&dev->dev);
2252 0 : }
2253 :
2254 0 : static void devm_input_device_unregister(struct device *dev, void *res)
2255 : {
2256 0 : struct input_devres *devres = res;
2257 0 : struct input_dev *input = devres->input;
2258 :
2259 : dev_dbg(dev, "%s: unregistering device %s\n",
2260 : __func__, dev_name(&input->dev));
2261 0 : __input_unregister_device(input);
2262 0 : }
2263 :
2264 : /**
2265 : * input_enable_softrepeat - enable software autorepeat
2266 : * @dev: input device
2267 : * @delay: repeat delay
2268 : * @period: repeat period
2269 : *
2270 : * Enable software autorepeat on the input device.
2271 : */
2272 0 : void input_enable_softrepeat(struct input_dev *dev, int delay, int period)
2273 : {
2274 0 : dev->timer.function = input_repeat_key;
2275 0 : dev->rep[REP_DELAY] = delay;
2276 0 : dev->rep[REP_PERIOD] = period;
2277 0 : }
2278 : EXPORT_SYMBOL(input_enable_softrepeat);
2279 :
2280 0 : bool input_device_enabled(struct input_dev *dev)
2281 : {
2282 : lockdep_assert_held(&dev->mutex);
2283 :
2284 0 : return !dev->inhibited && dev->users > 0;
2285 : }
2286 : EXPORT_SYMBOL_GPL(input_device_enabled);
2287 :
2288 : /**
2289 : * input_register_device - register device with input core
2290 : * @dev: device to be registered
2291 : *
2292 : * This function registers device with input core. The device must be
2293 : * allocated with input_allocate_device() and all it's capabilities
2294 : * set up before registering.
2295 : * If function fails the device must be freed with input_free_device().
2296 : * Once device has been successfully registered it can be unregistered
2297 : * with input_unregister_device(); input_free_device() should not be
2298 : * called in this case.
2299 : *
2300 : * Note that this function is also used to register managed input devices
2301 : * (ones allocated with devm_input_allocate_device()). Such managed input
2302 : * devices need not be explicitly unregistered or freed, their tear down
2303 : * is controlled by the devres infrastructure. It is also worth noting
2304 : * that tear down of managed input devices is internally a 2-step process:
2305 : * registered managed input device is first unregistered, but stays in
2306 : * memory and can still handle input_event() calls (although events will
2307 : * not be delivered anywhere). The freeing of managed input device will
2308 : * happen later, when devres stack is unwound to the point where device
2309 : * allocation was made.
2310 : */
2311 0 : int input_register_device(struct input_dev *dev)
2312 : {
2313 0 : struct input_devres *devres = NULL;
2314 : struct input_handler *handler;
2315 : unsigned int packet_size;
2316 : const char *path;
2317 : int error;
2318 :
2319 0 : if (test_bit(EV_ABS, dev->evbit) && !dev->absinfo) {
2320 0 : dev_err(&dev->dev,
2321 : "Absolute device without dev->absinfo, refusing to register\n");
2322 0 : return -EINVAL;
2323 : }
2324 :
2325 0 : if (dev->devres_managed) {
2326 0 : devres = devres_alloc(devm_input_device_unregister,
2327 : sizeof(*devres), GFP_KERNEL);
2328 0 : if (!devres)
2329 : return -ENOMEM;
2330 :
2331 0 : devres->input = dev;
2332 : }
2333 :
2334 : /* Every input device generates EV_SYN/SYN_REPORT events. */
2335 0 : __set_bit(EV_SYN, dev->evbit);
2336 :
2337 : /* KEY_RESERVED is not supposed to be transmitted to userspace. */
2338 0 : __clear_bit(KEY_RESERVED, dev->keybit);
2339 :
2340 : /* Make sure that bitmasks not mentioned in dev->evbit are clean. */
2341 0 : input_cleanse_bitmasks(dev);
2342 :
2343 0 : packet_size = input_estimate_events_per_packet(dev);
2344 0 : if (dev->hint_events_per_packet < packet_size)
2345 0 : dev->hint_events_per_packet = packet_size;
2346 :
2347 0 : dev->max_vals = dev->hint_events_per_packet + 2;
2348 0 : dev->vals = kcalloc(dev->max_vals, sizeof(*dev->vals), GFP_KERNEL);
2349 0 : if (!dev->vals) {
2350 : error = -ENOMEM;
2351 : goto err_devres_free;
2352 : }
2353 :
2354 : /*
2355 : * If delay and period are pre-set by the driver, then autorepeating
2356 : * is handled by the driver itself and we don't do it in input.c.
2357 : */
2358 0 : if (!dev->rep[REP_DELAY] && !dev->rep[REP_PERIOD])
2359 : input_enable_softrepeat(dev, 250, 33);
2360 :
2361 0 : if (!dev->getkeycode)
2362 0 : dev->getkeycode = input_default_getkeycode;
2363 :
2364 0 : if (!dev->setkeycode)
2365 0 : dev->setkeycode = input_default_setkeycode;
2366 :
2367 0 : if (dev->poller)
2368 0 : input_dev_poller_finalize(dev->poller);
2369 :
2370 0 : error = device_add(&dev->dev);
2371 0 : if (error)
2372 : goto err_free_vals;
2373 :
2374 0 : path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);
2375 0 : pr_info("%s as %s\n",
2376 : dev->name ? dev->name : "Unspecified device",
2377 : path ? path : "N/A");
2378 0 : kfree(path);
2379 :
2380 0 : error = mutex_lock_interruptible(&input_mutex);
2381 0 : if (error)
2382 : goto err_device_del;
2383 :
2384 0 : list_add_tail(&dev->node, &input_dev_list);
2385 :
2386 0 : list_for_each_entry(handler, &input_handler_list, node)
2387 0 : input_attach_handler(dev, handler);
2388 :
2389 : input_wakeup_procfs_readers();
2390 :
2391 0 : mutex_unlock(&input_mutex);
2392 :
2393 0 : if (dev->devres_managed) {
2394 : dev_dbg(dev->dev.parent, "%s: registering %s with devres.\n",
2395 : __func__, dev_name(&dev->dev));
2396 0 : devres_add(dev->dev.parent, devres);
2397 : }
2398 : return 0;
2399 :
2400 : err_device_del:
2401 0 : device_del(&dev->dev);
2402 : err_free_vals:
2403 0 : kfree(dev->vals);
2404 0 : dev->vals = NULL;
2405 : err_devres_free:
2406 0 : devres_free(devres);
2407 0 : return error;
2408 : }
2409 : EXPORT_SYMBOL(input_register_device);
2410 :
2411 : /**
2412 : * input_unregister_device - unregister previously registered device
2413 : * @dev: device to be unregistered
2414 : *
2415 : * This function unregisters an input device. Once device is unregistered
2416 : * the caller should not try to access it as it may get freed at any moment.
2417 : */
2418 0 : void input_unregister_device(struct input_dev *dev)
2419 : {
2420 0 : if (dev->devres_managed) {
2421 0 : WARN_ON(devres_destroy(dev->dev.parent,
2422 : devm_input_device_unregister,
2423 : devm_input_device_match,
2424 : dev));
2425 0 : __input_unregister_device(dev);
2426 : /*
2427 : * We do not do input_put_device() here because it will be done
2428 : * when 2nd devres fires up.
2429 : */
2430 : } else {
2431 0 : __input_unregister_device(dev);
2432 : input_put_device(dev);
2433 : }
2434 0 : }
2435 : EXPORT_SYMBOL(input_unregister_device);
2436 :
2437 : /**
2438 : * input_register_handler - register a new input handler
2439 : * @handler: handler to be registered
2440 : *
2441 : * This function registers a new input handler (interface) for input
2442 : * devices in the system and attaches it to all input devices that
2443 : * are compatible with the handler.
2444 : */
2445 0 : int input_register_handler(struct input_handler *handler)
2446 : {
2447 : struct input_dev *dev;
2448 : int error;
2449 :
2450 0 : error = mutex_lock_interruptible(&input_mutex);
2451 0 : if (error)
2452 : return error;
2453 :
2454 0 : INIT_LIST_HEAD(&handler->h_list);
2455 :
2456 0 : list_add_tail(&handler->node, &input_handler_list);
2457 :
2458 0 : list_for_each_entry(dev, &input_dev_list, node)
2459 0 : input_attach_handler(dev, handler);
2460 :
2461 : input_wakeup_procfs_readers();
2462 :
2463 0 : mutex_unlock(&input_mutex);
2464 0 : return 0;
2465 : }
2466 : EXPORT_SYMBOL(input_register_handler);
2467 :
2468 : /**
2469 : * input_unregister_handler - unregisters an input handler
2470 : * @handler: handler to be unregistered
2471 : *
2472 : * This function disconnects a handler from its input devices and
2473 : * removes it from lists of known handlers.
2474 : */
2475 0 : void input_unregister_handler(struct input_handler *handler)
2476 : {
2477 : struct input_handle *handle, *next;
2478 :
2479 0 : mutex_lock(&input_mutex);
2480 :
2481 0 : list_for_each_entry_safe(handle, next, &handler->h_list, h_node)
2482 0 : handler->disconnect(handle);
2483 0 : WARN_ON(!list_empty(&handler->h_list));
2484 :
2485 0 : list_del_init(&handler->node);
2486 :
2487 : input_wakeup_procfs_readers();
2488 :
2489 0 : mutex_unlock(&input_mutex);
2490 0 : }
2491 : EXPORT_SYMBOL(input_unregister_handler);
2492 :
2493 : /**
2494 : * input_handler_for_each_handle - handle iterator
2495 : * @handler: input handler to iterate
2496 : * @data: data for the callback
2497 : * @fn: function to be called for each handle
2498 : *
2499 : * Iterate over @bus's list of devices, and call @fn for each, passing
2500 : * it @data and stop when @fn returns a non-zero value. The function is
2501 : * using RCU to traverse the list and therefore may be using in atomic
2502 : * contexts. The @fn callback is invoked from RCU critical section and
2503 : * thus must not sleep.
2504 : */
2505 0 : int input_handler_for_each_handle(struct input_handler *handler, void *data,
2506 : int (*fn)(struct input_handle *, void *))
2507 : {
2508 : struct input_handle *handle;
2509 0 : int retval = 0;
2510 :
2511 : rcu_read_lock();
2512 :
2513 0 : list_for_each_entry_rcu(handle, &handler->h_list, h_node) {
2514 0 : retval = fn(handle, data);
2515 0 : if (retval)
2516 : break;
2517 : }
2518 :
2519 : rcu_read_unlock();
2520 :
2521 0 : return retval;
2522 : }
2523 : EXPORT_SYMBOL(input_handler_for_each_handle);
2524 :
2525 : /**
2526 : * input_register_handle - register a new input handle
2527 : * @handle: handle to register
2528 : *
2529 : * This function puts a new input handle onto device's
2530 : * and handler's lists so that events can flow through
2531 : * it once it is opened using input_open_device().
2532 : *
2533 : * This function is supposed to be called from handler's
2534 : * connect() method.
2535 : */
2536 0 : int input_register_handle(struct input_handle *handle)
2537 : {
2538 0 : struct input_handler *handler = handle->handler;
2539 0 : struct input_dev *dev = handle->dev;
2540 : int error;
2541 :
2542 : /*
2543 : * We take dev->mutex here to prevent race with
2544 : * input_release_device().
2545 : */
2546 0 : error = mutex_lock_interruptible(&dev->mutex);
2547 0 : if (error)
2548 : return error;
2549 :
2550 : /*
2551 : * Filters go to the head of the list, normal handlers
2552 : * to the tail.
2553 : */
2554 0 : if (handler->filter)
2555 0 : list_add_rcu(&handle->d_node, &dev->h_list);
2556 : else
2557 0 : list_add_tail_rcu(&handle->d_node, &dev->h_list);
2558 :
2559 0 : mutex_unlock(&dev->mutex);
2560 :
2561 : /*
2562 : * Since we are supposed to be called from ->connect()
2563 : * which is mutually exclusive with ->disconnect()
2564 : * we can't be racing with input_unregister_handle()
2565 : * and so separate lock is not needed here.
2566 : */
2567 0 : list_add_tail_rcu(&handle->h_node, &handler->h_list);
2568 :
2569 0 : if (handler->start)
2570 0 : handler->start(handle);
2571 :
2572 : return 0;
2573 : }
2574 : EXPORT_SYMBOL(input_register_handle);
2575 :
2576 : /**
2577 : * input_unregister_handle - unregister an input handle
2578 : * @handle: handle to unregister
2579 : *
2580 : * This function removes input handle from device's
2581 : * and handler's lists.
2582 : *
2583 : * This function is supposed to be called from handler's
2584 : * disconnect() method.
2585 : */
2586 0 : void input_unregister_handle(struct input_handle *handle)
2587 : {
2588 0 : struct input_dev *dev = handle->dev;
2589 :
2590 0 : list_del_rcu(&handle->h_node);
2591 :
2592 : /*
2593 : * Take dev->mutex to prevent race with input_release_device().
2594 : */
2595 0 : mutex_lock(&dev->mutex);
2596 0 : list_del_rcu(&handle->d_node);
2597 0 : mutex_unlock(&dev->mutex);
2598 :
2599 0 : synchronize_rcu();
2600 0 : }
2601 : EXPORT_SYMBOL(input_unregister_handle);
2602 :
2603 : /**
2604 : * input_get_new_minor - allocates a new input minor number
2605 : * @legacy_base: beginning or the legacy range to be searched
2606 : * @legacy_num: size of legacy range
2607 : * @allow_dynamic: whether we can also take ID from the dynamic range
2608 : *
2609 : * This function allocates a new device minor for from input major namespace.
2610 : * Caller can request legacy minor by specifying @legacy_base and @legacy_num
2611 : * parameters and whether ID can be allocated from dynamic range if there are
2612 : * no free IDs in legacy range.
2613 : */
2614 0 : int input_get_new_minor(int legacy_base, unsigned int legacy_num,
2615 : bool allow_dynamic)
2616 : {
2617 : /*
2618 : * This function should be called from input handler's ->connect()
2619 : * methods, which are serialized with input_mutex, so no additional
2620 : * locking is needed here.
2621 : */
2622 0 : if (legacy_base >= 0) {
2623 0 : int minor = ida_simple_get(&input_ida,
2624 : legacy_base,
2625 : legacy_base + legacy_num,
2626 : GFP_KERNEL);
2627 0 : if (minor >= 0 || !allow_dynamic)
2628 : return minor;
2629 : }
2630 :
2631 0 : return ida_simple_get(&input_ida,
2632 : INPUT_FIRST_DYNAMIC_DEV, INPUT_MAX_CHAR_DEVICES,
2633 : GFP_KERNEL);
2634 : }
2635 : EXPORT_SYMBOL(input_get_new_minor);
2636 :
2637 : /**
2638 : * input_free_minor - release previously allocated minor
2639 : * @minor: minor to be released
2640 : *
2641 : * This function releases previously allocated input minor so that it can be
2642 : * reused later.
2643 : */
2644 0 : void input_free_minor(unsigned int minor)
2645 : {
2646 0 : ida_simple_remove(&input_ida, minor);
2647 0 : }
2648 : EXPORT_SYMBOL(input_free_minor);
2649 :
2650 1 : static int __init input_init(void)
2651 : {
2652 : int err;
2653 :
2654 1 : err = class_register(&input_class);
2655 1 : if (err) {
2656 0 : pr_err("unable to register input_dev class\n");
2657 0 : return err;
2658 : }
2659 :
2660 1 : err = input_proc_init();
2661 1 : if (err)
2662 : goto fail1;
2663 :
2664 1 : err = register_chrdev_region(MKDEV(INPUT_MAJOR, 0),
2665 : INPUT_MAX_CHAR_DEVICES, "input");
2666 1 : if (err) {
2667 0 : pr_err("unable to register char major %d", INPUT_MAJOR);
2668 : goto fail2;
2669 : }
2670 :
2671 : return 0;
2672 :
2673 0 : fail2: input_proc_exit();
2674 0 : fail1: class_unregister(&input_class);
2675 0 : return err;
2676 : }
2677 :
2678 0 : static void __exit input_exit(void)
2679 : {
2680 0 : input_proc_exit();
2681 0 : unregister_chrdev_region(MKDEV(INPUT_MAJOR, 0),
2682 : INPUT_MAX_CHAR_DEVICES);
2683 0 : class_unregister(&input_class);
2684 0 : }
2685 :
2686 : subsys_initcall(input_init);
2687 : module_exit(input_exit);
|
