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