projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
fix mali API_VERSION grep
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / input / joydev.c
1 /*
2 * Joystick device driver for the input driver suite.
3 *
4 * Copyright (c) 1999-2002 Vojtech Pavlik
5 * Copyright (c) 1999 Colin Van Dyke
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 */
12
13 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
14
15 #include <asm/io.h>
16 #include <linux/delay.h>
17 #include <linux/errno.h>
18 #include <linux/joystick.h>
19 #include <linux/input.h>
20 #include <linux/kernel.h>
21 #include <linux/major.h>
22 #include <linux/sched.h>
23 #include <linux/slab.h>
24 #include <linux/mm.h>
25 #include <linux/miscdevice.h>
26 #include <linux/module.h>
27 #include <linux/poll.h>
28 #include <linux/init.h>
29 #include <linux/device.h>
30 #include <linux/cdev.h>
31
32 MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
33 MODULE_DESCRIPTION("Joystick device interfaces");
34 MODULE_SUPPORTED_DEVICE("input/js");
35 MODULE_LICENSE("GPL");
36
37 #define JOYDEV_MINOR_BASE 0
38 #define JOYDEV_MINORS 16
39 #define JOYDEV_BUFFER_SIZE 64
40
41 struct joydev {
42 int open;
43 struct input_handle handle;
44 wait_queue_head_t wait;
45 struct list_head client_list;
46 spinlock_t client_lock; /* protects client_list */
47 struct mutex mutex;
48 struct device dev;
49 struct cdev cdev;
50 bool exist;
51
52 struct js_corr corr[ABS_CNT];
53 struct JS_DATA_SAVE_TYPE glue;
54 int nabs;
55 int nkey;
56 __u16 keymap[KEY_MAX - BTN_MISC + 1];
57 __u16 keypam[KEY_MAX - BTN_MISC + 1];
58 __u8 absmap[ABS_CNT];
59 __u8 abspam[ABS_CNT];
60 __s16 abs[ABS_CNT];
61 };
62
63 struct joydev_client {
64 struct js_event buffer[JOYDEV_BUFFER_SIZE];
65 int head;
66 int tail;
67 int startup;
68 spinlock_t buffer_lock; /* protects access to buffer, head and tail */
69 struct fasync_struct *fasync;
70 struct joydev *joydev;
71 struct list_head node;
72 };
73
74 static int joydev_correct(int value, struct js_corr *corr)
75 {
76 switch (corr->type) {
77
78 case JS_CORR_NONE:
79 break;
80
81 case JS_CORR_BROKEN:
82 value = value > corr->coef[0] ? (value < corr->coef[1] ? 0 :
83 ((corr->coef[3] * (value - corr->coef[1])) >> 14)) :
84 ((corr->coef[2] * (value - corr->coef[0])) >> 14);
85 break;
86
87 default:
88 return 0;
89 }
90
91 return value < -32767 ? -32767 : (value > 32767 ? 32767 : value);
92 }
93
94 static void joydev_pass_event(struct joydev_client *client,
95 struct js_event *event)
96 {
97 struct joydev *joydev = client->joydev;
98
99 /*
100 * IRQs already disabled, just acquire the lock
101 */
102 spin_lock(&client->buffer_lock);
103
104 client->buffer[client->head] = *event;
105
106 if (client->startup == joydev->nabs + joydev->nkey) {
107 client->head++;
108 client->head &= JOYDEV_BUFFER_SIZE - 1;
109 if (client->tail == client->head)
110 client->startup = 0;
111 }
112
113 spin_unlock(&client->buffer_lock);
114
115 kill_fasync(&client->fasync, SIGIO, POLL_IN);
116 }
117
118 static void joydev_event(struct input_handle *handle,
119 unsigned int type, unsigned int code, int value)
120 {
121 struct joydev *joydev = handle->private;
122 struct joydev_client *client;
123 struct js_event event;
124
125 switch (type) {
126
127 case EV_KEY:
128 if (code < BTN_MISC || value == 2)
129 return;
130 event.type = JS_EVENT_BUTTON;
131 event.number = joydev->keymap[code - BTN_MISC];
132 event.value = value;
133 break;
134
135 case EV_ABS:
136 event.type = JS_EVENT_AXIS;
137 event.number = joydev->absmap[code];
138 event.value = joydev_correct(value,
139 &joydev->corr[event.number]);
140 if (event.value == joydev->abs[event.number])
141 return;
142 joydev->abs[event.number] = event.value;
143 break;
144
145 default:
146 return;
147 }
148
149 event.time = jiffies_to_msecs(jiffies);
150
151 rcu_read_lock();
152 list_for_each_entry_rcu(client, &joydev->client_list, node)
153 joydev_pass_event(client, &event);
154 rcu_read_unlock();
155
156 wake_up_interruptible(&joydev->wait);
157 }
158
159 static int joydev_fasync(int fd, struct file *file, int on)
160 {
161 struct joydev_client *client = file->private_data;
162
163 return fasync_helper(fd, file, on, &client->fasync);
164 }
165
166 static void joydev_free(struct device *dev)
167 {
168 struct joydev *joydev = container_of(dev, struct joydev, dev);
169
170 input_put_device(joydev->handle.dev);
171 kfree(joydev);
172 }
173
174 static void joydev_attach_client(struct joydev *joydev,
175 struct joydev_client *client)
176 {
177 spin_lock(&joydev->client_lock);
178 list_add_tail_rcu(&client->node, &joydev->client_list);
179 spin_unlock(&joydev->client_lock);
180 }
181
182 static void joydev_detach_client(struct joydev *joydev,
183 struct joydev_client *client)
184 {
185 spin_lock(&joydev->client_lock);
186 list_del_rcu(&client->node);
187 spin_unlock(&joydev->client_lock);
188 synchronize_rcu();
189 }
190
191 static void joydev_refresh_state(struct joydev *joydev)
192 {
193 struct input_dev *dev = joydev->handle.dev;
194 int i, val;
195
196 for (i = 0; i < joydev->nabs; i++) {
197 val = input_abs_get_val(dev, joydev->abspam[i]);
198 joydev->abs[i] = joydev_correct(val, &joydev->corr[i]);
199 }
200 }
201
202 static int joydev_open_device(struct joydev *joydev)
203 {
204 int retval;
205
206 retval = mutex_lock_interruptible(&joydev->mutex);
207 if (retval)
208 return retval;
209
210 if (!joydev->exist)
211 retval = -ENODEV;
212 else if (!joydev->open++) {
213 retval = input_open_device(&joydev->handle);
214 if (retval)
215 joydev->open--;
216 else
217 joydev_refresh_state(joydev);
218 }
219
220 mutex_unlock(&joydev->mutex);
221 return retval;
222 }
223
224 static void joydev_close_device(struct joydev *joydev)
225 {
226 mutex_lock(&joydev->mutex);
227
228 if (joydev->exist && !--joydev->open)
229 input_close_device(&joydev->handle);
230
231 mutex_unlock(&joydev->mutex);
232 }
233
234 /*
235 * Wake up users waiting for IO so they can disconnect from
236 * dead device.
237 */
238 static void joydev_hangup(struct joydev *joydev)
239 {
240 struct joydev_client *client;
241
242 spin_lock(&joydev->client_lock);
243 list_for_each_entry(client, &joydev->client_list, node)
244 kill_fasync(&client->fasync, SIGIO, POLL_HUP);
245 spin_unlock(&joydev->client_lock);
246
247 wake_up_interruptible(&joydev->wait);
248 }
249
250 static int joydev_release(struct inode *inode, struct file *file)
251 {
252 struct joydev_client *client = file->private_data;
253 struct joydev *joydev = client->joydev;
254
255 joydev_detach_client(joydev, client);
256 kfree(client);
257
258 joydev_close_device(joydev);
259
260 return 0;
261 }
262
263 static int joydev_open(struct inode *inode, struct file *file)
264 {
265 struct joydev *joydev =
266 container_of(inode->i_cdev, struct joydev, cdev);
267 struct joydev_client *client;
268 int error;
269
270 client = kzalloc(sizeof(struct joydev_client), GFP_KERNEL);
271 if (!client)
272 return -ENOMEM;
273
274 spin_lock_init(&client->buffer_lock);
275 client->joydev = joydev;
276 joydev_attach_client(joydev, client);
277
278 error = joydev_open_device(joydev);
279 if (error)
280 goto err_free_client;
281
282 file->private_data = client;
283 nonseekable_open(inode, file);
284
285 return 0;
286
287 err_free_client:
288 joydev_detach_client(joydev, client);
289 kfree(client);
290 return error;
291 }
292
293 static int joydev_generate_startup_event(struct joydev_client *client,
294 struct input_dev *input,
295 struct js_event *event)
296 {
297 struct joydev *joydev = client->joydev;
298 int have_event;
299
300 spin_lock_irq(&client->buffer_lock);
301
302 have_event = client->startup < joydev->nabs + joydev->nkey;
303
304 if (have_event) {
305
306 event->time = jiffies_to_msecs(jiffies);
307 if (client->startup < joydev->nkey) {
308 event->type = JS_EVENT_BUTTON | JS_EVENT_INIT;
309 event->number = client->startup;
310 event->value = !!test_bit(joydev->keypam[event->number],
311 input->key);
312 } else {
313 event->type = JS_EVENT_AXIS | JS_EVENT_INIT;
314 event->number = client->startup - joydev->nkey;
315 event->value = joydev->abs[event->number];
316 }
317 client->startup++;
318 }
319
320 spin_unlock_irq(&client->buffer_lock);
321
322 return have_event;
323 }
324
325 static int joydev_fetch_next_event(struct joydev_client *client,
326 struct js_event *event)
327 {
328 int have_event;
329
330 spin_lock_irq(&client->buffer_lock);
331
332 have_event = client->head != client->tail;
333 if (have_event) {
334 *event = client->buffer[client->tail++];
335 client->tail &= JOYDEV_BUFFER_SIZE - 1;
336 }
337
338 spin_unlock_irq(&client->buffer_lock);
339
340 return have_event;
341 }
342
343 /*
344 * Old joystick interface
345 */
346 static ssize_t joydev_0x_read(struct joydev_client *client,
347 struct input_dev *input,
348 char __user *buf)
349 {
350 struct joydev *joydev = client->joydev;
351 struct JS_DATA_TYPE data;
352 int i;
353
354 spin_lock_irq(&input->event_lock);
355
356 /*
357 * Get device state
358 */
359 for (data.buttons = i = 0; i < 32 && i < joydev->nkey; i++)
360 data.buttons |=
361 test_bit(joydev->keypam[i], input->key) ? (1 << i) : 0;
362 data.x = (joydev->abs[0] / 256 + 128) >> joydev->glue.JS_CORR.x;
363 data.y = (joydev->abs[1] / 256 + 128) >> joydev->glue.JS_CORR.y;
364
365 /*
366 * Reset reader's event queue
367 */
368 spin_lock(&client->buffer_lock);
369 client->startup = 0;
370 client->tail = client->head;
371 spin_unlock(&client->buffer_lock);
372
373 spin_unlock_irq(&input->event_lock);
374
375 if (copy_to_user(buf, &data, sizeof(struct JS_DATA_TYPE)))
376 return -EFAULT;
377
378 return sizeof(struct JS_DATA_TYPE);
379 }
380
381 static inline int joydev_data_pending(struct joydev_client *client)
382 {
383 struct joydev *joydev = client->joydev;
384
385 return client->startup < joydev->nabs + joydev->nkey ||
386 client->head != client->tail;
387 }
388
389 static ssize_t joydev_read(struct file *file, char __user *buf,
390 size_t count, loff_t *ppos)
391 {
392 struct joydev_client *client = file->private_data;
393 struct joydev *joydev = client->joydev;
394 struct input_dev *input = joydev->handle.dev;
395 struct js_event event;
396 int retval;
397
398 if (!joydev->exist)
399 return -ENODEV;
400
401 if (count < sizeof(struct js_event))
402 return -EINVAL;
403
404 if (count == sizeof(struct JS_DATA_TYPE))
405 return joydev_0x_read(client, input, buf);
406
407 if (!joydev_data_pending(client) && (file->f_flags & O_NONBLOCK))
408 return -EAGAIN;
409
410 retval = wait_event_interruptible(joydev->wait,
411 !joydev->exist || joydev_data_pending(client));
412 if (retval)
413 return retval;
414
415 if (!joydev->exist)
416 return -ENODEV;
417
418 while (retval + sizeof(struct js_event) <= count &&
419 joydev_generate_startup_event(client, input, &event)) {
420
421 if (copy_to_user(buf + retval, &event, sizeof(struct js_event)))
422 return -EFAULT;
423
424 retval += sizeof(struct js_event);
425 }
426
427 while (retval + sizeof(struct js_event) <= count &&
428 joydev_fetch_next_event(client, &event)) {
429
430 if (copy_to_user(buf + retval, &event, sizeof(struct js_event)))
431 return -EFAULT;
432
433 retval += sizeof(struct js_event);
434 }
435
436 return retval;
437 }
438
439 /* No kernel lock - fine */
440 static unsigned int joydev_poll(struct file *file, poll_table *wait)
441 {
442 struct joydev_client *client = file->private_data;
443 struct joydev *joydev = client->joydev;
444
445 poll_wait(file, &joydev->wait, wait);
446 return (joydev_data_pending(client) ? (POLLIN | POLLRDNORM) : 0) |
447 (joydev->exist ? 0 : (POLLHUP | POLLERR));
448 }
449
450 static int joydev_handle_JSIOCSAXMAP(struct joydev *joydev,
451 void __user *argp, size_t len)
452 {
453 __u8 *abspam;
454 int i;
455 int retval = 0;
456
457 len = min(len, sizeof(joydev->abspam));
458
459 /* Validate the map. */
460 abspam = kmalloc(len, GFP_KERNEL);
461 if (!abspam)
462 return -ENOMEM;
463
464 if (copy_from_user(abspam, argp, len)) {
465 retval = -EFAULT;
466 goto out;
467 }
468
469 for (i = 0; i < joydev->nabs; i++) {
470 if (abspam[i] > ABS_MAX) {
471 retval = -EINVAL;
472 goto out;
473 }
474 }
475
476 memcpy(joydev->abspam, abspam, len);
477
478 for (i = 0; i < joydev->nabs; i++)
479 joydev->absmap[joydev->abspam[i]] = i;
480
481 out:
482 kfree(abspam);
483 return retval;
484 }
485
486 static int joydev_handle_JSIOCSBTNMAP(struct joydev *joydev,
487 void __user *argp, size_t len)
488 {
489 __u16 *keypam;
490 int i;
491 int retval = 0;
492
493 len = min(len, sizeof(joydev->keypam));
494
495 /* Validate the map. */
496 keypam = kmalloc(len, GFP_KERNEL);
497 if (!keypam)
498 return -ENOMEM;
499
500 if (copy_from_user(keypam, argp, len)) {
501 retval = -EFAULT;
502 goto out;
503 }
504
505 for (i = 0; i < joydev->nkey; i++) {
506 if (keypam[i] > KEY_MAX || keypam[i] < BTN_MISC) {
507 retval = -EINVAL;
508 goto out;
509 }
510 }
511
512 memcpy(joydev->keypam, keypam, len);
513
514 for (i = 0; i < joydev->nkey; i++)
515 joydev->keymap[keypam[i] - BTN_MISC] = i;
516
517 out:
518 kfree(keypam);
519 return retval;
520 }
521
522
523 static int joydev_ioctl_common(struct joydev *joydev,
524 unsigned int cmd, void __user *argp)
525 {
526 struct input_dev *dev = joydev->handle.dev;
527 size_t len;
528 int i;
529 const char *name;
530
531 /* Process fixed-sized commands. */
532 switch (cmd) {
533
534 case JS_SET_CAL:
535 return copy_from_user(&joydev->glue.JS_CORR, argp,
536 sizeof(joydev->glue.JS_CORR)) ? -EFAULT : 0;
537
538 case JS_GET_CAL:
539 return copy_to_user(argp, &joydev->glue.JS_CORR,
540 sizeof(joydev->glue.JS_CORR)) ? -EFAULT : 0;
541
542 case JS_SET_TIMEOUT:
543 return get_user(joydev->glue.JS_TIMEOUT, (s32 __user *) argp);
544
545 case JS_GET_TIMEOUT:
546 return put_user(joydev->glue.JS_TIMEOUT, (s32 __user *) argp);
547
548 case JSIOCGVERSION:
549 return put_user(JS_VERSION, (__u32 __user *) argp);
550
551 case JSIOCGAXES:
552 return put_user(joydev->nabs, (__u8 __user *) argp);
553
554 case JSIOCGBUTTONS:
555 return put_user(joydev->nkey, (__u8 __user *) argp);
556
557 case JSIOCSCORR:
558 if (copy_from_user(joydev->corr, argp,
559 sizeof(joydev->corr[0]) * joydev->nabs))
560 return -EFAULT;
561
562 for (i = 0; i < joydev->nabs; i++) {
563 int val = input_abs_get_val(dev, joydev->abspam[i]);
564 joydev->abs[i] = joydev_correct(val, &joydev->corr[i]);
565 }
566 return 0;
567
568 case JSIOCGCORR:
569 return copy_to_user(argp, joydev->corr,
570 sizeof(joydev->corr[0]) * joydev->nabs) ? -EFAULT : 0;
571
572 }
573
574 /*
575 * Process variable-sized commands (the axis and button map commands
576 * are considered variable-sized to decouple them from the values of
577 * ABS_MAX and KEY_MAX).
578 */
579 switch (cmd & ~IOCSIZE_MASK) {
580
581 case (JSIOCSAXMAP & ~IOCSIZE_MASK):
582 return joydev_handle_JSIOCSAXMAP(joydev, argp, _IOC_SIZE(cmd));
583
584 case (JSIOCGAXMAP & ~IOCSIZE_MASK):
585 len = min_t(size_t, _IOC_SIZE(cmd), sizeof(joydev->abspam));
586 return copy_to_user(argp, joydev->abspam, len) ? -EFAULT : len;
587
588 case (JSIOCSBTNMAP & ~IOCSIZE_MASK):
589 return joydev_handle_JSIOCSBTNMAP(joydev, argp, _IOC_SIZE(cmd));
590
591 case (JSIOCGBTNMAP & ~IOCSIZE_MASK):
592 len = min_t(size_t, _IOC_SIZE(cmd), sizeof(joydev->keypam));
593 return copy_to_user(argp, joydev->keypam, len) ? -EFAULT : len;
594
595 case JSIOCGNAME(0):
596 name = dev->name;
597 if (!name)
598 return 0;
599
600 len = min_t(size_t, _IOC_SIZE(cmd), strlen(name) + 1);
601 return copy_to_user(argp, name, len) ? -EFAULT : len;
602 }
603
604 return -EINVAL;
605 }
606
607 #ifdef CONFIG_COMPAT
608 static long joydev_compat_ioctl(struct file *file,
609 unsigned int cmd, unsigned long arg)
610 {
611 struct joydev_client *client = file->private_data;
612 struct joydev *joydev = client->joydev;
613 void __user *argp = (void __user *)arg;
614 s32 tmp32;
615 struct JS_DATA_SAVE_TYPE_32 ds32;
616 int retval;
617
618 retval = mutex_lock_interruptible(&joydev->mutex);
619 if (retval)
620 return retval;
621
622 if (!joydev->exist) {
623 retval = -ENODEV;
624 goto out;
625 }
626
627 switch (cmd) {
628
629 case JS_SET_TIMELIMIT:
630 retval = get_user(tmp32, (s32 __user *) arg);
631 if (retval == 0)
632 joydev->glue.JS_TIMELIMIT = tmp32;
633 break;
634
635 case JS_GET_TIMELIMIT:
636 tmp32 = joydev->glue.JS_TIMELIMIT;
637 retval = put_user(tmp32, (s32 __user *) arg);
638 break;
639
640 case JS_SET_ALL:
641 retval = copy_from_user(&ds32, argp,
642 sizeof(ds32)) ? -EFAULT : 0;
643 if (retval == 0) {
644 joydev->glue.JS_TIMEOUT = ds32.JS_TIMEOUT;
645 joydev->glue.BUSY = ds32.BUSY;
646 joydev->glue.JS_EXPIRETIME = ds32.JS_EXPIRETIME;
647 joydev->glue.JS_TIMELIMIT = ds32.JS_TIMELIMIT;
648 joydev->glue.JS_SAVE = ds32.JS_SAVE;
649 joydev->glue.JS_CORR = ds32.JS_CORR;
650 }
651 break;
652
653 case JS_GET_ALL:
654 ds32.JS_TIMEOUT = joydev->glue.JS_TIMEOUT;
655 ds32.BUSY = joydev->glue.BUSY;
656 ds32.JS_EXPIRETIME = joydev->glue.JS_EXPIRETIME;
657 ds32.JS_TIMELIMIT = joydev->glue.JS_TIMELIMIT;
658 ds32.JS_SAVE = joydev->glue.JS_SAVE;
659 ds32.JS_CORR = joydev->glue.JS_CORR;
660
661 retval = copy_to_user(argp, &ds32, sizeof(ds32)) ? -EFAULT : 0;
662 break;
663
664 default:
665 retval = joydev_ioctl_common(joydev, cmd, argp);
666 break;
667 }
668
669 out:
670 mutex_unlock(&joydev->mutex);
671 return retval;
672 }
673 #endif /* CONFIG_COMPAT */
674
675 static long joydev_ioctl(struct file *file,
676 unsigned int cmd, unsigned long arg)
677 {
678 struct joydev_client *client = file->private_data;
679 struct joydev *joydev = client->joydev;
680 void __user *argp = (void __user *)arg;
681 int retval;
682
683 retval = mutex_lock_interruptible(&joydev->mutex);
684 if (retval)
685 return retval;
686
687 if (!joydev->exist) {
688 retval = -ENODEV;
689 goto out;
690 }
691
692 switch (cmd) {
693
694 case JS_SET_TIMELIMIT:
695 retval = get_user(joydev->glue.JS_TIMELIMIT,
696 (long __user *) arg);
697 break;
698
699 case JS_GET_TIMELIMIT:
700 retval = put_user(joydev->glue.JS_TIMELIMIT,
701 (long __user *) arg);
702 break;
703
704 case JS_SET_ALL:
705 retval = copy_from_user(&joydev->glue, argp,
706 sizeof(joydev->glue)) ? -EFAULT : 0;
707 break;
708
709 case JS_GET_ALL:
710 retval = copy_to_user(argp, &joydev->glue,
711 sizeof(joydev->glue)) ? -EFAULT : 0;
712 break;
713
714 default:
715 retval = joydev_ioctl_common(joydev, cmd, argp);
716 break;
717 }
718 out:
719 mutex_unlock(&joydev->mutex);
720 return retval;
721 }
722
723 static const struct file_operations joydev_fops = {
724 .owner = THIS_MODULE,
725 .read = joydev_read,
726 .poll = joydev_poll,
727 .open = joydev_open,
728 .release = joydev_release,
729 .unlocked_ioctl = joydev_ioctl,
730 #ifdef CONFIG_COMPAT
731 .compat_ioctl = joydev_compat_ioctl,
732 #endif
733 .fasync = joydev_fasync,
734 .llseek = no_llseek,
735 };
736
737 /*
738 * Mark device non-existent. This disables writes, ioctls and
739 * prevents new users from opening the device. Already posted
740 * blocking reads will stay, however new ones will fail.
741 */
742 static void joydev_mark_dead(struct joydev *joydev)
743 {
744 mutex_lock(&joydev->mutex);
745 joydev->exist = false;
746 mutex_unlock(&joydev->mutex);
747 }
748
749 static void joydev_cleanup(struct joydev *joydev)
750 {
751 struct input_handle *handle = &joydev->handle;
752
753 joydev_mark_dead(joydev);
754 joydev_hangup(joydev);
755
756 cdev_del(&joydev->cdev);
757
758 /* joydev is marked dead so no one else accesses joydev->open */
759 if (joydev->open)
760 input_close_device(handle);
761 }
762
763
764 static bool joydev_match(struct input_handler *handler, struct input_dev *dev)
765 {
766 /* Avoid touchpads and touchscreens */
767 if (test_bit(EV_KEY, dev->evbit) && test_bit(BTN_TOUCH, dev->keybit))
768 return false;
769
770 /* Avoid tablets, digitisers and similar devices */
771 if (test_bit(EV_KEY, dev->evbit) && test_bit(BTN_DIGI, dev->keybit))
772 return false;
773
774 return true;
775 }
776
777 static int joydev_connect(struct input_handler *handler, struct input_dev *dev,
778 const struct input_device_id *id)
779 {
780 struct joydev *joydev;
781 int i, j, t, minor, dev_no;
782 int error;
783
784 minor = input_get_new_minor(JOYDEV_MINOR_BASE, JOYDEV_MINORS, true);
785 if (minor < 0) {
786 error = minor;
787 pr_err("failed to reserve new minor: %d\n", error);
788 return error;
789 }
790
791 joydev = kzalloc(sizeof(struct joydev), GFP_KERNEL);
792 if (!joydev) {
793 error = -ENOMEM;
794 goto err_free_minor;
795 }
796
797 INIT_LIST_HEAD(&joydev->client_list);
798 spin_lock_init(&joydev->client_lock);
799 mutex_init(&joydev->mutex);
800 init_waitqueue_head(&joydev->wait);
801 joydev->exist = true;
802
803 dev_no = minor;
804 /* Normalize device number if it falls into legacy range */
805 if (dev_no < JOYDEV_MINOR_BASE + JOYDEV_MINORS)
806 dev_no -= JOYDEV_MINOR_BASE;
807 dev_set_name(&joydev->dev, "js%d", dev_no);
808
809 joydev->handle.dev = input_get_device(dev);
810 joydev->handle.name = dev_name(&joydev->dev);
811 joydev->handle.handler = handler;
812 joydev->handle.private = joydev;
813
814 for (i = 0; i < ABS_CNT; i++)
815 if (test_bit(i, dev->absbit)) {
816 joydev->absmap[i] = joydev->nabs;
817 joydev->abspam[joydev->nabs] = i;
818 joydev->nabs++;
819 }
820
821 for (i = BTN_JOYSTICK - BTN_MISC; i < KEY_MAX - BTN_MISC + 1; i++)
822 if (test_bit(i + BTN_MISC, dev->keybit)) {
823 joydev->keymap[i] = joydev->nkey;
824 joydev->keypam[joydev->nkey] = i + BTN_MISC;
825 joydev->nkey++;
826 }
827
828 for (i = 0; i < BTN_JOYSTICK - BTN_MISC; i++)
829 if (test_bit(i + BTN_MISC, dev->keybit)) {
830 joydev->keymap[i] = joydev->nkey;
831 joydev->keypam[joydev->nkey] = i + BTN_MISC;
832 joydev->nkey++;
833 }
834
835 for (i = 0; i < joydev->nabs; i++) {
836 j = joydev->abspam[i];
837 if (input_abs_get_max(dev, j) == input_abs_get_min(dev, j)) {
838 joydev->corr[i].type = JS_CORR_NONE;
839 continue;
840 }
841 joydev->corr[i].type = JS_CORR_BROKEN;
842 joydev->corr[i].prec = input_abs_get_fuzz(dev, j);
843
844 t = (input_abs_get_max(dev, j) + input_abs_get_min(dev, j)) / 2;
845 joydev->corr[i].coef[0] = t - input_abs_get_flat(dev, j);
846 joydev->corr[i].coef[1] = t + input_abs_get_flat(dev, j);
847
848 t = (input_abs_get_max(dev, j) - input_abs_get_min(dev, j)) / 2
849 - 2 * input_abs_get_flat(dev, j);
850 if (t) {
851 joydev->corr[i].coef[2] = (1 << 29) / t;
852 joydev->corr[i].coef[3] = (1 << 29) / t;
853 }
854 }
855
856 joydev->dev.devt = MKDEV(INPUT_MAJOR, minor);
857 joydev->dev.class = &input_class;
858 joydev->dev.parent = &dev->dev;
859 joydev->dev.release = joydev_free;
860 device_initialize(&joydev->dev);
861
862 error = input_register_handle(&joydev->handle);
863 if (error)
864 goto err_free_joydev;
865
866 cdev_init(&joydev->cdev, &joydev_fops);
867 joydev->cdev.kobj.parent = &joydev->dev.kobj;
868 error = cdev_add(&joydev->cdev, joydev->dev.devt, 1);
869 if (error)
870 goto err_unregister_handle;
871
872 error = device_add(&joydev->dev);
873 if (error)
874 goto err_cleanup_joydev;
875
876 return 0;
877
878 err_cleanup_joydev:
879 joydev_cleanup(joydev);
880 err_unregister_handle:
881 input_unregister_handle(&joydev->handle);
882 err_free_joydev:
883 put_device(&joydev->dev);
884 err_free_minor:
885 input_free_minor(minor);
886 return error;
887 }
888
889 static void joydev_disconnect(struct input_handle *handle)
890 {
891 struct joydev *joydev = handle->private;
892
893 device_del(&joydev->dev);
894 joydev_cleanup(joydev);
895 input_free_minor(MINOR(joydev->dev.devt));
896 input_unregister_handle(handle);
897 put_device(&joydev->dev);
898 }
899
900 static const struct input_device_id joydev_ids[] = {
901 {
902 .flags = INPUT_DEVICE_ID_MATCH_EVBIT |
903 INPUT_DEVICE_ID_MATCH_ABSBIT,
904 .evbit = { BIT_MASK(EV_ABS) },
905 .absbit = { BIT_MASK(ABS_X) },
906 },
907 {
908 .flags = INPUT_DEVICE_ID_MATCH_EVBIT |
909 INPUT_DEVICE_ID_MATCH_ABSBIT,
910 .evbit = { BIT_MASK(EV_ABS) },
911 .absbit = { BIT_MASK(ABS_WHEEL) },
912 },
913 {
914 .flags = INPUT_DEVICE_ID_MATCH_EVBIT |
915 INPUT_DEVICE_ID_MATCH_ABSBIT,
916 .evbit = { BIT_MASK(EV_ABS) },
917 .absbit = { BIT_MASK(ABS_THROTTLE) },
918 },
919 {
920 .flags = INPUT_DEVICE_ID_MATCH_EVBIT |
921 INPUT_DEVICE_ID_MATCH_KEYBIT,
922 .evbit = { BIT_MASK(EV_KEY) },
923 .keybit = {[BIT_WORD(BTN_JOYSTICK)] = BIT_MASK(BTN_JOYSTICK) },
924 },
925 {
926 .flags = INPUT_DEVICE_ID_MATCH_EVBIT |
927 INPUT_DEVICE_ID_MATCH_KEYBIT,
928 .evbit = { BIT_MASK(EV_KEY) },
929 .keybit = { [BIT_WORD(BTN_GAMEPAD)] = BIT_MASK(BTN_GAMEPAD) },
930 },
931 {
932 .flags = INPUT_DEVICE_ID_MATCH_EVBIT |
933 INPUT_DEVICE_ID_MATCH_KEYBIT,
934 .evbit = { BIT_MASK(EV_KEY) },
935 .keybit = { [BIT_WORD(BTN_TRIGGER_HAPPY)] = BIT_MASK(BTN_TRIGGER_HAPPY) },
936 },
937 { } /* Terminating entry */
938 };
939
940 MODULE_DEVICE_TABLE(input, joydev_ids);
941
942 static struct input_handler joydev_handler = {
943 .event = joydev_event,
944 .match = joydev_match,
945 .connect = joydev_connect,
946 .disconnect = joydev_disconnect,
947 .legacy_minors = true,
948 .minor = JOYDEV_MINOR_BASE,
949 .name = "joydev",
950 .id_table = joydev_ids,
951 };
952
953 static int __init joydev_init(void)
954 {
955 return input_register_handler(&joydev_handler);
956 }
957
958 static void __exit joydev_exit(void)
959 {
960 input_unregister_handler(&joydev_handler);
961 }
962
963 module_init(joydev_init);
964 module_exit(joydev_exit);
kernel source for telekom puls (alcatel/mediatek)