Input: psmouse - tweak PSMOUSE_DEFINE_ATTR to support raw set callbacks
[linux-2.6.git] / drivers / input / mouse / psmouse-base.c
1 /*
2  * PS/2 mouse driver
3  *
4  * Copyright (c) 1999-2002 Vojtech Pavlik
5  * Copyright (c) 2003-2004 Dmitry Torokhov
6  */
7
8 /*
9  * This program is free software; you can redistribute it and/or modify it
10  * under the terms of the GNU General Public License version 2 as published by
11  * the Free Software Foundation.
12  */
13
14 #include <linux/delay.h>
15 #include <linux/module.h>
16 #include <linux/slab.h>
17 #include <linux/interrupt.h>
18 #include <linux/input.h>
19 #include <linux/serio.h>
20 #include <linux/init.h>
21 #include <linux/libps2.h>
22 #include <linux/mutex.h>
23
24 #include "psmouse.h"
25 #include "synaptics.h"
26 #include "logips2pp.h"
27 #include "alps.h"
28 #include "lifebook.h"
29 #include "trackpoint.h"
30 #include "touchkit_ps2.h"
31
32 #define DRIVER_DESC     "PS/2 mouse driver"
33
34 MODULE_AUTHOR("Vojtech Pavlik <vojtech@suse.cz>");
35 MODULE_DESCRIPTION(DRIVER_DESC);
36 MODULE_LICENSE("GPL");
37
38 static unsigned int psmouse_max_proto = PSMOUSE_AUTO;
39 static int psmouse_set_maxproto(const char *val, struct kernel_param *kp);
40 static int psmouse_get_maxproto(char *buffer, struct kernel_param *kp);
41 #define param_check_proto_abbrev(name, p)       __param_check(name, p, unsigned int)
42 #define param_set_proto_abbrev                  psmouse_set_maxproto
43 #define param_get_proto_abbrev                  psmouse_get_maxproto
44 module_param_named(proto, psmouse_max_proto, proto_abbrev, 0644);
45 MODULE_PARM_DESC(proto, "Highest protocol extension to probe (bare, imps, exps, any). Useful for KVM switches.");
46
47 static unsigned int psmouse_resolution = 200;
48 module_param_named(resolution, psmouse_resolution, uint, 0644);
49 MODULE_PARM_DESC(resolution, "Resolution, in dpi.");
50
51 static unsigned int psmouse_rate = 100;
52 module_param_named(rate, psmouse_rate, uint, 0644);
53 MODULE_PARM_DESC(rate, "Report rate, in reports per second.");
54
55 static unsigned int psmouse_smartscroll = 1;
56 module_param_named(smartscroll, psmouse_smartscroll, bool, 0644);
57 MODULE_PARM_DESC(smartscroll, "Logitech Smartscroll autorepeat, 1 = enabled (default), 0 = disabled.");
58
59 static unsigned int psmouse_resetafter = 5;
60 module_param_named(resetafter, psmouse_resetafter, uint, 0644);
61 MODULE_PARM_DESC(resetafter, "Reset device after so many bad packets (0 = never).");
62
63 static unsigned int psmouse_resync_time;
64 module_param_named(resync_time, psmouse_resync_time, uint, 0644);
65 MODULE_PARM_DESC(resync_time, "How long can mouse stay idle before forcing resync (in seconds, 0 = never).");
66
67 PSMOUSE_DEFINE_ATTR(protocol, S_IWUSR | S_IRUGO,
68                         NULL,
69                         psmouse_attr_show_protocol, psmouse_attr_set_protocol);
70 PSMOUSE_DEFINE_ATTR(rate, S_IWUSR | S_IRUGO,
71                         (void *) offsetof(struct psmouse, rate),
72                         psmouse_show_int_attr, psmouse_attr_set_rate);
73 PSMOUSE_DEFINE_ATTR(resolution, S_IWUSR | S_IRUGO,
74                         (void *) offsetof(struct psmouse, resolution),
75                         psmouse_show_int_attr, psmouse_attr_set_resolution);
76 PSMOUSE_DEFINE_ATTR(resetafter, S_IWUSR | S_IRUGO,
77                         (void *) offsetof(struct psmouse, resetafter),
78                         psmouse_show_int_attr, psmouse_set_int_attr);
79 PSMOUSE_DEFINE_ATTR(resync_time, S_IWUSR | S_IRUGO,
80                         (void *) offsetof(struct psmouse, resync_time),
81                         psmouse_show_int_attr, psmouse_set_int_attr);
82
83 static struct attribute *psmouse_attributes[] = {
84         &psmouse_attr_protocol.dattr.attr,
85         &psmouse_attr_rate.dattr.attr,
86         &psmouse_attr_resolution.dattr.attr,
87         &psmouse_attr_resetafter.dattr.attr,
88         &psmouse_attr_resync_time.dattr.attr,
89         NULL
90 };
91
92 static struct attribute_group psmouse_attribute_group = {
93         .attrs  = psmouse_attributes,
94 };
95
96 /*
97  * psmouse_mutex protects all operations changing state of mouse
98  * (connecting, disconnecting, changing rate or resolution via
99  * sysfs). We could use a per-device semaphore but since there
100  * rarely more than one PS/2 mouse connected and since semaphore
101  * is taken in "slow" paths it is not worth it.
102  */
103 static DEFINE_MUTEX(psmouse_mutex);
104
105 static struct workqueue_struct *kpsmoused_wq;
106
107 struct psmouse_protocol {
108         enum psmouse_type type;
109         const char *name;
110         const char *alias;
111         int maxproto;
112         int (*detect)(struct psmouse *, int);
113         int (*init)(struct psmouse *);
114 };
115
116 /*
117  * psmouse_process_byte() analyzes the PS/2 data stream and reports
118  * relevant events to the input module once full packet has arrived.
119  */
120
121 static psmouse_ret_t psmouse_process_byte(struct psmouse *psmouse)
122 {
123         struct input_dev *dev = psmouse->dev;
124         unsigned char *packet = psmouse->packet;
125
126         if (psmouse->pktcnt < psmouse->pktsize)
127                 return PSMOUSE_GOOD_DATA;
128
129 /*
130  * Full packet accumulated, process it
131  */
132
133 /*
134  * Scroll wheel on IntelliMice, scroll buttons on NetMice
135  */
136
137         if (psmouse->type == PSMOUSE_IMPS || psmouse->type == PSMOUSE_GENPS)
138                 input_report_rel(dev, REL_WHEEL, -(signed char) packet[3]);
139
140 /*
141  * Scroll wheel and buttons on IntelliMouse Explorer
142  */
143
144         if (psmouse->type == PSMOUSE_IMEX) {
145                 switch (packet[3] & 0xC0) {
146                         case 0x80: /* vertical scroll on IntelliMouse Explorer 4.0 */
147                                 input_report_rel(dev, REL_WHEEL, (int) (packet[3] & 32) - (int) (packet[3] & 31));
148                                 break;
149                         case 0x40: /* horizontal scroll on IntelliMouse Explorer 4.0 */
150                                 input_report_rel(dev, REL_HWHEEL, (int) (packet[3] & 32) - (int) (packet[3] & 31));
151                                 break;
152                         case 0x00:
153                         case 0xC0:
154                                 input_report_rel(dev, REL_WHEEL, (int) (packet[3] & 8) - (int) (packet[3] & 7));
155                                 input_report_key(dev, BTN_SIDE, (packet[3] >> 4) & 1);
156                                 input_report_key(dev, BTN_EXTRA, (packet[3] >> 5) & 1);
157                                 break;
158                 }
159         }
160
161 /*
162  * Extra buttons on Genius NewNet 3D
163  */
164
165         if (psmouse->type == PSMOUSE_GENPS) {
166                 input_report_key(dev, BTN_SIDE, (packet[0] >> 6) & 1);
167                 input_report_key(dev, BTN_EXTRA, (packet[0] >> 7) & 1);
168         }
169
170 /*
171  * Extra button on ThinkingMouse
172  */
173         if (psmouse->type == PSMOUSE_THINKPS) {
174                 input_report_key(dev, BTN_EXTRA, (packet[0] >> 3) & 1);
175                 /* Without this bit of weirdness moving up gives wildly high Y changes. */
176                 packet[1] |= (packet[0] & 0x40) << 1;
177         }
178
179 /*
180  * Cortron PS2 Trackball reports SIDE button on the 4th bit of the first
181  * byte.
182  */
183         if (psmouse->type == PSMOUSE_CORTRON) {
184                 input_report_key(dev, BTN_SIDE, (packet[0] >> 3) & 1);
185                 packet[0] |= 0x08;
186         }
187
188 /*
189  * Generic PS/2 Mouse
190  */
191
192         input_report_key(dev, BTN_LEFT,    packet[0]       & 1);
193         input_report_key(dev, BTN_MIDDLE, (packet[0] >> 2) & 1);
194         input_report_key(dev, BTN_RIGHT,  (packet[0] >> 1) & 1);
195
196         input_report_rel(dev, REL_X, packet[1] ? (int) packet[1] - (int) ((packet[0] << 4) & 0x100) : 0);
197         input_report_rel(dev, REL_Y, packet[2] ? (int) ((packet[0] << 3) & 0x100) - (int) packet[2] : 0);
198
199         input_sync(dev);
200
201         return PSMOUSE_FULL_PACKET;
202 }
203
204 void psmouse_queue_work(struct psmouse *psmouse, struct delayed_work *work,
205                 unsigned long delay)
206 {
207         queue_delayed_work(kpsmoused_wq, work, delay);
208 }
209
210 /*
211  * __psmouse_set_state() sets new psmouse state and resets all flags.
212  */
213
214 static inline void __psmouse_set_state(struct psmouse *psmouse, enum psmouse_state new_state)
215 {
216         psmouse->state = new_state;
217         psmouse->pktcnt = psmouse->out_of_sync = 0;
218         psmouse->ps2dev.flags = 0;
219         psmouse->last = jiffies;
220 }
221
222
223 /*
224  * psmouse_set_state() sets new psmouse state and resets all flags and
225  * counters while holding serio lock so fighting with interrupt handler
226  * is not a concern.
227  */
228
229 void psmouse_set_state(struct psmouse *psmouse, enum psmouse_state new_state)
230 {
231         serio_pause_rx(psmouse->ps2dev.serio);
232         __psmouse_set_state(psmouse, new_state);
233         serio_continue_rx(psmouse->ps2dev.serio);
234 }
235
236 /*
237  * psmouse_handle_byte() processes one byte of the input data stream
238  * by calling corresponding protocol handler.
239  */
240
241 static int psmouse_handle_byte(struct psmouse *psmouse)
242 {
243         psmouse_ret_t rc = psmouse->protocol_handler(psmouse);
244
245         switch (rc) {
246                 case PSMOUSE_BAD_DATA:
247                         if (psmouse->state == PSMOUSE_ACTIVATED) {
248                                 printk(KERN_WARNING "psmouse.c: %s at %s lost sync at byte %d\n",
249                                         psmouse->name, psmouse->phys, psmouse->pktcnt);
250                                 if (++psmouse->out_of_sync == psmouse->resetafter) {
251                                         __psmouse_set_state(psmouse, PSMOUSE_IGNORE);
252                                         printk(KERN_NOTICE "psmouse.c: issuing reconnect request\n");
253                                         serio_reconnect(psmouse->ps2dev.serio);
254                                         return -1;
255                                 }
256                         }
257                         psmouse->pktcnt = 0;
258                         break;
259
260                 case PSMOUSE_FULL_PACKET:
261                         psmouse->pktcnt = 0;
262                         if (psmouse->out_of_sync) {
263                                 psmouse->out_of_sync = 0;
264                                 printk(KERN_NOTICE "psmouse.c: %s at %s - driver resynched.\n",
265                                         psmouse->name, psmouse->phys);
266                         }
267                         break;
268
269                 case PSMOUSE_GOOD_DATA:
270                         break;
271         }
272         return 0;
273 }
274
275 /*
276  * psmouse_interrupt() handles incoming characters, either passing them
277  * for normal processing or gathering them as command response.
278  */
279
280 static irqreturn_t psmouse_interrupt(struct serio *serio,
281                 unsigned char data, unsigned int flags)
282 {
283         struct psmouse *psmouse = serio_get_drvdata(serio);
284
285         if (psmouse->state == PSMOUSE_IGNORE)
286                 goto out;
287
288         if (flags & (SERIO_PARITY|SERIO_TIMEOUT)) {
289                 if (psmouse->state == PSMOUSE_ACTIVATED)
290                         printk(KERN_WARNING "psmouse.c: bad data from KBC -%s%s\n",
291                                 flags & SERIO_TIMEOUT ? " timeout" : "",
292                                 flags & SERIO_PARITY ? " bad parity" : "");
293                 ps2_cmd_aborted(&psmouse->ps2dev);
294                 goto out;
295         }
296
297         if (unlikely(psmouse->ps2dev.flags & PS2_FLAG_ACK))
298                 if  (ps2_handle_ack(&psmouse->ps2dev, data))
299                         goto out;
300
301         if (unlikely(psmouse->ps2dev.flags & PS2_FLAG_CMD))
302                 if  (ps2_handle_response(&psmouse->ps2dev, data))
303                         goto out;
304
305         if (psmouse->state <= PSMOUSE_RESYNCING)
306                 goto out;
307
308         if (psmouse->state == PSMOUSE_ACTIVATED &&
309             psmouse->pktcnt && time_after(jiffies, psmouse->last + HZ/2)) {
310                 printk(KERN_INFO "psmouse.c: %s at %s lost synchronization, throwing %d bytes away.\n",
311                        psmouse->name, psmouse->phys, psmouse->pktcnt);
312                 psmouse->badbyte = psmouse->packet[0];
313                 __psmouse_set_state(psmouse, PSMOUSE_RESYNCING);
314                 psmouse_queue_work(psmouse, &psmouse->resync_work, 0);
315                 goto out;
316         }
317
318         psmouse->packet[psmouse->pktcnt++] = data;
319 /*
320  * Check if this is a new device announcement (0xAA 0x00)
321  */
322         if (unlikely(psmouse->packet[0] == PSMOUSE_RET_BAT && psmouse->pktcnt <= 2)) {
323                 if (psmouse->pktcnt == 1) {
324                         psmouse->last = jiffies;
325                         goto out;
326                 }
327
328                 if (psmouse->packet[1] == PSMOUSE_RET_ID) {
329                         __psmouse_set_state(psmouse, PSMOUSE_IGNORE);
330                         serio_reconnect(serio);
331                         goto out;
332                 }
333 /*
334  * Not a new device, try processing first byte normally
335  */
336                 psmouse->pktcnt = 1;
337                 if (psmouse_handle_byte(psmouse))
338                         goto out;
339
340                 psmouse->packet[psmouse->pktcnt++] = data;
341         }
342
343 /*
344  * See if we need to force resync because mouse was idle for too long
345  */
346         if (psmouse->state == PSMOUSE_ACTIVATED &&
347             psmouse->pktcnt == 1 && psmouse->resync_time &&
348             time_after(jiffies, psmouse->last + psmouse->resync_time * HZ)) {
349                 psmouse->badbyte = psmouse->packet[0];
350                 __psmouse_set_state(psmouse, PSMOUSE_RESYNCING);
351                 psmouse_queue_work(psmouse, &psmouse->resync_work, 0);
352                 goto out;
353         }
354
355         psmouse->last = jiffies;
356         psmouse_handle_byte(psmouse);
357
358  out:
359         return IRQ_HANDLED;
360 }
361
362
363 /*
364  * psmouse_sliced_command() sends an extended PS/2 command to the mouse
365  * using sliced syntax, understood by advanced devices, such as Logitech
366  * or Synaptics touchpads. The command is encoded as:
367  * 0xE6 0xE8 rr 0xE8 ss 0xE8 tt 0xE8 uu where (rr*64)+(ss*16)+(tt*4)+uu
368  * is the command.
369  */
370 int psmouse_sliced_command(struct psmouse *psmouse, unsigned char command)
371 {
372         int i;
373
374         if (ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_SETSCALE11))
375                 return -1;
376
377         for (i = 6; i >= 0; i -= 2) {
378                 unsigned char d = (command >> i) & 3;
379                 if (ps2_command(&psmouse->ps2dev, &d, PSMOUSE_CMD_SETRES))
380                         return -1;
381         }
382
383         return 0;
384 }
385
386
387 /*
388  * psmouse_reset() resets the mouse into power-on state.
389  */
390 int psmouse_reset(struct psmouse *psmouse)
391 {
392         unsigned char param[2];
393
394         if (ps2_command(&psmouse->ps2dev, param, PSMOUSE_CMD_RESET_BAT))
395                 return -1;
396
397         if (param[0] != PSMOUSE_RET_BAT && param[1] != PSMOUSE_RET_ID)
398                 return -1;
399
400         return 0;
401 }
402
403
404 /*
405  * Genius NetMouse magic init.
406  */
407 static int genius_detect(struct psmouse *psmouse, int set_properties)
408 {
409         struct ps2dev *ps2dev = &psmouse->ps2dev;
410         unsigned char param[4];
411
412         param[0] = 3;
413         ps2_command(ps2dev, param, PSMOUSE_CMD_SETRES);
414         ps2_command(ps2dev,  NULL, PSMOUSE_CMD_SETSCALE11);
415         ps2_command(ps2dev,  NULL, PSMOUSE_CMD_SETSCALE11);
416         ps2_command(ps2dev,  NULL, PSMOUSE_CMD_SETSCALE11);
417         ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO);
418
419         if (param[0] != 0x00 || param[1] != 0x33 || param[2] != 0x55)
420                 return -1;
421
422         if (set_properties) {
423                 set_bit(BTN_EXTRA, psmouse->dev->keybit);
424                 set_bit(BTN_SIDE, psmouse->dev->keybit);
425                 set_bit(REL_WHEEL, psmouse->dev->relbit);
426
427                 psmouse->vendor = "Genius";
428                 psmouse->name = "Mouse";
429                 psmouse->pktsize = 4;
430         }
431
432         return 0;
433 }
434
435 /*
436  * IntelliMouse magic init.
437  */
438 static int intellimouse_detect(struct psmouse *psmouse, int set_properties)
439 {
440         struct ps2dev *ps2dev = &psmouse->ps2dev;
441         unsigned char param[2];
442
443         param[0] = 200;
444         ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
445         param[0] = 100;
446         ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
447         param[0] =  80;
448         ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
449         ps2_command(ps2dev, param, PSMOUSE_CMD_GETID);
450
451         if (param[0] != 3)
452                 return -1;
453
454         if (set_properties) {
455                 set_bit(BTN_MIDDLE, psmouse->dev->keybit);
456                 set_bit(REL_WHEEL, psmouse->dev->relbit);
457
458                 if (!psmouse->vendor) psmouse->vendor = "Generic";
459                 if (!psmouse->name) psmouse->name = "Wheel Mouse";
460                 psmouse->pktsize = 4;
461         }
462
463         return 0;
464 }
465
466 /*
467  * Try IntelliMouse/Explorer magic init.
468  */
469 static int im_explorer_detect(struct psmouse *psmouse, int set_properties)
470 {
471         struct ps2dev *ps2dev = &psmouse->ps2dev;
472         unsigned char param[2];
473
474         intellimouse_detect(psmouse, 0);
475
476         param[0] = 200;
477         ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
478         param[0] = 200;
479         ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
480         param[0] =  80;
481         ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
482         ps2_command(ps2dev, param, PSMOUSE_CMD_GETID);
483
484         if (param[0] != 4)
485                 return -1;
486
487 /* Magic to enable horizontal scrolling on IntelliMouse 4.0 */
488         param[0] = 200;
489         ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
490         param[0] =  80;
491         ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
492         param[0] =  40;
493         ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
494
495         if (set_properties) {
496                 set_bit(BTN_MIDDLE, psmouse->dev->keybit);
497                 set_bit(REL_WHEEL, psmouse->dev->relbit);
498                 set_bit(REL_HWHEEL, psmouse->dev->relbit);
499                 set_bit(BTN_SIDE, psmouse->dev->keybit);
500                 set_bit(BTN_EXTRA, psmouse->dev->keybit);
501
502                 if (!psmouse->vendor) psmouse->vendor = "Generic";
503                 if (!psmouse->name) psmouse->name = "Explorer Mouse";
504                 psmouse->pktsize = 4;
505         }
506
507         return 0;
508 }
509
510 /*
511  * Kensington ThinkingMouse / ExpertMouse magic init.
512  */
513 static int thinking_detect(struct psmouse *psmouse, int set_properties)
514 {
515         struct ps2dev *ps2dev = &psmouse->ps2dev;
516         unsigned char param[2];
517         static const unsigned char seq[] = { 20, 60, 40, 20, 20, 60, 40, 20, 20 };
518         int i;
519
520         param[0] = 10;
521         ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
522         param[0] = 0;
523         ps2_command(ps2dev, param, PSMOUSE_CMD_SETRES);
524         for (i = 0; i < ARRAY_SIZE(seq); i++) {
525                 param[0] = seq[i];
526                 ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
527         }
528         ps2_command(ps2dev, param, PSMOUSE_CMD_GETID);
529
530         if (param[0] != 2)
531                 return -1;
532
533         if (set_properties) {
534                 set_bit(BTN_EXTRA, psmouse->dev->keybit);
535
536                 psmouse->vendor = "Kensington";
537                 psmouse->name = "ThinkingMouse";
538         }
539
540         return 0;
541 }
542
543 /*
544  * Bare PS/2 protocol "detection". Always succeeds.
545  */
546 static int ps2bare_detect(struct psmouse *psmouse, int set_properties)
547 {
548         if (set_properties) {
549                 if (!psmouse->vendor) psmouse->vendor = "Generic";
550                 if (!psmouse->name) psmouse->name = "Mouse";
551         }
552
553         return 0;
554 }
555
556 /*
557  * Cortron PS/2 protocol detection. There's no special way to detect it, so it
558  * must be forced by sysfs protocol writing.
559  */
560 static int cortron_detect(struct psmouse *psmouse, int set_properties)
561 {
562         if (set_properties) {
563                 psmouse->vendor = "Cortron";
564                 psmouse->name = "PS/2 Trackball";
565                 set_bit(BTN_SIDE, psmouse->dev->keybit);
566         }
567
568         return 0;
569 }
570
571 /*
572  * psmouse_extensions() probes for any extensions to the basic PS/2 protocol
573  * the mouse may have.
574  */
575
576 static int psmouse_extensions(struct psmouse *psmouse,
577                               unsigned int max_proto, int set_properties)
578 {
579         int synaptics_hardware = 0;
580
581 /*
582  * We always check for lifebook because it does not disturb mouse
583  * (it only checks DMI information).
584  */
585         if (lifebook_detect(psmouse, set_properties) == 0) {
586                 if (max_proto > PSMOUSE_IMEX) {
587                         if (!set_properties || lifebook_init(psmouse) == 0)
588                                 return PSMOUSE_LIFEBOOK;
589                 }
590         }
591
592 /*
593  * Try Kensington ThinkingMouse (we try first, because synaptics probe
594  * upsets the thinkingmouse).
595  */
596
597         if (max_proto > PSMOUSE_IMEX && thinking_detect(psmouse, set_properties) == 0)
598                 return PSMOUSE_THINKPS;
599
600 /*
601  * Try Synaptics TouchPad. Note that probing is done even if Synaptics protocol
602  * support is disabled in config - we need to know if it is synaptics so we
603  * can reset it properly after probing for intellimouse.
604  */
605         if (max_proto > PSMOUSE_PS2 && synaptics_detect(psmouse, set_properties) == 0) {
606                 synaptics_hardware = 1;
607
608                 if (max_proto > PSMOUSE_IMEX) {
609                         if (!set_properties || synaptics_init(psmouse) == 0)
610                                 return PSMOUSE_SYNAPTICS;
611 /*
612  * Some Synaptics touchpads can emulate extended protocols (like IMPS/2).
613  * Unfortunately Logitech/Genius probes confuse some firmware versions so
614  * we'll have to skip them.
615  */
616                         max_proto = PSMOUSE_IMEX;
617                 }
618 /*
619  * Make sure that touchpad is in relative mode, gestures (taps) are enabled
620  */
621                 synaptics_reset(psmouse);
622         }
623
624 /*
625  * Try ALPS TouchPad
626  */
627         if (max_proto > PSMOUSE_IMEX) {
628                 ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_RESET_DIS);
629                 if (alps_detect(psmouse, set_properties) == 0) {
630                         if (!set_properties || alps_init(psmouse) == 0)
631                                 return PSMOUSE_ALPS;
632 /*
633  * Init failed, try basic relative protocols
634  */
635                         max_proto = PSMOUSE_IMEX;
636                 }
637         }
638
639         if (max_proto > PSMOUSE_IMEX) {
640
641                 if (genius_detect(psmouse, set_properties) == 0)
642                         return PSMOUSE_GENPS;
643
644                 if (ps2pp_init(psmouse, set_properties) == 0)
645                         return PSMOUSE_PS2PP;
646
647                 if (trackpoint_detect(psmouse, set_properties) == 0)
648                         return PSMOUSE_TRACKPOINT;
649
650                 if (touchkit_ps2_detect(psmouse, set_properties) == 0)
651                         return PSMOUSE_TOUCHKIT_PS2;
652         }
653
654 /*
655  * Reset to defaults in case the device got confused by extended
656  * protocol probes. Note that we follow up with full reset because
657  * some mice put themselves to sleep when they see PSMOUSE_RESET_DIS.
658  */
659         ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_RESET_DIS);
660         psmouse_reset(psmouse);
661
662         if (max_proto >= PSMOUSE_IMEX && im_explorer_detect(psmouse, set_properties) == 0)
663                 return PSMOUSE_IMEX;
664
665         if (max_proto >= PSMOUSE_IMPS && intellimouse_detect(psmouse, set_properties) == 0)
666                 return PSMOUSE_IMPS;
667
668 /*
669  * Okay, all failed, we have a standard mouse here. The number of the buttons
670  * is still a question, though. We assume 3.
671  */
672         ps2bare_detect(psmouse, set_properties);
673
674         if (synaptics_hardware) {
675 /*
676  * We detected Synaptics hardware but it did not respond to IMPS/2 probes.
677  * We need to reset the touchpad because if there is a track point on the
678  * pass through port it could get disabled while probing for protocol
679  * extensions.
680  */
681                 psmouse_reset(psmouse);
682         }
683
684         return PSMOUSE_PS2;
685 }
686
687 static const struct psmouse_protocol psmouse_protocols[] = {
688         {
689                 .type           = PSMOUSE_PS2,
690                 .name           = "PS/2",
691                 .alias          = "bare",
692                 .maxproto       = 1,
693                 .detect         = ps2bare_detect,
694         },
695 #ifdef CONFIG_MOUSE_PS2_LOGIPS2PP
696         {
697                 .type           = PSMOUSE_PS2PP,
698                 .name           = "PS2++",
699                 .alias          = "logitech",
700                 .detect         = ps2pp_init,
701         },
702 #endif
703         {
704                 .type           = PSMOUSE_THINKPS,
705                 .name           = "ThinkPS/2",
706                 .alias          = "thinkps",
707                 .detect         = thinking_detect,
708         },
709         {
710                 .type           = PSMOUSE_GENPS,
711                 .name           = "GenPS/2",
712                 .alias          = "genius",
713                 .detect         = genius_detect,
714         },
715         {
716                 .type           = PSMOUSE_IMPS,
717                 .name           = "ImPS/2",
718                 .alias          = "imps",
719                 .maxproto       = 1,
720                 .detect         = intellimouse_detect,
721         },
722         {
723                 .type           = PSMOUSE_IMEX,
724                 .name           = "ImExPS/2",
725                 .alias          = "exps",
726                 .maxproto       = 1,
727                 .detect         = im_explorer_detect,
728         },
729 #ifdef CONFIG_MOUSE_PS2_SYNAPTICS
730         {
731                 .type           = PSMOUSE_SYNAPTICS,
732                 .name           = "SynPS/2",
733                 .alias          = "synaptics",
734                 .detect         = synaptics_detect,
735                 .init           = synaptics_init,
736         },
737 #endif
738 #ifdef CONFIG_MOUSE_PS2_ALPS
739         {
740                 .type           = PSMOUSE_ALPS,
741                 .name           = "AlpsPS/2",
742                 .alias          = "alps",
743                 .detect         = alps_detect,
744                 .init           = alps_init,
745         },
746 #endif
747 #ifdef CONFIG_MOUSE_PS2_LIFEBOOK
748         {
749                 .type           = PSMOUSE_LIFEBOOK,
750                 .name           = "LBPS/2",
751                 .alias          = "lifebook",
752                 .init           = lifebook_init,
753         },
754 #endif
755 #ifdef CONFIG_MOUSE_PS2_TRACKPOINT
756         {
757                 .type           = PSMOUSE_TRACKPOINT,
758                 .name           = "TPPS/2",
759                 .alias          = "trackpoint",
760                 .detect         = trackpoint_detect,
761         },
762 #endif
763 #ifdef CONFIG_MOUSE_PS2_TOUCHKIT
764         {
765                 .type           = PSMOUSE_TOUCHKIT_PS2,
766                 .name           = "touchkitPS/2",
767                 .alias          = "touchkit",
768                 .detect         = touchkit_ps2_detect,
769         },
770 #endif
771         {
772                 .type           = PSMOUSE_CORTRON,
773                 .name           = "CortronPS/2",
774                 .alias          = "cortps",
775                 .detect         = cortron_detect,
776         },
777         {
778                 .type           = PSMOUSE_AUTO,
779                 .name           = "auto",
780                 .alias          = "any",
781                 .maxproto       = 1,
782         },
783 };
784
785 static const struct psmouse_protocol *psmouse_protocol_by_type(enum psmouse_type type)
786 {
787         int i;
788
789         for (i = 0; i < ARRAY_SIZE(psmouse_protocols); i++)
790                 if (psmouse_protocols[i].type == type)
791                         return &psmouse_protocols[i];
792
793         WARN_ON(1);
794         return &psmouse_protocols[0];
795 }
796
797 static const struct psmouse_protocol *psmouse_protocol_by_name(const char *name, size_t len)
798 {
799         const struct psmouse_protocol *p;
800         int i;
801
802         for (i = 0; i < ARRAY_SIZE(psmouse_protocols); i++) {
803                 p = &psmouse_protocols[i];
804
805                 if ((strlen(p->name) == len && !strncmp(p->name, name, len)) ||
806                     (strlen(p->alias) == len && !strncmp(p->alias, name, len)))
807                         return &psmouse_protocols[i];
808         }
809
810         return NULL;
811 }
812
813
814 /*
815  * psmouse_probe() probes for a PS/2 mouse.
816  */
817
818 static int psmouse_probe(struct psmouse *psmouse)
819 {
820         struct ps2dev *ps2dev = &psmouse->ps2dev;
821         unsigned char param[2];
822
823 /*
824  * First, we check if it's a mouse. It should send 0x00 or 0x03
825  * in case of an IntelliMouse in 4-byte mode or 0x04 for IM Explorer.
826  * Sunrex K8561 IR Keyboard/Mouse reports 0xff on second and subsequent
827  * ID queries, probably due to a firmware bug.
828  */
829
830         param[0] = 0xa5;
831         if (ps2_command(ps2dev, param, PSMOUSE_CMD_GETID))
832                 return -1;
833
834         if (param[0] != 0x00 && param[0] != 0x03 &&
835             param[0] != 0x04 && param[0] != 0xff)
836                 return -1;
837
838 /*
839  * Then we reset and disable the mouse so that it doesn't generate events.
840  */
841
842         if (ps2_command(ps2dev, NULL, PSMOUSE_CMD_RESET_DIS))
843                 printk(KERN_WARNING "psmouse.c: Failed to reset mouse on %s\n", ps2dev->serio->phys);
844
845         return 0;
846 }
847
848 /*
849  * Here we set the mouse resolution.
850  */
851
852 void psmouse_set_resolution(struct psmouse *psmouse, unsigned int resolution)
853 {
854         static const unsigned char params[] = { 0, 1, 2, 2, 3 };
855         unsigned char p;
856
857         if (resolution == 0 || resolution > 200)
858                 resolution = 200;
859
860         p = params[resolution / 50];
861         ps2_command(&psmouse->ps2dev, &p, PSMOUSE_CMD_SETRES);
862         psmouse->resolution = 25 << p;
863 }
864
865 /*
866  * Here we set the mouse report rate.
867  */
868
869 static void psmouse_set_rate(struct psmouse *psmouse, unsigned int rate)
870 {
871         static const unsigned char rates[] = { 200, 100, 80, 60, 40, 20, 10, 0 };
872         unsigned char r;
873         int i = 0;
874
875         while (rates[i] > rate) i++;
876         r = rates[i];
877         ps2_command(&psmouse->ps2dev, &r, PSMOUSE_CMD_SETRATE);
878         psmouse->rate = r;
879 }
880
881 /*
882  * psmouse_initialize() initializes the mouse to a sane state.
883  */
884
885 static void psmouse_initialize(struct psmouse *psmouse)
886 {
887 /*
888  * We set the mouse report rate, resolution and scaling.
889  */
890
891         if (psmouse_max_proto != PSMOUSE_PS2) {
892                 psmouse->set_rate(psmouse, psmouse->rate);
893                 psmouse->set_resolution(psmouse, psmouse->resolution);
894                 ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_SETSCALE11);
895         }
896 }
897
898 /*
899  * psmouse_activate() enables the mouse so that we get motion reports from it.
900  */
901
902 static void psmouse_activate(struct psmouse *psmouse)
903 {
904         if (ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_ENABLE))
905                 printk(KERN_WARNING "psmouse.c: Failed to enable mouse on %s\n",
906                         psmouse->ps2dev.serio->phys);
907
908         psmouse_set_state(psmouse, PSMOUSE_ACTIVATED);
909 }
910
911
912 /*
913  * psmouse_deactivate() puts the mouse into poll mode so that we don't get motion
914  * reports from it unless we explicitly request it.
915  */
916
917 static void psmouse_deactivate(struct psmouse *psmouse)
918 {
919         if (ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_DISABLE))
920                 printk(KERN_WARNING "psmouse.c: Failed to deactivate mouse on %s\n",
921                         psmouse->ps2dev.serio->phys);
922
923         psmouse_set_state(psmouse, PSMOUSE_CMD_MODE);
924 }
925
926 /*
927  * psmouse_poll() - default poll hanlder. Everyone except for ALPS uses it.
928  */
929
930 static int psmouse_poll(struct psmouse *psmouse)
931 {
932         return ps2_command(&psmouse->ps2dev, psmouse->packet,
933                            PSMOUSE_CMD_POLL | (psmouse->pktsize << 8));
934 }
935
936
937 /*
938  * psmouse_resync() attempts to re-validate current protocol.
939  */
940
941 static void psmouse_resync(struct work_struct *work)
942 {
943         struct psmouse *parent = NULL, *psmouse =
944                 container_of(work, struct psmouse, resync_work.work);
945         struct serio *serio = psmouse->ps2dev.serio;
946         psmouse_ret_t rc = PSMOUSE_GOOD_DATA;
947         int failed = 0, enabled = 0;
948         int i;
949
950         mutex_lock(&psmouse_mutex);
951
952         if (psmouse->state != PSMOUSE_RESYNCING)
953                 goto out;
954
955         if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) {
956                 parent = serio_get_drvdata(serio->parent);
957                 psmouse_deactivate(parent);
958         }
959
960 /*
961  * Some mice don't ACK commands sent while they are in the middle of
962  * transmitting motion packet. To avoid delay we use ps2_sendbyte()
963  * instead of ps2_command() which would wait for 200ms for an ACK
964  * that may never come.
965  * As an additional quirk ALPS touchpads may not only forget to ACK
966  * disable command but will stop reporting taps, so if we see that
967  * mouse at least once ACKs disable we will do full reconnect if ACK
968  * is missing.
969  */
970         psmouse->num_resyncs++;
971
972         if (ps2_sendbyte(&psmouse->ps2dev, PSMOUSE_CMD_DISABLE, 20)) {
973                 if (psmouse->num_resyncs < 3 || psmouse->acks_disable_command)
974                         failed = 1;
975         } else
976                 psmouse->acks_disable_command = 1;
977
978 /*
979  * Poll the mouse. If it was reset the packet will be shorter than
980  * psmouse->pktsize and ps2_command will fail. We do not expect and
981  * do not handle scenario when mouse "upgrades" its protocol while
982  * disconnected since it would require additional delay. If we ever
983  * see a mouse that does it we'll adjust the code.
984  */
985         if (!failed) {
986                 if (psmouse->poll(psmouse))
987                         failed = 1;
988                 else {
989                         psmouse_set_state(psmouse, PSMOUSE_CMD_MODE);
990                         for (i = 0; i < psmouse->pktsize; i++) {
991                                 psmouse->pktcnt++;
992                                 rc = psmouse->protocol_handler(psmouse);
993                                 if (rc != PSMOUSE_GOOD_DATA)
994                                         break;
995                         }
996                         if (rc != PSMOUSE_FULL_PACKET)
997                                 failed = 1;
998                         psmouse_set_state(psmouse, PSMOUSE_RESYNCING);
999                 }
1000         }
1001 /*
1002  * Now try to enable mouse. We try to do that even if poll failed and also
1003  * repeat our attempts 5 times, otherwise we may be left out with disabled
1004  * mouse.
1005  */
1006         for (i = 0; i < 5; i++) {
1007                 if (!ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_ENABLE)) {
1008                         enabled = 1;
1009                         break;
1010                 }
1011                 msleep(200);
1012         }
1013
1014         if (!enabled) {
1015                 printk(KERN_WARNING "psmouse.c: failed to re-enable mouse on %s\n",
1016                         psmouse->ps2dev.serio->phys);
1017                 failed = 1;
1018         }
1019
1020         if (failed) {
1021                 psmouse_set_state(psmouse, PSMOUSE_IGNORE);
1022                 printk(KERN_INFO "psmouse.c: resync failed, issuing reconnect request\n");
1023                 serio_reconnect(serio);
1024         } else
1025                 psmouse_set_state(psmouse, PSMOUSE_ACTIVATED);
1026
1027         if (parent)
1028                 psmouse_activate(parent);
1029  out:
1030         mutex_unlock(&psmouse_mutex);
1031 }
1032
1033 /*
1034  * psmouse_cleanup() resets the mouse into power-on state.
1035  */
1036
1037 static void psmouse_cleanup(struct serio *serio)
1038 {
1039         struct psmouse *psmouse = serio_get_drvdata(serio);
1040         struct psmouse *parent = NULL;
1041
1042         mutex_lock(&psmouse_mutex);
1043
1044         if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) {
1045                 parent = serio_get_drvdata(serio->parent);
1046                 psmouse_deactivate(parent);
1047         }
1048
1049         psmouse_deactivate(psmouse);
1050
1051         if (psmouse->cleanup)
1052                 psmouse->cleanup(psmouse);
1053
1054         psmouse_reset(psmouse);
1055
1056 /*
1057  * Some boxes, such as HP nx7400, get terribly confused if mouse
1058  * is not fully enabled before suspending/shutting down.
1059  */
1060         ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_ENABLE);
1061
1062         if (parent) {
1063                 if (parent->pt_deactivate)
1064                         parent->pt_deactivate(parent);
1065
1066                 psmouse_activate(parent);
1067         }
1068
1069         mutex_unlock(&psmouse_mutex);
1070 }
1071
1072 /*
1073  * psmouse_disconnect() closes and frees.
1074  */
1075
1076 static void psmouse_disconnect(struct serio *serio)
1077 {
1078         struct psmouse *psmouse, *parent = NULL;
1079
1080         psmouse = serio_get_drvdata(serio);
1081
1082         sysfs_remove_group(&serio->dev.kobj, &psmouse_attribute_group);
1083
1084         mutex_lock(&psmouse_mutex);
1085
1086         psmouse_set_state(psmouse, PSMOUSE_CMD_MODE);
1087
1088         /* make sure we don't have a resync in progress */
1089         mutex_unlock(&psmouse_mutex);
1090         flush_workqueue(kpsmoused_wq);
1091         mutex_lock(&psmouse_mutex);
1092
1093         if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) {
1094                 parent = serio_get_drvdata(serio->parent);
1095                 psmouse_deactivate(parent);
1096         }
1097
1098         if (psmouse->disconnect)
1099                 psmouse->disconnect(psmouse);
1100
1101         if (parent && parent->pt_deactivate)
1102                 parent->pt_deactivate(parent);
1103
1104         psmouse_set_state(psmouse, PSMOUSE_IGNORE);
1105
1106         serio_close(serio);
1107         serio_set_drvdata(serio, NULL);
1108         input_unregister_device(psmouse->dev);
1109         kfree(psmouse);
1110
1111         if (parent)
1112                 psmouse_activate(parent);
1113
1114         mutex_unlock(&psmouse_mutex);
1115 }
1116
1117 static int psmouse_switch_protocol(struct psmouse *psmouse, const struct psmouse_protocol *proto)
1118 {
1119         struct input_dev *input_dev = psmouse->dev;
1120
1121         input_dev->dev.parent = &psmouse->ps2dev.serio->dev;
1122
1123         input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REL);
1124         input_dev->keybit[BIT_WORD(BTN_MOUSE)] = BIT_MASK(BTN_LEFT) |
1125                 BIT_MASK(BTN_MIDDLE) | BIT_MASK(BTN_RIGHT);
1126         input_dev->relbit[0] = BIT_MASK(REL_X) | BIT_MASK(REL_Y);
1127
1128         psmouse->set_rate = psmouse_set_rate;
1129         psmouse->set_resolution = psmouse_set_resolution;
1130         psmouse->poll = psmouse_poll;
1131         psmouse->protocol_handler = psmouse_process_byte;
1132         psmouse->pktsize = 3;
1133
1134         if (proto && (proto->detect || proto->init)) {
1135                 if (proto->detect && proto->detect(psmouse, 1) < 0)
1136                         return -1;
1137
1138                 if (proto->init && proto->init(psmouse) < 0)
1139                         return -1;
1140
1141                 psmouse->type = proto->type;
1142         }
1143         else
1144                 psmouse->type = psmouse_extensions(psmouse, psmouse_max_proto, 1);
1145
1146         /*
1147          * If mouse's packet size is 3 there is no point in polling the
1148          * device in hopes to detect protocol reset - we won't get less
1149          * than 3 bytes response anyhow.
1150          */
1151         if (psmouse->pktsize == 3)
1152                 psmouse->resync_time = 0;
1153
1154         /*
1155          * Some smart KVMs fake response to POLL command returning just
1156          * 3 bytes and messing up our resync logic, so if initial poll
1157          * fails we won't try polling the device anymore. Hopefully
1158          * such KVM will maintain initially selected protocol.
1159          */
1160         if (psmouse->resync_time && psmouse->poll(psmouse))
1161                 psmouse->resync_time = 0;
1162
1163         snprintf(psmouse->devname, sizeof(psmouse->devname), "%s %s %s",
1164                  psmouse_protocol_by_type(psmouse->type)->name, psmouse->vendor, psmouse->name);
1165
1166         input_dev->name = psmouse->devname;
1167         input_dev->phys = psmouse->phys;
1168         input_dev->id.bustype = BUS_I8042;
1169         input_dev->id.vendor = 0x0002;
1170         input_dev->id.product = psmouse->type;
1171         input_dev->id.version = psmouse->model;
1172
1173         return 0;
1174 }
1175
1176 /*
1177  * psmouse_connect() is a callback from the serio module when
1178  * an unhandled serio port is found.
1179  */
1180 static int psmouse_connect(struct serio *serio, struct serio_driver *drv)
1181 {
1182         struct psmouse *psmouse, *parent = NULL;
1183         struct input_dev *input_dev;
1184         int retval = 0, error = -ENOMEM;
1185
1186         mutex_lock(&psmouse_mutex);
1187
1188         /*
1189          * If this is a pass-through port deactivate parent so the device
1190          * connected to this port can be successfully identified
1191          */
1192         if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) {
1193                 parent = serio_get_drvdata(serio->parent);
1194                 psmouse_deactivate(parent);
1195         }
1196
1197         psmouse = kzalloc(sizeof(struct psmouse), GFP_KERNEL);
1198         input_dev = input_allocate_device();
1199         if (!psmouse || !input_dev)
1200                 goto err_free;
1201
1202         ps2_init(&psmouse->ps2dev, serio);
1203         INIT_DELAYED_WORK(&psmouse->resync_work, psmouse_resync);
1204         psmouse->dev = input_dev;
1205         snprintf(psmouse->phys, sizeof(psmouse->phys), "%s/input0", serio->phys);
1206
1207         psmouse_set_state(psmouse, PSMOUSE_INITIALIZING);
1208
1209         serio_set_drvdata(serio, psmouse);
1210
1211         error = serio_open(serio, drv);
1212         if (error)
1213                 goto err_clear_drvdata;
1214
1215         if (psmouse_probe(psmouse) < 0) {
1216                 error = -ENODEV;
1217                 goto err_close_serio;
1218         }
1219
1220         psmouse->rate = psmouse_rate;
1221         psmouse->resolution = psmouse_resolution;
1222         psmouse->resetafter = psmouse_resetafter;
1223         psmouse->resync_time = parent ? 0 : psmouse_resync_time;
1224         psmouse->smartscroll = psmouse_smartscroll;
1225
1226         psmouse_switch_protocol(psmouse, NULL);
1227
1228         psmouse_set_state(psmouse, PSMOUSE_CMD_MODE);
1229         psmouse_initialize(psmouse);
1230
1231         error = input_register_device(psmouse->dev);
1232         if (error)
1233                 goto err_protocol_disconnect;
1234
1235         if (parent && parent->pt_activate)
1236                 parent->pt_activate(parent);
1237
1238         error = sysfs_create_group(&serio->dev.kobj, &psmouse_attribute_group);
1239         if (error)
1240                 goto err_pt_deactivate;
1241
1242         psmouse_activate(psmouse);
1243
1244  out:
1245         /* If this is a pass-through port the parent needs to be re-activated */
1246         if (parent)
1247                 psmouse_activate(parent);
1248
1249         mutex_unlock(&psmouse_mutex);
1250         return retval;
1251
1252  err_pt_deactivate:
1253         if (parent && parent->pt_deactivate)
1254                 parent->pt_deactivate(parent);
1255         input_unregister_device(psmouse->dev);
1256         input_dev = NULL; /* so we don't try to free it below */
1257  err_protocol_disconnect:
1258         if (psmouse->disconnect)
1259                 psmouse->disconnect(psmouse);
1260         psmouse_set_state(psmouse, PSMOUSE_IGNORE);
1261  err_close_serio:
1262         serio_close(serio);
1263  err_clear_drvdata:
1264         serio_set_drvdata(serio, NULL);
1265  err_free:
1266         input_free_device(input_dev);
1267         kfree(psmouse);
1268
1269         retval = error;
1270         goto out;
1271 }
1272
1273
1274 static int psmouse_reconnect(struct serio *serio)
1275 {
1276         struct psmouse *psmouse = serio_get_drvdata(serio);
1277         struct psmouse *parent = NULL;
1278         struct serio_driver *drv = serio->drv;
1279         int rc = -1;
1280
1281         if (!drv || !psmouse) {
1282                 printk(KERN_DEBUG "psmouse: reconnect request, but serio is disconnected, ignoring...\n");
1283                 return -1;
1284         }
1285
1286         mutex_lock(&psmouse_mutex);
1287
1288         if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) {
1289                 parent = serio_get_drvdata(serio->parent);
1290                 psmouse_deactivate(parent);
1291         }
1292
1293         psmouse_set_state(psmouse, PSMOUSE_INITIALIZING);
1294
1295         if (psmouse->reconnect) {
1296                 if (psmouse->reconnect(psmouse))
1297                         goto out;
1298         } else if (psmouse_probe(psmouse) < 0 ||
1299                    psmouse->type != psmouse_extensions(psmouse, psmouse_max_proto, 0))
1300                 goto out;
1301
1302         /* ok, the device type (and capabilities) match the old one,
1303          * we can continue using it, complete intialization
1304          */
1305         psmouse_set_state(psmouse, PSMOUSE_CMD_MODE);
1306
1307         psmouse_initialize(psmouse);
1308
1309         if (parent && parent->pt_activate)
1310                 parent->pt_activate(parent);
1311
1312         psmouse_activate(psmouse);
1313         rc = 0;
1314
1315 out:
1316         /* If this is a pass-through port the parent waits to be activated */
1317         if (parent)
1318                 psmouse_activate(parent);
1319
1320         mutex_unlock(&psmouse_mutex);
1321         return rc;
1322 }
1323
1324 static struct serio_device_id psmouse_serio_ids[] = {
1325         {
1326                 .type   = SERIO_8042,
1327                 .proto  = SERIO_ANY,
1328                 .id     = SERIO_ANY,
1329                 .extra  = SERIO_ANY,
1330         },
1331         {
1332                 .type   = SERIO_PS_PSTHRU,
1333                 .proto  = SERIO_ANY,
1334                 .id     = SERIO_ANY,
1335                 .extra  = SERIO_ANY,
1336         },
1337         { 0 }
1338 };
1339
1340 MODULE_DEVICE_TABLE(serio, psmouse_serio_ids);
1341
1342 static struct serio_driver psmouse_drv = {
1343         .driver         = {
1344                 .name   = "psmouse",
1345         },
1346         .description    = DRIVER_DESC,
1347         .id_table       = psmouse_serio_ids,
1348         .interrupt      = psmouse_interrupt,
1349         .connect        = psmouse_connect,
1350         .reconnect      = psmouse_reconnect,
1351         .disconnect     = psmouse_disconnect,
1352         .cleanup        = psmouse_cleanup,
1353 };
1354
1355 ssize_t psmouse_attr_show_helper(struct device *dev, struct device_attribute *devattr,
1356                                  char *buf)
1357 {
1358         struct serio *serio = to_serio_port(dev);
1359         struct psmouse_attribute *attr = to_psmouse_attr(devattr);
1360         struct psmouse *psmouse;
1361         int retval;
1362
1363         retval = serio_pin_driver(serio);
1364         if (retval)
1365                 return retval;
1366
1367         if (serio->drv != &psmouse_drv) {
1368                 retval = -ENODEV;
1369                 goto out;
1370         }
1371
1372         psmouse = serio_get_drvdata(serio);
1373
1374         retval = attr->show(psmouse, attr->data, buf);
1375
1376 out:
1377         serio_unpin_driver(serio);
1378         return retval;
1379 }
1380
1381 ssize_t psmouse_attr_set_helper(struct device *dev, struct device_attribute *devattr,
1382                                 const char *buf, size_t count)
1383 {
1384         struct serio *serio = to_serio_port(dev);
1385         struct psmouse_attribute *attr = to_psmouse_attr(devattr);
1386         struct psmouse *psmouse, *parent = NULL;
1387         int retval;
1388
1389         retval = serio_pin_driver(serio);
1390         if (retval)
1391                 return retval;
1392
1393         if (serio->drv != &psmouse_drv) {
1394                 retval = -ENODEV;
1395                 goto out_unpin;
1396         }
1397
1398         retval = mutex_lock_interruptible(&psmouse_mutex);
1399         if (retval)
1400                 goto out_unpin;
1401
1402         psmouse = serio_get_drvdata(serio);
1403
1404         if (attr->protect) {
1405                 if (psmouse->state == PSMOUSE_IGNORE) {
1406                         retval = -ENODEV;
1407                         goto out_unlock;
1408                 }
1409
1410                 if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) {
1411                         parent = serio_get_drvdata(serio->parent);
1412                         psmouse_deactivate(parent);
1413                 }
1414
1415                 psmouse_deactivate(psmouse);
1416         }
1417
1418         retval = attr->set(psmouse, attr->data, buf, count);
1419
1420         if (attr->protect) {
1421                 if (retval != -ENODEV)
1422                         psmouse_activate(psmouse);
1423
1424                 if (parent)
1425                         psmouse_activate(parent);
1426         }
1427
1428  out_unlock:
1429         mutex_unlock(&psmouse_mutex);
1430  out_unpin:
1431         serio_unpin_driver(serio);
1432         return retval;
1433 }
1434
1435 static ssize_t psmouse_show_int_attr(struct psmouse *psmouse, void *offset, char *buf)
1436 {
1437         unsigned int *field = (unsigned int *)((char *)psmouse + (size_t)offset);
1438
1439         return sprintf(buf, "%u\n", *field);
1440 }
1441
1442 static ssize_t psmouse_set_int_attr(struct psmouse *psmouse, void *offset, const char *buf, size_t count)
1443 {
1444         unsigned int *field = (unsigned int *)((char *)psmouse + (size_t)offset);
1445         unsigned long value;
1446
1447         if (strict_strtoul(buf, 10, &value))
1448                 return -EINVAL;
1449
1450         if ((unsigned int)value != value)
1451                 return -EINVAL;
1452
1453         *field = value;
1454
1455         return count;
1456 }
1457
1458 static ssize_t psmouse_attr_show_protocol(struct psmouse *psmouse, void *data, char *buf)
1459 {
1460         return sprintf(buf, "%s\n", psmouse_protocol_by_type(psmouse->type)->name);
1461 }
1462
1463 static ssize_t psmouse_attr_set_protocol(struct psmouse *psmouse, void *data, const char *buf, size_t count)
1464 {
1465         struct serio *serio = psmouse->ps2dev.serio;
1466         struct psmouse *parent = NULL;
1467         struct input_dev *old_dev, *new_dev;
1468         const struct psmouse_protocol *proto, *old_proto;
1469         int error;
1470         int retry = 0;
1471
1472         proto = psmouse_protocol_by_name(buf, count);
1473         if (!proto)
1474                 return -EINVAL;
1475
1476         if (psmouse->type == proto->type)
1477                 return count;
1478
1479         new_dev = input_allocate_device();
1480         if (!new_dev)
1481                 return -ENOMEM;
1482
1483         while (serio->child) {
1484                 if (++retry > 3) {
1485                         printk(KERN_WARNING "psmouse: failed to destroy child port, protocol change aborted.\n");
1486                         input_free_device(new_dev);
1487                         return -EIO;
1488                 }
1489
1490                 mutex_unlock(&psmouse_mutex);
1491                 serio_unpin_driver(serio);
1492                 serio_unregister_child_port(serio);
1493                 serio_pin_driver_uninterruptible(serio);
1494                 mutex_lock(&psmouse_mutex);
1495
1496                 if (serio->drv != &psmouse_drv) {
1497                         input_free_device(new_dev);
1498                         return -ENODEV;
1499                 }
1500
1501                 if (psmouse->type == proto->type) {
1502                         input_free_device(new_dev);
1503                         return count; /* switched by other thread */
1504                 }
1505         }
1506
1507         if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) {
1508                 parent = serio_get_drvdata(serio->parent);
1509                 if (parent->pt_deactivate)
1510                         parent->pt_deactivate(parent);
1511         }
1512
1513         old_dev = psmouse->dev;
1514         old_proto = psmouse_protocol_by_type(psmouse->type);
1515
1516         if (psmouse->disconnect)
1517                 psmouse->disconnect(psmouse);
1518
1519         psmouse_set_state(psmouse, PSMOUSE_IGNORE);
1520
1521         psmouse->dev = new_dev;
1522         psmouse_set_state(psmouse, PSMOUSE_INITIALIZING);
1523
1524         if (psmouse_switch_protocol(psmouse, proto) < 0) {
1525                 psmouse_reset(psmouse);
1526                 /* default to PSMOUSE_PS2 */
1527                 psmouse_switch_protocol(psmouse, &psmouse_protocols[0]);
1528         }
1529
1530         psmouse_initialize(psmouse);
1531         psmouse_set_state(psmouse, PSMOUSE_CMD_MODE);
1532
1533         error = input_register_device(psmouse->dev);
1534         if (error) {
1535                 if (psmouse->disconnect)
1536                         psmouse->disconnect(psmouse);
1537
1538                 psmouse_set_state(psmouse, PSMOUSE_IGNORE);
1539                 input_free_device(new_dev);
1540                 psmouse->dev = old_dev;
1541                 psmouse_set_state(psmouse, PSMOUSE_INITIALIZING);
1542                 psmouse_switch_protocol(psmouse, old_proto);
1543                 psmouse_initialize(psmouse);
1544                 psmouse_set_state(psmouse, PSMOUSE_CMD_MODE);
1545
1546                 return error;
1547         }
1548
1549         input_unregister_device(old_dev);
1550
1551         if (parent && parent->pt_activate)
1552                 parent->pt_activate(parent);
1553
1554         return count;
1555 }
1556
1557 static ssize_t psmouse_attr_set_rate(struct psmouse *psmouse, void *data, const char *buf, size_t count)
1558 {
1559         unsigned long value;
1560
1561         if (strict_strtoul(buf, 10, &value))
1562                 return -EINVAL;
1563
1564         psmouse->set_rate(psmouse, value);
1565         return count;
1566 }
1567
1568 static ssize_t psmouse_attr_set_resolution(struct psmouse *psmouse, void *data, const char *buf, size_t count)
1569 {
1570         unsigned long value;
1571
1572         if (strict_strtoul(buf, 10, &value))
1573                 return -EINVAL;
1574
1575         psmouse->set_resolution(psmouse, value);
1576         return count;
1577 }
1578
1579
1580 static int psmouse_set_maxproto(const char *val, struct kernel_param *kp)
1581 {
1582         const struct psmouse_protocol *proto;
1583
1584         if (!val)
1585                 return -EINVAL;
1586
1587         proto = psmouse_protocol_by_name(val, strlen(val));
1588
1589         if (!proto || !proto->maxproto)
1590                 return -EINVAL;
1591
1592         *((unsigned int *)kp->arg) = proto->type;
1593
1594         return 0;
1595 }
1596
1597 static int psmouse_get_maxproto(char *buffer, struct kernel_param *kp)
1598 {
1599         int type = *((unsigned int *)kp->arg);
1600
1601         return sprintf(buffer, "%s\n", psmouse_protocol_by_type(type)->name);
1602 }
1603
1604 static int __init psmouse_init(void)
1605 {
1606         int err;
1607
1608         kpsmoused_wq = create_singlethread_workqueue("kpsmoused");
1609         if (!kpsmoused_wq) {
1610                 printk(KERN_ERR "psmouse: failed to create kpsmoused workqueue\n");
1611                 return -ENOMEM;
1612         }
1613
1614         err = serio_register_driver(&psmouse_drv);
1615         if (err)
1616                 destroy_workqueue(kpsmoused_wq);
1617
1618         return err;
1619 }
1620
1621 static void __exit psmouse_exit(void)
1622 {
1623         serio_unregister_driver(&psmouse_drv);
1624         destroy_workqueue(kpsmoused_wq);
1625 }
1626
1627 module_init(psmouse_init);
1628 module_exit(psmouse_exit);