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