Input: hgpk - support GlideSensor and PenTablet modes

Add a "hgpk_mode" sysfs attribute that allows selection between 3 options:
Mouse (the existing option), GlideSensor and PenTablet.

GlideSensor is an enhanced protocol for the regular touchpad mode that
additionally reports pressure and uses absolute coordinates. We suspect
that it may be more reliable than mouse mode in some environments.

PenTablet mode puts the touchpad into resistive mode, you must then use
a stylus as an input. We suspect this is the most reliable way to drive
the touchpad.

The GlideSensor and PenTablet devices expose themselves with the
intention of being combined with the synaptics X11 input driver.

Based on earlier work by Paul Fox.

Signed-off-by: Daniel Drake <dsd@laptop.org>
Signed-off-by: Dmitry Torokhov <dtor@mail.ru>

3 files changed, 441 insertions, 43 deletions

diff --git a/drivers/input/mouse/hgpk.c b/drivers/input/mouse/hgpk.c
index 1d2205b24800..3d33d958a122 100644
--- a/drivers/input/mouse/hgpk.c
+++ b/drivers/input/mouse/hgpk.c
@@ -69,6 +69,32 @@ module_param(post_interrupt_delay, int, 0644);
 MODULE_PARM_DESC(post_interrupt_delay,
         "delay (ms) before recal after recal interrupt detected");
 
+static char hgpk_mode_name[16];
+module_param_string(hgpk_mode, hgpk_mode_name, sizeof(hgpk_mode_name), 0644);
+MODULE_PARM_DESC(hgpk_mode,
+        "default hgpk mode: mouse, glidesensor or pentablet");
+
+static int hgpk_default_mode = HGPK_MODE_MOUSE;
+
+static const char * const hgpk_mode_names[] = {
+        [HGPK_MODE_MOUSE] = "Mouse",
+        [HGPK_MODE_GLIDESENSOR] = "GlideSensor",
+        [HGPK_MODE_PENTABLET] = "PenTablet",
+};
+
+static int hgpk_mode_from_name(const char *buf, int len)
+{
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(hgpk_mode_names); i++) {
+                const char *name = hgpk_mode_names[i];
+                if (strlen(name) == len && !strncasecmp(name, buf, len))
+                        return i;
+        }
+
+        return HGPK_MODE_INVALID;
+}
+
 /*
  * 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
@@ -143,23 +169,139 @@ static void hgpk_spewing_hack(struct psmouse *psmouse,
  * 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
+ *
+ * ---
+ *
+ * HGPK Advanced Mode - single-mode format
+ *
+ * byte 0(PT):  1    1    0    0    1    1     1     1
+ * byte 0(GS):  1    1    1    1    1    1     1     1
+ * byte 1:      0   x6   x5   x4   x3   x2    x1    x0
+ * byte 2(PT):  0    0   x9   x8   x7    ? pt-dsw    0
+ * byte 2(GS):  0  x10   x9   x8   x7    ? gs-dsw pt-dsw
+ * byte 3:      0   y9   y8   y7    1    0   swr   swl
+ * byte 4:      0   y6   y5   y4   y3   y2    y1    y0
+ * byte 5:      0   z6   z5   z4   z3   z2    z1    z0
+ *
+ * ?'s are not defined in the protocol spec, may vary between models.
+ *
+ * swr/swl are the left/right buttons.
+ *
+ * pt-dsw/gs-dsw indicate that the pt/gs sensor is detecting a
+ * pen/finger
  */
-static int hgpk_validate_byte(unsigned char *packet)
+static bool hgpk_is_byte_valid(struct psmouse *psmouse, unsigned char *packet)
 {
-        return (packet[0] & 0x0C) != 0x08;
+        struct hgpk_data *priv = psmouse->private;
+        int pktcnt = psmouse->pktcnt;
+        bool valid;
+
+        switch (priv->mode) {
+        case HGPK_MODE_MOUSE:
+                valid = (packet[0] & 0x0C) == 0x08;
+                break;
+
+        case HGPK_MODE_GLIDESENSOR:
+                valid = pktcnt == 1 ?
+                        packet[0] == HGPK_GS : !(packet[pktcnt - 1] & 0x80);
+                break;
+
+        case HGPK_MODE_PENTABLET:
+                valid = pktcnt == 1 ?
+                        packet[0] == HGPK_PT : !(packet[pktcnt - 1] & 0x80);
+                break;
+
+        default:
+                valid = false;
+                break;
+        }
+
+        if (!valid)
+                hgpk_dbg(psmouse,
+                         "bad data, mode %d (%d) %02x %02x %02x %02x %02x %02x\n",
+                         priv->mode, pktcnt,
+                         psmouse->packet[0], psmouse->packet[1],
+                         psmouse->packet[2], psmouse->packet[3],
+                         psmouse->packet[4], psmouse->packet[5]);
+
+        return valid;
 }
 
