2 * OLPC HGPK (XO-1) touchpad PS/2 mouse driver
4 * Copyright (c) 2006-2008 One Laptop Per Child
7 * Andres Salomon <dilinger@debian.org>
9 * This driver is partly based on the ALPS driver, which is:
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>
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.
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).
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).
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>
44 #define ILLEGAL_XY 999999
47 module_param(tpdebug
, bool, 0644);
48 MODULE_PARM_DESC(tpdebug
, "enable debugging, dumping packets to KERN_DEBUG.");
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.");
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");
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");
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");
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");
76 static bool autorecal
= true;
77 module_param(autorecal
, bool, 0644);
78 MODULE_PARM_DESC(autorecal
, "enable recalibration in the driver");
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");
85 static int hgpk_default_mode
= HGPK_MODE_MOUSE
;
87 static const char * const hgpk_mode_names
[] = {
88 [HGPK_MODE_MOUSE
] = "Mouse",
89 [HGPK_MODE_GLIDESENSOR
] = "GlideSensor",
90 [HGPK_MODE_PENTABLET
] = "PenTablet",
93 static int hgpk_mode_from_name(const char *buf
, int len
)
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
))
103 return HGPK_MODE_INVALID
;
107 * see if new value is within 20% of half of old value
109 static int approx_half(int curr
, int prev
)
111 int belowhalf
, abovehalf
;
113 if (curr
< 5 || prev
< 5)
116 belowhalf
= (prev
* 8) / 20;
117 abovehalf
= (prev
* 12) / 20;
119 return belowhalf
< curr
&& curr
<= abovehalf
;
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.
127 static int hgpk_discard_decay_hack(struct psmouse
*psmouse
, int x
, int y
)
129 struct hgpk_data
*priv
= psmouse
->private;
131 bool do_recal
= false;
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 hgpk_err(psmouse
, "detected %dpx jump in x\n", x
);
141 } else if (approx_half(avx
, priv
->xbigj
)) {
142 hgpk_err(psmouse
, "detected secondary %dpx jump in x\n", x
);
144 priv
->xsaw_secondary
++;
146 if (priv
->xbigj
&& priv
->xsaw_secondary
> 1)
149 priv
->xsaw_secondary
= 0;
152 if (avy
> recalib_delta
||
153 (avy
> recalib_delta
/ 2 && ((avy
/ 4) > priv
->ylast
))) {
154 hgpk_err(psmouse
, "detected %dpx jump in y\n", y
);
156 } else if (approx_half(avy
, priv
->ybigj
)) {
157 hgpk_err(psmouse
, "detected secondary %dpx jump in y\n", y
);
159 priv
->ysaw_secondary
++;
161 if (priv
->ybigj
&& priv
->ysaw_secondary
> 1)
164 priv
->ysaw_secondary
= 0;
170 if (do_recal
&& jumpy_delay
) {
171 hgpk_err(psmouse
, "scheduling recalibration\n");
172 psmouse_queue_work(psmouse
, &priv
->recalib_wq
,
173 msecs_to_jiffies(jumpy_delay
));
176 return priv
->xbigj
|| priv
->ybigj
;
179 static void hgpk_reset_spew_detection(struct hgpk_data
*priv
)
181 priv
->spew_count
= 0;
182 priv
->dupe_count
= 0;
185 priv
->spew_flag
= NO_SPEW
;
188 static void hgpk_reset_hack_state(struct psmouse
*psmouse
)
190 struct hgpk_data
*priv
= psmouse
->private;
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
);
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".
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.
214 static void hgpk_spewing_hack(struct psmouse
*psmouse
,
215 int l
, int r
, int x
, int y
)
217 struct hgpk_data
*priv
= psmouse
->private;
219 /* ignore button press packets; many in a row could trigger
220 * a false-positive! */
224 /* don't track spew if the workaround feature has been turned off */
228 if (abs(x
) > 3 || abs(y
) > 3) {
229 /* no spew, or spew ended */
230 hgpk_reset_spew_detection(priv
);
234 /* Keep a tally of the overall delta to the cursor position caused by
239 switch (priv
->spew_flag
) {
241 /* we're not spewing, but this packet might be the start */
242 priv
->spew_flag
= MAYBE_SPEWING
;
249 if (priv
->spew_count
< SPEW_WATCH_COUNT
)
252 /* excessive spew detected, request recalibration */
253 priv
->spew_flag
= 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 hgpk_err(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
));
272 /* we already detected a spew and requested a recalibration,
273 * just wait for the queue to kick into action. */
279 * HGPK Mouse Mode format (standard mouse format, sans middle button)
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
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
291 * HGPK Advanced Mode - single-mode format
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
302 * ?'s are not defined in the protocol spec, may vary between models.
304 * swr/swl are the left/right buttons.
306 * pt-dsw/gs-dsw indicate that the pt/gs sensor is detecting a
309 static bool hgpk_is_byte_valid(struct psmouse
*psmouse
, unsigned char *packet
)
311 struct hgpk_data
*priv
= psmouse
->private;
312 int pktcnt
= psmouse
->pktcnt
;
315 switch (priv
->mode
) {
316 case HGPK_MODE_MOUSE
:
317 valid
= (packet
[0] & 0x0C) == 0x08;
320 case HGPK_MODE_GLIDESENSOR
:
321 valid
= pktcnt
== 1 ?
322 packet
[0] == HGPK_GS
: !(packet
[pktcnt
- 1] & 0x80);
325 case HGPK_MODE_PENTABLET
:
326 valid
= pktcnt
== 1 ?
327 packet
[0] == HGPK_PT
: !(packet
[pktcnt
- 1] & 0x80);
337 "bad data, mode %d (%d) %02x %02x %02x %02x %02x %02x\n",
339 psmouse
->packet
[0], psmouse
->packet
[1],
340 psmouse
->packet
[2], psmouse
->packet
[3],
341 psmouse
->packet
[4], psmouse
->packet
[5]);
346 static void hgpk_process_advanced_packet(struct psmouse
*psmouse
)
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);
357 if (priv
->mode
== HGPK_MODE_GLIDESENSOR
) {
358 int pt_down
= !!(packet
[2] & 1);
359 int finger_down
= !!(packet
[2] & 2);
362 input_report_abs(idev
, ABS_PRESSURE
, z
);
364 hgpk_dbg(psmouse
, "pd=%d fd=%d z=%d",
365 pt_down
, finger_down
, z
);
368 * PenTablet mode does not report pressure, so we don't
372 hgpk_dbg(psmouse
, "pd=%d ", down
);
376 hgpk_dbg(psmouse
, "l=%d r=%d x=%d y=%d\n", left
, right
, x
, y
);
378 input_report_key(idev
, BTN_TOUCH
, down
);
379 input_report_key(idev
, BTN_LEFT
, left
);
380 input_report_key(idev
, BTN_RIGHT
, right
);
383 * If this packet says that the finger was removed, reset our position
384 * tracking so that we don't erroneously detect a jump on next press.
387 hgpk_reset_hack_state(psmouse
);
392 * Weed out duplicate packets (we get quite a few, and they mess up
393 * our jump detection)
395 if (x
== priv
->abs_x
&& y
== priv
->abs_y
) {
396 if (++priv
->dupe_count
> SPEW_WATCH_COUNT
) {
398 hgpk_dbg(psmouse
, "hard spew detected\n");
399 priv
->spew_flag
= RECALIBRATING
;
400 psmouse_queue_work(psmouse
, &priv
->recalib_wq
,
401 msecs_to_jiffies(spew_delay
));
406 /* not a duplicate, continue with position reporting */
407 priv
->dupe_count
= 0;
409 /* Don't apply hacks in PT mode, it seems reliable */
410 if (priv
->mode
!= HGPK_MODE_PENTABLET
&& priv
->abs_x
!= -1) {
411 int x_diff
= priv
->abs_x
- x
;
412 int y_diff
= priv
->abs_y
- y
;
413 if (hgpk_discard_decay_hack(psmouse
, x_diff
, y_diff
)) {
415 hgpk_dbg(psmouse
, "discarding\n");
418 hgpk_spewing_hack(psmouse
, left
, right
, x_diff
, y_diff
);
421 input_report_abs(idev
, ABS_X
, x
);
422 input_report_abs(idev
, ABS_Y
, y
);
430 static void hgpk_process_simple_packet(struct psmouse
*psmouse
)
432 struct input_dev
*dev
= psmouse
->dev
;
433 unsigned char *packet
= psmouse
->packet
;
434 int left
= packet
[0] & 1;
435 int right
= (packet
[0] >> 1) & 1;
436 int x
= packet
[1] - ((packet
[0] << 4) & 0x100);
437 int y
= ((packet
[0] << 3) & 0x100) - packet
[2];
439 if (packet
[0] & 0xc0)
441 "overflow -- 0x%02x 0x%02x 0x%02x\n",
442 packet
[0], packet
[1], packet
[2]);
444 if (hgpk_discard_decay_hack(psmouse
, x
, y
)) {
446 hgpk_dbg(psmouse
, "discarding\n");
450 hgpk_spewing_hack(psmouse
, left
, right
, x
, y
);
453 hgpk_dbg(psmouse
, "l=%d r=%d x=%d y=%d\n", left
, right
, x
, y
);
455 input_report_key(dev
, BTN_LEFT
, left
);
456 input_report_key(dev
, BTN_RIGHT
, right
);
458 input_report_rel(dev
, REL_X
, x
);
459 input_report_rel(dev
, REL_Y
, y
);
464 static psmouse_ret_t
hgpk_process_byte(struct psmouse
*psmouse
)
466 struct hgpk_data
*priv
= psmouse
->private;
468 if (!hgpk_is_byte_valid(psmouse
, psmouse
->packet
))
469 return PSMOUSE_BAD_DATA
;
471 if (psmouse
->pktcnt
>= psmouse
->pktsize
) {
472 if (priv
->mode
== HGPK_MODE_MOUSE
)
473 hgpk_process_simple_packet(psmouse
);
475 hgpk_process_advanced_packet(psmouse
);
476 return PSMOUSE_FULL_PACKET
;
479 if (priv
->recalib_window
) {
480 if (time_before(jiffies
, priv
->recalib_window
)) {
482 * ugh, got a packet inside our recalibration
483 * window, schedule another recalibration.
486 "packet inside calibration window, "
487 "queueing another recalibration\n");
488 psmouse_queue_work(psmouse
, &priv
->recalib_wq
,
489 msecs_to_jiffies(post_interrupt_delay
));
491 priv
->recalib_window
= 0;
494 return PSMOUSE_GOOD_DATA
;
497 static int hgpk_select_mode(struct psmouse
*psmouse
)
499 struct ps2dev
*ps2dev
= &psmouse
->ps2dev
;
500 struct hgpk_data
*priv
= psmouse
->private;
505 * 4 disables to enable advanced mode
506 * then 3 0xf2 bytes as the preamble for GS/PT selection
508 const int advanced_init
[] = {
509 PSMOUSE_CMD_DISABLE
, PSMOUSE_CMD_DISABLE
,
510 PSMOUSE_CMD_DISABLE
, PSMOUSE_CMD_DISABLE
,
514 switch (priv
->mode
) {
515 case HGPK_MODE_MOUSE
:
516 psmouse
->pktsize
= 3;
519 case HGPK_MODE_GLIDESENSOR
:
520 case HGPK_MODE_PENTABLET
:
521 psmouse
->pktsize
= 6;
523 /* Switch to 'Advanced mode.', four disables in a row. */
524 for (i
= 0; i
< ARRAY_SIZE(advanced_init
); i
++)
525 if (ps2_command(ps2dev
, NULL
, advanced_init
[i
]))
528 /* select between GlideSensor (mouse) or PenTablet */
529 cmd
= priv
->mode
== HGPK_MODE_GLIDESENSOR
?
530 PSMOUSE_CMD_SETSCALE11
: PSMOUSE_CMD_SETSCALE21
;
532 if (ps2_command(ps2dev
, NULL
, cmd
))
543 static void hgpk_setup_input_device(struct input_dev
*input
,
544 struct input_dev
*old_input
,
548 input
->name
= old_input
->name
;
549 input
->phys
= old_input
->phys
;
550 input
->id
= old_input
->id
;
551 input
->dev
.parent
= old_input
->dev
.parent
;
554 memset(input
->evbit
, 0, sizeof(input
->evbit
));
555 memset(input
->relbit
, 0, sizeof(input
->relbit
));
556 memset(input
->keybit
, 0, sizeof(input
->keybit
));
558 /* All modes report left and right buttons */
559 __set_bit(EV_KEY
, input
->evbit
);
560 __set_bit(BTN_LEFT
, input
->keybit
);
561 __set_bit(BTN_RIGHT
, input
->keybit
);
564 case HGPK_MODE_MOUSE
:
565 __set_bit(EV_REL
, input
->evbit
);
566 __set_bit(REL_X
, input
->relbit
);
567 __set_bit(REL_Y
, input
->relbit
);
570 case HGPK_MODE_GLIDESENSOR
:
571 __set_bit(BTN_TOUCH
, input
->keybit
);
572 __set_bit(BTN_TOOL_FINGER
, input
->keybit
);
574 __set_bit(EV_ABS
, input
->evbit
);
576 /* GlideSensor has pressure sensor, PenTablet does not */
577 input_set_abs_params(input
, ABS_PRESSURE
, 0, 15, 0, 0);
579 /* From device specs */
580 input_set_abs_params(input
, ABS_X
, 0, 399, 0, 0);
581 input_set_abs_params(input
, ABS_Y
, 0, 290, 0, 0);
583 /* Calculated by hand based on usable size (52mm x 38mm) */
584 input_abs_set_res(input
, ABS_X
, 8);
585 input_abs_set_res(input
, ABS_Y
, 8);
588 case HGPK_MODE_PENTABLET
:
589 __set_bit(BTN_TOUCH
, input
->keybit
);
590 __set_bit(BTN_TOOL_FINGER
, input
->keybit
);
592 __set_bit(EV_ABS
, input
->evbit
);
594 /* From device specs */
595 input_set_abs_params(input
, ABS_X
, 0, 999, 0, 0);
596 input_set_abs_params(input
, ABS_Y
, 5, 239, 0, 0);
598 /* Calculated by hand based on usable size (156mm x 38mm) */
599 input_abs_set_res(input
, ABS_X
, 6);
600 input_abs_set_res(input
, ABS_Y
, 8);
608 static int hgpk_reset_device(struct psmouse
*psmouse
, bool recalibrate
)
612 psmouse_reset(psmouse
);
615 struct ps2dev
*ps2dev
= &psmouse
->ps2dev
;
617 /* send the recalibrate request */
618 if (ps2_command(ps2dev
, NULL
, 0xf5) ||
619 ps2_command(ps2dev
, NULL
, 0xf5) ||
620 ps2_command(ps2dev
, NULL
, 0xe6) ||
621 ps2_command(ps2dev
, NULL
, 0xf5)) {
625 /* according to ALPS, 150mS is required for recalibration */
629 err
= hgpk_select_mode(psmouse
);
631 hgpk_err(psmouse
, "failed to select mode\n");
635 hgpk_reset_hack_state(psmouse
);
640 static int hgpk_force_recalibrate(struct psmouse
*psmouse
)
642 struct ps2dev
*ps2dev
= &psmouse
->ps2dev
;
643 struct hgpk_data
*priv
= psmouse
->private;
646 /* C-series touchpads added the recalibrate command */
647 if (psmouse
->model
< HGPK_MODEL_C
)
651 hgpk_dbg(psmouse
, "recalibrations disabled, ignoring\n");
655 hgpk_dbg(psmouse
, "recalibrating touchpad..\n");
657 /* we don't want to race with the irq handler, nor with resyncs */
658 psmouse_set_state(psmouse
, PSMOUSE_INITIALIZING
);
660 /* start by resetting the device */
661 err
= hgpk_reset_device(psmouse
, true);
666 * XXX: If a finger is down during this delay, recalibration will
667 * detect capacitance incorrectly. This is a hardware bug, and
668 * we don't have a good way to deal with it. The 2s window stuff
669 * (below) is our best option for now.
672 if (ps2_command(ps2dev
, NULL
, PSMOUSE_CMD_ENABLE
))
675 psmouse_set_state(psmouse
, PSMOUSE_ACTIVATED
);
678 hgpk_dbg(psmouse
, "touchpad reactivated\n");
681 * If we get packets right away after recalibrating, it's likely
682 * that a finger was on the touchpad. If so, it's probably
683 * miscalibrated, so we optionally schedule another.
685 if (recal_guard_time
)
686 priv
->recalib_window
= jiffies
+
687 msecs_to_jiffies(recal_guard_time
);
693 * This puts the touchpad in a power saving mode; according to ALPS, current
694 * consumption goes down to 50uA after running this. To turn power back on,
695 * we drive MS-DAT low. Measuring with a 1mA resolution ammeter says that
696 * the current on the SUS_3.3V rail drops from 3mA or 4mA to 0 when we do this.
698 * We have no formal spec that details this operation -- the low-power
699 * sequence came from a long-lost email trail.
701 static int hgpk_toggle_powersave(struct psmouse
*psmouse
, int enable
)
703 struct ps2dev
*ps2dev
= &psmouse
->ps2dev
;
707 /* Added on D-series touchpads */
708 if (psmouse
->model
< HGPK_MODEL_D
)
712 psmouse_set_state(psmouse
, PSMOUSE_INITIALIZING
);
715 * Sending a byte will drive MS-DAT low; this will wake up
716 * the controller. Once we get an ACK back from it, it
717 * means we can continue with the touchpad re-init. ALPS
718 * tells us that 1s should be long enough, so set that as
719 * the upper bound. (in practice, it takes about 3 loops.)
721 for (timeo
= 20; timeo
> 0; timeo
--) {
722 if (!ps2_sendbyte(&psmouse
->ps2dev
,
723 PSMOUSE_CMD_DISABLE
, 20))
728 err
= hgpk_reset_device(psmouse
, false);
730 hgpk_err(psmouse
, "Failed to reset device!\n");
734 /* should be all set, enable the touchpad */
735 ps2_command(&psmouse
->ps2dev
, NULL
, PSMOUSE_CMD_ENABLE
);
736 psmouse_set_state(psmouse
, PSMOUSE_ACTIVATED
);
737 hgpk_dbg(psmouse
, "Touchpad powered up.\n");
739 hgpk_dbg(psmouse
, "Powering off touchpad.\n");
741 if (ps2_command(ps2dev
, NULL
, 0xec) ||
742 ps2_command(ps2dev
, NULL
, 0xec) ||
743 ps2_command(ps2dev
, NULL
, 0xea)) {
747 psmouse_set_state(psmouse
, PSMOUSE_IGNORE
);
749 /* probably won't see an ACK, the touchpad will be off */
750 ps2_sendbyte(&psmouse
->ps2dev
, 0xec, 20);
756 static int hgpk_poll(struct psmouse
*psmouse
)
758 /* We can't poll, so always return failure. */
762 static int hgpk_reconnect(struct psmouse
*psmouse
)
764 struct hgpk_data
*priv
= psmouse
->private;
767 * During suspend/resume the ps2 rails remain powered. We don't want
768 * to do a reset because it's flush data out of buffers; however,
769 * earlier prototypes (B1) had some brokenness that required a reset.
771 if (olpc_board_at_least(olpc_board(0xb2)))
772 if (psmouse
->ps2dev
.serio
->dev
.power
.power_state
.event
!=
777 return hgpk_reset_device(psmouse
, false);
780 static ssize_t
hgpk_show_powered(struct psmouse
*psmouse
, void *data
, char *buf
)
782 struct hgpk_data
*priv
= psmouse
->private;
784 return sprintf(buf
, "%d\n", priv
->powered
);
787 static ssize_t
hgpk_set_powered(struct psmouse
*psmouse
, void *data
,
788 const char *buf
, size_t count
)
790 struct hgpk_data
*priv
= psmouse
->private;
794 err
= strict_strtoul(buf
, 10, &value
);
795 if (err
|| value
> 1)
798 if (value
!= priv
->powered
) {
800 * hgpk_toggle_power will deal w/ state so
801 * we're not racing w/ irq
803 err
= hgpk_toggle_powersave(psmouse
, value
);
805 priv
->powered
= value
;
808 return err
? err
: count
;
811 __PSMOUSE_DEFINE_ATTR(powered
, S_IWUSR
| S_IRUGO
, NULL
,
812 hgpk_show_powered
, hgpk_set_powered
, false);
814 static ssize_t
attr_show_mode(struct psmouse
*psmouse
, void *data
, char *buf
)
816 struct hgpk_data
*priv
= psmouse
->private;
818 return sprintf(buf
, "%s\n", hgpk_mode_names
[priv
->mode
]);
821 static ssize_t
attr_set_mode(struct psmouse
*psmouse
, void *data
,
822 const char *buf
, size_t len
)
824 struct hgpk_data
*priv
= psmouse
->private;
825 enum hgpk_mode old_mode
= priv
->mode
;
826 enum hgpk_mode new_mode
= hgpk_mode_from_name(buf
, len
);
827 struct input_dev
*old_dev
= psmouse
->dev
;
828 struct input_dev
*new_dev
;
831 if (new_mode
== HGPK_MODE_INVALID
)
834 if (old_mode
== new_mode
)
837 new_dev
= input_allocate_device();
841 psmouse_set_state(psmouse
, PSMOUSE_INITIALIZING
);
843 /* Switch device into the new mode */
844 priv
->mode
= new_mode
;
845 err
= hgpk_reset_device(psmouse
, false);
847 goto err_try_restore
;
849 hgpk_setup_input_device(new_dev
, old_dev
, new_mode
);
851 psmouse_set_state(psmouse
, PSMOUSE_CMD_MODE
);
853 err
= input_register_device(new_dev
);
855 goto err_try_restore
;
857 psmouse
->dev
= new_dev
;
858 input_unregister_device(old_dev
);
863 input_free_device(new_dev
);
864 priv
->mode
= old_mode
;
865 hgpk_reset_device(psmouse
, false);
870 PSMOUSE_DEFINE_ATTR(hgpk_mode
, S_IWUSR
| S_IRUGO
, NULL
,
871 attr_show_mode
, attr_set_mode
);
873 static ssize_t
hgpk_trigger_recal_show(struct psmouse
*psmouse
,
874 void *data
, char *buf
)
879 static ssize_t
hgpk_trigger_recal(struct psmouse
*psmouse
, void *data
,
880 const char *buf
, size_t count
)
882 struct hgpk_data
*priv
= psmouse
->private;
886 err
= strict_strtoul(buf
, 10, &value
);
887 if (err
|| value
!= 1)
891 * We queue work instead of doing recalibration right here
892 * to avoid adding locking to to hgpk_force_recalibrate()
893 * since workqueue provides serialization.
895 psmouse_queue_work(psmouse
, &priv
->recalib_wq
, 0);
899 __PSMOUSE_DEFINE_ATTR(recalibrate
, S_IWUSR
| S_IRUGO
, NULL
,
900 hgpk_trigger_recal_show
, hgpk_trigger_recal
, false);
902 static void hgpk_disconnect(struct psmouse
*psmouse
)
904 struct hgpk_data
*priv
= psmouse
->private;
906 device_remove_file(&psmouse
->ps2dev
.serio
->dev
,
907 &psmouse_attr_powered
.dattr
);
908 device_remove_file(&psmouse
->ps2dev
.serio
->dev
,
909 &psmouse_attr_hgpk_mode
.dattr
);
911 if (psmouse
->model
>= HGPK_MODEL_C
)
912 device_remove_file(&psmouse
->ps2dev
.serio
->dev
,
913 &psmouse_attr_recalibrate
.dattr
);
915 psmouse_reset(psmouse
);
919 static void hgpk_recalib_work(struct work_struct
*work
)
921 struct delayed_work
*w
= to_delayed_work(work
);
922 struct hgpk_data
*priv
= container_of(w
, struct hgpk_data
, recalib_wq
);
923 struct psmouse
*psmouse
= priv
->psmouse
;
925 if (hgpk_force_recalibrate(psmouse
))
926 hgpk_err(psmouse
, "recalibration failed!\n");
929 static int hgpk_register(struct psmouse
*psmouse
)
931 struct hgpk_data
*priv
= psmouse
->private;
934 /* register handlers */
935 psmouse
->protocol_handler
= hgpk_process_byte
;
936 psmouse
->poll
= hgpk_poll
;
937 psmouse
->disconnect
= hgpk_disconnect
;
938 psmouse
->reconnect
= hgpk_reconnect
;
940 /* Disable the idle resync. */
941 psmouse
->resync_time
= 0;
942 /* Reset after a lot of bad bytes. */
943 psmouse
->resetafter
= 1024;
945 hgpk_setup_input_device(psmouse
->dev
, NULL
, priv
->mode
);
947 err
= device_create_file(&psmouse
->ps2dev
.serio
->dev
,
948 &psmouse_attr_powered
.dattr
);
950 hgpk_err(psmouse
, "Failed creating 'powered' sysfs node\n");
954 err
= device_create_file(&psmouse
->ps2dev
.serio
->dev
,
955 &psmouse_attr_hgpk_mode
.dattr
);
957 hgpk_err(psmouse
, "Failed creating 'hgpk_mode' sysfs node\n");
958 goto err_remove_powered
;
961 /* C-series touchpads added the recalibrate command */
962 if (psmouse
->model
>= HGPK_MODEL_C
) {
963 err
= device_create_file(&psmouse
->ps2dev
.serio
->dev
,
964 &psmouse_attr_recalibrate
.dattr
);
967 "Failed creating 'recalibrate' sysfs node\n");
968 goto err_remove_mode
;
975 device_remove_file(&psmouse
->ps2dev
.serio
->dev
,
976 &psmouse_attr_hgpk_mode
.dattr
);
978 device_remove_file(&psmouse
->ps2dev
.serio
->dev
,
979 &psmouse_attr_powered
.dattr
);
983 int hgpk_init(struct psmouse
*psmouse
)
985 struct hgpk_data
*priv
;
988 priv
= kzalloc(sizeof(struct hgpk_data
), GFP_KERNEL
);
994 psmouse
->private = priv
;
996 priv
->psmouse
= psmouse
;
997 priv
->powered
= true;
998 priv
->mode
= hgpk_default_mode
;
999 INIT_DELAYED_WORK(&priv
->recalib_wq
, hgpk_recalib_work
);
1001 err
= hgpk_reset_device(psmouse
, false);
1005 err
= hgpk_register(psmouse
);
1017 static enum hgpk_model_t
hgpk_get_model(struct psmouse
*psmouse
)
1019 struct ps2dev
*ps2dev
= &psmouse
->ps2dev
;
1020 unsigned char param
[3];
1022 /* E7, E7, E7, E9 gets us a 3 byte identifier */
1023 if (ps2_command(ps2dev
, NULL
, PSMOUSE_CMD_SETSCALE21
) ||
1024 ps2_command(ps2dev
, NULL
, PSMOUSE_CMD_SETSCALE21
) ||
1025 ps2_command(ps2dev
, NULL
, PSMOUSE_CMD_SETSCALE21
) ||
1026 ps2_command(ps2dev
, param
, PSMOUSE_CMD_GETINFO
)) {
1030 hgpk_dbg(psmouse
, "ID: %02x %02x %02x\n", param
[0], param
[1], param
[2]);
1032 /* HGPK signature: 0x67, 0x00, 0x<model> */
1033 if (param
[0] != 0x67 || param
[1] != 0x00)
1036 hgpk_info(psmouse
, "OLPC touchpad revision 0x%x\n", param
[2]);
1041 int hgpk_detect(struct psmouse
*psmouse
, bool set_properties
)
1045 version
= hgpk_get_model(psmouse
);
1049 if (set_properties
) {
1050 psmouse
->vendor
= "ALPS";
1051 psmouse
->name
= "HGPK";
1052 psmouse
->model
= version
;
1058 void hgpk_module_init(void)
1060 hgpk_default_mode
= hgpk_mode_from_name(hgpk_mode_name
,
1061 strlen(hgpk_mode_name
));
1062 if (hgpk_default_mode
== HGPK_MODE_INVALID
) {
1063 hgpk_default_mode
= HGPK_MODE_MOUSE
;
1064 strlcpy(hgpk_mode_name
, hgpk_mode_names
[HGPK_MODE_MOUSE
],
1065 sizeof(hgpk_mode_name
));