blob: 6365c19582644b83baea63d5932a696f7de7c3b9 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * The input core
3 *
4 * Copyright (c) 1999-2002 Vojtech Pavlik
5 */
6
7/*
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License version 2 as published by
10 * the Free Software Foundation.
11 */
12
Joe Perchesda0c4902010-11-29 23:33:07 -080013#define pr_fmt(fmt) KBUILD_BASENAME ": " fmt
14
Linus Torvalds1da177e2005-04-16 15:20:36 -070015#include <linux/init.h>
Dmitry Torokhovffd0db92009-09-16 01:06:43 -070016#include <linux/types.h>
Dmitry Torokhov7f8d4ca2012-10-08 09:07:24 -070017#include <linux/idr.h>
Henrik Rydberg47c78e82010-11-27 09:16:48 +010018#include <linux/input/mt.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#include <linux/module.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090020#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070021#include <linux/random.h>
22#include <linux/major.h>
23#include <linux/proc_fs.h>
Alexey Dobriyana99bbaf2009-10-04 16:11:37 +040024#include <linux/sched.h>
Dmitry Torokhov969b21c2006-04-02 00:09:34 -050025#include <linux/seq_file.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070026#include <linux/poll.h>
27#include <linux/device.h>
Jes Sorensene676c232006-02-19 00:21:46 -050028#include <linux/mutex.h>
Dmitry Torokhov80064792007-08-30 00:22:11 -040029#include <linux/rcupdate.h>
Dmitry Torokhov15e184a2010-01-11 00:05:43 -080030#include "input-compat.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070031
32MODULE_AUTHOR("Vojtech Pavlik <vojtech@suse.cz>");
33MODULE_DESCRIPTION("Input core");
34MODULE_LICENSE("GPL");
35
Dmitry Torokhov7f8d4ca2012-10-08 09:07:24 -070036#define INPUT_MAX_CHAR_DEVICES 1024
37#define INPUT_FIRST_DYNAMIC_DEV 256
38static DEFINE_IDA(input_ida);
Linus Torvalds1da177e2005-04-16 15:20:36 -070039
40static LIST_HEAD(input_dev_list);
41static LIST_HEAD(input_handler_list);
42
Dmitry Torokhov80064792007-08-30 00:22:11 -040043/*
44 * input_mutex protects access to both input_dev_list and input_handler_list.
45 * This also causes input_[un]register_device and input_[un]register_handler
46 * be mutually exclusive which simplifies locking in drivers implementing
47 * input handlers.
48 */
49static DEFINE_MUTEX(input_mutex);
50
Henrik Rydberg4369c642012-09-15 15:23:35 +020051static const struct input_value input_value_sync = { EV_SYN, SYN_REPORT, 1 };
52
Dmitry Torokhov80064792007-08-30 00:22:11 -040053static inline int is_event_supported(unsigned int code,
54 unsigned long *bm, unsigned int max)
55{
56 return code <= max && test_bit(code, bm);
57}
58
59static int input_defuzz_abs_event(int value, int old_val, int fuzz)
60{
61 if (fuzz) {
62 if (value > old_val - fuzz / 2 && value < old_val + fuzz / 2)
63 return old_val;
64
65 if (value > old_val - fuzz && value < old_val + fuzz)
66 return (old_val * 3 + value) / 4;
67
68 if (value > old_val - fuzz * 2 && value < old_val + fuzz * 2)
69 return (old_val + value) / 2;
70 }
71
72 return value;
73}
74
Dmitry Torokhov80064792007-08-30 00:22:11 -040075static void input_start_autorepeat(struct input_dev *dev, int code)
76{
77 if (test_bit(EV_REP, dev->evbit) &&
78 dev->rep[REP_PERIOD] && dev->rep[REP_DELAY] &&
Kees Cook4e974c12017-11-03 12:21:48 -070079 dev->timer.function) {
Dmitry Torokhov80064792007-08-30 00:22:11 -040080 dev->repeat_key = code;
81 mod_timer(&dev->timer,
82 jiffies + msecs_to_jiffies(dev->rep[REP_DELAY]));
83 }
84}
85
Johannes Berge7b5c1e2009-01-29 23:17:52 -080086static void input_stop_autorepeat(struct input_dev *dev)
87{
88 del_timer(&dev->timer);
89}
90
Dmitry Torokhov80064792007-08-30 00:22:11 -040091/*
92 * Pass event first through all filters and then, if event has not been
93 * filtered out, through all open handles. This function is called with
94 * dev->event_lock held and interrupts disabled.
95 */
Henrik Rydberg4369c642012-09-15 15:23:35 +020096static unsigned int input_to_handler(struct input_handle *handle,
97 struct input_value *vals, unsigned int count)
Dmitry Torokhov80064792007-08-30 00:22:11 -040098{
Henrik Rydberg4369c642012-09-15 15:23:35 +020099 struct input_handler *handler = handle->handler;
100 struct input_value *end = vals;
101 struct input_value *v;
102
Anshul Garg2c50ad342015-01-08 13:47:37 -0800103 if (handler->filter) {
104 for (v = vals; v != vals + count; v++) {
105 if (handler->filter(handle, v->type, v->code, v->value))
106 continue;
107 if (end != v)
108 *end = *v;
109 end++;
110 }
111 count = end - vals;
Henrik Rydberg4369c642012-09-15 15:23:35 +0200112 }
113
Henrik Rydberg4369c642012-09-15 15:23:35 +0200114 if (!count)
115 return 0;
116
117 if (handler->events)
118 handler->events(handle, vals, count);
119 else if (handler->event)
Anshul Garg2c50ad342015-01-08 13:47:37 -0800120 for (v = vals; v != vals + count; v++)
Henrik Rydberg4369c642012-09-15 15:23:35 +0200121 handler->event(handle, v->type, v->code, v->value);
122
123 return count;
124}
125
126/*
127 * Pass values first through all filters and then, if event has not been
128 * filtered out, through all open handles. This function is called with
129 * dev->event_lock held and interrupts disabled.
130 */
131static void input_pass_values(struct input_dev *dev,
132 struct input_value *vals, unsigned int count)
133{
Dmitry Torokhov80064792007-08-30 00:22:11 -0400134 struct input_handle *handle;
Henrik Rydberg4369c642012-09-15 15:23:35 +0200135 struct input_value *v;
136
137 if (!count)
138 return;
Dmitry Torokhov80064792007-08-30 00:22:11 -0400139
140 rcu_read_lock();
141
142 handle = rcu_dereference(dev->grab);
Henrik Rydberg4369c642012-09-15 15:23:35 +0200143 if (handle) {
144 count = input_to_handler(handle, vals, count);
145 } else {
146 list_for_each_entry_rcu(handle, &dev->h_list, d_node)
Anshul Garg2c50ad342015-01-08 13:47:37 -0800147 if (handle->open) {
Henrik Rydberg4369c642012-09-15 15:23:35 +0200148 count = input_to_handler(handle, vals, count);
Anshul Garg2c50ad342015-01-08 13:47:37 -0800149 if (!count)
150 break;
151 }
Dmitry Torokhov80064792007-08-30 00:22:11 -0400152 }
153
154 rcu_read_unlock();
Henrik Rydberg352ac4b2012-08-10 21:36:15 +0200155
Henrik Rydberg4369c642012-09-15 15:23:35 +0200156 /* trigger auto repeat for key events */
Anshul Garg5ab17142015-01-08 13:41:24 -0800157 if (test_bit(EV_REP, dev->evbit) && test_bit(EV_KEY, dev->evbit)) {
158 for (v = vals; v != vals + count; v++) {
159 if (v->type == EV_KEY && v->value != 2) {
160 if (v->value)
161 input_start_autorepeat(dev, v->code);
162 else
163 input_stop_autorepeat(dev);
164 }
Henrik Rydberg4369c642012-09-15 15:23:35 +0200165 }
166 }
167}
168
169static void input_pass_event(struct input_dev *dev,
170 unsigned int type, unsigned int code, int value)
171{
172 struct input_value vals[] = { { type, code, value } };
173
174 input_pass_values(dev, vals, ARRAY_SIZE(vals));
Dmitry Torokhov80064792007-08-30 00:22:11 -0400175}
176
177/*
178 * Generate software autorepeat event. Note that we take
179 * dev->event_lock here to avoid racing with input_event
180 * which may cause keys get "stuck".
181 */
Kees Cook4e974c12017-11-03 12:21:48 -0700182static void input_repeat_key(struct timer_list *t)
Dmitry Torokhov80064792007-08-30 00:22:11 -0400183{
Kees Cook4e974c12017-11-03 12:21:48 -0700184 struct input_dev *dev = from_timer(dev, t, timer);
Dmitry Torokhov80064792007-08-30 00:22:11 -0400185 unsigned long flags;
186
187 spin_lock_irqsave(&dev->event_lock, flags);
188
189 if (test_bit(dev->repeat_key, dev->key) &&
190 is_event_supported(dev->repeat_key, dev->keybit, KEY_MAX)) {
Henrik Rydberg4369c642012-09-15 15:23:35 +0200191 struct input_value vals[] = {
192 { EV_KEY, dev->repeat_key, 2 },
193 input_value_sync
194 };
Dmitry Torokhov80064792007-08-30 00:22:11 -0400195
Henrik Rydberg4369c642012-09-15 15:23:35 +0200196 input_pass_values(dev, vals, ARRAY_SIZE(vals));
Dmitry Torokhov80064792007-08-30 00:22:11 -0400197
198 if (dev->rep[REP_PERIOD])
199 mod_timer(&dev->timer, jiffies +
200 msecs_to_jiffies(dev->rep[REP_PERIOD]));
201 }
202
203 spin_unlock_irqrestore(&dev->event_lock, flags);
204}
205
Dmitry Torokhov80064792007-08-30 00:22:11 -0400206#define INPUT_IGNORE_EVENT 0
207#define INPUT_PASS_TO_HANDLERS 1
208#define INPUT_PASS_TO_DEVICE 2
Henrik Rydberg4369c642012-09-15 15:23:35 +0200209#define INPUT_SLOT 4
210#define INPUT_FLUSH 8
Dmitry Torokhov80064792007-08-30 00:22:11 -0400211#define INPUT_PASS_TO_ALL (INPUT_PASS_TO_HANDLERS | INPUT_PASS_TO_DEVICE)
212
Henrik Rydberg40d007e2010-07-15 23:10:10 -0700213static int input_handle_abs_event(struct input_dev *dev,
214 unsigned int code, int *pval)
215{
Henrik Rydberg8d18fba2012-09-15 15:15:58 +0200216 struct input_mt *mt = dev->mt;
Henrik Rydberg40d007e2010-07-15 23:10:10 -0700217 bool is_mt_event;
218 int *pold;
219
220 if (code == ABS_MT_SLOT) {
221 /*
222 * "Stage" the event; we'll flush it later, when we
Dmitry Torokhov144c0f82010-09-03 10:31:05 -0700223 * get actual touch data.
Henrik Rydberg40d007e2010-07-15 23:10:10 -0700224 */
Henrik Rydberg8d18fba2012-09-15 15:15:58 +0200225 if (mt && *pval >= 0 && *pval < mt->num_slots)
226 mt->slot = *pval;
Henrik Rydberg40d007e2010-07-15 23:10:10 -0700227
228 return INPUT_IGNORE_EVENT;
229 }
230
Henrik Rydbergb89529a2012-01-12 19:40:34 +0100231 is_mt_event = input_is_mt_value(code);
Henrik Rydberg40d007e2010-07-15 23:10:10 -0700232
233 if (!is_mt_event) {
Daniel Mackd31b2862010-08-02 20:18:21 -0700234 pold = &dev->absinfo[code].value;
Henrik Rydberg8d18fba2012-09-15 15:15:58 +0200235 } else if (mt) {
236 pold = &mt->slots[mt->slot].abs[code - ABS_MT_FIRST];
Henrik Rydberg40d007e2010-07-15 23:10:10 -0700237 } else {
238 /*
Dmitry Torokhov144c0f82010-09-03 10:31:05 -0700239 * Bypass filtering for multi-touch events when
Henrik Rydberg40d007e2010-07-15 23:10:10 -0700240 * not employing slots.
241 */
242 pold = NULL;
243 }
244
245 if (pold) {
246 *pval = input_defuzz_abs_event(*pval, *pold,
Daniel Mackd31b2862010-08-02 20:18:21 -0700247 dev->absinfo[code].fuzz);
Henrik Rydberg40d007e2010-07-15 23:10:10 -0700248 if (*pold == *pval)
249 return INPUT_IGNORE_EVENT;
250
251 *pold = *pval;
252 }
253
254 /* Flush pending "slot" event */
Henrik Rydberg8d18fba2012-09-15 15:15:58 +0200255 if (is_mt_event && mt && mt->slot != input_abs_get_val(dev, ABS_MT_SLOT)) {
256 input_abs_set_val(dev, ABS_MT_SLOT, mt->slot);
Henrik Rydberg4369c642012-09-15 15:23:35 +0200257 return INPUT_PASS_TO_HANDLERS | INPUT_SLOT;
Henrik Rydberg40d007e2010-07-15 23:10:10 -0700258 }
259
260 return INPUT_PASS_TO_HANDLERS;
261}
262
Henrik Rydberg4369c642012-09-15 15:23:35 +0200263static int input_get_disposition(struct input_dev *dev,
Dmitry Torokhov50c5d362014-07-19 16:30:31 -0700264 unsigned int type, unsigned int code, int *pval)
Dmitry Torokhov80064792007-08-30 00:22:11 -0400265{
266 int disposition = INPUT_IGNORE_EVENT;
Dmitry Torokhov50c5d362014-07-19 16:30:31 -0700267 int value = *pval;
Dmitry Torokhov80064792007-08-30 00:22:11 -0400268
269 switch (type) {
270
271 case EV_SYN:
272 switch (code) {
273 case SYN_CONFIG:
274 disposition = INPUT_PASS_TO_ALL;
275 break;
276
277 case SYN_REPORT:
Henrik Rydberg4369c642012-09-15 15:23:35 +0200278 disposition = INPUT_PASS_TO_HANDLERS | INPUT_FLUSH;
Dmitry Torokhov80064792007-08-30 00:22:11 -0400279 break;
Henrik Rydberg5e5ee682009-04-28 07:47:33 -0700280 case SYN_MT_REPORT:
Henrik Rydberg5e5ee682009-04-28 07:47:33 -0700281 disposition = INPUT_PASS_TO_HANDLERS;
282 break;
Dmitry Torokhov80064792007-08-30 00:22:11 -0400283 }
284 break;
285
286 case EV_KEY:
Henrik Rydberg06721202012-08-10 21:39:38 +0200287 if (is_event_supported(code, dev->keybit, KEY_MAX)) {
Dmitry Torokhov80064792007-08-30 00:22:11 -0400288
Henrik Rydberg06721202012-08-10 21:39:38 +0200289 /* auto-repeat bypasses state updates */
290 if (value == 2) {
291 disposition = INPUT_PASS_TO_HANDLERS;
292 break;
Dmitry Torokhov80064792007-08-30 00:22:11 -0400293 }
294
Henrik Rydberg06721202012-08-10 21:39:38 +0200295 if (!!test_bit(code, dev->key) != !!value) {
296
Dmitry Torokhov80064792007-08-30 00:22:11 -0400297 __change_bit(code, dev->key);
Henrik Rydberg06721202012-08-10 21:39:38 +0200298 disposition = INPUT_PASS_TO_HANDLERS;
Dmitry Torokhov80064792007-08-30 00:22:11 -0400299 }
Dmitry Torokhov80064792007-08-30 00:22:11 -0400300 }
301 break;
302
303 case EV_SW:
304 if (is_event_supported(code, dev->swbit, SW_MAX) &&
Henrik Rydberg06721202012-08-10 21:39:38 +0200305 !!test_bit(code, dev->sw) != !!value) {
Dmitry Torokhov80064792007-08-30 00:22:11 -0400306
307 __change_bit(code, dev->sw);
308 disposition = INPUT_PASS_TO_HANDLERS;
309 }
310 break;
311
312 case EV_ABS:
Henrik Rydberg40d007e2010-07-15 23:10:10 -0700313 if (is_event_supported(code, dev->absbit, ABS_MAX))
Dmitry Torokhov9ae43452011-02-02 23:04:27 -0800314 disposition = input_handle_abs_event(dev, code, &value);
Dmitry Torokhov80064792007-08-30 00:22:11 -0400315
Dmitry Torokhov80064792007-08-30 00:22:11 -0400316 break;
317
318 case EV_REL:
319 if (is_event_supported(code, dev->relbit, REL_MAX) && value)
320 disposition = INPUT_PASS_TO_HANDLERS;
321
322 break;
323
324 case EV_MSC:
325 if (is_event_supported(code, dev->mscbit, MSC_MAX))
326 disposition = INPUT_PASS_TO_ALL;
327
328 break;
329
330 case EV_LED:
331 if (is_event_supported(code, dev->ledbit, LED_MAX) &&
Henrik Rydberg06721202012-08-10 21:39:38 +0200332 !!test_bit(code, dev->led) != !!value) {
Dmitry Torokhov80064792007-08-30 00:22:11 -0400333
334 __change_bit(code, dev->led);
335 disposition = INPUT_PASS_TO_ALL;
336 }
337 break;
338
339 case EV_SND:
340 if (is_event_supported(code, dev->sndbit, SND_MAX)) {
341
342 if (!!test_bit(code, dev->snd) != !!value)
343 __change_bit(code, dev->snd);
344 disposition = INPUT_PASS_TO_ALL;
345 }
346 break;
347
348 case EV_REP:
349 if (code <= REP_MAX && value >= 0 && dev->rep[code] != value) {
350 dev->rep[code] = value;
351 disposition = INPUT_PASS_TO_ALL;
352 }
353 break;
354
355 case EV_FF:
356 if (value >= 0)
357 disposition = INPUT_PASS_TO_ALL;
358 break;
Richard Purdieed2fa4d2008-01-03 10:46:21 -0500359
360 case EV_PWR:
361 disposition = INPUT_PASS_TO_ALL;
362 break;
Dmitry Torokhov80064792007-08-30 00:22:11 -0400363 }
364
Dmitry Torokhov50c5d362014-07-19 16:30:31 -0700365 *pval = value;
Henrik Rydberg4369c642012-09-15 15:23:35 +0200366 return disposition;
367}
368
369static void input_handle_event(struct input_dev *dev,
370 unsigned int type, unsigned int code, int value)
371{
Dmitry Torokhovb55eb292016-01-23 11:29:13 -0800372 int disposition = input_get_disposition(dev, type, code, &value);
Henrik Rydberg4369c642012-09-15 15:23:35 +0200373
Dmitry Torokhovb55eb292016-01-23 11:29:13 -0800374 if (disposition != INPUT_IGNORE_EVENT && type != EV_SYN)
375 add_input_randomness(type, code, value);
Dmitry Torokhov80064792007-08-30 00:22:11 -0400376
377 if ((disposition & INPUT_PASS_TO_DEVICE) && dev->event)
378 dev->event(dev, type, code, value);
379
Henrik Rydberg4369c642012-09-15 15:23:35 +0200380 if (!dev->vals)
381 return;
382
383 if (disposition & INPUT_PASS_TO_HANDLERS) {
384 struct input_value *v;
385
386 if (disposition & INPUT_SLOT) {
387 v = &dev->vals[dev->num_vals++];
388 v->type = EV_ABS;
389 v->code = ABS_MT_SLOT;
390 v->value = dev->mt->slot;
391 }
392
393 v = &dev->vals[dev->num_vals++];
394 v->type = type;
395 v->code = code;
396 v->value = value;
397 }
398
399 if (disposition & INPUT_FLUSH) {
400 if (dev->num_vals >= 2)
401 input_pass_values(dev, dev->vals, dev->num_vals);
402 dev->num_vals = 0;
403 } else if (dev->num_vals >= dev->max_vals - 2) {
404 dev->vals[dev->num_vals++] = input_value_sync;
405 input_pass_values(dev, dev->vals, dev->num_vals);
406 dev->num_vals = 0;
407 }
408
Dmitry Torokhov80064792007-08-30 00:22:11 -0400409}
410
Dmitry Torokhov0e739d22006-07-06 00:22:43 -0400411/**
412 * input_event() - report new input event
Dmitry Torokhov14471902006-11-02 23:26:55 -0500413 * @dev: device that generated the event
Dmitry Torokhov0e739d22006-07-06 00:22:43 -0400414 * @type: type of the event
415 * @code: event code
416 * @value: value of the event
417 *
Dmitry Torokhov80064792007-08-30 00:22:11 -0400418 * This function should be used by drivers implementing various input
Dmitry Torokhovdf2d4632009-12-11 21:57:31 -0800419 * devices to report input events. See also input_inject_event().
420 *
421 * NOTE: input_event() may be safely used right after input device was
422 * allocated with input_allocate_device(), even before it is registered
423 * with input_register_device(), but the event will not reach any of the
424 * input handlers. Such early invocation of input_event() may be used
425 * to 'seed' initial state of a switch or initial position of absolute
426 * axis, etc.
Dmitry Torokhov0e739d22006-07-06 00:22:43 -0400427 */
Dmitry Torokhov80064792007-08-30 00:22:11 -0400428void input_event(struct input_dev *dev,
429 unsigned int type, unsigned int code, int value)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430{
Dmitry Torokhov80064792007-08-30 00:22:11 -0400431 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432
Dmitry Torokhov80064792007-08-30 00:22:11 -0400433 if (is_event_supported(type, dev->evbit, EV_MAX)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434
Dmitry Torokhov80064792007-08-30 00:22:11 -0400435 spin_lock_irqsave(&dev->event_lock, flags);
Dmitry Torokhov9ae43452011-02-02 23:04:27 -0800436 input_handle_event(dev, type, code, value);
Dmitry Torokhov80064792007-08-30 00:22:11 -0400437 spin_unlock_irqrestore(&dev->event_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439}
Dmitry Torokhovca56fe02006-06-26 01:49:21 -0400440EXPORT_SYMBOL(input_event);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441
Dmitry Torokhov0e739d22006-07-06 00:22:43 -0400442/**
443 * input_inject_event() - send input event from input handler
444 * @handle: input handle to send event through
445 * @type: type of the event
446 * @code: event code
447 * @value: value of the event
448 *
Dmitry Torokhov80064792007-08-30 00:22:11 -0400449 * Similar to input_event() but will ignore event if device is
450 * "grabbed" and handle injecting event is not the one that owns
451 * the device.
Dmitry Torokhov0e739d22006-07-06 00:22:43 -0400452 */
Dmitry Torokhov80064792007-08-30 00:22:11 -0400453void input_inject_event(struct input_handle *handle,
454 unsigned int type, unsigned int code, int value)
Dmitry Torokhov0e739d22006-07-06 00:22:43 -0400455{
Dmitry Torokhov80064792007-08-30 00:22:11 -0400456 struct input_dev *dev = handle->dev;
457 struct input_handle *grab;
458 unsigned long flags;
459
460 if (is_event_supported(type, dev->evbit, EV_MAX)) {
461 spin_lock_irqsave(&dev->event_lock, flags);
462
Dmitry Torokhov82ba56c2007-10-13 15:46:55 -0400463 rcu_read_lock();
Dmitry Torokhov80064792007-08-30 00:22:11 -0400464 grab = rcu_dereference(dev->grab);
465 if (!grab || grab == handle)
Dmitry Torokhov9ae43452011-02-02 23:04:27 -0800466 input_handle_event(dev, type, code, value);
Dmitry Torokhov82ba56c2007-10-13 15:46:55 -0400467 rcu_read_unlock();
Dmitry Torokhov80064792007-08-30 00:22:11 -0400468
469 spin_unlock_irqrestore(&dev->event_lock, flags);
470 }
Dmitry Torokhov0e739d22006-07-06 00:22:43 -0400471}
472EXPORT_SYMBOL(input_inject_event);
473
Dmitry Torokhov80064792007-08-30 00:22:11 -0400474/**
Daniel Mackd31b2862010-08-02 20:18:21 -0700475 * input_alloc_absinfo - allocates array of input_absinfo structs
476 * @dev: the input device emitting absolute events
477 *
478 * If the absinfo struct the caller asked for is already allocated, this
479 * functions will not do anything.
480 */
481void input_alloc_absinfo(struct input_dev *dev)
482{
483 if (!dev->absinfo)
Markus Elfringc3f6f862017-05-09 17:51:30 -0700484 dev->absinfo = kcalloc(ABS_CNT, sizeof(*dev->absinfo),
Daniel Mackd31b2862010-08-02 20:18:21 -0700485 GFP_KERNEL);
486
487 WARN(!dev->absinfo, "%s(): kcalloc() failed?\n", __func__);
488}
489EXPORT_SYMBOL(input_alloc_absinfo);
490
491void input_set_abs_params(struct input_dev *dev, unsigned int axis,
492 int min, int max, int fuzz, int flat)
493{
494 struct input_absinfo *absinfo;
495
496 input_alloc_absinfo(dev);
497 if (!dev->absinfo)
498 return;
499
500 absinfo = &dev->absinfo[axis];
501 absinfo->minimum = min;
502 absinfo->maximum = max;
503 absinfo->fuzz = fuzz;
504 absinfo->flat = flat;
505
Dmitry Torokhov2c9a9cf2014-10-08 09:28:32 -0700506 __set_bit(EV_ABS, dev->evbit);
507 __set_bit(axis, dev->absbit);
Daniel Mackd31b2862010-08-02 20:18:21 -0700508}
509EXPORT_SYMBOL(input_set_abs_params);
510
511
512/**
Dmitry Torokhov80064792007-08-30 00:22:11 -0400513 * input_grab_device - grabs device for exclusive use
514 * @handle: input handle that wants to own the device
515 *
516 * When a device is grabbed by an input handle all events generated by
517 * the device are delivered only to this handle. Also events injected
518 * by other input handles are ignored while device is grabbed.
519 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520int input_grab_device(struct input_handle *handle)
521{
Dmitry Torokhov80064792007-08-30 00:22:11 -0400522 struct input_dev *dev = handle->dev;
523 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524
Dmitry Torokhov80064792007-08-30 00:22:11 -0400525 retval = mutex_lock_interruptible(&dev->mutex);
526 if (retval)
527 return retval;
528
529 if (dev->grab) {
530 retval = -EBUSY;
531 goto out;
532 }
533
534 rcu_assign_pointer(dev->grab, handle);
Dmitry Torokhov80064792007-08-30 00:22:11 -0400535
536 out:
537 mutex_unlock(&dev->mutex);
538 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539}
Dmitry Torokhovca56fe02006-06-26 01:49:21 -0400540EXPORT_SYMBOL(input_grab_device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541
Dmitry Torokhov80064792007-08-30 00:22:11 -0400542static void __input_release_device(struct input_handle *handle)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543{
Andrew Mortona2b2ed22006-07-15 01:17:38 -0400544 struct input_dev *dev = handle->dev;
Dmitry Torokhovadc46332012-10-24 23:53:01 -0700545 struct input_handle *grabber;
Dmitry Torokhovc7e8dc62006-07-06 00:21:03 -0400546
Dmitry Torokhovadc46332012-10-24 23:53:01 -0700547 grabber = rcu_dereference_protected(dev->grab,
548 lockdep_is_held(&dev->mutex));
549 if (grabber == handle) {
Dmitry Torokhov80064792007-08-30 00:22:11 -0400550 rcu_assign_pointer(dev->grab, NULL);
551 /* Make sure input_pass_event() notices that grab is gone */
Dmitry Torokhov82ba56c2007-10-13 15:46:55 -0400552 synchronize_rcu();
Andrew Mortona2b2ed22006-07-15 01:17:38 -0400553
554 list_for_each_entry(handle, &dev->h_list, d_node)
Dmitry Torokhov80064792007-08-30 00:22:11 -0400555 if (handle->open && handle->handler->start)
Dmitry Torokhovc7e8dc62006-07-06 00:21:03 -0400556 handle->handler->start(handle);
557 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558}
Dmitry Torokhov80064792007-08-30 00:22:11 -0400559
560/**
561 * input_release_device - release previously grabbed device
562 * @handle: input handle that owns the device
563 *
564 * Releases previously grabbed device so that other input handles can
565 * start receiving input events. Upon release all handlers attached
566 * to the device have their start() method called so they have a change
567 * to synchronize device state with the rest of the system.
568 */
569void input_release_device(struct input_handle *handle)
570{
571 struct input_dev *dev = handle->dev;
572
573 mutex_lock(&dev->mutex);
574 __input_release_device(handle);
575 mutex_unlock(&dev->mutex);
576}
Dmitry Torokhovca56fe02006-06-26 01:49:21 -0400577EXPORT_SYMBOL(input_release_device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578
Dmitry Torokhov80064792007-08-30 00:22:11 -0400579/**
580 * input_open_device - open input device
581 * @handle: handle through which device is being accessed
582 *
583 * This function should be called by input handlers when they
584 * want to start receive events from given input device.
585 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586int input_open_device(struct input_handle *handle)
587{
Dmitry Torokhov0fbf87c2005-05-29 02:29:25 -0500588 struct input_dev *dev = handle->dev;
Dmitry Torokhov80064792007-08-30 00:22:11 -0400589 int retval;
Dmitry Torokhov0fbf87c2005-05-29 02:29:25 -0500590
Dmitry Torokhov80064792007-08-30 00:22:11 -0400591 retval = mutex_lock_interruptible(&dev->mutex);
592 if (retval)
593 return retval;
594
595 if (dev->going_away) {
596 retval = -ENODEV;
597 goto out;
598 }
Dmitry Torokhov0fbf87c2005-05-29 02:29:25 -0500599
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600 handle->open++;
Dmitry Torokhov0fbf87c2005-05-29 02:29:25 -0500601
602 if (!dev->users++ && dev->open)
Dmitry Torokhov80064792007-08-30 00:22:11 -0400603 retval = dev->open(dev);
Dmitry Torokhov0fbf87c2005-05-29 02:29:25 -0500604
Dmitry Torokhov80064792007-08-30 00:22:11 -0400605 if (retval) {
606 dev->users--;
607 if (!--handle->open) {
608 /*
609 * Make sure we are not delivering any more events
610 * through this handle
611 */
Dmitry Torokhov82ba56c2007-10-13 15:46:55 -0400612 synchronize_rcu();
Dmitry Torokhov80064792007-08-30 00:22:11 -0400613 }
614 }
Dmitry Torokhov0fbf87c2005-05-29 02:29:25 -0500615
Dmitry Torokhov80064792007-08-30 00:22:11 -0400616 out:
Jes Sorensene676c232006-02-19 00:21:46 -0500617 mutex_unlock(&dev->mutex);
Dmitry Torokhov80064792007-08-30 00:22:11 -0400618 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619}
Dmitry Torokhovca56fe02006-06-26 01:49:21 -0400620EXPORT_SYMBOL(input_open_device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621
Dmitry Torokhov80064792007-08-30 00:22:11 -0400622int input_flush_device(struct input_handle *handle, struct file *file)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623{
Dmitry Torokhov80064792007-08-30 00:22:11 -0400624 struct input_dev *dev = handle->dev;
625 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626
Dmitry Torokhov80064792007-08-30 00:22:11 -0400627 retval = mutex_lock_interruptible(&dev->mutex);
628 if (retval)
629 return retval;
630
631 if (dev->flush)
632 retval = dev->flush(dev, file);
633
634 mutex_unlock(&dev->mutex);
635 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636}
Dmitry Torokhovca56fe02006-06-26 01:49:21 -0400637EXPORT_SYMBOL(input_flush_device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638
Dmitry Torokhov80064792007-08-30 00:22:11 -0400639/**
640 * input_close_device - close input device
641 * @handle: handle through which device is being accessed
642 *
643 * This function should be called by input handlers when they
644 * want to stop receive events from given input device.
645 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646void input_close_device(struct input_handle *handle)
647{
Dmitry Torokhov0fbf87c2005-05-29 02:29:25 -0500648 struct input_dev *dev = handle->dev;
649
Jes Sorensene676c232006-02-19 00:21:46 -0500650 mutex_lock(&dev->mutex);
Dmitry Torokhov0fbf87c2005-05-29 02:29:25 -0500651
Dmitry Torokhov80064792007-08-30 00:22:11 -0400652 __input_release_device(handle);
653
Dmitry Torokhov0fbf87c2005-05-29 02:29:25 -0500654 if (!--dev->users && dev->close)
655 dev->close(dev);
Dmitry Torokhov80064792007-08-30 00:22:11 -0400656
657 if (!--handle->open) {
658 /*
Dmitry Torokhov82ba56c2007-10-13 15:46:55 -0400659 * synchronize_rcu() makes sure that input_pass_event()
Dmitry Torokhov80064792007-08-30 00:22:11 -0400660 * completed and that no more input events are delivered
661 * through this handle
662 */
Dmitry Torokhov82ba56c2007-10-13 15:46:55 -0400663 synchronize_rcu();
Dmitry Torokhov80064792007-08-30 00:22:11 -0400664 }
Dmitry Torokhov0fbf87c2005-05-29 02:29:25 -0500665
Jes Sorensene676c232006-02-19 00:21:46 -0500666 mutex_unlock(&dev->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667}
Dmitry Torokhovca56fe02006-06-26 01:49:21 -0400668EXPORT_SYMBOL(input_close_device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669
Dmitry Torokhov80064792007-08-30 00:22:11 -0400670/*
Oliver Neukum866d7d72010-07-01 09:01:50 -0700671 * Simulate keyup events for all keys that are marked as pressed.
672 * The function must be called with dev->event_lock held.
673 */
674static void input_dev_release_keys(struct input_dev *dev)
675{
Dmitry Torokhov00159f12015-08-06 19:15:30 -0700676 bool need_sync = false;
Oliver Neukum866d7d72010-07-01 09:01:50 -0700677 int code;
678
679 if (is_event_supported(EV_KEY, dev->evbit, EV_MAX)) {
Dmitry Torokhov00159f12015-08-06 19:15:30 -0700680 for_each_set_bit(code, dev->key, KEY_CNT) {
Anshul Garg3e2b03d2015-06-25 13:33:12 -0700681 input_pass_event(dev, EV_KEY, code, 0);
Dmitry Torokhov00159f12015-08-06 19:15:30 -0700682 need_sync = true;
683 }
684
685 if (need_sync)
686 input_pass_event(dev, EV_SYN, SYN_REPORT, 1);
687
Anshul Garg3e2b03d2015-06-25 13:33:12 -0700688 memset(dev->key, 0, sizeof(dev->key));
Oliver Neukum866d7d72010-07-01 09:01:50 -0700689 }
690}
691
692/*
Dmitry Torokhov80064792007-08-30 00:22:11 -0400693 * Prepare device for unregistering
694 */
695static void input_disconnect_device(struct input_dev *dev)
696{
697 struct input_handle *handle;
Dmitry Torokhov80064792007-08-30 00:22:11 -0400698
699 /*
700 * Mark device as going away. Note that we take dev->mutex here
701 * not to protect access to dev->going_away but rather to ensure
702 * that there are no threads in the middle of input_open_device()
703 */
704 mutex_lock(&dev->mutex);
Dmitry Torokhovffd0db92009-09-16 01:06:43 -0700705 dev->going_away = true;
Dmitry Torokhov80064792007-08-30 00:22:11 -0400706 mutex_unlock(&dev->mutex);
707
708 spin_lock_irq(&dev->event_lock);
709
710 /*
711 * Simulate keyup events for all pressed keys so that handlers
712 * are not left with "stuck" keys. The driver may continue
713 * generate events even after we done here but they will not
714 * reach any handlers.
715 */
Oliver Neukum866d7d72010-07-01 09:01:50 -0700716 input_dev_release_keys(dev);
Dmitry Torokhov80064792007-08-30 00:22:11 -0400717
718 list_for_each_entry(handle, &dev->h_list, d_node)
719 handle->open = 0;
720
721 spin_unlock_irq(&dev->event_lock);
722}
723
Mauro Carvalho Chehab8613e4c2010-09-09 21:54:22 -0700724/**
725 * input_scancode_to_scalar() - converts scancode in &struct input_keymap_entry
726 * @ke: keymap entry containing scancode to be converted.
727 * @scancode: pointer to the location where converted scancode should
728 * be stored.
729 *
730 * This function is used to convert scancode stored in &struct keymap_entry
731 * into scalar form understood by legacy keymap handling methods. These
732 * methods expect scancodes to be represented as 'unsigned int'.
733 */
734int input_scancode_to_scalar(const struct input_keymap_entry *ke,
735 unsigned int *scancode)
736{
737 switch (ke->len) {
738 case 1:
739 *scancode = *((u8 *)ke->scancode);
740 break;
741
742 case 2:
743 *scancode = *((u16 *)ke->scancode);
744 break;
745
746 case 4:
747 *scancode = *((u32 *)ke->scancode);
748 break;
749
750 default:
751 return -EINVAL;
752 }
753
754 return 0;
755}
756EXPORT_SYMBOL(input_scancode_to_scalar);
757
758/*
759 * Those routines handle the default case where no [gs]etkeycode() is
760 * defined. In this case, an array indexed by the scancode is used.
761 */
762
763static unsigned int input_fetch_keycode(struct input_dev *dev,
764 unsigned int index)
Marvin Raaijmakersc8e4c772007-03-14 22:50:42 -0400765{
766 switch (dev->keycodesize) {
Mauro Carvalho Chehab8613e4c2010-09-09 21:54:22 -0700767 case 1:
768 return ((u8 *)dev->keycode)[index];
Marvin Raaijmakersc8e4c772007-03-14 22:50:42 -0400769
Mauro Carvalho Chehab8613e4c2010-09-09 21:54:22 -0700770 case 2:
771 return ((u16 *)dev->keycode)[index];
Marvin Raaijmakersc8e4c772007-03-14 22:50:42 -0400772
Mauro Carvalho Chehab8613e4c2010-09-09 21:54:22 -0700773 default:
774 return ((u32 *)dev->keycode)[index];
Marvin Raaijmakersc8e4c772007-03-14 22:50:42 -0400775 }
776}
777
778static int input_default_getkeycode(struct input_dev *dev,
Mauro Carvalho Chehab8613e4c2010-09-09 21:54:22 -0700779 struct input_keymap_entry *ke)
Marvin Raaijmakersc8e4c772007-03-14 22:50:42 -0400780{
Mauro Carvalho Chehab8613e4c2010-09-09 21:54:22 -0700781 unsigned int index;
782 int error;
783
Marvin Raaijmakersc8e4c772007-03-14 22:50:42 -0400784 if (!dev->keycodesize)
785 return -EINVAL;
786
Mauro Carvalho Chehab8613e4c2010-09-09 21:54:22 -0700787 if (ke->flags & INPUT_KEYMAP_BY_INDEX)
788 index = ke->index;
789 else {
790 error = input_scancode_to_scalar(ke, &index);
791 if (error)
792 return error;
793 }
794
795 if (index >= dev->keycodemax)
Marvin Raaijmakersc8e4c772007-03-14 22:50:42 -0400796 return -EINVAL;
797
Mauro Carvalho Chehab8613e4c2010-09-09 21:54:22 -0700798 ke->keycode = input_fetch_keycode(dev, index);
799 ke->index = index;
800 ke->len = sizeof(index);
801 memcpy(ke->scancode, &index, sizeof(index));
Marvin Raaijmakersc8e4c772007-03-14 22:50:42 -0400802
803 return 0;
804}
805
806static int input_default_setkeycode(struct input_dev *dev,
Mauro Carvalho Chehab8613e4c2010-09-09 21:54:22 -0700807 const struct input_keymap_entry *ke,
808 unsigned int *old_keycode)
Marvin Raaijmakersc8e4c772007-03-14 22:50:42 -0400809{
Mauro Carvalho Chehab8613e4c2010-09-09 21:54:22 -0700810 unsigned int index;
811 int error;
Marvin Raaijmakersc8e4c772007-03-14 22:50:42 -0400812 int i;
813
Marvin Raaijmakersc8e4c772007-03-14 22:50:42 -0400814 if (!dev->keycodesize)
815 return -EINVAL;
816
Mauro Carvalho Chehab8613e4c2010-09-09 21:54:22 -0700817 if (ke->flags & INPUT_KEYMAP_BY_INDEX) {
818 index = ke->index;
819 } else {
820 error = input_scancode_to_scalar(ke, &index);
821 if (error)
822 return error;
823 }
824
825 if (index >= dev->keycodemax)
826 return -EINVAL;
827
Mattia Dongilide391d12010-11-18 09:06:43 -0800828 if (dev->keycodesize < sizeof(ke->keycode) &&
Mauro Carvalho Chehab8613e4c2010-09-09 21:54:22 -0700829 (ke->keycode >> (dev->keycodesize * 8)))
Marvin Raaijmakersc8e4c772007-03-14 22:50:42 -0400830 return -EINVAL;
831
832 switch (dev->keycodesize) {
833 case 1: {
834 u8 *k = (u8 *)dev->keycode;
Mauro Carvalho Chehab8613e4c2010-09-09 21:54:22 -0700835 *old_keycode = k[index];
836 k[index] = ke->keycode;
Marvin Raaijmakersc8e4c772007-03-14 22:50:42 -0400837 break;
838 }
839 case 2: {
840 u16 *k = (u16 *)dev->keycode;
Mauro Carvalho Chehab8613e4c2010-09-09 21:54:22 -0700841 *old_keycode = k[index];
842 k[index] = ke->keycode;
Marvin Raaijmakersc8e4c772007-03-14 22:50:42 -0400843 break;
844 }
845 default: {
846 u32 *k = (u32 *)dev->keycode;
Mauro Carvalho Chehab8613e4c2010-09-09 21:54:22 -0700847 *old_keycode = k[index];
848 k[index] = ke->keycode;
Marvin Raaijmakersc8e4c772007-03-14 22:50:42 -0400849 break;
850 }
851 }
852
Mauro Carvalho Chehab8613e4c2010-09-09 21:54:22 -0700853 __clear_bit(*old_keycode, dev->keybit);
854 __set_bit(ke->keycode, dev->keybit);
Marvin Raaijmakersc8e4c772007-03-14 22:50:42 -0400855
856 for (i = 0; i < dev->keycodemax; i++) {
Mauro Carvalho Chehab8613e4c2010-09-09 21:54:22 -0700857 if (input_fetch_keycode(dev, i) == *old_keycode) {
858 __set_bit(*old_keycode, dev->keybit);
Marvin Raaijmakersc8e4c772007-03-14 22:50:42 -0400859 break; /* Setting the bit twice is useless, so break */
860 }
861 }
862
863 return 0;
864}
865
Dmitry Torokhovf4f37c82007-11-04 00:41:12 -0400866/**
867 * input_get_keycode - retrieve keycode currently mapped to a given scancode
868 * @dev: input device which keymap is being queried
Mauro Carvalho Chehab8613e4c2010-09-09 21:54:22 -0700869 * @ke: keymap entry
Dmitry Torokhovf4f37c82007-11-04 00:41:12 -0400870 *
871 * This function should be called by anyone interested in retrieving current
Mauro Carvalho Chehab8613e4c2010-09-09 21:54:22 -0700872 * keymap. Presently evdev handlers use it.
Dmitry Torokhovf4f37c82007-11-04 00:41:12 -0400873 */
Mauro Carvalho Chehab8613e4c2010-09-09 21:54:22 -0700874int input_get_keycode(struct input_dev *dev, struct input_keymap_entry *ke)
Dmitry Torokhovf4f37c82007-11-04 00:41:12 -0400875{
Dmitry Torokhov2e2e3b92010-03-21 22:56:15 -0700876 unsigned long flags;
877 int retval;
878
879 spin_lock_irqsave(&dev->event_lock, flags);
Dmitry Torokhovaebd6362011-01-31 21:06:39 -0800880 retval = dev->getkeycode(dev, ke);
Mauro Carvalho Chehab8613e4c2010-09-09 21:54:22 -0700881 spin_unlock_irqrestore(&dev->event_lock, flags);
Dmitry Torokhovaebd6362011-01-31 21:06:39 -0800882
Dmitry Torokhov2e2e3b92010-03-21 22:56:15 -0700883 return retval;
Dmitry Torokhovf4f37c82007-11-04 00:41:12 -0400884}
885EXPORT_SYMBOL(input_get_keycode);
886
887/**
Mauro Carvalho Chehab8613e4c2010-09-09 21:54:22 -0700888 * input_set_keycode - attribute a keycode to a given scancode
Dmitry Torokhovf4f37c82007-11-04 00:41:12 -0400889 * @dev: input device which keymap is being updated
Mauro Carvalho Chehab8613e4c2010-09-09 21:54:22 -0700890 * @ke: new keymap entry
Dmitry Torokhovf4f37c82007-11-04 00:41:12 -0400891 *
892 * This function should be called by anyone needing to update current
893 * keymap. Presently keyboard and evdev handlers use it.
894 */
Dmitry Torokhov58b93992010-03-08 22:37:10 -0800895int input_set_keycode(struct input_dev *dev,
Mauro Carvalho Chehab8613e4c2010-09-09 21:54:22 -0700896 const struct input_keymap_entry *ke)
Dmitry Torokhovf4f37c82007-11-04 00:41:12 -0400897{
898 unsigned long flags;
Dmitry Torokhovfd6cf3d2010-07-14 00:25:21 -0700899 unsigned int old_keycode;
Dmitry Torokhovf4f37c82007-11-04 00:41:12 -0400900 int retval;
901
Mauro Carvalho Chehab8613e4c2010-09-09 21:54:22 -0700902 if (ke->keycode > KEY_MAX)
Dmitry Torokhovf4f37c82007-11-04 00:41:12 -0400903 return -EINVAL;
904
905 spin_lock_irqsave(&dev->event_lock, flags);
906
Dmitry Torokhovaebd6362011-01-31 21:06:39 -0800907 retval = dev->setkeycode(dev, ke, &old_keycode);
Dmitry Torokhovf4f37c82007-11-04 00:41:12 -0400908 if (retval)
909 goto out;
910
Dmitry Torokhov4f93df42010-01-05 17:56:00 -0800911 /* Make sure KEY_RESERVED did not get enabled. */
912 __clear_bit(KEY_RESERVED, dev->keybit);
913
Dmitry Torokhovf4f37c82007-11-04 00:41:12 -0400914 /*
915 * Simulate keyup event if keycode is not present
916 * in the keymap anymore
917 */
918 if (test_bit(EV_KEY, dev->evbit) &&
919 !is_event_supported(old_keycode, dev->keybit, KEY_MAX) &&
920 __test_and_clear_bit(old_keycode, dev->key)) {
Henrik Rydberg4369c642012-09-15 15:23:35 +0200921 struct input_value vals[] = {
922 { EV_KEY, old_keycode, 0 },
923 input_value_sync
924 };
Dmitry Torokhovf4f37c82007-11-04 00:41:12 -0400925
Henrik Rydberg4369c642012-09-15 15:23:35 +0200926 input_pass_values(dev, vals, ARRAY_SIZE(vals));
Dmitry Torokhovf4f37c82007-11-04 00:41:12 -0400927 }
928
929 out:
930 spin_unlock_irqrestore(&dev->event_lock, flags);
931
932 return retval;
933}
934EXPORT_SYMBOL(input_set_keycode);
Marvin Raaijmakersc8e4c772007-03-14 22:50:42 -0400935
Dmitry Torokhov55dfce82017-10-09 11:09:33 -0700936bool input_match_device_id(const struct input_dev *dev,
937 const struct input_device_id *id)
938{
939 if (id->flags & INPUT_DEVICE_ID_MATCH_BUS)
940 if (id->bustype != dev->id.bustype)
941 return false;
942
943 if (id->flags & INPUT_DEVICE_ID_MATCH_VENDOR)
944 if (id->vendor != dev->id.vendor)
945 return false;
946
947 if (id->flags & INPUT_DEVICE_ID_MATCH_PRODUCT)
948 if (id->product != dev->id.product)
949 return false;
950
951 if (id->flags & INPUT_DEVICE_ID_MATCH_VERSION)
952 if (id->version != dev->id.version)
953 return false;
954
955 if (!bitmap_subset(id->evbit, dev->evbit, EV_MAX) ||
956 !bitmap_subset(id->keybit, dev->keybit, KEY_MAX) ||
957 !bitmap_subset(id->relbit, dev->relbit, REL_MAX) ||
958 !bitmap_subset(id->absbit, dev->absbit, ABS_MAX) ||
959 !bitmap_subset(id->mscbit, dev->mscbit, MSC_MAX) ||
960 !bitmap_subset(id->ledbit, dev->ledbit, LED_MAX) ||
961 !bitmap_subset(id->sndbit, dev->sndbit, SND_MAX) ||
962 !bitmap_subset(id->ffbit, dev->ffbit, FF_MAX) ||
Dmitry Torokhov8724ecb2017-10-09 12:01:14 -0700963 !bitmap_subset(id->swbit, dev->swbit, SW_MAX) ||
964 !bitmap_subset(id->propbit, dev->propbit, INPUT_PROP_MAX)) {
Dmitry Torokhov55dfce82017-10-09 11:09:33 -0700965 return false;
966 }
967
968 return true;
969}
970EXPORT_SYMBOL(input_match_device_id);
971
Dmitry Torokhov0b7024ac2010-02-02 21:08:26 -0800972static const struct input_device_id *input_match_device(struct input_handler *handler,
Dmitry Torokhov66e66112006-09-14 01:31:59 -0400973 struct input_dev *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700974{
Dmitry Torokhov0b7024ac2010-02-02 21:08:26 -0800975 const struct input_device_id *id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700976
Dmitry Torokhov0b7024ac2010-02-02 21:08:26 -0800977 for (id = handler->id_table; id->flags || id->driver_info; id++) {
Dmitry Torokhov55dfce82017-10-09 11:09:33 -0700978 if (input_match_device_id(dev, id) &&
979 (!handler->match || handler->match(handler, dev))) {
Dmitry Torokhov0b7024ac2010-02-02 21:08:26 -0800980 return id;
Dmitry Torokhov55dfce82017-10-09 11:09:33 -0700981 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700982 }
983
984 return NULL;
985}
986
Dmitry Torokhov5b2a08262007-04-12 01:29:46 -0400987static int input_attach_handler(struct input_dev *dev, struct input_handler *handler)
988{
989 const struct input_device_id *id;
990 int error;
991
Dmitry Torokhov0b7024ac2010-02-02 21:08:26 -0800992 id = input_match_device(handler, dev);
Dmitry Torokhov5b2a08262007-04-12 01:29:46 -0400993 if (!id)
994 return -ENODEV;
995
996 error = handler->connect(handler, dev, id);
997 if (error && error != -ENODEV)
Joe Perchesda0c4902010-11-29 23:33:07 -0800998 pr_err("failed to attach handler %s to device %s, error: %d\n",
999 handler->name, kobject_name(&dev->dev.kobj), error);
Dmitry Torokhov5b2a08262007-04-12 01:29:46 -04001000
1001 return error;
1002}
1003
Dmitry Torokhov15e184a2010-01-11 00:05:43 -08001004#ifdef CONFIG_COMPAT
1005
1006static int input_bits_to_string(char *buf, int buf_size,
1007 unsigned long bits, bool skip_empty)
1008{
1009 int len = 0;
1010
Andrew Mortonb8b4ead2016-03-25 14:20:47 -07001011 if (in_compat_syscall()) {
Dmitry Torokhov15e184a2010-01-11 00:05:43 -08001012 u32 dword = bits >> 32;
1013 if (dword || !skip_empty)
1014 len += snprintf(buf, buf_size, "%x ", dword);
1015
1016 dword = bits & 0xffffffffUL;
1017 if (dword || !skip_empty || len)
1018 len += snprintf(buf + len, max(buf_size - len, 0),
1019 "%x", dword);
1020 } else {
1021 if (bits || !skip_empty)
1022 len += snprintf(buf, buf_size, "%lx", bits);
1023 }
1024
1025 return len;
1026}
1027
1028#else /* !CONFIG_COMPAT */
1029
1030static int input_bits_to_string(char *buf, int buf_size,
1031 unsigned long bits, bool skip_empty)
1032{
1033 return bits || !skip_empty ?
1034 snprintf(buf, buf_size, "%lx", bits) : 0;
1035}
1036
1037#endif
Dmitry Torokhov5b2a08262007-04-12 01:29:46 -04001038
Linus Torvalds1da177e2005-04-16 15:20:36 -07001039#ifdef CONFIG_PROC_FS
Dmitry Torokhovf96b4342005-06-30 00:50:29 -05001040
1041static struct proc_dir_entry *proc_bus_input_dir;
1042static DECLARE_WAIT_QUEUE_HEAD(input_devices_poll_wait);
1043static int input_devices_state;
1044
1045static inline void input_wakeup_procfs_readers(void)
1046{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001047 input_devices_state++;
1048 wake_up(&input_devices_poll_wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001049}
1050
Al Viroafc9a422017-07-03 06:39:46 -04001051static __poll_t input_proc_devices_poll(struct file *file, poll_table *wait)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052{
Dmitry Torokhovf96b4342005-06-30 00:50:29 -05001053 poll_wait(file, &input_devices_poll_wait, wait);
Dmitry Torokhovfa886612009-03-04 00:52:20 -08001054 if (file->f_version != input_devices_state) {
1055 file->f_version = input_devices_state;
Linus Torvaldsa9a08842018-02-11 14:34:03 -08001056 return EPOLLIN | EPOLLRDNORM;
Dmitry Torokhovfa886612009-03-04 00:52:20 -08001057 }
Dmitry Torokhov1e0afb22006-06-26 01:48:47 -04001058
Dmitry Torokhovf96b4342005-06-30 00:50:29 -05001059 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001060}
1061
Dmitry Torokhov1572ca22009-10-13 23:37:30 -07001062union input_seq_state {
1063 struct {
1064 unsigned short pos;
1065 bool mutex_acquired;
1066 };
1067 void *p;
1068};
1069
Dmitry Torokhov969b21c2006-04-02 00:09:34 -05001070static void *input_devices_seq_start(struct seq_file *seq, loff_t *pos)
1071{
Dmitry Torokhov1572ca22009-10-13 23:37:30 -07001072 union input_seq_state *state = (union input_seq_state *)&seq->private;
1073 int error;
1074
1075 /* We need to fit into seq->private pointer */
1076 BUILD_BUG_ON(sizeof(union input_seq_state) != sizeof(seq->private));
1077
1078 error = mutex_lock_interruptible(&input_mutex);
1079 if (error) {
1080 state->mutex_acquired = false;
1081 return ERR_PTR(error);
1082 }
1083
1084 state->mutex_acquired = true;
Dmitry Torokhov969b21c2006-04-02 00:09:34 -05001085
Pavel Emelianovad5d9722007-07-18 00:38:32 -04001086 return seq_list_start(&input_dev_list, *pos);
Dmitry Torokhov969b21c2006-04-02 00:09:34 -05001087}
1088
1089static void *input_devices_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1090{
Pavel Emelianovad5d9722007-07-18 00:38:32 -04001091 return seq_list_next(v, &input_dev_list, pos);
Dmitry Torokhov969b21c2006-04-02 00:09:34 -05001092}
1093
Dmitry Torokhov1572ca22009-10-13 23:37:30 -07001094static void input_seq_stop(struct seq_file *seq, void *v)
Dmitry Torokhov969b21c2006-04-02 00:09:34 -05001095{
Dmitry Torokhov1572ca22009-10-13 23:37:30 -07001096 union input_seq_state *state = (union input_seq_state *)&seq->private;
1097
1098 if (state->mutex_acquired)
1099 mutex_unlock(&input_mutex);
Dmitry Torokhov969b21c2006-04-02 00:09:34 -05001100}
1101
1102static void input_seq_print_bitmap(struct seq_file *seq, const char *name,
1103 unsigned long *bitmap, int max)
1104{
1105 int i;
Dmitry Torokhov15e184a2010-01-11 00:05:43 -08001106 bool skip_empty = true;
1107 char buf[18];
Dmitry Torokhov969b21c2006-04-02 00:09:34 -05001108
1109 seq_printf(seq, "B: %s=", name);
Dmitry Torokhov15e184a2010-01-11 00:05:43 -08001110
1111 for (i = BITS_TO_LONGS(max) - 1; i >= 0; i--) {
1112 if (input_bits_to_string(buf, sizeof(buf),
1113 bitmap[i], skip_empty)) {
1114 skip_empty = false;
1115 seq_printf(seq, "%s%s", buf, i > 0 ? " " : "");
1116 }
1117 }
1118
1119 /*
1120 * If no output was produced print a single 0.
1121 */
1122 if (skip_empty)
Markus Elfringbb546132017-05-09 17:48:45 -07001123 seq_putc(seq, '0');
Dmitry Torokhov15e184a2010-01-11 00:05:43 -08001124
Dmitry Torokhov969b21c2006-04-02 00:09:34 -05001125 seq_putc(seq, '\n');
1126}
1127
1128static int input_devices_seq_show(struct seq_file *seq, void *v)
1129{
1130 struct input_dev *dev = container_of(v, struct input_dev, node);
Dmitry Torokhov9657d752007-06-14 23:32:24 -04001131 const char *path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001132 struct input_handle *handle;
1133
Dmitry Torokhov969b21c2006-04-02 00:09:34 -05001134 seq_printf(seq, "I: Bus=%04x Vendor=%04x Product=%04x Version=%04x\n",
1135 dev->id.bustype, dev->id.vendor, dev->id.product, dev->id.version);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001136
Dmitry Torokhov969b21c2006-04-02 00:09:34 -05001137 seq_printf(seq, "N: Name=\"%s\"\n", dev->name ? dev->name : "");
1138 seq_printf(seq, "P: Phys=%s\n", dev->phys ? dev->phys : "");
1139 seq_printf(seq, "S: Sysfs=%s\n", path ? path : "");
Dmitry Torokhov15e03ae2007-03-07 23:20:17 -05001140 seq_printf(seq, "U: Uniq=%s\n", dev->uniq ? dev->uniq : "");
Markus Elfring63c95762017-05-09 17:49:59 -07001141 seq_puts(seq, "H: Handlers=");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001142
Dmitry Torokhov969b21c2006-04-02 00:09:34 -05001143 list_for_each_entry(handle, &dev->h_list, d_node)
1144 seq_printf(seq, "%s ", handle->name);
1145 seq_putc(seq, '\n');
Dmitry Torokhov051b2fe2005-09-15 02:01:54 -05001146
Henrik Rydberg85b77202010-12-18 20:51:13 +01001147 input_seq_print_bitmap(seq, "PROP", dev->propbit, INPUT_PROP_MAX);
1148
Dmitry Torokhov969b21c2006-04-02 00:09:34 -05001149 input_seq_print_bitmap(seq, "EV", dev->evbit, EV_MAX);
1150 if (test_bit(EV_KEY, dev->evbit))
1151 input_seq_print_bitmap(seq, "KEY", dev->keybit, KEY_MAX);
1152 if (test_bit(EV_REL, dev->evbit))
1153 input_seq_print_bitmap(seq, "REL", dev->relbit, REL_MAX);
1154 if (test_bit(EV_ABS, dev->evbit))
1155 input_seq_print_bitmap(seq, "ABS", dev->absbit, ABS_MAX);
1156 if (test_bit(EV_MSC, dev->evbit))
1157 input_seq_print_bitmap(seq, "MSC", dev->mscbit, MSC_MAX);
1158 if (test_bit(EV_LED, dev->evbit))
1159 input_seq_print_bitmap(seq, "LED", dev->ledbit, LED_MAX);
1160 if (test_bit(EV_SND, dev->evbit))
1161 input_seq_print_bitmap(seq, "SND", dev->sndbit, SND_MAX);
1162 if (test_bit(EV_FF, dev->evbit))
1163 input_seq_print_bitmap(seq, "FF", dev->ffbit, FF_MAX);
1164 if (test_bit(EV_SW, dev->evbit))
1165 input_seq_print_bitmap(seq, "SW", dev->swbit, SW_MAX);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001166
Dmitry Torokhov969b21c2006-04-02 00:09:34 -05001167 seq_putc(seq, '\n');
Linus Torvalds1da177e2005-04-16 15:20:36 -07001168
Dmitry Torokhov969b21c2006-04-02 00:09:34 -05001169 kfree(path);
1170 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001171}
1172
Jan Engelhardtcec69c32008-01-31 00:43:32 -05001173static const struct seq_operations input_devices_seq_ops = {
Dmitry Torokhov969b21c2006-04-02 00:09:34 -05001174 .start = input_devices_seq_start,
1175 .next = input_devices_seq_next,
Dmitry Torokhov1572ca22009-10-13 23:37:30 -07001176 .stop = input_seq_stop,
Dmitry Torokhov969b21c2006-04-02 00:09:34 -05001177 .show = input_devices_seq_show,
1178};
1179
1180static int input_proc_devices_open(struct inode *inode, struct file *file)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001181{
Dmitry Torokhov969b21c2006-04-02 00:09:34 -05001182 return seq_open(file, &input_devices_seq_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001183}
1184
Arjan van de Ven2b8693c2007-02-12 00:55:32 -08001185static const struct file_operations input_devices_fileops = {
Dmitry Torokhov969b21c2006-04-02 00:09:34 -05001186 .owner = THIS_MODULE,
1187 .open = input_proc_devices_open,
1188 .poll = input_proc_devices_poll,
1189 .read = seq_read,
1190 .llseek = seq_lseek,
1191 .release = seq_release,
1192};
1193
1194static void *input_handlers_seq_start(struct seq_file *seq, loff_t *pos)
1195{
Dmitry Torokhov1572ca22009-10-13 23:37:30 -07001196 union input_seq_state *state = (union input_seq_state *)&seq->private;
1197 int error;
Dmitry Torokhov80064792007-08-30 00:22:11 -04001198
Dmitry Torokhov1572ca22009-10-13 23:37:30 -07001199 /* We need to fit into seq->private pointer */
1200 BUILD_BUG_ON(sizeof(union input_seq_state) != sizeof(seq->private));
1201
1202 error = mutex_lock_interruptible(&input_mutex);
1203 if (error) {
1204 state->mutex_acquired = false;
1205 return ERR_PTR(error);
1206 }
1207
1208 state->mutex_acquired = true;
1209 state->pos = *pos;
1210
Pavel Emelianovad5d9722007-07-18 00:38:32 -04001211 return seq_list_start(&input_handler_list, *pos);
Dmitry Torokhov969b21c2006-04-02 00:09:34 -05001212}
1213
1214static void *input_handlers_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1215{
Dmitry Torokhov1572ca22009-10-13 23:37:30 -07001216 union input_seq_state *state = (union input_seq_state *)&seq->private;
Dmitry Torokhov969b21c2006-04-02 00:09:34 -05001217
Dmitry Torokhov1572ca22009-10-13 23:37:30 -07001218 state->pos = *pos + 1;
1219 return seq_list_next(v, &input_handler_list, pos);
Dmitry Torokhov969b21c2006-04-02 00:09:34 -05001220}
1221
1222static int input_handlers_seq_show(struct seq_file *seq, void *v)
1223{
1224 struct input_handler *handler = container_of(v, struct input_handler, node);
Dmitry Torokhov1572ca22009-10-13 23:37:30 -07001225 union input_seq_state *state = (union input_seq_state *)&seq->private;
Dmitry Torokhov969b21c2006-04-02 00:09:34 -05001226
Dmitry Torokhov1572ca22009-10-13 23:37:30 -07001227 seq_printf(seq, "N: Number=%u Name=%s", state->pos, handler->name);
Dmitry Torokhovef7995f2010-01-29 23:59:12 -08001228 if (handler->filter)
1229 seq_puts(seq, " (filter)");
Dmitry Torokhov7f8d4ca2012-10-08 09:07:24 -07001230 if (handler->legacy_minors)
Dmitry Torokhov969b21c2006-04-02 00:09:34 -05001231 seq_printf(seq, " Minor=%d", handler->minor);
1232 seq_putc(seq, '\n');
1233
1234 return 0;
1235}
Dmitry Torokhov1572ca22009-10-13 23:37:30 -07001236
Jan Engelhardtcec69c32008-01-31 00:43:32 -05001237static const struct seq_operations input_handlers_seq_ops = {
Dmitry Torokhov969b21c2006-04-02 00:09:34 -05001238 .start = input_handlers_seq_start,
1239 .next = input_handlers_seq_next,
Dmitry Torokhov1572ca22009-10-13 23:37:30 -07001240 .stop = input_seq_stop,
Dmitry Torokhov969b21c2006-04-02 00:09:34 -05001241 .show = input_handlers_seq_show,
1242};
1243
1244static int input_proc_handlers_open(struct inode *inode, struct file *file)
1245{
1246 return seq_open(file, &input_handlers_seq_ops);
1247}
1248
Arjan van de Ven2b8693c2007-02-12 00:55:32 -08001249static const struct file_operations input_handlers_fileops = {
Dmitry Torokhov969b21c2006-04-02 00:09:34 -05001250 .owner = THIS_MODULE,
1251 .open = input_proc_handlers_open,
1252 .read = seq_read,
1253 .llseek = seq_lseek,
1254 .release = seq_release,
1255};
Luke Kosewskie334016fc2005-06-01 02:39:28 -05001256
Linus Torvalds1da177e2005-04-16 15:20:36 -07001257static int __init input_proc_init(void)
1258{
1259 struct proc_dir_entry *entry;
1260
Alexey Dobriyan9c370662008-04-29 01:01:41 -07001261 proc_bus_input_dir = proc_mkdir("bus/input", NULL);
Dmitry Torokhovf96b4342005-06-30 00:50:29 -05001262 if (!proc_bus_input_dir)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001263 return -ENOMEM;
Dmitry Torokhovf96b4342005-06-30 00:50:29 -05001264
Denis V. Lunevc7705f3442008-04-29 01:02:35 -07001265 entry = proc_create("devices", 0, proc_bus_input_dir,
1266 &input_devices_fileops);
Dmitry Torokhovf96b4342005-06-30 00:50:29 -05001267 if (!entry)
1268 goto fail1;
1269
Denis V. Lunevc7705f3442008-04-29 01:02:35 -07001270 entry = proc_create("handlers", 0, proc_bus_input_dir,
1271 &input_handlers_fileops);
Dmitry Torokhovf96b4342005-06-30 00:50:29 -05001272 if (!entry)
1273 goto fail2;
1274
Linus Torvalds1da177e2005-04-16 15:20:36 -07001275 return 0;
Dmitry Torokhovf96b4342005-06-30 00:50:29 -05001276
1277 fail2: remove_proc_entry("devices", proc_bus_input_dir);
Alexey Dobriyan9c370662008-04-29 01:01:41 -07001278 fail1: remove_proc_entry("bus/input", NULL);
Dmitry Torokhovf96b4342005-06-30 00:50:29 -05001279 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001280}
Dmitry Torokhovf96b4342005-06-30 00:50:29 -05001281
Andrew Mortonbeffbdc2005-07-01 23:54:30 -05001282static void input_proc_exit(void)
Dmitry Torokhovf96b4342005-06-30 00:50:29 -05001283{
1284 remove_proc_entry("devices", proc_bus_input_dir);
1285 remove_proc_entry("handlers", proc_bus_input_dir);
Alexey Dobriyan9c370662008-04-29 01:01:41 -07001286 remove_proc_entry("bus/input", NULL);
Dmitry Torokhovf96b4342005-06-30 00:50:29 -05001287}
1288
Linus Torvalds1da177e2005-04-16 15:20:36 -07001289#else /* !CONFIG_PROC_FS */
Dmitry Torokhovf96b4342005-06-30 00:50:29 -05001290static inline void input_wakeup_procfs_readers(void) { }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001291static inline int input_proc_init(void) { return 0; }
Dmitry Torokhovf96b4342005-06-30 00:50:29 -05001292static inline void input_proc_exit(void) { }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001293#endif
1294
Dmitry Torokhov9657d752007-06-14 23:32:24 -04001295#define INPUT_DEV_STRING_ATTR_SHOW(name) \
1296static ssize_t input_dev_show_##name(struct device *dev, \
1297 struct device_attribute *attr, \
1298 char *buf) \
1299{ \
1300 struct input_dev *input_dev = to_input_dev(dev); \
1301 \
1302 return scnprintf(buf, PAGE_SIZE, "%s\n", \
1303 input_dev->name ? input_dev->name : ""); \
1304} \
1305static DEVICE_ATTR(name, S_IRUGO, input_dev_show_##name, NULL)
Dmitry Torokhov5c1e9a62005-09-15 02:01:55 -05001306
1307INPUT_DEV_STRING_ATTR_SHOW(name);
1308INPUT_DEV_STRING_ATTR_SHOW(phys);
1309INPUT_DEV_STRING_ATTR_SHOW(uniq);
1310
Dmitry Torokhovac648a62006-04-02 00:09:51 -05001311static int input_print_modalias_bits(char *buf, int size,
1312 char name, unsigned long *bm,
1313 unsigned int min_bit, unsigned int max_bit)
Rusty Russell1d8f4302005-12-07 21:40:34 +01001314{
Dmitry Torokhovac648a62006-04-02 00:09:51 -05001315 int len = 0, i;
Rusty Russell1d8f4302005-12-07 21:40:34 +01001316
Dmitry Torokhovac648a62006-04-02 00:09:51 -05001317 len += snprintf(buf, max(size, 0), "%c", name);
1318 for (i = min_bit; i < max_bit; i++)
Jiri Slaby7b19ada2007-10-18 23:40:32 -07001319 if (bm[BIT_WORD(i)] & BIT_MASK(i))
Dmitry Torokhovac648a62006-04-02 00:09:51 -05001320 len += snprintf(buf + len, max(size - len, 0), "%X,", i);
Kay Sieversbd37e5a2006-01-05 13:19:55 +01001321 return len;
1322}
1323
Dmitry Torokhov2db66872006-04-02 00:09:26 -05001324static int input_print_modalias(char *buf, int size, struct input_dev *id,
1325 int add_cr)
Kay Sieversbd37e5a2006-01-05 13:19:55 +01001326{
1327 int len;
1328
Dmitry Torokhovac648a62006-04-02 00:09:51 -05001329 len = snprintf(buf, max(size, 0),
1330 "input:b%04Xv%04Xp%04Xe%04X-",
1331 id->id.bustype, id->id.vendor,
1332 id->id.product, id->id.version);
Kay Sieversbd37e5a2006-01-05 13:19:55 +01001333
Dmitry Torokhovac648a62006-04-02 00:09:51 -05001334 len += input_print_modalias_bits(buf + len, size - len,
1335 'e', id->evbit, 0, EV_MAX);
1336 len += input_print_modalias_bits(buf + len, size - len,
1337 'k', id->keybit, KEY_MIN_INTERESTING, KEY_MAX);
1338 len += input_print_modalias_bits(buf + len, size - len,
1339 'r', id->relbit, 0, REL_MAX);
1340 len += input_print_modalias_bits(buf + len, size - len,
1341 'a', id->absbit, 0, ABS_MAX);
1342 len += input_print_modalias_bits(buf + len, size - len,
1343 'm', id->mscbit, 0, MSC_MAX);
1344 len += input_print_modalias_bits(buf + len, size - len,
1345 'l', id->ledbit, 0, LED_MAX);
1346 len += input_print_modalias_bits(buf + len, size - len,
1347 's', id->sndbit, 0, SND_MAX);
1348 len += input_print_modalias_bits(buf + len, size - len,
1349 'f', id->ffbit, 0, FF_MAX);
1350 len += input_print_modalias_bits(buf + len, size - len,
1351 'w', id->swbit, 0, SW_MAX);
Dmitry Torokhov2db66872006-04-02 00:09:26 -05001352
1353 if (add_cr)
Dmitry Torokhovac648a62006-04-02 00:09:51 -05001354 len += snprintf(buf + len, max(size - len, 0), "\n");
Dmitry Torokhov2db66872006-04-02 00:09:26 -05001355
Rusty Russell1d8f4302005-12-07 21:40:34 +01001356 return len;
1357}
1358
Dmitry Torokhov9657d752007-06-14 23:32:24 -04001359static ssize_t input_dev_show_modalias(struct device *dev,
1360 struct device_attribute *attr,
1361 char *buf)
Rusty Russell1d8f4302005-12-07 21:40:34 +01001362{
1363 struct input_dev *id = to_input_dev(dev);
Kay Sieversbd37e5a2006-01-05 13:19:55 +01001364 ssize_t len;
Rusty Russell1d8f4302005-12-07 21:40:34 +01001365
Dmitry Torokhov2db66872006-04-02 00:09:26 -05001366 len = input_print_modalias(buf, PAGE_SIZE, id, 1);
1367
Richard Purdie8a3cf452006-06-26 01:48:21 -04001368 return min_t(int, len, PAGE_SIZE);
Rusty Russell1d8f4302005-12-07 21:40:34 +01001369}
Dmitry Torokhov9657d752007-06-14 23:32:24 -04001370static DEVICE_ATTR(modalias, S_IRUGO, input_dev_show_modalias, NULL);
Rusty Russell1d8f4302005-12-07 21:40:34 +01001371
Henrik Rydberg85b77202010-12-18 20:51:13 +01001372static int input_print_bitmap(char *buf, int buf_size, unsigned long *bitmap,
1373 int max, int add_cr);
1374
1375static ssize_t input_dev_show_properties(struct device *dev,
1376 struct device_attribute *attr,
1377 char *buf)
1378{
1379 struct input_dev *input_dev = to_input_dev(dev);
1380 int len = input_print_bitmap(buf, PAGE_SIZE, input_dev->propbit,
1381 INPUT_PROP_MAX, true);
1382 return min_t(int, len, PAGE_SIZE);
1383}
1384static DEVICE_ATTR(properties, S_IRUGO, input_dev_show_properties, NULL);
1385
Greg Kroah-Hartman629b77a2005-10-27 22:25:43 -07001386static struct attribute *input_dev_attrs[] = {
Dmitry Torokhov9657d752007-06-14 23:32:24 -04001387 &dev_attr_name.attr,
1388 &dev_attr_phys.attr,
1389 &dev_attr_uniq.attr,
1390 &dev_attr_modalias.attr,
Henrik Rydberg85b77202010-12-18 20:51:13 +01001391 &dev_attr_properties.attr,
Greg Kroah-Hartman629b77a2005-10-27 22:25:43 -07001392 NULL
1393};
1394
Arvind Yadav5e895b72017-07-10 20:15:49 -07001395static const struct attribute_group input_dev_attr_group = {
Greg Kroah-Hartman629b77a2005-10-27 22:25:43 -07001396 .attrs = input_dev_attrs,
Dmitry Torokhov5c1e9a62005-09-15 02:01:55 -05001397};
1398
Dmitry Torokhov9657d752007-06-14 23:32:24 -04001399#define INPUT_DEV_ID_ATTR(name) \
1400static ssize_t input_dev_show_id_##name(struct device *dev, \
1401 struct device_attribute *attr, \
1402 char *buf) \
1403{ \
1404 struct input_dev *input_dev = to_input_dev(dev); \
1405 return scnprintf(buf, PAGE_SIZE, "%04x\n", input_dev->id.name); \
1406} \
1407static DEVICE_ATTR(name, S_IRUGO, input_dev_show_id_##name, NULL)
Dmitry Torokhov5c1e9a62005-09-15 02:01:55 -05001408
1409INPUT_DEV_ID_ATTR(bustype);
1410INPUT_DEV_ID_ATTR(vendor);
1411INPUT_DEV_ID_ATTR(product);
1412INPUT_DEV_ID_ATTR(version);
1413
1414static struct attribute *input_dev_id_attrs[] = {
Dmitry Torokhov9657d752007-06-14 23:32:24 -04001415 &dev_attr_bustype.attr,
1416 &dev_attr_vendor.attr,
1417 &dev_attr_product.attr,
1418 &dev_attr_version.attr,
Dmitry Torokhov5c1e9a62005-09-15 02:01:55 -05001419 NULL
1420};
1421
Arvind Yadav5e895b72017-07-10 20:15:49 -07001422static const struct attribute_group input_dev_id_attr_group = {
Dmitry Torokhov5c1e9a62005-09-15 02:01:55 -05001423 .name = "id",
1424 .attrs = input_dev_id_attrs,
1425};
1426
Dmitry Torokhov969b21c2006-04-02 00:09:34 -05001427static int input_print_bitmap(char *buf, int buf_size, unsigned long *bitmap,
1428 int max, int add_cr)
1429{
1430 int i;
1431 int len = 0;
Dmitry Torokhov15e184a2010-01-11 00:05:43 -08001432 bool skip_empty = true;
Dmitry Torokhov969b21c2006-04-02 00:09:34 -05001433
Dmitry Torokhov15e184a2010-01-11 00:05:43 -08001434 for (i = BITS_TO_LONGS(max) - 1; i >= 0; i--) {
1435 len += input_bits_to_string(buf + len, max(buf_size - len, 0),
1436 bitmap[i], skip_empty);
1437 if (len) {
1438 skip_empty = false;
1439 if (i > 0)
1440 len += snprintf(buf + len, max(buf_size - len, 0), " ");
1441 }
1442 }
Dmitry Torokhov969b21c2006-04-02 00:09:34 -05001443
Dmitry Torokhov15e184a2010-01-11 00:05:43 -08001444 /*
1445 * If no output was produced print a single 0.
1446 */
1447 if (len == 0)
1448 len = snprintf(buf, buf_size, "%d", 0);
Dmitry Torokhov969b21c2006-04-02 00:09:34 -05001449
1450 if (add_cr)
1451 len += snprintf(buf + len, max(buf_size - len, 0), "\n");
1452
1453 return len;
1454}
1455
Dmitry Torokhov9657d752007-06-14 23:32:24 -04001456#define INPUT_DEV_CAP_ATTR(ev, bm) \
1457static ssize_t input_dev_show_cap_##bm(struct device *dev, \
1458 struct device_attribute *attr, \
1459 char *buf) \
1460{ \
1461 struct input_dev *input_dev = to_input_dev(dev); \
1462 int len = input_print_bitmap(buf, PAGE_SIZE, \
Dmitry Torokhov15e184a2010-01-11 00:05:43 -08001463 input_dev->bm##bit, ev##_MAX, \
1464 true); \
Dmitry Torokhov9657d752007-06-14 23:32:24 -04001465 return min_t(int, len, PAGE_SIZE); \
1466} \
1467static DEVICE_ATTR(bm, S_IRUGO, input_dev_show_cap_##bm, NULL)
Dmitry Torokhov5c1e9a62005-09-15 02:01:55 -05001468
1469INPUT_DEV_CAP_ATTR(EV, ev);
1470INPUT_DEV_CAP_ATTR(KEY, key);
1471INPUT_DEV_CAP_ATTR(REL, rel);
1472INPUT_DEV_CAP_ATTR(ABS, abs);
1473INPUT_DEV_CAP_ATTR(MSC, msc);
1474INPUT_DEV_CAP_ATTR(LED, led);
1475INPUT_DEV_CAP_ATTR(SND, snd);
1476INPUT_DEV_CAP_ATTR(FF, ff);
1477INPUT_DEV_CAP_ATTR(SW, sw);
1478
1479static struct attribute *input_dev_caps_attrs[] = {
Dmitry Torokhov9657d752007-06-14 23:32:24 -04001480 &dev_attr_ev.attr,
1481 &dev_attr_key.attr,
1482 &dev_attr_rel.attr,
1483 &dev_attr_abs.attr,
1484 &dev_attr_msc.attr,
1485 &dev_attr_led.attr,
1486 &dev_attr_snd.attr,
1487 &dev_attr_ff.attr,
1488 &dev_attr_sw.attr,
Dmitry Torokhov5c1e9a62005-09-15 02:01:55 -05001489 NULL
1490};
1491
Arvind Yadav5e895b72017-07-10 20:15:49 -07001492static const struct attribute_group input_dev_caps_attr_group = {
Dmitry Torokhov5c1e9a62005-09-15 02:01:55 -05001493 .name = "capabilities",
1494 .attrs = input_dev_caps_attrs,
1495};
1496
David Brownella4dbd672009-06-24 10:06:31 -07001497static const struct attribute_group *input_dev_attr_groups[] = {
Dmitry Torokhovcb9def42007-03-07 23:20:26 -05001498 &input_dev_attr_group,
1499 &input_dev_id_attr_group,
1500 &input_dev_caps_attr_group,
1501 NULL
1502};
1503
Dmitry Torokhov9657d752007-06-14 23:32:24 -04001504static void input_dev_release(struct device *device)
Dmitry Torokhovd19fbe82005-09-15 02:01:39 -05001505{
Dmitry Torokhov9657d752007-06-14 23:32:24 -04001506 struct input_dev *dev = to_input_dev(device);
Dmitry Torokhovd19fbe82005-09-15 02:01:39 -05001507
Anssi Hannula509ca1a2006-07-19 01:40:22 -04001508 input_ff_destroy(dev);
Henrik Rydberg40d007e2010-07-15 23:10:10 -07001509 input_mt_destroy_slots(dev);
Daniel Mackd31b2862010-08-02 20:18:21 -07001510 kfree(dev->absinfo);
Henrik Rydberg4369c642012-09-15 15:23:35 +02001511 kfree(dev->vals);
Dmitry Torokhovd19fbe82005-09-15 02:01:39 -05001512 kfree(dev);
Anssi Hannula509ca1a2006-07-19 01:40:22 -04001513
Dmitry Torokhovd19fbe82005-09-15 02:01:39 -05001514 module_put(THIS_MODULE);
1515}
1516
Dmitry Torokhova7fadbe2005-09-15 02:01:57 -05001517/*
Kay Sievers312c0042005-11-16 09:00:00 +01001518 * Input uevent interface - loading event handlers based on
Dmitry Torokhova7fadbe2005-09-15 02:01:57 -05001519 * device bitfields.
1520 */
Kay Sievers7eff2e72007-08-14 15:15:12 +02001521static int input_add_uevent_bm_var(struct kobj_uevent_env *env,
Dmitry Torokhovac648a62006-04-02 00:09:51 -05001522 const char *name, unsigned long *bitmap, int max)
Dmitry Torokhova7fadbe2005-09-15 02:01:57 -05001523{
Kay Sievers7eff2e72007-08-14 15:15:12 +02001524 int len;
1525
Henrik Rydbergfcd30272010-12-18 20:28:26 +01001526 if (add_uevent_var(env, "%s", name))
Dmitry Torokhova7fadbe2005-09-15 02:01:57 -05001527 return -ENOMEM;
1528
Kay Sievers7eff2e72007-08-14 15:15:12 +02001529 len = input_print_bitmap(&env->buf[env->buflen - 1],
1530 sizeof(env->buf) - env->buflen,
Dmitry Torokhov15e184a2010-01-11 00:05:43 -08001531 bitmap, max, false);
Kay Sievers7eff2e72007-08-14 15:15:12 +02001532 if (len >= (sizeof(env->buf) - env->buflen))
Dmitry Torokhova7fadbe2005-09-15 02:01:57 -05001533 return -ENOMEM;
1534
Kay Sievers7eff2e72007-08-14 15:15:12 +02001535 env->buflen += len;
Dmitry Torokhova7fadbe2005-09-15 02:01:57 -05001536 return 0;
1537}
1538
Kay Sievers7eff2e72007-08-14 15:15:12 +02001539static int input_add_uevent_modalias_var(struct kobj_uevent_env *env,
Dmitry Torokhovac648a62006-04-02 00:09:51 -05001540 struct input_dev *dev)
1541{
Kay Sievers7eff2e72007-08-14 15:15:12 +02001542 int len;
1543
1544 if (add_uevent_var(env, "MODALIAS="))
Dmitry Torokhovac648a62006-04-02 00:09:51 -05001545 return -ENOMEM;
1546
Kay Sievers7eff2e72007-08-14 15:15:12 +02001547 len = input_print_modalias(&env->buf[env->buflen - 1],
1548 sizeof(env->buf) - env->buflen,
1549 dev, 0);
1550 if (len >= (sizeof(env->buf) - env->buflen))
Dmitry Torokhovac648a62006-04-02 00:09:51 -05001551 return -ENOMEM;
1552
Kay Sievers7eff2e72007-08-14 15:15:12 +02001553 env->buflen += len;
Dmitry Torokhovac648a62006-04-02 00:09:51 -05001554 return 0;
1555}
1556
Dmitry Torokhova7fadbe2005-09-15 02:01:57 -05001557#define INPUT_ADD_HOTPLUG_VAR(fmt, val...) \
1558 do { \
Kay Sievers7eff2e72007-08-14 15:15:12 +02001559 int err = add_uevent_var(env, fmt, val); \
Dmitry Torokhova7fadbe2005-09-15 02:01:57 -05001560 if (err) \
1561 return err; \
1562 } while (0)
1563
1564#define INPUT_ADD_HOTPLUG_BM_VAR(name, bm, max) \
1565 do { \
Kay Sievers7eff2e72007-08-14 15:15:12 +02001566 int err = input_add_uevent_bm_var(env, name, bm, max); \
Dmitry Torokhova7fadbe2005-09-15 02:01:57 -05001567 if (err) \
1568 return err; \
1569 } while (0)
1570
Dmitry Torokhovac648a62006-04-02 00:09:51 -05001571#define INPUT_ADD_HOTPLUG_MODALIAS_VAR(dev) \
1572 do { \
Kay Sievers7eff2e72007-08-14 15:15:12 +02001573 int err = input_add_uevent_modalias_var(env, dev); \
Dmitry Torokhovac648a62006-04-02 00:09:51 -05001574 if (err) \
1575 return err; \
1576 } while (0)
1577
Kay Sievers7eff2e72007-08-14 15:15:12 +02001578static int input_dev_uevent(struct device *device, struct kobj_uevent_env *env)
Dmitry Torokhova7fadbe2005-09-15 02:01:57 -05001579{
Dmitry Torokhov9657d752007-06-14 23:32:24 -04001580 struct input_dev *dev = to_input_dev(device);
Dmitry Torokhova7fadbe2005-09-15 02:01:57 -05001581
1582 INPUT_ADD_HOTPLUG_VAR("PRODUCT=%x/%x/%x/%x",
1583 dev->id.bustype, dev->id.vendor,
1584 dev->id.product, dev->id.version);
1585 if (dev->name)
1586 INPUT_ADD_HOTPLUG_VAR("NAME=\"%s\"", dev->name);
1587 if (dev->phys)
1588 INPUT_ADD_HOTPLUG_VAR("PHYS=\"%s\"", dev->phys);
Dmitry Torokhov08de1f02005-11-08 21:34:29 -08001589 if (dev->uniq)
Dmitry Torokhova7fadbe2005-09-15 02:01:57 -05001590 INPUT_ADD_HOTPLUG_VAR("UNIQ=\"%s\"", dev->uniq);
1591
Henrik Rydberg85b77202010-12-18 20:51:13 +01001592 INPUT_ADD_HOTPLUG_BM_VAR("PROP=", dev->propbit, INPUT_PROP_MAX);
1593
Dmitry Torokhova7fadbe2005-09-15 02:01:57 -05001594 INPUT_ADD_HOTPLUG_BM_VAR("EV=", dev->evbit, EV_MAX);
1595 if (test_bit(EV_KEY, dev->evbit))
1596 INPUT_ADD_HOTPLUG_BM_VAR("KEY=", dev->keybit, KEY_MAX);
1597 if (test_bit(EV_REL, dev->evbit))
1598 INPUT_ADD_HOTPLUG_BM_VAR("REL=", dev->relbit, REL_MAX);
1599 if (test_bit(EV_ABS, dev->evbit))
1600 INPUT_ADD_HOTPLUG_BM_VAR("ABS=", dev->absbit, ABS_MAX);
1601 if (test_bit(EV_MSC, dev->evbit))
1602 INPUT_ADD_HOTPLUG_BM_VAR("MSC=", dev->mscbit, MSC_MAX);
1603 if (test_bit(EV_LED, dev->evbit))
1604 INPUT_ADD_HOTPLUG_BM_VAR("LED=", dev->ledbit, LED_MAX);
1605 if (test_bit(EV_SND, dev->evbit))
1606 INPUT_ADD_HOTPLUG_BM_VAR("SND=", dev->sndbit, SND_MAX);
1607 if (test_bit(EV_FF, dev->evbit))
1608 INPUT_ADD_HOTPLUG_BM_VAR("FF=", dev->ffbit, FF_MAX);
1609 if (test_bit(EV_SW, dev->evbit))
1610 INPUT_ADD_HOTPLUG_BM_VAR("SW=", dev->swbit, SW_MAX);
1611
Dmitry Torokhovac648a62006-04-02 00:09:51 -05001612 INPUT_ADD_HOTPLUG_MODALIAS_VAR(dev);
Dmitry Torokhova7fadbe2005-09-15 02:01:57 -05001613
1614 return 0;
1615}
1616
Dmitry Torokhov3cc96352009-11-12 23:19:05 -08001617#define INPUT_DO_TOGGLE(dev, type, bits, on) \
1618 do { \
1619 int i; \
1620 bool active; \
1621 \
1622 if (!test_bit(EV_##type, dev->evbit)) \
1623 break; \
1624 \
Anshul Garg3e2b03d2015-06-25 13:33:12 -07001625 for_each_set_bit(i, dev->bits##bit, type##_CNT) { \
Dmitry Torokhov3cc96352009-11-12 23:19:05 -08001626 active = test_bit(i, dev->bits); \
1627 if (!active && !on) \
1628 continue; \
1629 \
1630 dev->event(dev, EV_##type, i, on ? active : 0); \
1631 } \
Dmitry Torokhovffd0db92009-09-16 01:06:43 -07001632 } while (0)
1633
Dmitry Torokhovb50b5212010-11-03 11:02:31 -07001634static void input_dev_toggle(struct input_dev *dev, bool activate)
Dmitry Torokhovffd0db92009-09-16 01:06:43 -07001635{
1636 if (!dev->event)
1637 return;
1638
1639 INPUT_DO_TOGGLE(dev, LED, led, activate);
1640 INPUT_DO_TOGGLE(dev, SND, snd, activate);
1641
1642 if (activate && test_bit(EV_REP, dev->evbit)) {
1643 dev->event(dev, EV_REP, REP_PERIOD, dev->rep[REP_PERIOD]);
1644 dev->event(dev, EV_REP, REP_DELAY, dev->rep[REP_DELAY]);
1645 }
1646}
1647
Dmitry Torokhovb50b5212010-11-03 11:02:31 -07001648/**
1649 * input_reset_device() - reset/restore the state of input device
1650 * @dev: input device whose state needs to be reset
1651 *
1652 * This function tries to reset the state of an opened input device and
1653 * bring internal state and state if the hardware in sync with each other.
1654 * We mark all keys as released, restore LED state, repeat rate, etc.
1655 */
1656void input_reset_device(struct input_dev *dev)
1657{
Aleksej Makarov768d9aa2013-11-23 10:20:36 -08001658 unsigned long flags;
1659
Dmitry Torokhovb50b5212010-11-03 11:02:31 -07001660 mutex_lock(&dev->mutex);
Aleksej Makarov768d9aa2013-11-23 10:20:36 -08001661 spin_lock_irqsave(&dev->event_lock, flags);
Dmitry Torokhovb50b5212010-11-03 11:02:31 -07001662
Aleksej Makarov768d9aa2013-11-23 10:20:36 -08001663 input_dev_toggle(dev, true);
1664 input_dev_release_keys(dev);
Dmitry Torokhovb50b5212010-11-03 11:02:31 -07001665
Aleksej Makarov768d9aa2013-11-23 10:20:36 -08001666 spin_unlock_irqrestore(&dev->event_lock, flags);
Dmitry Torokhovb50b5212010-11-03 11:02:31 -07001667 mutex_unlock(&dev->mutex);
1668}
1669EXPORT_SYMBOL(input_reset_device);
1670
Aleksej Makarov768d9aa2013-11-23 10:20:36 -08001671#ifdef CONFIG_PM_SLEEP
Dmitry Torokhovffd0db92009-09-16 01:06:43 -07001672static int input_dev_suspend(struct device *dev)
1673{
1674 struct input_dev *input_dev = to_input_dev(dev);
1675
Aleksej Makarov768d9aa2013-11-23 10:20:36 -08001676 spin_lock_irq(&input_dev->event_lock);
Dmitry Torokhovb50b5212010-11-03 11:02:31 -07001677
Aleksej Makarov768d9aa2013-11-23 10:20:36 -08001678 /*
1679 * Keys that are pressed now are unlikely to be
1680 * still pressed when we resume.
1681 */
1682 input_dev_release_keys(input_dev);
Dmitry Torokhovb50b5212010-11-03 11:02:31 -07001683
Aleksej Makarov768d9aa2013-11-23 10:20:36 -08001684 /* Turn off LEDs and sounds, if any are active. */
1685 input_dev_toggle(input_dev, false);
1686
1687 spin_unlock_irq(&input_dev->event_lock);
Dmitry Torokhovffd0db92009-09-16 01:06:43 -07001688
1689 return 0;
1690}
1691
1692static int input_dev_resume(struct device *dev)
1693{
1694 struct input_dev *input_dev = to_input_dev(dev);
1695
Aleksej Makarov768d9aa2013-11-23 10:20:36 -08001696 spin_lock_irq(&input_dev->event_lock);
1697
1698 /* Restore state of LEDs and sounds, if any were active. */
1699 input_dev_toggle(input_dev, true);
1700
1701 spin_unlock_irq(&input_dev->event_lock);
1702
1703 return 0;
1704}
1705
1706static int input_dev_freeze(struct device *dev)
1707{
1708 struct input_dev *input_dev = to_input_dev(dev);
1709
1710 spin_lock_irq(&input_dev->event_lock);
1711
1712 /*
1713 * Keys that are pressed now are unlikely to be
1714 * still pressed when we resume.
1715 */
1716 input_dev_release_keys(input_dev);
1717
1718 spin_unlock_irq(&input_dev->event_lock);
1719
1720 return 0;
1721}
1722
1723static int input_dev_poweroff(struct device *dev)
1724{
1725 struct input_dev *input_dev = to_input_dev(dev);
1726
1727 spin_lock_irq(&input_dev->event_lock);
1728
1729 /* Turn off LEDs and sounds, if any are active. */
1730 input_dev_toggle(input_dev, false);
1731
1732 spin_unlock_irq(&input_dev->event_lock);
Dmitry Torokhovffd0db92009-09-16 01:06:43 -07001733
1734 return 0;
1735}
1736
1737static const struct dev_pm_ops input_dev_pm_ops = {
1738 .suspend = input_dev_suspend,
1739 .resume = input_dev_resume,
Aleksej Makarov768d9aa2013-11-23 10:20:36 -08001740 .freeze = input_dev_freeze,
1741 .poweroff = input_dev_poweroff,
Dmitry Torokhovffd0db92009-09-16 01:06:43 -07001742 .restore = input_dev_resume,
1743};
1744#endif /* CONFIG_PM */
1745
Bhumika Goyalf7193152017-01-24 10:33:55 -08001746static const struct device_type input_dev_type = {
Dmitry Torokhov9657d752007-06-14 23:32:24 -04001747 .groups = input_dev_attr_groups,
1748 .release = input_dev_release,
1749 .uevent = input_dev_uevent,
Aleksej Makarov768d9aa2013-11-23 10:20:36 -08001750#ifdef CONFIG_PM_SLEEP
Dmitry Torokhovffd0db92009-09-16 01:06:43 -07001751 .pm = &input_dev_pm_ops,
1752#endif
Dmitry Torokhov9657d752007-06-14 23:32:24 -04001753};
1754
Al Viro2c9ede52011-07-23 20:24:48 -04001755static char *input_devnode(struct device *dev, umode_t *mode)
Kay Sieversaa5ed632009-04-30 15:23:42 +02001756{
1757 return kasprintf(GFP_KERNEL, "input/%s", dev_name(dev));
1758}
1759
Greg Kroah-Hartmanea9f2402005-10-27 22:25:43 -07001760struct class input_class = {
Dmitry Torokhov9657d752007-06-14 23:32:24 -04001761 .name = "input",
Kay Sieverse454cea2009-09-18 23:01:12 +02001762 .devnode = input_devnode,
Dmitry Torokhovd19fbe82005-09-15 02:01:39 -05001763};
Dmitry Torokhovca56fe02006-06-26 01:49:21 -04001764EXPORT_SYMBOL_GPL(input_class);
Dmitry Torokhovd19fbe82005-09-15 02:01:39 -05001765
Dmitry Torokhov14471902006-11-02 23:26:55 -05001766/**
1767 * input_allocate_device - allocate memory for new input device
1768 *
Dmitry Torokhov2be975c2012-11-03 12:16:12 -07001769 * Returns prepared struct input_dev or %NULL.
Dmitry Torokhov14471902006-11-02 23:26:55 -05001770 *
1771 * NOTE: Use input_free_device() to free devices that have not been
1772 * registered; input_unregister_device() should be used for already
1773 * registered devices.
1774 */
Dmitry Torokhovd19fbe82005-09-15 02:01:39 -05001775struct input_dev *input_allocate_device(void)
1776{
Aniroop Mathur9c7d66f2014-12-02 15:22:28 -08001777 static atomic_t input_no = ATOMIC_INIT(-1);
Dmitry Torokhovd19fbe82005-09-15 02:01:39 -05001778 struct input_dev *dev;
1779
Markus Elfringc3f6f862017-05-09 17:51:30 -07001780 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
Dmitry Torokhovd19fbe82005-09-15 02:01:39 -05001781 if (dev) {
Dmitry Torokhov9657d752007-06-14 23:32:24 -04001782 dev->dev.type = &input_dev_type;
1783 dev->dev.class = &input_class;
1784 device_initialize(&dev->dev);
Dmitry Torokhovf60d2b12006-06-26 01:48:36 -04001785 mutex_init(&dev->mutex);
Dmitry Torokhov80064792007-08-30 00:22:11 -04001786 spin_lock_init(&dev->event_lock);
Kees Cook4e974c12017-11-03 12:21:48 -07001787 timer_setup(&dev->timer, NULL, 0);
Dmitry Torokhovd19fbe82005-09-15 02:01:39 -05001788 INIT_LIST_HEAD(&dev->h_list);
1789 INIT_LIST_HEAD(&dev->node);
Dmitry Torokhov655816e2006-09-14 01:32:14 -04001790
Richard Leitnerbf1d50f2014-10-08 14:24:15 -07001791 dev_set_name(&dev->dev, "input%lu",
Aniroop Mathur9c7d66f2014-12-02 15:22:28 -08001792 (unsigned long)atomic_inc_return(&input_no));
David Herrmanna60a71b2013-10-06 01:15:08 -07001793
Dmitry Torokhov655816e2006-09-14 01:32:14 -04001794 __module_get(THIS_MODULE);
Dmitry Torokhovd19fbe82005-09-15 02:01:39 -05001795 }
1796
1797 return dev;
1798}
Dmitry Torokhovca56fe02006-06-26 01:49:21 -04001799EXPORT_SYMBOL(input_allocate_device);
Dmitry Torokhovd19fbe82005-09-15 02:01:39 -05001800
Dmitry Torokhov2be975c2012-11-03 12:16:12 -07001801struct input_devres {
1802 struct input_dev *input;
1803};
1804
1805static int devm_input_device_match(struct device *dev, void *res, void *data)
1806{
1807 struct input_devres *devres = res;
1808
1809 return devres->input == data;
1810}
1811
1812static void devm_input_device_release(struct device *dev, void *res)
1813{
1814 struct input_devres *devres = res;
1815 struct input_dev *input = devres->input;
1816
1817 dev_dbg(dev, "%s: dropping reference to %s\n",
1818 __func__, dev_name(&input->dev));
1819 input_put_device(input);
1820}
1821
1822/**
1823 * devm_input_allocate_device - allocate managed input device
1824 * @dev: device owning the input device being created
1825 *
1826 * Returns prepared struct input_dev or %NULL.
1827 *
1828 * Managed input devices do not need to be explicitly unregistered or
1829 * freed as it will be done automatically when owner device unbinds from
1830 * its driver (or binding fails). Once managed input device is allocated,
1831 * it is ready to be set up and registered in the same fashion as regular
1832 * input device. There are no special devm_input_device_[un]register()
Dmitry Torokhovb6662632013-01-08 09:10:31 -08001833 * variants, regular ones work with both managed and unmanaged devices,
1834 * should you need them. In most cases however, managed input device need
1835 * not be explicitly unregistered or freed.
Dmitry Torokhov2be975c2012-11-03 12:16:12 -07001836 *
1837 * NOTE: the owner device is set up as parent of input device and users
1838 * should not override it.
1839 */
Dmitry Torokhov2be975c2012-11-03 12:16:12 -07001840struct input_dev *devm_input_allocate_device(struct device *dev)
1841{
1842 struct input_dev *input;
1843 struct input_devres *devres;
1844
1845 devres = devres_alloc(devm_input_device_release,
Markus Elfringc3f6f862017-05-09 17:51:30 -07001846 sizeof(*devres), GFP_KERNEL);
Dmitry Torokhov2be975c2012-11-03 12:16:12 -07001847 if (!devres)
1848 return NULL;
1849
1850 input = input_allocate_device();
1851 if (!input) {
1852 devres_free(devres);
1853 return NULL;
1854 }
1855
1856 input->dev.parent = dev;
1857 input->devres_managed = true;
1858
1859 devres->input = input;
1860 devres_add(dev, devres);
1861
1862 return input;
1863}
1864EXPORT_SYMBOL(devm_input_allocate_device);
1865
Dmitry Torokhov14471902006-11-02 23:26:55 -05001866/**
1867 * input_free_device - free memory occupied by input_dev structure
1868 * @dev: input device to free
1869 *
1870 * This function should only be used if input_register_device()
1871 * was not called yet or if it failed. Once device was registered
1872 * use input_unregister_device() and memory will be freed once last
Dmitry Torokhov80064792007-08-30 00:22:11 -04001873 * reference to the device is dropped.
Dmitry Torokhov14471902006-11-02 23:26:55 -05001874 *
1875 * Device should be allocated by input_allocate_device().
1876 *
1877 * NOTE: If there are references to the input device then memory
1878 * will not be freed until last reference is dropped.
1879 */
Dmitry Torokhovf60d2b12006-06-26 01:48:36 -04001880void input_free_device(struct input_dev *dev)
1881{
Dmitry Torokhov2be975c2012-11-03 12:16:12 -07001882 if (dev) {
1883 if (dev->devres_managed)
1884 WARN_ON(devres_destroy(dev->dev.parent,
1885 devm_input_device_release,
1886 devm_input_device_match,
1887 dev));
Dmitry Torokhovf60d2b12006-06-26 01:48:36 -04001888 input_put_device(dev);
Dmitry Torokhov2be975c2012-11-03 12:16:12 -07001889 }
Dmitry Torokhovf60d2b12006-06-26 01:48:36 -04001890}
Dmitry Torokhovca56fe02006-06-26 01:49:21 -04001891EXPORT_SYMBOL(input_free_device);
Dmitry Torokhovf60d2b12006-06-26 01:48:36 -04001892
Dmitry Torokhov534565f2007-04-25 00:53:18 -04001893/**
1894 * input_set_capability - mark device as capable of a certain event
1895 * @dev: device that is capable of emitting or accepting event
1896 * @type: type of the event (EV_KEY, EV_REL, etc...)
1897 * @code: event code
1898 *
1899 * In addition to setting up corresponding bit in appropriate capability
1900 * bitmap the function also adjusts dev->evbit.
1901 */
1902void input_set_capability(struct input_dev *dev, unsigned int type, unsigned int code)
1903{
1904 switch (type) {
1905 case EV_KEY:
1906 __set_bit(code, dev->keybit);
1907 break;
1908
1909 case EV_REL:
1910 __set_bit(code, dev->relbit);
1911 break;
1912
1913 case EV_ABS:
Dmitry Torokhov28a2a2e2013-12-26 17:44:29 -08001914 input_alloc_absinfo(dev);
1915 if (!dev->absinfo)
1916 return;
1917
Dmitry Torokhov534565f2007-04-25 00:53:18 -04001918 __set_bit(code, dev->absbit);
1919 break;
1920
1921 case EV_MSC:
1922 __set_bit(code, dev->mscbit);
1923 break;
1924
1925 case EV_SW:
1926 __set_bit(code, dev->swbit);
1927 break;
1928
1929 case EV_LED:
1930 __set_bit(code, dev->ledbit);
1931 break;
1932
1933 case EV_SND:
1934 __set_bit(code, dev->sndbit);
1935 break;
1936
1937 case EV_FF:
1938 __set_bit(code, dev->ffbit);
1939 break;
1940
Dmitry Baryshkov22d1c392007-12-14 01:21:03 -05001941 case EV_PWR:
1942 /* do nothing */
1943 break;
1944
Dmitry Torokhov534565f2007-04-25 00:53:18 -04001945 default:
Nick Simonov67043f42018-05-15 10:33:52 -07001946 pr_err("%s: unknown type %u (code %u)\n", __func__, type, code);
Dmitry Torokhov534565f2007-04-25 00:53:18 -04001947 dump_stack();
1948 return;
1949 }
1950
1951 __set_bit(type, dev->evbit);
1952}
1953EXPORT_SYMBOL(input_set_capability);
1954
Jeff Brown80b48952011-04-18 10:08:02 -07001955static unsigned int input_estimate_events_per_packet(struct input_dev *dev)
1956{
1957 int mt_slots;
1958 int i;
1959 unsigned int events;
1960
Henrik Rydberg8d18fba2012-09-15 15:15:58 +02001961 if (dev->mt) {
1962 mt_slots = dev->mt->num_slots;
Jeff Brown80b48952011-04-18 10:08:02 -07001963 } else if (test_bit(ABS_MT_TRACKING_ID, dev->absbit)) {
1964 mt_slots = dev->absinfo[ABS_MT_TRACKING_ID].maximum -
1965 dev->absinfo[ABS_MT_TRACKING_ID].minimum + 1,
Hans Petter Selasky8c127f02011-05-25 09:24:32 -07001966 mt_slots = clamp(mt_slots, 2, 32);
Jeff Brown80b48952011-04-18 10:08:02 -07001967 } else if (test_bit(ABS_MT_POSITION_X, dev->absbit)) {
1968 mt_slots = 2;
1969 } else {
1970 mt_slots = 0;
1971 }
1972
1973 events = mt_slots + 1; /* count SYN_MT_REPORT and SYN_REPORT */
1974
Anshul Garg3e2b03d2015-06-25 13:33:12 -07001975 if (test_bit(EV_ABS, dev->evbit))
1976 for_each_set_bit(i, dev->absbit, ABS_CNT)
1977 events += input_is_mt_axis(i) ? mt_slots : 1;
Jeff Brown80b48952011-04-18 10:08:02 -07001978
Anshul Garg3e2b03d2015-06-25 13:33:12 -07001979 if (test_bit(EV_REL, dev->evbit))
1980 events += bitmap_weight(dev->relbit, REL_CNT);
Jeff Brown80b48952011-04-18 10:08:02 -07001981
Henrik Rydberg7c75bf92012-09-01 16:15:43 +02001982 /* Make room for KEY and MSC events */
1983 events += 7;
1984
Jeff Brown80b48952011-04-18 10:08:02 -07001985 return events;
1986}
1987
Dmitry Torokhov92a3a582010-01-05 17:56:01 -08001988#define INPUT_CLEANSE_BITMASK(dev, type, bits) \
1989 do { \
1990 if (!test_bit(EV_##type, dev->evbit)) \
1991 memset(dev->bits##bit, 0, \
1992 sizeof(dev->bits##bit)); \
1993 } while (0)
1994
1995static void input_cleanse_bitmasks(struct input_dev *dev)
1996{
1997 INPUT_CLEANSE_BITMASK(dev, KEY, key);
1998 INPUT_CLEANSE_BITMASK(dev, REL, rel);
1999 INPUT_CLEANSE_BITMASK(dev, ABS, abs);
2000 INPUT_CLEANSE_BITMASK(dev, MSC, msc);
2001 INPUT_CLEANSE_BITMASK(dev, LED, led);
2002 INPUT_CLEANSE_BITMASK(dev, SND, snd);
2003 INPUT_CLEANSE_BITMASK(dev, FF, ff);
2004 INPUT_CLEANSE_BITMASK(dev, SW, sw);
2005}
2006
Dmitry Torokhov2be975c2012-11-03 12:16:12 -07002007static void __input_unregister_device(struct input_dev *dev)
2008{
2009 struct input_handle *handle, *next;
2010
2011 input_disconnect_device(dev);
2012
2013 mutex_lock(&input_mutex);
2014
2015 list_for_each_entry_safe(handle, next, &dev->h_list, d_node)
2016 handle->handler->disconnect(handle);
2017 WARN_ON(!list_empty(&dev->h_list));
2018
2019 del_timer_sync(&dev->timer);
2020 list_del_init(&dev->node);
2021
2022 input_wakeup_procfs_readers();
2023
2024 mutex_unlock(&input_mutex);
2025
2026 device_del(&dev->dev);
2027}
2028
2029static void devm_input_device_unregister(struct device *dev, void *res)
2030{
2031 struct input_devres *devres = res;
2032 struct input_dev *input = devres->input;
2033
2034 dev_dbg(dev, "%s: unregistering device %s\n",
2035 __func__, dev_name(&input->dev));
2036 __input_unregister_device(input);
2037}
2038
Dmitry Torokhov80064792007-08-30 00:22:11 -04002039/**
Petri Gynther027c71b2015-10-13 23:13:55 -07002040 * input_enable_softrepeat - enable software autorepeat
2041 * @dev: input device
2042 * @delay: repeat delay
2043 * @period: repeat period
2044 *
2045 * Enable software autorepeat on the input device.
2046 */
2047void input_enable_softrepeat(struct input_dev *dev, int delay, int period)
2048{
Kees Cook841b86f2017-10-23 09:40:42 +02002049 dev->timer.function = input_repeat_key;
Petri Gynther027c71b2015-10-13 23:13:55 -07002050 dev->rep[REP_DELAY] = delay;
2051 dev->rep[REP_PERIOD] = period;
2052}
2053EXPORT_SYMBOL(input_enable_softrepeat);
2054
2055/**
Dmitry Torokhov80064792007-08-30 00:22:11 -04002056 * input_register_device - register device with input core
2057 * @dev: device to be registered
2058 *
2059 * This function registers device with input core. The device must be
2060 * allocated with input_allocate_device() and all it's capabilities
2061 * set up before registering.
2062 * If function fails the device must be freed with input_free_device().
2063 * Once device has been successfully registered it can be unregistered
2064 * with input_unregister_device(); input_free_device() should not be
2065 * called in this case.
Dmitry Torokhovb6662632013-01-08 09:10:31 -08002066 *
2067 * Note that this function is also used to register managed input devices
2068 * (ones allocated with devm_input_allocate_device()). Such managed input
2069 * devices need not be explicitly unregistered or freed, their tear down
2070 * is controlled by the devres infrastructure. It is also worth noting
2071 * that tear down of managed input devices is internally a 2-step process:
2072 * registered managed input device is first unregistered, but stays in
2073 * memory and can still handle input_event() calls (although events will
2074 * not be delivered anywhere). The freeing of managed input device will
2075 * happen later, when devres stack is unwound to the point where device
2076 * allocation was made.
Dmitry Torokhov80064792007-08-30 00:22:11 -04002077 */
Dmitry Torokhov5f945482005-11-02 22:51:46 -05002078int input_register_device(struct input_dev *dev)
Dmitry Torokhovf96b4342005-06-30 00:50:29 -05002079{
Dmitry Torokhov2be975c2012-11-03 12:16:12 -07002080 struct input_devres *devres = NULL;
Dmitry Torokhovf96b4342005-06-30 00:50:29 -05002081 struct input_handler *handler;
Henrik Rydberg7c75bf92012-09-01 16:15:43 +02002082 unsigned int packet_size;
Dmitry Torokhovbd0ef232005-11-20 00:56:31 -05002083 const char *path;
2084 int error;
Dmitry Torokhovf96b4342005-06-30 00:50:29 -05002085
Dmitry Torokhov6ecfe512017-01-31 15:09:08 -08002086 if (test_bit(EV_ABS, dev->evbit) && !dev->absinfo) {
2087 dev_err(&dev->dev,
2088 "Absolute device without dev->absinfo, refusing to register\n");
2089 return -EINVAL;
2090 }
2091
Dmitry Torokhov2be975c2012-11-03 12:16:12 -07002092 if (dev->devres_managed) {
2093 devres = devres_alloc(devm_input_device_unregister,
Markus Elfringc3f6f862017-05-09 17:51:30 -07002094 sizeof(*devres), GFP_KERNEL);
Dmitry Torokhov2be975c2012-11-03 12:16:12 -07002095 if (!devres)
2096 return -ENOMEM;
2097
2098 devres->input = dev;
2099 }
2100
Dmitry Torokhov4f93df42010-01-05 17:56:00 -08002101 /* Every input device generates EV_SYN/SYN_REPORT events. */
Dmitry Torokhov80064792007-08-30 00:22:11 -04002102 __set_bit(EV_SYN, dev->evbit);
Dmitry Torokhovf96b4342005-06-30 00:50:29 -05002103
Dmitry Torokhov4f93df42010-01-05 17:56:00 -08002104 /* KEY_RESERVED is not supposed to be transmitted to userspace. */
2105 __clear_bit(KEY_RESERVED, dev->keybit);
2106
Dmitry Torokhov92a3a582010-01-05 17:56:01 -08002107 /* Make sure that bitmasks not mentioned in dev->evbit are clean. */
2108 input_cleanse_bitmasks(dev);
2109
Henrik Rydberg7c75bf92012-09-01 16:15:43 +02002110 packet_size = input_estimate_events_per_packet(dev);
2111 if (dev->hint_events_per_packet < packet_size)
2112 dev->hint_events_per_packet = packet_size;
Jeff Brown80b48952011-04-18 10:08:02 -07002113
Kang Hu95079b82013-10-31 00:47:53 -07002114 dev->max_vals = dev->hint_events_per_packet + 2;
Henrik Rydberg4369c642012-09-15 15:23:35 +02002115 dev->vals = kcalloc(dev->max_vals, sizeof(*dev->vals), GFP_KERNEL);
Dmitry Torokhov2be975c2012-11-03 12:16:12 -07002116 if (!dev->vals) {
2117 error = -ENOMEM;
2118 goto err_devres_free;
2119 }
Dmitry Torokhovf96b4342005-06-30 00:50:29 -05002120
Dmitry Torokhov5b2a08262007-04-12 01:29:46 -04002121 /*
Dmitry Torokhovf96b4342005-06-30 00:50:29 -05002122 * If delay and period are pre-set by the driver, then autorepeating
Dmitry Torokhovf96b4342005-06-30 00:50:29 -05002123 * is handled by the driver itself and we don't do it in input.c.
Dmitry Torokhov5f945482005-11-02 22:51:46 -05002124 */
Petri Gynther027c71b2015-10-13 23:13:55 -07002125 if (!dev->rep[REP_DELAY] && !dev->rep[REP_PERIOD])
2126 input_enable_softrepeat(dev, 250, 33);
Dmitry Torokhov5b2a08262007-04-12 01:29:46 -04002127
Dmitry Torokhovf96b4342005-06-30 00:50:29 -05002128 if (!dev->getkeycode)
Dmitry Torokhov5b2a08262007-04-12 01:29:46 -04002129 dev->getkeycode = input_default_getkeycode;
Dmitry Torokhovf96b4342005-06-30 00:50:29 -05002130
Dmitry Torokhov80064792007-08-30 00:22:11 -04002131 if (!dev->setkeycode)
Dmitry Torokhovf96b4342005-06-30 00:50:29 -05002132 dev->setkeycode = input_default_setkeycode;
2133
Dmitry Torokhovf96b4342005-06-30 00:50:29 -05002134 error = device_add(&dev->dev);
2135 if (error)
Dmitry Torokhov2be975c2012-11-03 12:16:12 -07002136 goto err_free_vals;
Dmitry Torokhovf96b4342005-06-30 00:50:29 -05002137
2138 path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);
2139 pr_info("%s as %s\n",
2140 dev->name ? dev->name : "Unspecified device",
2141 path ? path : "N/A");
2142 kfree(path);
2143
2144 error = mutex_lock_interruptible(&input_mutex);
Dmitry Torokhov2be975c2012-11-03 12:16:12 -07002145 if (error)
2146 goto err_device_del;
Dmitry Torokhovf96b4342005-06-30 00:50:29 -05002147
2148 list_add_tail(&dev->node, &input_dev_list);
2149
2150 list_for_each_entry(handler, &input_handler_list, node)
2151 input_attach_handler(dev, handler);
2152
2153 input_wakeup_procfs_readers();
2154
2155 mutex_unlock(&input_mutex);
2156
Dmitry Torokhov2be975c2012-11-03 12:16:12 -07002157 if (dev->devres_managed) {
2158 dev_dbg(dev->dev.parent, "%s: registering %s with devres.\n",
2159 __func__, dev_name(&dev->dev));
2160 devres_add(dev->dev.parent, devres);
2161 }
Dmitry Torokhovf96b4342005-06-30 00:50:29 -05002162 return 0;
Dmitry Torokhov2be975c2012-11-03 12:16:12 -07002163
2164err_device_del:
2165 device_del(&dev->dev);
2166err_free_vals:
2167 kfree(dev->vals);
2168 dev->vals = NULL;
2169err_devres_free:
2170 devres_free(devres);
2171 return error;
Dmitry Torokhovf96b4342005-06-30 00:50:29 -05002172}
2173EXPORT_SYMBOL(input_register_device);
2174
2175/**
2176 * input_unregister_device - unregister previously registered device
2177 * @dev: device to be unregistered
2178 *
2179 * This function unregisters an input device. Once device is unregistered
2180 * the caller should not try to access it as it may get freed at any moment.
2181 */
2182void input_unregister_device(struct input_dev *dev)
2183{
Dmitry Torokhov2be975c2012-11-03 12:16:12 -07002184 if (dev->devres_managed) {
2185 WARN_ON(devres_destroy(dev->dev.parent,
2186 devm_input_device_unregister,
2187 devm_input_device_match,
2188 dev));
2189 __input_unregister_device(dev);
2190 /*
2191 * We do not do input_put_device() here because it will be done
2192 * when 2nd devres fires up.
2193 */
2194 } else {
2195 __input_unregister_device(dev);
2196 input_put_device(dev);
2197 }
Dmitry Torokhovf96b4342005-06-30 00:50:29 -05002198}
2199EXPORT_SYMBOL(input_unregister_device);
2200
Dmitry Torokhov80064792007-08-30 00:22:11 -04002201/**
2202 * input_register_handler - register a new input handler
2203 * @handler: handler to be registered
2204 *
2205 * This function registers a new input handler (interface) for input
2206 * devices in the system and attaches it to all input devices that
2207 * are compatible with the handler.
2208 */
Dmitry Torokhovf96b4342005-06-30 00:50:29 -05002209int input_register_handler(struct input_handler *handler)
2210{
2211 struct input_dev *dev;
Dmitry Torokhov7f8d4ca2012-10-08 09:07:24 -07002212 int error;
Dmitry Torokhov80064792007-08-30 00:22:11 -04002213
Dmitry Torokhov7f8d4ca2012-10-08 09:07:24 -07002214 error = mutex_lock_interruptible(&input_mutex);
2215 if (error)
2216 return error;
Dmitry Torokhovf96b4342005-06-30 00:50:29 -05002217
2218 INIT_LIST_HEAD(&handler->h_list);
2219
Dmitry Torokhovf96b4342005-06-30 00:50:29 -05002220 list_add_tail(&handler->node, &input_handler_list);
2221
2222 list_for_each_entry(dev, &input_dev_list, node)
Dmitry Torokhov5b2a08262007-04-12 01:29:46 -04002223 input_attach_handler(dev, handler);
Dmitry Torokhovf96b4342005-06-30 00:50:29 -05002224
2225 input_wakeup_procfs_readers();
Dmitry Torokhov80064792007-08-30 00:22:11 -04002226
Dmitry Torokhov80064792007-08-30 00:22:11 -04002227 mutex_unlock(&input_mutex);
Dmitry Torokhov7f8d4ca2012-10-08 09:07:24 -07002228 return 0;
Dmitry Torokhovf96b4342005-06-30 00:50:29 -05002229}
2230EXPORT_SYMBOL(input_register_handler);
2231
Dmitry Torokhov80064792007-08-30 00:22:11 -04002232/**
2233 * input_unregister_handler - unregisters an input handler
2234 * @handler: handler to be unregistered
2235 *
2236 * This function disconnects a handler from its input devices and
2237 * removes it from lists of known handlers.
2238 */
Dmitry Torokhovf96b4342005-06-30 00:50:29 -05002239void input_unregister_handler(struct input_handler *handler)
2240{
Dmitry Torokhov5b2a08262007-04-12 01:29:46 -04002241 struct input_handle *handle, *next;
Dmitry Torokhovf96b4342005-06-30 00:50:29 -05002242
Dmitry Torokhov80064792007-08-30 00:22:11 -04002243 mutex_lock(&input_mutex);
2244
Dmitry Torokhov5b2a08262007-04-12 01:29:46 -04002245 list_for_each_entry_safe(handle, next, &handler->h_list, h_node)
Dmitry Torokhovf96b4342005-06-30 00:50:29 -05002246 handler->disconnect(handle);
Dmitry Torokhov5b2a08262007-04-12 01:29:46 -04002247 WARN_ON(!list_empty(&handler->h_list));
Dmitry Torokhovf96b4342005-06-30 00:50:29 -05002248
2249 list_del_init(&handler->node);
2250
Dmitry Torokhovf96b4342005-06-30 00:50:29 -05002251 input_wakeup_procfs_readers();
Dmitry Torokhov80064792007-08-30 00:22:11 -04002252
2253 mutex_unlock(&input_mutex);
Dmitry Torokhovf96b4342005-06-30 00:50:29 -05002254}
Dmitry Torokhovca56fe02006-06-26 01:49:21 -04002255EXPORT_SYMBOL(input_unregister_handler);
Dmitry Torokhovf96b4342005-06-30 00:50:29 -05002256
Dmitry Torokhov80064792007-08-30 00:22:11 -04002257/**
Dmitry Torokhov66d2a592009-12-01 21:54:35 -08002258 * input_handler_for_each_handle - handle iterator
2259 * @handler: input handler to iterate
2260 * @data: data for the callback
2261 * @fn: function to be called for each handle
2262 *
2263 * Iterate over @bus's list of devices, and call @fn for each, passing
2264 * it @data and stop when @fn returns a non-zero value. The function is
Shailendra Vermaec8beff2015-05-18 10:44:33 -07002265 * using RCU to traverse the list and therefore may be using in atomic
Dmitry Torokhov66d2a592009-12-01 21:54:35 -08002266 * contexts. The @fn callback is invoked from RCU critical section and
2267 * thus must not sleep.
2268 */
2269int input_handler_for_each_handle(struct input_handler *handler, void *data,
2270 int (*fn)(struct input_handle *, void *))
2271{
2272 struct input_handle *handle;
2273 int retval = 0;
2274
2275 rcu_read_lock();
2276
2277 list_for_each_entry_rcu(handle, &handler->h_list, h_node) {
2278 retval = fn(handle, data);
2279 if (retval)
2280 break;
2281 }
2282
2283 rcu_read_unlock();
2284
2285 return retval;
2286}
2287EXPORT_SYMBOL(input_handler_for_each_handle);
2288
2289/**
Dmitry Torokhov80064792007-08-30 00:22:11 -04002290 * input_register_handle - register a new input handle
2291 * @handle: handle to register
2292 *
2293 * This function puts a new input handle onto device's
2294 * and handler's lists so that events can flow through
2295 * it once it is opened using input_open_device().
2296 *
2297 * This function is supposed to be called from handler's
2298 * connect() method.
2299 */
Dmitry Torokhov5b2a08262007-04-12 01:29:46 -04002300int input_register_handle(struct input_handle *handle)
2301{
2302 struct input_handler *handler = handle->handler;
Dmitry Torokhov80064792007-08-30 00:22:11 -04002303 struct input_dev *dev = handle->dev;
2304 int error;
Dmitry Torokhov5b2a08262007-04-12 01:29:46 -04002305
Dmitry Torokhov80064792007-08-30 00:22:11 -04002306 /*
2307 * We take dev->mutex here to prevent race with
2308 * input_release_device().
2309 */
2310 error = mutex_lock_interruptible(&dev->mutex);
2311 if (error)
2312 return error;
Dmitry Torokhovef7995f2010-01-29 23:59:12 -08002313
2314 /*
2315 * Filters go to the head of the list, normal handlers
2316 * to the tail.
2317 */
2318 if (handler->filter)
2319 list_add_rcu(&handle->d_node, &dev->h_list);
2320 else
2321 list_add_tail_rcu(&handle->d_node, &dev->h_list);
2322
Dmitry Torokhov80064792007-08-30 00:22:11 -04002323 mutex_unlock(&dev->mutex);
Dmitry Torokhov80064792007-08-30 00:22:11 -04002324
2325 /*
2326 * Since we are supposed to be called from ->connect()
2327 * which is mutually exclusive with ->disconnect()
2328 * we can't be racing with input_unregister_handle()
2329 * and so separate lock is not needed here.
2330 */
Dmitry Torokhov66d2a592009-12-01 21:54:35 -08002331 list_add_tail_rcu(&handle->h_node, &handler->h_list);
Dmitry Torokhov5b2a08262007-04-12 01:29:46 -04002332
2333 if (handler->start)
2334 handler->start(handle);
2335
2336 return 0;
2337}
2338EXPORT_SYMBOL(input_register_handle);
2339
Dmitry Torokhov80064792007-08-30 00:22:11 -04002340/**
2341 * input_unregister_handle - unregister an input handle
2342 * @handle: handle to unregister
2343 *
2344 * This function removes input handle from device's
2345 * and handler's lists.
2346 *
2347 * This function is supposed to be called from handler's
2348 * disconnect() method.
2349 */
Dmitry Torokhov5b2a08262007-04-12 01:29:46 -04002350void input_unregister_handle(struct input_handle *handle)
2351{
Dmitry Torokhov80064792007-08-30 00:22:11 -04002352 struct input_dev *dev = handle->dev;
2353
Dmitry Torokhov66d2a592009-12-01 21:54:35 -08002354 list_del_rcu(&handle->h_node);
Dmitry Torokhov80064792007-08-30 00:22:11 -04002355
2356 /*
2357 * Take dev->mutex to prevent race with input_release_device().
2358 */
2359 mutex_lock(&dev->mutex);
2360 list_del_rcu(&handle->d_node);
2361 mutex_unlock(&dev->mutex);
Dmitry Torokhov66d2a592009-12-01 21:54:35 -08002362
Dmitry Torokhov82ba56c2007-10-13 15:46:55 -04002363 synchronize_rcu();
Dmitry Torokhov5b2a08262007-04-12 01:29:46 -04002364}
2365EXPORT_SYMBOL(input_unregister_handle);
2366
Dmitry Torokhov7f8d4ca2012-10-08 09:07:24 -07002367/**
2368 * input_get_new_minor - allocates a new input minor number
2369 * @legacy_base: beginning or the legacy range to be searched
2370 * @legacy_num: size of legacy range
2371 * @allow_dynamic: whether we can also take ID from the dynamic range
2372 *
2373 * This function allocates a new device minor for from input major namespace.
2374 * Caller can request legacy minor by specifying @legacy_base and @legacy_num
2375 * parameters and whether ID can be allocated from dynamic range if there are
2376 * no free IDs in legacy range.
2377 */
2378int input_get_new_minor(int legacy_base, unsigned int legacy_num,
2379 bool allow_dynamic)
Dmitry Torokhovf96b4342005-06-30 00:50:29 -05002380{
Dmitry Torokhovf96b4342005-06-30 00:50:29 -05002381 /*
Dmitry Torokhov7f8d4ca2012-10-08 09:07:24 -07002382 * This function should be called from input handler's ->connect()
2383 * methods, which are serialized with input_mutex, so no additional
2384 * locking is needed here.
Dmitry Torokhovf96b4342005-06-30 00:50:29 -05002385 */
Dmitry Torokhov7f8d4ca2012-10-08 09:07:24 -07002386 if (legacy_base >= 0) {
2387 int minor = ida_simple_get(&input_ida,
2388 legacy_base,
2389 legacy_base + legacy_num,
2390 GFP_KERNEL);
2391 if (minor >= 0 || !allow_dynamic)
2392 return minor;
Dmitry Torokhovf96b4342005-06-30 00:50:29 -05002393 }
Arnd Bergmann2f2177c2010-03-09 20:38:48 -08002394
Dmitry Torokhov7f8d4ca2012-10-08 09:07:24 -07002395 return ida_simple_get(&input_ida,
2396 INPUT_FIRST_DYNAMIC_DEV, INPUT_MAX_CHAR_DEVICES,
2397 GFP_KERNEL);
Dmitry Torokhovf96b4342005-06-30 00:50:29 -05002398}
Dmitry Torokhov7f8d4ca2012-10-08 09:07:24 -07002399EXPORT_SYMBOL(input_get_new_minor);
Dmitry Torokhovf96b4342005-06-30 00:50:29 -05002400
Dmitry Torokhov7f8d4ca2012-10-08 09:07:24 -07002401/**
2402 * input_free_minor - release previously allocated minor
2403 * @minor: minor to be released
2404 *
2405 * This function releases previously allocated input minor so that it can be
2406 * reused later.
2407 */
2408void input_free_minor(unsigned int minor)
2409{
2410 ida_simple_remove(&input_ida, minor);
2411}
2412EXPORT_SYMBOL(input_free_minor);
Dmitry Torokhovf96b4342005-06-30 00:50:29 -05002413
Linus Torvalds1da177e2005-04-16 15:20:36 -07002414static int __init input_init(void)
2415{
Dmitry Torokhovf96b4342005-06-30 00:50:29 -05002416 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002417
Greg Kroah-Hartmanea9f2402005-10-27 22:25:43 -07002418 err = class_register(&input_class);
Dmitry Torokhovd19fbe82005-09-15 02:01:39 -05002419 if (err) {
Joe Perchesda0c4902010-11-29 23:33:07 -08002420 pr_err("unable to register input_dev class\n");
Dmitry Torokhovd19fbe82005-09-15 02:01:39 -05002421 return err;
2422 }
2423
Dmitry Torokhovf96b4342005-06-30 00:50:29 -05002424 err = input_proc_init();
2425 if (err)
Greg Kroah-Hartmanb0fdfeb2005-10-27 22:25:43 -07002426 goto fail1;
Dmitry Torokhovf96b4342005-06-30 00:50:29 -05002427
Dmitry Torokhov7f8d4ca2012-10-08 09:07:24 -07002428 err = register_chrdev_region(MKDEV(INPUT_MAJOR, 0),
2429 INPUT_MAX_CHAR_DEVICES, "input");
Dmitry Torokhovf96b4342005-06-30 00:50:29 -05002430 if (err) {
Joe Perchesda0c4902010-11-29 23:33:07 -08002431 pr_err("unable to register char major %d", INPUT_MAJOR);
Greg Kroah-Hartmanb0fdfeb2005-10-27 22:25:43 -07002432 goto fail2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002433 }
Dmitry Torokhovf96b4342005-06-30 00:50:29 -05002434
Dmitry Torokhovf96b4342005-06-30 00:50:29 -05002435 return 0;
2436
Greg Kroah-Hartmanb0fdfeb2005-10-27 22:25:43 -07002437 fail2: input_proc_exit();
Greg Kroah-Hartmanea9f2402005-10-27 22:25:43 -07002438 fail1: class_unregister(&input_class);
Dmitry Torokhovf96b4342005-06-30 00:50:29 -05002439 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002440}
2441
2442static void __exit input_exit(void)
2443{
Dmitry Torokhovf96b4342005-06-30 00:50:29 -05002444 input_proc_exit();
Dmitry Torokhov7f8d4ca2012-10-08 09:07:24 -07002445 unregister_chrdev_region(MKDEV(INPUT_MAJOR, 0),
2446 INPUT_MAX_CHAR_DEVICES);
Greg Kroah-Hartmanea9f2402005-10-27 22:25:43 -07002447 class_unregister(&input_class);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002448}
2449
2450subsys_initcall(input_init);
2451module_exit(input_exit);