-static void hgpk_process_packet(struct psmouse *psmouse)
+static void hgpk_process_advanced_packet(struct psmouse *psmouse)
 {
-        struct input_dev *dev = psmouse->dev;
+        struct hgpk_data *priv = psmouse->private;
+        struct input_dev *idev = psmouse->dev;
         unsigned char *packet = psmouse->packet;
-        int x, y, left, right;
+        int down = !!(packet[2] & 2);
+        int left = !!(packet[3] & 1);
+        int right = !!(packet[3] & 2);
+        int x = packet[1] | ((packet[2] & 0x78) << 4);
+        int y = packet[4] | ((packet[3] & 0x70) << 3);
+
+        if (priv->mode == HGPK_MODE_GLIDESENSOR) {
+                int pt_down = !!(packet[2] & 1);
+                int finger_down = !!(packet[2] & 2);
+                int z = packet[5];
+
+                input_report_abs(idev, ABS_PRESSURE, z);
+                if (tpdebug)
+                        hgpk_dbg(psmouse, "pd=%d fd=%d z=%d",
+                                 pt_down, finger_down, z);
+        } else {
+                /*
+                 * PenTablet mode does not report pressure, so we don't
+                 * report it here
+                 */
+                if (tpdebug)
+                        hgpk_dbg(psmouse, "pd=%d ", down);
+        }
 
-        left = packet[0] & 1;
-        right = (packet[0] >> 1) & 1;
+        if (tpdebug)
+                hgpk_dbg(psmouse, "l=%d r=%d x=%d y=%d\n", left, right, x, y);
 
-        x = packet[1] - ((packet[0] << 4) & 0x100);
-        y = ((packet[0] << 3) & 0x100) - packet[2];
+        input_report_key(idev, BTN_TOUCH, down);
+        input_report_key(idev, BTN_LEFT, left);
+        input_report_key(idev, BTN_RIGHT, right);
+
+        /*
+         * If this packet says that the finger was removed, reset our position
+         * tracking so that we don't erroneously detect a jump on next press.
+         */
+        if (!down)
+                priv->abs_x = priv->abs_y = -1;
+
+        /*
+         * Report position if finger/pen is down, but weed out duplicate
+         * packets (we get quite a few in this mode, and they mess up our
+         * jump detection.
+         */
+        if (down && (x != priv->abs_x || y != priv->abs_y)) {
+
+                /* Don't apply hacks in PT mode, it seems reliable */
+                if (priv->mode != HGPK_MODE_PENTABLET && priv->abs_x != -1) {
+                        hgpk_jumpy_hack(psmouse,
+                                        priv->abs_x - x, priv->abs_y - y);
+                        hgpk_spewing_hack(psmouse, left, right,
+                                          priv->abs_x - x, priv->abs_y - y);
+                }
+
+                input_report_abs(idev, ABS_X, x);
+                input_report_abs(idev, ABS_Y, y);
+                priv->abs_x = x;
+                priv->abs_y = y;
+        }
+
+        input_sync(idev);
+}
+
+static void hgpk_process_simple_packet(struct psmouse *psmouse)
+{
+        struct input_dev *dev = psmouse->dev;
+        unsigned char *packet = psmouse->packet;
+        int left = packet[0] & 1;
+        int right = (packet[0] >> 1) & 1;
+        int x = packet[1] - ((packet[0] << 4) & 0x100);
+        int y = ((packet[0] << 3) & 0x100) - packet[2];
 
         hgpk_jumpy_hack(psmouse, x, y);
         hgpk_spewing_hack(psmouse, left, right, x, y);
@@ -180,15 +322,14 @@ 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]);
+        if (!hgpk_is_byte_valid(psmouse, psmouse->packet))
                 return PSMOUSE_BAD_DATA;
