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