evdev.c 32 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Event char devices, giving access to raw input device events.
  4. *
  5. * Copyright (c) 1999-2002 Vojtech Pavlik
  6. */
  7. #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  8. #define EVDEV_MINOR_BASE 64
  9. #define EVDEV_MINORS 32
  10. #define EVDEV_MIN_BUFFER_SIZE 64U
  11. #define EVDEV_BUF_PACKETS 8
  12. #include <linux/poll.h>
  13. #include <linux/sched.h>
  14. #include <linux/slab.h>
  15. #include <linux/vmalloc.h>
  16. #include <linux/mm.h>
  17. #include <linux/module.h>
  18. #include <linux/init.h>
  19. #include <linux/input/mt.h>
  20. #include <linux/major.h>
  21. #include <linux/device.h>
  22. #include <linux/cdev.h>
  23. #include "input-compat.h"
  24. struct evdev {
  25. int open;
  26. struct input_handle handle;
  27. struct evdev_client __rcu *grab;
  28. struct list_head client_list;
  29. spinlock_t client_lock; /* protects client_list */
  30. struct mutex mutex;
  31. struct device dev;
  32. struct cdev cdev;
  33. bool exist;
  34. };
  35. struct evdev_client {
  36. unsigned int head;
  37. unsigned int tail;
  38. unsigned int packet_head; /* [future] position of the first element of next packet */
  39. spinlock_t buffer_lock; /* protects access to buffer, head and tail */
  40. wait_queue_head_t wait;
  41. struct fasync_struct *fasync;
  42. struct evdev *evdev;
  43. struct list_head node;
  44. enum input_clock_type clk_type;
  45. bool revoked;
  46. unsigned long *evmasks[EV_CNT];
  47. unsigned int bufsize;
  48. struct input_event buffer[];
  49. };
  50. static size_t evdev_get_mask_cnt(unsigned int type)
  51. {
  52. static const size_t counts[EV_CNT] = {
  53. /* EV_SYN==0 is EV_CNT, _not_ SYN_CNT, see EVIOCGBIT */
  54. [EV_SYN] = EV_CNT,
  55. [EV_KEY] = KEY_CNT,
  56. [EV_REL] = REL_CNT,
  57. [EV_ABS] = ABS_CNT,
  58. [EV_MSC] = MSC_CNT,
  59. [EV_SW] = SW_CNT,
  60. [EV_LED] = LED_CNT,
  61. [EV_SND] = SND_CNT,
  62. [EV_FF] = FF_CNT,
  63. };
  64. return (type < EV_CNT) ? counts[type] : 0;
  65. }
  66. /* requires the buffer lock to be held */
  67. static bool __evdev_is_filtered(struct evdev_client *client,
  68. unsigned int type,
  69. unsigned int code)
  70. {
  71. unsigned long *mask;
  72. size_t cnt;
  73. /* EV_SYN and unknown codes are never filtered */
  74. if (type == EV_SYN || type >= EV_CNT)
  75. return false;
  76. /* first test whether the type is filtered */
  77. mask = client->evmasks[0];
  78. if (mask && !test_bit(type, mask))
  79. return true;
  80. /* unknown values are never filtered */
  81. cnt = evdev_get_mask_cnt(type);
  82. if (!cnt || code >= cnt)
  83. return false;
  84. mask = client->evmasks[type];
  85. return mask && !test_bit(code, mask);
  86. }
  87. /* flush queued events of type @type, caller must hold client->buffer_lock */
  88. static void __evdev_flush_queue(struct evdev_client *client, unsigned int type)
  89. {
  90. unsigned int i, head, num;
  91. unsigned int mask = client->bufsize - 1;
  92. bool is_report;
  93. struct input_event *ev;
  94. BUG_ON(type == EV_SYN);
  95. head = client->tail;
  96. client->packet_head = client->tail;
  97. /* init to 1 so a leading SYN_REPORT will not be dropped */
  98. num = 1;
  99. for (i = client->tail; i != client->head; i = (i + 1) & mask) {
  100. ev = &client->buffer[i];
  101. is_report = ev->type == EV_SYN && ev->code == SYN_REPORT;
  102. if (ev->type == type) {
  103. /* drop matched entry */
  104. continue;
  105. } else if (is_report && !num) {
  106. /* drop empty SYN_REPORT groups */
  107. continue;
  108. } else if (head != i) {
  109. /* move entry to fill the gap */
  110. client->buffer[head] = *ev;
  111. }
  112. num++;
  113. head = (head + 1) & mask;
  114. if (is_report) {
  115. num = 0;
  116. client->packet_head = head;
  117. }
  118. }
  119. client->head = head;
  120. }
  121. static void __evdev_queue_syn_dropped(struct evdev_client *client)
  122. {
  123. ktime_t *ev_time = input_get_timestamp(client->evdev->handle.dev);
  124. struct timespec64 ts = ktime_to_timespec64(ev_time[client->clk_type]);
  125. struct input_event ev;
  126. ev.input_event_sec = ts.tv_sec;
  127. ev.input_event_usec = ts.tv_nsec / NSEC_PER_USEC;
  128. ev.type = EV_SYN;
  129. ev.code = SYN_DROPPED;
  130. ev.value = 0;
  131. client->buffer[client->head++] = ev;
  132. client->head &= client->bufsize - 1;
  133. if (unlikely(client->head == client->tail)) {
  134. /* drop queue but keep our SYN_DROPPED event */
  135. client->tail = (client->head - 1) & (client->bufsize - 1);
  136. client->packet_head = client->tail;
  137. }
  138. }
  139. static void evdev_queue_syn_dropped(struct evdev_client *client)
  140. {
  141. unsigned long flags;
  142. spin_lock_irqsave(&client->buffer_lock, flags);
  143. __evdev_queue_syn_dropped(client);
  144. spin_unlock_irqrestore(&client->buffer_lock, flags);
  145. }
  146. static int evdev_set_clk_type(struct evdev_client *client, unsigned int clkid)
  147. {
  148. unsigned long flags;
  149. enum input_clock_type clk_type;
  150. switch (clkid) {
  151. case CLOCK_REALTIME:
  152. clk_type = INPUT_CLK_REAL;
  153. break;
  154. case CLOCK_MONOTONIC:
  155. clk_type = INPUT_CLK_MONO;
  156. break;
  157. case CLOCK_BOOTTIME:
  158. clk_type = INPUT_CLK_BOOT;
  159. break;
  160. default:
  161. return -EINVAL;
  162. }
  163. if (client->clk_type != clk_type) {
  164. client->clk_type = clk_type;
  165. /*
  166. * Flush pending events and queue SYN_DROPPED event,
  167. * but only if the queue is not empty.
  168. */
  169. spin_lock_irqsave(&client->buffer_lock, flags);
  170. if (client->head != client->tail) {
  171. client->packet_head = client->head = client->tail;
  172. __evdev_queue_syn_dropped(client);
  173. }
  174. spin_unlock_irqrestore(&client->buffer_lock, flags);
  175. }
  176. return 0;
  177. }
  178. static void __pass_event(struct evdev_client *client,
  179. const struct input_event *event)
  180. {
  181. client->buffer[client->head++] = *event;
  182. client->head &= client->bufsize - 1;
  183. if (unlikely(client->head == client->tail)) {
  184. /*
  185. * This effectively "drops" all unconsumed events, leaving
  186. * EV_SYN/SYN_DROPPED plus the newest event in the queue.
  187. */
  188. client->tail = (client->head - 2) & (client->bufsize - 1);
  189. client->buffer[client->tail] = (struct input_event) {
  190. .input_event_sec = event->input_event_sec,
  191. .input_event_usec = event->input_event_usec,
  192. .type = EV_SYN,
  193. .code = SYN_DROPPED,
  194. .value = 0,
  195. };
  196. client->packet_head = client->tail;
  197. }
  198. if (event->type == EV_SYN && event->code == SYN_REPORT) {
  199. client->packet_head = client->head;
  200. kill_fasync(&client->fasync, SIGIO, POLL_IN);
  201. }
  202. }
  203. static void evdev_pass_values(struct evdev_client *client,
  204. const struct input_value *vals, unsigned int count,
  205. ktime_t *ev_time)
  206. {
  207. const struct input_value *v;
  208. struct input_event event;
  209. struct timespec64 ts;
  210. bool wakeup = false;
  211. if (client->revoked)
  212. return;
  213. ts = ktime_to_timespec64(ev_time[client->clk_type]);
  214. event.input_event_sec = ts.tv_sec;
  215. event.input_event_usec = ts.tv_nsec / NSEC_PER_USEC;
  216. /* Interrupts are disabled, just acquire the lock. */
  217. spin_lock(&client->buffer_lock);
  218. for (v = vals; v != vals + count; v++) {
  219. if (__evdev_is_filtered(client, v->type, v->code))
  220. continue;
  221. if (v->type == EV_SYN && v->code == SYN_REPORT) {
  222. /* drop empty SYN_REPORT */
  223. if (client->packet_head == client->head)
  224. continue;
  225. wakeup = true;
  226. }
  227. event.type = v->type;
  228. event.code = v->code;
  229. event.value = v->value;
  230. __pass_event(client, &event);
  231. }
  232. spin_unlock(&client->buffer_lock);
  233. if (wakeup)
  234. wake_up_interruptible_poll(&client->wait,
  235. EPOLLIN | EPOLLOUT | EPOLLRDNORM | EPOLLWRNORM);
  236. }
  237. /*
  238. * Pass incoming events to all connected clients.
  239. */
  240. static void evdev_events(struct input_handle *handle,
  241. const struct input_value *vals, unsigned int count)
  242. {
  243. struct evdev *evdev = handle->private;
  244. struct evdev_client *client;
  245. ktime_t *ev_time = input_get_timestamp(handle->dev);
  246. rcu_read_lock();
  247. client = rcu_dereference(evdev->grab);
  248. if (client)
  249. evdev_pass_values(client, vals, count, ev_time);
  250. else
  251. list_for_each_entry_rcu(client, &evdev->client_list, node)
  252. evdev_pass_values(client, vals, count, ev_time);
  253. rcu_read_unlock();
  254. }
  255. /*
  256. * Pass incoming event to all connected clients.
  257. */
  258. static void evdev_event(struct input_handle *handle,
  259. unsigned int type, unsigned int code, int value)
  260. {
  261. struct input_value vals[] = { { type, code, value } };
  262. evdev_events(handle, vals, 1);
  263. }
  264. static int evdev_fasync(int fd, struct file *file, int on)
  265. {
  266. struct evdev_client *client = file->private_data;
  267. return fasync_helper(fd, file, on, &client->fasync);
  268. }
  269. static void evdev_free(struct device *dev)
  270. {
  271. struct evdev *evdev = container_of(dev, struct evdev, dev);
  272. input_put_device(evdev->handle.dev);
  273. kfree(evdev);
  274. }
  275. /*
  276. * Grabs an event device (along with underlying input device).
  277. * This function is called with evdev->mutex taken.
  278. */
  279. static int evdev_grab(struct evdev *evdev, struct evdev_client *client)
  280. {
  281. int error;
  282. if (evdev->grab)
  283. return -EBUSY;
  284. error = input_grab_device(&evdev->handle);
  285. if (error)
  286. return error;
  287. rcu_assign_pointer(evdev->grab, client);
  288. return 0;
  289. }
  290. static int evdev_ungrab(struct evdev *evdev, struct evdev_client *client)
  291. {
  292. struct evdev_client *grab = rcu_dereference_protected(evdev->grab,
  293. lockdep_is_held(&evdev->mutex));
  294. if (grab != client)
  295. return -EINVAL;
  296. rcu_assign_pointer(evdev->grab, NULL);
  297. synchronize_rcu();
  298. input_release_device(&evdev->handle);
  299. return 0;
  300. }
  301. static void evdev_attach_client(struct evdev *evdev,
  302. struct evdev_client *client)
  303. {
  304. spin_lock(&evdev->client_lock);
  305. list_add_tail_rcu(&client->node, &evdev->client_list);
  306. spin_unlock(&evdev->client_lock);
  307. }
  308. static void evdev_detach_client(struct evdev *evdev,
  309. struct evdev_client *client)
  310. {
  311. spin_lock(&evdev->client_lock);
  312. list_del_rcu(&client->node);
  313. spin_unlock(&evdev->client_lock);
  314. synchronize_rcu();
  315. }
  316. static int evdev_open_device(struct evdev *evdev)
  317. {
  318. int retval;
  319. retval = mutex_lock_interruptible(&evdev->mutex);
  320. if (retval)
  321. return retval;
  322. if (!evdev->exist)
  323. retval = -ENODEV;
  324. else if (!evdev->open++) {
  325. retval = input_open_device(&evdev->handle);
  326. if (retval)
  327. evdev->open--;
  328. }
  329. mutex_unlock(&evdev->mutex);
  330. return retval;
  331. }
  332. static void evdev_close_device(struct evdev *evdev)
  333. {
  334. mutex_lock(&evdev->mutex);
  335. if (evdev->exist && !--evdev->open)
  336. input_close_device(&evdev->handle);
  337. mutex_unlock(&evdev->mutex);
  338. }
  339. /*
  340. * Wake up users waiting for IO so they can disconnect from
  341. * dead device.
  342. */
  343. static void evdev_hangup(struct evdev *evdev)
  344. {
  345. struct evdev_client *client;
  346. spin_lock(&evdev->client_lock);
  347. list_for_each_entry(client, &evdev->client_list, node) {
  348. kill_fasync(&client->fasync, SIGIO, POLL_HUP);
  349. wake_up_interruptible_poll(&client->wait, EPOLLHUP | EPOLLERR);
  350. }
  351. spin_unlock(&evdev->client_lock);
  352. }
  353. static int evdev_release(struct inode *inode, struct file *file)
  354. {
  355. struct evdev_client *client = file->private_data;
  356. struct evdev *evdev = client->evdev;
  357. unsigned int i;
  358. mutex_lock(&evdev->mutex);
  359. if (evdev->exist && !client->revoked)
  360. input_flush_device(&evdev->handle, file);
  361. evdev_ungrab(evdev, client);
  362. mutex_unlock(&evdev->mutex);
  363. evdev_detach_client(evdev, client);
  364. for (i = 0; i < EV_CNT; ++i)
  365. bitmap_free(client->evmasks[i]);
  366. kvfree(client);
  367. evdev_close_device(evdev);
  368. return 0;
  369. }
  370. static unsigned int evdev_compute_buffer_size(struct input_dev *dev)
  371. {
  372. unsigned int n_events =
  373. max(dev->hint_events_per_packet * EVDEV_BUF_PACKETS,
  374. EVDEV_MIN_BUFFER_SIZE);
  375. return roundup_pow_of_two(n_events);
  376. }
  377. static int evdev_open(struct inode *inode, struct file *file)
  378. {
  379. struct evdev *evdev = container_of(inode->i_cdev, struct evdev, cdev);
  380. unsigned int bufsize = evdev_compute_buffer_size(evdev->handle.dev);
  381. struct evdev_client *client;
  382. int error;
  383. client = kvzalloc(struct_size(client, buffer, bufsize), GFP_KERNEL);
  384. if (!client)
  385. return -ENOMEM;
  386. init_waitqueue_head(&client->wait);
  387. client->bufsize = bufsize;
  388. spin_lock_init(&client->buffer_lock);
  389. client->evdev = evdev;
  390. evdev_attach_client(evdev, client);
  391. error = evdev_open_device(evdev);
  392. if (error)
  393. goto err_free_client;
  394. file->private_data = client;
  395. stream_open(inode, file);
  396. return 0;
  397. err_free_client:
  398. evdev_detach_client(evdev, client);
  399. kvfree(client);
  400. return error;
  401. }
  402. static ssize_t evdev_write(struct file *file, const char __user *buffer,
  403. size_t count, loff_t *ppos)
  404. {
  405. struct evdev_client *client = file->private_data;
  406. struct evdev *evdev = client->evdev;
  407. struct input_event event;
  408. int retval = 0;
  409. if (count != 0 && count < input_event_size())
  410. return -EINVAL;
  411. retval = mutex_lock_interruptible(&evdev->mutex);
  412. if (retval)
  413. return retval;
  414. if (!evdev->exist || client->revoked) {
  415. retval = -ENODEV;
  416. goto out;
  417. }
  418. while (retval + input_event_size() <= count) {
  419. if (input_event_from_user(buffer + retval, &event)) {
  420. retval = -EFAULT;
  421. goto out;
  422. }
  423. retval += input_event_size();
  424. input_inject_event(&evdev->handle,
  425. event.type, event.code, event.value);
  426. cond_resched();
  427. }
  428. out:
  429. mutex_unlock(&evdev->mutex);
  430. return retval;
  431. }
  432. static int evdev_fetch_next_event(struct evdev_client *client,
  433. struct input_event *event)
  434. {
  435. int have_event;
  436. spin_lock_irq(&client->buffer_lock);
  437. have_event = client->packet_head != client->tail;
  438. if (have_event) {
  439. *event = client->buffer[client->tail++];
  440. client->tail &= client->bufsize - 1;
  441. }
  442. spin_unlock_irq(&client->buffer_lock);
  443. return have_event;
  444. }
  445. static ssize_t evdev_read(struct file *file, char __user *buffer,
  446. size_t count, loff_t *ppos)
  447. {
  448. struct evdev_client *client = file->private_data;
  449. struct evdev *evdev = client->evdev;
  450. struct input_event event;
  451. size_t read = 0;
  452. int error;
  453. if (count != 0 && count < input_event_size())
  454. return -EINVAL;
  455. for (;;) {
  456. if (!evdev->exist || client->revoked)
  457. return -ENODEV;
  458. if (client->packet_head == client->tail &&
  459. (file->f_flags & O_NONBLOCK))
  460. return -EAGAIN;
  461. /*
  462. * count == 0 is special - no IO is done but we check
  463. * for error conditions (see above).
  464. */
  465. if (count == 0)
  466. break;
  467. while (read + input_event_size() <= count &&
  468. evdev_fetch_next_event(client, &event)) {
  469. if (input_event_to_user(buffer + read, &event))
  470. return -EFAULT;
  471. read += input_event_size();
  472. }
  473. if (read)
  474. break;
  475. if (!(file->f_flags & O_NONBLOCK)) {
  476. error = wait_event_interruptible(client->wait,
  477. client->packet_head != client->tail ||
  478. !evdev->exist || client->revoked);
  479. if (error)
  480. return error;
  481. }
  482. }
  483. return read;
  484. }
  485. /* No kernel lock - fine */
  486. static __poll_t evdev_poll(struct file *file, poll_table *wait)
  487. {
  488. struct evdev_client *client = file->private_data;
  489. struct evdev *evdev = client->evdev;
  490. __poll_t mask;
  491. poll_wait(file, &client->wait, wait);
  492. if (evdev->exist && !client->revoked)
  493. mask = EPOLLOUT | EPOLLWRNORM;
  494. else
  495. mask = EPOLLHUP | EPOLLERR;
  496. if (client->packet_head != client->tail)
  497. mask |= EPOLLIN | EPOLLRDNORM;
  498. return mask;
  499. }
  500. #ifdef CONFIG_COMPAT
  501. #define BITS_PER_LONG_COMPAT (sizeof(compat_long_t) * 8)
  502. #define BITS_TO_LONGS_COMPAT(x) ((((x) - 1) / BITS_PER_LONG_COMPAT) + 1)
  503. #ifdef __BIG_ENDIAN
  504. static int bits_to_user(unsigned long *bits, unsigned int maxbit,
  505. unsigned int maxlen, void __user *p, int compat)
  506. {
  507. int len, i;
  508. if (compat) {
  509. len = BITS_TO_LONGS_COMPAT(maxbit) * sizeof(compat_long_t);
  510. if (len > maxlen)
  511. len = maxlen;
  512. for (i = 0; i < len / sizeof(compat_long_t); i++)
  513. if (copy_to_user((compat_long_t __user *) p + i,
  514. (compat_long_t *) bits +
  515. i + 1 - ((i % 2) << 1),
  516. sizeof(compat_long_t)))
  517. return -EFAULT;
  518. } else {
  519. len = BITS_TO_LONGS(maxbit) * sizeof(long);
  520. if (len > maxlen)
  521. len = maxlen;
  522. if (copy_to_user(p, bits, len))
  523. return -EFAULT;
  524. }
  525. return len;
  526. }
  527. static int bits_from_user(unsigned long *bits, unsigned int maxbit,
  528. unsigned int maxlen, const void __user *p, int compat)
  529. {
  530. int len, i;
  531. if (compat) {
  532. if (maxlen % sizeof(compat_long_t))
  533. return -EINVAL;
  534. len = BITS_TO_LONGS_COMPAT(maxbit) * sizeof(compat_long_t);
  535. if (len > maxlen)
  536. len = maxlen;
  537. for (i = 0; i < len / sizeof(compat_long_t); i++)
  538. if (copy_from_user((compat_long_t *) bits +
  539. i + 1 - ((i % 2) << 1),
  540. (compat_long_t __user *) p + i,
  541. sizeof(compat_long_t)))
  542. return -EFAULT;
  543. if (i % 2)
  544. *((compat_long_t *) bits + i - 1) = 0;
  545. } else {
  546. if (maxlen % sizeof(long))
  547. return -EINVAL;
  548. len = BITS_TO_LONGS(maxbit) * sizeof(long);
  549. if (len > maxlen)
  550. len = maxlen;
  551. if (copy_from_user(bits, p, len))
  552. return -EFAULT;
  553. }
  554. return len;
  555. }
  556. #else
  557. static int bits_to_user(unsigned long *bits, unsigned int maxbit,
  558. unsigned int maxlen, void __user *p, int compat)
  559. {
  560. int len = compat ?
  561. BITS_TO_LONGS_COMPAT(maxbit) * sizeof(compat_long_t) :
  562. BITS_TO_LONGS(maxbit) * sizeof(long);
  563. if (len > maxlen)
  564. len = maxlen;
  565. return copy_to_user(p, bits, len) ? -EFAULT : len;
  566. }
  567. static int bits_from_user(unsigned long *bits, unsigned int maxbit,
  568. unsigned int maxlen, const void __user *p, int compat)
  569. {
  570. size_t chunk_size = compat ? sizeof(compat_long_t) : sizeof(long);
  571. int len;
  572. if (maxlen % chunk_size)
  573. return -EINVAL;
  574. len = compat ? BITS_TO_LONGS_COMPAT(maxbit) : BITS_TO_LONGS(maxbit);
  575. len *= chunk_size;
  576. if (len > maxlen)
  577. len = maxlen;
  578. return copy_from_user(bits, p, len) ? -EFAULT : len;
  579. }
  580. #endif /* __BIG_ENDIAN */
  581. #else
  582. static int bits_to_user(unsigned long *bits, unsigned int maxbit,
  583. unsigned int maxlen, void __user *p, int compat)
  584. {
  585. int len = BITS_TO_LONGS(maxbit) * sizeof(long);
  586. if (len > maxlen)
  587. len = maxlen;
  588. return copy_to_user(p, bits, len) ? -EFAULT : len;
  589. }
  590. static int bits_from_user(unsigned long *bits, unsigned int maxbit,
  591. unsigned int maxlen, const void __user *p, int compat)
  592. {
  593. int len;
  594. if (maxlen % sizeof(long))
  595. return -EINVAL;
  596. len = BITS_TO_LONGS(maxbit) * sizeof(long);
  597. if (len > maxlen)
  598. len = maxlen;
  599. return copy_from_user(bits, p, len) ? -EFAULT : len;
  600. }
  601. #endif /* CONFIG_COMPAT */
  602. static int str_to_user(const char *str, unsigned int maxlen, void __user *p)
  603. {
  604. int len;
  605. if (!str)
  606. return -ENOENT;
  607. len = strlen(str) + 1;
  608. if (len > maxlen)
  609. len = maxlen;
  610. return copy_to_user(p, str, len) ? -EFAULT : len;
  611. }
  612. static int handle_eviocgbit(struct input_dev *dev,
  613. unsigned int type, unsigned int size,
  614. void __user *p, int compat_mode)
  615. {
  616. unsigned long *bits;
  617. int len;
  618. switch (type) {
  619. case 0: bits = dev->evbit; len = EV_MAX; break;
  620. case EV_KEY: bits = dev->keybit; len = KEY_MAX; break;
  621. case EV_REL: bits = dev->relbit; len = REL_MAX; break;
  622. case EV_ABS: bits = dev->absbit; len = ABS_MAX; break;
  623. case EV_MSC: bits = dev->mscbit; len = MSC_MAX; break;
  624. case EV_LED: bits = dev->ledbit; len = LED_MAX; break;
  625. case EV_SND: bits = dev->sndbit; len = SND_MAX; break;
  626. case EV_FF: bits = dev->ffbit; len = FF_MAX; break;
  627. case EV_SW: bits = dev->swbit; len = SW_MAX; break;
  628. default: return -EINVAL;
  629. }
  630. return bits_to_user(bits, len, size, p, compat_mode);
  631. }
  632. static int evdev_handle_get_keycode(struct input_dev *dev, void __user *p)
  633. {
  634. struct input_keymap_entry ke = {
  635. .len = sizeof(unsigned int),
  636. .flags = 0,
  637. };
  638. int __user *ip = (int __user *)p;
  639. int error;
  640. /* legacy case */
  641. if (copy_from_user(ke.scancode, p, sizeof(unsigned int)))
  642. return -EFAULT;
  643. error = input_get_keycode(dev, &ke);
  644. if (error)
  645. return error;
  646. if (put_user(ke.keycode, ip + 1))
  647. return -EFAULT;
  648. return 0;
  649. }
  650. static int evdev_handle_get_keycode_v2(struct input_dev *dev, void __user *p)
  651. {
  652. struct input_keymap_entry ke;
  653. int error;
  654. if (copy_from_user(&ke, p, sizeof(ke)))
  655. return -EFAULT;
  656. error = input_get_keycode(dev, &ke);
  657. if (error)
  658. return error;
  659. if (copy_to_user(p, &ke, sizeof(ke)))
  660. return -EFAULT;
  661. return 0;
  662. }
  663. static int evdev_handle_set_keycode(struct input_dev *dev, void __user *p)
  664. {
  665. struct input_keymap_entry ke = {
  666. .len = sizeof(unsigned int),
  667. .flags = 0,
  668. };
  669. int __user *ip = (int __user *)p;
  670. if (copy_from_user(ke.scancode, p, sizeof(unsigned int)))
  671. return -EFAULT;
  672. if (get_user(ke.keycode, ip + 1))
  673. return -EFAULT;
  674. return input_set_keycode(dev, &ke);
  675. }
  676. static int evdev_handle_set_keycode_v2(struct input_dev *dev, void __user *p)
  677. {
  678. struct input_keymap_entry ke;
  679. if (copy_from_user(&ke, p, sizeof(ke)))
  680. return -EFAULT;
  681. if (ke.len > sizeof(ke.scancode))
  682. return -EINVAL;
  683. return input_set_keycode(dev, &ke);
  684. }
  685. /*
  686. * If we transfer state to the user, we should flush all pending events
  687. * of the same type from the client's queue. Otherwise, they might end up
  688. * with duplicate events, which can screw up client's state tracking.
  689. * If bits_to_user fails after flushing the queue, we queue a SYN_DROPPED
  690. * event so user-space will notice missing events.
  691. *
  692. * LOCKING:
  693. * We need to take event_lock before buffer_lock to avoid dead-locks. But we
  694. * need the even_lock only to guarantee consistent state. We can safely release
  695. * it while flushing the queue. This allows input-core to handle filters while
  696. * we flush the queue.
  697. */
  698. static int evdev_handle_get_val(struct evdev_client *client,
  699. struct input_dev *dev, unsigned int type,
  700. unsigned long *bits, unsigned int maxbit,
  701. unsigned int maxlen, void __user *p,
  702. int compat)
  703. {
  704. int ret;
  705. unsigned long *mem;
  706. mem = bitmap_alloc(maxbit, GFP_KERNEL);
  707. if (!mem)
  708. return -ENOMEM;
  709. spin_lock_irq(&dev->event_lock);
  710. spin_lock(&client->buffer_lock);
  711. bitmap_copy(mem, bits, maxbit);
  712. spin_unlock(&dev->event_lock);
  713. __evdev_flush_queue(client, type);
  714. spin_unlock_irq(&client->buffer_lock);
  715. ret = bits_to_user(mem, maxbit, maxlen, p, compat);
  716. if (ret < 0)
  717. evdev_queue_syn_dropped(client);
  718. bitmap_free(mem);
  719. return ret;
  720. }
  721. static int evdev_handle_mt_request(struct input_dev *dev,
  722. unsigned int size,
  723. int __user *ip)
  724. {
  725. const struct input_mt *mt = dev->mt;
  726. unsigned int code;
  727. int max_slots;
  728. int i;
  729. if (get_user(code, &ip[0]))
  730. return -EFAULT;
  731. if (!mt || !input_is_mt_value(code))
  732. return -EINVAL;
  733. max_slots = (size - sizeof(__u32)) / sizeof(__s32);
  734. for (i = 0; i < mt->num_slots && i < max_slots; i++) {
  735. int value = input_mt_get_value(&mt->slots[i], code);
  736. if (put_user(value, &ip[1 + i]))
  737. return -EFAULT;
  738. }
  739. return 0;
  740. }
  741. static int evdev_revoke(struct evdev *evdev, struct evdev_client *client,
  742. struct file *file)
  743. {
  744. client->revoked = true;
  745. evdev_ungrab(evdev, client);
  746. input_flush_device(&evdev->handle, file);
  747. wake_up_interruptible_poll(&client->wait, EPOLLHUP | EPOLLERR);
  748. return 0;
  749. }
  750. /* must be called with evdev-mutex held */
  751. static int evdev_set_mask(struct evdev_client *client,
  752. unsigned int type,
  753. const void __user *codes,
  754. u32 codes_size,
  755. int compat)
  756. {
  757. unsigned long flags, *mask, *oldmask;
  758. size_t cnt;
  759. int error;
  760. /* we allow unknown types and 'codes_size > size' for forward-compat */
  761. cnt = evdev_get_mask_cnt(type);
  762. if (!cnt)
  763. return 0;
  764. mask = bitmap_zalloc(cnt, GFP_KERNEL);
  765. if (!mask)
  766. return -ENOMEM;
  767. error = bits_from_user(mask, cnt - 1, codes_size, codes, compat);
  768. if (error < 0) {
  769. bitmap_free(mask);
  770. return error;
  771. }
  772. spin_lock_irqsave(&client->buffer_lock, flags);
  773. oldmask = client->evmasks[type];
  774. client->evmasks[type] = mask;
  775. spin_unlock_irqrestore(&client->buffer_lock, flags);
  776. bitmap_free(oldmask);
  777. return 0;
  778. }
  779. /* must be called with evdev-mutex held */
  780. static int evdev_get_mask(struct evdev_client *client,
  781. unsigned int type,
  782. void __user *codes,
  783. u32 codes_size,
  784. int compat)
  785. {
  786. unsigned long *mask;
  787. size_t cnt, size, xfer_size;
  788. int i;
  789. int error;
  790. /* we allow unknown types and 'codes_size > size' for forward-compat */
  791. cnt = evdev_get_mask_cnt(type);
  792. size = sizeof(unsigned long) * BITS_TO_LONGS(cnt);
  793. xfer_size = min_t(size_t, codes_size, size);
  794. if (cnt > 0) {
  795. mask = client->evmasks[type];
  796. if (mask) {
  797. error = bits_to_user(mask, cnt - 1,
  798. xfer_size, codes, compat);
  799. if (error < 0)
  800. return error;
  801. } else {
  802. /* fake mask with all bits set */
  803. for (i = 0; i < xfer_size; i++)
  804. if (put_user(0xffU, (u8 __user *)codes + i))
  805. return -EFAULT;
  806. }
  807. }
  808. if (xfer_size < codes_size)
  809. if (clear_user(codes + xfer_size, codes_size - xfer_size))
  810. return -EFAULT;
  811. return 0;
  812. }
  813. static long evdev_do_ioctl(struct file *file, unsigned int cmd,
  814. void __user *p, int compat_mode)
  815. {
  816. struct evdev_client *client = file->private_data;
  817. struct evdev *evdev = client->evdev;
  818. struct input_dev *dev = evdev->handle.dev;
  819. struct input_absinfo abs;
  820. struct input_mask mask;
  821. struct ff_effect effect;
  822. int __user *ip = (int __user *)p;
  823. unsigned int i, t, u, v;
  824. unsigned int size;
  825. int error;
  826. /* First we check for fixed-length commands */
  827. switch (cmd) {
  828. case EVIOCGVERSION:
  829. return put_user(EV_VERSION, ip);
  830. case EVIOCGID:
  831. if (copy_to_user(p, &dev->id, sizeof(struct input_id)))
  832. return -EFAULT;
  833. return 0;
  834. case EVIOCGREP:
  835. if (!test_bit(EV_REP, dev->evbit))
  836. return -ENOSYS;
  837. if (put_user(dev->rep[REP_DELAY], ip))
  838. return -EFAULT;
  839. if (put_user(dev->rep[REP_PERIOD], ip + 1))
  840. return -EFAULT;
  841. return 0;
  842. case EVIOCSREP:
  843. if (!test_bit(EV_REP, dev->evbit))
  844. return -ENOSYS;
  845. if (get_user(u, ip))
  846. return -EFAULT;
  847. if (get_user(v, ip + 1))
  848. return -EFAULT;
  849. input_inject_event(&evdev->handle, EV_REP, REP_DELAY, u);
  850. input_inject_event(&evdev->handle, EV_REP, REP_PERIOD, v);
  851. return 0;
  852. case EVIOCRMFF:
  853. return input_ff_erase(dev, (int)(unsigned long) p, file);
  854. case EVIOCGEFFECTS:
  855. i = test_bit(EV_FF, dev->evbit) ?
  856. dev->ff->max_effects : 0;
  857. if (put_user(i, ip))
  858. return -EFAULT;
  859. return 0;
  860. case EVIOCGRAB:
  861. if (p)
  862. return evdev_grab(evdev, client);
  863. else
  864. return evdev_ungrab(evdev, client);
  865. case EVIOCREVOKE:
  866. if (p)
  867. return -EINVAL;
  868. else
  869. return evdev_revoke(evdev, client, file);
  870. case EVIOCGMASK: {
  871. void __user *codes_ptr;
  872. if (copy_from_user(&mask, p, sizeof(mask)))
  873. return -EFAULT;
  874. codes_ptr = (void __user *)(unsigned long)mask.codes_ptr;
  875. return evdev_get_mask(client,
  876. mask.type, codes_ptr, mask.codes_size,
  877. compat_mode);
  878. }
  879. case EVIOCSMASK: {
  880. const void __user *codes_ptr;
  881. if (copy_from_user(&mask, p, sizeof(mask)))
  882. return -EFAULT;
  883. codes_ptr = (const void __user *)(unsigned long)mask.codes_ptr;
  884. return evdev_set_mask(client,
  885. mask.type, codes_ptr, mask.codes_size,
  886. compat_mode);
  887. }
  888. case EVIOCSCLOCKID:
  889. if (copy_from_user(&i, p, sizeof(unsigned int)))
  890. return -EFAULT;
  891. return evdev_set_clk_type(client, i);
  892. case EVIOCGKEYCODE:
  893. return evdev_handle_get_keycode(dev, p);
  894. case EVIOCSKEYCODE:
  895. return evdev_handle_set_keycode(dev, p);
  896. case EVIOCGKEYCODE_V2:
  897. return evdev_handle_get_keycode_v2(dev, p);
  898. case EVIOCSKEYCODE_V2:
  899. return evdev_handle_set_keycode_v2(dev, p);
  900. }
  901. size = _IOC_SIZE(cmd);
  902. /* Now check variable-length commands */
  903. #define EVIOC_MASK_SIZE(nr) ((nr) & ~(_IOC_SIZEMASK << _IOC_SIZESHIFT))
  904. switch (EVIOC_MASK_SIZE(cmd)) {
  905. case EVIOCGPROP(0):
  906. return bits_to_user(dev->propbit, INPUT_PROP_MAX,
  907. size, p, compat_mode);
  908. case EVIOCGMTSLOTS(0):
  909. return evdev_handle_mt_request(dev, size, ip);
  910. case EVIOCGKEY(0):
  911. return evdev_handle_get_val(client, dev, EV_KEY, dev->key,
  912. KEY_MAX, size, p, compat_mode);
  913. case EVIOCGLED(0):
  914. return evdev_handle_get_val(client, dev, EV_LED, dev->led,
  915. LED_MAX, size, p, compat_mode);
  916. case EVIOCGSND(0):
  917. return evdev_handle_get_val(client, dev, EV_SND, dev->snd,
  918. SND_MAX, size, p, compat_mode);
  919. case EVIOCGSW(0):
  920. return evdev_handle_get_val(client, dev, EV_SW, dev->sw,
  921. SW_MAX, size, p, compat_mode);
  922. case EVIOCGNAME(0):
  923. return str_to_user(dev->name, size, p);
  924. case EVIOCGPHYS(0):
  925. return str_to_user(dev->phys, size, p);
  926. case EVIOCGUNIQ(0):
  927. return str_to_user(dev->uniq, size, p);
  928. case EVIOC_MASK_SIZE(EVIOCSFF):
  929. if (input_ff_effect_from_user(p, size, &effect))
  930. return -EFAULT;
  931. error = input_ff_upload(dev, &effect, file);
  932. if (error)
  933. return error;
  934. if (put_user(effect.id, &(((struct ff_effect __user *)p)->id)))
  935. return -EFAULT;
  936. return 0;
  937. }
  938. /* Multi-number variable-length handlers */
  939. if (_IOC_TYPE(cmd) != 'E')
  940. return -EINVAL;
  941. if (_IOC_DIR(cmd) == _IOC_READ) {
  942. if ((_IOC_NR(cmd) & ~EV_MAX) == _IOC_NR(EVIOCGBIT(0, 0)))
  943. return handle_eviocgbit(dev,
  944. _IOC_NR(cmd) & EV_MAX, size,
  945. p, compat_mode);
  946. if ((_IOC_NR(cmd) & ~ABS_MAX) == _IOC_NR(EVIOCGABS(0))) {
  947. if (!dev->absinfo)
  948. return -EINVAL;
  949. t = _IOC_NR(cmd) & ABS_MAX;
  950. abs = dev->absinfo[t];
  951. if (copy_to_user(p, &abs, min_t(size_t,
  952. size, sizeof(struct input_absinfo))))
  953. return -EFAULT;
  954. return 0;
  955. }
  956. }
  957. if (_IOC_DIR(cmd) == _IOC_WRITE) {
  958. if ((_IOC_NR(cmd) & ~ABS_MAX) == _IOC_NR(EVIOCSABS(0))) {
  959. if (!dev->absinfo)
  960. return -EINVAL;
  961. t = _IOC_NR(cmd) & ABS_MAX;
  962. if (copy_from_user(&abs, p, min_t(size_t,
  963. size, sizeof(struct input_absinfo))))
  964. return -EFAULT;
  965. if (size < sizeof(struct input_absinfo))
  966. abs.resolution = 0;
  967. /* We can't change number of reserved MT slots */
  968. if (t == ABS_MT_SLOT)
  969. return -EINVAL;
  970. /*
  971. * Take event lock to ensure that we are not
  972. * changing device parameters in the middle
  973. * of event.
  974. */
  975. spin_lock_irq(&dev->event_lock);
  976. dev->absinfo[t] = abs;
  977. spin_unlock_irq(&dev->event_lock);
  978. return 0;
  979. }
  980. }
  981. return -EINVAL;
  982. }
  983. static long evdev_ioctl_handler(struct file *file, unsigned int cmd,
  984. void __user *p, int compat_mode)
  985. {
  986. struct evdev_client *client = file->private_data;
  987. struct evdev *evdev = client->evdev;
  988. int retval;
  989. retval = mutex_lock_interruptible(&evdev->mutex);
  990. if (retval)
  991. return retval;
  992. if (!evdev->exist || client->revoked) {
  993. retval = -ENODEV;
  994. goto out;
  995. }
  996. retval = evdev_do_ioctl(file, cmd, p, compat_mode);
  997. out:
  998. mutex_unlock(&evdev->mutex);
  999. return retval;
  1000. }
  1001. static long evdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
  1002. {
  1003. return evdev_ioctl_handler(file, cmd, (void __user *)arg, 0);
  1004. }
  1005. #ifdef CONFIG_COMPAT
  1006. static long evdev_ioctl_compat(struct file *file,
  1007. unsigned int cmd, unsigned long arg)
  1008. {
  1009. return evdev_ioctl_handler(file, cmd, compat_ptr(arg), 1);
  1010. }
  1011. #endif
  1012. static const struct file_operations evdev_fops = {
  1013. .owner = THIS_MODULE,
  1014. .read = evdev_read,
  1015. .write = evdev_write,
  1016. .poll = evdev_poll,
  1017. .open = evdev_open,
  1018. .release = evdev_release,
  1019. .unlocked_ioctl = evdev_ioctl,
  1020. #ifdef CONFIG_COMPAT
  1021. .compat_ioctl = evdev_ioctl_compat,
  1022. #endif
  1023. .fasync = evdev_fasync,
  1024. .llseek = no_llseek,
  1025. };
  1026. /*
  1027. * Mark device non-existent. This disables writes, ioctls and
  1028. * prevents new users from opening the device. Already posted
  1029. * blocking reads will stay, however new ones will fail.
  1030. */
  1031. static void evdev_mark_dead(struct evdev *evdev)
  1032. {
  1033. mutex_lock(&evdev->mutex);
  1034. evdev->exist = false;
  1035. mutex_unlock(&evdev->mutex);
  1036. }
  1037. static void evdev_cleanup(struct evdev *evdev)
  1038. {
  1039. struct input_handle *handle = &evdev->handle;
  1040. evdev_mark_dead(evdev);
  1041. evdev_hangup(evdev);
  1042. /* evdev is marked dead so no one else accesses evdev->open */
  1043. if (evdev->open) {
  1044. input_flush_device(handle, NULL);
  1045. input_close_device(handle);
  1046. }
  1047. }
  1048. /*
  1049. * Create new evdev device. Note that input core serializes calls
  1050. * to connect and disconnect.
  1051. */
  1052. static int evdev_connect(struct input_handler *handler, struct input_dev *dev,
  1053. const struct input_device_id *id)
  1054. {
  1055. struct evdev *evdev;
  1056. int minor;
  1057. int dev_no;
  1058. int error;
  1059. minor = input_get_new_minor(EVDEV_MINOR_BASE, EVDEV_MINORS, true);
  1060. if (minor < 0) {
  1061. error = minor;
  1062. pr_err("failed to reserve new minor: %d\n", error);
  1063. return error;
  1064. }
  1065. evdev = kzalloc(sizeof(struct evdev), GFP_KERNEL);
  1066. if (!evdev) {
  1067. error = -ENOMEM;
  1068. goto err_free_minor;
  1069. }
  1070. INIT_LIST_HEAD(&evdev->client_list);
  1071. spin_lock_init(&evdev->client_lock);
  1072. mutex_init(&evdev->mutex);
  1073. evdev->exist = true;
  1074. dev_no = minor;
  1075. /* Normalize device number if it falls into legacy range */
  1076. if (dev_no < EVDEV_MINOR_BASE + EVDEV_MINORS)
  1077. dev_no -= EVDEV_MINOR_BASE;
  1078. dev_set_name(&evdev->dev, "event%d", dev_no);
  1079. evdev->handle.dev = input_get_device(dev);
  1080. evdev->handle.name = dev_name(&evdev->dev);
  1081. evdev->handle.handler = handler;
  1082. evdev->handle.private = evdev;
  1083. evdev->dev.devt = MKDEV(INPUT_MAJOR, minor);
  1084. evdev->dev.class = &input_class;
  1085. evdev->dev.parent = &dev->dev;
  1086. evdev->dev.release = evdev_free;
  1087. device_initialize(&evdev->dev);
  1088. error = input_register_handle(&evdev->handle);
  1089. if (error)
  1090. goto err_free_evdev;
  1091. cdev_init(&evdev->cdev, &evdev_fops);
  1092. error = cdev_device_add(&evdev->cdev, &evdev->dev);
  1093. if (error)
  1094. goto err_cleanup_evdev;
  1095. return 0;
  1096. err_cleanup_evdev:
  1097. evdev_cleanup(evdev);
  1098. input_unregister_handle(&evdev->handle);
  1099. err_free_evdev:
  1100. put_device(&evdev->dev);
  1101. err_free_minor:
  1102. input_free_minor(minor);
  1103. return error;
  1104. }
  1105. static void evdev_disconnect(struct input_handle *handle)
  1106. {
  1107. struct evdev *evdev = handle->private;
  1108. cdev_device_del(&evdev->cdev, &evdev->dev);
  1109. evdev_cleanup(evdev);
  1110. input_free_minor(MINOR(evdev->dev.devt));
  1111. input_unregister_handle(handle);
  1112. put_device(&evdev->dev);
  1113. }
  1114. static const struct input_device_id evdev_ids[] = {
  1115. { .driver_info = 1 }, /* Matches all devices */
  1116. { }, /* Terminating zero entry */
  1117. };
  1118. MODULE_DEVICE_TABLE(input, evdev_ids);
  1119. static struct input_handler evdev_handler = {
  1120. .event = evdev_event,
  1121. .events = evdev_events,
  1122. .connect = evdev_connect,
  1123. .disconnect = evdev_disconnect,
  1124. .legacy_minors = true,
  1125. .minor = EVDEV_MINOR_BASE,
  1126. .name = "evdev",
  1127. .id_table = evdev_ids,
  1128. };
  1129. static int __init evdev_init(void)
  1130. {
  1131. return input_register_handler(&evdev_handler);
  1132. }
  1133. static void __exit evdev_exit(void)
  1134. {
  1135. input_unregister_handler(&evdev_handler);
  1136. }
  1137. module_init(evdev_init);
  1138. module_exit(evdev_exit);
  1139. MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
  1140. MODULE_DESCRIPTION("Input driver event char devices");
  1141. MODULE_LICENSE("GPL");