blob: f36110689aae873404e878625f3b5727f6e997ca [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * ALPS touchpad PS/2 mouse driver
3 *
4 * Copyright (c) 2003 Neil Brown <neilb@cse.unsw.edu.au>
Peter Osterlund963f6262005-07-11 01:08:04 -05005 * Copyright (c) 2003-2005 Peter Osterlund <petero2@telia.com>
Linus Torvalds1da177e2005-04-16 15:20:36 -07006 * 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
Ivan Casado Ruizc30b4c12005-06-01 02:39:18 -050033#define ALPS_FW_BK_1 0x04
Linus Torvalds1da177e2005-04-16 15:20:36 -070034#define ALPS_4BTN 0x08
35#define ALPS_OLDPROTO 0x10
36#define ALPS_PASS 0x20
Ivan Casado Ruizc30b4c12005-06-01 02:39:18 -050037#define ALPS_FW_BK_2 0x40
Linus Torvalds1da177e2005-04-16 15:20:36 -070038
Helge Dellere38de672006-09-10 21:54:39 -040039static const struct alps_model_info alps_model_data[] = {
Dmitry Torokhovb75d1722009-04-23 19:25:51 -070040 { { 0x32, 0x02, 0x14 }, 0xf8, 0xf8, ALPS_PASS | ALPS_DUALPOINT }, /* Toshiba Salellite Pro M10 */
Dmitry Torokhovaf27a692009-05-08 18:30:33 -070041 { { 0x33, 0x02, 0x0a }, 0x88, 0xf8, ALPS_OLDPROTO }, /* UMAX-530T */
Linus Torvalds1da177e2005-04-16 15:20:36 -070042 { { 0x53, 0x02, 0x0a }, 0xf8, 0xf8, 0 },
43 { { 0x53, 0x02, 0x14 }, 0xf8, 0xf8, 0 },
Dmitry Torokhovaf27a692009-05-08 18:30:33 -070044 { { 0x60, 0x03, 0xc8 }, 0xf8, 0xf8, 0 }, /* HP ze1115 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070045 { { 0x63, 0x02, 0x0a }, 0xf8, 0xf8, 0 },
46 { { 0x63, 0x02, 0x14 }, 0xf8, 0xf8, 0 },
Dmitry Torokhovaf27a692009-05-08 18:30:33 -070047 { { 0x63, 0x02, 0x28 }, 0xf8, 0xf8, ALPS_FW_BK_2 }, /* Fujitsu Siemens S6010 */
48 { { 0x63, 0x02, 0x3c }, 0x8f, 0x8f, ALPS_WHEEL }, /* Toshiba Satellite S2400-103 */
49 { { 0x63, 0x02, 0x50 }, 0xef, 0xef, ALPS_FW_BK_1 }, /* NEC Versa L320 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070050 { { 0x63, 0x02, 0x64 }, 0xf8, 0xf8, 0 },
Dmitry Torokhovaf27a692009-05-08 18:30:33 -070051 { { 0x63, 0x03, 0xc8 }, 0xf8, 0xf8, ALPS_PASS | ALPS_DUALPOINT }, /* Dell Latitude D800 */
52 { { 0x73, 0x00, 0x0a }, 0xf8, 0xf8, ALPS_DUALPOINT }, /* ThinkPad R61 8918-5QG */
Linus Torvalds1da177e2005-04-16 15:20:36 -070053 { { 0x73, 0x02, 0x0a }, 0xf8, 0xf8, 0 },
Dmitry Torokhovaf27a692009-05-08 18:30:33 -070054 { { 0x73, 0x02, 0x14 }, 0xf8, 0xf8, ALPS_FW_BK_2 }, /* Ahtec Laptop */
Linus Torvalds1da177e2005-04-16 15:20:36 -070055 { { 0x20, 0x02, 0x0e }, 0xf8, 0xf8, ALPS_PASS | ALPS_DUALPOINT }, /* XXX */
56 { { 0x22, 0x02, 0x0a }, 0xf8, 0xf8, ALPS_PASS | ALPS_DUALPOINT },
57 { { 0x22, 0x02, 0x14 }, 0xff, 0xff, ALPS_PASS | ALPS_DUALPOINT }, /* Dell Latitude D600 */
Elvis Pranskevichus0d46ed12008-09-10 10:19:13 -040058 { { 0x62, 0x02, 0x14 }, 0xcf, 0xcf, ALPS_PASS | ALPS_DUALPOINT }, /* Dell Latitude E6500 */
Dmitry Torokhovaf27a692009-05-08 18:30:33 -070059 { { 0x73, 0x02, 0x50 }, 0xcf, 0xcf, ALPS_FW_BK_1 }, /* Dell Vostro 1400 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070060};
61
62/*
63 * XXX - this entry is suspicious. First byte has zero lower nibble,
64 * which is what a normal mouse would report. Also, the value 0x0e
65 * isn't valid per PS/2 spec.
66 */
67
68/*
69 * ALPS abolute Mode - new format
Dmitry Torokhov968ac842005-05-29 02:28:29 -050070 *
71 * byte 0: 1 ? ? ? 1 ? ? ?
Linus Torvalds1da177e2005-04-16 15:20:36 -070072 * byte 1: 0 x6 x5 x4 x3 x2 x1 x0
73 * byte 2: 0 x10 x9 x8 x7 ? fin ges
Dmitry Torokhov968ac842005-05-29 02:28:29 -050074 * byte 3: 0 y9 y8 y7 1 M R L
Linus Torvalds1da177e2005-04-16 15:20:36 -070075 * byte 4: 0 y6 y5 y4 y3 y2 y1 y0
76 * byte 5: 0 z6 z5 z4 z3 z2 z1 z0
77 *
78 * ?'s can have different meanings on different models,
79 * such as wheel rotation, extra buttons, stick buttons
80 * on a dualpoint, etc.
81 */
82
David Howells7d12e782006-10-05 14:55:46 +010083static void alps_process_packet(struct psmouse *psmouse)
Linus Torvalds1da177e2005-04-16 15:20:36 -070084{
85 struct alps_data *priv = psmouse->private;
86 unsigned char *packet = psmouse->packet;
Dmitry Torokhov2e5b6362005-09-15 02:01:44 -050087 struct input_dev *dev = psmouse->dev;
88 struct input_dev *dev2 = priv->dev2;
Linus Torvalds1da177e2005-04-16 15:20:36 -070089 int x, y, z, ges, fin, left, right, middle;
Ivan Casado Ruizc30b4c12005-06-01 02:39:18 -050090 int back = 0, forward = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070091
Linus Torvalds1da177e2005-04-16 15:20:36 -070092 if ((packet[0] & 0xc8) == 0x08) { /* 3-byte PS/2 packet */
Dmitry Torokhov968ac842005-05-29 02:28:29 -050093 input_report_key(dev2, BTN_LEFT, packet[0] & 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -070094 input_report_key(dev2, BTN_RIGHT, packet[0] & 2);
95 input_report_key(dev2, BTN_MIDDLE, packet[0] & 4);
96 input_report_rel(dev2, REL_X,
97 packet[1] ? packet[1] - ((packet[0] << 4) & 0x100) : 0);
98 input_report_rel(dev2, REL_Y,
99 packet[2] ? ((packet[0] << 3) & 0x100) - packet[2] : 0);
100 input_sync(dev2);
101 return;
102 }
103
104 if (priv->i->flags & ALPS_OLDPROTO) {
Yotam Medinid2f40122006-05-29 23:30:36 -0400105 left = packet[2] & 0x10;
106 right = packet[2] & 0x08;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107 middle = 0;
108 x = packet[1] | ((packet[0] & 0x07) << 7);
109 y = packet[4] | ((packet[3] & 0x07) << 7);
110 z = packet[5];
111 } else {
112 left = packet[3] & 1;
113 right = packet[3] & 2;
114 middle = packet[3] & 4;
115 x = packet[1] | ((packet[2] & 0x78) << (7 - 3));
116 y = packet[4] | ((packet[3] & 0x70) << (7 - 4));
117 z = packet[5];
118 }
119
Ivan Casado Ruizc30b4c12005-06-01 02:39:18 -0500120 if (priv->i->flags & ALPS_FW_BK_1) {
Laszlo Kajan3c00bb92008-03-18 00:39:55 -0400121 back = packet[0] & 0x10;
122 forward = packet[2] & 4;
Ivan Casado Ruizc30b4c12005-06-01 02:39:18 -0500123 }
124
125 if (priv->i->flags & ALPS_FW_BK_2) {
126 back = packet[3] & 4;
127 forward = packet[2] & 4;
128 if ((middle = forward && back))
129 forward = back = 0;
130 }
131
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132 ges = packet[2] & 1;
133 fin = packet[2] & 2;
134
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135 if ((priv->i->flags & ALPS_DUALPOINT) && z == 127) {
136 input_report_rel(dev2, REL_X, (x > 383 ? (x - 768) : x));
137 input_report_rel(dev2, REL_Y, -(y > 255 ? (y - 512) : y));
Ulrich Dangeld7ed5d82009-06-11 00:15:09 -0700138
139 input_report_key(dev2, BTN_LEFT, left);
140 input_report_key(dev2, BTN_RIGHT, right);
141 input_report_key(dev2, BTN_MIDDLE, middle);
142
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143 input_sync(dev);
144 input_sync(dev2);
145 return;
146 }
147
Ulrich Dangeld7ed5d82009-06-11 00:15:09 -0700148 input_report_key(dev, BTN_LEFT, left);
149 input_report_key(dev, BTN_RIGHT, right);
150 input_report_key(dev, BTN_MIDDLE, middle);
151
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152 /* Convert hardware tap to a reasonable Z value */
153 if (ges && !fin) z = 40;
154
155 /*
156 * A "tap and drag" operation is reported by the hardware as a transition
157 * from (!fin && ges) to (fin && ges). This should be translated to the
158 * sequence Z>0, Z==0, Z>0, so the Z==0 event has to be generated manually.
159 */
160 if (ges && fin && !priv->prev_fin) {
161 input_report_abs(dev, ABS_X, x);
162 input_report_abs(dev, ABS_Y, y);
163 input_report_abs(dev, ABS_PRESSURE, 0);
164 input_report_key(dev, BTN_TOOL_FINGER, 0);
165 input_sync(dev);
166 }
167 priv->prev_fin = fin;
168
169 if (z > 30) input_report_key(dev, BTN_TOUCH, 1);
170 if (z < 25) input_report_key(dev, BTN_TOUCH, 0);
171
172 if (z > 0) {
173 input_report_abs(dev, ABS_X, x);
174 input_report_abs(dev, ABS_Y, y);
175 }
176
177 input_report_abs(dev, ABS_PRESSURE, z);
178 input_report_key(dev, BTN_TOOL_FINGER, z > 0);
179
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180 if (priv->i->flags & ALPS_WHEEL)
Vojtech Pavlike6c047b2005-09-04 01:40:43 -0500181 input_report_rel(dev, REL_WHEEL, ((packet[2] << 1) & 0x08) - ((packet[0] >> 4) & 0x07));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182
Ivan Casado Ruizc30b4c12005-06-01 02:39:18 -0500183 if (priv->i->flags & (ALPS_FW_BK_1 | ALPS_FW_BK_2)) {
184 input_report_key(dev, BTN_FORWARD, forward);
185 input_report_key(dev, BTN_BACK, back);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186 }
187
188 input_sync(dev);
189}
190
David Howells7d12e782006-10-05 14:55:46 +0100191static psmouse_ret_t alps_process_byte(struct psmouse *psmouse)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192{
193 struct alps_data *priv = psmouse->private;
194
195 if ((psmouse->packet[0] & 0xc8) == 0x08) { /* PS/2 packet */
196 if (psmouse->pktcnt == 3) {
David Howells7d12e782006-10-05 14:55:46 +0100197 alps_process_packet(psmouse);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198 return PSMOUSE_FULL_PACKET;
199 }
200 return PSMOUSE_GOOD_DATA;
201 }
202
203 if ((psmouse->packet[0] & priv->i->mask0) != priv->i->byte0)
204 return PSMOUSE_BAD_DATA;
205
206 /* Bytes 2 - 6 should have 0 in the highest bit */
207 if (psmouse->pktcnt >= 2 && psmouse->pktcnt <= 6 &&
208 (psmouse->packet[psmouse->pktcnt - 1] & 0x80))
209 return PSMOUSE_BAD_DATA;
210
211 if (psmouse->pktcnt == 6) {
David Howells7d12e782006-10-05 14:55:46 +0100212 alps_process_packet(psmouse);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 return PSMOUSE_FULL_PACKET;
214 }
215
216 return PSMOUSE_GOOD_DATA;
217}
218
Helge Dellere38de672006-09-10 21:54:39 -0400219static const struct alps_model_info *alps_get_model(struct psmouse *psmouse, int *version)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220{
221 struct ps2dev *ps2dev = &psmouse->ps2dev;
Helge Dellere38de672006-09-10 21:54:39 -0400222 static const unsigned char rates[] = { 0, 10, 20, 40, 60, 80, 100, 200 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223 unsigned char param[4];
224 int i;
225
226 /*
227 * First try "E6 report".
228 * ALPS should return 0,0,10 or 0,0,100
229 */
230 param[0] = 0;
231 if (ps2_command(ps2dev, param, PSMOUSE_CMD_SETRES) ||
232 ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE11) ||
233 ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE11) ||
234 ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE11))
235 return NULL;
236
237 param[0] = param[1] = param[2] = 0xff;
238 if (ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO))
239 return NULL;
240
241 dbg("E6 report: %2.2x %2.2x %2.2x", param[0], param[1], param[2]);
242
243 if (param[0] != 0 || param[1] != 0 || (param[2] != 10 && param[2] != 100))
244 return NULL;
245
246 /*
247 * Now try "E7 report". Allowed responses are in
248 * alps_model_data[].signature
249 */
250 param[0] = 0;
251 if (ps2_command(ps2dev, param, PSMOUSE_CMD_SETRES) ||
252 ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE21) ||
253 ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE21) ||
254 ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE21))
255 return NULL;
256
257 param[0] = param[1] = param[2] = 0xff;
258 if (ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO))
259 return NULL;
260
261 dbg("E7 report: %2.2x %2.2x %2.2x", param[0], param[1], param[2]);
262
Dmitry Torokhov1e0c5b12007-05-14 23:51:54 -0400263 if (version) {
264 for (i = 0; i < ARRAY_SIZE(rates) && param[2] != rates[i]; i++)
265 /* empty */;
266 *version = (param[0] << 8) | (param[1] << 4) | i;
267 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268
269 for (i = 0; i < ARRAY_SIZE(alps_model_data); i++)
Dmitry Torokhov1e0c5b12007-05-14 23:51:54 -0400270 if (!memcmp(param, alps_model_data[i].signature,
271 sizeof(alps_model_data[i].signature)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272 return alps_model_data + i;
273
274 return NULL;
275}
276
277/*
278 * For DualPoint devices select the device that should respond to
279 * subsequent commands. It looks like glidepad is behind stickpointer,
280 * I'd thought it would be other way around...
281 */
Dmitry Torokhovb7802c52009-09-09 19:13:20 -0700282static int alps_passthrough_mode(struct psmouse *psmouse, bool enable)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283{
284 struct ps2dev *ps2dev = &psmouse->ps2dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285 int cmd = enable ? PSMOUSE_CMD_SETSCALE21 : PSMOUSE_CMD_SETSCALE11;
286
287 if (ps2_command(ps2dev, NULL, cmd) ||
288 ps2_command(ps2dev, NULL, cmd) ||
289 ps2_command(ps2dev, NULL, cmd) ||
290 ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE))
291 return -1;
292
293 /* we may get 3 more bytes, just ignore them */
Dmitry Torokhovc6117632005-06-01 02:39:51 -0500294 ps2_drain(ps2dev, 3, 100);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295
296 return 0;
297}
298
299static int alps_absolute_mode(struct psmouse *psmouse)
300{
301 struct ps2dev *ps2dev = &psmouse->ps2dev;
302
303 /* Try ALPS magic knock - 4 disable before enable */
304 if (ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE) ||
305 ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE) ||
306 ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE) ||
307 ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE) ||
308 ps2_command(ps2dev, NULL, PSMOUSE_CMD_ENABLE))
309 return -1;
310
311 /*
312 * Switch mouse to poll (remote) mode so motion data will not
313 * get in our way
314 */
315 return ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_SETPOLL);
316}
317
318static int alps_get_status(struct psmouse *psmouse, char *param)
319{
320 struct ps2dev *ps2dev = &psmouse->ps2dev;
321
322 /* Get status: 0xF5 0xF5 0xF5 0xE9 */
323 if (ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE) ||
324 ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE) ||
325 ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE) ||
326 ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO))
327 return -1;
328
329 dbg("Status: %2.2x %2.2x %2.2x", param[0], param[1], param[2]);
330
331 return 0;
332}
333
334/*
335 * Turn touchpad tapping on or off. The sequences are:
336 * 0xE9 0xF5 0xF5 0xF3 0x0A to enable,
337 * 0xE9 0xF5 0xF5 0xE8 0x00 to disable.
338 * My guess that 0xE9 (GetInfo) is here as a sync point.
339 * For models that also have stickpointer (DualPoints) its tapping
340 * is controlled separately (0xE6 0xE6 0xE6 0xF3 0x14|0x0A) but
341 * we don't fiddle with it.
342 */
343static int alps_tap_mode(struct psmouse *psmouse, int enable)
344{
345 struct ps2dev *ps2dev = &psmouse->ps2dev;
346 int cmd = enable ? PSMOUSE_CMD_SETRATE : PSMOUSE_CMD_SETRES;
347 unsigned char tap_arg = enable ? 0x0A : 0x00;
348 unsigned char param[4];
349
350 if (ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO) ||
351 ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE) ||
352 ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE) ||
353 ps2_command(ps2dev, &tap_arg, cmd))
354 return -1;
355
356 if (alps_get_status(psmouse, param))
357 return -1;
358
359 return 0;
360}
361
Dmitry Torokhovf0d5c6f2006-01-14 00:27:37 -0500362/*
363 * alps_poll() - poll the touchpad for current motion packet.
364 * Used in resync.
365 */
366static int alps_poll(struct psmouse *psmouse)
367{
368 struct alps_data *priv = psmouse->private;
369 unsigned char buf[6];
Dmitry Torokhovb7802c52009-09-09 19:13:20 -0700370 bool poll_failed;
Dmitry Torokhovf0d5c6f2006-01-14 00:27:37 -0500371
372 if (priv->i->flags & ALPS_PASS)
Dmitry Torokhovb7802c52009-09-09 19:13:20 -0700373 alps_passthrough_mode(psmouse, true);
Dmitry Torokhovf0d5c6f2006-01-14 00:27:37 -0500374
375 poll_failed = ps2_command(&psmouse->ps2dev, buf,
376 PSMOUSE_CMD_POLL | (psmouse->pktsize << 8)) < 0;
377
378 if (priv->i->flags & ALPS_PASS)
Dmitry Torokhovb7802c52009-09-09 19:13:20 -0700379 alps_passthrough_mode(psmouse, false);
Dmitry Torokhovf0d5c6f2006-01-14 00:27:37 -0500380
381 if (poll_failed || (buf[0] & priv->i->mask0) != priv->i->byte0)
382 return -1;
383
384 if ((psmouse->badbyte & 0xc8) == 0x08) {
385/*
386 * Poll the track stick ...
387 */
388 if (ps2_command(&psmouse->ps2dev, buf, PSMOUSE_CMD_POLL | (3 << 8)))
389 return -1;
390 }
391
392 memcpy(psmouse->packet, buf, sizeof(buf));
393 return 0;
394}
395
Dmitry Torokhov1e0c5b12007-05-14 23:51:54 -0400396static int alps_hw_init(struct psmouse *psmouse, int *version)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397{
398 struct alps_data *priv = psmouse->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399
Dmitry Torokhov1e0c5b12007-05-14 23:51:54 -0400400 priv->i = alps_get_model(psmouse, version);
401 if (!priv->i)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 return -1;
403
Dmitry Torokhovb7802c52009-09-09 19:13:20 -0700404 if ((priv->i->flags & ALPS_PASS) &&
405 alps_passthrough_mode(psmouse, true)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406 return -1;
Dmitry Torokhovb7802c52009-09-09 19:13:20 -0700407 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408
Dmitry Torokhovb7802c52009-09-09 19:13:20 -0700409 if (alps_tap_mode(psmouse, true)) {
Dmitry Torokhov1e0c5b12007-05-14 23:51:54 -0400410 printk(KERN_WARNING "alps.c: Failed to enable hardware tapping\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411 return -1;
Peter Osterlund963f6262005-07-11 01:08:04 -0500412 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413
414 if (alps_absolute_mode(psmouse)) {
Dmitry Torokhov1e0c5b12007-05-14 23:51:54 -0400415 printk(KERN_ERR "alps.c: Failed to enable absolute mode\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 return -1;
417 }
418
Dmitry Torokhovb7802c52009-09-09 19:13:20 -0700419 if ((priv->i->flags & ALPS_PASS) &&
420 alps_passthrough_mode(psmouse, false)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421 return -1;
Dmitry Torokhovb7802c52009-09-09 19:13:20 -0700422 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423
Dmitry Torokhov1e0c5b12007-05-14 23:51:54 -0400424 /* ALPS needs stream mode, otherwise it won't report any data */
425 if (ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_SETSTREAM)) {
426 printk(KERN_ERR "alps.c: Failed to enable stream mode\n");
427 return -1;
428 }
429
430 return 0;
431}
432
433static int alps_reconnect(struct psmouse *psmouse)
434{
435 psmouse_reset(psmouse);
436
437 if (alps_hw_init(psmouse, NULL))
438 return -1;
439
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 return 0;
441}
442
443static void alps_disconnect(struct psmouse *psmouse)
444{
445 struct alps_data *priv = psmouse->private;
Dmitry Torokhov2e5b6362005-09-15 02:01:44 -0500446
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447 psmouse_reset(psmouse);
Dmitry Torokhov2e5b6362005-09-15 02:01:44 -0500448 input_unregister_device(priv->dev2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449 kfree(priv);
450}
451
452int alps_init(struct psmouse *psmouse)
453{
454 struct alps_data *priv;
Dmitry Torokhov2e5b6362005-09-15 02:01:44 -0500455 struct input_dev *dev1 = psmouse->dev, *dev2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456 int version;
457
Dmitry Torokhovf42649e2007-04-12 01:31:13 -0400458 priv = kzalloc(sizeof(struct alps_data), GFP_KERNEL);
Dmitry Torokhov2e5b6362005-09-15 02:01:44 -0500459 dev2 = input_allocate_device();
460 if (!priv || !dev2)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461 goto init_fail;
Dmitry Torokhov2e5b6362005-09-15 02:01:44 -0500462
463 priv->dev2 = dev2;
Dmitry Torokhov1e0c5b12007-05-14 23:51:54 -0400464 psmouse->private = priv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465
Dmitry Torokhov1e0c5b12007-05-14 23:51:54 -0400466 if (alps_hw_init(psmouse, &version))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467 goto init_fail;
468
Jiri Slaby7b19ada2007-10-18 23:40:32 -0700469 dev1->evbit[BIT_WORD(EV_KEY)] |= BIT_MASK(EV_KEY);
470 dev1->keybit[BIT_WORD(BTN_TOUCH)] |= BIT_MASK(BTN_TOUCH);
471 dev1->keybit[BIT_WORD(BTN_TOOL_FINGER)] |= BIT_MASK(BTN_TOOL_FINGER);
472 dev1->keybit[BIT_WORD(BTN_LEFT)] |= BIT_MASK(BTN_LEFT) |
473 BIT_MASK(BTN_MIDDLE) | BIT_MASK(BTN_RIGHT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474
Jiri Slaby7b19ada2007-10-18 23:40:32 -0700475 dev1->evbit[BIT_WORD(EV_ABS)] |= BIT_MASK(EV_ABS);
Dmitry Torokhov2e5b6362005-09-15 02:01:44 -0500476 input_set_abs_params(dev1, ABS_X, 0, 1023, 0, 0);
477 input_set_abs_params(dev1, ABS_Y, 0, 767, 0, 0);
478 input_set_abs_params(dev1, ABS_PRESSURE, 0, 127, 0, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479
480 if (priv->i->flags & ALPS_WHEEL) {
Jiri Slaby7b19ada2007-10-18 23:40:32 -0700481 dev1->evbit[BIT_WORD(EV_REL)] |= BIT_MASK(EV_REL);
482 dev1->relbit[BIT_WORD(REL_WHEEL)] |= BIT_MASK(REL_WHEEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483 }
484
Ivan Casado Ruizc30b4c12005-06-01 02:39:18 -0500485 if (priv->i->flags & (ALPS_FW_BK_1 | ALPS_FW_BK_2)) {
Jiri Slaby7b19ada2007-10-18 23:40:32 -0700486 dev1->keybit[BIT_WORD(BTN_FORWARD)] |= BIT_MASK(BTN_FORWARD);
487 dev1->keybit[BIT_WORD(BTN_BACK)] |= BIT_MASK(BTN_BACK);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488 }
489
Dmitry Torokhov08ffce42006-06-26 01:45:10 -0400490 snprintf(priv->phys, sizeof(priv->phys), "%s/input1", psmouse->ps2dev.serio->phys);
Dmitry Torokhov2e5b6362005-09-15 02:01:44 -0500491 dev2->phys = priv->phys;
492 dev2->name = (priv->i->flags & ALPS_DUALPOINT) ? "DualPoint Stick" : "PS/2 Mouse";
493 dev2->id.bustype = BUS_I8042;
494 dev2->id.vendor = 0x0002;
495 dev2->id.product = PSMOUSE_ALPS;
496 dev2->id.version = 0x0000;
Dmitry Torokhov1db3a342008-03-18 00:29:18 -0400497 dev2->dev.parent = &psmouse->ps2dev.serio->dev;
Dmitry Torokhov968ac842005-05-29 02:28:29 -0500498
Jiri Slaby7b19ada2007-10-18 23:40:32 -0700499 dev2->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REL);
500 dev2->relbit[BIT_WORD(REL_X)] |= BIT_MASK(REL_X) | BIT_MASK(REL_Y);
501 dev2->keybit[BIT_WORD(BTN_LEFT)] |= BIT_MASK(BTN_LEFT) |
502 BIT_MASK(BTN_MIDDLE) | BIT_MASK(BTN_RIGHT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503
Dmitry Torokhovf42649e2007-04-12 01:31:13 -0400504 if (input_register_device(priv->dev2))
505 goto init_fail;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506
507 psmouse->protocol_handler = alps_process_byte;
Dmitry Torokhovf0d5c6f2006-01-14 00:27:37 -0500508 psmouse->poll = alps_poll;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509 psmouse->disconnect = alps_disconnect;
510 psmouse->reconnect = alps_reconnect;
511 psmouse->pktsize = 6;
512
Dmitry Torokhovf0d5c6f2006-01-14 00:27:37 -0500513 /* We are having trouble resyncing ALPS touchpads so disable it for now */
514 psmouse->resync_time = 0;
515
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516 return 0;
517
518init_fail:
Dmitry Torokhovf42649e2007-04-12 01:31:13 -0400519 psmouse_reset(psmouse);
Dmitry Torokhov2e5b6362005-09-15 02:01:44 -0500520 input_free_device(dev2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 kfree(priv);
Dmitry Torokhov1e0c5b12007-05-14 23:51:54 -0400522 psmouse->private = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523 return -1;
524}
525
Dmitry Torokhovb7802c52009-09-09 19:13:20 -0700526int alps_detect(struct psmouse *psmouse, bool set_properties)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527{
528 int version;
Helge Dellere38de672006-09-10 21:54:39 -0400529 const struct alps_model_info *model;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530
Dmitry Torokhovf42649e2007-04-12 01:31:13 -0400531 model = alps_get_model(psmouse, &version);
532 if (!model)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533 return -1;
534
535 if (set_properties) {
536 psmouse->vendor = "ALPS";
Dmitry Torokhov968ac842005-05-29 02:28:29 -0500537 psmouse->name = model->flags & ALPS_DUALPOINT ?
538 "DualPoint TouchPad" : "GlidePoint";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539 psmouse->model = version;
540 }
541 return 0;
542}
543