Automatic merge of /spare/repo/linux-2.6/.git branch HEAD
[linux-2.6] / drivers / input / mouse / alps.c
1 /*
2  * ALPS touchpad PS/2 mouse driver
3  *
4  * Copyright (c) 2003 Neil Brown <neilb@cse.unsw.edu.au>
5  * Copyright (c) 2003 Peter Osterlund <petero2@telia.com>
6  * Copyright (c) 2004 Dmitry Torokhov <dtor@mail.ru>
7  * Copyright (c) 2005 Vojtech Pavlik <vojtech@suse.cz>
8  *
9  * ALPS detection, tap switching and status querying info is taken from
10  * tpconfig utility (by C. Scott Ananian and Bruce Kall).
11  *
12  * This program is free software; you can redistribute it and/or modify it
13  * under the terms of the GNU General Public License version 2 as published by
14  * the Free Software Foundation.
15  */
16
17 #include <linux/input.h>
18 #include <linux/serio.h>
19 #include <linux/libps2.h>
20
21 #include "psmouse.h"
22 #include "alps.h"
23
24 #undef DEBUG
25 #ifdef DEBUG
26 #define dbg(format, arg...) printk(KERN_INFO "alps.c: " format "\n", ## arg)
27 #else
28 #define dbg(format, arg...) do {} while (0)
29 #endif
30
31 #define ALPS_DUALPOINT  0x01
32 #define ALPS_WHEEL      0x02
33 #define ALPS_FW_BK      0x04
34 #define ALPS_4BTN       0x08
35 #define ALPS_OLDPROTO   0x10
36 #define ALPS_PASS       0x20
37
38 static struct alps_model_info alps_model_data[] = {
39         { { 0x33, 0x02, 0x0a }, 0x88, 0xf8, ALPS_OLDPROTO },            /* UMAX-530T */
40         { { 0x53, 0x02, 0x0a }, 0xf8, 0xf8, 0 },
41         { { 0x53, 0x02, 0x14 }, 0xf8, 0xf8, 0 },
42         { { 0x63, 0x02, 0x0a }, 0xf8, 0xf8, 0 },
43         { { 0x63, 0x02, 0x14 }, 0xf8, 0xf8, 0 },
44         { { 0x63, 0x02, 0x28 }, 0xf8, 0xf8, 0 },
45         { { 0x63, 0x02, 0x3c }, 0x8f, 0x8f, ALPS_WHEEL },               /* Toshiba Satellite S2400-103 */
46         { { 0x63, 0x02, 0x50 }, 0xef, 0xef, ALPS_FW_BK },               /* NEC Versa L320 */
47         { { 0x63, 0x02, 0x64 }, 0xf8, 0xf8, 0 },
48         { { 0x63, 0x03, 0xc8 }, 0xf8, 0xf8, ALPS_PASS },                /* Dell Latitude D800 */
49         { { 0x73, 0x02, 0x0a }, 0xf8, 0xf8, 0 },
50         { { 0x73, 0x02, 0x14 }, 0xf8, 0xf8, 0 },
51         { { 0x20, 0x02, 0x0e }, 0xf8, 0xf8, ALPS_PASS | ALPS_DUALPOINT }, /* XXX */
52         { { 0x22, 0x02, 0x0a }, 0xf8, 0xf8, ALPS_PASS | ALPS_DUALPOINT },
53         { { 0x22, 0x02, 0x14 }, 0xff, 0xff, ALPS_PASS | ALPS_DUALPOINT }, /* Dell Latitude D600 */
54 };
55
56 /*
57  * XXX - this entry is suspicious. First byte has zero lower nibble,
58  * which is what a normal mouse would report. Also, the value 0x0e
59  * isn't valid per PS/2 spec.
60  */
61
62 /*
63  * ALPS abolute Mode - new format
64  * 
65  * byte 0:  1    ?    ?    ?    1    ?    ?    ? 
66  * byte 1:  0   x6   x5   x4   x3   x2   x1   x0
67  * byte 2:  0   x10  x9   x8   x7    ?  fin  ges
68  * byte 3:  0   y9   y8   y7    1    M    R    L 
69  * byte 4:  0   y6   y5   y4   y3   y2   y1   y0
70  * byte 5:  0   z6   z5   z4   z3   z2   z1   z0
71  *
72  * ?'s can have different meanings on different models,
73  * such as wheel rotation, extra buttons, stick buttons
74  * on a dualpoint, etc.
75  */
76
77 static void alps_process_packet(struct psmouse *psmouse, struct pt_regs *regs)
78 {
79         struct alps_data *priv = psmouse->private;
80         unsigned char *packet = psmouse->packet;
81         struct input_dev *dev = &psmouse->dev;
82         struct input_dev *dev2 = &priv->dev2;
83         int x, y, z, ges, fin, left, right, middle;
84
85         input_regs(dev, regs);
86
87         if ((packet[0] & 0xc8) == 0x08) {   /* 3-byte PS/2 packet */
88                 input_report_key(dev2, BTN_LEFT,   packet[0] & 1);    
89                 input_report_key(dev2, BTN_RIGHT,  packet[0] & 2);
90                 input_report_key(dev2, BTN_MIDDLE, packet[0] & 4);
91                 input_report_rel(dev2, REL_X,
92                         packet[1] ? packet[1] - ((packet[0] << 4) & 0x100) : 0);
93                 input_report_rel(dev2, REL_Y,
94                         packet[2] ? ((packet[0] << 3) & 0x100) - packet[2] : 0);
95                 input_sync(dev2);
96                 return;
97         }
98
99         if (priv->i->flags & ALPS_OLDPROTO) {
100                 left = packet[2] & 0x08;
101                 right = packet[2] & 0x10;
102                 middle = 0;
103                 x = packet[1] | ((packet[0] & 0x07) << 7);
104                 y = packet[4] | ((packet[3] & 0x07) << 7);
105                 z = packet[5];
106         } else {
107                 left = packet[3] & 1;
108                 right = packet[3] & 2;
109                 middle = packet[3] & 4;
110                 x = packet[1] | ((packet[2] & 0x78) << (7 - 3));
111                 y = packet[4] | ((packet[3] & 0x70) << (7 - 4));
112                 z = packet[5];
113         }
114
115         ges = packet[2] & 1;
116         fin = packet[2] & 2;
117
118         input_report_key(dev, BTN_LEFT, left);
119         input_report_key(dev, BTN_RIGHT, right);
120         input_report_key(dev, BTN_MIDDLE, middle);
121
122         if ((priv->i->flags & ALPS_DUALPOINT) && z == 127) {
123                 input_report_rel(dev2, REL_X,  (x > 383 ? (x - 768) : x));
124                 input_report_rel(dev2, REL_Y, -(y > 255 ? (y - 512) : y));
125                 input_sync(dev);
126                 input_sync(dev2);
127                 return;
128         }
129
130         /* Convert hardware tap to a reasonable Z value */
131         if (ges && !fin) z = 40;
132
133         /*
134          * A "tap and drag" operation is reported by the hardware as a transition
135          * from (!fin && ges) to (fin && ges). This should be translated to the
136          * sequence Z>0, Z==0, Z>0, so the Z==0 event has to be generated manually.
137          */
138         if (ges && fin && !priv->prev_fin) {
139                 input_report_abs(dev, ABS_X, x);
140                 input_report_abs(dev, ABS_Y, y);
141                 input_report_abs(dev, ABS_PRESSURE, 0);
142                 input_report_key(dev, BTN_TOOL_FINGER, 0);
143                 input_sync(dev);
144         }
145         priv->prev_fin = fin;
146
147         if (z > 30) input_report_key(dev, BTN_TOUCH, 1);
148         if (z < 25) input_report_key(dev, BTN_TOUCH, 0);
149
150         if (z > 0) {
151                 input_report_abs(dev, ABS_X, x);
152                 input_report_abs(dev, ABS_Y, y);
153         }
154
155         input_report_abs(dev, ABS_PRESSURE, z);
156         input_report_key(dev, BTN_TOOL_FINGER, z > 0);
157
158
159         if (priv->i->flags & ALPS_WHEEL)
160                 input_report_rel(dev, REL_WHEEL, ((packet[0] >> 4) & 0x07) | ((packet[2] >> 2) & 0x08));
161
162         if (priv->i->flags & ALPS_FW_BK) {
163                 input_report_key(dev, BTN_FORWARD, packet[0] & 0x10);
164                 input_report_key(dev, BTN_BACK, packet[2] & 0x04);
165         }
166
167         input_sync(dev);
168 }
169
170 static psmouse_ret_t alps_process_byte(struct psmouse *psmouse, struct pt_regs *regs)
171 {
172         struct alps_data *priv = psmouse->private;
173
174         if ((psmouse->packet[0] & 0xc8) == 0x08) { /* PS/2 packet */
175                 if (psmouse->pktcnt == 3) {
176                         alps_process_packet(psmouse, regs);
177                         return PSMOUSE_FULL_PACKET;
178                 }
179                 return PSMOUSE_GOOD_DATA;
180         }
181
182         if ((psmouse->packet[0] & priv->i->mask0) != priv->i->byte0)
183                 return PSMOUSE_BAD_DATA;
184
185         /* Bytes 2 - 6 should have 0 in the highest bit */
186         if (psmouse->pktcnt >= 2 && psmouse->pktcnt <= 6 &&
187             (psmouse->packet[psmouse->pktcnt - 1] & 0x80))
188                 return PSMOUSE_BAD_DATA;
189
190         if (psmouse->pktcnt == 6) {
191                 alps_process_packet(psmouse, regs);
192                 return PSMOUSE_FULL_PACKET;
193         }
194
195         return PSMOUSE_GOOD_DATA;
196 }
197
198 static struct alps_model_info *alps_get_model(struct psmouse *psmouse, int *version)
199 {
200         struct ps2dev *ps2dev = &psmouse->ps2dev;
201         unsigned char rates[] = { 0, 10, 20, 40, 60, 80, 100, 200 };
202         unsigned char param[4];
203         int i;
204
205         /*
206          * First try "E6 report".
207          * ALPS should return 0,0,10 or 0,0,100
208          */
209         param[0] = 0;
210         if (ps2_command(ps2dev, param, PSMOUSE_CMD_SETRES) ||
211             ps2_command(ps2dev,  NULL, PSMOUSE_CMD_SETSCALE11) ||
212             ps2_command(ps2dev,  NULL, PSMOUSE_CMD_SETSCALE11) ||
213             ps2_command(ps2dev,  NULL, PSMOUSE_CMD_SETSCALE11))
214                 return NULL;
215
216         param[0] = param[1] = param[2] = 0xff;
217         if (ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO))
218                 return NULL;
219
220         dbg("E6 report: %2.2x %2.2x %2.2x", param[0], param[1], param[2]);
221
222         if (param[0] != 0 || param[1] != 0 || (param[2] != 10 && param[2] != 100))
223                 return NULL;
224
225         /*
226          * Now try "E7 report". Allowed responses are in
227          * alps_model_data[].signature
228          */
229         param[0] = 0;
230         if (ps2_command(ps2dev, param, PSMOUSE_CMD_SETRES) ||
231             ps2_command(ps2dev,  NULL, PSMOUSE_CMD_SETSCALE21) ||
232             ps2_command(ps2dev,  NULL, PSMOUSE_CMD_SETSCALE21) ||
233             ps2_command(ps2dev,  NULL, PSMOUSE_CMD_SETSCALE21))
234                 return NULL;
235
236         param[0] = param[1] = param[2] = 0xff;
237         if (ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO))
238                 return NULL;
239
240         dbg("E7 report: %2.2x %2.2x %2.2x", param[0], param[1], param[2]);
241
242         for (i = 0; i < ARRAY_SIZE(rates) && param[2] != rates[i]; i++);
243         *version = (param[0] << 8) | (param[1] << 4) | i;
244
245         for (i = 0; i < ARRAY_SIZE(alps_model_data); i++)
246                 if (!memcmp(param, alps_model_data[i].signature, sizeof(alps_model_data[i].signature)))
247                         return alps_model_data + i;
248
249         return NULL;
250 }
251
252 /*
253  * For DualPoint devices select the device that should respond to
254  * subsequent commands. It looks like glidepad is behind stickpointer,
255  * I'd thought it would be other way around...
256  */
257 static int alps_passthrough_mode(struct psmouse *psmouse, int enable)
258 {
259         struct ps2dev *ps2dev = &psmouse->ps2dev;
260         unsigned char param[3];
261         int cmd = enable ? PSMOUSE_CMD_SETSCALE21 : PSMOUSE_CMD_SETSCALE11;
262
263         if (ps2_command(ps2dev, NULL, cmd) ||
264             ps2_command(ps2dev, NULL, cmd) ||
265             ps2_command(ps2dev, NULL, cmd) ||
266             ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE))
267                 return -1;
268
269         /* we may get 3 more bytes, just ignore them */
270         ps2_command(ps2dev, param, 0x0300);
271
272         return 0;
273 }
274
275 static int alps_absolute_mode(struct psmouse *psmouse)
276 {
277         struct ps2dev *ps2dev = &psmouse->ps2dev;
278
279         /* Try ALPS magic knock - 4 disable before enable */
280         if (ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE) ||
281             ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE) ||
282             ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE) ||
283             ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE) ||
284             ps2_command(ps2dev, NULL, PSMOUSE_CMD_ENABLE))
285                 return -1;
286
287         /*
288          * Switch mouse to poll (remote) mode so motion data will not
289          * get in our way
290          */
291         return ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_SETPOLL);
292 }
293
294 static int alps_get_status(struct psmouse *psmouse, char *param)
295 {
296         struct ps2dev *ps2dev = &psmouse->ps2dev;
297
298         /* Get status: 0xF5 0xF5 0xF5 0xE9 */
299         if (ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE) ||
300             ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE) ||
301             ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE) ||
302             ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO))
303                 return -1;
304
305         dbg("Status: %2.2x %2.2x %2.2x", param[0], param[1], param[2]);
306
307         return 0;
308 }
309
310 /*
311  * Turn touchpad tapping on or off. The sequences are:
312  * 0xE9 0xF5 0xF5 0xF3 0x0A to enable,
313  * 0xE9 0xF5 0xF5 0xE8 0x00 to disable.
314  * My guess that 0xE9 (GetInfo) is here as a sync point.
315  * For models that also have stickpointer (DualPoints) its tapping
316  * is controlled separately (0xE6 0xE6 0xE6 0xF3 0x14|0x0A) but
317  * we don't fiddle with it.
318  */
319 static int alps_tap_mode(struct psmouse *psmouse, int enable)
320 {
321         struct ps2dev *ps2dev = &psmouse->ps2dev;
322         int cmd = enable ? PSMOUSE_CMD_SETRATE : PSMOUSE_CMD_SETRES;
323         unsigned char tap_arg = enable ? 0x0A : 0x00;
324         unsigned char param[4];
325
326         if (ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO) ||
327             ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE) ||
328             ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE) ||
329             ps2_command(ps2dev, &tap_arg, cmd))
330                 return -1;
331
332         if (alps_get_status(psmouse, param))
333                 return -1;
334
335         return 0;
336 }
337
338 static int alps_reconnect(struct psmouse *psmouse)
339 {
340         struct alps_data *priv = psmouse->private;
341         unsigned char param[4];
342         int version;
343
344         psmouse_reset(psmouse);
345
346         if (!(priv->i = alps_get_model(psmouse, &version)))
347                 return -1;
348
349         if (priv->i->flags & ALPS_PASS && alps_passthrough_mode(psmouse, 1))
350                 return -1;
351
352         if (alps_get_status(psmouse, param))
353                 return -1;
354
355         if (param[0] & 0x04)
356                 alps_tap_mode(psmouse, 1);
357
358         if (alps_absolute_mode(psmouse)) {
359                 printk(KERN_ERR "alps.c: Failed to enable absolute mode\n");
360                 return -1;
361         }
362
363         if (priv->i->flags == ALPS_PASS && alps_passthrough_mode(psmouse, 0))
364                 return -1;
365
366         return 0;
367 }
368
369 static void alps_disconnect(struct psmouse *psmouse)
370 {
371         struct alps_data *priv = psmouse->private;
372         psmouse_reset(psmouse);
373         input_unregister_device(&priv->dev2);
374         kfree(priv);
375 }
376
377 int alps_init(struct psmouse *psmouse)
378 {
379         struct alps_data *priv;
380         unsigned char param[4];
381         int version;
382
383         psmouse->private = priv = kmalloc(sizeof(struct alps_data), GFP_KERNEL);
384         if (!priv)
385                 goto init_fail;
386         memset(priv, 0, sizeof(struct alps_data));
387
388         if (!(priv->i = alps_get_model(psmouse, &version)))
389                 goto init_fail;
390
391         if ((priv->i->flags & ALPS_PASS) && alps_passthrough_mode(psmouse, 1))
392                 goto init_fail;
393
394         if (alps_get_status(psmouse, param)) {
395                 printk(KERN_ERR "alps.c: touchpad status report request failed\n");
396                 goto init_fail;
397         }
398
399         if (param[0] & 0x04) {
400                 printk(KERN_INFO "alps.c: Enabling hardware tapping\n");
401                 if (alps_tap_mode(psmouse, 1))
402                         printk(KERN_WARNING "alps.c: Failed to enable hardware tapping\n");
403         }
404
405         if (alps_absolute_mode(psmouse)) {
406                 printk(KERN_ERR "alps.c: Failed to enable absolute mode\n");
407                 goto init_fail;
408         }
409
410         if ((priv->i->flags & ALPS_PASS) && alps_passthrough_mode(psmouse, 0))
411                 goto init_fail;
412
413         psmouse->dev.evbit[LONG(EV_KEY)] |= BIT(EV_KEY);
414         psmouse->dev.keybit[LONG(BTN_TOUCH)] |= BIT(BTN_TOUCH);
415         psmouse->dev.keybit[LONG(BTN_TOOL_FINGER)] |= BIT(BTN_TOOL_FINGER);
416         psmouse->dev.keybit[LONG(BTN_LEFT)] |= BIT(BTN_LEFT) | BIT(BTN_MIDDLE) | BIT(BTN_RIGHT);
417
418         psmouse->dev.evbit[LONG(EV_ABS)] |= BIT(EV_ABS);
419         input_set_abs_params(&psmouse->dev, ABS_X, 0, 1023, 0, 0);
420         input_set_abs_params(&psmouse->dev, ABS_Y, 0, 767, 0, 0);
421         input_set_abs_params(&psmouse->dev, ABS_PRESSURE, 0, 127, 0, 0);
422
423         if (priv->i->flags & ALPS_WHEEL) {
424                 psmouse->dev.evbit[LONG(EV_REL)] |= BIT(EV_REL);
425                 psmouse->dev.relbit[LONG(REL_WHEEL)] |= BIT(REL_WHEEL);
426         }
427
428         if (priv->i->flags & ALPS_FW_BK) {
429                 psmouse->dev.keybit[LONG(BTN_FORWARD)] |= BIT(BTN_FORWARD);
430                 psmouse->dev.keybit[LONG(BTN_BACK)] |= BIT(BTN_BACK);
431         }
432
433         sprintf(priv->phys, "%s/input1", psmouse->ps2dev.serio->phys);
434         priv->dev2.phys = priv->phys;
435         priv->dev2.name = (priv->i->flags & ALPS_DUALPOINT) ? "DualPoint Stick" : "PS/2 Mouse";
436         priv->dev2.id.bustype = BUS_I8042;
437         priv->dev2.id.vendor = 0x0002;
438         priv->dev2.id.product = PSMOUSE_ALPS;
439         priv->dev2.id.version = 0x0000; 
440         
441         priv->dev2.evbit[0] = BIT(EV_KEY) | BIT(EV_REL);
442         priv->dev2.relbit[LONG(REL_X)] |= BIT(REL_X) | BIT(REL_Y);
443         priv->dev2.keybit[LONG(BTN_LEFT)] |= BIT(BTN_LEFT) | BIT(BTN_MIDDLE) | BIT(BTN_RIGHT);
444
445         input_register_device(&priv->dev2);
446
447         printk(KERN_INFO "input: %s on %s\n", priv->dev2.name, psmouse->ps2dev.serio->phys);
448
449         psmouse->protocol_handler = alps_process_byte;
450         psmouse->disconnect = alps_disconnect;
451         psmouse->reconnect = alps_reconnect;
452         psmouse->pktsize = 6;
453
454         return 0;
455
456 init_fail:
457         kfree(priv);
458         return -1;
459 }
460
461 int alps_detect(struct psmouse *psmouse, int set_properties)
462 {
463         int version;
464         struct alps_model_info *model; 
465
466         if (!(model = alps_get_model(psmouse, &version)))
467                 return -1;
468
469         if (set_properties) {
470                 psmouse->vendor = "ALPS";
471                 if (model->flags & ALPS_DUALPOINT) 
472                         psmouse->name = "DualPoint TouchPad";
473                 else
474                         psmouse->name = "GlidePoint";
475                 psmouse->model = version;
476         }
477         return 0;
478 }
479