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