Merge branch 'next' into for-linus

10 files changed, 827 insertions, 117 deletions

diff --git a/drivers/input/mouse/Kconfig b/drivers/input/mouse/Kconfig
index f996546fc443..f488b6852baf 100644
--- a/drivers/input/mouse/Kconfig
+++ b/drivers/input/mouse/Kconfig
@@ -96,6 +96,16 @@ config MOUSE_PS2_TOUCHKIT
 
           If unsure, say N.
 
+config MOUSE_PS2_OLPC
+        bool "OLPC PS/2 mouse protocol extension"
+        depends on MOUSE_PS2 && OLPC
+        help
+          Say Y here if you have an OLPC XO-1 laptop (with built-in
+          PS/2 touchpad/tablet device).  The manufacturer calls the
+          touchpad an HGPK.
+
+          If unsure, say N.
+
 config MOUSE_SERIAL
         tristate "Serial mouse"
         select SERIO
diff --git a/drivers/input/mouse/Makefile b/drivers/input/mouse/Makefile
index d4d202516090..8e6e69097801 100644
--- a/drivers/input/mouse/Makefile
+++ b/drivers/input/mouse/Makefile
@@ -21,6 +21,7 @@ obj-$(CONFIG_MOUSE_GPIO)	+= gpio_mouse.o
 psmouse-objs := psmouse-base.o synaptics.o
 
 psmouse-$(CONFIG_MOUSE_PS2_ALPS)        += alps.o
+psmouse-$(CONFIG_MOUSE_PS2_OLPC)        += hgpk.o
 psmouse-$(CONFIG_MOUSE_PS2_LOGIPS2PP)   += logips2pp.o
 psmouse-$(CONFIG_MOUSE_PS2_LIFEBOOK)    += lifebook.o
 psmouse-$(CONFIG_MOUSE_PS2_TRACKPOINT)  += trackpoint.o
diff --git a/drivers/input/mouse/alps.c b/drivers/input/mouse/alps.c
index 385e32bcf6a6..cbedf957cc58 100644
--- a/drivers/input/mouse/alps.c
+++ b/drivers/input/mouse/alps.c
@@ -54,6 +54,7 @@ static const struct alps_model_info alps_model_data[] = {
         { { 0x20, 0x02, 0x0e }, 0xf8, 0xf8, ALPS_PASS | ALPS_DUALPOINT }, /* XXX */
         { { 0x22, 0x02, 0x0a }, 0xf8, 0xf8, ALPS_PASS | ALPS_DUALPOINT },
         { { 0x22, 0x02, 0x14 }, 0xff, 0xff, ALPS_PASS | ALPS_DUALPOINT }, /* Dell Latitude D600 */
+        { { 0x62, 0x02, 0x14 }, 0xcf, 0xcf, ALPS_PASS | ALPS_DUALPOINT }, /* Dell Latitude E6500 */
         { { 0x73, 0x02, 0x50 }, 0xcf, 0xcf, ALPS_FW_BK_1 } /* Dell Vostro 1400 */
 };
 
diff --git a/drivers/input/mouse/appletouch.c b/drivers/input/mouse/appletouch.c
index 1f41ae94f26b..079816e6b23b 100644
--- a/drivers/input/mouse/appletouch.c
+++ b/drivers/input/mouse/appletouch.c
@@ -136,12 +136,28 @@ MODULE_DEVICE_TABLE(usb, atp_table);
 #define ATP_GEYSER_MODE_REQUEST_INDEX           0
 #define ATP_GEYSER_MODE_VENDOR_VALUE            0x04
 
+/**
+ * enum atp_status_bits - status bit meanings
+ *
+ * These constants represent the meaning of the status bits.
+ * (only Geyser 3/4)
+ *
+ * @ATP_STATUS_BUTTON: The button was pressed
+ * @ATP_STATUS_BASE_UPDATE: Update of the base values (untouched pad)
+ * @ATP_STATUS_FROM_RESET: Reset previously performed
+ */
+enum atp_status_bits {
+        ATP_STATUS_BUTTON       = BIT(0),
+        ATP_STATUS_BASE_UPDATE  = BIT(2),
+        ATP_STATUS_FROM_RESET   = BIT(4),
+};
+
 /* Structure to hold all of our device specific stuff */
 struct atp {
         char                    phys[64];
         struct usb_device       *udev;          /* usb device */
         struct urb              *urb;           /* usb request block */
-        signed char             *data;          /* transferred data */
+        u8                      *data;          /* transferred data */
         struct input_dev        *input;         /* input dev */
         enum atp_touchpad_type  type;           /* type of touchpad */
         bool                    open;
@@ -251,8 +267,6 @@ static void atp_reinit(struct work_struct *work)
         int retval;
 
         dprintk("appletouch: putting appletouch to sleep (reinit)\n");
-        dev->idlecount = 0;
-
         atp_geyser_init(udev);
 
         retval = usb_submit_urb(dev->urb, GFP_ATOMIC);
@@ -327,11 +341,14 @@ static inline void atp_report_fingers(struct input_dev *input, int fingers)
         input_report_key(input, BTN_TOOL_TRIPLETAP, fingers > 2);
 }
 
-static void atp_complete(struct urb *urb)
+/* Check URB status and for correct length of data package */
+
+#define ATP_URB_STATUS_SUCCESS          0
+#define ATP_URB_STATUS_ERROR            1
+#define ATP_URB_STATUS_ERROR_FATAL      2
+
+static int atp_status_check(struct urb *urb)
 {
-        int x, y, x_z, y_z, x_f, y_f;
-        int retval, i, j;
-        int key;
         struct atp *dev = urb->context;
 
         switch (urb->status) {
@@ -351,11 +368,12 @@ static void atp_complete(struct urb *urb)
                 /* This urb is terminated, clean up */
                 dbg("atp_complete: urb shutting down with status: %d",
                     urb->status);
-                return;
+                return ATP_URB_STATUS_ERROR_FATAL;
+
         default:
                 dbg("atp_complete: nonzero urb status received: %d",
                     urb->status);
-                goto exit;
+                return ATP_URB_STATUS_ERROR;
         }
 
         /* drop incomplete datasets */
@@ -363,30 +381,33 @@ static void atp_complete(struct urb *urb)
                 dprintk("appletouch: incomplete data package"
                         " (first byte: %d, length: %d).\n",
                         dev->data[0], dev->urb->actual_length);
-                goto exit;
+                return ATP_URB_STATUS_ERROR;
         }
 
