8 files changed, 291 insertions, 30 deletions

diff --git a/drivers/input/mouse/alps.c b/drivers/input/mouse/alps.c
index a59a1a64b674..35a49bf57227 100644
--- a/drivers/input/mouse/alps.c
+++ b/drivers/input/mouse/alps.c
@@ -2234,8 +2234,8 @@ static int alps_identify(struct psmouse *psmouse, struct alps_data *priv)
                 return 0;
         }
 
-        psmouse_info(psmouse,
-                     "Unknown ALPS touchpad: E7=%3ph, EC=%3ph\n", e7, ec);
+        psmouse_dbg(psmouse,
+                    "Likely not an ALPS touchpad: E7=%3ph, EC=%3ph\n", e7, ec);
 
         return -EINVAL;
 }
@@ -2373,6 +2373,10 @@ int alps_init(struct psmouse *psmouse)
         dev2->keybit[BIT_WORD(BTN_LEFT)] =
                 BIT_MASK(BTN_LEFT) | BIT_MASK(BTN_MIDDLE) | BIT_MASK(BTN_RIGHT);
 
+        __set_bit(INPUT_PROP_POINTER, dev2->propbit);
+        if (priv->flags & ALPS_DUALPOINT)
+                __set_bit(INPUT_PROP_POINTING_STICK, dev2->propbit);
+
         if (input_register_device(priv->dev2))
                 goto init_fail;
 
diff --git a/drivers/input/mouse/elantech.c b/drivers/input/mouse/elantech.c
index ee2a04d90d20..06fc6e76ffbe 100644
--- a/drivers/input/mouse/elantech.c
+++ b/drivers/input/mouse/elantech.c
@@ -18,6 +18,7 @@
 #include <linux/input/mt.h>
 #include <linux/serio.h>
 #include <linux/libps2.h>
+#include <asm/unaligned.h>
 #include "psmouse.h"
 #include "elantech.h"
 
@@ -403,6 +404,68 @@ static void elantech_report_absolute_v2(struct psmouse *psmouse)
         input_sync(dev);
 }
 
+static void elantech_report_trackpoint(struct psmouse *psmouse,
+                                       int packet_type)
+{
+        /*
+         * byte 0:  0   0  sx  sy   0   M   R   L
+         * byte 1:~sx   0   0   0   0   0   0   0
+         * byte 2:~sy   0   0   0   0   0   0   0
+         * byte 3:  0   0 ~sy ~sx   0   1   1   0
+         * byte 4: x7  x6  x5  x4  x3  x2  x1  x0
+         * byte 5: y7  y6  y5  y4  y3  y2  y1  y0
+         *
+         * x and y are written in two's complement spread
+         * over 9 bits with sx/sy the relative top bit and
+         * x7..x0 and y7..y0 the lower bits.
+         * The sign of y is opposite to what the input driver
+         * expects for a relative movement
+         */
+
+        struct elantech_data *etd = psmouse->private;
+        struct input_dev *tp_dev = etd->tp_dev;
+        unsigned char *packet = psmouse->packet;
+        int x, y;
+        u32 t;
+
+        if (dev_WARN_ONCE(&psmouse->ps2dev.serio->dev,
+                          !tp_dev,
+                          psmouse_fmt("Unexpected trackpoint message\n"))) {
+                if (etd->debug == 1)
+                        elantech_packet_dump(psmouse);
+                return;
+        }
+
+        t = get_unaligned_le32(&packet[0]);
+
+        switch (t & ~7U) {
+        case 0x06000030U:
+        case 0x16008020U:
+        case 0x26800010U:
+        case 0x36808000U:
+                x = packet[4] - (int)((packet[1]^0x80) << 1);
+                y = (int)((packet[2]^0x80) << 1) - packet[5];
+
+                input_report_key(tp_dev, BTN_LEFT, packet[0] & 0x01);
+                input_report_key(tp_dev, BTN_RIGHT, packet[0] & 0x02);
+                input_report_key(tp_dev, BTN_MIDDLE, packet[0] & 0x04);
+
+                input_report_rel(tp_dev, REL_X, x);
+                input_report_rel(tp_dev, REL_Y, y);
+
+                input_sync(tp_dev);
+
+                break;
+
+        default:
+                /* Dump unexpected packet sequences if debug=1 (default) */
+                if (etd->debug == 1)
+                        elantech_packet_dump(psmouse);
+
+                break;
+        }
+}
+
 /*
  * Interpret complete data packets and report absolute mode input events for
  * hardware version 3. (12 byte packets for two fingers)
@@ -715,6 +778,8 @@ static int elantech_packet_check_v3(struct psmouse *psmouse)
 
                 if ((packet[0] & 0x0c) == 0x0c && (packet[3] & 0xce) == 0x0c)
                         return PACKET_V3_TAIL;
+                if ((packet[3] & 0x0f) == 0x06)
+                        return PACKET_TRACKPOINT;
         }
 
         return PACKET_UNKNOWN;
@@ -791,14 +856,23 @@ static psmouse_ret_t elantech_process_byte(struct psmouse *psmouse)
 
         case 3:
                 packet_type = elantech_packet_check_v3(psmouse);
-                /* ignore debounce */
-                if (packet_type == PACKET_DEBOUNCE)
-                        return PSMOUSE_FULL_PACKET;
-
-                if (packet_type == PACKET_UNKNOWN)
+                switch (packet_type) {
+                case PACKET_UNKNOWN:
                         return PSMOUSE_BAD_DATA;
 
-                elantech_report_absolute_v3(psmouse, packet_type);
+                case PACKET_DEBOUNCE:
+                        /* ignore debounce */
+                        break;
+
+                case PACKET_TRACKPOINT:
+                        elantech_report_trackpoint(psmouse, packet_type);
+                        break;
+
+                default:
+                        elantech_report_absolute_v3(psmouse, packet_type);
+                        break;
+                }
+
                 break;
 
         case 4:
