Input: struct device - replace bus_id with dev_name(), dev_set_name()
[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_fasync(-1, file, 0);
248         joydev_detach_client(joydev, client);
249         kfree(client);
250
251         joydev_close_device(joydev);
252         put_device(&joydev->dev);
253
254         return 0;
255 }
256
257 static int joydev_open(struct inode *inode, struct file *file)
258 {
259         struct joydev_client *client;
260         struct joydev *joydev;
261         int i = iminor(inode) - JOYDEV_MINOR_BASE;
262         int error;
263
264         if (i >= JOYDEV_MINORS)
265                 return -ENODEV;
266
267         error = mutex_lock_interruptible(&joydev_table_mutex);
268         if (error)
269                 return error;
270         joydev = joydev_table[i];
271         if (joydev)
272                 get_device(&joydev->dev);
273         mutex_unlock(&joydev_table_mutex);
274
275         if (!joydev)
276                 return -ENODEV;
277
278         client = kzalloc(sizeof(struct joydev_client), GFP_KERNEL);
279         if (!client) {
280                 error = -ENOMEM;
281                 goto err_put_joydev;
282         }
283
284         spin_lock_init(&client->buffer_lock);
285         client->joydev = joydev;
286         joydev_attach_client(joydev, client);
287
288         error = joydev_open_device(joydev);
289         if (error)
290                 goto err_free_client;
291
292         file->private_data = client;
293         return 0;
294
295  err_free_client:
296         joydev_detach_client(joydev, client);
297         kfree(client);
298  err_put_joydev:
299         put_device(&joydev->dev);
300         return error;
301 }
302
303 static int joydev_generate_startup_event(struct joydev_client *client,
304                                          struct input_dev *input,
305                                          struct js_event *event)
306 {
307         struct joydev *joydev = client->joydev;
308         int have_event;
309
310         spin_lock_irq(&client->buffer_lock);
311
312         have_event = client->startup < joydev->nabs + joydev->nkey;
313
314         if (have_event) {
315
316                 event->time = jiffies_to_msecs(jiffies);
317                 if (client->startup < joydev->nkey) {
318                         event->type = JS_EVENT_BUTTON | JS_EVENT_INIT;
319                         event->number = client->startup;
320                         event->value = !!test_bit(joydev->keypam[event->number],
321                                                   input->key);
322                 } else {
323                         event->type = JS_EVENT_AXIS | JS_EVENT_INIT;
324                         event->number = client->startup - joydev->nkey;
325                         event->value = joydev->abs[event->number];
326                 }
327                 client->startup++;
328         }
329
330         spin_unlock_irq(&client->buffer_lock);
331
332         return have_event;
333 }
334
335 static int joydev_fetch_next_event(struct joydev_client *client,
336                                    struct js_event *event)
337 {
338         int have_event;
339
340         spin_lock_irq(&client->buffer_lock);
341
342         have_event = client->head != client->tail;
343         if (have_event) {
344                 *event = client->buffer[client->tail++];
345                 client->tail &= JOYDEV_BUFFER_SIZE - 1;
346         }
347
348         spin_unlock_irq(&client->buffer_lock);
349
350         return have_event;
351 }
352
353 /*
354  * Old joystick interface
355  */
356 static ssize_t joydev_0x_read(struct joydev_client *client,
357                               struct input_dev *input,
358                               char __user *buf)
359 {
360         struct joydev *joydev = client->joydev;
361         struct JS_DATA_TYPE data;
362         int i;
363
364         spin_lock_irq(&input->event_lock);
365
366         /*
367          * Get device state
368          */
369         for (data.buttons = i = 0; i < 32 && i < joydev->nkey; i++)
370                 data.buttons |=
371                         test_bit(joydev->keypam[i], input->key) ? (1 << i) : 0;
372         data.x = (joydev->abs[0] / 256 + 128) >> joydev->glue.JS_CORR.x;
373         data.y = (joydev->abs[1] / 256 + 128) >> joydev->glue.JS_CORR.y;
374
375         /*
376          * Reset reader's event queue
377          */
378         spin_lock(&client->buffer_lock);
379         client->startup = 0;
380         client->tail = client->head;
381         spin_unlock(&client->buffer_lock);
382
383         spin_unlock_irq(&input->event_lock);
384
385         if (copy_to_user(buf, &data, sizeof(struct JS_DATA_TYPE)))
386                 return -EFAULT;
387
388         return sizeof(struct JS_DATA_TYPE);
389 }
390
391 static inline int joydev_data_pending(struct joydev_client *client)
392 {
393         struct joydev *joydev = client->joydev;
394
395         return client->startup < joydev->nabs + joydev->nkey ||
396                 client->head != client->tail;
397 }
398
399 static ssize_t joydev_read(struct file *file, char __user *buf,
400                            size_t count, loff_t *ppos)
401 {
402         struct joydev_client *client = file->private_data;
403         struct joydev *joydev = client->joydev;
404         struct input_dev *input = joydev->handle.dev;
405         struct js_event event;
406         int retval;
407
408         if (!joydev->exist)
409                 return -ENODEV;
410
411         if (count < sizeof(struct js_event))
412                 return -EINVAL;
413
414         if (count == sizeof(struct JS_DATA_TYPE))
415                 return joydev_0x_read(client, input, buf);
416
417         if (!joydev_data_pending(client) && (file->f_flags & O_NONBLOCK))
418                 return -EAGAIN;
419
420         retval = wait_event_interruptible(joydev->wait,
421                         !joydev->exist || joydev_data_pending(client));
422         if (retval)
423                 return retval;
424
425         if (!joydev->exist)
426                 return -ENODEV;
427
428         while (retval + sizeof(struct js_event) <= count &&
429                joydev_generate_startup_event(client, input, &event)) {
430
431                 if (copy_to_user(buf + retval, &event, sizeof(struct js_event)))
432                         return -EFAULT;
433
434                 retval += sizeof(struct js_event);
435         }
436
437         while (retval + sizeof(struct js_event) <= count &&
438                joydev_fetch_next_event(client, &event)) {
439
440                 if (copy_to_user(buf + retval, &event, sizeof(struct js_event)))
441                         return -EFAULT;
442
443                 retval += sizeof(struct js_event);
444         }
445
446         return retval;
447 }
448
449 /* No kernel lock - fine */
450 static unsigned int joydev_poll(struct file *file, poll_table *wait)
451 {
452         struct joydev_client *client = file->private_data;
453         struct joydev *joydev = client->joydev;
454
455         poll_wait(file, &joydev->wait, wait);
456         return (joydev_data_pending(client) ? (POLLIN | POLLRDNORM) : 0) |
457                 (joydev->exist ?  0 : (POLLHUP | POLLERR));
458 }
459
460 static int joydev_ioctl_common(struct joydev *joydev,
461                                 unsigned int cmd, void __user *argp)
462 {
463         struct input_dev *dev = joydev->handle.dev;
464         int i, j;
465
466         switch (cmd) {
467
468         case JS_SET_CAL:
469                 return copy_from_user(&joydev->glue.JS_CORR, argp,
470                                 sizeof(joydev->glue.JS_CORR)) ? -EFAULT : 0;
471
472         case JS_GET_CAL:
473                 return copy_to_user(argp, &joydev->glue.JS_CORR,
474                                 sizeof(joydev->glue.JS_CORR)) ? -EFAULT : 0;
475
476         case JS_SET_TIMEOUT:
477                 return get_user(joydev->glue.JS_TIMEOUT, (s32 __user *) argp);
478
479         case JS_GET_TIMEOUT:
480                 return put_user(joydev->glue.JS_TIMEOUT, (s32 __user *) argp);
481
482         case JSIOCGVERSION:
483                 return put_user(JS_VERSION, (__u32 __user *) argp);
484
485         case JSIOCGAXES:
486                 return put_user(joydev->nabs, (__u8 __user *) argp);
487
488         case JSIOCGBUTTONS:
489                 return put_user(joydev->nkey, (__u8 __user *) argp);
490
491         case JSIOCSCORR:
492                 if (copy_from_user(joydev->corr, argp,
493                               sizeof(joydev->corr[0]) * joydev->nabs))
494                     return -EFAULT;
495
496                 for (i = 0; i < joydev->nabs; i++) {
497                         j = joydev->abspam[i];
498                         joydev->abs[i] = joydev_correct(dev->abs[j],
499                                                         &joydev->corr[i]);
500                 }
501                 return 0;
502
503         case JSIOCGCORR:
504                 return copy_to_user(argp, joydev->corr,
505                         sizeof(joydev->corr[0]) * joydev->nabs) ? -EFAULT : 0;
506
507         case JSIOCSAXMAP:
508                 if (copy_from_user(joydev->abspam, argp,
509                                    sizeof(__u8) * (ABS_MAX + 1)))
510                         return -EFAULT;
511
512                 for (i = 0; i < joydev->nabs; i++) {
513                         if (joydev->abspam[i] > ABS_MAX)
514                                 return -EINVAL;
515                         joydev->absmap[joydev->abspam[i]] = i;
516                 }
517                 return 0;
518
519         case JSIOCGAXMAP:
520                 return copy_to_user(argp, joydev->abspam,
521                         sizeof(__u8) * (ABS_MAX + 1)) ? -EFAULT : 0;
522
523         case JSIOCSBTNMAP:
524                 if (copy_from_user(joydev->keypam, argp,
525                                    sizeof(__u16) * (KEY_MAX - BTN_MISC + 1)))
526                         return -EFAULT;
527
528                 for (i = 0; i < joydev->nkey; i++) {
529                         if (joydev->keypam[i] > KEY_MAX ||
530                             joydev->keypam[i] < BTN_MISC)
531                                 return -EINVAL;
532                         joydev->keymap[joydev->keypam[i] - BTN_MISC] = i;
533                 }
534
535                 return 0;
536
537         case JSIOCGBTNMAP:
538                 return copy_to_user(argp, joydev->keypam,
539                         sizeof(__u16) * (KEY_MAX - BTN_MISC + 1)) ? -EFAULT : 0;
540
541         default:
542                 if ((cmd & ~IOCSIZE_MASK) == JSIOCGNAME(0)) {
543                         int len;
544                         if (!dev->name)
545                                 return 0;
546                         len = strlen(dev->name) + 1;
547                         if (len > _IOC_SIZE(cmd))
548                                 len = _IOC_SIZE(cmd);
549                         if (copy_to_user(argp, dev->name, len))
550                                 return -EFAULT;
551                         return len;
552                 }
553         }
554         return -EINVAL;
555 }
556
557 #ifdef CONFIG_COMPAT
558 static long joydev_compat_ioctl(struct file *file,
559                                 unsigned int cmd, unsigned long arg)
560 {
561         struct joydev_client *client = file->private_data;
562         struct joydev *joydev = client->joydev;
563         void __user *argp = (void __user *)arg;
564         s32 tmp32;
565         struct JS_DATA_SAVE_TYPE_32 ds32;
566         int retval;
567
568         retval = mutex_lock_interruptible(&joydev->mutex);
569         if (retval)
570                 return retval;
571
572         if (!joydev->exist) {
573                 retval = -ENODEV;
574                 goto out;
575         }
576
577         switch (cmd) {
578
579         case JS_SET_TIMELIMIT:
580                 retval = get_user(tmp32, (s32 __user *) arg);
581                 if (retval == 0)
582                         joydev->glue.JS_TIMELIMIT = tmp32;
583                 break;
584
585         case JS_GET_TIMELIMIT:
586                 tmp32 = joydev->glue.JS_TIMELIMIT;
587                 retval = put_user(tmp32, (s32 __user *) arg);
588                 break;
589
590         case JS_SET_ALL:
591                 retval = copy_from_user(&ds32, argp,
592                                         sizeof(ds32)) ? -EFAULT : 0;
593                 if (retval == 0) {
594                         joydev->glue.JS_TIMEOUT    = ds32.JS_TIMEOUT;
595                         joydev->glue.BUSY          = ds32.BUSY;
596                         joydev->glue.JS_EXPIRETIME = ds32.JS_EXPIRETIME;
597                         joydev->glue.JS_TIMELIMIT  = ds32.JS_TIMELIMIT;
598                         joydev->glue.JS_SAVE       = ds32.JS_SAVE;
599                         joydev->glue.JS_CORR       = ds32.JS_CORR;
600                 }
601                 break;
602
603         case JS_GET_ALL:
604                 ds32.JS_TIMEOUT    = joydev->glue.JS_TIMEOUT;
605                 ds32.BUSY          = joydev->glue.BUSY;
606                 ds32.JS_EXPIRETIME = joydev->glue.JS_EXPIRETIME;
607                 ds32.JS_TIMELIMIT  = joydev->glue.JS_TIMELIMIT;
608                 ds32.JS_SAVE       = joydev->glue.JS_SAVE;
609                 ds32.JS_CORR       = joydev->glue.JS_CORR;
610
611                 retval = copy_to_user(argp, &ds32, sizeof(ds32)) ? -EFAULT : 0;
612                 break;
613
614         default:
615                 retval = joydev_ioctl_common(joydev, cmd, argp);
616                 break;
617         }
618
619  out:
620         mutex_unlock(&joydev->mutex);
621         return retval;
622 }
623 #endif /* CONFIG_COMPAT */
624
625 static long joydev_ioctl(struct file *file,
626                          unsigned int cmd, unsigned long arg)
627 {
628         struct joydev_client *client = file->private_data;
629         struct joydev *joydev = client->joydev;
630         void __user *argp = (void __user *)arg;
631         int retval;
632
633         retval = mutex_lock_interruptible(&joydev->mutex);
634         if (retval)
635                 return retval;
636
637         if (!joydev->exist) {
638                 retval = -ENODEV;
639                 goto out;
640         }
641
642         switch (cmd) {
643
644         case JS_SET_TIMELIMIT:
645                 retval = get_user(joydev->glue.JS_TIMELIMIT,
646                                   (long __user *) arg);
647                 break;
648
649         case JS_GET_TIMELIMIT:
650                 retval = put_user(joydev->glue.JS_TIMELIMIT,
651                                   (long __user *) arg);
652                 break;
653
654         case JS_SET_ALL:
655                 retval = copy_from_user(&joydev->glue, argp,
656                                         sizeof(joydev->glue)) ? -EFAULT: 0;
657                 break;
658
659         case JS_GET_ALL:
660                 retval = copy_to_user(argp, &joydev->glue,
661                                       sizeof(joydev->glue)) ? -EFAULT : 0;
662                 break;
663
664         default:
665                 retval = joydev_ioctl_common(joydev, cmd, argp);
666                 break;
667         }
668  out:
669         mutex_unlock(&joydev->mutex);
670         return retval;
671 }
672
673 static const struct file_operations joydev_fops = {
674         .owner          = THIS_MODULE,
675         .read           = joydev_read,
676         .poll           = joydev_poll,
677         .open           = joydev_open,
678         .release        = joydev_release,
679         .unlocked_ioctl = joydev_ioctl,
680 #ifdef CONFIG_COMPAT
681         .compat_ioctl   = joydev_compat_ioctl,
682 #endif
683         .fasync         = joydev_fasync,
684 };
685
686 static int joydev_install_chrdev(struct joydev *joydev)
687 {
688         joydev_table[joydev->minor] = joydev;
689         return 0;
690 }
691
692 static void joydev_remove_chrdev(struct joydev *joydev)
693 {
694         mutex_lock(&joydev_table_mutex);
695         joydev_table[joydev->minor] = NULL;
696         mutex_unlock(&joydev_table_mutex);
697 }
698
699 /*
700  * Mark device non-existant. This disables writes, ioctls and
701  * prevents new users from opening the device. Already posted
702  * blocking reads will stay, however new ones will fail.
703  */
704 static void joydev_mark_dead(struct joydev *joydev)
705 {
706         mutex_lock(&joydev->mutex);
707         joydev->exist = 0;
708         mutex_unlock(&joydev->mutex);
709 }
710
711 static void joydev_cleanup(struct joydev *joydev)
712 {
713         struct input_handle *handle = &joydev->handle;
714
715         joydev_mark_dead(joydev);
716         joydev_hangup(joydev);
717         joydev_remove_chrdev(joydev);
718
719         /* joydev is marked dead so noone else accesses joydev->open */
720         if (joydev->open)
721                 input_close_device(handle);
722 }
723
724 static int joydev_connect(struct input_handler *handler, struct input_dev *dev,
725                           const struct input_device_id *id)
726 {
727         struct joydev *joydev;
728         int i, j, t, minor;
729         int error;
730
731         for (minor = 0; minor < JOYDEV_MINORS; minor++)
732                 if (!joydev_table[minor])
733                         break;
734
735         if (minor == JOYDEV_MINORS) {
736                 printk(KERN_ERR "joydev: no more free joydev devices\n");
737                 return -ENFILE;
738         }
739
740         joydev = kzalloc(sizeof(struct joydev), GFP_KERNEL);
741         if (!joydev)
742                 return -ENOMEM;
743
744         INIT_LIST_HEAD(&joydev->client_list);
745         spin_lock_init(&joydev->client_lock);
746         mutex_init(&joydev->mutex);
747         init_waitqueue_head(&joydev->wait);
748
749         snprintf(joydev->name, sizeof(joydev->name), "js%d", minor);
750         joydev->exist = 1;
751         joydev->minor = minor;
752
753         joydev->exist = 1;
754         joydev->handle.dev = input_get_device(dev);
755         joydev->handle.name = joydev->name;
756         joydev->handle.handler = handler;
757         joydev->handle.private = joydev;
758
759         for (i = 0; i < ABS_MAX + 1; i++)
760                 if (test_bit(i, dev->absbit)) {
761                         joydev->absmap[i] = joydev->nabs;
762                         joydev->abspam[joydev->nabs] = i;
763                         joydev->nabs++;
764                 }
765
766         for (i = BTN_JOYSTICK - BTN_MISC; i < KEY_MAX - BTN_MISC + 1; i++)
767                 if (test_bit(i + BTN_MISC, dev->keybit)) {
768                         joydev->keymap[i] = joydev->nkey;
769                         joydev->keypam[joydev->nkey] = i + BTN_MISC;
770                         joydev->nkey++;
771                 }
772
773         for (i = 0; i < BTN_JOYSTICK - BTN_MISC; i++)
774                 if (test_bit(i + BTN_MISC, dev->keybit)) {
775                         joydev->keymap[i] = joydev->nkey;
776                         joydev->keypam[joydev->nkey] = i + BTN_MISC;
777                         joydev->nkey++;
778                 }
779
780         for (i = 0; i < joydev->nabs; i++) {
781                 j = joydev->abspam[i];
782                 if (dev->absmax[j] == dev->absmin[j]) {
783                         joydev->corr[i].type = JS_CORR_NONE;
784                         joydev->abs[i] = dev->abs[j];
785                         continue;
786                 }
787                 joydev->corr[i].type = JS_CORR_BROKEN;
788                 joydev->corr[i].prec = dev->absfuzz[j];
789                 joydev->corr[i].coef[0] =
790                         (dev->absmax[j] + dev->absmin[j]) / 2 - dev->absflat[j];
791                 joydev->corr[i].coef[1] =
792                         (dev->absmax[j] + dev->absmin[j]) / 2 + dev->absflat[j];
793
794                 t = (dev->absmax[j] - dev->absmin[j]) / 2 - 2 * dev->absflat[j];
795                 if (t) {
796                         joydev->corr[i].coef[2] = (1 << 29) / t;
797                         joydev->corr[i].coef[3] = (1 << 29) / t;
798
799                         joydev->abs[i] = joydev_correct(dev->abs[j],
800                                                         joydev->corr + i);
801                 }
802         }
803
804         dev_set_name(&joydev->dev, joydev->name);
805         joydev->dev.devt = MKDEV(INPUT_MAJOR, JOYDEV_MINOR_BASE + minor);
806         joydev->dev.class = &input_class;
807         joydev->dev.parent = &dev->dev;
808         joydev->dev.release = joydev_free;
809         device_initialize(&joydev->dev);
810
811         error = input_register_handle(&joydev->handle);
812         if (error)
813                 goto err_free_joydev;
814
815         error = joydev_install_chrdev(joydev);
816         if (error)
817                 goto err_unregister_handle;
818
819         error = device_add(&joydev->dev);
820         if (error)
821                 goto err_cleanup_joydev;
822
823         return 0;
824
825  err_cleanup_joydev:
826         joydev_cleanup(joydev);
827  err_unregister_handle:
828         input_unregister_handle(&joydev->handle);
829  err_free_joydev:
830         put_device(&joydev->dev);
831         return error;
832 }
833
834 static void joydev_disconnect(struct input_handle *handle)
835 {
836         struct joydev *joydev = handle->private;
837
838         device_del(&joydev->dev);
839         joydev_cleanup(joydev);
840         input_unregister_handle(handle);
841         put_device(&joydev->dev);
842 }
843
844 static const struct input_device_id joydev_blacklist[] = {
845         {
846                 .flags = INPUT_DEVICE_ID_MATCH_EVBIT |
847                                 INPUT_DEVICE_ID_MATCH_KEYBIT,
848                 .evbit = { BIT_MASK(EV_KEY) },
849                 .keybit = { [BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH) },
850         },      /* Avoid itouchpads, touchscreens and tablets */
851         { }     /* Terminating entry */
852 };
853
854 static const struct input_device_id joydev_ids[] = {
855         {
856                 .flags = INPUT_DEVICE_ID_MATCH_EVBIT |
857                                 INPUT_DEVICE_ID_MATCH_ABSBIT,
858                 .evbit = { BIT_MASK(EV_ABS) },
859                 .absbit = { BIT_MASK(ABS_X) },
860         },
861         {
862                 .flags = INPUT_DEVICE_ID_MATCH_EVBIT |
863                                 INPUT_DEVICE_ID_MATCH_ABSBIT,
864                 .evbit = { BIT_MASK(EV_ABS) },
865                 .absbit = { BIT_MASK(ABS_WHEEL) },
866         },
867         {
868                 .flags = INPUT_DEVICE_ID_MATCH_EVBIT |
869                                 INPUT_DEVICE_ID_MATCH_ABSBIT,
870                 .evbit = { BIT_MASK(EV_ABS) },
871                 .absbit = { BIT_MASK(ABS_THROTTLE) },
872         },
873         { }     /* Terminating entry */
874 };
875
876 MODULE_DEVICE_TABLE(input, joydev_ids);
877
878 static struct input_handler joydev_handler = {
879         .event          = joydev_event,
880         .connect        = joydev_connect,
881         .disconnect     = joydev_disconnect,
882         .fops           = &joydev_fops,
883         .minor          = JOYDEV_MINOR_BASE,
884         .name           = "joydev",
885         .id_table       = joydev_ids,
886         .blacklist      = joydev_blacklist,
887 };
888
889 static int __init joydev_init(void)
890 {
891         return input_register_handler(&joydev_handler);
892 }
893
894 static void __exit joydev_exit(void)
895 {
896         input_unregister_handler(&joydev_handler);
897 }
898
899 module_init(joydev_init);
900 module_exit(joydev_exit);