Input: psmouse - small formatting changes to better follow coding style
[linux-2.6.git] / drivers / input / mouse / synaptics.c
1 /*
2  * Synaptics TouchPad PS/2 mouse driver
3  *
4  *   2003 Dmitry Torokhov <dtor@mail.ru>
5  *     Added support for pass-through port. Special thanks to Peter Berg Larsen
6  *     for explaining various Synaptics quirks.
7  *
8  *   2003 Peter Osterlund <petero2@telia.com>
9  *     Ported to 2.5 input device infrastructure.
10  *
11  *   Copyright (C) 2001 Stefan Gmeiner <riddlebox@freesurf.ch>
12  *     start merging tpconfig and gpm code to a xfree-input module
13  *     adding some changes and extensions (ex. 3rd and 4th button)
14  *
15  *   Copyright (c) 1997 C. Scott Ananian <cananian@alumni.priceton.edu>
16  *   Copyright (c) 1998-2000 Bruce Kalk <kall@compass.com>
17  *     code for the special synaptics commands (from the tpconfig-source)
18  *
19  * This program is free software; you can redistribute it and/or modify it
20  * under the terms of the GNU General Public License version 2 as published by
21  * the Free Software Foundation.
22  *
23  * Trademarks are the property of their respective owners.
24  */
25
26 #include <linux/module.h>
27 #include <linux/dmi.h>
28 #include <linux/input.h>
29 #include <linux/serio.h>
30 #include <linux/libps2.h>
31 #include <linux/slab.h>
32 #include "psmouse.h"
33 #include "synaptics.h"
34
35 /*
36  * The x/y limits are taken from the Synaptics TouchPad interfacing Guide,
37  * section 2.3.2, which says that they should be valid regardless of the
38  * actual size of the sensor.
39  * Note that newer firmware allows querying device for maximum useable
40  * coordinates.
41  */
42 #define XMIN_NOMINAL 1472
43 #define XMAX_NOMINAL 5472
44 #define YMIN_NOMINAL 1408
45 #define YMAX_NOMINAL 4448
46
47
48 /*****************************************************************************
49  *      Stuff we need even when we do not want native Synaptics support
50  ****************************************************************************/
51
52 /*
53  * Set the synaptics touchpad mode byte by special commands
54  */
55 static int synaptics_mode_cmd(struct psmouse *psmouse, unsigned char mode)
56 {
57         unsigned char param[1];
58
59         if (psmouse_sliced_command(psmouse, mode))
60                 return -1;
61         param[0] = SYN_PS_SET_MODE2;
62         if (ps2_command(&psmouse->ps2dev, param, PSMOUSE_CMD_SETRATE))
63                 return -1;
64         return 0;
65 }
66
67 int synaptics_detect(struct psmouse *psmouse, bool set_properties)
68 {
69         struct ps2dev *ps2dev = &psmouse->ps2dev;
70         unsigned char param[4];
71
72         param[0] = 0;
73
74         ps2_command(ps2dev, param, PSMOUSE_CMD_SETRES);
75         ps2_command(ps2dev, param, PSMOUSE_CMD_SETRES);
76         ps2_command(ps2dev, param, PSMOUSE_CMD_SETRES);
77         ps2_command(ps2dev, param, PSMOUSE_CMD_SETRES);
78         ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO);
79
80         if (param[1] != 0x47)
81                 return -ENODEV;
82
83         if (set_properties) {
84                 psmouse->vendor = "Synaptics";
85                 psmouse->name = "TouchPad";
86         }
87
88         return 0;
89 }
90
91 void synaptics_reset(struct psmouse *psmouse)
92 {
93         /* reset touchpad back to relative mode, gestures enabled */
94         synaptics_mode_cmd(psmouse, 0);
95 }
96
97 #ifdef CONFIG_MOUSE_PS2_SYNAPTICS
98
99 /*****************************************************************************
100  *      Synaptics communications functions
101  ****************************************************************************/
102
103 /*
104  * Send a command to the synpatics touchpad by special commands
105  */
106 static int synaptics_send_cmd(struct psmouse *psmouse, unsigned char c, unsigned char *param)
107 {
108         if (psmouse_sliced_command(psmouse, c))
109                 return -1;
110         if (ps2_command(&psmouse->ps2dev, param, PSMOUSE_CMD_GETINFO))
111                 return -1;
112         return 0;
113 }
114
115 /*
116  * Read the model-id bytes from the touchpad
117  * see also SYN_MODEL_* macros
118  */
119 static int synaptics_model_id(struct psmouse *psmouse)
120 {
121         struct synaptics_data *priv = psmouse->private;
122         unsigned char mi[3];
123
124         if (synaptics_send_cmd(psmouse, SYN_QUE_MODEL, mi))
125                 return -1;
126         priv->model_id = (mi[0]<<16) | (mi[1]<<8) | mi[2];
127         return 0;
128 }
129
130 /*
131  * Read the capability-bits from the touchpad
132  * see also the SYN_CAP_* macros
133  */
134 static int synaptics_capability(struct psmouse *psmouse)
135 {
136         struct synaptics_data *priv = psmouse->private;
137         unsigned char cap[3];
138
139         if (synaptics_send_cmd(psmouse, SYN_QUE_CAPABILITIES, cap))
140                 return -1;
141         priv->capabilities = (cap[0] << 16) | (cap[1] << 8) | cap[2];
142         priv->ext_cap = priv->ext_cap_0c = 0;
143
144         if (!SYN_CAP_VALID(priv->capabilities))
145                 return -1;
146
147         /*
148          * Unless capExtended is set the rest of the flags should be ignored
149          */
150         if (!SYN_CAP_EXTENDED(priv->capabilities))
151                 priv->capabilities = 0;
152
153         if (SYN_EXT_CAP_REQUESTS(priv->capabilities) >= 1) {
154                 if (synaptics_send_cmd(psmouse, SYN_QUE_EXT_CAPAB, cap)) {
155                         printk(KERN_ERR "Synaptics claims to have extended capabilities,"
156                                " but I'm not able to read them.\n");
157                 } else {
158                         priv->ext_cap = (cap[0] << 16) | (cap[1] << 8) | cap[2];
159
160                         /*
161                          * if nExtBtn is greater than 8 it should be considered
162                          * invalid and treated as 0
163                          */
164                         if (SYN_CAP_MULTI_BUTTON_NO(priv->ext_cap) > 8)
165                                 priv->ext_cap &= 0xff0fff;
166                 }
167         }
168
169         if (SYN_EXT_CAP_REQUESTS(priv->capabilities) >= 4) {
170                 if (synaptics_send_cmd(psmouse, SYN_QUE_EXT_CAPAB_0C, cap)) {
171                         printk(KERN_ERR "Synaptics claims to have extended capability 0x0c,"
172                                " but I'm not able to read it.\n");
173                 } else {
174                         priv->ext_cap_0c = (cap[0] << 16) | (cap[1] << 8) | cap[2];
175                 }
176         }
177
178         return 0;
179 }
180
181 /*
182  * Identify Touchpad
183  * See also the SYN_ID_* macros
184  */
185 static int synaptics_identify(struct psmouse *psmouse)
186 {
187         struct synaptics_data *priv = psmouse->private;
188         unsigned char id[3];
189
190         if (synaptics_send_cmd(psmouse, SYN_QUE_IDENTIFY, id))
191                 return -1;
192         priv->identity = (id[0]<<16) | (id[1]<<8) | id[2];
193         if (SYN_ID_IS_SYNAPTICS(priv->identity))
194                 return 0;
195         return -1;
196 }
197
198 /*
199  * Read touchpad resolution and maximum reported coordinates
200  * Resolution is left zero if touchpad does not support the query
201  */
202 static int synaptics_resolution(struct psmouse *psmouse)
203 {
204         struct synaptics_data *priv = psmouse->private;
205         unsigned char res[3];
206         unsigned char max[3];
207
208         if (SYN_ID_MAJOR(priv->identity) < 4)
209
210         if (synaptics_send_cmd(psmouse, SYN_QUE_RESOLUTION, res) == 0) {
211                 if (res[0] != 0 && (res[1] & 0x80) && res[2] != 0) {
212                         priv->x_res = res[0]; /* x resolution in units/mm */
213                         priv->y_res = res[2]; /* y resolution in units/mm */
214                 }
215         }
216
217         if (SYN_EXT_CAP_REQUESTS(priv->capabilities) >= 5 &&
218             SYN_CAP_MAX_DIMENSIONS(priv->ext_cap_0c)) {
219                 if (synaptics_send_cmd(psmouse, SYN_QUE_EXT_DIMENSIONS, max)) {
220                         printk(KERN_ERR "Synaptics claims to have dimensions query,"
221                                " but I'm not able to read it.\n");
222                 } else {
223                         priv->x_max = (max[0] << 5) | ((max[1] & 0x0f) << 1);
224                         priv->y_max = (max[2] << 5) | ((max[1] & 0xf0) >> 3);
225                 }
226         }
227
228         return 0;
229 }
230
231 static int synaptics_query_hardware(struct psmouse *psmouse)
232 {
233         if (synaptics_identify(psmouse))
234                 return -1;
235         if (synaptics_model_id(psmouse))
236                 return -1;
237         if (synaptics_capability(psmouse))
238                 return -1;
239         if (synaptics_resolution(psmouse))
240                 return -1;
241
242         return 0;
243 }
244
245 static int synaptics_set_absolute_mode(struct psmouse *psmouse)
246 {
247         struct synaptics_data *priv = psmouse->private;
248
249         priv->mode = SYN_BIT_ABSOLUTE_MODE;
250         if (SYN_ID_MAJOR(priv->identity) >= 4)
251                 priv->mode |= SYN_BIT_DISABLE_GESTURE;
252         if (SYN_CAP_EXTENDED(priv->capabilities))
253                 priv->mode |= SYN_BIT_W_MODE;
254
255         if (synaptics_mode_cmd(psmouse, priv->mode))
256                 return -1;
257
258         return 0;
259 }
260
261 static void synaptics_set_rate(struct psmouse *psmouse, unsigned int rate)
262 {
263         struct synaptics_data *priv = psmouse->private;
264
265         if (rate >= 80) {
266                 priv->mode |= SYN_BIT_HIGH_RATE;
267                 psmouse->rate = 80;
268         } else {
269                 priv->mode &= ~SYN_BIT_HIGH_RATE;
270                 psmouse->rate = 40;
271         }
272
273         synaptics_mode_cmd(psmouse, priv->mode);
274 }
275
276 /*****************************************************************************
277  *      Synaptics pass-through PS/2 port support
278  ****************************************************************************/
279 static int synaptics_pt_write(struct serio *serio, unsigned char c)
280 {
281         struct psmouse *parent = serio_get_drvdata(serio->parent);
282         char rate_param = SYN_PS_CLIENT_CMD; /* indicates that we want pass-through port */
283
284         if (psmouse_sliced_command(parent, c))
285                 return -1;
286         if (ps2_command(&parent->ps2dev, &rate_param, PSMOUSE_CMD_SETRATE))
287                 return -1;
288         return 0;
289 }
290
291 static inline int synaptics_is_pt_packet(unsigned char *buf)
292 {
293         return (buf[0] & 0xFC) == 0x84 && (buf[3] & 0xCC) == 0xC4;
294 }
295
296 static void synaptics_pass_pt_packet(struct serio *ptport, unsigned char *packet)
297 {
298         struct psmouse *child = serio_get_drvdata(ptport);
299
300         if (child && child->state == PSMOUSE_ACTIVATED) {
301                 serio_interrupt(ptport, packet[1], 0);
302                 serio_interrupt(ptport, packet[4], 0);
303                 serio_interrupt(ptport, packet[5], 0);
304                 if (child->pktsize == 4)
305                         serio_interrupt(ptport, packet[2], 0);
306         } else
307                 serio_interrupt(ptport, packet[1], 0);
308 }
309
310 static void synaptics_pt_activate(struct psmouse *psmouse)
311 {
312         struct serio *ptport = psmouse->ps2dev.serio->child;
313         struct psmouse *child = serio_get_drvdata(ptport);
314         struct synaptics_data *priv = psmouse->private;
315
316         /* adjust the touchpad to child's choice of protocol */
317         if (child) {
318                 if (child->pktsize == 4)
319                         priv->mode |= SYN_BIT_FOUR_BYTE_CLIENT;
320                 else
321                         priv->mode &= ~SYN_BIT_FOUR_BYTE_CLIENT;
322
323                 if (synaptics_mode_cmd(psmouse, priv->mode))
324                         printk(KERN_INFO "synaptics: failed to switch guest protocol\n");
325         }
326 }
327
328 static void synaptics_pt_create(struct psmouse *psmouse)
329 {
330         struct serio *serio;
331
332         serio = kzalloc(sizeof(struct serio), GFP_KERNEL);
333         if (!serio) {
334                 printk(KERN_ERR "synaptics: not enough memory to allocate pass-through port\n");
335                 return;
336         }
337
338         serio->id.type = SERIO_PS_PSTHRU;
339         strlcpy(serio->name, "Synaptics pass-through", sizeof(serio->name));
340         strlcpy(serio->phys, "synaptics-pt/serio0", sizeof(serio->name));
341         serio->write = synaptics_pt_write;
342         serio->parent = psmouse->ps2dev.serio;
343
344         psmouse->pt_activate = synaptics_pt_activate;
345
346         printk(KERN_INFO "serio: %s port at %s\n", serio->name, psmouse->phys);
347         serio_register_port(serio);
348 }
349
350 /*****************************************************************************
351  *      Functions to interpret the absolute mode packets
352  ****************************************************************************/
353
354 static void synaptics_parse_hw_state(unsigned char buf[], struct synaptics_data *priv, struct synaptics_hw_state *hw)
355 {
356         memset(hw, 0, sizeof(struct synaptics_hw_state));
357
358         if (SYN_MODEL_NEWABS(priv->model_id)) {
359                 hw->x = (((buf[3] & 0x10) << 8) |
360                          ((buf[1] & 0x0f) << 8) |
361                          buf[4]);
362                 hw->y = (((buf[3] & 0x20) << 7) |
363                          ((buf[1] & 0xf0) << 4) |
364                          buf[5]);
365
366                 hw->z = buf[2];
367                 hw->w = (((buf[0] & 0x30) >> 2) |
368                          ((buf[0] & 0x04) >> 1) |
369                          ((buf[3] & 0x04) >> 2));
370
371                 hw->left  = (buf[0] & 0x01) ? 1 : 0;
372                 hw->right = (buf[0] & 0x02) ? 1 : 0;
373
374                 if (SYN_CAP_CLICKPAD(priv->ext_cap_0c)) {
375                         /*
376                          * Clickpad's button is transmitted as middle button,
377                          * however, since it is primary button, we will report
378                          * it as BTN_LEFT.
379                          */
380                         hw->left = ((buf[0] ^ buf[3]) & 0x01) ? 1 : 0;
381
382                 } else if (SYN_CAP_MIDDLE_BUTTON(priv->capabilities)) {
383                         hw->middle = ((buf[0] ^ buf[3]) & 0x01) ? 1 : 0;
384                         if (hw->w == 2)
385                                 hw->scroll = (signed char)(buf[1]);
386                 }
387
388                 if (SYN_CAP_FOUR_BUTTON(priv->capabilities)) {
389                         hw->up   = ((buf[0] ^ buf[3]) & 0x01) ? 1 : 0;
390                         hw->down = ((buf[0] ^ buf[3]) & 0x02) ? 1 : 0;
391                 }
392
393                 if (SYN_CAP_MULTI_BUTTON_NO(priv->ext_cap) &&
394                     ((buf[0] ^ buf[3]) & 0x02)) {
395                         switch (SYN_CAP_MULTI_BUTTON_NO(priv->ext_cap) & ~0x01) {
396                         default:
397                                 /*
398                                  * if nExtBtn is greater than 8 it should be
399                                  * considered invalid and treated as 0
400                                  */
401                                 break;
402                         case 8:
403                                 hw->ext_buttons |= ((buf[5] & 0x08)) ? 0x80 : 0;
404                                 hw->ext_buttons |= ((buf[4] & 0x08)) ? 0x40 : 0;
405                         case 6:
406                                 hw->ext_buttons |= ((buf[5] & 0x04)) ? 0x20 : 0;
407                                 hw->ext_buttons |= ((buf[4] & 0x04)) ? 0x10 : 0;
408                         case 4:
409                                 hw->ext_buttons |= ((buf[5] & 0x02)) ? 0x08 : 0;
410                                 hw->ext_buttons |= ((buf[4] & 0x02)) ? 0x04 : 0;
411                         case 2:
412                                 hw->ext_buttons |= ((buf[5] & 0x01)) ? 0x02 : 0;
413                                 hw->ext_buttons |= ((buf[4] & 0x01)) ? 0x01 : 0;
414                         }
415                 }
416         } else {
417                 hw->x = (((buf[1] & 0x1f) << 8) | buf[2]);
418                 hw->y = (((buf[4] & 0x1f) << 8) | buf[5]);
419
420                 hw->z = (((buf[0] & 0x30) << 2) | (buf[3] & 0x3F));
421                 hw->w = (((buf[1] & 0x80) >> 4) | ((buf[0] & 0x04) >> 1));
422
423                 hw->left  = (buf[0] & 0x01) ? 1 : 0;
424                 hw->right = (buf[0] & 0x02) ? 1 : 0;
425         }
426 }
427
428 /*
429  *  called for each full received packet from the touchpad
430  */
431 static void synaptics_process_packet(struct psmouse *psmouse)
432 {
433         struct input_dev *dev = psmouse->dev;
434         struct synaptics_data *priv = psmouse->private;
435         struct synaptics_hw_state hw;
436         int num_fingers;
437         int finger_width;
438         int i;
439
440         synaptics_parse_hw_state(psmouse->packet, priv, &hw);
441
442         if (hw.scroll) {
443                 priv->scroll += hw.scroll;
444
445                 while (priv->scroll >= 4) {
446                         input_report_key(dev, BTN_BACK, !hw.down);
447                         input_sync(dev);
448                         input_report_key(dev, BTN_BACK, hw.down);
449                         input_sync(dev);
450                         priv->scroll -= 4;
451                 }
452                 while (priv->scroll <= -4) {
453                         input_report_key(dev, BTN_FORWARD, !hw.up);
454                         input_sync(dev);
455                         input_report_key(dev, BTN_FORWARD, hw.up);
456                         input_sync(dev);
457                         priv->scroll += 4;
458                 }
459                 return;
460         }
461
462         if (hw.z > 0) {
463                 num_fingers = 1;
464                 finger_width = 5;
465                 if (SYN_CAP_EXTENDED(priv->capabilities)) {
466                         switch (hw.w) {
467                         case 0 ... 1:
468                                 if (SYN_CAP_MULTIFINGER(priv->capabilities))
469                                         num_fingers = hw.w + 2;
470                                 break;
471                         case 2:
472                                 if (SYN_MODEL_PEN(priv->model_id))
473                                         ;   /* Nothing, treat a pen as a single finger */
474                                 break;
475                         case 4 ... 15:
476                                 if (SYN_CAP_PALMDETECT(priv->capabilities))
477                                         finger_width = hw.w;
478                                 break;
479                         }
480                 }
481         } else {
482                 num_fingers = 0;
483                 finger_width = 0;
484         }
485
486         /* Post events
487          * BTN_TOUCH has to be first as mousedev relies on it when doing
488          * absolute -> relative conversion
489          */
490         if (hw.z > 30) input_report_key(dev, BTN_TOUCH, 1);
491         if (hw.z < 25) input_report_key(dev, BTN_TOUCH, 0);
492
493         if (hw.z > 0) {
494                 input_report_abs(dev, ABS_X, hw.x);
495                 input_report_abs(dev, ABS_Y, YMAX_NOMINAL + YMIN_NOMINAL - hw.y);
496         }
497         input_report_abs(dev, ABS_PRESSURE, hw.z);
498
499         input_report_abs(dev, ABS_TOOL_WIDTH, finger_width);
500         input_report_key(dev, BTN_TOOL_FINGER, num_fingers == 1);
501         input_report_key(dev, BTN_LEFT, hw.left);
502         input_report_key(dev, BTN_RIGHT, hw.right);
503
504         if (SYN_CAP_MULTIFINGER(priv->capabilities)) {
505                 input_report_key(dev, BTN_TOOL_DOUBLETAP, num_fingers == 2);
506                 input_report_key(dev, BTN_TOOL_TRIPLETAP, num_fingers == 3);
507         }
508
509         if (SYN_CAP_MIDDLE_BUTTON(priv->capabilities))
510                 input_report_key(dev, BTN_MIDDLE, hw.middle);
511
512         if (SYN_CAP_FOUR_BUTTON(priv->capabilities)) {
513                 input_report_key(dev, BTN_FORWARD, hw.up);
514                 input_report_key(dev, BTN_BACK, hw.down);
515         }
516
517         for (i = 0; i < SYN_CAP_MULTI_BUTTON_NO(priv->ext_cap); i++)
518                 input_report_key(dev, BTN_0 + i, hw.ext_buttons & (1 << i));
519
520         input_sync(dev);
521 }
522
523 static int synaptics_validate_byte(unsigned char packet[], int idx, unsigned char pkt_type)
524 {
525         static const unsigned char newabs_mask[]        = { 0xC8, 0x00, 0x00, 0xC8, 0x00 };
526         static const unsigned char newabs_rel_mask[]    = { 0xC0, 0x00, 0x00, 0xC0, 0x00 };
527         static const unsigned char newabs_rslt[]        = { 0x80, 0x00, 0x00, 0xC0, 0x00 };
528         static const unsigned char oldabs_mask[]        = { 0xC0, 0x60, 0x00, 0xC0, 0x60 };
529         static const unsigned char oldabs_rslt[]        = { 0xC0, 0x00, 0x00, 0x80, 0x00 };
530
531         if (idx < 0 || idx > 4)
532                 return 0;
533
534         switch (pkt_type) {
535
536         case SYN_NEWABS:
537         case SYN_NEWABS_RELAXED:
538                 return (packet[idx] & newabs_rel_mask[idx]) == newabs_rslt[idx];
539
540         case SYN_NEWABS_STRICT:
541                 return (packet[idx] & newabs_mask[idx]) == newabs_rslt[idx];
542
543         case SYN_OLDABS:
544                 return (packet[idx] & oldabs_mask[idx]) == oldabs_rslt[idx];
545
546         default:
547                 printk(KERN_ERR "synaptics: unknown packet type %d\n", pkt_type);
548                 return 0;
549         }
550 }
551
552 static unsigned char synaptics_detect_pkt_type(struct psmouse *psmouse)
553 {
554         int i;
555
556         for (i = 0; i < 5; i++)
557                 if (!synaptics_validate_byte(psmouse->packet, i, SYN_NEWABS_STRICT)) {
558                         printk(KERN_INFO "synaptics: using relaxed packet validation\n");
559                         return SYN_NEWABS_RELAXED;
560                 }
561
562         return SYN_NEWABS_STRICT;
563 }
564
565 static psmouse_ret_t synaptics_process_byte(struct psmouse *psmouse)
566 {
567         struct synaptics_data *priv = psmouse->private;
568
569         if (psmouse->pktcnt >= 6) { /* Full packet received */
570                 if (unlikely(priv->pkt_type == SYN_NEWABS))
571                         priv->pkt_type = synaptics_detect_pkt_type(psmouse);
572
573                 if (SYN_CAP_PASS_THROUGH(priv->capabilities) && synaptics_is_pt_packet(psmouse->packet)) {
574                         if (psmouse->ps2dev.serio->child)
575                                 synaptics_pass_pt_packet(psmouse->ps2dev.serio->child, psmouse->packet);
576                 } else
577                         synaptics_process_packet(psmouse);
578
579                 return PSMOUSE_FULL_PACKET;
580         }
581
582         return synaptics_validate_byte(psmouse->packet, psmouse->pktcnt - 1, priv->pkt_type) ?
583                 PSMOUSE_GOOD_DATA : PSMOUSE_BAD_DATA;
584 }
585
586 /*****************************************************************************
587  *      Driver initialization/cleanup functions
588  ****************************************************************************/
589 static void set_input_params(struct input_dev *dev, struct synaptics_data *priv)
590 {
591         int i;
592
593         __set_bit(EV_ABS, dev->evbit);
594         input_set_abs_params(dev, ABS_X,
595                              XMIN_NOMINAL, priv->x_max ?: XMAX_NOMINAL, 0, 0);
596         input_set_abs_params(dev, ABS_Y,
597                              YMIN_NOMINAL, priv->y_max ?: YMAX_NOMINAL, 0, 0);
598         input_set_abs_params(dev, ABS_PRESSURE, 0, 255, 0, 0);
599         __set_bit(ABS_TOOL_WIDTH, dev->absbit);
600
601         __set_bit(EV_KEY, dev->evbit);
602         __set_bit(BTN_TOUCH, dev->keybit);
603         __set_bit(BTN_TOOL_FINGER, dev->keybit);
604         __set_bit(BTN_LEFT, dev->keybit);
605         __set_bit(BTN_RIGHT, dev->keybit);
606
607         if (SYN_CAP_MULTIFINGER(priv->capabilities)) {
608                 __set_bit(BTN_TOOL_DOUBLETAP, dev->keybit);
609                 __set_bit(BTN_TOOL_TRIPLETAP, dev->keybit);
610         }
611
612         if (SYN_CAP_MIDDLE_BUTTON(priv->capabilities))
613                 __set_bit(BTN_MIDDLE, dev->keybit);
614
615         if (SYN_CAP_FOUR_BUTTON(priv->capabilities) ||
616             SYN_CAP_MIDDLE_BUTTON(priv->capabilities)) {
617                 __set_bit(BTN_FORWARD, dev->keybit);
618                 __set_bit(BTN_BACK, dev->keybit);
619         }
620
621         for (i = 0; i < SYN_CAP_MULTI_BUTTON_NO(priv->ext_cap); i++)
622                 __set_bit(BTN_0 + i, dev->keybit);
623
624         __clear_bit(EV_REL, dev->evbit);
625         __clear_bit(REL_X, dev->relbit);
626         __clear_bit(REL_Y, dev->relbit);
627
628         dev->absres[ABS_X] = priv->x_res;
629         dev->absres[ABS_Y] = priv->y_res;
630
631         if (SYN_CAP_CLICKPAD(priv->ext_cap_0c)) {
632                 /* Clickpads report only left button */
633                 __clear_bit(BTN_RIGHT, dev->keybit);
634                 __clear_bit(BTN_MIDDLE, dev->keybit);
635         }
636 }
637
638 static void synaptics_disconnect(struct psmouse *psmouse)
639 {
640         synaptics_reset(psmouse);
641         kfree(psmouse->private);
642         psmouse->private = NULL;
643 }
644
645 static int synaptics_reconnect(struct psmouse *psmouse)
646 {
647         struct synaptics_data *priv = psmouse->private;
648         struct synaptics_data old_priv = *priv;
649
650         psmouse_reset(psmouse);
651
652         if (synaptics_detect(psmouse, 0))
653                 return -1;
654
655         if (synaptics_query_hardware(psmouse)) {
656                 printk(KERN_ERR "Unable to query Synaptics hardware.\n");
657                 return -1;
658         }
659
660         if (old_priv.identity != priv->identity ||
661             old_priv.model_id != priv->model_id ||
662             old_priv.capabilities != priv->capabilities ||
663             old_priv.ext_cap != priv->ext_cap)
664                 return -1;
665
666         if (synaptics_set_absolute_mode(psmouse)) {
667                 printk(KERN_ERR "Unable to initialize Synaptics hardware.\n");
668                 return -1;
669         }
670
671         return 0;
672 }
673
674 static bool impaired_toshiba_kbc;
675
676 static const struct dmi_system_id __initconst toshiba_dmi_table[] = {
677 #if defined(CONFIG_DMI) && defined(CONFIG_X86)
678         {
679                 /* Toshiba Satellite */
680                 .matches = {
681                         DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
682                         DMI_MATCH(DMI_PRODUCT_NAME, "Satellite"),
683                 },
684         },
685         {
686                 /* Toshiba Dynabook */
687                 .matches = {
688                         DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
689                         DMI_MATCH(DMI_PRODUCT_NAME, "dynabook"),
690                 },
691         },
692         {
693                 /* Toshiba Portege M300 */
694                 .matches = {
695                         DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
696                         DMI_MATCH(DMI_PRODUCT_NAME, "PORTEGE M300"),
697                 },
698
699         },
700         {
701                 /* Toshiba Portege M300 */
702                 .matches = {
703                         DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
704                         DMI_MATCH(DMI_PRODUCT_NAME, "Portable PC"),
705                         DMI_MATCH(DMI_PRODUCT_VERSION, "Version 1.0"),
706                 },
707
708         },
709         { }
710 #endif
711 };
712
713 void __init synaptics_module_init(void)
714 {
715         impaired_toshiba_kbc = dmi_check_system(toshiba_dmi_table);
716 }
717
718 int synaptics_init(struct psmouse *psmouse)
719 {
720         struct synaptics_data *priv;
721
722         psmouse->private = priv = kzalloc(sizeof(struct synaptics_data), GFP_KERNEL);
723         if (!priv)
724                 return -1;
725
726         psmouse_reset(psmouse);
727
728         if (synaptics_query_hardware(psmouse)) {
729                 printk(KERN_ERR "Unable to query Synaptics hardware.\n");
730                 goto init_fail;
731         }
732
733         if (synaptics_set_absolute_mode(psmouse)) {
734                 printk(KERN_ERR "Unable to initialize Synaptics hardware.\n");
735                 goto init_fail;
736         }
737
738         priv->pkt_type = SYN_MODEL_NEWABS(priv->model_id) ? SYN_NEWABS : SYN_OLDABS;
739
740         printk(KERN_INFO "Synaptics Touchpad, model: %ld, fw: %ld.%ld, id: %#lx, caps: %#lx/%#lx/%#lx\n",
741                 SYN_ID_MODEL(priv->identity),
742                 SYN_ID_MAJOR(priv->identity), SYN_ID_MINOR(priv->identity),
743                 priv->model_id, priv->capabilities, priv->ext_cap, priv->ext_cap_0c);
744
745         set_input_params(psmouse->dev, priv);
746
747         /*
748          * Encode touchpad model so that it can be used to set
749          * input device->id.version and be visible to userspace.
750          * Because version is __u16 we have to drop something.
751          * Hardware info bits seem to be good candidates as they
752          * are documented to be for Synaptics corp. internal use.
753          */
754         psmouse->model = ((priv->model_id & 0x00ff0000) >> 8) |
755                           (priv->model_id & 0x000000ff);
756
757         psmouse->protocol_handler = synaptics_process_byte;
758         psmouse->set_rate = synaptics_set_rate;
759         psmouse->disconnect = synaptics_disconnect;
760         psmouse->reconnect = synaptics_reconnect;
761         psmouse->cleanup = synaptics_reset;
762         psmouse->pktsize = 6;
763         /* Synaptics can usually stay in sync without extra help */
764         psmouse->resync_time = 0;
765
766         if (SYN_CAP_PASS_THROUGH(priv->capabilities))
767                 synaptics_pt_create(psmouse);
768
769         /*
770          * Toshiba's KBC seems to have trouble handling data from
771          * Synaptics as full rate, switch to lower rate which is roughly
772          * thye same as rate of standard PS/2 mouse.
773          */
774         if (psmouse->rate >= 80 && impaired_toshiba_kbc) {
775                 printk(KERN_INFO "synaptics: Toshiba %s detected, limiting rate to 40pps.\n",
776                         dmi_get_system_info(DMI_PRODUCT_NAME));
777                 psmouse->rate = 40;
778         }
779
780         return 0;
781
782  init_fail:
783         kfree(priv);
784         return -1;
785 }
786
787 bool synaptics_supported(void)
788 {
789         return true;
790 }
791
792 #else /* CONFIG_MOUSE_PS2_SYNAPTICS */
793
794 void __init synaptics_module_init(void)
795 {
796 }
797
798 int synaptics_init(struct psmouse *psmouse)
799 {
800         return -ENOSYS;
801 }
802
803 bool synaptics_supported(void)
804 {
805         return false;
806 }
807
808 #endif /* CONFIG_MOUSE_PS2_SYNAPTICS */
809