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