@@ -1018,8 +1092,10 @@ static int elantech_get_resolution_v4(struct psmouse *psmouse,
  * Asus UX31               0x361f00        20, 15, 0e      clickpad
  * Asus UX32VD             0x361f02        00, 15, 0e      clickpad
  * Avatar AVIU-145A2       0x361f00        ?               clickpad
+ * Fujitsu H730            0x570f00        c0, 14, 0c      3 hw buttons (**)
  * Gigabyte U2442          0x450f01        58, 17, 0c      2 hw buttons
  * Lenovo L430             0x350f02        b9, 15, 0c      2 hw buttons (*)
+ * Lenovo L530             0x350f02        b9, 15, 0c      2 hw buttons (*)
  * Samsung NF210           0x150b00        78, 14, 0a      2 hw buttons
  * Samsung NP770Z5E        0x575f01        10, 15, 0f      clickpad
  * Samsung NP700Z5B        0x361f06        21, 15, 0f      clickpad
@@ -1029,6 +1105,8 @@ static int elantech_get_resolution_v4(struct psmouse *psmouse,
  * Samsung RF710           0x450f00        ?               2 hw buttons
  * System76 Pangolin       0x250f01        ?               2 hw buttons
  * (*) + 3 trackpoint buttons
+ * (**) + 0 trackpoint buttons
+ * Note: Lenovo L430 and Lenovo L430 have the same fw_version/caps
  */
 static void elantech_set_buttonpad_prop(struct psmouse *psmouse)
 {
@@ -1253,6 +1331,13 @@ static bool elantech_is_signature_valid(const unsigned char *param)
         if (param[1] == 0)
                 return true;
 
+        /*
+         * Some models have a revision higher then 20. Meaning param[2] may
+         * be 10 or 20, skip the rates check for these.
+         */
+        if (param[0] == 0x46 && (param[1] & 0xef) == 0x0f && param[2] < 40)
+                return true;
+
         for (i = 0; i < ARRAY_SIZE(rates); i++)
                 if (param[2] == rates[i])
                         return false;
@@ -1324,6 +1409,10 @@ int elantech_detect(struct psmouse *psmouse, bool set_properties)
  */
 static void elantech_disconnect(struct psmouse *psmouse)
 {
+        struct elantech_data *etd = psmouse->private;
+
+        if (etd->tp_dev)
+                input_unregister_device(etd->tp_dev);
         sysfs_remove_group(&psmouse->ps2dev.serio->dev.kobj,
                            &elantech_attr_group);
         kfree(psmouse->private);
@@ -1438,8 +1527,10 @@ static int elantech_set_properties(struct elantech_data *etd)
 int elantech_init(struct psmouse *psmouse)
 {
         struct elantech_data *etd;
-        int i, error;
+        int i;
+        int error = -EINVAL;
         unsigned char param[3];
+        struct input_dev *tp_dev;
 
         psmouse->private = etd = kzalloc(sizeof(struct elantech_data), GFP_KERNEL);
         if (!etd)
@@ -1498,14 +1589,53 @@ int elantech_init(struct psmouse *psmouse)
                 goto init_fail;
         }
 
+        /* The MSB indicates the presence of the trackpoint */
+        if ((etd->capabilities[0] & 0x80) == 0x80) {
+                tp_dev = input_allocate_device();
+
+                if (!tp_dev) {
+                        error = -ENOMEM;
+                        goto init_fail_tp_alloc;
+                }
+
+                etd->tp_dev = tp_dev;
+                snprintf(etd->tp_phys, sizeof(etd->tp_phys), "%s/input1",
+                        psmouse->ps2dev.serio->phys);
+                tp_dev->phys = etd->tp_phys;
+                tp_dev->name = "Elantech PS/2 TrackPoint";
+                tp_dev->id.bustype = BUS_I8042;
+                tp_dev->id.vendor  = 0x0002;
+                tp_dev->id.product = PSMOUSE_ELANTECH;
+                tp_dev->id.version = 0x0000;
+                tp_dev->dev.parent = &psmouse->ps2dev.serio->dev;
+                tp_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REL);
+                tp_dev->relbit[BIT_WORD(REL_X)] =
+                        BIT_MASK(REL_X) | BIT_MASK(REL_Y);
+                tp_dev->keybit[BIT_WORD(BTN_LEFT)] =
+                        BIT_MASK(BTN_LEFT) | BIT_MASK(BTN_MIDDLE) |
+                        BIT_MASK(BTN_RIGHT);
+
+                __set_bit(INPUT_PROP_POINTER, tp_dev->propbit);
+                __set_bit(INPUT_PROP_POINTING_STICK, tp_dev->propbit);
+
+                error = input_register_device(etd->tp_dev);
+                if (error < 0)
+                        goto init_fail_tp_reg;
+        }
+
         psmouse->protocol_handler = elantech_process_byte;
         psmouse->disconnect = elantech_disconnect;
         psmouse->reconnect = elantech_reconnect;
         psmouse->pktsize = etd->hw_version > 1 ? 6 : 4;
 
         return 0;
-
+ init_fail_tp_reg:
+        input_free_device(tp_dev);
+ init_fail_tp_alloc:
+        sysfs_remove_group(&psmouse->ps2dev.serio->dev.kobj,
+                           &elantech_attr_group);
  init_fail:
+        psmouse_reset(psmouse);
         kfree(etd);
-        return -1;
+        return error;
 }
diff --git a/drivers/input/mouse/elantech.h b/drivers/input/mouse/elantech.h
index 9e0e2a1f340d..6f3afec02f03 100644
--- a/drivers/input/mouse/elantech.h
+++ b/drivers/input/mouse/elantech.h
@@ -94,6 +94,7 @@
 #define PACKET_V4_HEAD                  0x05
 #define PACKET_V4_MOTION                0x06
 #define PACKET_V4_STATUS                0x07
+#define PACKET_TRACKPOINT               0x08
 
 /*
  * track up to 5 fingers for v4 hardware
@@ -114,6 +115,8 @@ struct finger_pos {
 };
 
 struct elantech_data {
+        struct input_dev *tp_dev;       /* Relative device for trackpoint */
+        char tp_phys[32];
         unsigned char reg_07;
         unsigned char reg_10;
         unsigned char reg_11;
diff --git a/drivers/input/mouse/psmouse-base.c b/drivers/input/mouse/psmouse-base.c
index cff065f6261c..b4e1f014ddc2 100644
--- a/drivers/input/mouse/psmouse-base.c
+++ b/drivers/input/mouse/psmouse-base.c
@@ -670,6 +670,8 @@ static void psmouse_apply_defaults(struct psmouse *psmouse)
         __set_bit(REL_X, input_dev->relbit);
         __set_bit(REL_Y, input_dev->relbit);
 
+        __set_bit(INPUT_PROP_POINTER, input_dev->propbit);
+
         psmouse->set_rate = psmouse_set_rate;
         psmouse->set_resolution = psmouse_set_resolution;
         psmouse->poll = psmouse_poll;
diff --git a/drivers/input/mouse/synaptics.c b/drivers/input/mouse/synaptics.c
index ef9e0b8a9aa7..fd23181c1fb7 100644
--- a/drivers/input/mouse/synaptics.c
+++ b/drivers/input/mouse/synaptics.c
@@ -117,6 +117,9 @@ void synaptics_reset(struct psmouse *psmouse)
 }
 
 #ifdef CONFIG_MOUSE_PS2_SYNAPTICS
+
+static bool cr48_profile_sensor;
+
 struct min_max_quirk {
         const char * const *pnp_ids;
         int x_min, x_max, y_min, y_max;
@@ -626,10 +629,61 @@ static int synaptics_parse_hw_state(const unsigned char buf[],
                          ((buf[0] & 0x04) >> 1) |
                          ((buf[3] & 0x04) >> 2));
 
+                if ((SYN_CAP_ADV_GESTURE(priv->ext_cap_0c) ||
+                        SYN_CAP_IMAGE_SENSOR(priv->ext_cap_0c)) &&
+                    hw->w == 2) {
+                        synaptics_parse_agm(buf, priv, hw);
+                        return 1;
+                }
+
+                hw->x = (((buf[3] & 0x10) << 8) |
+                         ((buf[1] & 0x0f) << 8) |
+                         buf[4]);
+                hw->y = (((buf[3] & 0x20) << 7) |
+                         ((buf[1] & 0xf0) << 4) |
+                         buf[5]);
+                hw->z = buf[2];
+
                 hw->left  = (buf[0] & 0x01) ? 1 : 0;
                 hw->right = (buf[0] & 0x02) ? 1 : 0;
 
-                if (SYN_CAP_CLICKPAD(priv->ext_cap_0c)) {
+                if (SYN_CAP_FORCEPAD(priv->ext_cap_0c)) {
+                        /*
+                         * ForcePads, like Clickpads, use middle button
+                         * bits to report primary button clicks.
+                         * Unfortunately they report primary button not
+                         * only when user presses on the pad above certain
+                         * threshold, but also when there are more than one
+                         * finger on the touchpad, which interferes with
+                         * out multi-finger gestures.
+                         */
+                        if (hw->z == 0) {
+                                /* No contacts */
+                                priv->press = priv->report_press = false;
+                        } else if (hw->w >= 4 && ((buf[0] ^ buf[3]) & 0x01)) {
+                                /*
+                                 * Single-finger touch with pressure above
+                                 * the threshold. If pressure stays long
+                                 * enough, we'll start reporting primary
+                                 * button. We rely on the device continuing
+                                 * sending data even if finger does not
+                                 * move.
+                                 */
+                                if  (!priv->press) {
+                                        priv->press_start = jiffies;
+                                        priv->press = true;
+                                } else if (time_after(jiffies,
+                                                priv->press_start +
+                                                        msecs_to_jiffies(50))) {
+                                        priv->report_press = true;
+                                }
+                        } else {
+                                priv->press = false;
+                        }
+
+                        hw->left = priv->report_press;
+
+                } else if (SYN_CAP_CLICKPAD(priv->ext_cap_0c)) {
                         /*
                          * Clickpad's button is transmitted as middle button,
                          * however, since it is primary button, we will report
@@ -648,21 +702,6 @@ static int synaptics_parse_hw_state(const unsigned char buf[],
                         hw->down = ((buf[0] ^ buf[3]) & 0x02) ? 1 : 0;
                 }
 
-                if ((SYN_CAP_ADV_GESTURE(priv->ext_cap_0c) ||
-                        SYN_CAP_IMAGE_SENSOR(priv->ext_cap_0c)) &&
-                    hw->w == 2) {
-                        synaptics_parse_agm(buf, priv, hw);
-                        return 1;
-                }
-
-                hw->x = (((buf[3] & 0x10) << 8) |
-                         ((buf[1] & 0x0f) << 8) |
-                         buf[4]);
-                hw->y = (((buf[3] & 0x20) << 7) |
-                         ((buf[1] & 0xf0) << 4) |
-                         buf[5]);
-                hw->z = buf[2];
-
                 if (SYN_CAP_MULTI_BUTTON_NO(priv->ext_cap) &&
                     ((buf[0] ^ buf[3]) & 0x02)) {
                         switch (SYN_CAP_MULTI_BUTTON_NO(priv->ext_cap) & ~0x01) {
@@ -1152,6 +1191,42 @@ static void synaptics_image_sensor_process(struct psmouse *psmouse,
         priv->agm_pending = false;
 }
 
+static void synaptics_profile_sensor_process(struct psmouse *psmouse,
+                                             struct synaptics_hw_state *sgm,
+                                             int num_fingers)
+{
+        struct input_dev *dev = psmouse->dev;
+        struct synaptics_data *priv = psmouse->private;
+        struct synaptics_hw_state *hw[2] = { sgm, &priv->agm };
+        struct input_mt_pos pos[2];
+        int slot[2], nsemi, i;
+
+        nsemi = clamp_val(num_fingers, 0, 2);
+
+        for (i = 0; i < nsemi; i++) {
+                pos[i].x = hw[i]->x;
+                pos[i].y = synaptics_invert_y(hw[i]->y);
+        }
+
+        input_mt_assign_slots(dev, slot, pos, nsemi);
+
+        for (i = 0; i < nsemi; i++) {
+                input_mt_slot(dev, slot[i]);
+                input_mt_report_slot_state(dev, MT_TOOL_FINGER, true);
+                input_report_abs(dev, ABS_MT_POSITION_X, pos[i].x);
+                input_report_abs(dev, ABS_MT_POSITION_Y, pos[i].y);
+                input_report_abs(dev, ABS_MT_PRESSURE, hw[i]->z);
+        }
+
+        input_mt_drop_unused(dev);
+        input_mt_report_pointer_emulation(dev, false);
+        input_mt_report_finger_count(dev, num_fingers);
+
+        synaptics_report_buttons(psmouse, sgm);
+
+        input_sync(dev);
+}
+
 /*
  *  called for each full received packet from the touchpad
  */
@@ -1215,6 +1290,11 @@ static void synaptics_process_packet(struct psmouse *psmouse)
                 finger_width = 0;
         }
 
+        if (cr48_profile_sensor) {
+                synaptics_profile_sensor_process(psmouse, &hw, num_fingers);
+                return;
+        }
+
         if (SYN_CAP_ADV_GESTURE(priv->ext_cap_0c))
                 synaptics_report_semi_mt_data(dev, &hw, &priv->agm,
                                               num_fingers);
@@ -1360,6 +1440,9 @@ static void set_input_params(struct psmouse *psmouse,
         set_abs_position_params(dev, priv, ABS_X, ABS_Y);
         input_set_abs_params(dev, ABS_PRESSURE, 0, 255, 0, 0);
 
+        if (cr48_profile_sensor)
+                input_set_abs_params(dev, ABS_MT_PRESSURE, 0, 255, 0, 0);
+
         if (SYN_CAP_IMAGE_SENSOR(priv->ext_cap_0c)) {
                 set_abs_position_params(dev, priv, ABS_MT_POSITION_X,
                                         ABS_MT_POSITION_Y);
@@ -1371,11 +1454,16 @@ static void set_input_params(struct psmouse *psmouse,
                 __set_bit(BTN_TOOL_QUADTAP, dev->keybit);
                 __set_bit(BTN_TOOL_QUINTTAP, dev->keybit);
         } else if (SYN_CAP_ADV_GESTURE(priv->ext_cap_0c)) {
-                /* Non-image sensors with AGM use semi-mt */
-                __set_bit(INPUT_PROP_SEMI_MT, dev->propbit);
-                input_mt_init_slots(dev, 2, 0);
                 set_abs_position_params(dev, priv, ABS_MT_POSITION_X,
                                         ABS_MT_POSITION_Y);
+                /*
+                 * Profile sensor in CR-48 tracks contacts reasonably well,
+                 * other non-image sensors with AGM use semi-mt.
+                 */
+                input_mt_init_slots(dev, 2,
+                                    INPUT_MT_POINTER |
+                                    (cr48_profile_sensor ?
+                                        INPUT_MT_TRACK : INPUT_MT_SEMI_MT));
         }
 
         if (SYN_CAP_PALMDETECT(priv->capabilities))
@@ -1577,10 +1665,24 @@ static const struct dmi_system_id olpc_dmi_table[] __initconst = {
         { }
 };
 
+static const struct dmi_system_id __initconst cr48_dmi_table[] = {
+#if defined(CONFIG_DMI) && defined(CONFIG_X86)
+        {
+                /* Cr-48 Chromebook (Codename Mario) */
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "IEC"),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "Mario"),
+                },
+        },
+#endif
+        { }
+};
+
 void __init synaptics_module_init(void)
 {
         impaired_toshiba_kbc = dmi_check_system(toshiba_dmi_table);
         broken_olpc_ec = dmi_check_system(olpc_dmi_table);
+        cr48_profile_sensor = dmi_check_system(cr48_dmi_table);
 }
 
 static int __synaptics_init(struct psmouse *psmouse, bool absolute_mode)
diff --git a/drivers/input/mouse/synaptics.h b/drivers/input/mouse/synaptics.h
index e594af0b264b..fb2e076738ae 100644
--- a/drivers/input/mouse/synaptics.h
+++ b/drivers/input/mouse/synaptics.h
@@ -78,6 +78,11 @@
  * 2    0x08    image sensor            image sensor tracks 5 fingers, but only
  *                                      reports 2.
  * 2    0x20    report min              query 0x0f gives min coord reported
+ * 2    0x80    forcepad                forcepad is a variant of clickpad that
+ *                                      does not have physical buttons but rather
+ *                                      uses pressure above certain threshold to
+ *                                      report primary clicks. Forcepads also have
+ *                                      clickpad bit set.
  */
 #define SYN_CAP_CLICKPAD(ex0c)          ((ex0c) & 0x100000) /* 1-button ClickPad */
 #define SYN_CAP_CLICKPAD2BTN(ex0c)      ((ex0c) & 0x000100) /* 2-button ClickPad */
@@ -86,6 +91,7 @@
 #define SYN_CAP_ADV_GESTURE(ex0c)       ((ex0c) & 0x080000)
 #define SYN_CAP_REDUCED_FILTERING(ex0c) ((ex0c) & 0x000400)
 #define SYN_CAP_IMAGE_SENSOR(ex0c)      ((ex0c) & 0x000800)
+#define SYN_CAP_FORCEPAD(ex0c)          ((ex0c) & 0x008000)
 
 /* synaptics modes query bits */
 #define SYN_MODE_ABSOLUTE(m)            ((m) & (1 << 7))
@@ -177,6 +183,11 @@ struct synaptics_data {
          */
         struct synaptics_hw_state agm;
         bool agm_pending;                       /* new AGM packet received */
+
+        /* ForcePad handling */
+        unsigned long                           press_start;
+        bool                                    press;
+        bool                                    report_press;
 };
 
 void synaptics_module_init(void);
diff --git a/drivers/input/mouse/synaptics_usb.c b/drivers/input/mouse/synaptics_usb.c
index e122bda16aab..6bcc0189c1c9 100644
--- a/drivers/input/mouse/synaptics_usb.c
+++ b/drivers/input/mouse/synaptics_usb.c
@@ -387,6 +387,7 @@ static int synusb_probe(struct usb_interface *intf,
                 __set_bit(EV_REL, input_dev->evbit);
                 __set_bit(REL_X, input_dev->relbit);
                 __set_bit(REL_Y, input_dev->relbit);
+                __set_bit(INPUT_PROP_POINTING_STICK, input_dev->propbit);
                 input_set_abs_params(input_dev, ABS_PRESSURE, 0, 127, 0, 0);
         } else {
                 input_set_abs_params(input_dev, ABS_X,
@@ -401,6 +402,11 @@ static int synusb_probe(struct usb_interface *intf,
                 __set_bit(BTN_TOOL_TRIPLETAP, input_dev->keybit);
         }
 
+        if (synusb->flags & SYNUSB_TOUCHSCREEN)
+                __set_bit(INPUT_PROP_DIRECT, input_dev->propbit);
+        else
+                __set_bit(INPUT_PROP_POINTER, input_dev->propbit);
+
         __set_bit(BTN_LEFT, input_dev->keybit);
         __set_bit(BTN_RIGHT, input_dev->keybit);
         __set_bit(BTN_MIDDLE, input_dev->keybit);
diff --git a/drivers/input/mouse/trackpoint.c b/drivers/input/mouse/trackpoint.c
index ca843b6cf6bd..30c8b6998808 100644
--- a/drivers/input/mouse/trackpoint.c
+++ b/drivers/input/mouse/trackpoint.c
@@ -393,6 +393,9 @@ int trackpoint_detect(struct psmouse *psmouse, bool set_properties)
         if ((button_info & 0x0f) >= 3)
                 __set_bit(BTN_MIDDLE, psmouse->dev->keybit);
 
+        __set_bit(INPUT_PROP_POINTER, psmouse->dev->propbit);
+        __set_bit(INPUT_PROP_POINTING_STICK, psmouse->dev->propbit);
+
         trackpoint_defaults(psmouse->private);
 
         error = trackpoint_power_on_reset(&psmouse->ps2dev);