1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * OLPC HGPK (XO-1) touchpad PS/2 mouse driver |
4 | * |
5 | * Copyright (c) 2006-2008 One Laptop Per Child |
6 | * Authors: |
7 | * Zephaniah E. Hull |
8 | * Andres Salomon <dilinger@debian.org> |
9 | * |
10 | * This driver is partly based on the ALPS driver, which is: |
11 | * |
12 | * Copyright (c) 2003 Neil Brown <neilb@cse.unsw.edu.au> |
13 | * Copyright (c) 2003-2005 Peter Osterlund <petero2@telia.com> |
14 | * Copyright (c) 2004 Dmitry Torokhov <dtor@mail.ru> |
15 | * Copyright (c) 2005 Vojtech Pavlik <vojtech@suse.cz> |
16 | */ |
17 | |
18 | /* |
19 | * The spec from ALPS is available from |
20 | * <http://wiki.laptop.org/go/Touch_Pad/Tablet>. It refers to this |
21 | * device as HGPK (Hybrid GS, PT, and Keymatrix). |
22 | * |
23 | * The earliest versions of the device had simultaneous reporting; that |
24 | * was removed. After that, the device used the Advanced Mode GS/PT streaming |
25 | * stuff. That turned out to be too buggy to support, so we've finally |
26 | * switched to Mouse Mode (which utilizes only the center 1/3 of the touchpad). |
27 | */ |
28 | |
29 | #define DEBUG |
30 | #include <linux/slab.h> |
31 | #include <linux/input.h> |
32 | #include <linux/module.h> |
33 | #include <linux/serio.h> |
34 | #include <linux/libps2.h> |
35 | #include <linux/delay.h> |
36 | #include <asm/olpc.h> |
37 | |
38 | #include "psmouse.h" |
39 | #include "hgpk.h" |
40 | |
41 | #define ILLEGAL_XY 999999 |
42 | |
43 | static bool tpdebug; |
44 | module_param(tpdebug, bool, 0644); |
45 | MODULE_PARM_DESC(tpdebug, "enable debugging, dumping packets to KERN_DEBUG." ); |
46 | |
47 | static int recalib_delta = 100; |
48 | module_param(recalib_delta, int, 0644); |
49 | MODULE_PARM_DESC(recalib_delta, |
50 | "packets containing a delta this large will be discarded, and a " |
51 | "recalibration may be scheduled." ); |
52 | |
53 | static int jumpy_delay = 20; |
54 | module_param(jumpy_delay, int, 0644); |
55 | MODULE_PARM_DESC(jumpy_delay, |
56 | "delay (ms) before recal after jumpiness detected" ); |
57 | |
58 | static int spew_delay = 1; |
59 | module_param(spew_delay, int, 0644); |
60 | MODULE_PARM_DESC(spew_delay, |
61 | "delay (ms) before recal after packet spew detected" ); |
62 | |
63 | static int recal_guard_time; |
64 | module_param(recal_guard_time, int, 0644); |
65 | MODULE_PARM_DESC(recal_guard_time, |
66 | "interval (ms) during which recal will be restarted if packet received" ); |
67 | |
68 | static int post_interrupt_delay = 40; |
69 | module_param(post_interrupt_delay, int, 0644); |
70 | MODULE_PARM_DESC(post_interrupt_delay, |
71 | "delay (ms) before recal after recal interrupt detected" ); |
72 | |
73 | static bool autorecal = true; |
74 | module_param(autorecal, bool, 0644); |
75 | MODULE_PARM_DESC(autorecal, "enable recalibration in the driver" ); |
76 | |
77 | static char hgpk_mode_name[16]; |
78 | module_param_string(hgpk_mode, hgpk_mode_name, sizeof(hgpk_mode_name), 0644); |
79 | MODULE_PARM_DESC(hgpk_mode, |
80 | "default hgpk mode: mouse, glidesensor or pentablet" ); |
81 | |
82 | static int hgpk_default_mode = HGPK_MODE_MOUSE; |
83 | |
84 | static const char * const hgpk_mode_names[] = { |
85 | [HGPK_MODE_MOUSE] = "Mouse" , |
86 | [HGPK_MODE_GLIDESENSOR] = "GlideSensor" , |
87 | [HGPK_MODE_PENTABLET] = "PenTablet" , |
88 | }; |
89 | |
90 | static int hgpk_mode_from_name(const char *buf, int len) |
91 | { |
92 | int i; |
93 | |
94 | for (i = 0; i < ARRAY_SIZE(hgpk_mode_names); i++) { |
95 | const char *name = hgpk_mode_names[i]; |
96 | if (strlen(name) == len && !strncasecmp(s1: name, s2: buf, n: len)) |
97 | return i; |
98 | } |
99 | |
100 | return HGPK_MODE_INVALID; |
101 | } |
102 | |
103 | /* |
104 | * see if new value is within 20% of half of old value |
105 | */ |
106 | static int approx_half(int curr, int prev) |
107 | { |
108 | int belowhalf, abovehalf; |
109 | |
110 | if (curr < 5 || prev < 5) |
111 | return 0; |
112 | |
113 | belowhalf = (prev * 8) / 20; |
114 | abovehalf = (prev * 12) / 20; |
115 | |
116 | return belowhalf < curr && curr <= abovehalf; |
117 | } |
118 | |
119 | /* |
120 | * Throw out oddly large delta packets, and any that immediately follow whose |
121 | * values are each approximately half of the previous. It seems that the ALPS |
122 | * firmware emits errant packets, and they get averaged out slowly. |
123 | */ |
124 | static int hgpk_discard_decay_hack(struct psmouse *psmouse, int x, int y) |
125 | { |
126 | struct hgpk_data *priv = psmouse->private; |
127 | int avx, avy; |
128 | bool do_recal = false; |
129 | |
130 | avx = abs(x); |
131 | avy = abs(y); |
132 | |
133 | /* discard if too big, or half that but > 4 times the prev delta */ |
134 | if (avx > recalib_delta || |
135 | (avx > recalib_delta / 2 && ((avx / 4) > priv->xlast))) { |
136 | psmouse_warn(psmouse, "detected %dpx jump in x\n" , x); |
137 | priv->xbigj = avx; |
138 | } else if (approx_half(curr: avx, prev: priv->xbigj)) { |
139 | psmouse_warn(psmouse, "detected secondary %dpx jump in x\n" , x); |
140 | priv->xbigj = avx; |
141 | priv->xsaw_secondary++; |
142 | } else { |
143 | if (priv->xbigj && priv->xsaw_secondary > 1) |
144 | do_recal = true; |
145 | priv->xbigj = 0; |
146 | priv->xsaw_secondary = 0; |
147 | } |
148 | |
149 | if (avy > recalib_delta || |
150 | (avy > recalib_delta / 2 && ((avy / 4) > priv->ylast))) { |
151 | psmouse_warn(psmouse, "detected %dpx jump in y\n" , y); |
152 | priv->ybigj = avy; |
153 | } else if (approx_half(curr: avy, prev: priv->ybigj)) { |
154 | psmouse_warn(psmouse, "detected secondary %dpx jump in y\n" , y); |
155 | priv->ybigj = avy; |
156 | priv->ysaw_secondary++; |
157 | } else { |
158 | if (priv->ybigj && priv->ysaw_secondary > 1) |
159 | do_recal = true; |
160 | priv->ybigj = 0; |
161 | priv->ysaw_secondary = 0; |
162 | } |
163 | |
164 | priv->xlast = avx; |
165 | priv->ylast = avy; |
166 | |
167 | if (do_recal && jumpy_delay) { |
168 | psmouse_warn(psmouse, "scheduling recalibration\n" ); |
169 | psmouse_queue_work(psmouse, work: &priv->recalib_wq, |
170 | delay: msecs_to_jiffies(m: jumpy_delay)); |
171 | } |
172 | |
173 | return priv->xbigj || priv->ybigj; |
174 | } |
175 | |
176 | static void hgpk_reset_spew_detection(struct hgpk_data *priv) |
177 | { |
178 | priv->spew_count = 0; |
179 | priv->dupe_count = 0; |
180 | priv->x_tally = 0; |
181 | priv->y_tally = 0; |
182 | priv->spew_flag = NO_SPEW; |
183 | } |
184 | |
185 | static void hgpk_reset_hack_state(struct psmouse *psmouse) |
186 | { |
187 | struct hgpk_data *priv = psmouse->private; |
188 | |
189 | priv->abs_x = priv->abs_y = -1; |
190 | priv->xlast = priv->ylast = ILLEGAL_XY; |
191 | priv->xbigj = priv->ybigj = 0; |
192 | priv->xsaw_secondary = priv->ysaw_secondary = 0; |
193 | hgpk_reset_spew_detection(priv); |
194 | } |
195 | |
196 | /* |
197 | * We have no idea why this particular hardware bug occurs. The touchpad |
198 | * will randomly start spewing packets without anything touching the |
199 | * pad. This wouldn't necessarily be bad, but it's indicative of a |
200 | * severely miscalibrated pad; attempting to use the touchpad while it's |
201 | * spewing means the cursor will jump all over the place, and act "drunk". |
202 | * |
203 | * The packets that are spewed tend to all have deltas between -2 and 2, and |
204 | * the cursor will move around without really going very far. It will |
205 | * tend to end up in the same location; if we tally up the changes over |
206 | * 100 packets, we end up w/ a final delta of close to 0. This happens |
207 | * pretty regularly when the touchpad is spewing, and is pretty hard to |
208 | * manually trigger (at least for *my* fingers). So, it makes a perfect |
209 | * scheme for detecting spews. |
210 | */ |
211 | static void hgpk_spewing_hack(struct psmouse *psmouse, |
212 | int l, int r, int x, int y) |
213 | { |
214 | struct hgpk_data *priv = psmouse->private; |
215 | |
216 | /* ignore button press packets; many in a row could trigger |
217 | * a false-positive! */ |
218 | if (l || r) |
219 | return; |
220 | |
221 | /* don't track spew if the workaround feature has been turned off */ |
222 | if (!spew_delay) |
223 | return; |
224 | |
225 | if (abs(x) > 3 || abs(y) > 3) { |
226 | /* no spew, or spew ended */ |
227 | hgpk_reset_spew_detection(priv); |
228 | return; |
229 | } |
230 | |
231 | /* Keep a tally of the overall delta to the cursor position caused by |
232 | * the spew */ |
233 | priv->x_tally += x; |
234 | priv->y_tally += y; |
235 | |
236 | switch (priv->spew_flag) { |
237 | case NO_SPEW: |
238 | /* we're not spewing, but this packet might be the start */ |
239 | priv->spew_flag = MAYBE_SPEWING; |
240 | |
241 | fallthrough; |
242 | |
243 | case MAYBE_SPEWING: |
244 | priv->spew_count++; |
245 | |
246 | if (priv->spew_count < SPEW_WATCH_COUNT) |
247 | break; |
248 | |
249 | /* excessive spew detected, request recalibration */ |
250 | priv->spew_flag = SPEW_DETECTED; |
251 | |
252 | fallthrough; |
253 | |
254 | case SPEW_DETECTED: |
255 | /* only recalibrate when the overall delta to the cursor |
256 | * is really small. if the spew is causing significant cursor |
257 | * movement, it is probably a case of the user moving the |
258 | * cursor very slowly across the screen. */ |
259 | if (abs(priv->x_tally) < 3 && abs(priv->y_tally) < 3) { |
260 | psmouse_warn(psmouse, "packet spew detected (%d,%d)\n" , |
261 | priv->x_tally, priv->y_tally); |
262 | priv->spew_flag = RECALIBRATING; |
263 | psmouse_queue_work(psmouse, work: &priv->recalib_wq, |
264 | delay: msecs_to_jiffies(m: spew_delay)); |
265 | } |
266 | |
267 | break; |
268 | case RECALIBRATING: |
269 | /* we already detected a spew and requested a recalibration, |
270 | * just wait for the queue to kick into action. */ |
271 | break; |
272 | } |
273 | } |
274 | |
275 | /* |
276 | * HGPK Mouse Mode format (standard mouse format, sans middle button) |
277 | * |
278 | * byte 0: y-over x-over y-neg x-neg 1 0 swr swl |
279 | * byte 1: x7 x6 x5 x4 x3 x2 x1 x0 |
280 | * byte 2: y7 y6 y5 y4 y3 y2 y1 y0 |
281 | * |
282 | * swr/swl are the left/right buttons. |
283 | * x-neg/y-neg are the x and y delta negative bits |
284 | * x-over/y-over are the x and y overflow bits |
285 | * |
286 | * --- |
287 | * |
288 | * HGPK Advanced Mode - single-mode format |
289 | * |
290 | * byte 0(PT): 1 1 0 0 1 1 1 1 |
291 | * byte 0(GS): 1 1 1 1 1 1 1 1 |
292 | * byte 1: 0 x6 x5 x4 x3 x2 x1 x0 |
293 | * byte 2(PT): 0 0 x9 x8 x7 ? pt-dsw 0 |
294 | * byte 2(GS): 0 x10 x9 x8 x7 ? gs-dsw pt-dsw |
295 | * byte 3: 0 y9 y8 y7 1 0 swr swl |
296 | * byte 4: 0 y6 y5 y4 y3 y2 y1 y0 |
297 | * byte 5: 0 z6 z5 z4 z3 z2 z1 z0 |
298 | * |
299 | * ?'s are not defined in the protocol spec, may vary between models. |
300 | * |
301 | * swr/swl are the left/right buttons. |
302 | * |
303 | * pt-dsw/gs-dsw indicate that the pt/gs sensor is detecting a |
304 | * pen/finger |
305 | */ |
306 | static bool hgpk_is_byte_valid(struct psmouse *psmouse, unsigned char *packet) |
307 | { |
308 | struct hgpk_data *priv = psmouse->private; |
309 | int pktcnt = psmouse->pktcnt; |
310 | bool valid; |
311 | |
312 | switch (priv->mode) { |
313 | case HGPK_MODE_MOUSE: |
314 | valid = (packet[0] & 0x0C) == 0x08; |
315 | break; |
316 | |
317 | case HGPK_MODE_GLIDESENSOR: |
318 | valid = pktcnt == 1 ? |
319 | packet[0] == HGPK_GS : !(packet[pktcnt - 1] & 0x80); |
320 | break; |
321 | |
322 | case HGPK_MODE_PENTABLET: |
323 | valid = pktcnt == 1 ? |
324 | packet[0] == HGPK_PT : !(packet[pktcnt - 1] & 0x80); |
325 | break; |
326 | |
327 | default: |
328 | valid = false; |
329 | break; |
330 | } |
331 | |
332 | if (!valid) |
333 | psmouse_dbg(psmouse, |
334 | "bad data, mode %d (%d) %*ph\n" , |
335 | priv->mode, pktcnt, 6, psmouse->packet); |
336 | |
337 | return valid; |
338 | } |
339 | |
340 | static void hgpk_process_advanced_packet(struct psmouse *psmouse) |
341 | { |
342 | struct hgpk_data *priv = psmouse->private; |
343 | struct input_dev *idev = psmouse->dev; |
344 | unsigned char *packet = psmouse->packet; |
345 | int down = !!(packet[2] & 2); |
346 | int left = !!(packet[3] & 1); |
347 | int right = !!(packet[3] & 2); |
348 | int x = packet[1] | ((packet[2] & 0x78) << 4); |
349 | int y = packet[4] | ((packet[3] & 0x70) << 3); |
350 | |
351 | if (priv->mode == HGPK_MODE_GLIDESENSOR) { |
352 | int pt_down = !!(packet[2] & 1); |
353 | int finger_down = !!(packet[2] & 2); |
354 | int z = packet[5]; |
355 | |
356 | input_report_abs(dev: idev, ABS_PRESSURE, value: z); |
357 | if (tpdebug) |
358 | psmouse_dbg(psmouse, "pd=%d fd=%d z=%d" , |
359 | pt_down, finger_down, z); |
360 | } else { |
361 | /* |
362 | * PenTablet mode does not report pressure, so we don't |
363 | * report it here |
364 | */ |
365 | if (tpdebug) |
366 | psmouse_dbg(psmouse, "pd=%d " , down); |
367 | } |
368 | |
369 | if (tpdebug) |
370 | psmouse_dbg(psmouse, "l=%d r=%d x=%d y=%d\n" , |
371 | left, right, x, y); |
372 | |
373 | input_report_key(dev: idev, BTN_TOUCH, value: down); |
374 | input_report_key(dev: idev, BTN_LEFT, value: left); |
375 | input_report_key(dev: idev, BTN_RIGHT, value: right); |
376 | |
377 | /* |
378 | * If this packet says that the finger was removed, reset our position |
379 | * tracking so that we don't erroneously detect a jump on next press. |
380 | */ |
381 | if (!down) { |
382 | hgpk_reset_hack_state(psmouse); |
383 | goto done; |
384 | } |
385 | |
386 | /* |
387 | * Weed out duplicate packets (we get quite a few, and they mess up |
388 | * our jump detection) |
389 | */ |
390 | if (x == priv->abs_x && y == priv->abs_y) { |
391 | if (++priv->dupe_count > SPEW_WATCH_COUNT) { |
392 | if (tpdebug) |
393 | psmouse_dbg(psmouse, "hard spew detected\n" ); |
394 | priv->spew_flag = RECALIBRATING; |
395 | psmouse_queue_work(psmouse, work: &priv->recalib_wq, |
396 | delay: msecs_to_jiffies(m: spew_delay)); |
397 | } |
398 | goto done; |
399 | } |
400 | |
401 | /* not a duplicate, continue with position reporting */ |
402 | priv->dupe_count = 0; |
403 | |
404 | /* Don't apply hacks in PT mode, it seems reliable */ |
405 | if (priv->mode != HGPK_MODE_PENTABLET && priv->abs_x != -1) { |
406 | int x_diff = priv->abs_x - x; |
407 | int y_diff = priv->abs_y - y; |
408 | if (hgpk_discard_decay_hack(psmouse, x: x_diff, y: y_diff)) { |
409 | if (tpdebug) |
410 | psmouse_dbg(psmouse, "discarding\n" ); |
411 | goto done; |
412 | } |
413 | hgpk_spewing_hack(psmouse, l: left, r: right, x: x_diff, y: y_diff); |
414 | } |
415 | |
416 | input_report_abs(dev: idev, ABS_X, value: x); |
417 | input_report_abs(dev: idev, ABS_Y, value: y); |
418 | priv->abs_x = x; |
419 | priv->abs_y = y; |
420 | |
421 | done: |
422 | input_sync(dev: idev); |
423 | } |
424 | |
425 | static void hgpk_process_simple_packet(struct psmouse *psmouse) |
426 | { |
427 | struct input_dev *dev = psmouse->dev; |
428 | unsigned char *packet = psmouse->packet; |
429 | int left = packet[0] & 1; |
430 | int right = (packet[0] >> 1) & 1; |
431 | int x = packet[1] - ((packet[0] << 4) & 0x100); |
432 | int y = ((packet[0] << 3) & 0x100) - packet[2]; |
433 | |
434 | if (packet[0] & 0xc0) |
435 | psmouse_dbg(psmouse, |
436 | "overflow -- 0x%02x 0x%02x 0x%02x\n" , |
437 | packet[0], packet[1], packet[2]); |
438 | |
439 | if (hgpk_discard_decay_hack(psmouse, x, y)) { |
440 | if (tpdebug) |
441 | psmouse_dbg(psmouse, "discarding\n" ); |
442 | return; |
443 | } |
444 | |
445 | hgpk_spewing_hack(psmouse, l: left, r: right, x, y); |
446 | |
447 | if (tpdebug) |
448 | psmouse_dbg(psmouse, "l=%d r=%d x=%d y=%d\n" , |
449 | left, right, x, y); |
450 | |
451 | input_report_key(dev, BTN_LEFT, value: left); |
452 | input_report_key(dev, BTN_RIGHT, value: right); |
453 | |
454 | input_report_rel(dev, REL_X, value: x); |
455 | input_report_rel(dev, REL_Y, value: y); |
456 | |
457 | input_sync(dev); |
458 | } |
459 | |
460 | static psmouse_ret_t hgpk_process_byte(struct psmouse *psmouse) |
461 | { |
462 | struct hgpk_data *priv = psmouse->private; |
463 | |
464 | if (!hgpk_is_byte_valid(psmouse, packet: psmouse->packet)) |
465 | return PSMOUSE_BAD_DATA; |
466 | |
467 | if (psmouse->pktcnt >= psmouse->pktsize) { |
468 | if (priv->mode == HGPK_MODE_MOUSE) |
469 | hgpk_process_simple_packet(psmouse); |
470 | else |
471 | hgpk_process_advanced_packet(psmouse); |
472 | return PSMOUSE_FULL_PACKET; |
473 | } |
474 | |
475 | if (priv->recalib_window) { |
476 | if (time_before(jiffies, priv->recalib_window)) { |
477 | /* |
478 | * ugh, got a packet inside our recalibration |
479 | * window, schedule another recalibration. |
480 | */ |
481 | psmouse_dbg(psmouse, |
482 | "packet inside calibration window, queueing another recalibration\n" ); |
483 | psmouse_queue_work(psmouse, work: &priv->recalib_wq, |
484 | delay: msecs_to_jiffies(m: post_interrupt_delay)); |
485 | } |
486 | priv->recalib_window = 0; |
487 | } |
488 | |
489 | return PSMOUSE_GOOD_DATA; |
490 | } |
491 | |
492 | static int hgpk_select_mode(struct psmouse *psmouse) |
493 | { |
494 | struct ps2dev *ps2dev = &psmouse->ps2dev; |
495 | struct hgpk_data *priv = psmouse->private; |
496 | int i; |
497 | int cmd; |
498 | |
499 | /* |
500 | * 4 disables to enable advanced mode |
501 | * then 3 0xf2 bytes as the preamble for GS/PT selection |
502 | */ |
503 | const int advanced_init[] = { |
504 | PSMOUSE_CMD_DISABLE, PSMOUSE_CMD_DISABLE, |
505 | PSMOUSE_CMD_DISABLE, PSMOUSE_CMD_DISABLE, |
506 | 0xf2, 0xf2, 0xf2, |
507 | }; |
508 | |
509 | switch (priv->mode) { |
510 | case HGPK_MODE_MOUSE: |
511 | psmouse->pktsize = 3; |
512 | break; |
513 | |
514 | case HGPK_MODE_GLIDESENSOR: |
515 | case HGPK_MODE_PENTABLET: |
516 | psmouse->pktsize = 6; |
517 | |
518 | /* Switch to 'Advanced mode.', four disables in a row. */ |
519 | for (i = 0; i < ARRAY_SIZE(advanced_init); i++) |
520 | if (ps2_command(ps2dev, NULL, command: advanced_init[i])) |
521 | return -EIO; |
522 | |
523 | /* select between GlideSensor (mouse) or PenTablet */ |
524 | cmd = priv->mode == HGPK_MODE_GLIDESENSOR ? |
525 | PSMOUSE_CMD_SETSCALE11 : PSMOUSE_CMD_SETSCALE21; |
526 | |
527 | if (ps2_command(ps2dev, NULL, command: cmd)) |
528 | return -EIO; |
529 | break; |
530 | |
531 | default: |
532 | return -EINVAL; |
533 | } |
534 | |
535 | return 0; |
536 | } |
537 | |
538 | static void hgpk_setup_input_device(struct input_dev *input, |
539 | struct input_dev *old_input, |
540 | enum hgpk_mode mode) |
541 | { |
542 | if (old_input) { |
543 | input->name = old_input->name; |
544 | input->phys = old_input->phys; |
545 | input->id = old_input->id; |
546 | input->dev.parent = old_input->dev.parent; |
547 | } |
548 | |
549 | memset(input->evbit, 0, sizeof(input->evbit)); |
550 | memset(input->relbit, 0, sizeof(input->relbit)); |
551 | memset(input->keybit, 0, sizeof(input->keybit)); |
552 | |
553 | /* All modes report left and right buttons */ |
554 | __set_bit(EV_KEY, input->evbit); |
555 | __set_bit(BTN_LEFT, input->keybit); |
556 | __set_bit(BTN_RIGHT, input->keybit); |
557 | |
558 | switch (mode) { |
559 | case HGPK_MODE_MOUSE: |
560 | __set_bit(EV_REL, input->evbit); |
561 | __set_bit(REL_X, input->relbit); |
562 | __set_bit(REL_Y, input->relbit); |
563 | break; |
564 | |
565 | case HGPK_MODE_GLIDESENSOR: |
566 | __set_bit(BTN_TOUCH, input->keybit); |
567 | __set_bit(BTN_TOOL_FINGER, input->keybit); |
568 | |
569 | __set_bit(EV_ABS, input->evbit); |
570 | |
571 | /* GlideSensor has pressure sensor, PenTablet does not */ |
572 | input_set_abs_params(dev: input, ABS_PRESSURE, min: 0, max: 15, fuzz: 0, flat: 0); |
573 | |
574 | /* From device specs */ |
575 | input_set_abs_params(dev: input, ABS_X, min: 0, max: 399, fuzz: 0, flat: 0); |
576 | input_set_abs_params(dev: input, ABS_Y, min: 0, max: 290, fuzz: 0, flat: 0); |
577 | |
578 | /* Calculated by hand based on usable size (52mm x 38mm) */ |
579 | input_abs_set_res(dev: input, ABS_X, val: 8); |
580 | input_abs_set_res(dev: input, ABS_Y, val: 8); |
581 | break; |
582 | |
583 | case HGPK_MODE_PENTABLET: |
584 | __set_bit(BTN_TOUCH, input->keybit); |
585 | __set_bit(BTN_TOOL_FINGER, input->keybit); |
586 | |
587 | __set_bit(EV_ABS, input->evbit); |
588 | |
589 | /* From device specs */ |
590 | input_set_abs_params(dev: input, ABS_X, min: 0, max: 999, fuzz: 0, flat: 0); |
591 | input_set_abs_params(dev: input, ABS_Y, min: 5, max: 239, fuzz: 0, flat: 0); |
592 | |
593 | /* Calculated by hand based on usable size (156mm x 38mm) */ |
594 | input_abs_set_res(dev: input, ABS_X, val: 6); |
595 | input_abs_set_res(dev: input, ABS_Y, val: 8); |
596 | break; |
597 | |
598 | default: |
599 | BUG(); |
600 | } |
601 | } |
602 | |
603 | static int hgpk_reset_device(struct psmouse *psmouse, bool recalibrate) |
604 | { |
605 | int err; |
606 | |
607 | psmouse_reset(psmouse); |
608 | |
609 | if (recalibrate) { |
610 | struct ps2dev *ps2dev = &psmouse->ps2dev; |
611 | |
612 | /* send the recalibrate request */ |
613 | if (ps2_command(ps2dev, NULL, command: 0xf5) || |
614 | ps2_command(ps2dev, NULL, command: 0xf5) || |
615 | ps2_command(ps2dev, NULL, command: 0xe6) || |
616 | ps2_command(ps2dev, NULL, command: 0xf5)) { |
617 | return -1; |
618 | } |
619 | |
620 | /* according to ALPS, 150mS is required for recalibration */ |
621 | msleep(msecs: 150); |
622 | } |
623 | |
624 | err = hgpk_select_mode(psmouse); |
625 | if (err) { |
626 | psmouse_err(psmouse, "failed to select mode\n" ); |
627 | return err; |
628 | } |
629 | |
630 | hgpk_reset_hack_state(psmouse); |
631 | |
632 | return 0; |
633 | } |
634 | |
635 | static int hgpk_force_recalibrate(struct psmouse *psmouse) |
636 | { |
637 | struct hgpk_data *priv = psmouse->private; |
638 | int err; |
639 | |
640 | /* C-series touchpads added the recalibrate command */ |
641 | if (psmouse->model < HGPK_MODEL_C) |
642 | return 0; |
643 | |
644 | if (!autorecal) { |
645 | psmouse_dbg(psmouse, "recalibration disabled, ignoring\n" ); |
646 | return 0; |
647 | } |
648 | |
649 | psmouse_dbg(psmouse, "recalibrating touchpad..\n" ); |
650 | |
651 | /* we don't want to race with the irq handler, nor with resyncs */ |
652 | psmouse_set_state(psmouse, new_state: PSMOUSE_INITIALIZING); |
653 | |
654 | /* start by resetting the device */ |
655 | err = hgpk_reset_device(psmouse, recalibrate: true); |
656 | if (err) |
657 | return err; |
658 | |
659 | /* |
660 | * XXX: If a finger is down during this delay, recalibration will |
661 | * detect capacitance incorrectly. This is a hardware bug, and |
662 | * we don't have a good way to deal with it. The 2s window stuff |
663 | * (below) is our best option for now. |
664 | */ |
665 | if (psmouse_activate(psmouse)) |
666 | return -1; |
667 | |
668 | if (tpdebug) |
669 | psmouse_dbg(psmouse, "touchpad reactivated\n" ); |
670 | |
671 | /* |
672 | * If we get packets right away after recalibrating, it's likely |
673 | * that a finger was on the touchpad. If so, it's probably |
674 | * miscalibrated, so we optionally schedule another. |
675 | */ |
676 | if (recal_guard_time) |
677 | priv->recalib_window = jiffies + |
678 | msecs_to_jiffies(m: recal_guard_time); |
679 | |
680 | return 0; |
681 | } |
682 | |
683 | /* |
684 | * This puts the touchpad in a power saving mode; according to ALPS, current |
685 | * consumption goes down to 50uA after running this. To turn power back on, |
686 | * we drive MS-DAT low. Measuring with a 1mA resolution ammeter says that |
687 | * the current on the SUS_3.3V rail drops from 3mA or 4mA to 0 when we do this. |
688 | * |
689 | * We have no formal spec that details this operation -- the low-power |
690 | * sequence came from a long-lost email trail. |
691 | */ |
692 | static int hgpk_toggle_powersave(struct psmouse *psmouse, int enable) |
693 | { |
694 | struct ps2dev *ps2dev = &psmouse->ps2dev; |
695 | int timeo; |
696 | int err; |
697 | |
698 | /* Added on D-series touchpads */ |
699 | if (psmouse->model < HGPK_MODEL_D) |
700 | return 0; |
701 | |
702 | if (enable) { |
703 | psmouse_set_state(psmouse, new_state: PSMOUSE_INITIALIZING); |
704 | |
705 | /* |
706 | * Sending a byte will drive MS-DAT low; this will wake up |
707 | * the controller. Once we get an ACK back from it, it |
708 | * means we can continue with the touchpad re-init. ALPS |
709 | * tells us that 1s should be long enough, so set that as |
710 | * the upper bound. (in practice, it takes about 3 loops.) |
711 | */ |
712 | for (timeo = 20; timeo > 0; timeo--) { |
713 | if (!ps2_sendbyte(ps2dev, PSMOUSE_CMD_DISABLE, timeout: 20)) |
714 | break; |
715 | msleep(msecs: 25); |
716 | } |
717 | |
718 | err = hgpk_reset_device(psmouse, recalibrate: false); |
719 | if (err) { |
720 | psmouse_err(psmouse, "Failed to reset device!\n" ); |
721 | return err; |
722 | } |
723 | |
724 | /* should be all set, enable the touchpad */ |
725 | psmouse_activate(psmouse); |
726 | psmouse_dbg(psmouse, "Touchpad powered up.\n" ); |
727 | } else { |
728 | psmouse_dbg(psmouse, "Powering off touchpad.\n" ); |
729 | |
730 | if (ps2_command(ps2dev, NULL, command: 0xec) || |
731 | ps2_command(ps2dev, NULL, command: 0xec) || |
732 | ps2_command(ps2dev, NULL, command: 0xea)) { |
733 | return -1; |
734 | } |
735 | |
736 | psmouse_set_state(psmouse, new_state: PSMOUSE_IGNORE); |
737 | |
738 | /* probably won't see an ACK, the touchpad will be off */ |
739 | ps2_sendbyte(ps2dev, byte: 0xec, timeout: 20); |
740 | } |
741 | |
742 | return 0; |
743 | } |
744 | |
745 | static int hgpk_poll(struct psmouse *psmouse) |
746 | { |
747 | /* We can't poll, so always return failure. */ |
748 | return -1; |
749 | } |
750 | |
751 | static int hgpk_reconnect(struct psmouse *psmouse) |
752 | { |
753 | struct hgpk_data *priv = psmouse->private; |
754 | |
755 | /* |
756 | * During suspend/resume the ps2 rails remain powered. We don't want |
757 | * to do a reset because it's flush data out of buffers; however, |
758 | * earlier prototypes (B1) had some brokenness that required a reset. |
759 | */ |
760 | if (olpc_board_at_least(olpc_board(0xb2))) |
761 | if (psmouse->ps2dev.serio->dev.power.power_state.event != |
762 | PM_EVENT_ON) |
763 | return 0; |
764 | |
765 | priv->powered = 1; |
766 | return hgpk_reset_device(psmouse, recalibrate: false); |
767 | } |
768 | |
769 | static ssize_t hgpk_show_powered(struct psmouse *psmouse, void *data, char *buf) |
770 | { |
771 | struct hgpk_data *priv = psmouse->private; |
772 | |
773 | return sprintf(buf, fmt: "%d\n" , priv->powered); |
774 | } |
775 | |
776 | static ssize_t hgpk_set_powered(struct psmouse *psmouse, void *data, |
777 | const char *buf, size_t count) |
778 | { |
779 | struct hgpk_data *priv = psmouse->private; |
780 | unsigned int value; |
781 | int err; |
782 | |
783 | err = kstrtouint(s: buf, base: 10, res: &value); |
784 | if (err) |
785 | return err; |
786 | |
787 | if (value > 1) |
788 | return -EINVAL; |
789 | |
790 | if (value != priv->powered) { |
791 | /* |
792 | * hgpk_toggle_power will deal w/ state so |
793 | * we're not racing w/ irq |
794 | */ |
795 | err = hgpk_toggle_powersave(psmouse, enable: value); |
796 | if (!err) |
797 | priv->powered = value; |
798 | } |
799 | |
800 | return err ? err : count; |
801 | } |
802 | |
803 | __PSMOUSE_DEFINE_ATTR(powered, S_IWUSR | S_IRUGO, NULL, |
804 | hgpk_show_powered, hgpk_set_powered, false); |
805 | |
806 | static ssize_t attr_show_mode(struct psmouse *psmouse, void *data, char *buf) |
807 | { |
808 | struct hgpk_data *priv = psmouse->private; |
809 | |
810 | return sprintf(buf, fmt: "%s\n" , hgpk_mode_names[priv->mode]); |
811 | } |
812 | |
813 | static ssize_t attr_set_mode(struct psmouse *psmouse, void *data, |
814 | const char *buf, size_t len) |
815 | { |
816 | struct hgpk_data *priv = psmouse->private; |
817 | enum hgpk_mode old_mode = priv->mode; |
818 | enum hgpk_mode new_mode = hgpk_mode_from_name(buf, len); |
819 | struct input_dev *old_dev = psmouse->dev; |
820 | struct input_dev *new_dev; |
821 | int err; |
822 | |
823 | if (new_mode == HGPK_MODE_INVALID) |
824 | return -EINVAL; |
825 | |
826 | if (old_mode == new_mode) |
827 | return len; |
828 | |
829 | new_dev = input_allocate_device(); |
830 | if (!new_dev) |
831 | return -ENOMEM; |
832 | |
833 | psmouse_set_state(psmouse, new_state: PSMOUSE_INITIALIZING); |
834 | |
835 | /* Switch device into the new mode */ |
836 | priv->mode = new_mode; |
837 | err = hgpk_reset_device(psmouse, recalibrate: false); |
838 | if (err) |
839 | goto err_try_restore; |
840 | |
841 | hgpk_setup_input_device(input: new_dev, old_input: old_dev, mode: new_mode); |
842 | |
843 | psmouse_set_state(psmouse, new_state: PSMOUSE_CMD_MODE); |
844 | |
845 | err = input_register_device(new_dev); |
846 | if (err) |
847 | goto err_try_restore; |
848 | |
849 | psmouse->dev = new_dev; |
850 | input_unregister_device(old_dev); |
851 | |
852 | return len; |
853 | |
854 | err_try_restore: |
855 | input_free_device(dev: new_dev); |
856 | priv->mode = old_mode; |
857 | hgpk_reset_device(psmouse, recalibrate: false); |
858 | |
859 | return err; |
860 | } |
861 | |
862 | PSMOUSE_DEFINE_ATTR(hgpk_mode, S_IWUSR | S_IRUGO, NULL, |
863 | attr_show_mode, attr_set_mode); |
864 | |
865 | static ssize_t hgpk_trigger_recal_show(struct psmouse *psmouse, |
866 | void *data, char *buf) |
867 | { |
868 | return -EINVAL; |
869 | } |
870 | |
871 | static ssize_t hgpk_trigger_recal(struct psmouse *psmouse, void *data, |
872 | const char *buf, size_t count) |
873 | { |
874 | struct hgpk_data *priv = psmouse->private; |
875 | unsigned int value; |
876 | int err; |
877 | |
878 | err = kstrtouint(s: buf, base: 10, res: &value); |
879 | if (err) |
880 | return err; |
881 | |
882 | if (value != 1) |
883 | return -EINVAL; |
884 | |
885 | /* |
886 | * We queue work instead of doing recalibration right here |
887 | * to avoid adding locking to hgpk_force_recalibrate() |
888 | * since workqueue provides serialization. |
889 | */ |
890 | psmouse_queue_work(psmouse, work: &priv->recalib_wq, delay: 0); |
891 | return count; |
892 | } |
893 | |
894 | __PSMOUSE_DEFINE_ATTR(recalibrate, S_IWUSR | S_IRUGO, NULL, |
895 | hgpk_trigger_recal_show, hgpk_trigger_recal, false); |
896 | |
897 | static void hgpk_disconnect(struct psmouse *psmouse) |
898 | { |
899 | struct hgpk_data *priv = psmouse->private; |
900 | |
901 | device_remove_file(dev: &psmouse->ps2dev.serio->dev, |
902 | attr: &psmouse_attr_powered.dattr); |
903 | device_remove_file(dev: &psmouse->ps2dev.serio->dev, |
904 | attr: &psmouse_attr_hgpk_mode.dattr); |
905 | |
906 | if (psmouse->model >= HGPK_MODEL_C) |
907 | device_remove_file(dev: &psmouse->ps2dev.serio->dev, |
908 | attr: &psmouse_attr_recalibrate.dattr); |
909 | |
910 | psmouse_reset(psmouse); |
911 | kfree(objp: priv); |
912 | } |
913 | |
914 | static void hgpk_recalib_work(struct work_struct *work) |
915 | { |
916 | struct delayed_work *w = to_delayed_work(work); |
917 | struct hgpk_data *priv = container_of(w, struct hgpk_data, recalib_wq); |
918 | struct psmouse *psmouse = priv->psmouse; |
919 | |
920 | if (hgpk_force_recalibrate(psmouse)) |
921 | psmouse_err(psmouse, "recalibration failed!\n" ); |
922 | } |
923 | |
924 | static int hgpk_register(struct psmouse *psmouse) |
925 | { |
926 | struct hgpk_data *priv = psmouse->private; |
927 | int err; |
928 | |
929 | /* register handlers */ |
930 | psmouse->protocol_handler = hgpk_process_byte; |
931 | psmouse->poll = hgpk_poll; |
932 | psmouse->disconnect = hgpk_disconnect; |
933 | psmouse->reconnect = hgpk_reconnect; |
934 | |
935 | /* Disable the idle resync. */ |
936 | psmouse->resync_time = 0; |
937 | /* Reset after a lot of bad bytes. */ |
938 | psmouse->resetafter = 1024; |
939 | |
940 | hgpk_setup_input_device(input: psmouse->dev, NULL, mode: priv->mode); |
941 | |
942 | err = device_create_file(device: &psmouse->ps2dev.serio->dev, |
943 | entry: &psmouse_attr_powered.dattr); |
944 | if (err) { |
945 | psmouse_err(psmouse, "Failed creating 'powered' sysfs node\n" ); |
946 | return err; |
947 | } |
948 | |
949 | err = device_create_file(device: &psmouse->ps2dev.serio->dev, |
950 | entry: &psmouse_attr_hgpk_mode.dattr); |
951 | if (err) { |
952 | psmouse_err(psmouse, |
953 | "Failed creating 'hgpk_mode' sysfs node\n" ); |
954 | goto err_remove_powered; |
955 | } |
956 | |
957 | /* C-series touchpads added the recalibrate command */ |
958 | if (psmouse->model >= HGPK_MODEL_C) { |
959 | err = device_create_file(device: &psmouse->ps2dev.serio->dev, |
960 | entry: &psmouse_attr_recalibrate.dattr); |
961 | if (err) { |
962 | psmouse_err(psmouse, |
963 | "Failed creating 'recalibrate' sysfs node\n" ); |
964 | goto err_remove_mode; |
965 | } |
966 | } |
967 | |
968 | return 0; |
969 | |
970 | err_remove_mode: |
971 | device_remove_file(dev: &psmouse->ps2dev.serio->dev, |
972 | attr: &psmouse_attr_hgpk_mode.dattr); |
973 | err_remove_powered: |
974 | device_remove_file(dev: &psmouse->ps2dev.serio->dev, |
975 | attr: &psmouse_attr_powered.dattr); |
976 | return err; |
977 | } |
978 | |
979 | int hgpk_init(struct psmouse *psmouse) |
980 | { |
981 | struct hgpk_data *priv; |
982 | int err; |
983 | |
984 | priv = kzalloc(size: sizeof(struct hgpk_data), GFP_KERNEL); |
985 | if (!priv) { |
986 | err = -ENOMEM; |
987 | goto alloc_fail; |
988 | } |
989 | |
990 | psmouse->private = priv; |
991 | |
992 | priv->psmouse = psmouse; |
993 | priv->powered = true; |
994 | priv->mode = hgpk_default_mode; |
995 | INIT_DELAYED_WORK(&priv->recalib_wq, hgpk_recalib_work); |
996 | |
997 | err = hgpk_reset_device(psmouse, recalibrate: false); |
998 | if (err) |
999 | goto init_fail; |
1000 | |
1001 | err = hgpk_register(psmouse); |
1002 | if (err) |
1003 | goto init_fail; |
1004 | |
1005 | return 0; |
1006 | |
1007 | init_fail: |
1008 | kfree(objp: priv); |
1009 | alloc_fail: |
1010 | return err; |
1011 | } |
1012 | |
1013 | static enum hgpk_model_t hgpk_get_model(struct psmouse *psmouse) |
1014 | { |
1015 | struct ps2dev *ps2dev = &psmouse->ps2dev; |
1016 | unsigned char param[3]; |
1017 | |
1018 | /* E7, E7, E7, E9 gets us a 3 byte identifier */ |
1019 | if (ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE21) || |
1020 | ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE21) || |
1021 | ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE21) || |
1022 | ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO)) { |
1023 | return -EIO; |
1024 | } |
1025 | |
1026 | psmouse_dbg(psmouse, "ID: %*ph\n" , 3, param); |
1027 | |
1028 | /* HGPK signature: 0x67, 0x00, 0x<model> */ |
1029 | if (param[0] != 0x67 || param[1] != 0x00) |
1030 | return -ENODEV; |
1031 | |
1032 | psmouse_info(psmouse, "OLPC touchpad revision 0x%x\n" , param[2]); |
1033 | |
1034 | return param[2]; |
1035 | } |
1036 | |
1037 | int hgpk_detect(struct psmouse *psmouse, bool set_properties) |
1038 | { |
1039 | int version; |
1040 | |
1041 | version = hgpk_get_model(psmouse); |
1042 | if (version < 0) |
1043 | return version; |
1044 | |
1045 | if (set_properties) { |
1046 | psmouse->vendor = "ALPS" ; |
1047 | psmouse->name = "HGPK" ; |
1048 | psmouse->model = version; |
1049 | } |
1050 | |
1051 | return 0; |
1052 | } |
1053 | |
1054 | void hgpk_module_init(void) |
1055 | { |
1056 | hgpk_default_mode = hgpk_mode_from_name(buf: hgpk_mode_name, |
1057 | strlen(hgpk_mode_name)); |
1058 | if (hgpk_default_mode == HGPK_MODE_INVALID) { |
1059 | hgpk_default_mode = HGPK_MODE_MOUSE; |
1060 | strscpy(p: hgpk_mode_name, q: hgpk_mode_names[HGPK_MODE_MOUSE], |
1061 | size: sizeof(hgpk_mode_name)); |
1062 | } |
1063 | } |
1064 | |