]>
git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - drivers/input/mouse/hgpk.c
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 psmouse_warn(psmouse
, "detected %dpx jump in x\n", x
);
141 } else if (approx_half(avx
, priv
->xbigj
)) {
142 psmouse_warn(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 psmouse_warn(psmouse
, "detected %dpx jump in y\n", y
);
156 } else if (approx_half(avy
, priv
->ybigj
)) {
157 psmouse_warn(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 psmouse_warn(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 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
));
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) %*ph\n",
338 priv
->mode
, pktcnt
, 6, psmouse
->packet
);
343 static void hgpk_process_advanced_packet(struct psmouse
*psmouse
)
345 struct hgpk_data
*priv
= psmouse
->private;
346 struct input_dev
*idev
= psmouse
->dev
;
347 unsigned char *packet
= psmouse
->packet
;
348 int down
= !!(packet
[2] & 2);
349 int left
= !!(packet
[3] & 1);
350 int right
= !!(packet
[3] & 2);
351 int x
= packet
[1] | ((packet
[2] & 0x78) << 4);
352 int y
= packet
[4] | ((packet
[3] & 0x70) << 3);
354 if (priv
->mode
== HGPK_MODE_GLIDESENSOR
) {
355 int pt_down
= !!(packet
[2] & 1);
356 int finger_down
= !!(packet
[2] & 2);
359 input_report_abs(idev
, ABS_PRESSURE
, z
);
361 psmouse_dbg(psmouse
, "pd=%d fd=%d z=%d",
362 pt_down
, finger_down
, z
);
365 * PenTablet mode does not report pressure, so we don't
369 psmouse_dbg(psmouse
, "pd=%d ", down
);
373 psmouse_dbg(psmouse
, "l=%d r=%d x=%d y=%d\n",
376 input_report_key(idev
, BTN_TOUCH
, down
);
377 input_report_key(idev
, BTN_LEFT
, left
);
378 input_report_key(idev
, BTN_RIGHT
, right
);
381 * If this packet says that the finger was removed, reset our position
382 * tracking so that we don't erroneously detect a jump on next press.
385 hgpk_reset_hack_state(psmouse
);
390 * Weed out duplicate packets (we get quite a few, and they mess up
391 * our jump detection)
393 if (x
== priv
->abs_x
&& y
== priv
->abs_y
) {
394 if (++priv
->dupe_count
> SPEW_WATCH_COUNT
) {
396 psmouse_dbg(psmouse
, "hard spew detected\n");
397 priv
->spew_flag
= RECALIBRATING
;
398 psmouse_queue_work(psmouse
, &priv
->recalib_wq
,
399 msecs_to_jiffies(spew_delay
));
404 /* not a duplicate, continue with position reporting */
405 priv
->dupe_count
= 0;
407 /* Don't apply hacks in PT mode, it seems reliable */
408 if (priv
->mode
!= HGPK_MODE_PENTABLET
&& priv
->abs_x
!= -1) {
409 int x_diff
= priv
->abs_x
- x
;
410 int y_diff
= priv
->abs_y
- y
;
411 if (hgpk_discard_decay_hack(psmouse
, x_diff
, y_diff
)) {
413 psmouse_dbg(psmouse
, "discarding\n");
416 hgpk_spewing_hack(psmouse
, left
, right
, x_diff
, y_diff
);
419 input_report_abs(idev
, ABS_X
, x
);
420 input_report_abs(idev
, ABS_Y
, y
);
428 static void hgpk_process_simple_packet(struct psmouse
*psmouse
)
430 struct input_dev
*dev
= psmouse
->dev
;
431 unsigned char *packet
= psmouse
->packet
;
432 int left
= packet
[0] & 1;
433 int right
= (packet
[0] >> 1) & 1;
434 int x
= packet
[1] - ((packet
[0] << 4) & 0x100);
435 int y
= ((packet
[0] << 3) & 0x100) - packet
[2];
437 if (packet
[0] & 0xc0)
439 "overflow -- 0x%02x 0x%02x 0x%02x\n",
440 packet
[0], packet
[1], packet
[2]);
442 if (hgpk_discard_decay_hack(psmouse
, x
, y
)) {
444 psmouse_dbg(psmouse
, "discarding\n");
448 hgpk_spewing_hack(psmouse
, left
, right
, x
, y
);
451 psmouse_dbg(psmouse
, "l=%d r=%d x=%d y=%d\n",
454 input_report_key(dev
, BTN_LEFT
, left
);
455 input_report_key(dev
, BTN_RIGHT
, right
);
457 input_report_rel(dev
, REL_X
, x
);
458 input_report_rel(dev
, REL_Y
, y
);
463 static psmouse_ret_t
hgpk_process_byte(struct psmouse
*psmouse
)
465 struct hgpk_data
*priv
= psmouse
->private;
467 if (!hgpk_is_byte_valid(psmouse
, psmouse
->packet
))
468 return PSMOUSE_BAD_DATA
;
470 if (psmouse
->pktcnt
>= psmouse
->pktsize
) {
471 if (priv
->mode
== HGPK_MODE_MOUSE
)
472 hgpk_process_simple_packet(psmouse
);
474 hgpk_process_advanced_packet(psmouse
);
475 return PSMOUSE_FULL_PACKET
;
478 if (priv
->recalib_window
) {
479 if (time_before(jiffies
, priv
->recalib_window
)) {
481 * ugh, got a packet inside our recalibration
482 * window, schedule another recalibration.
485 "packet inside calibration window, queueing another recalibration\n");
486 psmouse_queue_work(psmouse
, &priv
->recalib_wq
,
487 msecs_to_jiffies(post_interrupt_delay
));
489 priv
->recalib_window
= 0;
492 return PSMOUSE_GOOD_DATA
;
495 static int hgpk_select_mode(struct psmouse
*psmouse
)
497 struct ps2dev
*ps2dev
= &psmouse
->ps2dev
;
498 struct hgpk_data
*priv
= psmouse
->private;
503 * 4 disables to enable advanced mode
504 * then 3 0xf2 bytes as the preamble for GS/PT selection
506 const int advanced_init
[] = {
507 PSMOUSE_CMD_DISABLE
, PSMOUSE_CMD_DISABLE
,
508 PSMOUSE_CMD_DISABLE
, PSMOUSE_CMD_DISABLE
,
512 switch (priv
->mode
) {
513 case HGPK_MODE_MOUSE
:
514 psmouse
->pktsize
= 3;
517 case HGPK_MODE_GLIDESENSOR
:
518 case HGPK_MODE_PENTABLET
:
519 psmouse
->pktsize
= 6;
521 /* Switch to 'Advanced mode.', four disables in a row. */
522 for (i
= 0; i
< ARRAY_SIZE(advanced_init
); i
++)
523 if (ps2_command(ps2dev
, NULL
, advanced_init
[i
]))
526 /* select between GlideSensor (mouse) or PenTablet */
527 cmd
= priv
->mode
== HGPK_MODE_GLIDESENSOR
?
528 PSMOUSE_CMD_SETSCALE11
: PSMOUSE_CMD_SETSCALE21
;
530 if (ps2_command(ps2dev
, NULL
, cmd
))
541 static void hgpk_setup_input_device(struct input_dev
*input
,
542 struct input_dev
*old_input
,
546 input
->name
= old_input
->name
;
547 input
->phys
= old_input
->phys
;
548 input
->id
= old_input
->id
;
549 input
->dev
.parent
= old_input
->dev
.parent
;
552 memset(input
->evbit
, 0, sizeof(input
->evbit
));
553 memset(input
->relbit
, 0, sizeof(input
->relbit
));
554 memset(input
->keybit
, 0, sizeof(input
->keybit
));
556 /* All modes report left and right buttons */
557 __set_bit(EV_KEY
, input
->evbit
);
558 __set_bit(BTN_LEFT
, input
->keybit
);
559 __set_bit(BTN_RIGHT
, input
->keybit
);
562 case HGPK_MODE_MOUSE
:
563 __set_bit(EV_REL
, input
->evbit
);
564 __set_bit(REL_X
, input
->relbit
);
565 __set_bit(REL_Y
, input
->relbit
);
568 case HGPK_MODE_GLIDESENSOR
:
569 __set_bit(BTN_TOUCH
, input
->keybit
);
570 __set_bit(BTN_TOOL_FINGER
, input
->keybit
);
572 __set_bit(EV_ABS
, input
->evbit
);
574 /* GlideSensor has pressure sensor, PenTablet does not */
575 input_set_abs_params(input
, ABS_PRESSURE
, 0, 15, 0, 0);
577 /* From device specs */
578 input_set_abs_params(input
, ABS_X
, 0, 399, 0, 0);
579 input_set_abs_params(input
, ABS_Y
, 0, 290, 0, 0);
581 /* Calculated by hand based on usable size (52mm x 38mm) */
582 input_abs_set_res(input
, ABS_X
, 8);
583 input_abs_set_res(input
, ABS_Y
, 8);
586 case HGPK_MODE_PENTABLET
:
587 __set_bit(BTN_TOUCH
, input
->keybit
);
588 __set_bit(BTN_TOOL_FINGER
, input
->keybit
);
590 __set_bit(EV_ABS
, input
->evbit
);
592 /* From device specs */
593 input_set_abs_params(input
, ABS_X
, 0, 999, 0, 0);
594 input_set_abs_params(input
, ABS_Y
, 5, 239, 0, 0);
596 /* Calculated by hand based on usable size (156mm x 38mm) */
597 input_abs_set_res(input
, ABS_X
, 6);
598 input_abs_set_res(input
, ABS_Y
, 8);
606 static int hgpk_reset_device(struct psmouse
*psmouse
, bool recalibrate
)
610 psmouse_reset(psmouse
);
613 struct ps2dev
*ps2dev
= &psmouse
->ps2dev
;
615 /* send the recalibrate request */
616 if (ps2_command(ps2dev
, NULL
, 0xf5) ||
617 ps2_command(ps2dev
, NULL
, 0xf5) ||
618 ps2_command(ps2dev
, NULL
, 0xe6) ||
619 ps2_command(ps2dev
, NULL
, 0xf5)) {
623 /* according to ALPS, 150mS is required for recalibration */
627 err
= hgpk_select_mode(psmouse
);
629 psmouse_err(psmouse
, "failed to select mode\n");
633 hgpk_reset_hack_state(psmouse
);
638 static int hgpk_force_recalibrate(struct psmouse
*psmouse
)
640 struct hgpk_data
*priv
= psmouse
->private;
643 /* C-series touchpads added the recalibrate command */
644 if (psmouse
->model
< HGPK_MODEL_C
)
648 psmouse_dbg(psmouse
, "recalibration disabled, ignoring\n");
652 psmouse_dbg(psmouse
, "recalibrating touchpad..\n");
654 /* we don't want to race with the irq handler, nor with resyncs */
655 psmouse_set_state(psmouse
, PSMOUSE_INITIALIZING
);
657 /* start by resetting the device */
658 err
= hgpk_reset_device(psmouse
, true);
663 * XXX: If a finger is down during this delay, recalibration will
664 * detect capacitance incorrectly. This is a hardware bug, and
665 * we don't have a good way to deal with it. The 2s window stuff
666 * (below) is our best option for now.
668 if (psmouse_activate(psmouse
))
672 psmouse_dbg(psmouse
, "touchpad reactivated\n");
675 * If we get packets right away after recalibrating, it's likely
676 * that a finger was on the touchpad. If so, it's probably
677 * miscalibrated, so we optionally schedule another.
679 if (recal_guard_time
)
680 priv
->recalib_window
= jiffies
+
681 msecs_to_jiffies(recal_guard_time
);
687 * This puts the touchpad in a power saving mode; according to ALPS, current
688 * consumption goes down to 50uA after running this. To turn power back on,
689 * we drive MS-DAT low. Measuring with a 1mA resolution ammeter says that
690 * the current on the SUS_3.3V rail drops from 3mA or 4mA to 0 when we do this.
692 * We have no formal spec that details this operation -- the low-power
693 * sequence came from a long-lost email trail.
695 static int hgpk_toggle_powersave(struct psmouse
*psmouse
, int enable
)
697 struct ps2dev
*ps2dev
= &psmouse
->ps2dev
;
701 /* Added on D-series touchpads */
702 if (psmouse
->model
< HGPK_MODEL_D
)
706 psmouse_set_state(psmouse
, PSMOUSE_INITIALIZING
);
709 * Sending a byte will drive MS-DAT low; this will wake up
710 * the controller. Once we get an ACK back from it, it
711 * means we can continue with the touchpad re-init. ALPS
712 * tells us that 1s should be long enough, so set that as
713 * the upper bound. (in practice, it takes about 3 loops.)
715 for (timeo
= 20; timeo
> 0; timeo
--) {
716 if (!ps2_sendbyte(&psmouse
->ps2dev
,
717 PSMOUSE_CMD_DISABLE
, 20))
722 err
= hgpk_reset_device(psmouse
, false);
724 psmouse_err(psmouse
, "Failed to reset device!\n");
728 /* should be all set, enable the touchpad */
729 psmouse_activate(psmouse
);
730 psmouse_dbg(psmouse
, "Touchpad powered up.\n");
732 psmouse_dbg(psmouse
, "Powering off touchpad.\n");
734 if (ps2_command(ps2dev
, NULL
, 0xec) ||
735 ps2_command(ps2dev
, NULL
, 0xec) ||
736 ps2_command(ps2dev
, NULL
, 0xea)) {
740 psmouse_set_state(psmouse
, PSMOUSE_IGNORE
);
742 /* probably won't see an ACK, the touchpad will be off */
743 ps2_sendbyte(&psmouse
->ps2dev
, 0xec, 20);
749 static int hgpk_poll(struct psmouse
*psmouse
)
751 /* We can't poll, so always return failure. */
755 static int hgpk_reconnect(struct psmouse
*psmouse
)
757 struct hgpk_data
*priv
= psmouse
->private;
760 * During suspend/resume the ps2 rails remain powered. We don't want
761 * to do a reset because it's flush data out of buffers; however,
762 * earlier prototypes (B1) had some brokenness that required a reset.
764 if (olpc_board_at_least(olpc_board(0xb2)))
765 if (psmouse
->ps2dev
.serio
->dev
.power
.power_state
.event
!=
770 return hgpk_reset_device(psmouse
, false);
773 static ssize_t
hgpk_show_powered(struct psmouse
*psmouse
, void *data
, char *buf
)
775 struct hgpk_data
*priv
= psmouse
->private;
777 return sprintf(buf
, "%d\n", priv
->powered
);
780 static ssize_t
hgpk_set_powered(struct psmouse
*psmouse
, void *data
,
781 const char *buf
, size_t count
)
783 struct hgpk_data
*priv
= psmouse
->private;
787 err
= kstrtouint(buf
, 10, &value
);
794 if (value
!= priv
->powered
) {
796 * hgpk_toggle_power will deal w/ state so
797 * we're not racing w/ irq
799 err
= hgpk_toggle_powersave(psmouse
, value
);
801 priv
->powered
= value
;
804 return err
? err
: count
;
807 __PSMOUSE_DEFINE_ATTR(powered
, S_IWUSR
| S_IRUGO
, NULL
,
808 hgpk_show_powered
, hgpk_set_powered
, false);
810 static ssize_t
attr_show_mode(struct psmouse
*psmouse
, void *data
, char *buf
)
812 struct hgpk_data
*priv
= psmouse
->private;
814 return sprintf(buf
, "%s\n", hgpk_mode_names
[priv
->mode
]);
817 static ssize_t
attr_set_mode(struct psmouse
*psmouse
, void *data
,
818 const char *buf
, size_t len
)
820 struct hgpk_data
*priv
= psmouse
->private;
821 enum hgpk_mode old_mode
= priv
->mode
;
822 enum hgpk_mode new_mode
= hgpk_mode_from_name(buf
, len
);
823 struct input_dev
*old_dev
= psmouse
->dev
;
824 struct input_dev
*new_dev
;
827 if (new_mode
== HGPK_MODE_INVALID
)
830 if (old_mode
== new_mode
)
833 new_dev
= input_allocate_device();
837 psmouse_set_state(psmouse
, PSMOUSE_INITIALIZING
);
839 /* Switch device into the new mode */
840 priv
->mode
= new_mode
;
841 err
= hgpk_reset_device(psmouse
, false);
843 goto err_try_restore
;
845 hgpk_setup_input_device(new_dev
, old_dev
, new_mode
);
847 psmouse_set_state(psmouse
, PSMOUSE_CMD_MODE
);
849 err
= input_register_device(new_dev
);
851 goto err_try_restore
;
853 psmouse
->dev
= new_dev
;
854 input_unregister_device(old_dev
);
859 input_free_device(new_dev
);
860 priv
->mode
= old_mode
;
861 hgpk_reset_device(psmouse
, false);
866 PSMOUSE_DEFINE_ATTR(hgpk_mode
, S_IWUSR
| S_IRUGO
, NULL
,
867 attr_show_mode
, attr_set_mode
);
869 static ssize_t
hgpk_trigger_recal_show(struct psmouse
*psmouse
,
870 void *data
, char *buf
)
875 static ssize_t
hgpk_trigger_recal(struct psmouse
*psmouse
, void *data
,
876 const char *buf
, size_t count
)
878 struct hgpk_data
*priv
= psmouse
->private;
882 err
= kstrtouint(buf
, 10, &value
);
890 * We queue work instead of doing recalibration right here
891 * to avoid adding locking to to hgpk_force_recalibrate()
892 * since workqueue provides serialization.
894 psmouse_queue_work(psmouse
, &priv
->recalib_wq
, 0);
898 __PSMOUSE_DEFINE_ATTR(recalibrate
, S_IWUSR
| S_IRUGO
, NULL
,
899 hgpk_trigger_recal_show
, hgpk_trigger_recal
, false);
901 static void hgpk_disconnect(struct psmouse
*psmouse
)
903 struct hgpk_data
*priv
= psmouse
->private;
905 device_remove_file(&psmouse
->ps2dev
.serio
->dev
,
906 &psmouse_attr_powered
.dattr
);
907 device_remove_file(&psmouse
->ps2dev
.serio
->dev
,
908 &psmouse_attr_hgpk_mode
.dattr
);
910 if (psmouse
->model
>= HGPK_MODEL_C
)
911 device_remove_file(&psmouse
->ps2dev
.serio
->dev
,
912 &psmouse_attr_recalibrate
.dattr
);
914 psmouse_reset(psmouse
);
918 static void hgpk_recalib_work(struct work_struct
*work
)
920 struct delayed_work
*w
= to_delayed_work(work
);
921 struct hgpk_data
*priv
= container_of(w
, struct hgpk_data
, recalib_wq
);
922 struct psmouse
*psmouse
= priv
->psmouse
;
924 if (hgpk_force_recalibrate(psmouse
))
925 psmouse_err(psmouse
, "recalibration failed!\n");
928 static int hgpk_register(struct psmouse
*psmouse
)
930 struct hgpk_data
*priv
= psmouse
->private;
933 /* register handlers */
934 psmouse
->protocol_handler
= hgpk_process_byte
;
935 psmouse
->poll
= hgpk_poll
;
936 psmouse
->disconnect
= hgpk_disconnect
;
937 psmouse
->reconnect
= hgpk_reconnect
;
939 /* Disable the idle resync. */
940 psmouse
->resync_time
= 0;
941 /* Reset after a lot of bad bytes. */
942 psmouse
->resetafter
= 1024;
944 hgpk_setup_input_device(psmouse
->dev
, NULL
, priv
->mode
);
946 err
= device_create_file(&psmouse
->ps2dev
.serio
->dev
,
947 &psmouse_attr_powered
.dattr
);
949 psmouse_err(psmouse
, "Failed creating 'powered' sysfs node\n");
953 err
= device_create_file(&psmouse
->ps2dev
.serio
->dev
,
954 &psmouse_attr_hgpk_mode
.dattr
);
957 "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 psmouse_dbg(psmouse
, "ID: %*ph\n", 3, param
);
1032 /* HGPK signature: 0x67, 0x00, 0x<model> */
1033 if (param
[0] != 0x67 || param
[1] != 0x00)
1036 psmouse_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
));