llseek: automatically add .llseek fop
[linux-2.6.git] / drivers / input / mousedev.c
1 /*
2  * Input driver to ExplorerPS/2 device driver module.
3  *
4  * Copyright (c) 1999-2002 Vojtech Pavlik
5  * Copyright (c) 2004      Dmitry Torokhov
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 version 2 as published by
9  * the Free Software Foundation.
10  */
11
12 #define MOUSEDEV_MINOR_BASE     32
13 #define MOUSEDEV_MINORS         32
14 #define MOUSEDEV_MIX            31
15
16 #include <linux/sched.h>
17 #include <linux/slab.h>
18 #include <linux/poll.h>
19 #include <linux/module.h>
20 #include <linux/init.h>
21 #include <linux/input.h>
22 #include <linux/random.h>
23 #include <linux/major.h>
24 #include <linux/device.h>
25 #include <linux/kernel.h>
26 #ifdef CONFIG_INPUT_MOUSEDEV_PSAUX
27 #include <linux/miscdevice.h>
28 #endif
29
30 MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
31 MODULE_DESCRIPTION("Mouse (ExplorerPS/2) device interfaces");
32 MODULE_LICENSE("GPL");
33
34 #ifndef CONFIG_INPUT_MOUSEDEV_SCREEN_X
35 #define CONFIG_INPUT_MOUSEDEV_SCREEN_X  1024
36 #endif
37 #ifndef CONFIG_INPUT_MOUSEDEV_SCREEN_Y
38 #define CONFIG_INPUT_MOUSEDEV_SCREEN_Y  768
39 #endif
40
41 static int xres = CONFIG_INPUT_MOUSEDEV_SCREEN_X;
42 module_param(xres, uint, 0644);
43 MODULE_PARM_DESC(xres, "Horizontal screen resolution");
44
45 static int yres = CONFIG_INPUT_MOUSEDEV_SCREEN_Y;
46 module_param(yres, uint, 0644);
47 MODULE_PARM_DESC(yres, "Vertical screen resolution");
48
49 static unsigned tap_time = 200;
50 module_param(tap_time, uint, 0644);
51 MODULE_PARM_DESC(tap_time, "Tap time for touchpads in absolute mode (msecs)");
52
53 struct mousedev_hw_data {
54         int dx, dy, dz;
55         int x, y;
56         int abs_event;
57         unsigned long buttons;
58 };
59
60 struct mousedev {
61         int open;
62         int minor;
63         struct input_handle handle;
64         wait_queue_head_t wait;
65         struct list_head client_list;
66         spinlock_t client_lock; /* protects client_list */
67         struct mutex mutex;
68         struct device dev;
69         bool exist;
70
71         struct list_head mixdev_node;
72         int mixdev_open;
73
74         struct mousedev_hw_data packet;
75         unsigned int pkt_count;
76         int old_x[4], old_y[4];
77         int frac_dx, frac_dy;
78         unsigned long touch;
79 };
80
81 enum mousedev_emul {
82         MOUSEDEV_EMUL_PS2,
83         MOUSEDEV_EMUL_IMPS,
84         MOUSEDEV_EMUL_EXPS
85 };
86
87 struct mousedev_motion {
88         int dx, dy, dz;
89         unsigned long buttons;
90 };
91
92 #define PACKET_QUEUE_LEN        16
93 struct mousedev_client {
94         struct fasync_struct *fasync;
95         struct mousedev *mousedev;
96         struct list_head node;
97
98         struct mousedev_motion packets[PACKET_QUEUE_LEN];
99         unsigned int head, tail;
100         spinlock_t packet_lock;
101         int pos_x, pos_y;
102
103         signed char ps2[6];
104         unsigned char ready, buffer, bufsiz;
105         unsigned char imexseq, impsseq;
106         enum mousedev_emul mode;
107         unsigned long last_buttons;
108 };
109
110 #define MOUSEDEV_SEQ_LEN        6
111
112 static unsigned char mousedev_imps_seq[] = { 0xf3, 200, 0xf3, 100, 0xf3, 80 };
113 static unsigned char mousedev_imex_seq[] = { 0xf3, 200, 0xf3, 200, 0xf3, 80 };
114
115 static struct input_handler mousedev_handler;
116
117 static struct mousedev *mousedev_table[MOUSEDEV_MINORS];
118 static DEFINE_MUTEX(mousedev_table_mutex);
119 static struct mousedev *mousedev_mix;
120 static LIST_HEAD(mousedev_mix_list);
121
122 static void mixdev_open_devices(void);
123 static void mixdev_close_devices(void);
124
125 #define fx(i)  (mousedev->old_x[(mousedev->pkt_count - (i)) & 03])
126 #define fy(i)  (mousedev->old_y[(mousedev->pkt_count - (i)) & 03])
127
128 static void mousedev_touchpad_event(struct input_dev *dev,
129                                     struct mousedev *mousedev,
130                                     unsigned int code, int value)
131 {
132         int size, tmp;
133         enum { FRACTION_DENOM = 128 };
134
135         switch (code) {
136
137         case ABS_X:
138
139                 fx(0) = value;
140                 if (mousedev->touch && mousedev->pkt_count >= 2) {
141                         size = input_abs_get_max(dev, ABS_X) -
142                                         input_abs_get_min(dev, ABS_X);
143                         if (size == 0)
144                                 size = 256 * 2;
145
146                         tmp = ((value - fx(2)) * 256 * FRACTION_DENOM) / size;
147                         tmp += mousedev->frac_dx;
148                         mousedev->packet.dx = tmp / FRACTION_DENOM;
149                         mousedev->frac_dx =
150                                 tmp - mousedev->packet.dx * FRACTION_DENOM;
151                 }
152                 break;
153
154         case ABS_Y:
155                 fy(0) = value;
156                 if (mousedev->touch && mousedev->pkt_count >= 2) {
157                         /* use X size for ABS_Y to keep the same scale */
158                         size = input_abs_get_max(dev, ABS_X) -
159                                         input_abs_get_min(dev, ABS_X);
160                         if (size == 0)
161                                 size = 256 * 2;
162
163                         tmp = -((value - fy(2)) * 256 * FRACTION_DENOM) / size;
164                         tmp += mousedev->frac_dy;
165                         mousedev->packet.dy = tmp / FRACTION_DENOM;
166                         mousedev->frac_dy = tmp -
167                                 mousedev->packet.dy * FRACTION_DENOM;
168                 }
169                 break;
170         }
171 }
172
173 static void mousedev_abs_event(struct input_dev *dev, struct mousedev *mousedev,
174                                 unsigned int code, int value)
175 {
176         int min, max, size;
177
178         switch (code) {
179
180         case ABS_X:
181                 min = input_abs_get_min(dev, ABS_X);
182                 max = input_abs_get_max(dev, ABS_X);
183
184                 size = max - min;
185                 if (size == 0)
186                         size = xres ? : 1;
187
188                 clamp(value, min, max);
189
190                 mousedev->packet.x = ((value - min) * xres) / size;
191                 mousedev->packet.abs_event = 1;
192                 break;
193
194         case ABS_Y:
195                 min = input_abs_get_min(dev, ABS_Y);
196                 max = input_abs_get_max(dev, ABS_Y);
197
198                 size = max - min;
199                 if (size == 0)
200                         size = yres ? : 1;
201
202                 clamp(value, min, max);
203
204                 mousedev->packet.y = yres - ((value - min) * yres) / size;
205                 mousedev->packet.abs_event = 1;
206                 break;
207         }
208 }
209
210 static void mousedev_rel_event(struct mousedev *mousedev,
211                                 unsigned int code, int value)
212 {
213         switch (code) {
214         case REL_X:
215                 mousedev->packet.dx += value;
216                 break;
217
218         case REL_Y:
219                 mousedev->packet.dy -= value;
220                 break;
221
222         case REL_WHEEL:
223                 mousedev->packet.dz -= value;
224                 break;
225         }
226 }
227
228 static void mousedev_key_event(struct mousedev *mousedev,
229                                 unsigned int code, int value)
230 {
231         int index;
232
233         switch (code) {
234
235         case BTN_TOUCH:
236         case BTN_0:
237         case BTN_LEFT:          index = 0; break;
238
239         case BTN_STYLUS:
240         case BTN_1:
241         case BTN_RIGHT:         index = 1; break;
242
243         case BTN_2:
244         case BTN_FORWARD:
245         case BTN_STYLUS2:
246         case BTN_MIDDLE:        index = 2; break;
247
248         case BTN_3:
249         case BTN_BACK:
250         case BTN_SIDE:          index = 3; break;
251
252         case BTN_4:
253         case BTN_EXTRA:         index = 4; break;
254
255         default:                return;
256         }
257
258         if (value) {
259                 set_bit(index, &mousedev->packet.buttons);
260                 set_bit(index, &mousedev_mix->packet.buttons);
261         } else {
262                 clear_bit(index, &mousedev->packet.buttons);
263                 clear_bit(index, &mousedev_mix->packet.buttons);
264         }
265 }
266
267 static void mousedev_notify_readers(struct mousedev *mousedev,
268                                     struct mousedev_hw_data *packet)
269 {
270         struct mousedev_client *client;
271         struct mousedev_motion *p;
272         unsigned int new_head;
273         int wake_readers = 0;
274
275         rcu_read_lock();
276         list_for_each_entry_rcu(client, &mousedev->client_list, node) {
277
278                 /* Just acquire the lock, interrupts already disabled */
279                 spin_lock(&client->packet_lock);
280
281                 p = &client->packets[client->head];
282                 if (client->ready && p->buttons != mousedev->packet.buttons) {
283                         new_head = (client->head + 1) % PACKET_QUEUE_LEN;
284                         if (new_head != client->tail) {
285                                 p = &client->packets[client->head = new_head];
286                                 memset(p, 0, sizeof(struct mousedev_motion));
287                         }
288                 }
289
290                 if (packet->abs_event) {
291                         p->dx += packet->x - client->pos_x;
292                         p->dy += packet->y - client->pos_y;
293                         client->pos_x = packet->x;
294                         client->pos_y = packet->y;
295                 }
296
297                 client->pos_x += packet->dx;
298                 client->pos_x = client->pos_x < 0 ?
299                         0 : (client->pos_x >= xres ? xres : client->pos_x);
300                 client->pos_y += packet->dy;
301                 client->pos_y = client->pos_y < 0 ?
302                         0 : (client->pos_y >= yres ? yres : client->pos_y);
303
304                 p->dx += packet->dx;
305                 p->dy += packet->dy;
306                 p->dz += packet->dz;
307                 p->buttons = mousedev->packet.buttons;
308
309                 if (p->dx || p->dy || p->dz ||
310                     p->buttons != client->last_buttons)
311                         client->ready = 1;
312
313                 spin_unlock(&client->packet_lock);
314
315                 if (client->ready) {
316                         kill_fasync(&client->fasync, SIGIO, POLL_IN);
317                         wake_readers = 1;
318                 }
319         }
320         rcu_read_unlock();
321
322         if (wake_readers)
323                 wake_up_interruptible(&mousedev->wait);
324 }
325
326 static void mousedev_touchpad_touch(struct mousedev *mousedev, int value)
327 {
328         if (!value) {
329                 if (mousedev->touch &&
330                     time_before(jiffies,
331                                 mousedev->touch + msecs_to_jiffies(tap_time))) {
332                         /*
333                          * Toggle left button to emulate tap.
334                          * We rely on the fact that mousedev_mix always has 0
335                          * motion packet so we won't mess current position.
336                          */
337                         set_bit(0, &mousedev->packet.buttons);
338                         set_bit(0, &mousedev_mix->packet.buttons);
339                         mousedev_notify_readers(mousedev, &mousedev_mix->packet);
340                         mousedev_notify_readers(mousedev_mix,
341                                                 &mousedev_mix->packet);
342                         clear_bit(0, &mousedev->packet.buttons);
343                         clear_bit(0, &mousedev_mix->packet.buttons);
344                 }
345                 mousedev->touch = mousedev->pkt_count = 0;
346                 mousedev->frac_dx = 0;
347                 mousedev->frac_dy = 0;
348
349         } else if (!mousedev->touch)
350                 mousedev->touch = jiffies;
351 }
352
353 static void mousedev_event(struct input_handle *handle,
354                            unsigned int type, unsigned int code, int value)
355 {
356         struct mousedev *mousedev = handle->private;
357
358         switch (type) {
359
360         case EV_ABS:
361                 /* Ignore joysticks */
362                 if (test_bit(BTN_TRIGGER, handle->dev->keybit))
363                         return;
364
365                 if (test_bit(BTN_TOOL_FINGER, handle->dev->keybit))
366                         mousedev_touchpad_event(handle->dev,
367                                                 mousedev, code, value);
368                 else
369                         mousedev_abs_event(handle->dev, mousedev, code, value);
370
371                 break;
372
373         case EV_REL:
374                 mousedev_rel_event(mousedev, code, value);
375                 break;
376
377         case EV_KEY:
378                 if (value != 2) {
379                         if (code == BTN_TOUCH &&
380                             test_bit(BTN_TOOL_FINGER, handle->dev->keybit))
381                                 mousedev_touchpad_touch(mousedev, value);
382                         else
383                                 mousedev_key_event(mousedev, code, value);
384                 }
385                 break;
386
387         case EV_SYN:
388                 if (code == SYN_REPORT) {
389                         if (mousedev->touch) {
390                                 mousedev->pkt_count++;
391                                 /*
392                                  * Input system eats duplicate events,
393                                  * but we need all of them to do correct
394                                  * averaging so apply present one forward
395                                  */
396                                 fx(0) = fx(1);
397                                 fy(0) = fy(1);
398                         }
399
400                         mousedev_notify_readers(mousedev, &mousedev->packet);
401                         mousedev_notify_readers(mousedev_mix, &mousedev->packet);
402
403                         mousedev->packet.dx = mousedev->packet.dy =
404                                 mousedev->packet.dz = 0;
405                         mousedev->packet.abs_event = 0;
406                 }
407                 break;
408         }
409 }
410
411 static int mousedev_fasync(int fd, struct file *file, int on)
412 {
413         struct mousedev_client *client = file->private_data;
414
415         return fasync_helper(fd, file, on, &client->fasync);
416 }
417
418 static void mousedev_free(struct device *dev)
419 {
420         struct mousedev *mousedev = container_of(dev, struct mousedev, dev);
421
422         input_put_device(mousedev->handle.dev);
423         kfree(mousedev);
424 }
425
426 static int mousedev_open_device(struct mousedev *mousedev)
427 {
428         int retval;
429
430         retval = mutex_lock_interruptible(&mousedev->mutex);
431         if (retval)
432                 return retval;
433
434         if (mousedev->minor == MOUSEDEV_MIX)
435                 mixdev_open_devices();
436         else if (!mousedev->exist)
437                 retval = -ENODEV;
438         else if (!mousedev->open++) {
439                 retval = input_open_device(&mousedev->handle);
440                 if (retval)
441                         mousedev->open--;
442         }
443
444         mutex_unlock(&mousedev->mutex);
445         return retval;
446 }
447
448 static void mousedev_close_device(struct mousedev *mousedev)
449 {
450         mutex_lock(&mousedev->mutex);
451
452         if (mousedev->minor == MOUSEDEV_MIX)
453                 mixdev_close_devices();
454         else if (mousedev->exist && !--mousedev->open)
455                 input_close_device(&mousedev->handle);
456
457         mutex_unlock(&mousedev->mutex);
458 }
459
460 /*
461  * Open all available devices so they can all be multiplexed in one.
462  * stream. Note that this function is called with mousedev_mix->mutex
463  * held.
464  */
465 static void mixdev_open_devices(void)
466 {
467         struct mousedev *mousedev;
468
469         if (mousedev_mix->open++)
470                 return;
471
472         list_for_each_entry(mousedev, &mousedev_mix_list, mixdev_node) {
473                 if (!mousedev->mixdev_open) {
474                         if (mousedev_open_device(mousedev))
475                                 continue;
476
477                         mousedev->mixdev_open = 1;
478                 }
479         }
480 }
481
482 /*
483  * Close all devices that were opened as part of multiplexed
484  * device. Note that this function is called with mousedev_mix->mutex
485  * held.
486  */
487 static void mixdev_close_devices(void)
488 {
489         struct mousedev *mousedev;
490
491         if (--mousedev_mix->open)
492                 return;
493
494         list_for_each_entry(mousedev, &mousedev_mix_list, mixdev_node) {
495                 if (mousedev->mixdev_open) {
496                         mousedev->mixdev_open = 0;
497                         mousedev_close_device(mousedev);
498                 }
499         }
500 }
501
502
503 static void mousedev_attach_client(struct mousedev *mousedev,
504                                    struct mousedev_client *client)
505 {
506         spin_lock(&mousedev->client_lock);
507         list_add_tail_rcu(&client->node, &mousedev->client_list);
508         spin_unlock(&mousedev->client_lock);
509         synchronize_rcu();
510 }
511
512 static void mousedev_detach_client(struct mousedev *mousedev,
513                                    struct mousedev_client *client)
514 {
515         spin_lock(&mousedev->client_lock);
516         list_del_rcu(&client->node);
517         spin_unlock(&mousedev->client_lock);
518         synchronize_rcu();
519 }
520
521 static int mousedev_release(struct inode *inode, struct file *file)
522 {
523         struct mousedev_client *client = file->private_data;
524         struct mousedev *mousedev = client->mousedev;
525
526         mousedev_detach_client(mousedev, client);
527         kfree(client);
528
529         mousedev_close_device(mousedev);
530         put_device(&mousedev->dev);
531
532         return 0;
533 }
534
535 static int mousedev_open(struct inode *inode, struct file *file)
536 {
537         struct mousedev_client *client;
538         struct mousedev *mousedev;
539         int error;
540         int i;
541
542 #ifdef CONFIG_INPUT_MOUSEDEV_PSAUX
543         if (imajor(inode) == MISC_MAJOR)
544                 i = MOUSEDEV_MIX;
545         else
546 #endif
547                 i = iminor(inode) - MOUSEDEV_MINOR_BASE;
548
549         if (i >= MOUSEDEV_MINORS)
550                 return -ENODEV;
551
552         error = mutex_lock_interruptible(&mousedev_table_mutex);
553         if (error) {
554                 return error;
555         }
556         mousedev = mousedev_table[i];
557         if (mousedev)
558                 get_device(&mousedev->dev);
559         mutex_unlock(&mousedev_table_mutex);
560
561         if (!mousedev) {
562                 return -ENODEV;
563         }
564
565         client = kzalloc(sizeof(struct mousedev_client), GFP_KERNEL);
566         if (!client) {
567                 error = -ENOMEM;
568                 goto err_put_mousedev;
569         }
570
571         spin_lock_init(&client->packet_lock);
572         client->pos_x = xres / 2;
573         client->pos_y = yres / 2;
574         client->mousedev = mousedev;
575         mousedev_attach_client(mousedev, client);
576
577         error = mousedev_open_device(mousedev);
578         if (error)
579                 goto err_free_client;
580
581         file->private_data = client;
582         return 0;
583
584  err_free_client:
585         mousedev_detach_client(mousedev, client);
586         kfree(client);
587  err_put_mousedev:
588         put_device(&mousedev->dev);
589         return error;
590 }
591
592 static inline int mousedev_limit_delta(int delta, int limit)
593 {
594         return delta > limit ? limit : (delta < -limit ? -limit : delta);
595 }
596
597 static void mousedev_packet(struct mousedev_client *client,
598                             signed char *ps2_data)
599 {
600         struct mousedev_motion *p = &client->packets[client->tail];
601
602         ps2_data[0] = 0x08 |
603                 ((p->dx < 0) << 4) | ((p->dy < 0) << 5) | (p->buttons & 0x07);
604         ps2_data[1] = mousedev_limit_delta(p->dx, 127);
605         ps2_data[2] = mousedev_limit_delta(p->dy, 127);
606         p->dx -= ps2_data[1];
607         p->dy -= ps2_data[2];
608
609         switch (client->mode) {
610         case MOUSEDEV_EMUL_EXPS:
611                 ps2_data[3] = mousedev_limit_delta(p->dz, 7);
612                 p->dz -= ps2_data[3];
613                 ps2_data[3] = (ps2_data[3] & 0x0f) | ((p->buttons & 0x18) << 1);
614                 client->bufsiz = 4;
615                 break;
616
617         case MOUSEDEV_EMUL_IMPS:
618                 ps2_data[0] |=
619                         ((p->buttons & 0x10) >> 3) | ((p->buttons & 0x08) >> 1);
620                 ps2_data[3] = mousedev_limit_delta(p->dz, 127);
621                 p->dz -= ps2_data[3];
622                 client->bufsiz = 4;
623                 break;
624
625         case MOUSEDEV_EMUL_PS2:
626         default:
627                 ps2_data[0] |=
628                         ((p->buttons & 0x10) >> 3) | ((p->buttons & 0x08) >> 1);
629                 p->dz = 0;
630                 client->bufsiz = 3;
631                 break;
632         }
633
634         if (!p->dx && !p->dy && !p->dz) {
635                 if (client->tail == client->head) {
636                         client->ready = 0;
637                         client->last_buttons = p->buttons;
638                 } else
639                         client->tail = (client->tail + 1) % PACKET_QUEUE_LEN;
640         }
641 }
642
643 static void mousedev_generate_response(struct mousedev_client *client,
644                                         int command)
645 {
646         client->ps2[0] = 0xfa; /* ACK */
647
648         switch (command) {
649
650         case 0xeb: /* Poll */
651                 mousedev_packet(client, &client->ps2[1]);
652                 client->bufsiz++; /* account for leading ACK */
653                 break;
654
655         case 0xf2: /* Get ID */
656                 switch (client->mode) {
657                 case MOUSEDEV_EMUL_PS2:
658                         client->ps2[1] = 0;
659                         break;
660                 case MOUSEDEV_EMUL_IMPS:
661                         client->ps2[1] = 3;
662                         break;
663                 case MOUSEDEV_EMUL_EXPS:
664                         client->ps2[1] = 4;
665                         break;
666                 }
667                 client->bufsiz = 2;
668                 break;
669
670         case 0xe9: /* Get info */
671                 client->ps2[1] = 0x60; client->ps2[2] = 3; client->ps2[3] = 200;
672                 client->bufsiz = 4;
673                 break;
674
675         case 0xff: /* Reset */
676                 client->impsseq = client->imexseq = 0;
677                 client->mode = MOUSEDEV_EMUL_PS2;
678                 client->ps2[1] = 0xaa; client->ps2[2] = 0x00;
679                 client->bufsiz = 3;
680                 break;
681
682         default:
683                 client->bufsiz = 1;
684                 break;
685         }
686         client->buffer = client->bufsiz;
687 }
688
689 static ssize_t mousedev_write(struct file *file, const char __user *buffer,
690                                 size_t count, loff_t *ppos)
691 {
692         struct mousedev_client *client = file->private_data;
693         unsigned char c;
694         unsigned int i;
695
696         for (i = 0; i < count; i++) {
697
698                 if (get_user(c, buffer + i))
699                         return -EFAULT;
700
701                 spin_lock_irq(&client->packet_lock);
702
703                 if (c == mousedev_imex_seq[client->imexseq]) {
704                         if (++client->imexseq == MOUSEDEV_SEQ_LEN) {
705                                 client->imexseq = 0;
706                                 client->mode = MOUSEDEV_EMUL_EXPS;
707                         }
708                 } else
709                         client->imexseq = 0;
710
711                 if (c == mousedev_imps_seq[client->impsseq]) {
712                         if (++client->impsseq == MOUSEDEV_SEQ_LEN) {
713                                 client->impsseq = 0;
714                                 client->mode = MOUSEDEV_EMUL_IMPS;
715                         }
716                 } else
717                         client->impsseq = 0;
718
719                 mousedev_generate_response(client, c);
720
721                 spin_unlock_irq(&client->packet_lock);
722         }
723
724         kill_fasync(&client->fasync, SIGIO, POLL_IN);
725         wake_up_interruptible(&client->mousedev->wait);
726
727         return count;
728 }
729
730 static ssize_t mousedev_read(struct file *file, char __user *buffer,
731                              size_t count, loff_t *ppos)
732 {
733         struct mousedev_client *client = file->private_data;
734         struct mousedev *mousedev = client->mousedev;
735         signed char data[sizeof(client->ps2)];
736         int retval = 0;
737
738         if (!client->ready && !client->buffer && mousedev->exist &&
739             (file->f_flags & O_NONBLOCK))
740                 return -EAGAIN;
741
742         retval = wait_event_interruptible(mousedev->wait,
743                         !mousedev->exist || client->ready || client->buffer);
744         if (retval)
745                 return retval;
746
747         if (!mousedev->exist)
748                 return -ENODEV;
749
750         spin_lock_irq(&client->packet_lock);
751
752         if (!client->buffer && client->ready) {
753                 mousedev_packet(client, client->ps2);
754                 client->buffer = client->bufsiz;
755         }
756
757         if (count > client->buffer)
758                 count = client->buffer;
759
760         memcpy(data, client->ps2 + client->bufsiz - client->buffer, count);
761         client->buffer -= count;
762
763         spin_unlock_irq(&client->packet_lock);
764
765         if (copy_to_user(buffer, data, count))
766                 return -EFAULT;
767
768         return count;
769 }
770
771 /* No kernel lock - fine */
772 static unsigned int mousedev_poll(struct file *file, poll_table *wait)
773 {
774         struct mousedev_client *client = file->private_data;
775         struct mousedev *mousedev = client->mousedev;
776         unsigned int mask;
777
778         poll_wait(file, &mousedev->wait, wait);
779
780         mask = mousedev->exist ? POLLOUT | POLLWRNORM : POLLHUP | POLLERR;
781         if (client->ready || client->buffer)
782                 mask |= POLLIN | POLLRDNORM;
783
784         return mask;
785 }
786
787 static const struct file_operations mousedev_fops = {
788         .owner =        THIS_MODULE,
789         .read =         mousedev_read,
790         .write =        mousedev_write,
791         .poll =         mousedev_poll,
792         .open =         mousedev_open,
793         .release =      mousedev_release,
794         .fasync =       mousedev_fasync,
795         .llseek = noop_llseek,
796 };
797
798 static int mousedev_install_chrdev(struct mousedev *mousedev)
799 {
800         mousedev_table[mousedev->minor] = mousedev;
801         return 0;
802 }
803
804 static void mousedev_remove_chrdev(struct mousedev *mousedev)
805 {
806         mutex_lock(&mousedev_table_mutex);
807         mousedev_table[mousedev->minor] = NULL;
808         mutex_unlock(&mousedev_table_mutex);
809 }
810
811 /*
812  * Mark device non-existent. This disables writes, ioctls and
813  * prevents new users from opening the device. Already posted
814  * blocking reads will stay, however new ones will fail.
815  */
816 static void mousedev_mark_dead(struct mousedev *mousedev)
817 {
818         mutex_lock(&mousedev->mutex);
819         mousedev->exist = false;
820         mutex_unlock(&mousedev->mutex);
821 }
822
823 /*
824  * Wake up users waiting for IO so they can disconnect from
825  * dead device.
826  */
827 static void mousedev_hangup(struct mousedev *mousedev)
828 {
829         struct mousedev_client *client;
830
831         spin_lock(&mousedev->client_lock);
832         list_for_each_entry(client, &mousedev->client_list, node)
833                 kill_fasync(&client->fasync, SIGIO, POLL_HUP);
834         spin_unlock(&mousedev->client_lock);
835
836         wake_up_interruptible(&mousedev->wait);
837 }
838
839 static void mousedev_cleanup(struct mousedev *mousedev)
840 {
841         struct input_handle *handle = &mousedev->handle;
842
843         mousedev_mark_dead(mousedev);
844         mousedev_hangup(mousedev);
845         mousedev_remove_chrdev(mousedev);
846
847         /* mousedev is marked dead so no one else accesses mousedev->open */
848         if (mousedev->open)
849                 input_close_device(handle);
850 }
851
852 static struct mousedev *mousedev_create(struct input_dev *dev,
853                                         struct input_handler *handler,
854                                         int minor)
855 {
856         struct mousedev *mousedev;
857         int error;
858
859         mousedev = kzalloc(sizeof(struct mousedev), GFP_KERNEL);
860         if (!mousedev) {
861                 error = -ENOMEM;
862                 goto err_out;
863         }
864
865         INIT_LIST_HEAD(&mousedev->client_list);
866         INIT_LIST_HEAD(&mousedev->mixdev_node);
867         spin_lock_init(&mousedev->client_lock);
868         mutex_init(&mousedev->mutex);
869         lockdep_set_subclass(&mousedev->mutex,
870                              minor == MOUSEDEV_MIX ? MOUSEDEV_MIX : 0);
871         init_waitqueue_head(&mousedev->wait);
872
873         if (minor == MOUSEDEV_MIX)
874                 dev_set_name(&mousedev->dev, "mice");
875         else
876                 dev_set_name(&mousedev->dev, "mouse%d", minor);
877
878         mousedev->minor = minor;
879         mousedev->exist = true;
880         mousedev->handle.dev = input_get_device(dev);
881         mousedev->handle.name = dev_name(&mousedev->dev);
882         mousedev->handle.handler = handler;
883         mousedev->handle.private = mousedev;
884
885         mousedev->dev.class = &input_class;
886         if (dev)
887                 mousedev->dev.parent = &dev->dev;
888         mousedev->dev.devt = MKDEV(INPUT_MAJOR, MOUSEDEV_MINOR_BASE + minor);
889         mousedev->dev.release = mousedev_free;
890         device_initialize(&mousedev->dev);
891
892         if (minor != MOUSEDEV_MIX) {
893                 error = input_register_handle(&mousedev->handle);
894                 if (error)
895                         goto err_free_mousedev;
896         }
897
898         error = mousedev_install_chrdev(mousedev);
899         if (error)
900                 goto err_unregister_handle;
901
902         error = device_add(&mousedev->dev);
903         if (error)
904                 goto err_cleanup_mousedev;
905
906         return mousedev;
907
908  err_cleanup_mousedev:
909         mousedev_cleanup(mousedev);
910  err_unregister_handle:
911         if (minor != MOUSEDEV_MIX)
912                 input_unregister_handle(&mousedev->handle);
913  err_free_mousedev:
914         put_device(&mousedev->dev);
915  err_out:
916         return ERR_PTR(error);
917 }
918
919 static void mousedev_destroy(struct mousedev *mousedev)
920 {
921         device_del(&mousedev->dev);
922         mousedev_cleanup(mousedev);
923         if (mousedev->minor != MOUSEDEV_MIX)
924                 input_unregister_handle(&mousedev->handle);
925         put_device(&mousedev->dev);
926 }
927
928 static int mixdev_add_device(struct mousedev *mousedev)
929 {
930         int retval;
931
932         retval = mutex_lock_interruptible(&mousedev_mix->mutex);
933         if (retval)
934                 return retval;
935
936         if (mousedev_mix->open) {
937                 retval = mousedev_open_device(mousedev);
938                 if (retval)
939                         goto out;
940
941                 mousedev->mixdev_open = 1;
942         }
943
944         get_device(&mousedev->dev);
945         list_add_tail(&mousedev->mixdev_node, &mousedev_mix_list);
946
947  out:
948         mutex_unlock(&mousedev_mix->mutex);
949         return retval;
950 }
951
952 static void mixdev_remove_device(struct mousedev *mousedev)
953 {
954         mutex_lock(&mousedev_mix->mutex);
955
956         if (mousedev->mixdev_open) {
957                 mousedev->mixdev_open = 0;
958                 mousedev_close_device(mousedev);
959         }
960
961         list_del_init(&mousedev->mixdev_node);
962         mutex_unlock(&mousedev_mix->mutex);
963
964         put_device(&mousedev->dev);
965 }
966
967 static int mousedev_connect(struct input_handler *handler,
968                             struct input_dev *dev,
969                             const struct input_device_id *id)
970 {
971         struct mousedev *mousedev;
972         int minor;
973         int error;
974
975         for (minor = 0; minor < MOUSEDEV_MINORS; minor++)
976                 if (!mousedev_table[minor])
977                         break;
978
979         if (minor == MOUSEDEV_MINORS) {
980                 printk(KERN_ERR "mousedev: no more free mousedev devices\n");
981                 return -ENFILE;
982         }
983
984         mousedev = mousedev_create(dev, handler, minor);
985         if (IS_ERR(mousedev))
986                 return PTR_ERR(mousedev);
987
988         error = mixdev_add_device(mousedev);
989         if (error) {
990                 mousedev_destroy(mousedev);
991                 return error;
992         }
993
994         return 0;
995 }
996
997 static void mousedev_disconnect(struct input_handle *handle)
998 {
999         struct mousedev *mousedev = handle->private;
1000
1001         mixdev_remove_device(mousedev);
1002         mousedev_destroy(mousedev);
1003 }
1004
1005 static const struct input_device_id mousedev_ids[] = {
1006         {
1007                 .flags = INPUT_DEVICE_ID_MATCH_EVBIT |
1008                                 INPUT_DEVICE_ID_MATCH_KEYBIT |
1009                                 INPUT_DEVICE_ID_MATCH_RELBIT,
1010                 .evbit = { BIT_MASK(EV_KEY) | BIT_MASK(EV_REL) },
1011                 .keybit = { [BIT_WORD(BTN_LEFT)] = BIT_MASK(BTN_LEFT) },
1012                 .relbit = { BIT_MASK(REL_X) | BIT_MASK(REL_Y) },
1013         },      /* A mouse like device, at least one button,
1014                    two relative axes */
1015         {
1016                 .flags = INPUT_DEVICE_ID_MATCH_EVBIT |
1017                                 INPUT_DEVICE_ID_MATCH_RELBIT,
1018                 .evbit = { BIT_MASK(EV_KEY) | BIT_MASK(EV_REL) },
1019                 .relbit = { BIT_MASK(REL_WHEEL) },
1020         },      /* A separate scrollwheel */
1021         {
1022                 .flags = INPUT_DEVICE_ID_MATCH_EVBIT |
1023                                 INPUT_DEVICE_ID_MATCH_KEYBIT |
1024                                 INPUT_DEVICE_ID_MATCH_ABSBIT,
1025                 .evbit = { BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS) },
1026                 .keybit = { [BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH) },
1027                 .absbit = { BIT_MASK(ABS_X) | BIT_MASK(ABS_Y) },
1028         },      /* A tablet like device, at least touch detection,
1029                    two absolute axes */
1030         {
1031                 .flags = INPUT_DEVICE_ID_MATCH_EVBIT |
1032                                 INPUT_DEVICE_ID_MATCH_KEYBIT |
1033                                 INPUT_DEVICE_ID_MATCH_ABSBIT,
1034                 .evbit = { BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS) },
1035                 .keybit = { [BIT_WORD(BTN_TOOL_FINGER)] =
1036                                 BIT_MASK(BTN_TOOL_FINGER) },
1037                 .absbit = { BIT_MASK(ABS_X) | BIT_MASK(ABS_Y) |
1038                                 BIT_MASK(ABS_PRESSURE) |
1039                                 BIT_MASK(ABS_TOOL_WIDTH) },
1040         },      /* A touchpad */
1041         {
1042                 .flags = INPUT_DEVICE_ID_MATCH_EVBIT |
1043                         INPUT_DEVICE_ID_MATCH_KEYBIT |
1044                         INPUT_DEVICE_ID_MATCH_ABSBIT,
1045                 .evbit = { BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS) },
1046                 .keybit = { [BIT_WORD(BTN_LEFT)] = BIT_MASK(BTN_LEFT) },
1047                 .absbit = { BIT_MASK(ABS_X) | BIT_MASK(ABS_Y) },
1048         },      /* Mouse-like device with absolute X and Y but ordinary
1049                    clicks, like hp ILO2 High Performance mouse */
1050
1051         { },    /* Terminating entry */
1052 };
1053
1054 MODULE_DEVICE_TABLE(input, mousedev_ids);
1055
1056 static struct input_handler mousedev_handler = {
1057         .event =        mousedev_event,
1058         .connect =      mousedev_connect,
1059         .disconnect =   mousedev_disconnect,
1060         .fops =         &mousedev_fops,
1061         .minor =        MOUSEDEV_MINOR_BASE,
1062         .name =         "mousedev",
1063         .id_table =     mousedev_ids,
1064 };
1065
1066 #ifdef CONFIG_INPUT_MOUSEDEV_PSAUX
1067 static struct miscdevice psaux_mouse = {
1068         PSMOUSE_MINOR, "psaux", &mousedev_fops
1069 };
1070 static int psaux_registered;
1071 #endif
1072
1073 static int __init mousedev_init(void)
1074 {
1075         int error;
1076
1077         mousedev_mix = mousedev_create(NULL, &mousedev_handler, MOUSEDEV_MIX);
1078         if (IS_ERR(mousedev_mix))
1079                 return PTR_ERR(mousedev_mix);
1080
1081         error = input_register_handler(&mousedev_handler);
1082         if (error) {
1083                 mousedev_destroy(mousedev_mix);
1084                 return error;
1085         }
1086
1087 #ifdef CONFIG_INPUT_MOUSEDEV_PSAUX
1088         error = misc_register(&psaux_mouse);
1089         if (error)
1090                 printk(KERN_WARNING "mice: could not register psaux device, "
1091                         "error: %d\n", error);
1092         else
1093                 psaux_registered = 1;
1094 #endif
1095
1096         printk(KERN_INFO "mice: PS/2 mouse device common for all mice\n");
1097
1098         return 0;
1099 }
1100
1101 static void __exit mousedev_exit(void)
1102 {
1103 #ifdef CONFIG_INPUT_MOUSEDEV_PSAUX
1104         if (psaux_registered)
1105                 misc_deregister(&psaux_mouse);
1106 #endif
1107         input_unregister_handler(&mousedev_handler);
1108         mousedev_destroy(mousedev_mix);
1109 }
1110
1111 module_init(mousedev_init);
1112 module_exit(mousedev_exit);