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 : : static inline int is_event_supported(unsigned int code,
51 : : unsigned long *bm, unsigned int max)
52 : : {
53 : 3 : 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 : 3 : static void input_start_autorepeat(struct input_dev *dev, int code)
73 : : {
74 : 3 : if (test_bit(EV_REP, dev->evbit) &&
75 : 3 : dev->rep[REP_PERIOD] && dev->rep[REP_DELAY] &&
76 : 3 : dev->timer.function) {
77 : 3 : dev->repeat_key = code;
78 : 3 : mod_timer(&dev->timer,
79 : 3 : jiffies + msecs_to_jiffies(dev->rep[REP_DELAY]));
80 : : }
81 : 3 : }
82 : :
83 : : static void input_stop_autorepeat(struct input_dev *dev)
84 : : {
85 : 3 : del_timer(&dev->timer);
86 : : }
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 : 3 : static unsigned int input_to_handler(struct input_handle *handle,
94 : : struct input_value *vals, unsigned int count)
95 : : {
96 : 3 : struct input_handler *handler = handle->handler;
97 : : struct input_value *end = vals;
98 : : struct input_value *v;
99 : :
100 : 3 : if (handler->filter) {
101 : 3 : for (v = vals; v != vals + count; v++) {
102 : 3 : if (handler->filter(handle, v->type, v->code, v->value))
103 : 0 : continue;
104 : 3 : if (end != v)
105 : 0 : *end = *v;
106 : 3 : end++;
107 : : }
108 : 3 : count = end - vals;
109 : : }
110 : :
111 : 3 : if (!count)
112 : : return 0;
113 : :
114 : 3 : if (handler->events)
115 : 3 : handler->events(handle, vals, count);
116 : 3 : else if (handler->event)
117 : 3 : for (v = vals; v != vals + count; v++)
118 : 3 : handler->event(handle, v->type, v->code, v->value);
119 : :
120 : 3 : 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 : 3 : static void input_pass_values(struct input_dev *dev,
129 : : struct input_value *vals, unsigned int count)
130 : : {
131 : : struct input_handle *handle;
132 : : struct input_value *v;
133 : :
134 : 3 : if (!count)
135 : 3 : return;
136 : :
137 : : rcu_read_lock();
138 : :
139 : 3 : handle = rcu_dereference(dev->grab);
140 : 3 : if (handle) {
141 : 0 : count = input_to_handler(handle, vals, count);
142 : : } else {
143 : 3 : list_for_each_entry_rcu(handle, &dev->h_list, d_node)
144 : 3 : if (handle->open) {
145 : 3 : count = input_to_handler(handle, vals, count);
146 : 3 : if (!count)
147 : : break;
148 : : }
149 : : }
150 : :
151 : : rcu_read_unlock();
152 : :
153 : : /* trigger auto repeat for key events */
154 : 3 : if (test_bit(EV_REP, dev->evbit) && test_bit(EV_KEY, dev->evbit)) {
155 : 3 : for (v = vals; v != vals + count; v++) {
156 : 3 : if (v->type == EV_KEY && v->value != 2) {
157 : 3 : if (v->value)
158 : 3 : input_start_autorepeat(dev, v->code);
159 : : else
160 : : input_stop_autorepeat(dev);
161 : : }
162 : : }
163 : : }
164 : : }
165 : :
166 : : 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 : : }
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 : 1 : static void input_repeat_key(struct timer_list *t)
180 : : {
181 : 1 : struct input_dev *dev = from_timer(dev, t, timer);
182 : : unsigned long flags;
183 : :
184 : 1 : spin_lock_irqsave(&dev->event_lock, flags);
185 : :
186 : 1 : if (test_bit(dev->repeat_key, dev->key) &&
187 : 1 : is_event_supported(dev->repeat_key, dev->keybit, KEY_MAX)) {
188 : 1 : struct input_value vals[] = {
189 : : { EV_KEY, dev->repeat_key, 2 },
190 : : input_value_sync
191 : : };
192 : :
193 : 1 : input_set_timestamp(dev, ktime_get());
194 : 1 : input_pass_values(dev, vals, ARRAY_SIZE(vals));
195 : :
196 : 1 : if (dev->rep[REP_PERIOD])
197 : 1 : mod_timer(&dev->timer, jiffies +
198 : 1 : msecs_to_jiffies(dev->rep[REP_PERIOD]));
199 : : }
200 : :
201 : : spin_unlock_irqrestore(&dev->event_lock, flags);
202 : 1 : }
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 : : bool is_mt_event;
216 : : 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 : : return INPUT_IGNORE_EVENT;
227 : : }
228 : :
229 : : 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 : : input_abs_set_val(dev, ABS_MT_SLOT, mt->slot);
255 : : return INPUT_PASS_TO_HANDLERS | INPUT_SLOT;
256 : : }
257 : :
258 : : return INPUT_PASS_TO_HANDLERS;
259 : : }
260 : :
261 : 3 : static int input_get_disposition(struct input_dev *dev,
262 : : unsigned int type, unsigned int code, int *pval)
263 : : {
264 : : int disposition = INPUT_IGNORE_EVENT;
265 : 3 : int value = *pval;
266 : :
267 : 3 : switch (type) {
268 : :
269 : : case EV_SYN:
270 : 3 : switch (code) {
271 : : case SYN_CONFIG:
272 : : disposition = INPUT_PASS_TO_ALL;
273 : 0 : break;
274 : :
275 : : case SYN_REPORT:
276 : : disposition = INPUT_PASS_TO_HANDLERS | INPUT_FLUSH;
277 : 3 : break;
278 : : case SYN_MT_REPORT:
279 : : disposition = INPUT_PASS_TO_HANDLERS;
280 : 0 : break;
281 : : }
282 : : break;
283 : :
284 : : case EV_KEY:
285 : 3 : if (is_event_supported(code, dev->keybit, KEY_MAX)) {
286 : :
287 : : /* auto-repeat bypasses state updates */
288 : 3 : if (value == 2) {
289 : : disposition = INPUT_PASS_TO_HANDLERS;
290 : : break;
291 : : }
292 : :
293 : 3 : if (!!test_bit(code, dev->key) != !!value) {
294 : :
295 : : __change_bit(code, dev->key);
296 : : disposition = INPUT_PASS_TO_HANDLERS;
297 : : }
298 : : }
299 : : break;
300 : :
301 : : case EV_SW:
302 : 0 : if (is_event_supported(code, dev->swbit, SW_MAX) &&
303 : 0 : !!test_bit(code, dev->sw) != !!value) {
304 : :
305 : : __change_bit(code, dev->sw);
306 : : disposition = INPUT_PASS_TO_HANDLERS;
307 : : }
308 : : break;
309 : :
310 : : 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 : : case EV_REL:
317 : 1 : if (is_event_supported(code, dev->relbit, REL_MAX) && value)
318 : : disposition = INPUT_PASS_TO_HANDLERS;
319 : :
320 : : break;
321 : :
322 : : case EV_MSC:
323 : 3 : if (is_event_supported(code, dev->mscbit, MSC_MAX))
324 : : disposition = INPUT_PASS_TO_ALL;
325 : :
326 : : break;
327 : :
328 : : case EV_LED:
329 : 3 : if (is_event_supported(code, dev->ledbit, LED_MAX) &&
330 : 3 : !!test_bit(code, dev->led) != !!value) {
331 : :
332 : : __change_bit(code, dev->led);
333 : : disposition = INPUT_PASS_TO_ALL;
334 : : }
335 : : break;
336 : :
337 : : 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 : : __change_bit(code, dev->snd);
342 : : disposition = INPUT_PASS_TO_ALL;
343 : : }
344 : : break;
345 : :
346 : : case EV_REP:
347 : 0 : if (code <= REP_MAX && value >= 0 && dev->rep[code] != value) {
348 : 0 : dev->rep[code] = value;
349 : : disposition = INPUT_PASS_TO_ALL;
350 : : }
351 : : break;
352 : :
353 : : case EV_FF:
354 : 0 : if (value >= 0)
355 : : disposition = INPUT_PASS_TO_ALL;
356 : : break;
357 : :
358 : : case EV_PWR:
359 : : disposition = INPUT_PASS_TO_ALL;
360 : 0 : break;
361 : : }
362 : :
363 : 3 : *pval = value;
364 : 3 : return disposition;
365 : : }
366 : :
367 : 3 : static void input_handle_event(struct input_dev *dev,
368 : : unsigned int type, unsigned int code, int value)
369 : : {
370 : 3 : int disposition = input_get_disposition(dev, type, code, &value);
371 : :
372 : 3 : if (disposition != INPUT_IGNORE_EVENT && type != EV_SYN)
373 : 3 : add_input_randomness(type, code, value);
374 : :
375 : 3 : if ((disposition & INPUT_PASS_TO_DEVICE) && dev->event)
376 : 3 : dev->event(dev, type, code, value);
377 : :
378 : 3 : if (!dev->vals)
379 : 3 : return;
380 : :
381 : 3 : if (disposition & INPUT_PASS_TO_HANDLERS) {
382 : : struct input_value *v;
383 : :
384 : 3 : 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 : 3 : v = &dev->vals[dev->num_vals++];
392 : 3 : v->type = type;
393 : 3 : v->code = code;
394 : 3 : v->value = value;
395 : : }
396 : :
397 : 3 : if (disposition & INPUT_FLUSH) {
398 : 3 : if (dev->num_vals >= 2)
399 : 3 : input_pass_values(dev, dev->vals, dev->num_vals);
400 : 3 : 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 : 3 : dev->timestamp[INPUT_CLK_MONO] = ktime_set(0, 0);
408 : 3 : } 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 : 3 : void input_event(struct input_dev *dev,
434 : : unsigned int type, unsigned int code, int value)
435 : : {
436 : : unsigned long flags;
437 : :
438 : 3 : if (is_event_supported(type, dev->evbit, EV_MAX)) {
439 : :
440 : 3 : spin_lock_irqsave(&dev->event_lock, flags);
441 : 3 : input_handle_event(dev, type, code, value);
442 : : spin_unlock_irqrestore(&dev->event_lock, flags);
443 : : }
444 : 3 : }
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 : 3 : void input_inject_event(struct input_handle *handle,
459 : : unsigned int type, unsigned int code, int value)
460 : : {
461 : 3 : struct input_dev *dev = handle->dev;
462 : : struct input_handle *grab;
463 : : unsigned long flags;
464 : :
465 : 3 : if (is_event_supported(type, dev->evbit, EV_MAX)) {
466 : 3 : spin_lock_irqsave(&dev->event_lock, flags);
467 : :
468 : : rcu_read_lock();
469 : 3 : grab = rcu_dereference(dev->grab);
470 : 3 : if (!grab || grab == handle)
471 : 3 : input_handle_event(dev, type, code, value);
472 : : rcu_read_unlock();
473 : :
474 : : spin_unlock_irqrestore(&dev->event_lock, flags);
475 : : }
476 : 3 : }
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 : 2 : void input_alloc_absinfo(struct input_dev *dev)
487 : : {
488 : 2 : if (dev->absinfo)
489 : 2 : return;
490 : :
491 : 2 : dev->absinfo = kcalloc(ABS_CNT, sizeof(*dev->absinfo), GFP_KERNEL);
492 : 2 : 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 : 2 : void input_set_abs_params(struct input_dev *dev, unsigned int axis,
505 : : int min, int max, int fuzz, int flat)
506 : : {
507 : : struct input_absinfo *absinfo;
508 : :
509 : 2 : input_alloc_absinfo(dev);
510 : 2 : if (!dev->absinfo)
511 : 2 : return;
512 : :
513 : 2 : absinfo = &dev->absinfo[axis];
514 : 2 : absinfo->minimum = min;
515 : 2 : absinfo->maximum = max;
516 : 2 : absinfo->fuzz = fuzz;
517 : 2 : absinfo->flat = flat;
518 : :
519 : : __set_bit(EV_ABS, dev->evbit);
520 : 2 : __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 : : 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 : : retval = -EBUSY;
544 : : goto out;
545 : : }
546 : :
547 : 0 : rcu_assign_pointer(dev->grab, handle);
548 : :
549 : : out:
550 : 0 : mutex_unlock(&dev->mutex);
551 : 0 : return retval;
552 : : }
553 : : EXPORT_SYMBOL(input_grab_device);
554 : :
555 : 3 : static void __input_release_device(struct input_handle *handle)
556 : : {
557 : 3 : struct input_dev *dev = handle->dev;
558 : : struct input_handle *grabber;
559 : :
560 : 3 : grabber = rcu_dereference_protected(dev->grab,
561 : : lockdep_is_held(&dev->mutex));
562 : 3 : if (grabber == handle) {
563 : : 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 : 3 : }
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 : 3 : int input_open_device(struct input_handle *handle)
600 : : {
601 : 3 : struct input_dev *dev = handle->dev;
602 : : int retval;
603 : :
604 : 3 : retval = mutex_lock_interruptible(&dev->mutex);
605 : 3 : if (retval)
606 : : return retval;
607 : :
608 : 3 : if (dev->going_away) {
609 : : retval = -ENODEV;
610 : : goto out;
611 : : }
612 : :
613 : 3 : handle->open++;
614 : :
615 : 3 : if (dev->users++) {
616 : : /*
617 : : * Device is already opened, so we can exit immediately and
618 : : * report success.
619 : : */
620 : : goto out;
621 : : }
622 : :
623 : 3 : if (dev->open) {
624 : 3 : retval = dev->open(dev);
625 : 3 : 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 : 3 : if (dev->poller)
638 : 0 : input_dev_poller_start(dev->poller);
639 : :
640 : : out:
641 : 3 : mutex_unlock(&dev->mutex);
642 : 3 : return retval;
643 : : }
644 : : EXPORT_SYMBOL(input_open_device);
645 : :
646 : 3 : int input_flush_device(struct input_handle *handle, struct file *file)
647 : : {
648 : 3 : struct input_dev *dev = handle->dev;
649 : : int retval;
650 : :
651 : 3 : retval = mutex_lock_interruptible(&dev->mutex);
652 : 3 : if (retval)
653 : : return retval;
654 : :
655 : 3 : if (dev->flush)
656 : 0 : retval = dev->flush(dev, file);
657 : :
658 : 3 : mutex_unlock(&dev->mutex);
659 : 3 : 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 : 3 : void input_close_device(struct input_handle *handle)
671 : : {
672 : 3 : struct input_dev *dev = handle->dev;
673 : :
674 : 3 : mutex_lock(&dev->mutex);
675 : :
676 : 3 : __input_release_device(handle);
677 : :
678 : 3 : if (!--dev->users) {
679 : 3 : if (dev->poller)
680 : 0 : input_dev_poller_stop(dev->poller);
681 : :
682 : 3 : if (dev->close)
683 : 3 : dev->close(dev);
684 : : }
685 : :
686 : 3 : 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 : 3 : synchronize_rcu();
693 : : }
694 : :
695 : 3 : mutex_unlock(&dev->mutex);
696 : 3 : }
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 : : bool need_sync = false;
706 : : 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 : : input_pass_event(dev, EV_KEY, code, 0);
711 : : need_sync = true;
712 : : }
713 : :
714 : 0 : if (need_sync)
715 : : 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 : : 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 : : 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 : : 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 : : case 1:
768 : 0 : *scancode = *((u8 *)ke->scancode);
769 : 0 : break;
770 : :
771 : : case 2:
772 : 0 : *scancode = *((u16 *)ke->scancode);
773 : 0 : break;
774 : :
775 : : 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 : : case 1:
797 : 0 : return ((u8 *)dev->keycode)[index];
798 : :
799 : : case 2:
800 : 0 : return ((u16 *)dev->keycode)[index];
801 : :
802 : : 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 : : unsigned int index;
811 : : 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 : : 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 : : unsigned int index;
840 : : int error;
841 : : 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 : : 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 : : 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 : : 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 : : 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 : : unsigned long flags;
908 : : int retval;
909 : :
910 : 0 : spin_lock_irqsave(&dev->event_lock, flags);
911 : 0 : retval = dev->getkeycode(dev, ke);
912 : : 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 : : unsigned long flags;
930 : : unsigned int old_keycode;
931 : : 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 : : 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 : : out:
965 : : spin_unlock_irqrestore(&dev->event_lock, flags);
966 : :
967 : 0 : return retval;
968 : : }
969 : : EXPORT_SYMBOL(input_set_keycode);
970 : :
971 : 3 : bool input_match_device_id(const struct input_dev *dev,
972 : : const struct input_device_id *id)
973 : : {
974 : 3 : if (id->flags & INPUT_DEVICE_ID_MATCH_BUS)
975 : 0 : if (id->bustype != dev->id.bustype)
976 : : return false;
977 : :
978 : 3 : if (id->flags & INPUT_DEVICE_ID_MATCH_VENDOR)
979 : 0 : if (id->vendor != dev->id.vendor)
980 : : return false;
981 : :
982 : 3 : if (id->flags & INPUT_DEVICE_ID_MATCH_PRODUCT)
983 : 0 : if (id->product != dev->id.product)
984 : : return false;
985 : :
986 : 3 : if (id->flags & INPUT_DEVICE_ID_MATCH_VERSION)
987 : 0 : if (id->version != dev->id.version)
988 : : return false;
989 : :
990 : 3 : if (!bitmap_subset(id->evbit, dev->evbit, EV_MAX) ||
991 : 3 : !bitmap_subset(id->keybit, dev->keybit, KEY_MAX) ||
992 : 3 : !bitmap_subset(id->relbit, dev->relbit, REL_MAX) ||
993 : 3 : !bitmap_subset(id->absbit, dev->absbit, ABS_MAX) ||
994 : 3 : !bitmap_subset(id->mscbit, dev->mscbit, MSC_MAX) ||
995 : 3 : !bitmap_subset(id->ledbit, dev->ledbit, LED_MAX) ||
996 : 3 : !bitmap_subset(id->sndbit, dev->sndbit, SND_MAX) ||
997 : 3 : !bitmap_subset(id->ffbit, dev->ffbit, FF_MAX) ||
998 : 3 : !bitmap_subset(id->swbit, dev->swbit, SW_MAX) ||
999 : 3 : !bitmap_subset(id->propbit, dev->propbit, INPUT_PROP_MAX)) {
1000 : : return false;
1001 : : }
1002 : :
1003 : : return true;
1004 : : }
1005 : : EXPORT_SYMBOL(input_match_device_id);
1006 : :
1007 : 3 : static const struct input_device_id *input_match_device(struct input_handler *handler,
1008 : : struct input_dev *dev)
1009 : : {
1010 : : const struct input_device_id *id;
1011 : :
1012 : 3 : for (id = handler->id_table; id->flags || id->driver_info; id++) {
1013 : 3 : if (input_match_device_id(dev, id) &&
1014 : 3 : (!handler->match || handler->match(handler, dev))) {
1015 : 3 : return id;
1016 : : }
1017 : : }
1018 : :
1019 : : return NULL;
1020 : : }
1021 : :
1022 : 3 : static int input_attach_handler(struct input_dev *dev, struct input_handler *handler)
1023 : : {
1024 : : const struct input_device_id *id;
1025 : : int error;
1026 : :
1027 : 3 : id = input_match_device(handler, dev);
1028 : 3 : if (!id)
1029 : : return -ENODEV;
1030 : :
1031 : 3 : error = handler->connect(handler, dev, id);
1032 : 3 : 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 : 3 : return error;
1037 : : }
1038 : :
1039 : : #ifdef CONFIG_COMPAT
1040 : :
1041 : : static int input_bits_to_string(char *buf, int buf_size,
1042 : : unsigned long bits, bool skip_empty)
1043 : : {
1044 : : int len = 0;
1045 : :
1046 : : if (in_compat_syscall()) {
1047 : : u32 dword = bits >> 32;
1048 : : if (dword || !skip_empty)
1049 : : len += snprintf(buf, buf_size, "%x ", dword);
1050 : :
1051 : : dword = bits & 0xffffffffUL;
1052 : : if (dword || !skip_empty || len)
1053 : : len += snprintf(buf + len, max(buf_size - len, 0),
1054 : : "%x", dword);
1055 : : } else {
1056 : : if (bits || !skip_empty)
1057 : : len += snprintf(buf, buf_size, "%lx", bits);
1058 : : }
1059 : :
1060 : : 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 : 3 : return bits || !skip_empty ?
1069 : 3 : 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 : 3 : static inline void input_wakeup_procfs_readers(void)
1081 : : {
1082 : 3 : input_devices_state++;
1083 : 3 : wake_up(&input_devices_poll_wait);
1084 : 3 : }
1085 : :
1086 : 0 : static __poll_t input_proc_devices_poll(struct file *file, poll_table *wait)
1087 : : {
1088 : : 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 : : union input_seq_state *state = (union input_seq_state *)&seq->private;
1108 : : int error;
1109 : :
1110 : : /* We need to fit into seq->private pointer */
1111 : : 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 : : 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 : : int i;
1141 : : bool skip_empty = true;
1142 : : 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 : : 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 : : 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 : : 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 file_operations input_devices_fileops = {
1221 : : .owner = THIS_MODULE,
1222 : : .open = input_proc_devices_open,
1223 : : .poll = input_proc_devices_poll,
1224 : : .read = seq_read,
1225 : : .llseek = seq_lseek,
1226 : : .release = seq_release,
1227 : : };
1228 : :
1229 : 0 : static void *input_handlers_seq_start(struct seq_file *seq, loff_t *pos)
1230 : : {
1231 : : union input_seq_state *state = (union input_seq_state *)&seq->private;
1232 : : int error;
1233 : :
1234 : : /* We need to fit into seq->private pointer */
1235 : : BUILD_BUG_ON(sizeof(union input_seq_state) != sizeof(seq->private));
1236 : :
1237 : 0 : error = mutex_lock_interruptible(&input_mutex);
1238 : 0 : if (error) {
1239 : 0 : state->mutex_acquired = false;
1240 : 0 : return ERR_PTR(error);
1241 : : }
1242 : :
1243 : 0 : state->mutex_acquired = true;
1244 : 0 : state->pos = *pos;
1245 : :
1246 : 0 : return seq_list_start(&input_handler_list, *pos);
1247 : : }
1248 : :
1249 : 0 : static void *input_handlers_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1250 : : {
1251 : : union input_seq_state *state = (union input_seq_state *)&seq->private;
1252 : :
1253 : 0 : state->pos = *pos + 1;
1254 : 0 : return seq_list_next(v, &input_handler_list, pos);
1255 : : }
1256 : :
1257 : 0 : static int input_handlers_seq_show(struct seq_file *seq, void *v)
1258 : : {
1259 : : struct input_handler *handler = container_of(v, struct input_handler, node);
1260 : : union input_seq_state *state = (union input_seq_state *)&seq->private;
1261 : :
1262 : 0 : seq_printf(seq, "N: Number=%u Name=%s", state->pos, handler->name);
1263 : 0 : if (handler->filter)
1264 : 0 : seq_puts(seq, " (filter)");
1265 : 0 : if (handler->legacy_minors)
1266 : 0 : seq_printf(seq, " Minor=%d", handler->minor);
1267 : 0 : seq_putc(seq, '\n');
1268 : :
1269 : 0 : return 0;
1270 : : }
1271 : :
1272 : : static const struct seq_operations input_handlers_seq_ops = {
1273 : : .start = input_handlers_seq_start,
1274 : : .next = input_handlers_seq_next,
1275 : : .stop = input_seq_stop,
1276 : : .show = input_handlers_seq_show,
1277 : : };
1278 : :
1279 : 0 : static int input_proc_handlers_open(struct inode *inode, struct file *file)
1280 : : {
1281 : 0 : return seq_open(file, &input_handlers_seq_ops);
1282 : : }
1283 : :
1284 : : static const struct file_operations input_handlers_fileops = {
1285 : : .owner = THIS_MODULE,
1286 : : .open = input_proc_handlers_open,
1287 : : .read = seq_read,
1288 : : .llseek = seq_lseek,
1289 : : .release = seq_release,
1290 : : };
1291 : :
1292 : 3 : static int __init input_proc_init(void)
1293 : : {
1294 : : struct proc_dir_entry *entry;
1295 : :
1296 : 3 : proc_bus_input_dir = proc_mkdir("bus/input", NULL);
1297 : 3 : if (!proc_bus_input_dir)
1298 : : return -ENOMEM;
1299 : :
1300 : 3 : entry = proc_create("devices", 0, proc_bus_input_dir,
1301 : : &input_devices_fileops);
1302 : 3 : if (!entry)
1303 : : goto fail1;
1304 : :
1305 : 3 : entry = proc_create("handlers", 0, proc_bus_input_dir,
1306 : : &input_handlers_fileops);
1307 : 3 : if (!entry)
1308 : : goto fail2;
1309 : :
1310 : : return 0;
1311 : :
1312 : 0 : fail2: remove_proc_entry("devices", proc_bus_input_dir);
1313 : 0 : fail1: remove_proc_entry("bus/input", NULL);
1314 : 0 : return -ENOMEM;
1315 : : }
1316 : :
1317 : 0 : static void input_proc_exit(void)
1318 : : {
1319 : 0 : remove_proc_entry("devices", proc_bus_input_dir);
1320 : 0 : remove_proc_entry("handlers", proc_bus_input_dir);
1321 : 0 : remove_proc_entry("bus/input", NULL);
1322 : 0 : }
1323 : :
1324 : : #else /* !CONFIG_PROC_FS */
1325 : : static inline void input_wakeup_procfs_readers(void) { }
1326 : : static inline int input_proc_init(void) { return 0; }
1327 : : static inline void input_proc_exit(void) { }
1328 : : #endif
1329 : :
1330 : : #define INPUT_DEV_STRING_ATTR_SHOW(name) \
1331 : : static ssize_t input_dev_show_##name(struct device *dev, \
1332 : : struct device_attribute *attr, \
1333 : : char *buf) \
1334 : : { \
1335 : : struct input_dev *input_dev = to_input_dev(dev); \
1336 : : \
1337 : : return scnprintf(buf, PAGE_SIZE, "%s\n", \
1338 : : input_dev->name ? input_dev->name : ""); \
1339 : : } \
1340 : : static DEVICE_ATTR(name, S_IRUGO, input_dev_show_##name, NULL)
1341 : :
1342 : 3 : INPUT_DEV_STRING_ATTR_SHOW(name);
1343 : 3 : INPUT_DEV_STRING_ATTR_SHOW(phys);
1344 : 0 : INPUT_DEV_STRING_ATTR_SHOW(uniq);
1345 : :
1346 : 3 : static int input_print_modalias_bits(char *buf, int size,
1347 : : char name, unsigned long *bm,
1348 : : unsigned int min_bit, unsigned int max_bit)
1349 : : {
1350 : : int len = 0, i;
1351 : :
1352 : 3 : len += snprintf(buf, max(size, 0), "%c", name);
1353 : 3 : for (i = min_bit; i < max_bit; i++)
1354 : 3 : if (bm[BIT_WORD(i)] & BIT_MASK(i))
1355 : 3 : len += snprintf(buf + len, max(size - len, 0), "%X,", i);
1356 : 3 : return len;
1357 : : }
1358 : :
1359 : 3 : static int input_print_modalias(char *buf, int size, struct input_dev *id,
1360 : : int add_cr)
1361 : : {
1362 : : int len;
1363 : :
1364 : 3 : len = snprintf(buf, max(size, 0),
1365 : : "input:b%04Xv%04Xp%04Xe%04X-",
1366 : 3 : id->id.bustype, id->id.vendor,
1367 : 3 : id->id.product, id->id.version);
1368 : :
1369 : 3 : len += input_print_modalias_bits(buf + len, size - len,
1370 : 3 : 'e', id->evbit, 0, EV_MAX);
1371 : 3 : len += input_print_modalias_bits(buf + len, size - len,
1372 : 3 : 'k', id->keybit, KEY_MIN_INTERESTING, KEY_MAX);
1373 : 3 : len += input_print_modalias_bits(buf + len, size - len,
1374 : 3 : 'r', id->relbit, 0, REL_MAX);
1375 : 3 : len += input_print_modalias_bits(buf + len, size - len,
1376 : 3 : 'a', id->absbit, 0, ABS_MAX);
1377 : 3 : len += input_print_modalias_bits(buf + len, size - len,
1378 : 3 : 'm', id->mscbit, 0, MSC_MAX);
1379 : 3 : len += input_print_modalias_bits(buf + len, size - len,
1380 : 3 : 'l', id->ledbit, 0, LED_MAX);
1381 : 3 : len += input_print_modalias_bits(buf + len, size - len,
1382 : 3 : 's', id->sndbit, 0, SND_MAX);
1383 : 3 : len += input_print_modalias_bits(buf + len, size - len,
1384 : 3 : 'f', id->ffbit, 0, FF_MAX);
1385 : 3 : len += input_print_modalias_bits(buf + len, size - len,
1386 : 3 : 'w', id->swbit, 0, SW_MAX);
1387 : :
1388 : 3 : if (add_cr)
1389 : 0 : len += snprintf(buf + len, max(size - len, 0), "\n");
1390 : :
1391 : 3 : return len;
1392 : : }
1393 : :
1394 : 0 : static ssize_t input_dev_show_modalias(struct device *dev,
1395 : : struct device_attribute *attr,
1396 : : char *buf)
1397 : : {
1398 : 0 : struct input_dev *id = to_input_dev(dev);
1399 : : ssize_t len;
1400 : :
1401 : 0 : len = input_print_modalias(buf, PAGE_SIZE, id, 1);
1402 : :
1403 : 0 : return min_t(int, len, PAGE_SIZE);
1404 : : }
1405 : : static DEVICE_ATTR(modalias, S_IRUGO, input_dev_show_modalias, NULL);
1406 : :
1407 : : static int input_print_bitmap(char *buf, int buf_size, unsigned long *bitmap,
1408 : : int max, int add_cr);
1409 : :
1410 : 3 : static ssize_t input_dev_show_properties(struct device *dev,
1411 : : struct device_attribute *attr,
1412 : : char *buf)
1413 : : {
1414 : : struct input_dev *input_dev = to_input_dev(dev);
1415 : 3 : int len = input_print_bitmap(buf, PAGE_SIZE, input_dev->propbit,
1416 : : INPUT_PROP_MAX, true);
1417 : 3 : return min_t(int, len, PAGE_SIZE);
1418 : : }
1419 : : static DEVICE_ATTR(properties, S_IRUGO, input_dev_show_properties, NULL);
1420 : :
1421 : : static struct attribute *input_dev_attrs[] = {
1422 : : &dev_attr_name.attr,
1423 : : &dev_attr_phys.attr,
1424 : : &dev_attr_uniq.attr,
1425 : : &dev_attr_modalias.attr,
1426 : : &dev_attr_properties.attr,
1427 : : NULL
1428 : : };
1429 : :
1430 : : static const struct attribute_group input_dev_attr_group = {
1431 : : .attrs = input_dev_attrs,
1432 : : };
1433 : :
1434 : : #define INPUT_DEV_ID_ATTR(name) \
1435 : : static ssize_t input_dev_show_id_##name(struct device *dev, \
1436 : : struct device_attribute *attr, \
1437 : : char *buf) \
1438 : : { \
1439 : : struct input_dev *input_dev = to_input_dev(dev); \
1440 : : return scnprintf(buf, PAGE_SIZE, "%04x\n", input_dev->id.name); \
1441 : : } \
1442 : : static DEVICE_ATTR(name, S_IRUGO, input_dev_show_id_##name, NULL)
1443 : :
1444 : 3 : INPUT_DEV_ID_ATTR(bustype);
1445 : 3 : INPUT_DEV_ID_ATTR(vendor);
1446 : 3 : INPUT_DEV_ID_ATTR(product);
1447 : 0 : INPUT_DEV_ID_ATTR(version);
1448 : :
1449 : : static struct attribute *input_dev_id_attrs[] = {
1450 : : &dev_attr_bustype.attr,
1451 : : &dev_attr_vendor.attr,
1452 : : &dev_attr_product.attr,
1453 : : &dev_attr_version.attr,
1454 : : NULL
1455 : : };
1456 : :
1457 : : static const struct attribute_group input_dev_id_attr_group = {
1458 : : .name = "id",
1459 : : .attrs = input_dev_id_attrs,
1460 : : };
1461 : :
1462 : 3 : static int input_print_bitmap(char *buf, int buf_size, unsigned long *bitmap,
1463 : : int max, int add_cr)
1464 : : {
1465 : : int i;
1466 : : int len = 0;
1467 : : bool skip_empty = true;
1468 : :
1469 : 3 : for (i = BITS_TO_LONGS(max) - 1; i >= 0; i--) {
1470 : 3 : len += input_bits_to_string(buf + len, max(buf_size - len, 0),
1471 : 3 : bitmap[i], skip_empty);
1472 : 3 : if (len) {
1473 : : skip_empty = false;
1474 : 3 : if (i > 0)
1475 : 3 : len += snprintf(buf + len, max(buf_size - len, 0), " ");
1476 : : }
1477 : : }
1478 : :
1479 : : /*
1480 : : * If no output was produced print a single 0.
1481 : : */
1482 : 3 : if (len == 0)
1483 : 3 : len = snprintf(buf, buf_size, "%d", 0);
1484 : :
1485 : 3 : if (add_cr)
1486 : 3 : len += snprintf(buf + len, max(buf_size - len, 0), "\n");
1487 : :
1488 : 3 : return len;
1489 : : }
1490 : :
1491 : : #define INPUT_DEV_CAP_ATTR(ev, bm) \
1492 : : static ssize_t input_dev_show_cap_##bm(struct device *dev, \
1493 : : struct device_attribute *attr, \
1494 : : char *buf) \
1495 : : { \
1496 : : struct input_dev *input_dev = to_input_dev(dev); \
1497 : : int len = input_print_bitmap(buf, PAGE_SIZE, \
1498 : : input_dev->bm##bit, ev##_MAX, \
1499 : : true); \
1500 : : return min_t(int, len, PAGE_SIZE); \
1501 : : } \
1502 : : static DEVICE_ATTR(bm, S_IRUGO, input_dev_show_cap_##bm, NULL)
1503 : :
1504 : 3 : INPUT_DEV_CAP_ATTR(EV, ev);
1505 : 3 : INPUT_DEV_CAP_ATTR(KEY, key);
1506 : 3 : INPUT_DEV_CAP_ATTR(REL, rel);
1507 : 3 : INPUT_DEV_CAP_ATTR(ABS, abs);
1508 : 0 : INPUT_DEV_CAP_ATTR(MSC, msc);
1509 : 0 : INPUT_DEV_CAP_ATTR(LED, led);
1510 : 0 : INPUT_DEV_CAP_ATTR(SND, snd);
1511 : 0 : INPUT_DEV_CAP_ATTR(FF, ff);
1512 : 0 : INPUT_DEV_CAP_ATTR(SW, sw);
1513 : :
1514 : : static struct attribute *input_dev_caps_attrs[] = {
1515 : : &dev_attr_ev.attr,
1516 : : &dev_attr_key.attr,
1517 : : &dev_attr_rel.attr,
1518 : : &dev_attr_abs.attr,
1519 : : &dev_attr_msc.attr,
1520 : : &dev_attr_led.attr,
1521 : : &dev_attr_snd.attr,
1522 : : &dev_attr_ff.attr,
1523 : : &dev_attr_sw.attr,
1524 : : NULL
1525 : : };
1526 : :
1527 : : static const struct attribute_group input_dev_caps_attr_group = {
1528 : : .name = "capabilities",
1529 : : .attrs = input_dev_caps_attrs,
1530 : : };
1531 : :
1532 : : static const struct attribute_group *input_dev_attr_groups[] = {
1533 : : &input_dev_attr_group,
1534 : : &input_dev_id_attr_group,
1535 : : &input_dev_caps_attr_group,
1536 : : &input_poller_attribute_group,
1537 : : NULL
1538 : : };
1539 : :
1540 : 0 : static void input_dev_release(struct device *device)
1541 : : {
1542 : 0 : struct input_dev *dev = to_input_dev(device);
1543 : :
1544 : 0 : input_ff_destroy(dev);
1545 : 0 : input_mt_destroy_slots(dev);
1546 : 0 : kfree(dev->poller);
1547 : 0 : kfree(dev->absinfo);
1548 : 0 : kfree(dev->vals);
1549 : 0 : kfree(dev);
1550 : :
1551 : 0 : module_put(THIS_MODULE);
1552 : 0 : }
1553 : :
1554 : : /*
1555 : : * Input uevent interface - loading event handlers based on
1556 : : * device bitfields.
1557 : : */
1558 : 3 : static int input_add_uevent_bm_var(struct kobj_uevent_env *env,
1559 : : const char *name, unsigned long *bitmap, int max)
1560 : : {
1561 : : int len;
1562 : :
1563 : 3 : if (add_uevent_var(env, "%s", name))
1564 : : return -ENOMEM;
1565 : :
1566 : 3 : len = input_print_bitmap(&env->buf[env->buflen - 1],
1567 : 3 : sizeof(env->buf) - env->buflen,
1568 : : bitmap, max, false);
1569 : 3 : if (len >= (sizeof(env->buf) - env->buflen))
1570 : : return -ENOMEM;
1571 : :
1572 : 3 : env->buflen += len;
1573 : 3 : return 0;
1574 : : }
1575 : :
1576 : 3 : static int input_add_uevent_modalias_var(struct kobj_uevent_env *env,
1577 : : struct input_dev *dev)
1578 : : {
1579 : : int len;
1580 : :
1581 : 3 : if (add_uevent_var(env, "MODALIAS="))
1582 : : return -ENOMEM;
1583 : :
1584 : 3 : len = input_print_modalias(&env->buf[env->buflen - 1],
1585 : 3 : sizeof(env->buf) - env->buflen,
1586 : : dev, 0);
1587 : 3 : if (len >= (sizeof(env->buf) - env->buflen))
1588 : : return -ENOMEM;
1589 : :
1590 : 3 : env->buflen += len;
1591 : 3 : return 0;
1592 : : }
1593 : :
1594 : : #define INPUT_ADD_HOTPLUG_VAR(fmt, val...) \
1595 : : do { \
1596 : : int err = add_uevent_var(env, fmt, val); \
1597 : : if (err) \
1598 : : return err; \
1599 : : } while (0)
1600 : :
1601 : : #define INPUT_ADD_HOTPLUG_BM_VAR(name, bm, max) \
1602 : : do { \
1603 : : int err = input_add_uevent_bm_var(env, name, bm, max); \
1604 : : if (err) \
1605 : : return err; \
1606 : : } while (0)
1607 : :
1608 : : #define INPUT_ADD_HOTPLUG_MODALIAS_VAR(dev) \
1609 : : do { \
1610 : : int err = input_add_uevent_modalias_var(env, dev); \
1611 : : if (err) \
1612 : : return err; \
1613 : : } while (0)
1614 : :
1615 : 3 : static int input_dev_uevent(struct device *device, struct kobj_uevent_env *env)
1616 : : {
1617 : 3 : struct input_dev *dev = to_input_dev(device);
1618 : :
1619 : 3 : INPUT_ADD_HOTPLUG_VAR("PRODUCT=%x/%x/%x/%x",
1620 : : dev->id.bustype, dev->id.vendor,
1621 : : dev->id.product, dev->id.version);
1622 : 3 : if (dev->name)
1623 : 3 : INPUT_ADD_HOTPLUG_VAR("NAME=\"%s\"", dev->name);
1624 : 3 : if (dev->phys)
1625 : 3 : INPUT_ADD_HOTPLUG_VAR("PHYS=\"%s\"", dev->phys);
1626 : 3 : if (dev->uniq)
1627 : 3 : INPUT_ADD_HOTPLUG_VAR("UNIQ=\"%s\"", dev->uniq);
1628 : :
1629 : 3 : INPUT_ADD_HOTPLUG_BM_VAR("PROP=", dev->propbit, INPUT_PROP_MAX);
1630 : :
1631 : 3 : INPUT_ADD_HOTPLUG_BM_VAR("EV=", dev->evbit, EV_MAX);
1632 : 3 : if (test_bit(EV_KEY, dev->evbit))
1633 : 3 : INPUT_ADD_HOTPLUG_BM_VAR("KEY=", dev->keybit, KEY_MAX);
1634 : 3 : if (test_bit(EV_REL, dev->evbit))
1635 : 3 : INPUT_ADD_HOTPLUG_BM_VAR("REL=", dev->relbit, REL_MAX);
1636 : 3 : if (test_bit(EV_ABS, dev->evbit))
1637 : 2 : INPUT_ADD_HOTPLUG_BM_VAR("ABS=", dev->absbit, ABS_MAX);
1638 : 3 : if (test_bit(EV_MSC, dev->evbit))
1639 : 3 : INPUT_ADD_HOTPLUG_BM_VAR("MSC=", dev->mscbit, MSC_MAX);
1640 : 3 : if (test_bit(EV_LED, dev->evbit))
1641 : 3 : INPUT_ADD_HOTPLUG_BM_VAR("LED=", dev->ledbit, LED_MAX);
1642 : 3 : if (test_bit(EV_SND, dev->evbit))
1643 : 0 : INPUT_ADD_HOTPLUG_BM_VAR("SND=", dev->sndbit, SND_MAX);
1644 : 3 : if (test_bit(EV_FF, dev->evbit))
1645 : 0 : INPUT_ADD_HOTPLUG_BM_VAR("FF=", dev->ffbit, FF_MAX);
1646 : 3 : if (test_bit(EV_SW, dev->evbit))
1647 : 0 : INPUT_ADD_HOTPLUG_BM_VAR("SW=", dev->swbit, SW_MAX);
1648 : :
1649 : 3 : INPUT_ADD_HOTPLUG_MODALIAS_VAR(dev);
1650 : :
1651 : : return 0;
1652 : : }
1653 : :
1654 : : #define INPUT_DO_TOGGLE(dev, type, bits, on) \
1655 : : do { \
1656 : : int i; \
1657 : : bool active; \
1658 : : \
1659 : : if (!test_bit(EV_##type, dev->evbit)) \
1660 : : break; \
1661 : : \
1662 : : for_each_set_bit(i, dev->bits##bit, type##_CNT) { \
1663 : : active = test_bit(i, dev->bits); \
1664 : : if (!active && !on) \
1665 : : continue; \
1666 : : \
1667 : : dev->event(dev, EV_##type, i, on ? active : 0); \
1668 : : } \
1669 : : } while (0)
1670 : :
1671 : 0 : static void input_dev_toggle(struct input_dev *dev, bool activate)
1672 : : {
1673 : 0 : if (!dev->event)
1674 : 0 : return;
1675 : :
1676 : 0 : INPUT_DO_TOGGLE(dev, LED, led, activate);
1677 : 0 : INPUT_DO_TOGGLE(dev, SND, snd, activate);
1678 : :
1679 : 0 : if (activate && test_bit(EV_REP, dev->evbit)) {
1680 : 0 : dev->event(dev, EV_REP, REP_PERIOD, dev->rep[REP_PERIOD]);
1681 : 0 : dev->event(dev, EV_REP, REP_DELAY, dev->rep[REP_DELAY]);
1682 : : }
1683 : : }
1684 : :
1685 : : /**
1686 : : * input_reset_device() - reset/restore the state of input device
1687 : : * @dev: input device whose state needs to be reset
1688 : : *
1689 : : * This function tries to reset the state of an opened input device and
1690 : : * bring internal state and state if the hardware in sync with each other.
1691 : : * We mark all keys as released, restore LED state, repeat rate, etc.
1692 : : */
1693 : 0 : void input_reset_device(struct input_dev *dev)
1694 : : {
1695 : : unsigned long flags;
1696 : :
1697 : 0 : mutex_lock(&dev->mutex);
1698 : 0 : spin_lock_irqsave(&dev->event_lock, flags);
1699 : :
1700 : 0 : input_dev_toggle(dev, true);
1701 : 0 : input_dev_release_keys(dev);
1702 : :
1703 : : spin_unlock_irqrestore(&dev->event_lock, flags);
1704 : 0 : mutex_unlock(&dev->mutex);
1705 : 0 : }
1706 : : EXPORT_SYMBOL(input_reset_device);
1707 : :
1708 : : #ifdef CONFIG_PM_SLEEP
1709 : : static int input_dev_suspend(struct device *dev)
1710 : : {
1711 : : struct input_dev *input_dev = to_input_dev(dev);
1712 : :
1713 : : spin_lock_irq(&input_dev->event_lock);
1714 : :
1715 : : /*
1716 : : * Keys that are pressed now are unlikely to be
1717 : : * still pressed when we resume.
1718 : : */
1719 : : input_dev_release_keys(input_dev);
1720 : :
1721 : : /* Turn off LEDs and sounds, if any are active. */
1722 : : input_dev_toggle(input_dev, false);
1723 : :
1724 : : spin_unlock_irq(&input_dev->event_lock);
1725 : :
1726 : : return 0;
1727 : : }
1728 : :
1729 : : static int input_dev_resume(struct device *dev)
1730 : : {
1731 : : struct input_dev *input_dev = to_input_dev(dev);
1732 : :
1733 : : spin_lock_irq(&input_dev->event_lock);
1734 : :
1735 : : /* Restore state of LEDs and sounds, if any were active. */
1736 : : input_dev_toggle(input_dev, true);
1737 : :
1738 : : spin_unlock_irq(&input_dev->event_lock);
1739 : :
1740 : : return 0;
1741 : : }
1742 : :
1743 : : static int input_dev_freeze(struct device *dev)
1744 : : {
1745 : : struct input_dev *input_dev = to_input_dev(dev);
1746 : :
1747 : : spin_lock_irq(&input_dev->event_lock);
1748 : :
1749 : : /*
1750 : : * Keys that are pressed now are unlikely to be
1751 : : * still pressed when we resume.
1752 : : */
1753 : : input_dev_release_keys(input_dev);
1754 : :
1755 : : spin_unlock_irq(&input_dev->event_lock);
1756 : :
1757 : : return 0;
1758 : : }
1759 : :
1760 : : static int input_dev_poweroff(struct device *dev)
1761 : : {
1762 : : struct input_dev *input_dev = to_input_dev(dev);
1763 : :
1764 : : spin_lock_irq(&input_dev->event_lock);
1765 : :
1766 : : /* Turn off LEDs and sounds, if any are active. */
1767 : : input_dev_toggle(input_dev, false);
1768 : :
1769 : : spin_unlock_irq(&input_dev->event_lock);
1770 : :
1771 : : return 0;
1772 : : }
1773 : :
1774 : : static const struct dev_pm_ops input_dev_pm_ops = {
1775 : : .suspend = input_dev_suspend,
1776 : : .resume = input_dev_resume,
1777 : : .freeze = input_dev_freeze,
1778 : : .poweroff = input_dev_poweroff,
1779 : : .restore = input_dev_resume,
1780 : : };
1781 : : #endif /* CONFIG_PM */
1782 : :
1783 : : static const struct device_type input_dev_type = {
1784 : : .groups = input_dev_attr_groups,
1785 : : .release = input_dev_release,
1786 : : .uevent = input_dev_uevent,
1787 : : #ifdef CONFIG_PM_SLEEP
1788 : : .pm = &input_dev_pm_ops,
1789 : : #endif
1790 : : };
1791 : :
1792 : 3 : static char *input_devnode(struct device *dev, umode_t *mode)
1793 : : {
1794 : 3 : return kasprintf(GFP_KERNEL, "input/%s", dev_name(dev));
1795 : : }
1796 : :
1797 : : struct class input_class = {
1798 : : .name = "input",
1799 : : .devnode = input_devnode,
1800 : : };
1801 : : EXPORT_SYMBOL_GPL(input_class);
1802 : :
1803 : : /**
1804 : : * input_allocate_device - allocate memory for new input device
1805 : : *
1806 : : * Returns prepared struct input_dev or %NULL.
1807 : : *
1808 : : * NOTE: Use input_free_device() to free devices that have not been
1809 : : * registered; input_unregister_device() should be used for already
1810 : : * registered devices.
1811 : : */
1812 : 3 : struct input_dev *input_allocate_device(void)
1813 : : {
1814 : : static atomic_t input_no = ATOMIC_INIT(-1);
1815 : : struct input_dev *dev;
1816 : :
1817 : 3 : dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1818 : 3 : if (dev) {
1819 : 3 : dev->dev.type = &input_dev_type;
1820 : 3 : dev->dev.class = &input_class;
1821 : 3 : device_initialize(&dev->dev);
1822 : 3 : mutex_init(&dev->mutex);
1823 : 3 : spin_lock_init(&dev->event_lock);
1824 : 3 : timer_setup(&dev->timer, NULL, 0);
1825 : 3 : INIT_LIST_HEAD(&dev->h_list);
1826 : 3 : INIT_LIST_HEAD(&dev->node);
1827 : :
1828 : 3 : dev_set_name(&dev->dev, "input%lu",
1829 : 3 : (unsigned long)atomic_inc_return(&input_no));
1830 : :
1831 : 3 : __module_get(THIS_MODULE);
1832 : : }
1833 : :
1834 : 3 : return dev;
1835 : : }
1836 : : EXPORT_SYMBOL(input_allocate_device);
1837 : :
1838 : : struct input_devres {
1839 : : struct input_dev *input;
1840 : : };
1841 : :
1842 : 0 : static int devm_input_device_match(struct device *dev, void *res, void *data)
1843 : : {
1844 : : struct input_devres *devres = res;
1845 : :
1846 : 0 : return devres->input == data;
1847 : : }
1848 : :
1849 : 0 : static void devm_input_device_release(struct device *dev, void *res)
1850 : : {
1851 : : struct input_devres *devres = res;
1852 : 0 : struct input_dev *input = devres->input;
1853 : :
1854 : : dev_dbg(dev, "%s: dropping reference to %s\n",
1855 : : __func__, dev_name(&input->dev));
1856 : : input_put_device(input);
1857 : 0 : }
1858 : :
1859 : : /**
1860 : : * devm_input_allocate_device - allocate managed input device
1861 : : * @dev: device owning the input device being created
1862 : : *
1863 : : * Returns prepared struct input_dev or %NULL.
1864 : : *
1865 : : * Managed input devices do not need to be explicitly unregistered or
1866 : : * freed as it will be done automatically when owner device unbinds from
1867 : : * its driver (or binding fails). Once managed input device is allocated,
1868 : : * it is ready to be set up and registered in the same fashion as regular
1869 : : * input device. There are no special devm_input_device_[un]register()
1870 : : * variants, regular ones work with both managed and unmanaged devices,
1871 : : * should you need them. In most cases however, managed input device need
1872 : : * not be explicitly unregistered or freed.
1873 : : *
1874 : : * NOTE: the owner device is set up as parent of input device and users
1875 : : * should not override it.
1876 : : */
1877 : 0 : struct input_dev *devm_input_allocate_device(struct device *dev)
1878 : : {
1879 : : struct input_dev *input;
1880 : : struct input_devres *devres;
1881 : :
1882 : : devres = devres_alloc(devm_input_device_release,
1883 : : sizeof(*devres), GFP_KERNEL);
1884 : 0 : if (!devres)
1885 : : return NULL;
1886 : :
1887 : 0 : input = input_allocate_device();
1888 : 0 : if (!input) {
1889 : 0 : devres_free(devres);
1890 : 0 : return NULL;
1891 : : }
1892 : :
1893 : 0 : input->dev.parent = dev;
1894 : 0 : input->devres_managed = true;
1895 : :
1896 : 0 : devres->input = input;
1897 : 0 : devres_add(dev, devres);
1898 : :
1899 : 0 : return input;
1900 : : }
1901 : : EXPORT_SYMBOL(devm_input_allocate_device);
1902 : :
1903 : : /**
1904 : : * input_free_device - free memory occupied by input_dev structure
1905 : : * @dev: input device to free
1906 : : *
1907 : : * This function should only be used if input_register_device()
1908 : : * was not called yet or if it failed. Once device was registered
1909 : : * use input_unregister_device() and memory will be freed once last
1910 : : * reference to the device is dropped.
1911 : : *
1912 : : * Device should be allocated by input_allocate_device().
1913 : : *
1914 : : * NOTE: If there are references to the input device then memory
1915 : : * will not be freed until last reference is dropped.
1916 : : */
1917 : 0 : void input_free_device(struct input_dev *dev)
1918 : : {
1919 : 0 : if (dev) {
1920 : 0 : if (dev->devres_managed)
1921 : 0 : WARN_ON(devres_destroy(dev->dev.parent,
1922 : : devm_input_device_release,
1923 : : devm_input_device_match,
1924 : : dev));
1925 : : input_put_device(dev);
1926 : : }
1927 : 0 : }
1928 : : EXPORT_SYMBOL(input_free_device);
1929 : :
1930 : : /**
1931 : : * input_set_timestamp - set timestamp for input events
1932 : : * @dev: input device to set timestamp for
1933 : : * @timestamp: the time at which the event has occurred
1934 : : * in CLOCK_MONOTONIC
1935 : : *
1936 : : * This function is intended to provide to the input system a more
1937 : : * accurate time of when an event actually occurred. The driver should
1938 : : * call this function as soon as a timestamp is acquired ensuring
1939 : : * clock conversions in input_set_timestamp are done correctly.
1940 : : *
1941 : : * The system entering suspend state between timestamp acquisition and
1942 : : * calling input_set_timestamp can result in inaccurate conversions.
1943 : : */
1944 : 3 : void input_set_timestamp(struct input_dev *dev, ktime_t timestamp)
1945 : : {
1946 : 3 : dev->timestamp[INPUT_CLK_MONO] = timestamp;
1947 : 3 : dev->timestamp[INPUT_CLK_REAL] = ktime_mono_to_real(timestamp);
1948 : 3 : dev->timestamp[INPUT_CLK_BOOT] = ktime_mono_to_any(timestamp,
1949 : : TK_OFFS_BOOT);
1950 : 3 : }
1951 : : EXPORT_SYMBOL(input_set_timestamp);
1952 : :
1953 : : /**
1954 : : * input_get_timestamp - get timestamp for input events
1955 : : * @dev: input device to get timestamp from
1956 : : *
1957 : : * A valid timestamp is a timestamp of non-zero value.
1958 : : */
1959 : 3 : ktime_t *input_get_timestamp(struct input_dev *dev)
1960 : : {
1961 : : const ktime_t invalid_timestamp = ktime_set(0, 0);
1962 : :
1963 : 3 : if (!ktime_compare(dev->timestamp[INPUT_CLK_MONO], invalid_timestamp))
1964 : 3 : input_set_timestamp(dev, ktime_get());
1965 : :
1966 : 3 : return dev->timestamp;
1967 : : }
1968 : : EXPORT_SYMBOL(input_get_timestamp);
1969 : :
1970 : : /**
1971 : : * input_set_capability - mark device as capable of a certain event
1972 : : * @dev: device that is capable of emitting or accepting event
1973 : : * @type: type of the event (EV_KEY, EV_REL, etc...)
1974 : : * @code: event code
1975 : : *
1976 : : * In addition to setting up corresponding bit in appropriate capability
1977 : : * bitmap the function also adjusts dev->evbit.
1978 : : */
1979 : 0 : void input_set_capability(struct input_dev *dev, unsigned int type, unsigned int code)
1980 : : {
1981 : 0 : switch (type) {
1982 : : case EV_KEY:
1983 : 0 : __set_bit(code, dev->keybit);
1984 : : break;
1985 : :
1986 : : case EV_REL:
1987 : 0 : __set_bit(code, dev->relbit);
1988 : : break;
1989 : :
1990 : : case EV_ABS:
1991 : 0 : input_alloc_absinfo(dev);
1992 : 0 : if (!dev->absinfo)
1993 : : return;
1994 : :
1995 : 0 : __set_bit(code, dev->absbit);
1996 : : break;
1997 : :
1998 : : case EV_MSC:
1999 : 0 : __set_bit(code, dev->mscbit);
2000 : : break;
2001 : :
2002 : : case EV_SW:
2003 : 0 : __set_bit(code, dev->swbit);
2004 : : break;
2005 : :
2006 : : case EV_LED:
2007 : 0 : __set_bit(code, dev->ledbit);
2008 : : break;
2009 : :
2010 : : case EV_SND:
2011 : 0 : __set_bit(code, dev->sndbit);
2012 : : break;
2013 : :
2014 : : case EV_FF:
2015 : 0 : __set_bit(code, dev->ffbit);
2016 : : break;
2017 : :
2018 : : case EV_PWR:
2019 : : /* do nothing */
2020 : : break;
2021 : :
2022 : : default:
2023 : 0 : pr_err("%s: unknown type %u (code %u)\n", __func__, type, code);
2024 : 0 : dump_stack();
2025 : 0 : return;
2026 : : }
2027 : :
2028 : 0 : __set_bit(type, dev->evbit);
2029 : : }
2030 : : EXPORT_SYMBOL(input_set_capability);
2031 : :
2032 : 3 : static unsigned int input_estimate_events_per_packet(struct input_dev *dev)
2033 : : {
2034 : : int mt_slots;
2035 : : int i;
2036 : : unsigned int events;
2037 : :
2038 : 3 : if (dev->mt) {
2039 : 0 : mt_slots = dev->mt->num_slots;
2040 : 3 : } else if (test_bit(ABS_MT_TRACKING_ID, dev->absbit)) {
2041 : 0 : mt_slots = dev->absinfo[ABS_MT_TRACKING_ID].maximum -
2042 : 0 : dev->absinfo[ABS_MT_TRACKING_ID].minimum + 1,
2043 : 0 : mt_slots = clamp(mt_slots, 2, 32);
2044 : 3 : } else if (test_bit(ABS_MT_POSITION_X, dev->absbit)) {
2045 : : mt_slots = 2;
2046 : : } else {
2047 : : mt_slots = 0;
2048 : : }
2049 : :
2050 : 3 : events = mt_slots + 1; /* count SYN_MT_REPORT and SYN_REPORT */
2051 : :
2052 : 3 : if (test_bit(EV_ABS, dev->evbit))
2053 : 2 : for_each_set_bit(i, dev->absbit, ABS_CNT)
2054 : 2 : events += input_is_mt_axis(i) ? mt_slots : 1;
2055 : :
2056 : 3 : if (test_bit(EV_REL, dev->evbit))
2057 : 3 : events += bitmap_weight(dev->relbit, REL_CNT);
2058 : :
2059 : : /* Make room for KEY and MSC events */
2060 : 3 : events += 7;
2061 : :
2062 : 3 : return events;
2063 : : }
2064 : :
2065 : : #define INPUT_CLEANSE_BITMASK(dev, type, bits) \
2066 : : do { \
2067 : : if (!test_bit(EV_##type, dev->evbit)) \
2068 : : memset(dev->bits##bit, 0, \
2069 : : sizeof(dev->bits##bit)); \
2070 : : } while (0)
2071 : :
2072 : 3 : static void input_cleanse_bitmasks(struct input_dev *dev)
2073 : : {
2074 : 3 : INPUT_CLEANSE_BITMASK(dev, KEY, key);
2075 : 3 : INPUT_CLEANSE_BITMASK(dev, REL, rel);
2076 : 3 : INPUT_CLEANSE_BITMASK(dev, ABS, abs);
2077 : 3 : INPUT_CLEANSE_BITMASK(dev, MSC, msc);
2078 : 3 : INPUT_CLEANSE_BITMASK(dev, LED, led);
2079 : 3 : INPUT_CLEANSE_BITMASK(dev, SND, snd);
2080 : 3 : INPUT_CLEANSE_BITMASK(dev, FF, ff);
2081 : 3 : INPUT_CLEANSE_BITMASK(dev, SW, sw);
2082 : 3 : }
2083 : :
2084 : 0 : static void __input_unregister_device(struct input_dev *dev)
2085 : : {
2086 : : struct input_handle *handle, *next;
2087 : :
2088 : 0 : input_disconnect_device(dev);
2089 : :
2090 : 0 : mutex_lock(&input_mutex);
2091 : :
2092 : 0 : list_for_each_entry_safe(handle, next, &dev->h_list, d_node)
2093 : 0 : handle->handler->disconnect(handle);
2094 : 0 : WARN_ON(!list_empty(&dev->h_list));
2095 : :
2096 : 0 : del_timer_sync(&dev->timer);
2097 : 0 : list_del_init(&dev->node);
2098 : :
2099 : 0 : input_wakeup_procfs_readers();
2100 : :
2101 : 0 : mutex_unlock(&input_mutex);
2102 : :
2103 : 0 : device_del(&dev->dev);
2104 : 0 : }
2105 : :
2106 : 0 : static void devm_input_device_unregister(struct device *dev, void *res)
2107 : : {
2108 : : struct input_devres *devres = res;
2109 : 0 : struct input_dev *input = devres->input;
2110 : :
2111 : : dev_dbg(dev, "%s: unregistering device %s\n",
2112 : : __func__, dev_name(&input->dev));
2113 : 0 : __input_unregister_device(input);
2114 : 0 : }
2115 : :
2116 : : /**
2117 : : * input_enable_softrepeat - enable software autorepeat
2118 : : * @dev: input device
2119 : : * @delay: repeat delay
2120 : : * @period: repeat period
2121 : : *
2122 : : * Enable software autorepeat on the input device.
2123 : : */
2124 : 0 : void input_enable_softrepeat(struct input_dev *dev, int delay, int period)
2125 : : {
2126 : 3 : dev->timer.function = input_repeat_key;
2127 : 3 : dev->rep[REP_DELAY] = delay;
2128 : 3 : dev->rep[REP_PERIOD] = period;
2129 : 0 : }
2130 : : EXPORT_SYMBOL(input_enable_softrepeat);
2131 : :
2132 : : /**
2133 : : * input_register_device - register device with input core
2134 : : * @dev: device to be registered
2135 : : *
2136 : : * This function registers device with input core. The device must be
2137 : : * allocated with input_allocate_device() and all it's capabilities
2138 : : * set up before registering.
2139 : : * If function fails the device must be freed with input_free_device().
2140 : : * Once device has been successfully registered it can be unregistered
2141 : : * with input_unregister_device(); input_free_device() should not be
2142 : : * called in this case.
2143 : : *
2144 : : * Note that this function is also used to register managed input devices
2145 : : * (ones allocated with devm_input_allocate_device()). Such managed input
2146 : : * devices need not be explicitly unregistered or freed, their tear down
2147 : : * is controlled by the devres infrastructure. It is also worth noting
2148 : : * that tear down of managed input devices is internally a 2-step process:
2149 : : * registered managed input device is first unregistered, but stays in
2150 : : * memory and can still handle input_event() calls (although events will
2151 : : * not be delivered anywhere). The freeing of managed input device will
2152 : : * happen later, when devres stack is unwound to the point where device
2153 : : * allocation was made.
2154 : : */
2155 : 3 : int input_register_device(struct input_dev *dev)
2156 : : {
2157 : : struct input_devres *devres = NULL;
2158 : : struct input_handler *handler;
2159 : : unsigned int packet_size;
2160 : : const char *path;
2161 : : int error;
2162 : :
2163 : 3 : if (test_bit(EV_ABS, dev->evbit) && !dev->absinfo) {
2164 : 0 : dev_err(&dev->dev,
2165 : : "Absolute device without dev->absinfo, refusing to register\n");
2166 : 0 : return -EINVAL;
2167 : : }
2168 : :
2169 : 3 : if (dev->devres_managed) {
2170 : : devres = devres_alloc(devm_input_device_unregister,
2171 : : sizeof(*devres), GFP_KERNEL);
2172 : 0 : if (!devres)
2173 : : return -ENOMEM;
2174 : :
2175 : 0 : devres->input = dev;
2176 : : }
2177 : :
2178 : : /* Every input device generates EV_SYN/SYN_REPORT events. */
2179 : : __set_bit(EV_SYN, dev->evbit);
2180 : :
2181 : : /* KEY_RESERVED is not supposed to be transmitted to userspace. */
2182 : : __clear_bit(KEY_RESERVED, dev->keybit);
2183 : :
2184 : : /* Make sure that bitmasks not mentioned in dev->evbit are clean. */
2185 : 3 : input_cleanse_bitmasks(dev);
2186 : :
2187 : 3 : packet_size = input_estimate_events_per_packet(dev);
2188 : 3 : if (dev->hint_events_per_packet < packet_size)
2189 : 3 : dev->hint_events_per_packet = packet_size;
2190 : :
2191 : 3 : dev->max_vals = dev->hint_events_per_packet + 2;
2192 : 3 : dev->vals = kcalloc(dev->max_vals, sizeof(*dev->vals), GFP_KERNEL);
2193 : 3 : if (!dev->vals) {
2194 : : error = -ENOMEM;
2195 : : goto err_devres_free;
2196 : : }
2197 : :
2198 : : /*
2199 : : * If delay and period are pre-set by the driver, then autorepeating
2200 : : * is handled by the driver itself and we don't do it in input.c.
2201 : : */
2202 : 3 : if (!dev->rep[REP_DELAY] && !dev->rep[REP_PERIOD])
2203 : : input_enable_softrepeat(dev, 250, 33);
2204 : :
2205 : 3 : if (!dev->getkeycode)
2206 : 0 : dev->getkeycode = input_default_getkeycode;
2207 : :
2208 : 3 : if (!dev->setkeycode)
2209 : 0 : dev->setkeycode = input_default_setkeycode;
2210 : :
2211 : 3 : if (dev->poller)
2212 : 0 : input_dev_poller_finalize(dev->poller);
2213 : :
2214 : 3 : error = device_add(&dev->dev);
2215 : 3 : if (error)
2216 : : goto err_free_vals;
2217 : :
2218 : 3 : path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);
2219 : 3 : pr_info("%s as %s\n",
2220 : : dev->name ? dev->name : "Unspecified device",
2221 : : path ? path : "N/A");
2222 : 3 : kfree(path);
2223 : :
2224 : 3 : error = mutex_lock_interruptible(&input_mutex);
2225 : 3 : if (error)
2226 : : goto err_device_del;
2227 : :
2228 : 3 : list_add_tail(&dev->node, &input_dev_list);
2229 : :
2230 : 3 : list_for_each_entry(handler, &input_handler_list, node)
2231 : 3 : input_attach_handler(dev, handler);
2232 : :
2233 : 3 : input_wakeup_procfs_readers();
2234 : :
2235 : 3 : mutex_unlock(&input_mutex);
2236 : :
2237 : 3 : if (dev->devres_managed) {
2238 : : dev_dbg(dev->dev.parent, "%s: registering %s with devres.\n",
2239 : : __func__, dev_name(&dev->dev));
2240 : 0 : devres_add(dev->dev.parent, devres);
2241 : : }
2242 : : return 0;
2243 : :
2244 : : err_device_del:
2245 : 0 : device_del(&dev->dev);
2246 : : err_free_vals:
2247 : 0 : kfree(dev->vals);
2248 : 0 : dev->vals = NULL;
2249 : : err_devres_free:
2250 : 0 : devres_free(devres);
2251 : 0 : return error;
2252 : : }
2253 : : EXPORT_SYMBOL(input_register_device);
2254 : :
2255 : : /**
2256 : : * input_unregister_device - unregister previously registered device
2257 : : * @dev: device to be unregistered
2258 : : *
2259 : : * This function unregisters an input device. Once device is unregistered
2260 : : * the caller should not try to access it as it may get freed at any moment.
2261 : : */
2262 : 0 : void input_unregister_device(struct input_dev *dev)
2263 : : {
2264 : 0 : if (dev->devres_managed) {
2265 : 0 : WARN_ON(devres_destroy(dev->dev.parent,
2266 : : devm_input_device_unregister,
2267 : : devm_input_device_match,
2268 : : dev));
2269 : 0 : __input_unregister_device(dev);
2270 : : /*
2271 : : * We do not do input_put_device() here because it will be done
2272 : : * when 2nd devres fires up.
2273 : : */
2274 : : } else {
2275 : 0 : __input_unregister_device(dev);
2276 : : input_put_device(dev);
2277 : : }
2278 : 0 : }
2279 : : EXPORT_SYMBOL(input_unregister_device);
2280 : :
2281 : : /**
2282 : : * input_register_handler - register a new input handler
2283 : : * @handler: handler to be registered
2284 : : *
2285 : : * This function registers a new input handler (interface) for input
2286 : : * devices in the system and attaches it to all input devices that
2287 : : * are compatible with the handler.
2288 : : */
2289 : 3 : int input_register_handler(struct input_handler *handler)
2290 : : {
2291 : : struct input_dev *dev;
2292 : : int error;
2293 : :
2294 : 3 : error = mutex_lock_interruptible(&input_mutex);
2295 : 3 : if (error)
2296 : : return error;
2297 : :
2298 : 3 : INIT_LIST_HEAD(&handler->h_list);
2299 : :
2300 : 3 : list_add_tail(&handler->node, &input_handler_list);
2301 : :
2302 : 3 : list_for_each_entry(dev, &input_dev_list, node)
2303 : 3 : input_attach_handler(dev, handler);
2304 : :
2305 : 3 : input_wakeup_procfs_readers();
2306 : :
2307 : 3 : mutex_unlock(&input_mutex);
2308 : 3 : return 0;
2309 : : }
2310 : : EXPORT_SYMBOL(input_register_handler);
2311 : :
2312 : : /**
2313 : : * input_unregister_handler - unregisters an input handler
2314 : : * @handler: handler to be unregistered
2315 : : *
2316 : : * This function disconnects a handler from its input devices and
2317 : : * removes it from lists of known handlers.
2318 : : */
2319 : 0 : void input_unregister_handler(struct input_handler *handler)
2320 : : {
2321 : : struct input_handle *handle, *next;
2322 : :
2323 : 0 : mutex_lock(&input_mutex);
2324 : :
2325 : 0 : list_for_each_entry_safe(handle, next, &handler->h_list, h_node)
2326 : 0 : handler->disconnect(handle);
2327 : 0 : WARN_ON(!list_empty(&handler->h_list));
2328 : :
2329 : 0 : list_del_init(&handler->node);
2330 : :
2331 : 0 : input_wakeup_procfs_readers();
2332 : :
2333 : 0 : mutex_unlock(&input_mutex);
2334 : 0 : }
2335 : : EXPORT_SYMBOL(input_unregister_handler);
2336 : :
2337 : : /**
2338 : : * input_handler_for_each_handle - handle iterator
2339 : : * @handler: input handler to iterate
2340 : : * @data: data for the callback
2341 : : * @fn: function to be called for each handle
2342 : : *
2343 : : * Iterate over @bus's list of devices, and call @fn for each, passing
2344 : : * it @data and stop when @fn returns a non-zero value. The function is
2345 : : * using RCU to traverse the list and therefore may be using in atomic
2346 : : * contexts. The @fn callback is invoked from RCU critical section and
2347 : : * thus must not sleep.
2348 : : */
2349 : 0 : int input_handler_for_each_handle(struct input_handler *handler, void *data,
2350 : : int (*fn)(struct input_handle *, void *))
2351 : : {
2352 : : struct input_handle *handle;
2353 : : int retval = 0;
2354 : :
2355 : : rcu_read_lock();
2356 : :
2357 : 0 : list_for_each_entry_rcu(handle, &handler->h_list, h_node) {
2358 : 0 : retval = fn(handle, data);
2359 : 0 : if (retval)
2360 : : break;
2361 : : }
2362 : :
2363 : : rcu_read_unlock();
2364 : :
2365 : 0 : return retval;
2366 : : }
2367 : : EXPORT_SYMBOL(input_handler_for_each_handle);
2368 : :
2369 : : /**
2370 : : * input_register_handle - register a new input handle
2371 : : * @handle: handle to register
2372 : : *
2373 : : * This function puts a new input handle onto device's
2374 : : * and handler's lists so that events can flow through
2375 : : * it once it is opened using input_open_device().
2376 : : *
2377 : : * This function is supposed to be called from handler's
2378 : : * connect() method.
2379 : : */
2380 : 3 : int input_register_handle(struct input_handle *handle)
2381 : : {
2382 : 3 : struct input_handler *handler = handle->handler;
2383 : 3 : struct input_dev *dev = handle->dev;
2384 : : int error;
2385 : :
2386 : : /*
2387 : : * We take dev->mutex here to prevent race with
2388 : : * input_release_device().
2389 : : */
2390 : 3 : error = mutex_lock_interruptible(&dev->mutex);
2391 : 3 : if (error)
2392 : : return error;
2393 : :
2394 : : /*
2395 : : * Filters go to the head of the list, normal handlers
2396 : : * to the tail.
2397 : : */
2398 : 3 : if (handler->filter)
2399 : 3 : list_add_rcu(&handle->d_node, &dev->h_list);
2400 : : else
2401 : 3 : list_add_tail_rcu(&handle->d_node, &dev->h_list);
2402 : :
2403 : 3 : mutex_unlock(&dev->mutex);
2404 : :
2405 : : /*
2406 : : * Since we are supposed to be called from ->connect()
2407 : : * which is mutually exclusive with ->disconnect()
2408 : : * we can't be racing with input_unregister_handle()
2409 : : * and so separate lock is not needed here.
2410 : : */
2411 : 3 : list_add_tail_rcu(&handle->h_node, &handler->h_list);
2412 : :
2413 : 3 : if (handler->start)
2414 : 3 : handler->start(handle);
2415 : :
2416 : : return 0;
2417 : : }
2418 : : EXPORT_SYMBOL(input_register_handle);
2419 : :
2420 : : /**
2421 : : * input_unregister_handle - unregister an input handle
2422 : : * @handle: handle to unregister
2423 : : *
2424 : : * This function removes input handle from device's
2425 : : * and handler's lists.
2426 : : *
2427 : : * This function is supposed to be called from handler's
2428 : : * disconnect() method.
2429 : : */
2430 : 0 : void input_unregister_handle(struct input_handle *handle)
2431 : : {
2432 : 0 : struct input_dev *dev = handle->dev;
2433 : :
2434 : : list_del_rcu(&handle->h_node);
2435 : :
2436 : : /*
2437 : : * Take dev->mutex to prevent race with input_release_device().
2438 : : */
2439 : 0 : mutex_lock(&dev->mutex);
2440 : : list_del_rcu(&handle->d_node);
2441 : 0 : mutex_unlock(&dev->mutex);
2442 : :
2443 : 0 : synchronize_rcu();
2444 : 0 : }
2445 : : EXPORT_SYMBOL(input_unregister_handle);
2446 : :
2447 : : /**
2448 : : * input_get_new_minor - allocates a new input minor number
2449 : : * @legacy_base: beginning or the legacy range to be searched
2450 : : * @legacy_num: size of legacy range
2451 : : * @allow_dynamic: whether we can also take ID from the dynamic range
2452 : : *
2453 : : * This function allocates a new device minor for from input major namespace.
2454 : : * Caller can request legacy minor by specifying @legacy_base and @legacy_num
2455 : : * parameters and whether ID can be allocated from dynamic range if there are
2456 : : * no free IDs in legacy range.
2457 : : */
2458 : 3 : int input_get_new_minor(int legacy_base, unsigned int legacy_num,
2459 : : bool allow_dynamic)
2460 : : {
2461 : : /*
2462 : : * This function should be called from input handler's ->connect()
2463 : : * methods, which are serialized with input_mutex, so no additional
2464 : : * locking is needed here.
2465 : : */
2466 : 3 : if (legacy_base >= 0) {
2467 : 3 : int minor = ida_simple_get(&input_ida,
2468 : : legacy_base,
2469 : : legacy_base + legacy_num,
2470 : : GFP_KERNEL);
2471 : 3 : if (minor >= 0 || !allow_dynamic)
2472 : : return minor;
2473 : : }
2474 : :
2475 : 0 : return ida_simple_get(&input_ida,
2476 : : INPUT_FIRST_DYNAMIC_DEV, INPUT_MAX_CHAR_DEVICES,
2477 : : GFP_KERNEL);
2478 : : }
2479 : : EXPORT_SYMBOL(input_get_new_minor);
2480 : :
2481 : : /**
2482 : : * input_free_minor - release previously allocated minor
2483 : : * @minor: minor to be released
2484 : : *
2485 : : * This function releases previously allocated input minor so that it can be
2486 : : * reused later.
2487 : : */
2488 : 0 : void input_free_minor(unsigned int minor)
2489 : : {
2490 : 0 : ida_simple_remove(&input_ida, minor);
2491 : 0 : }
2492 : : EXPORT_SYMBOL(input_free_minor);
2493 : :
2494 : 3 : static int __init input_init(void)
2495 : : {
2496 : : int err;
2497 : :
2498 : 3 : err = class_register(&input_class);
2499 : 3 : if (err) {
2500 : 0 : pr_err("unable to register input_dev class\n");
2501 : 0 : return err;
2502 : : }
2503 : :
2504 : 3 : err = input_proc_init();
2505 : 3 : if (err)
2506 : : goto fail1;
2507 : :
2508 : 3 : err = register_chrdev_region(MKDEV(INPUT_MAJOR, 0),
2509 : : INPUT_MAX_CHAR_DEVICES, "input");
2510 : 3 : if (err) {
2511 : 0 : pr_err("unable to register char major %d", INPUT_MAJOR);
2512 : : goto fail2;
2513 : : }
2514 : :
2515 : : return 0;
2516 : :
2517 : 0 : fail2: input_proc_exit();
2518 : 0 : fail1: class_unregister(&input_class);
2519 : 0 : return err;
2520 : : }
2521 : :
2522 : 0 : static void __exit input_exit(void)
2523 : : {
2524 : 0 : input_proc_exit();
2525 : 0 : unregister_chrdev_region(MKDEV(INPUT_MAJOR, 0),
2526 : : INPUT_MAX_CHAR_DEVICES);
2527 : 0 : class_unregister(&input_class);
2528 : 0 : }
2529 : :
2530 : : subsys_initcall(input_init);
2531 : : module_exit(input_exit);
|