-        /* reorder the sensors values */
-        if (dev->type == ATP_GEYSER3 || dev->type == ATP_GEYSER4) {
-                memset(dev->xy_cur, 0, sizeof(dev->xy_cur));
+        return ATP_URB_STATUS_SUCCESS;
+}
 
-                /*
-                 * The values are laid out like this:
-                 * -, Y1, Y2, -, Y3, Y4, -, ..., -, X1, X2, -, X3, X4, ...
-                 * '-' is an unused value.
-                 */
+/*
+ * USB interrupt callback functions
+ */
 
-                /* read X values */
-                for (i = 0, j = 19; i < 20; i += 2, j += 3) {
-                        dev->xy_cur[i] = dev->data[j + 1];
-                        dev->xy_cur[i + 1] = dev->data[j + 2];
-                }
-                /* read Y values */
-                for (i = 0, j = 1; i < 9; i += 2, j += 3) {
-                        dev->xy_cur[ATP_XSENSORS + i] = dev->data[j + 1];
-                        dev->xy_cur[ATP_XSENSORS + i + 1] = dev->data[j + 2];
-                }
-        } else if (dev->type == ATP_GEYSER2) {
+/* Interrupt function for older touchpads: FOUNTAIN/GEYSER1/GEYSER2 */
+
+static void atp_complete_geyser_1_2(struct urb *urb)
+{
+        int x, y, x_z, y_z, x_f, y_f;
+        int retval, i, j;
+        int key;
+        struct atp *dev = urb->context;
+        int status = atp_status_check(urb);
+
+        if (status == ATP_URB_STATUS_ERROR_FATAL)
+                return;
+        else if (status == ATP_URB_STATUS_ERROR)
+                goto exit;
+
+        /* reorder the sensors values */
+        if (dev->type == ATP_GEYSER2) {
                 memset(dev->xy_cur, 0, sizeof(dev->xy_cur));
 
                 /*
@@ -427,34 +448,40 @@ static void atp_complete(struct urb *urb)
                 /* first sample */
                 dev->valid = true;
                 dev->x_old = dev->y_old = -1;
+
+                /* Store first sample */
                 memcpy(dev->xy_old, dev->xy_cur, sizeof(dev->xy_old));
 
-                if (dev->size_detect_done ||
-                    dev->type == ATP_GEYSER3) /* No 17" Macbooks (yet) */
-                        goto exit;
+                /* Perform size detection, if not done already */
+                if (!dev->size_detect_done) {
+
+                        /* 17" Powerbooks have extra X sensors */
+                        for (i = (dev->type == ATP_GEYSER2 ? 15 : 16);
+                             i < ATP_XSENSORS; i++) {
+                                if (!dev->xy_cur[i])
+                                        continue;
+
+                                printk(KERN_INFO
+                                        "appletouch: 17\" model detected.\n");
+
+                                if (dev->type == ATP_GEYSER2)
+                                        input_set_abs_params(dev->input, ABS_X,
+                                                             0,
+                                                             (20 - 1) *
+                                                             ATP_XFACT - 1,
+                                                             ATP_FUZZ, 0);
+                                else
+                                        input_set_abs_params(dev->input, ABS_X,
+                                                             0,
+                                                             (26 - 1) *
+                                                             ATP_XFACT - 1,
+                                                             ATP_FUZZ, 0);
+                                break;
+                        }
 
-                /* 17" Powerbooks have extra X sensors */
-                for (i = (dev->type == ATP_GEYSER2 ? 15 : 16);
-                     i < ATP_XSENSORS; i++) {
-                        if (!dev->xy_cur[i])
-                                continue;
-
-                        printk(KERN_INFO "appletouch: 17\" model detected.\n");
-                        if (dev->type == ATP_GEYSER2)
-                                input_set_abs_params(dev->input, ABS_X, 0,
-                                                     (20 - 1) *
-                                                     ATP_XFACT - 1,
-                                                     ATP_FUZZ, 0);
-                        else
-                                input_set_abs_params(dev->input, ABS_X, 0,
-                                                     (ATP_XSENSORS - 1) *
-                                                     ATP_XFACT - 1,
-                                                     ATP_FUZZ, 0);
-                        break;
+                        dev->size_detect_done = 1;
+                        goto exit;
                 }
-
-                dev->size_detect_done = 1;
-                goto exit;
         }
 
         for (i = 0; i < ATP_XSENSORS + ATP_YSENSORS; i++) {
@@ -475,7 +502,118 @@ static void atp_complete(struct urb *urb)
                               ATP_XFACT, &x_z, &x_f);
         y = atp_calculate_abs(dev->xy_acc + ATP_XSENSORS, ATP_YSENSORS,
                               ATP_YFACT, &y_z, &y_f);
-        key = dev->data[dev->datalen - 1] & 1;
+        key = dev->data[dev->datalen - 1] & ATP_STATUS_BUTTON;
+
+        if (x && y) {
+                if (dev->x_old != -1) {
+                        x = (dev->x_old * 3 + x) >> 2;
+                        y = (dev->y_old * 3 + y) >> 2;
+                        dev->x_old = x;
+                        dev->y_old = y;
+
+                        if (debug > 1)
+                                printk(KERN_DEBUG "appletouch: "
+                                        "X: %3d Y: %3d Xz: %3d Yz: %3d\n",
+                                        x, y, x_z, y_z);
+
+                        input_report_key(dev->input, BTN_TOUCH, 1);
+                        input_report_abs(dev->input, ABS_X, x);
+                        input_report_abs(dev->input, ABS_Y, y);
+                        input_report_abs(dev->input, ABS_PRESSURE,
+                                         min(ATP_PRESSURE, x_z + y_z));
+                        atp_report_fingers(dev->input, max(x_f, y_f));
+                }
+                dev->x_old = x;
+                dev->y_old = y;
+
+        } else if (!x && !y) {
+
+                dev->x_old = dev->y_old = -1;
+                input_report_key(dev->input, BTN_TOUCH, 0);
+                input_report_abs(dev->input, ABS_PRESSURE, 0);
+                atp_report_fingers(dev->input, 0);
+
+                /* reset the accumulator on release */
+                memset(dev->xy_acc, 0, sizeof(dev->xy_acc));
+        }
+
+        input_report_key(dev->input, BTN_LEFT, key);
+        input_sync(dev->input);
+
+ exit:
+        retval = usb_submit_urb(dev->urb, GFP_ATOMIC);
+        if (retval)
+                err("atp_complete: usb_submit_urb failed with result %d",
+                    retval);
+}
+
+/* Interrupt function for older touchpads: GEYSER3/GEYSER4 */
+
+static void atp_complete_geyser_3_4(struct urb *urb)
+{
+        int x, y, x_z, y_z, x_f, y_f;
+        int retval, i, j;
+        int key;
+        struct atp *dev = urb->context;
+        int status = atp_status_check(urb);
+
+        if (status == ATP_URB_STATUS_ERROR_FATAL)
+                return;
+        else if (status == ATP_URB_STATUS_ERROR)
+                goto exit;
+
+        /* Reorder the sensors values:
+         *
+         * The values are laid out like this:
+         * -, Y1, Y2, -, Y3, Y4, -, ..., -, X1, X2, -, X3, X4, ...
+         * '-' is an unused value.
+         */
+
+        /* read X values */
+        for (i = 0, j = 19; i < 20; i += 2, j += 3) {
+                dev->xy_cur[i] = dev->data[j + 1];
+                dev->xy_cur[i + 1] = dev->data[j + 2];
+        }
+        /* read Y values */
+        for (i = 0, j = 1; i < 9; i += 2, j += 3) {
+                dev->xy_cur[ATP_XSENSORS + i] = dev->data[j + 1];
+                dev->xy_cur[ATP_XSENSORS + i + 1] = dev->data[j + 2];
+        }
+
+        dbg_dump("sample", dev->xy_cur);
+
+        /* Just update the base values (i.e. touchpad in untouched state) */
+        if (dev->data[dev->datalen - 1] & ATP_STATUS_BASE_UPDATE) {
+
+                dprintk(KERN_DEBUG "appletouch: updated base values\n");
+
+                memcpy(dev->xy_old, dev->xy_cur, sizeof(dev->xy_old));
+                goto exit;
+        }
+
+        for (i = 0; i < ATP_XSENSORS + ATP_YSENSORS; i++) {
+                /* calculate the change */
+                dev->xy_acc[i] = dev->xy_cur[i] - dev->xy_old[i];
+
+                /* this is a round-robin value, so couple with that */
+                if (dev->xy_acc[i] > 127)
+                        dev->xy_acc[i] -= 256;
+
+                if (dev->xy_acc[i] < -127)
+                        dev->xy_acc[i] += 256;
+
+                /* prevent down drifting */
+                if (dev->xy_acc[i] < 0)
+                        dev->xy_acc[i] = 0;
+        }
+
+        dbg_dump("accumulator", dev->xy_acc);
+
+        x = atp_calculate_abs(dev->xy_acc, ATP_XSENSORS,
+                              ATP_XFACT, &x_z, &x_f);
+        y = atp_calculate_abs(dev->xy_acc + ATP_XSENSORS, ATP_YSENSORS,
+                              ATP_YFACT, &y_z, &y_f);
+        key = dev->data[dev->datalen - 1] & ATP_STATUS_BUTTON;
 
         if (x && y) {
                 if (dev->x_old != -1) {
@@ -514,28 +652,27 @@ static void atp_complete(struct urb *urb)
         input_sync(dev->input);
 
         /*
-         * Many Geysers will continue to send packets continually after
+         * Geysers 3/4 will continue to send packets continually after
          * the first touch unless reinitialised. Do so if it's been
          * idle for a while in order to avoid waking the kernel up
-         * several hundred times a second. Re-initialization does not
-         * work on Fountain touchpads.
+         * several hundred times a second.
          */
-        if (dev->type != ATP_FOUNTAIN) {
-                /*
-                 * Button must not be pressed when entering suspend,
-                 * otherwise we will never release the button.
-                 */
-                if (!x && !y && !key) {
-                        dev->idlecount++;
-                        if (dev->idlecount == 10) {
-                                dev->valid = false;
-                                schedule_work(&dev->work);
-                                /* Don't resubmit urb here, wait for reinit */
-                                return;
-                        }
-                } else
+
+        /*
+         * Button must not be pressed when entering suspend,
+         * otherwise we will never release the button.
+         */
+        if (!x && !y && !key) {
+                dev->idlecount++;
+                if (dev->idlecount == 10) {
+                        dev->x_old = dev->y_old = -1;
                         dev->idlecount = 0;
-        }
+                        schedule_work(&dev->work);
+                        /* Don't resubmit urb here, wait for reinit */
+                        return;
+                }
+        } else
+                dev->idlecount = 0;
 
  exit:
         retval = usb_submit_urb(dev->urb, GFP_ATOMIC);
@@ -632,9 +769,19 @@ static int atp_probe(struct usb_interface *iface,
         if (!dev->data)
                 goto err_free_urb;
 
-        usb_fill_int_urb(dev->urb, udev,
-                         usb_rcvintpipe(udev, int_in_endpointAddr),
-                         dev->data, dev->datalen, atp_complete, dev, 1);
+        /* Select the USB complete (callback) function */
+        if (dev->type == ATP_FOUNTAIN ||
+            dev->type == ATP_GEYSER1 ||
+            dev->type == ATP_GEYSER2)
+                usb_fill_int_urb(dev->urb, udev,
+                                 usb_rcvintpipe(udev, int_in_endpointAddr),
+                                 dev->data, dev->datalen,
+                                 atp_complete_geyser_1_2, dev, 1);
+        else
+                usb_fill_int_urb(dev->urb, udev,
+                                 usb_rcvintpipe(udev, int_in_endpointAddr),
+                                 dev->data, dev->datalen,
+                                 atp_complete_geyser_3_4, dev, 1);
 
         error = atp_handle_geyser(dev);
         if (error)
@@ -751,8 +898,6 @@ static int atp_suspend(struct usb_interface *iface, pm_message_t message)
         struct atp *dev = usb_get_intfdata(iface);
 
         usb_kill_urb(dev->urb);
-        dev->valid = false;
-
         return 0;
 }
 
diff --git a/drivers/input/mouse/hgpk.c b/drivers/input/mouse/hgpk.c
new file mode 100644
index 000000000000..e82d34201e97
--- /dev/null
+++ b/drivers/input/mouse/hgpk.c
@@ -0,0 +1,477 @@
+/*
+ * OLPC HGPK (XO-1) touchpad PS/2 mouse driver
+ *
+ * Copyright (c) 2006-2008 One Laptop Per Child
+ * Authors:
+ *   Zephaniah E. Hull
+ *   Andres Salomon <dilinger@debian.org>
+ *
+ * This driver is partly based on the ALPS driver, which is:
+ *
+ * Copyright (c) 2003 Neil Brown <neilb@cse.unsw.edu.au>
+ * Copyright (c) 2003-2005 Peter Osterlund <petero2@telia.com>
+ * Copyright (c) 2004 Dmitry Torokhov <dtor@mail.ru>
+ * Copyright (c) 2005 Vojtech Pavlik <vojtech@suse.cz>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+/*
+ * The spec from ALPS is available from
+ * <http://wiki.laptop.org/go/Touch_Pad/Tablet>.  It refers to this
+ * device as HGPK (Hybrid GS, PT, and Keymatrix).
+ *
+ * The earliest versions of the device had simultaneous reporting; that
+ * was removed.  After that, the device used the Advanced Mode GS/PT streaming
+ * stuff.  That turned out to be too buggy to support, so we've finally
+ * switched to Mouse Mode (which utilizes only the center 1/3 of the touchpad).
+ */
+
+#define DEBUG
+#include <linux/input.h>
+#include <linux/serio.h>
+#include <linux/libps2.h>
+#include <linux/delay.h>
+#include <asm/olpc.h>
+
+#include "psmouse.h"
+#include "hgpk.h"
+
+static int tpdebug;
+module_param(tpdebug, int, 0644);
+MODULE_PARM_DESC(tpdebug, "enable debugging, dumping packets to KERN_DEBUG.");
+
+static int recalib_delta = 100;
+module_param(recalib_delta, int, 0644);
+MODULE_PARM_DESC(recalib_delta,
+        "packets containing a delta this large will cause a recalibration.");
+
+/*
+ * When the touchpad gets ultra-sensitive, one can keep their finger 1/2"
+ * above the pad and still have it send packets.  This causes a jump cursor
+ * when one places their finger on the pad.  We can probably detect the
+ * jump as we see a large deltas (>= 100px).  In mouse mode, I've been
+ * unable to even come close to 100px deltas during normal usage, so I think
+ * this threshold is safe.  If a large delta occurs, trigger a recalibration.
+ */
+static void hgpk_jumpy_hack(struct psmouse *psmouse, int x, int y)
+{
+        struct hgpk_data *priv = psmouse->private;
+
+        if (abs(x) > recalib_delta || abs(y) > recalib_delta) {
+                hgpk_err(psmouse, ">%dpx jump detected (%d,%d)\n",
+                                recalib_delta, x, y);
+                /* My car gets forty rods to the hogshead and that's the
+                 * way I likes it! */
+                psmouse_queue_work(psmouse, &priv->recalib_wq,
+                                msecs_to_jiffies(1000));
+        }
+}
+
+/*
+ * We have no idea why this particular hardware bug occurs.  The touchpad
+ * will randomly start spewing packets without anything touching the
+ * pad.  This wouldn't necessarily be bad, but it's indicative of a
+ * severely miscalibrated pad; attempting to use the touchpad while it's
+ * spewing means the cursor will jump all over the place, and act "drunk".
+ *
+ * The packets that are spewed tend to all have deltas between -2 and 2, and
+ * the cursor will move around without really going very far.  It will
+ * tend to end up in the same location; if we tally up the changes over
+ * 100 packets, we end up w/ a final delta of close to 0.  This happens
+ * pretty regularly when the touchpad is spewing, and is pretty hard to
+ * manually trigger (at least for *my* fingers).  So, it makes a perfect
+ * scheme for detecting spews.
+ */
+static void hgpk_spewing_hack(struct psmouse *psmouse,
+                              int l, int r, int x, int y)
+{
+        struct hgpk_data *priv = psmouse->private;
+
+        /* ignore button press packets; many in a row could trigger
+         * a false-positive! */
+        if (l || r)
+                return;
+
+        priv->x_tally += x;
+        priv->y_tally += y;
+
+        if (++priv->count > 100) {
+                if (abs(priv->x_tally) < 3 && abs(priv->y_tally) < 3) {
+                        hgpk_dbg(psmouse, "packet spew detected (%d,%d)\n",
+                                 priv->x_tally, priv->y_tally);
+                        psmouse_queue_work(psmouse, &priv->recalib_wq,
+                                           msecs_to_jiffies(1000));
+                }
+                /* reset every 100 packets */
+                priv->count = 0;
+                priv->x_tally = 0;
+                priv->y_tally = 0;
+        }
+}
+
+/*
+ * HGPK Mouse Mode format (standard mouse format, sans middle button)
+ *
+ * byte 0:      y-over  x-over  y-neg   x-neg   1       0       swr     swl
+ * byte 1:      x7      x6      x5      x4      x3      x2      x1      x0
+ * byte 2:      y7      y6      y5      y4      y3      y2      y1      y0
+ *
+ * swr/swl are the left/right buttons.
+ * x-neg/y-neg are the x and y delta negative bits
+ * x-over/y-over are the x and y overflow bits
+ */
+static int hgpk_validate_byte(unsigned char *packet)
+{
+        return (packet[0] & 0x0C) == 0x08;
+}
+
+static void hgpk_process_packet(struct psmouse *psmouse)
+{
+        struct input_dev *dev = psmouse->dev;
+        unsigned char *packet = psmouse->packet;
+        int x, y, left, right;
+
+        left = packet[0] & 1;
+        right = (packet[0] >> 1) & 1;
+
+        x = packet[1] - ((packet[0] << 4) & 0x100);
+        y = ((packet[0] << 3) & 0x100) - packet[2];
+
+        hgpk_jumpy_hack(psmouse, x, y);
+        hgpk_spewing_hack(psmouse, left, right, x, y);
+
+        if (tpdebug)
+                hgpk_dbg(psmouse, "l=%d r=%d x=%d y=%d\n", left, right, x, y);
+
+        input_report_key(dev, BTN_LEFT, left);
+        input_report_key(dev, BTN_RIGHT, right);
+
+        input_report_rel(dev, REL_X, x);
+        input_report_rel(dev, REL_Y, y);
+
+        input_sync(dev);
+}
+
+static psmouse_ret_t hgpk_process_byte(struct psmouse *psmouse)
+{
+        struct hgpk_data *priv = psmouse->private;
+
+        if (hgpk_validate_byte(psmouse->packet)) {
+                hgpk_dbg(psmouse, "%s: (%d) %02x %02x %02x\n",
+                                __func__, psmouse->pktcnt, psmouse->packet[0],
+                                psmouse->packet[1], psmouse->packet[2]);
+                return PSMOUSE_BAD_DATA;
+        }
+
+        if (psmouse->pktcnt >= psmouse->pktsize) {
+                hgpk_process_packet(psmouse);
+                return PSMOUSE_FULL_PACKET;
+        }
+
+        if (priv->recalib_window) {
+                if (time_before(jiffies, priv->recalib_window)) {
+                        /*
+                         * ugh, got a packet inside our recalibration
+                         * window, schedule another recalibration.
+                         */
+                        hgpk_dbg(psmouse,
+                                 "packet inside calibration window, "
+                                 "queueing another recalibration\n");
+                        psmouse_queue_work(psmouse, &priv->recalib_wq,
+                                        msecs_to_jiffies(1000));
+                }
+                priv->recalib_window = 0;
+        }
+
+        return PSMOUSE_GOOD_DATA;
+}
+
+static int hgpk_force_recalibrate(struct psmouse *psmouse)
+{
+        struct ps2dev *ps2dev = &psmouse->ps2dev;
+        struct hgpk_data *priv = psmouse->private;
+
+        /* C-series touchpads added the recalibrate command */
+        if (psmouse->model < HGPK_MODEL_C)
+                return 0;
+
+        /* we don't want to race with the irq handler, nor with resyncs */
+        psmouse_set_state(psmouse, PSMOUSE_INITIALIZING);
+
+        /* start by resetting the device */
+        psmouse_reset(psmouse);
+
+        /* send the recalibrate request */
+        if (ps2_command(ps2dev, NULL, 0xf5) ||
+            ps2_command(ps2dev, NULL, 0xf5) ||
+            ps2_command(ps2dev, NULL, 0xe6) ||
+            ps2_command(ps2dev, NULL, 0xf5)) {
+                return -1;
+        }
+
+        /* according to ALPS, 150mS is required for recalibration */
+        msleep(150);
+
+        /* XXX: If a finger is down during this delay, recalibration will
+         * detect capacitance incorrectly.  This is a hardware bug, and
+         * we don't have a good way to deal with it.  The 2s window stuff
+         * (below) is our best option for now.
+         */
+
+        if (ps2_command(ps2dev, NULL, PSMOUSE_CMD_ENABLE))
+                return -1;
+
+        psmouse_set_state(psmouse, PSMOUSE_ACTIVATED);
+
+        /* After we recalibrate, we shouldn't get any packets for 2s.  If
+         * we do, it's likely that someone's finger was on the touchpad.
+         * If someone's finger *was* on the touchpad, it's probably
+         * miscalibrated.  So, we should schedule another recalibration
+         */
+        priv->recalib_window = jiffies +  msecs_to_jiffies(2000);
+
+        return 0;
+}
+
+/*
+ * This kills power to the touchpad; according to ALPS, current consumption
+ * goes down to 50uA after running this.  To turn power back on, we drive
+ * MS-DAT low.
+ */
+static int hgpk_toggle_power(struct psmouse *psmouse, int enable)
+{
+        struct ps2dev *ps2dev = &psmouse->ps2dev;
+        int timeo;
+
+        /* Added on D-series touchpads */
+        if (psmouse->model < HGPK_MODEL_D)
+                return 0;
+
+        if (enable) {
+                psmouse_set_state(psmouse, PSMOUSE_INITIALIZING);
+
+                /*
+                 * Sending a byte will drive MS-DAT low; this will wake up
+                 * the controller.  Once we get an ACK back from it, it
+                 * means we can continue with the touchpad re-init.  ALPS
+                 * tells us that 1s should be long enough, so set that as
+                 * the upper bound.
+                 */
+                for (timeo = 20; timeo > 0; timeo--) {
+                        if (!ps2_sendbyte(&psmouse->ps2dev,
+                                        PSMOUSE_CMD_DISABLE, 20))
+                                break;
+                        msleep(50);
+                }
+
+                psmouse_reset(psmouse);
+
+                /* should be all set, enable the touchpad */
+                ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_ENABLE);
+                psmouse_set_state(psmouse, PSMOUSE_ACTIVATED);
+
+        } else {
+                hgpk_dbg(psmouse, "Powering off touchpad.\n");
+                psmouse_set_state(psmouse, PSMOUSE_IGNORE);
+
+                if (ps2_command(ps2dev, NULL, 0xec) ||
+                    ps2_command(ps2dev, NULL, 0xec) ||
+                    ps2_command(ps2dev, NULL, 0xea)) {
+                        return -1;
+                }
+
+                /* probably won't see an ACK, the touchpad will be off */
+                ps2_sendbyte(&psmouse->ps2dev, 0xec, 20);
+        }
+
+        return 0;
+}
+
+static int hgpk_poll(struct psmouse *psmouse)
+{
+        /* We can't poll, so always return failure. */
+        return -1;
+}
+
+static int hgpk_reconnect(struct psmouse *psmouse)
+{
+        /* During suspend/resume the ps2 rails remain powered.  We don't want
+         * to do a reset because it's flush data out of buffers; however,
+         * earlier prototypes (B1) had some brokenness that required a reset. */
+        if (olpc_board_at_least(olpc_board(0xb2)))
+                if (psmouse->ps2dev.serio->dev.power.power_state.event !=
+                                PM_EVENT_ON)
+                        return 0;
+
+        psmouse_reset(psmouse);
+
+        return 0;
+}
+
+static ssize_t hgpk_show_powered(struct psmouse *psmouse, void *data, char *buf)
+{
+        struct hgpk_data *priv = psmouse->private;
+
+        return sprintf(buf, "%d\n", priv->powered);
+}
+
+static ssize_t hgpk_set_powered(struct psmouse *psmouse, void *data,
+                                const char *buf, size_t count)
+{
+        struct hgpk_data *priv = psmouse->private;
+        unsigned long value;
+        int err;
+
+        err = strict_strtoul(buf, 10, &value);
+        if (err || value > 1)
+                return -EINVAL;
+
+        if (value != priv->powered) {
+                /*
+                 * hgpk_toggle_power will deal w/ state so
+                 * we're not racing w/ irq
+                 */
+                err = hgpk_toggle_power(psmouse, value);
+                if (!err)
+                        priv->powered = value;
+        }
+
+        return err ? err : count;
+}
+
+__PSMOUSE_DEFINE_ATTR(powered, S_IWUSR | S_IRUGO, NULL,
+                      hgpk_show_powered, hgpk_set_powered, 0);
+
+static void hgpk_disconnect(struct psmouse *psmouse)
+{
+        struct hgpk_data *priv = psmouse->private;
+
+        device_remove_file(&psmouse->ps2dev.serio->dev,
+                           &psmouse_attr_powered.dattr);
+        psmouse_reset(psmouse);
+        kfree(priv);
+}
+
+static void hgpk_recalib_work(struct work_struct *work)
+{
+        struct delayed_work *w = container_of(work, struct delayed_work, work);
+        struct hgpk_data *priv = container_of(w, struct hgpk_data, recalib_wq);
+        struct psmouse *psmouse = priv->psmouse;
+
+        hgpk_dbg(psmouse, "recalibrating touchpad..\n");
+
+        if (hgpk_force_recalibrate(psmouse))
+                hgpk_err(psmouse, "recalibration failed!\n");
+}
+
+static int hgpk_register(struct psmouse *psmouse)
+{
+        struct input_dev *dev = psmouse->dev;
+        int err;
+
+        /* unset the things that psmouse-base sets which we don't have */
+        __clear_bit(BTN_MIDDLE, dev->keybit);
+
+        /* set the things we do have */
+        __set_bit(EV_KEY, dev->evbit);
+        __set_bit(EV_REL, dev->evbit);
+
+        __set_bit(REL_X, dev->relbit);
+        __set_bit(REL_Y, dev->relbit);
+
+        __set_bit(BTN_LEFT, dev->keybit);
+        __set_bit(BTN_RIGHT, dev->keybit);
+
+        /* register handlers */
+        psmouse->protocol_handler = hgpk_process_byte;
+        psmouse->poll = hgpk_poll;
+        psmouse->disconnect = hgpk_disconnect;
+        psmouse->reconnect = hgpk_reconnect;
+        psmouse->pktsize = 3;
+
+        /* Disable the idle resync. */
+        psmouse->resync_time = 0;
+        /* Reset after a lot of bad bytes. */
+        psmouse->resetafter = 1024;
+
+        err = device_create_file(&psmouse->ps2dev.serio->dev,
+                                 &psmouse_attr_powered.dattr);
+        if (err)
+                hgpk_err(psmouse, "Failed to create sysfs attribute\n");
+
+        return err;
+}
+
+int hgpk_init(struct psmouse *psmouse)
+{
+        struct hgpk_data *priv;
+        int err = -ENOMEM;
+
+        priv = kzalloc(sizeof(struct hgpk_data), GFP_KERNEL);
+        if (!priv)
+                goto alloc_fail;
+
+        psmouse->private = priv;
+        priv->psmouse = psmouse;
+        priv->powered = 1;
+        INIT_DELAYED_WORK(&priv->recalib_wq, hgpk_recalib_work);
+
+        err = psmouse_reset(psmouse);
+        if (err)
+                goto init_fail;
+
+        err = hgpk_register(psmouse);
+        if (err)
+                goto init_fail;
+
+        return 0;
+
+init_fail:
+        kfree(priv);
+alloc_fail:
+        return err;
+}
+
+static enum hgpk_model_t hgpk_get_model(struct psmouse *psmouse)
+{
+        struct ps2dev *ps2dev = &psmouse->ps2dev;
+        unsigned char param[3];
+
+        /* E7, E7, E7, E9 gets us a 3 byte identifier */
+        if (ps2_command(ps2dev,  NULL, PSMOUSE_CMD_SETSCALE21) ||
+            ps2_command(ps2dev,  NULL, PSMOUSE_CMD_SETSCALE21) ||
+            ps2_command(ps2dev,  NULL, PSMOUSE_CMD_SETSCALE21) ||
+            ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO)) {
+                return -EIO;
+        }
+
+        hgpk_dbg(psmouse, "ID: %02x %02x %02x", param[0], param[1], param[2]);
+
+        /* HGPK signature: 0x67, 0x00, 0x<model> */
+        if (param[0] != 0x67 || param[1] != 0x00)
+                return -ENODEV;
+
+        hgpk_info(psmouse, "OLPC touchpad revision 0x%x\n", param[2]);
+
+        return param[2];
+}
+
+int hgpk_detect(struct psmouse *psmouse, int set_properties)
+{
+        int version;
+
+        version = hgpk_get_model(psmouse);
+        if (version < 0)
+                return version;
+
+        if (set_properties) {
+                psmouse->vendor = "ALPS";
+                psmouse->name = "HGPK";
+                psmouse->model = version;
+        }
+
+        return 0;
+}
diff --git a/drivers/input/mouse/hgpk.h b/drivers/input/mouse/hgpk.h
new file mode 100644
index 000000000000..a4b2a96f5f54
--- /dev/null
+++ b/drivers/input/mouse/hgpk.h
@@ -0,0 +1,49 @@
+/*
+ * OLPC HGPK (XO-1) touchpad PS/2 mouse driver
+ */
+
+#ifndef _HGPK_H
+#define _HGPK_H
+
+enum hgpk_model_t {
+        HGPK_MODEL_PREA = 0x0a, /* pre-B1s */
+        HGPK_MODEL_A = 0x14,    /* found on B1s, PT disabled in hardware */
+        HGPK_MODEL_B = 0x28,    /* B2s, has capacitance issues */
+        HGPK_MODEL_C = 0x3c,
+        HGPK_MODEL_D = 0x50,    /* C1, mass production */
+};
+
+struct hgpk_data {
+        struct psmouse *psmouse;
+        int powered;
+        int count, x_tally, y_tally;    /* hardware workaround stuff */
+        unsigned long recalib_window;
+        struct delayed_work recalib_wq;
+};
+
+#define hgpk_dbg(psmouse, format, arg...)               \
+        dev_dbg(&(psmouse)->ps2dev.serio->dev, format, ## arg)
+#define hgpk_err(psmouse, format, arg...)               \
+        dev_err(&(psmouse)->ps2dev.serio->dev, format, ## arg)
+#define hgpk_info(psmouse, format, arg...)              \
+        dev_info(&(psmouse)->ps2dev.serio->dev, format, ## arg)
+#define hgpk_warn(psmouse, format, arg...)              \
+        dev_warn(&(psmouse)->ps2dev.serio->dev, format, ## arg)
+#define hgpk_notice(psmouse, format, arg...)            \
+        dev_notice(&(psmouse)->ps2dev.serio->dev, format, ## arg)
+
+#ifdef CONFIG_MOUSE_PS2_OLPC
+int hgpk_detect(struct psmouse *psmouse, int set_properties);
+int hgpk_init(struct psmouse *psmouse);
+#else
+static inline int hgpk_detect(struct psmouse *psmouse, int set_properties)
+{
+        return -ENODEV;
+}
+static inline int hgpk_init(struct psmouse *psmouse)
+{
+        return -ENODEV;
+}
+#endif
+
+#endif
diff --git a/drivers/input/mouse/logips2pp.c b/drivers/input/mouse/logips2pp.c
index 0c5660d28caa..390f1dbb98a4 100644
--- a/drivers/input/mouse/logips2pp.c
+++ b/drivers/input/mouse/logips2pp.c
@@ -157,10 +157,8 @@ static ssize_t ps2pp_attr_show_smartscroll(struct psmouse *psmouse, void *data,
 static ssize_t ps2pp_attr_set_smartscroll(struct psmouse *psmouse, void *data, const char *buf, size_t count)
 {
         unsigned long value;
-        char *rest;
 
-        value = simple_strtoul(buf, &rest, 10);
-        if (*rest || value > 1)
+        if (strict_strtoul(buf, 10, &value) || value > 1)
                 return -EINVAL;
 
         ps2pp_set_smartscroll(psmouse, value);
diff --git a/drivers/input/mouse/psmouse-base.c b/drivers/input/mouse/psmouse-base.c
index f5a6be1d3c46..126e977e199e 100644
--- a/drivers/input/mouse/psmouse-base.c
+++ b/drivers/input/mouse/psmouse-base.c
@@ -25,6 +25,7 @@
 #include "synaptics.h"
 #include "logips2pp.h"
 #include "alps.h"
+#include "hgpk.h"
 #include "lifebook.h"
 #include "trackpoint.h"
 #include "touchkit_ps2.h"
@@ -201,6 +202,12 @@ static psmouse_ret_t psmouse_process_byte(struct psmouse *psmouse)
         return PSMOUSE_FULL_PACKET;
 }
 
+void psmouse_queue_work(struct psmouse *psmouse, struct delayed_work *work,
+                unsigned long delay)
+{
+        queue_delayed_work(kpsmoused_wq, work, delay);
+}
+
 /*
  * __psmouse_set_state() sets new psmouse state and resets all flags.
  */
@@ -220,7 +227,7 @@ static inline void __psmouse_set_state(struct psmouse *psmouse, enum psmouse_sta
  * is not a concern.
  */
 
-static void psmouse_set_state(struct psmouse *psmouse, enum psmouse_state new_state)
+void psmouse_set_state(struct psmouse *psmouse, enum psmouse_state new_state)
 {
         serio_pause_rx(psmouse->ps2dev.serio);
         __psmouse_set_state(psmouse, new_state);
@@ -305,7 +312,7 @@ static irqreturn_t psmouse_interrupt(struct serio *serio,
                        psmouse->name, psmouse->phys, psmouse->pktcnt);
                 psmouse->badbyte = psmouse->packet[0];
                 __psmouse_set_state(psmouse, PSMOUSE_RESYNCING);
-                queue_work(kpsmoused_wq, &psmouse->resync_work);
+                psmouse_queue_work(psmouse, &psmouse->resync_work, 0);
                 goto out;
         }
 
@@ -342,7 +349,7 @@ static irqreturn_t psmouse_interrupt(struct serio *serio,
             time_after(jiffies, psmouse->last + psmouse->resync_time * HZ)) {
                 psmouse->badbyte = psmouse->packet[0];
                 __psmouse_set_state(psmouse, PSMOUSE_RESYNCING);
-                queue_work(kpsmoused_wq, &psmouse->resync_work);
+                psmouse_queue_work(psmouse, &psmouse->resync_work, 0);
                 goto out;
         }
 
@@ -630,8 +637,20 @@ static int psmouse_extensions(struct psmouse *psmouse,
                 }
         }
 
-        if (max_proto > PSMOUSE_IMEX) {
+/*
+ * Try OLPC HGPK touchpad.
+ */
+        if (max_proto > PSMOUSE_IMEX &&
+                        hgpk_detect(psmouse, set_properties) == 0) {
+                if (!set_properties || hgpk_init(psmouse) == 0)
+                        return PSMOUSE_HGPK;
+/*
+ * Init failed, try basic relative protocols
+ */
+                max_proto = PSMOUSE_IMEX;
+        }
 
+        if (max_proto > PSMOUSE_IMEX) {
                 if (genius_detect(psmouse, set_properties) == 0)
                         return PSMOUSE_GENPS;
 
@@ -762,6 +781,14 @@ static const struct psmouse_protocol psmouse_protocols[] = {
                 .detect         = touchkit_ps2_detect,
         },
 #endif
+#ifdef CONFIG_MOUSE_PS2_OLPC
+        {
+                .type           = PSMOUSE_HGPK,
+                .name           = "OLPC HGPK",
+                .alias          = "hgpk",
+                .detect         = hgpk_detect,
+        },
+#endif
         {
                 .type           = PSMOUSE_CORTRON,
                 .name           = "CortronPS/2",
@@ -935,7 +962,7 @@ static int psmouse_poll(struct psmouse *psmouse)
 static void psmouse_resync(struct work_struct *work)
 {
         struct psmouse *parent = NULL, *psmouse =
-                container_of(work, struct psmouse, resync_work);
+                container_of(work, struct psmouse, resync_work.work);
         struct serio *serio = psmouse->ps2dev.serio;
         psmouse_ret_t rc = PSMOUSE_GOOD_DATA;
         int failed = 0, enabled = 0;
@@ -1194,7 +1221,7 @@ static int psmouse_connect(struct serio *serio, struct serio_driver *drv)
                 goto err_free;
 
         ps2_init(&psmouse->ps2dev, serio);
-        INIT_WORK(&psmouse->resync_work, psmouse_resync);
+        INIT_DELAYED_WORK(&psmouse->resync_work, psmouse_resync);
         psmouse->dev = input_dev;
         snprintf(psmouse->phys, sizeof(psmouse->phys), "%s/input0", serio->phys);
 
@@ -1395,25 +1422,29 @@ ssize_t psmouse_attr_set_helper(struct device *dev, struct device_attribute *dev
 
         psmouse = serio_get_drvdata(serio);
 
-        if (psmouse->state == PSMOUSE_IGNORE) {
-                retval = -ENODEV;
-                goto out_unlock;
-        }
+        if (attr->protect) {
+                if (psmouse->state == PSMOUSE_IGNORE) {
+                        retval = -ENODEV;
+                        goto out_unlock;
+                }
 
-        if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) {
-                parent = serio_get_drvdata(serio->parent);
-                psmouse_deactivate(parent);
-        }
+                if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) {
+                        parent = serio_get_drvdata(serio->parent);
+                        psmouse_deactivate(parent);
+                }
 
-        psmouse_deactivate(psmouse);
+                psmouse_deactivate(psmouse);
+        }
 
         retval = attr->set(psmouse, attr->data, buf, count);
 
-        if (retval != -ENODEV)
-                psmouse_activate(psmouse);
+        if (attr->protect) {
+                if (retval != -ENODEV)
+                        psmouse_activate(psmouse);
 
-        if (parent)
-                psmouse_activate(parent);
+                if (parent)
+                        psmouse_activate(parent);
+        }
 
  out_unlock:
         mutex_unlock(&psmouse_mutex);
@@ -1433,10 +1464,8 @@ static ssize_t psmouse_set_int_attr(struct psmouse *psmouse, void *offset, const
 {
         unsigned int *field = (unsigned int *)((char *)psmouse + (size_t)offset);
         unsigned long value;
-        char *rest;
 
-        value = simple_strtoul(buf, &rest, 10);
-        if (*rest)
+        if (strict_strtoul(buf, 10, &value))
                 return -EINVAL;
 
         if ((unsigned int)value != value)
@@ -1549,10 +1578,8 @@ static ssize_t psmouse_attr_set_protocol(struct psmouse *psmouse, void *data, co
 static ssize_t psmouse_attr_set_rate(struct psmouse *psmouse, void *data, const char *buf, size_t count)
 {
         unsigned long value;
-        char *rest;
 
-        value = simple_strtoul(buf, &rest, 10);
-        if (*rest)
+        if (strict_strtoul(buf, 10, &value))
                 return -EINVAL;
 
         psmouse->set_rate(psmouse, value);
@@ -1562,10 +1589,8 @@ static ssize_t psmouse_attr_set_rate(struct psmouse *psmouse, void *data, const
 static ssize_t psmouse_attr_set_resolution(struct psmouse *psmouse, void *data, const char *buf, size_t count)
 {
         unsigned long value;
-        char *rest;
 
-        value = simple_strtoul(buf, &rest, 10);
-        if (*rest)
+        if (strict_strtoul(buf, 10, &value))
                 return -EINVAL;
 
         psmouse->set_resolution(psmouse, value);
diff --git a/drivers/input/mouse/psmouse.h b/drivers/input/mouse/psmouse.h
index 1317bdd8cc7c..8b608a1cdd12 100644
--- a/drivers/input/mouse/psmouse.h
+++ b/drivers/input/mouse/psmouse.h
@@ -39,7 +39,7 @@ struct psmouse {
         void *private;
         struct input_dev *dev;
         struct ps2dev ps2dev;
-        struct work_struct resync_work;
+        struct delayed_work resync_work;
         char *vendor;
         char *name;
         unsigned char packet[8];
@@ -89,20 +89,24 @@ enum psmouse_type {
         PSMOUSE_TRACKPOINT,
         PSMOUSE_TOUCHKIT_PS2,
         PSMOUSE_CORTRON,
+        PSMOUSE_HGPK,
         PSMOUSE_AUTO            /* This one should always be last */
 };
 
+void psmouse_queue_work(struct psmouse *psmouse, struct delayed_work *work,
+                unsigned long delay);
 int psmouse_sliced_command(struct psmouse *psmouse, unsigned char command);
 int psmouse_reset(struct psmouse *psmouse);
+void psmouse_set_state(struct psmouse *psmouse, enum psmouse_state new_state);
 void psmouse_set_resolution(struct psmouse *psmouse, unsigned int resolution);
 
-
 struct psmouse_attribute {
         struct device_attribute dattr;
         void *data;
         ssize_t (*show)(struct psmouse *psmouse, void *data, char *buf);
         ssize_t (*set)(struct psmouse *psmouse, void *data,
                         const char *buf, size_t count);
+        int protect;
 };
 #define to_psmouse_attr(a)      container_of((a), struct psmouse_attribute, dattr)
 
@@ -111,7 +115,7 @@ ssize_t psmouse_attr_show_helper(struct device *dev, struct device_attribute *at
 ssize_t psmouse_attr_set_helper(struct device *dev, struct device_attribute *attr,
                                 const char *buf, size_t count);
 
-#define PSMOUSE_DEFINE_ATTR(_name, _mode, _data, _show, _set)                   \
+#define __PSMOUSE_DEFINE_ATTR(_name, _mode, _data, _show, _set, _protect)       \
 static ssize_t _show(struct psmouse *, void *data, char *);                     \
 static ssize_t _set(struct psmouse *, void *data, const char *, size_t);        \
 static struct psmouse_attribute psmouse_attr_##_name = {                        \
@@ -126,6 +130,10 @@ static struct psmouse_attribute psmouse_attr_##_name = {			\
         .data   = _data,                                                        \
         .show   = _show,                                                        \
         .set    = _set,                                                         \
+        .protect = _protect,                                                    \
 }
 
+#define PSMOUSE_DEFINE_ATTR(_name, _mode, _data, _show, _set)   \
+                __PSMOUSE_DEFINE_ATTR(_name, _mode, _data, _show, _set, 1)
+
 #endif /* _PSMOUSE_H */
diff --git a/drivers/input/mouse/trackpoint.c b/drivers/input/mouse/trackpoint.c
index 26b845fc186a..e68c814c4361 100644
--- a/drivers/input/mouse/trackpoint.c
+++ b/drivers/input/mouse/trackpoint.c
@@ -89,10 +89,8 @@ static ssize_t trackpoint_set_int_attr(struct psmouse *psmouse, void *data,
         struct trackpoint_attr_data *attr = data;
         unsigned char *field = (unsigned char *)((char *)tp + attr->field_offset);
         unsigned long value;
-        char *rest;
 
-        value = simple_strtoul(buf, &rest, 10);
-        if (*rest || value > 255)
+        if (strict_strtoul(buf, 10, &value) || value > 255)
                 return -EINVAL;
 
         *field = value;
@@ -117,10 +115,8 @@ static ssize_t trackpoint_set_bit_attr(struct psmouse *psmouse, void *data,
         struct trackpoint_attr_data *attr = data;
         unsigned char *field = (unsigned char *)((char *)tp + attr->field_offset);
         unsigned long value;
-        char *rest;
 
-        value = simple_strtoul(buf, &rest, 10);
-        if (*rest || value > 1)
+        if (strict_strtoul(buf, 10, &value) || value > 1)
                 return -EINVAL;
 
         if (attr->inverted)