-        }
 
         if (psmouse->pktcnt >= psmouse->pktsize) {
-                hgpk_process_packet(psmouse);
+                if (priv->mode == HGPK_MODE_MOUSE)
+                        hgpk_process_simple_packet(psmouse);
+                else
+                        hgpk_process_advanced_packet(psmouse);
                 return PSMOUSE_FULL_PACKET;
         }
 
@@ -210,10 +351,161 @@ static psmouse_ret_t hgpk_process_byte(struct psmouse *psmouse)
         return PSMOUSE_GOOD_DATA;
 }
 
+static int hgpk_select_mode(struct psmouse *psmouse)
+{
+        struct ps2dev *ps2dev = &psmouse->ps2dev;
+        struct hgpk_data *priv = psmouse->private;
+        int i;
+        int cmd;
+
+        /*
+         * 4 disables to enable advanced mode
+         * then 3 0xf2 bytes as the preamble for GS/PT selection
+         */
+        const int advanced_init[] = {
+                PSMOUSE_CMD_DISABLE, PSMOUSE_CMD_DISABLE,
+                PSMOUSE_CMD_DISABLE, PSMOUSE_CMD_DISABLE,
+                0xf2, 0xf2, 0xf2,
+        };
+
+        switch (priv->mode) {
+        case HGPK_MODE_MOUSE:
+                psmouse->pktsize = 3;
+                break;
+
+        case HGPK_MODE_GLIDESENSOR:
+        case HGPK_MODE_PENTABLET:
+                psmouse->pktsize = 6;
+
+                /* Switch to 'Advanced mode.', four disables in a row. */
+                for (i = 0; i < ARRAY_SIZE(advanced_init); i++)
+                        if (ps2_command(ps2dev, NULL, advanced_init[i]))
+                                return -EIO;
+
+                /* select between GlideSensor (mouse) or PenTablet */
+                cmd = priv->mode == HGPK_MODE_GLIDESENSOR ?
+                        PSMOUSE_CMD_SETSCALE11 : PSMOUSE_CMD_SETSCALE21;
+
+                if (ps2_command(ps2dev, NULL, cmd))
+                        return -EIO;
+                break;
+
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static void hgpk_setup_input_device(struct input_dev *input,
+                                    struct input_dev *old_input,
+                                    enum hgpk_mode mode)
+{
+        if (old_input) {
+                input->name = old_input->name;
+                input->phys = old_input->phys;
+                input->id = old_input->id;
+                input->dev.parent = old_input->dev.parent;
+        }
+
+        memset(input->evbit, 0, sizeof(input->evbit));
+        memset(input->relbit, 0, sizeof(input->relbit));
+        memset(input->keybit, 0, sizeof(input->keybit));
+
+        /* All modes report left and right buttons */
+        __set_bit(EV_KEY, input->evbit);
+        __set_bit(BTN_LEFT, input->keybit);
+        __set_bit(BTN_RIGHT, input->keybit);
+
+        switch (mode) {
+        case HGPK_MODE_MOUSE:
+                __set_bit(EV_REL, input->evbit);
+                __set_bit(REL_X, input->relbit);
+                __set_bit(REL_Y, input->relbit);
+                break;
+
+        case HGPK_MODE_GLIDESENSOR:
+                __set_bit(BTN_TOUCH, input->keybit);
+                __set_bit(BTN_TOOL_FINGER, input->keybit);
+
+                __set_bit(EV_ABS, input->evbit);
+
+                /* GlideSensor has pressure sensor, PenTablet does not */
+                input_set_abs_params(input, ABS_PRESSURE, 0, 15, 0, 0);
+
+                /* From device specs */
+                input_set_abs_params(input, ABS_X, 0, 399, 0, 0);
+                input_set_abs_params(input, ABS_Y, 0, 290, 0, 0);
+
+                /* Calculated by hand based on usable size (52mm x 38mm) */
+                input_abs_set_res(input, ABS_X, 8);
+                input_abs_set_res(input, ABS_Y, 8);
+                break;
+
+        case HGPK_MODE_PENTABLET:
+                __set_bit(BTN_TOUCH, input->keybit);
+                __set_bit(BTN_TOOL_FINGER, input->keybit);
+
+                __set_bit(EV_ABS, input->evbit);
+
+                /* From device specs */
+                input_set_abs_params(input, ABS_X, 0, 999, 0, 0);
+                input_set_abs_params(input, ABS_Y, 5, 239, 0, 0);
+
+                /* Calculated by hand based on usable size (156mm x 38mm) */
+                input_abs_set_res(input, ABS_X, 6);
+                input_abs_set_res(input, ABS_Y, 8);
+                break;
+
+        default:
+                BUG();
+        }
+}
+
+static void hgpk_reset_hack_state(struct psmouse *psmouse)
+{
+        struct hgpk_data *priv = psmouse->private;
+
+        priv->abs_x = priv->abs_y = -1;
+}
+
+static int hgpk_reset_device(struct psmouse *psmouse, bool recalibrate)
+{
+        int err;
+
+        psmouse_reset(psmouse);
+
+        if (recalibrate) {
+                struct ps2dev *ps2dev = &psmouse->ps2dev;
+
+                /* 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);
+        }
+
+        err = hgpk_select_mode(psmouse);
+        if (err) {
+                hgpk_err(psmouse, "failed to select mode\n");
+                return err;
+        }
+
+        hgpk_reset_hack_state(psmouse);
+
+        return 0;
+}
+
 static int hgpk_force_recalibrate(struct psmouse *psmouse)
 {
         struct ps2dev *ps2dev = &psmouse->ps2dev;
         struct hgpk_data *priv = psmouse->private;
+        int err;
 
         /* C-series touchpads added the recalibrate command */
         if (psmouse->model < HGPK_MODEL_C)
@@ -223,20 +515,12 @@ static int hgpk_force_recalibrate(struct psmouse *psmouse)
         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);
+        err = hgpk_reset_device(psmouse, true);
+        if (err)
+                return err;
 
-        /* XXX: If a finger is down during this delay, recalibration will
+        /*
+         * 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.
@@ -247,12 +531,13 @@ static int hgpk_force_recalibrate(struct psmouse *psmouse)
 
         psmouse_set_state(psmouse, PSMOUSE_ACTIVATED);
 
-        /* After we recalibrate, we shouldn't get any packets for 2s.  If
+        /*
+         * 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(recal_guard_time);
+        priv->recalib_window = jiffies + msecs_to_jiffies(recal_guard_time);
 
         return 0;
 }
@@ -266,6 +551,7 @@ static int hgpk_toggle_power(struct psmouse *psmouse, int enable)
 {
         struct ps2dev *ps2dev = &psmouse->ps2dev;
         int timeo;
+        int err;
 
         /* Added on D-series touchpads */
         if (psmouse->model < HGPK_MODEL_D)
@@ -288,7 +574,11 @@ static int hgpk_toggle_power(struct psmouse *psmouse, int enable)
                         msleep(50);
                 }
 
-                psmouse_reset(psmouse);
+                err = hgpk_reset_device(psmouse, false);
+                if (err) {
+                        hgpk_err(psmouse, "Failed to reset device!\n");
+                        return err;
+                }
 
                 /* should be all set, enable the touchpad */
                 ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_ENABLE);
@@ -319,17 +609,17 @@ static int hgpk_poll(struct psmouse *psmouse)
 
 static int hgpk_reconnect(struct psmouse *psmouse)
 {
-        /* During suspend/resume the ps2 rails remain powered.  We don't want
+        /*
+         * 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. */
+         * 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;
+        return hgpk_reset_device(psmouse, false);
 }
 
 static ssize_t hgpk_show_powered(struct psmouse *psmouse, void *data, char *buf)
@@ -366,6 +656,65 @@ static ssize_t hgpk_set_powered(struct psmouse *psmouse, void *data,
 __PSMOUSE_DEFINE_ATTR(powered, S_IWUSR | S_IRUGO, NULL,
                       hgpk_show_powered, hgpk_set_powered, false);
 
+static ssize_t attr_show_mode(struct psmouse *psmouse, void *data, char *buf)
+{
+        struct hgpk_data *priv = psmouse->private;
+
+        return sprintf(buf, "%s\n", hgpk_mode_names[priv->mode]);
+}
+
+static ssize_t attr_set_mode(struct psmouse *psmouse, void *data,
+                             const char *buf, size_t len)
+{
+        struct hgpk_data *priv = psmouse->private;
+        enum hgpk_mode old_mode = priv->mode;
+        enum hgpk_mode new_mode = hgpk_mode_from_name(buf, len);
+        struct input_dev *old_dev = psmouse->dev;
+        struct input_dev *new_dev;
+        int err;
+
+        if (new_mode == HGPK_MODE_INVALID)
+                return -EINVAL;
+
+        if (old_mode == new_mode)
+                return len;
+
+        new_dev = input_allocate_device();
+        if (!new_dev)
+                return -ENOMEM;
+
+        psmouse_set_state(psmouse, PSMOUSE_INITIALIZING);
+
+        /* Switch device into the new mode */
+        priv->mode = new_mode;
+        err = hgpk_reset_device(psmouse, false);
+        if (err)
+                goto err_try_restore;
+
+        hgpk_setup_input_device(new_dev, old_dev, new_mode);
+
+        psmouse_set_state(psmouse, PSMOUSE_CMD_MODE);
+
+        err = input_register_device(new_dev);
+        if (err)
+                goto err_try_restore;
+
+        psmouse->dev = new_dev;
+        input_unregister_device(old_dev);
+
+        return len;
+
+err_try_restore:
+        input_free_device(new_dev);
+        priv->mode = old_mode;
+        hgpk_reset_device(psmouse, false);
+
+        return err;
+}
+
+PSMOUSE_DEFINE_ATTR(hgpk_mode, S_IWUSR | S_IRUGO, NULL,
+                    attr_show_mode, attr_set_mode);
+
 static ssize_t hgpk_trigger_recal_show(struct psmouse *psmouse,
                 void *data, char *buf)
 {
@@ -401,6 +750,8 @@ static void hgpk_disconnect(struct psmouse *psmouse)
 
         device_remove_file(&psmouse->ps2dev.serio->dev,
                            &psmouse_attr_powered.dattr);
+        device_remove_file(&psmouse->ps2dev.serio->dev,
+                           &psmouse_attr_hgpk_mode.dattr);
 
         if (psmouse->model >= HGPK_MODEL_C)
                 device_remove_file(&psmouse->ps2dev.serio->dev,
@@ -424,6 +775,7 @@ static void hgpk_recalib_work(struct work_struct *work)
 
 static int hgpk_register(struct psmouse *psmouse)
 {
+        struct hgpk_data *priv = psmouse->private;
         int err;
 
         /* register handlers */
@@ -431,13 +783,14 @@ static int hgpk_register(struct psmouse *psmouse)
         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;
 
+        hgpk_setup_input_device(psmouse->dev, NULL, priv->mode);
+
         err = device_create_file(&psmouse->ps2dev.serio->dev,
                                  &psmouse_attr_powered.dattr);
         if (err) {
@@ -445,6 +798,13 @@ static int hgpk_register(struct psmouse *psmouse)
                 return err;
         }
 
+        err = device_create_file(&psmouse->ps2dev.serio->dev,
+                                 &psmouse_attr_hgpk_mode.dattr);
+        if (err) {
+                hgpk_err(psmouse, "Failed creating 'hgpk_mode' sysfs node\n");
+                goto err_remove_powered;
+        }
+
         /* C-series touchpads added the recalibrate command */
         if (psmouse->model >= HGPK_MODEL_C) {
                 err = device_create_file(&psmouse->ps2dev.serio->dev,
@@ -452,30 +812,40 @@ static int hgpk_register(struct psmouse *psmouse)
                 if (err) {
                         hgpk_err(psmouse,
                                 "Failed creating 'recalibrate' sysfs node\n");
-                        device_remove_file(&psmouse->ps2dev.serio->dev,
-                                        &psmouse_attr_powered.dattr);
-                        return err;
+                        goto err_remove_mode;
                 }
         }
 
         return 0;
+
+err_remove_mode:
+        device_remove_file(&psmouse->ps2dev.serio->dev,
+                           &psmouse_attr_hgpk_mode.dattr);
+err_remove_powered:
+        device_remove_file(&psmouse->ps2dev.serio->dev,
+                           &psmouse_attr_powered.dattr);
+        return err;
 }
 
 int hgpk_init(struct psmouse *psmouse)
 {
         struct hgpk_data *priv;
-        int err = -ENOMEM;
+        int err;
 
         priv = kzalloc(sizeof(struct hgpk_data), GFP_KERNEL);
-        if (!priv)
+        if (!priv) {
+                err = -ENOMEM;
                 goto alloc_fail;
+        }
 
         psmouse->private = priv;
+
         priv->psmouse = psmouse;
         priv->powered = true;
+        priv->mode = hgpk_default_mode;
         INIT_DELAYED_WORK(&priv->recalib_wq, hgpk_recalib_work);
 
-        err = psmouse_reset(psmouse);
+        err = hgpk_reset_device(psmouse, false);
         if (err)
                 goto init_fail;
 
@@ -531,3 +901,14 @@ int hgpk_detect(struct psmouse *psmouse, bool set_properties)
 
         return 0;
 }
+
+void hgpk_module_init(void)
+{
+        hgpk_default_mode = hgpk_mode_from_name(hgpk_mode_name,
+                                                strlen(hgpk_mode_name));
+        if (hgpk_default_mode == HGPK_MODE_INVALID) {
+                hgpk_default_mode = HGPK_MODE_MOUSE;
+                strlcpy(hgpk_mode_name, hgpk_mode_names[HGPK_MODE_MOUSE],
+                        sizeof(hgpk_mode_name));
+        }
+}
diff --git a/drivers/input/mouse/hgpk.h b/drivers/input/mouse/hgpk.h
index d61cfd3ee9cb..01c983bb8465 100644
--- a/drivers/input/mouse/hgpk.h
+++ b/drivers/input/mouse/hgpk.h
@@ -5,6 +5,9 @@
 #ifndef _HGPK_H
 #define _HGPK_H
 
+#define HGPK_GS         0xff       /* The GlideSensor */
+#define HGPK_PT         0xcf       /* The PenTablet */
+
 enum hgpk_model_t {
         HGPK_MODEL_PREA = 0x0a, /* pre-B1s */
         HGPK_MODEL_A = 0x14,    /* found on B1s, PT disabled in hardware */
@@ -13,12 +16,21 @@ enum hgpk_model_t {
         HGPK_MODEL_D = 0x50,    /* C1, mass production */
 };
 
+enum hgpk_mode {
+        HGPK_MODE_MOUSE,
+        HGPK_MODE_GLIDESENSOR,
+        HGPK_MODE_PENTABLET,
+        HGPK_MODE_INVALID
+};
+
 struct hgpk_data {
         struct psmouse *psmouse;
+        enum hgpk_mode mode;
         bool powered;
         int count, x_tally, y_tally;    /* hardware workaround stuff */
         unsigned long recalib_window;
         struct delayed_work recalib_wq;
+        int abs_x, abs_y;
 };
 
 #define hgpk_dbg(psmouse, format, arg...)               \
@@ -33,9 +45,13 @@ struct hgpk_data {
         dev_notice(&(psmouse)->ps2dev.serio->dev, format, ## arg)
 
 #ifdef CONFIG_MOUSE_PS2_OLPC
+void hgpk_module_init(void);
 int hgpk_detect(struct psmouse *psmouse, bool set_properties);
 int hgpk_init(struct psmouse *psmouse);
 #else
+static inline void hgpk_module_init(void)
+{
+}
 static inline int hgpk_detect(struct psmouse *psmouse, bool set_properties)
 {
         return -ENODEV;
diff --git a/drivers/input/mouse/psmouse-base.c b/drivers/input/mouse/psmouse-base.c
index cd9d0c97e429..3f74baee102b 100644
--- a/drivers/input/mouse/psmouse-base.c
+++ b/drivers/input/mouse/psmouse-base.c
@@ -1711,6 +1711,7 @@ static int __init psmouse_init(void)
 
         lifebook_module_init();
         synaptics_module_init();
+        hgpk_module_init();
 
         kpsmoused_wq = create_singlethread_workqueue("kpsmoused");
         if (!kpsmoused_wq) {